init

node_modules/@microsoft/api-extractor-model/lib/model/ApiCallSignature.d.ts

@@ -0,0 +1,55 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { type IApiDeclaredItemOptions, ApiDeclaredItem } from '../items/ApiDeclaredItem';
+import { type IApiParameterListMixinOptions, ApiParameterListMixin } from '../mixins/ApiParameterListMixin';
+import { type IApiReleaseTagMixinOptions, ApiReleaseTagMixin } from '../mixins/ApiReleaseTagMixin';
+import { type IApiReturnTypeMixinOptions, ApiReturnTypeMixin } from '../mixins/ApiReturnTypeMixin';
+import { type IApiTypeParameterListMixinOptions, ApiTypeParameterListMixin } from '../mixins/ApiTypeParameterListMixin';
+/**
+ * Constructor options for {@link ApiCallSignature}.
+ * @public
+ */
+export interface IApiCallSignatureOptions extends IApiTypeParameterListMixinOptions, IApiParameterListMixinOptions, IApiReleaseTagMixinOptions, IApiReturnTypeMixinOptions, IApiDeclaredItemOptions {
+}
+declare const ApiCallSignature_base: typeof ApiDeclaredItem & (new (...args: any[]) => ApiReturnTypeMixin) & (new (...args: any[]) => ApiReleaseTagMixin) & (new (...args: any[]) => ApiParameterListMixin) & (new (...args: any[]) => ApiTypeParameterListMixin);
+/**
+ * Represents a TypeScript function call signature.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiCallSignature` represents a TypeScript declaration such as `(x: number, y: number): number`
+ * in this example:
+ *
+ * ```ts
+ * export interface IChooser {
+ *   // A call signature:
+ *   (x: number, y: number): number;
+ *
+ *   // Another overload for this call signature:
+ *   (x: string, y: string): string;
+ * }
+ *
+ * function chooseFirst<T>(x: T, y: T): T {
+ *   return x;
+ * }
+ *
+ * let chooser: IChooser = chooseFirst;
+ * ```
+ *
+ * @public
+ */
+export declare class ApiCallSignature extends ApiCallSignature_base {
+    constructor(options: IApiCallSignatureOptions);
+    static getContainerKey(overloadIndex: number): string;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiCallSignature.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiCallSignature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiCallSignature.d.ts","sourceRoot":"","sources":["../../src/model/ApiCallSignature.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAGrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,KAAK,uBAAuB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACzF,OAAO,EAAE,KAAK,6BAA6B,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC5G,OAAO,EAAE,KAAK,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,KAAK,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EACL,KAAK,iCAAiC,EACtC,yBAAyB,EAC1B,MAAM,qCAAqC,CAAC;AAE7C;;;GAGG;AACH,MAAM,WAAW,wBACf,SAAQ,iCAAiC,EACvC,6BAA6B,EAC7B,0BAA0B,EAC1B,0BAA0B,EAC1B,uBAAuB;CAAG;;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,gBAAiB,SAAQ,qBAErC;gBACoB,OAAO,EAAE,wBAAwB;WAItC,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM;IAI5D,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAOvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiCallSignature.js

@@ -0,0 +1,67 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiCallSignature = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiDeclaredItem_1 = require("../items/ApiDeclaredItem");
+const ApiParameterListMixin_1 = require("../mixins/ApiParameterListMixin");
+const ApiReleaseTagMixin_1 = require("../mixins/ApiReleaseTagMixin");
+const ApiReturnTypeMixin_1 = require("../mixins/ApiReturnTypeMixin");
+const ApiTypeParameterListMixin_1 = require("../mixins/ApiTypeParameterListMixin");
+/**
+ * Represents a TypeScript function call signature.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiCallSignature` represents a TypeScript declaration such as `(x: number, y: number): number`
+ * in this example:
+ *
+ * ```ts
+ * export interface IChooser {
+ *   // A call signature:
+ *   (x: number, y: number): number;
+ *
+ *   // Another overload for this call signature:
+ *   (x: string, y: string): string;
+ * }
+ *
+ * function chooseFirst<T>(x: T, y: T): T {
+ *   return x;
+ * }
+ *
+ * let chooser: IChooser = chooseFirst;
+ * ```
+ *
+ * @public
+ */
+class ApiCallSignature extends (0, ApiTypeParameterListMixin_1.ApiTypeParameterListMixin)((0, ApiParameterListMixin_1.ApiParameterListMixin)((0, ApiReleaseTagMixin_1.ApiReleaseTagMixin)((0, ApiReturnTypeMixin_1.ApiReturnTypeMixin)(ApiDeclaredItem_1.ApiDeclaredItem)))) {
+    constructor(options) {
+        super(options);
+    }
+    static getContainerKey(overloadIndex) {
+        return `|${ApiItem_1.ApiItemKind.CallSignature}|${overloadIndex}`;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.CallSignature;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiCallSignature.getContainerKey(this.overloadIndex);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const parent = this.parent
+            ? this.parent.canonicalReference
+            : // .withMeaning() requires some kind of component
+                DeclarationReference_1.DeclarationReference.empty().addNavigationStep("#" /* Navigation.Members */, '(parent)');
+        return parent.withMeaning("call" /* Meaning.CallSignature */).withOverloadIndex(this.overloadIndex);
+    }
+}
+exports.ApiCallSignature = ApiCallSignature;
+//# sourceMappingURL=ApiCallSignature.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiCallSignature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiCallSignature.js","sourceRoot":"","sources":["../../src/model/ApiCallSignature.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,kGAIiE;AACjE,8CAA+C;AAC/C,8DAAyF;AACzF,2EAA4G;AAC5G,qEAAmG;AACnG,qEAAmG;AACnG,mFAG6C;AAa7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAa,gBAAiB,SAAQ,IAAA,qDAAyB,EAC7D,IAAA,6CAAqB,EAAC,IAAA,uCAAkB,EAAC,IAAA,uCAAkB,EAAC,iCAAe,CAAC,CAAC,CAAC,CAC/E;IACC,YAAmB,OAAiC;QAClD,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,MAAM,CAAC,eAAe,CAAC,aAAqB;QACjD,OAAO,IAAI,qBAAW,CAAC,aAAa,IAAI,aAAa,EAAE,CAAC;IAC1D,CAAC;IAED,gBAAgB;IAChB,IAAW,IAAI;QACb,OAAO,qBAAW,CAAC,aAAa,CAAC;IACnC,CAAC;IAED,gBAAgB;IAChB,IAAW,YAAY;QACrB,OAAO,gBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC9D,CAAC;IAED,sBAAsB;IACf,uBAAuB;QAC5B,MAAM,MAAM,GAAyB,IAAI,CAAC,MAAM;YAC9C,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB;YAChC,CAAC,CAAC,iDAAiD;gBACjD,2CAAoB,CAAC,KAAK,EAAE,CAAC,iBAAiB,+BAAqB,UAAU,CAAC,CAAC;QACnF,OAAO,MAAM,CAAC,WAAW,oCAAuB,CAAC,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACzF,CAAC;CACF;AA7BD,4CA6BC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport {\n  DeclarationReference,\n  Meaning,\n  Navigation\n} from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';\nimport { ApiItemKind } from '../items/ApiItem';\nimport { type IApiDeclaredItemOptions, ApiDeclaredItem } from '../items/ApiDeclaredItem';\nimport { type IApiParameterListMixinOptions, ApiParameterListMixin } from '../mixins/ApiParameterListMixin';\nimport { type IApiReleaseTagMixinOptions, ApiReleaseTagMixin } from '../mixins/ApiReleaseTagMixin';\nimport { type IApiReturnTypeMixinOptions, ApiReturnTypeMixin } from '../mixins/ApiReturnTypeMixin';\nimport {\n  type IApiTypeParameterListMixinOptions,\n  ApiTypeParameterListMixin\n} from '../mixins/ApiTypeParameterListMixin';\n\n/**\n * Constructor options for {@link ApiCallSignature}.\n * @public\n */\nexport interface IApiCallSignatureOptions\n  extends IApiTypeParameterListMixinOptions,\n    IApiParameterListMixinOptions,\n    IApiReleaseTagMixinOptions,\n    IApiReturnTypeMixinOptions,\n    IApiDeclaredItemOptions {}\n\n/**\n * Represents a TypeScript function call signature.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.\n *\n * `ApiCallSignature` represents a TypeScript declaration such as `(x: number, y: number): number`\n * in this example:\n *\n * ```ts\n * export interface IChooser {\n *   // A call signature:\n *   (x: number, y: number): number;\n *\n *   // Another overload for this call signature:\n *   (x: string, y: string): string;\n * }\n *\n * function chooseFirst<T>(x: T, y: T): T {\n *   return x;\n * }\n *\n * let chooser: IChooser = chooseFirst;\n * ```\n *\n * @public\n */\nexport class ApiCallSignature extends ApiTypeParameterListMixin(\n  ApiParameterListMixin(ApiReleaseTagMixin(ApiReturnTypeMixin(ApiDeclaredItem)))\n) {\n  public constructor(options: IApiCallSignatureOptions) {\n    super(options);\n  }\n\n  public static getContainerKey(overloadIndex: number): string {\n    return `|${ApiItemKind.CallSignature}|${overloadIndex}`;\n  }\n\n  /** @override */\n  public get kind(): ApiItemKind {\n    return ApiItemKind.CallSignature;\n  }\n\n  /** @override */\n  public get containerKey(): string {\n    return ApiCallSignature.getContainerKey(this.overloadIndex);\n  }\n\n  /** @beta @override */\n  public buildCanonicalReference(): DeclarationReference {\n    const parent: DeclarationReference = this.parent\n      ? this.parent.canonicalReference\n      : // .withMeaning() requires some kind of component\n        DeclarationReference.empty().addNavigationStep(Navigation.Members, '(parent)');\n    return parent.withMeaning(Meaning.CallSignature).withOverloadIndex(this.overloadIndex);\n  }\n}\n"]}

node_modules/@microsoft/api-extractor-model/lib/model/ApiClass.d.ts

@@ -0,0 +1,66 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { ApiDeclaredItem, type IApiDeclaredItemOptions, type IApiDeclaredItemJson } from '../items/ApiDeclaredItem';
+import { ApiItemContainerMixin, type IApiItemContainerMixinOptions } from '../mixins/ApiItemContainerMixin';
+import { ApiReleaseTagMixin, type IApiReleaseTagMixinOptions } from '../mixins/ApiReleaseTagMixin';
+import type { IExcerptTokenRange } from '../mixins/Excerpt';
+import { HeritageType } from './HeritageType';
+import { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';
+import { ApiTypeParameterListMixin, type IApiTypeParameterListMixinOptions, type IApiTypeParameterListMixinJson } from '../mixins/ApiTypeParameterListMixin';
+import type { DeserializerContext } from './DeserializerContext';
+import { type IApiExportedMixinJson, type IApiExportedMixinOptions, ApiExportedMixin } from '../mixins/ApiExportedMixin';
+import { ApiAbstractMixin, type IApiAbstractMixinJson, type IApiAbstractMixinOptions } from '../mixins/ApiAbstractMixin';
+/**
+ * Constructor options for {@link ApiClass}.
+ * @public
+ */
+export interface IApiClassOptions extends IApiItemContainerMixinOptions, IApiNameMixinOptions, IApiAbstractMixinOptions, IApiReleaseTagMixinOptions, IApiDeclaredItemOptions, IApiTypeParameterListMixinOptions, IApiExportedMixinOptions {
+    extendsTokenRange: IExcerptTokenRange | undefined;
+    implementsTokenRanges: IExcerptTokenRange[];
+}
+export interface IApiClassJson extends IApiDeclaredItemJson, IApiAbstractMixinJson, IApiTypeParameterListMixinJson, IApiExportedMixinJson {
+    extendsTokenRange?: IExcerptTokenRange;
+    implementsTokenRanges: IExcerptTokenRange[];
+}
+declare const ApiClass_base: typeof ApiDeclaredItem & (new (...args: any[]) => ApiExportedMixin) & (new (...args: any[]) => ApiReleaseTagMixin) & (new (...args: any[]) => ApiTypeParameterListMixin) & (new (...args: any[]) => ApiAbstractMixin) & (new (...args: any[]) => ApiNameMixin) & (new (...args: any[]) => ApiItemContainerMixin);
+/**
+ * Represents a TypeScript class declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiClass` represents a TypeScript declaration such as this:
+ *
+ * ```ts
+ * export class X { }
+ * ```
+ *
+ * @public
+ */
+export declare class ApiClass extends ApiClass_base {
+    /**
+     * The base class that this class inherits from (using the `extends` keyword), or undefined if there is no base class.
+     */
+    readonly extendsType: HeritageType | undefined;
+    private readonly _implementsTypes;
+    constructor(options: IApiClassOptions);
+    static getContainerKey(name: string): string;
+    /** @override */
+    static onDeserializeInto(options: Partial<IApiClassOptions>, context: DeserializerContext, jsonObject: IApiClassJson): void;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /**
+     * The list of interfaces that this class implements using the `implements` keyword.
+     */
+    get implementsTypes(): ReadonlyArray<HeritageType>;
+    /** @override */
+    serializeInto(jsonObject: Partial<IApiClassJson>): void;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiClass.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiClass.d.ts","sourceRoot":"","sources":["../../src/model/ApiClass.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAIrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EACL,eAAe,EACf,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EAC1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,qBAAqB,EAAE,KAAK,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAC5G,OAAO,EAAE,kBAAkB,EAAE,KAAK,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,KAAK,oBAAoB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EACL,yBAAyB,EACzB,KAAK,iCAAiC,EACtC,KAAK,8BAA8B,EACpC,MAAM,qCAAqC,CAAC;AAC7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,gBAAgB,EACjB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,gBAAgB,EAChB,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC9B,MAAM,4BAA4B,CAAC;AAEpC;;;GAGG;AACH,MAAM,WAAW,gBACf,SAAQ,6BAA6B,EACnC,oBAAoB,EACpB,wBAAwB,EACxB,0BAA0B,EAC1B,uBAAuB,EACvB,iCAAiC,EACjC,wBAAwB;IAC1B,iBAAiB,EAAE,kBAAkB,GAAG,SAAS,CAAC;IAClD,qBAAqB,EAAE,kBAAkB,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,aACf,SAAQ,oBAAoB,EAC1B,qBAAqB,EACrB,8BAA8B,EAC9B,qBAAqB;IACvB,iBAAiB,CAAC,EAAE,kBAAkB,CAAC;IACvC,qBAAqB,EAAE,kBAAkB,EAAE,CAAC;CAC7C;;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,QAAS,SAAQ,aAI7B;IACC;;OAEG;IACH,SAAgB,WAAW,EAAE,YAAY,GAAG,SAAS,CAAC;IAEtD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsB;gBAEpC,OAAO,EAAE,gBAAgB;WAc9B,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAInD,gBAAgB;WACF,iBAAiB,CAC7B,OAAO,EAAE,OAAO,CAAC,gBAAgB,CAAC,EAClC,OAAO,EAAE,mBAAmB,EAC5B,UAAU,EAAE,aAAa,GACxB,IAAI;IAOP,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED;;OAEG;IACH,IAAW,eAAe,IAAI,aAAa,CAAC,YAAY,CAAC,CAExD;IAED,gBAAgB;IACT,aAAa,CAAC,UAAU,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI;IAW9D,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAOvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiClass.js

@@ -0,0 +1,88 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClass = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiDeclaredItem_1 = require("../items/ApiDeclaredItem");
+const ApiItemContainerMixin_1 = require("../mixins/ApiItemContainerMixin");
+const ApiReleaseTagMixin_1 = require("../mixins/ApiReleaseTagMixin");
+const HeritageType_1 = require("./HeritageType");
+const ApiNameMixin_1 = require("../mixins/ApiNameMixin");
+const ApiTypeParameterListMixin_1 = require("../mixins/ApiTypeParameterListMixin");
+const ApiExportedMixin_1 = require("../mixins/ApiExportedMixin");
+const ApiAbstractMixin_1 = require("../mixins/ApiAbstractMixin");
+/**
+ * Represents a TypeScript class declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiClass` represents a TypeScript declaration such as this:
+ *
+ * ```ts
+ * export class X { }
+ * ```
+ *
+ * @public
+ */
+class ApiClass extends (0, ApiItemContainerMixin_1.ApiItemContainerMixin)((0, ApiNameMixin_1.ApiNameMixin)((0, ApiAbstractMixin_1.ApiAbstractMixin)((0, ApiTypeParameterListMixin_1.ApiTypeParameterListMixin)((0, ApiReleaseTagMixin_1.ApiReleaseTagMixin)((0, ApiExportedMixin_1.ApiExportedMixin)(ApiDeclaredItem_1.ApiDeclaredItem)))))) {
+    constructor(options) {
+        super(options);
+        this._implementsTypes = [];
+        if (options.extendsTokenRange) {
+            this.extendsType = new HeritageType_1.HeritageType(this.buildExcerpt(options.extendsTokenRange));
+        }
+        else {
+            this.extendsType = undefined;
+        }
+        for (const implementsTokenRange of options.implementsTokenRanges) {
+            this._implementsTypes.push(new HeritageType_1.HeritageType(this.buildExcerpt(implementsTokenRange)));
+        }
+    }
+    static getContainerKey(name) {
+        return `${name}|${ApiItem_1.ApiItemKind.Class}`;
+    }
+    /** @override */
+    static onDeserializeInto(options, context, jsonObject) {
+        super.onDeserializeInto(options, context, jsonObject);
+        options.extendsTokenRange = jsonObject.extendsTokenRange;
+        options.implementsTokenRanges = jsonObject.implementsTokenRanges;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.Class;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiClass.getContainerKey(this.name);
+    }
+    /**
+     * The list of interfaces that this class implements using the `implements` keyword.
+     */
+    get implementsTypes() {
+        return this._implementsTypes;
+    }
+    /** @override */
+    serializeInto(jsonObject) {
+        super.serializeInto(jsonObject);
+        // Note that JSON does not support the "undefined" value, so we simply omit the field entirely if it is undefined
+        if (this.extendsType) {
+            jsonObject.extendsTokenRange = this.extendsType.excerpt.tokenRange;
+        }
+        jsonObject.implementsTokenRanges = this.implementsTypes.map((x) => x.excerpt.tokenRange);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const nameComponent = DeclarationReference_1.DeclarationReference.parseComponent(this.name);
+        const navigation = this.isExported ? "." /* Navigation.Exports */ : "~" /* Navigation.Locals */;
+        return (this.parent ? this.parent.canonicalReference : DeclarationReference_1.DeclarationReference.empty())
+            .addNavigationStep(navigation, nameComponent)
+            .withMeaning("class" /* Meaning.Class */);
+    }
+}
+exports.ApiClass = ApiClass;
+//# sourceMappingURL=ApiClass.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiConstructSignature.d.ts

@@ -0,0 +1,68 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { type IApiDeclaredItemOptions, ApiDeclaredItem } from '../items/ApiDeclaredItem';
+import { type IApiParameterListMixinOptions, ApiParameterListMixin } from '../mixins/ApiParameterListMixin';
+import { type IApiReleaseTagMixinOptions, ApiReleaseTagMixin } from '../mixins/ApiReleaseTagMixin';
+import { type IApiReturnTypeMixinOptions, ApiReturnTypeMixin } from '../mixins/ApiReturnTypeMixin';
+import { ApiTypeParameterListMixin, type IApiTypeParameterListMixinOptions } from '../mixins/ApiTypeParameterListMixin';
+/**
+ * Constructor options for {@link ApiConstructor}.
+ * @public
+ */
+export interface IApiConstructSignatureOptions extends IApiTypeParameterListMixinOptions, IApiParameterListMixinOptions, IApiReleaseTagMixinOptions, IApiReturnTypeMixinOptions, IApiDeclaredItemOptions {
+}
+declare const ApiConstructSignature_base: typeof ApiDeclaredItem & (new (...args: any[]) => ApiReturnTypeMixin) & (new (...args: any[]) => ApiReleaseTagMixin) & (new (...args: any[]) => ApiParameterListMixin) & (new (...args: any[]) => ApiTypeParameterListMixin);
+/**
+ * Represents a TypeScript construct signature that belongs to an `ApiInterface`.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiConstructSignature` represents a construct signature using the `new` keyword such as in this example:
+ *
+ * ```ts
+ * export interface IVector {
+ *   x: number;
+ *   y: number;
+ * }
+ *
+ * export interface IVectorConstructor {
+ *   // A construct signature:
+ *   new(x: number, y: number): IVector;
+ * }
+ *
+ * export function createVector(vectorConstructor: IVectorConstructor,
+ *   x: number, y: number): IVector {
+ *   return new vectorConstructor(x, y);
+ * }
+ *
+ * class Vector implements IVector {
+ *   public x: number;
+ *   public y: number;
+ *   public constructor(x: number, y: number) {
+ *     this.x = x;
+ *     this.y = y;
+ *   }
+ * }
+ *
+ * let vector: Vector = createVector(Vector, 1, 2);
+ * ```
+ *
+ * Compare with {@link ApiConstructor}, which describes the class constructor itself.
+ *
+ * @public
+ */
+export declare class ApiConstructSignature extends ApiConstructSignature_base {
+    constructor(options: IApiConstructSignatureOptions);
+    static getContainerKey(overloadIndex: number): string;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiConstructSignature.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiConstructSignature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiConstructSignature.d.ts","sourceRoot":"","sources":["../../src/model/ApiConstructSignature.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAGrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,KAAK,uBAAuB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACzF,OAAO,EAAE,KAAK,6BAA6B,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC5G,OAAO,EAAE,KAAK,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,KAAK,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EACL,yBAAyB,EACzB,KAAK,iCAAiC,EACvC,MAAM,qCAAqC,CAAC;AAE7C;;;GAGG;AACH,MAAM,WAAW,6BACf,SAAQ,iCAAiC,EACvC,6BAA6B,EAC7B,0BAA0B,EAC1B,0BAA0B,EAC1B,uBAAuB;CAAG;;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBAAa,qBAAsB,SAAQ,0BAE1C;gBACoB,OAAO,EAAE,6BAA6B;WAI3C,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM;IAI5D,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAOvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiConstructSignature.js

@@ -0,0 +1,80 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiConstructSignature = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiDeclaredItem_1 = require("../items/ApiDeclaredItem");
+const ApiParameterListMixin_1 = require("../mixins/ApiParameterListMixin");
+const ApiReleaseTagMixin_1 = require("../mixins/ApiReleaseTagMixin");
+const ApiReturnTypeMixin_1 = require("../mixins/ApiReturnTypeMixin");
+const ApiTypeParameterListMixin_1 = require("../mixins/ApiTypeParameterListMixin");
+/**
+ * Represents a TypeScript construct signature that belongs to an `ApiInterface`.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiConstructSignature` represents a construct signature using the `new` keyword such as in this example:
+ *
+ * ```ts
+ * export interface IVector {
+ *   x: number;
+ *   y: number;
+ * }
+ *
+ * export interface IVectorConstructor {
+ *   // A construct signature:
+ *   new(x: number, y: number): IVector;
+ * }
+ *
+ * export function createVector(vectorConstructor: IVectorConstructor,
+ *   x: number, y: number): IVector {
+ *   return new vectorConstructor(x, y);
+ * }
+ *
+ * class Vector implements IVector {
+ *   public x: number;
+ *   public y: number;
+ *   public constructor(x: number, y: number) {
+ *     this.x = x;
+ *     this.y = y;
+ *   }
+ * }
+ *
+ * let vector: Vector = createVector(Vector, 1, 2);
+ * ```
+ *
+ * Compare with {@link ApiConstructor}, which describes the class constructor itself.
+ *
+ * @public
+ */
+class ApiConstructSignature extends (0, ApiTypeParameterListMixin_1.ApiTypeParameterListMixin)((0, ApiParameterListMixin_1.ApiParameterListMixin)((0, ApiReleaseTagMixin_1.ApiReleaseTagMixin)((0, ApiReturnTypeMixin_1.ApiReturnTypeMixin)(ApiDeclaredItem_1.ApiDeclaredItem)))) {
+    constructor(options) {
+        super(options);
+    }
+    static getContainerKey(overloadIndex) {
+        return `|${ApiItem_1.ApiItemKind.ConstructSignature}|${overloadIndex}`;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.ConstructSignature;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiConstructSignature.getContainerKey(this.overloadIndex);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const parent = this.parent
+            ? this.parent.canonicalReference
+            : // .withMeaning() requires some kind of component
+                DeclarationReference_1.DeclarationReference.empty().addNavigationStep("#" /* Navigation.Members */, '(parent)');
+        return parent.withMeaning("new" /* Meaning.ConstructSignature */).withOverloadIndex(this.overloadIndex);
+    }
+}
+exports.ApiConstructSignature = ApiConstructSignature;
+//# sourceMappingURL=ApiConstructSignature.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiConstructSignature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiConstructSignature.js","sourceRoot":"","sources":["../../src/model/ApiConstructSignature.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,kGAIiE;AACjE,8CAA+C;AAC/C,8DAAyF;AACzF,2EAA4G;AAC5G,qEAAmG;AACnG,qEAAmG;AACnG,mFAG6C;AAa7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAa,qBAAsB,SAAQ,IAAA,qDAAyB,EAClE,IAAA,6CAAqB,EAAC,IAAA,uCAAkB,EAAC,IAAA,uCAAkB,EAAC,iCAAe,CAAC,CAAC,CAAC,CAC/E;IACC,YAAmB,OAAsC;QACvD,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,MAAM,CAAC,eAAe,CAAC,aAAqB;QACjD,OAAO,IAAI,qBAAW,CAAC,kBAAkB,IAAI,aAAa,EAAE,CAAC;IAC/D,CAAC;IAED,gBAAgB;IAChB,IAAW,IAAI;QACb,OAAO,qBAAW,CAAC,kBAAkB,CAAC;IACxC,CAAC;IAED,gBAAgB;IAChB,IAAW,YAAY;QACrB,OAAO,qBAAqB,CAAC,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACnE,CAAC;IAED,sBAAsB;IACf,uBAAuB;QAC5B,MAAM,MAAM,GAAyB,IAAI,CAAC,MAAM;YAC9C,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB;YAChC,CAAC,CAAC,iDAAiD;gBACjD,2CAAoB,CAAC,KAAK,EAAE,CAAC,iBAAiB,+BAAqB,UAAU,CAAC,CAAC;QACnF,OAAO,MAAM,CAAC,WAAW,wCAA4B,CAAC,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC9F,CAAC;CACF;AA7BD,sDA6BC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport {\n  DeclarationReference,\n  Meaning,\n  Navigation\n} from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';\nimport { ApiItemKind } from '../items/ApiItem';\nimport { type IApiDeclaredItemOptions, ApiDeclaredItem } from '../items/ApiDeclaredItem';\nimport { type IApiParameterListMixinOptions, ApiParameterListMixin } from '../mixins/ApiParameterListMixin';\nimport { type IApiReleaseTagMixinOptions, ApiReleaseTagMixin } from '../mixins/ApiReleaseTagMixin';\nimport { type IApiReturnTypeMixinOptions, ApiReturnTypeMixin } from '../mixins/ApiReturnTypeMixin';\nimport {\n  ApiTypeParameterListMixin,\n  type IApiTypeParameterListMixinOptions\n} from '../mixins/ApiTypeParameterListMixin';\n\n/**\n * Constructor options for {@link ApiConstructor}.\n * @public\n */\nexport interface IApiConstructSignatureOptions\n  extends IApiTypeParameterListMixinOptions,\n    IApiParameterListMixinOptions,\n    IApiReleaseTagMixinOptions,\n    IApiReturnTypeMixinOptions,\n    IApiDeclaredItemOptions {}\n\n/**\n * Represents a TypeScript construct signature that belongs to an `ApiInterface`.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.\n *\n * `ApiConstructSignature` represents a construct signature using the `new` keyword such as in this example:\n *\n * ```ts\n * export interface IVector {\n *   x: number;\n *   y: number;\n * }\n *\n * export interface IVectorConstructor {\n *   // A construct signature:\n *   new(x: number, y: number): IVector;\n * }\n *\n * export function createVector(vectorConstructor: IVectorConstructor,\n *   x: number, y: number): IVector {\n *   return new vectorConstructor(x, y);\n * }\n *\n * class Vector implements IVector {\n *   public x: number;\n *   public y: number;\n *   public constructor(x: number, y: number) {\n *     this.x = x;\n *     this.y = y;\n *   }\n * }\n *\n * let vector: Vector = createVector(Vector, 1, 2);\n * ```\n *\n * Compare with {@link ApiConstructor}, which describes the class constructor itself.\n *\n * @public\n */\nexport class ApiConstructSignature extends ApiTypeParameterListMixin(\n  ApiParameterListMixin(ApiReleaseTagMixin(ApiReturnTypeMixin(ApiDeclaredItem)))\n) {\n  public constructor(options: IApiConstructSignatureOptions) {\n    super(options);\n  }\n\n  public static getContainerKey(overloadIndex: number): string {\n    return `|${ApiItemKind.ConstructSignature}|${overloadIndex}`;\n  }\n\n  /** @override */\n  public get kind(): ApiItemKind {\n    return ApiItemKind.ConstructSignature;\n  }\n\n  /** @override */\n  public get containerKey(): string {\n    return ApiConstructSignature.getContainerKey(this.overloadIndex);\n  }\n\n  /** @beta @override */\n  public buildCanonicalReference(): DeclarationReference {\n    const parent: DeclarationReference = this.parent\n      ? this.parent.canonicalReference\n      : // .withMeaning() requires some kind of component\n        DeclarationReference.empty().addNavigationStep(Navigation.Members, '(parent)');\n    return parent.withMeaning(Meaning.ConstructSignature).withOverloadIndex(this.overloadIndex);\n  }\n}\n"]}

node_modules/@microsoft/api-extractor-model/lib/model/ApiConstructor.d.ts

@@ -0,0 +1,52 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { type IApiDeclaredItemOptions, ApiDeclaredItem } from '../items/ApiDeclaredItem';
+import { type IApiParameterListMixinOptions, ApiParameterListMixin } from '../mixins/ApiParameterListMixin';
+import { ApiProtectedMixin, type IApiProtectedMixinOptions } from '../mixins/ApiProtectedMixin';
+import { type IApiReleaseTagMixinOptions, ApiReleaseTagMixin } from '../mixins/ApiReleaseTagMixin';
+/**
+ * Constructor options for {@link ApiConstructor}.
+ * @public
+ */
+export interface IApiConstructorOptions extends IApiParameterListMixinOptions, IApiProtectedMixinOptions, IApiReleaseTagMixinOptions, IApiDeclaredItemOptions {
+}
+declare const ApiConstructor_base: typeof ApiDeclaredItem & (new (...args: any[]) => ApiReleaseTagMixin) & (new (...args: any[]) => ApiProtectedMixin) & (new (...args: any[]) => ApiParameterListMixin);
+/**
+ * Represents a TypeScript class constructor declaration that belongs to an `ApiClass`.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiConstructor` represents a declaration using the `constructor` keyword such as in this example:
+ *
+ * ```ts
+ * export class Vector {
+ *   public x: number;
+ *   public y: number;
+ *
+ *   // A class constructor:
+ *   public constructor(x: number, y: number) {
+ *     this.x = x;
+ *     this.y = y;
+ *   }
+ * }
+ * ```
+ *
+ * Compare with {@link ApiConstructSignature}, which describes the construct signature for a class constructor.
+ *
+ * @public
+ */
+export declare class ApiConstructor extends ApiConstructor_base {
+    constructor(options: IApiConstructorOptions);
+    static getContainerKey(overloadIndex: number): string;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiConstructor.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiConstructor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiConstructor.d.ts","sourceRoot":"","sources":["../../src/model/ApiConstructor.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAGrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,KAAK,uBAAuB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACzF,OAAO,EAAE,KAAK,6BAA6B,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC5G,OAAO,EAAE,iBAAiB,EAAE,KAAK,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAChG,OAAO,EAAE,KAAK,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAEnG;;;GAGG;AACH,MAAM,WAAW,sBACf,SAAQ,6BAA6B,EACnC,yBAAyB,EACzB,0BAA0B,EAC1B,uBAAuB;CAAG;;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,cAAe,SAAQ,mBAEnC;gBACoB,OAAO,EAAE,sBAAsB;WAIpC,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM;IAI5D,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAOvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiConstructor.js

@@ -0,0 +1,64 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiConstructor = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiDeclaredItem_1 = require("../items/ApiDeclaredItem");
+const ApiParameterListMixin_1 = require("../mixins/ApiParameterListMixin");
+const ApiProtectedMixin_1 = require("../mixins/ApiProtectedMixin");
+const ApiReleaseTagMixin_1 = require("../mixins/ApiReleaseTagMixin");
+/**
+ * Represents a TypeScript class constructor declaration that belongs to an `ApiClass`.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiConstructor` represents a declaration using the `constructor` keyword such as in this example:
+ *
+ * ```ts
+ * export class Vector {
+ *   public x: number;
+ *   public y: number;
+ *
+ *   // A class constructor:
+ *   public constructor(x: number, y: number) {
+ *     this.x = x;
+ *     this.y = y;
+ *   }
+ * }
+ * ```
+ *
+ * Compare with {@link ApiConstructSignature}, which describes the construct signature for a class constructor.
+ *
+ * @public
+ */
+class ApiConstructor extends (0, ApiParameterListMixin_1.ApiParameterListMixin)((0, ApiProtectedMixin_1.ApiProtectedMixin)((0, ApiReleaseTagMixin_1.ApiReleaseTagMixin)(ApiDeclaredItem_1.ApiDeclaredItem))) {
+    constructor(options) {
+        super(options);
+    }
+    static getContainerKey(overloadIndex) {
+        return `|${ApiItem_1.ApiItemKind.Constructor}|${overloadIndex}`;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.Constructor;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiConstructor.getContainerKey(this.overloadIndex);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const parent = this.parent
+            ? this.parent.canonicalReference
+            : // .withMeaning() requires some kind of component
+                DeclarationReference_1.DeclarationReference.empty().addNavigationStep("#" /* Navigation.Members */, '(parent)');
+        return parent.withMeaning("constructor" /* Meaning.Constructor */).withOverloadIndex(this.overloadIndex);
+    }
+}
+exports.ApiConstructor = ApiConstructor;
+//# sourceMappingURL=ApiConstructor.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiConstructor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiConstructor.js","sourceRoot":"","sources":["../../src/model/ApiConstructor.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,kGAIiE;AACjE,8CAA+C;AAC/C,8DAAyF;AACzF,2EAA4G;AAC5G,mEAAgG;AAChG,qEAAmG;AAYnG;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAa,cAAe,SAAQ,IAAA,6CAAqB,EACvD,IAAA,qCAAiB,EAAC,IAAA,uCAAkB,EAAC,iCAAe,CAAC,CAAC,CACvD;IACC,YAAmB,OAA+B;QAChD,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,MAAM,CAAC,eAAe,CAAC,aAAqB;QACjD,OAAO,IAAI,qBAAW,CAAC,WAAW,IAAI,aAAa,EAAE,CAAC;IACxD,CAAC;IAED,gBAAgB;IAChB,IAAW,IAAI;QACb,OAAO,qBAAW,CAAC,WAAW,CAAC;IACjC,CAAC;IAED,gBAAgB;IAChB,IAAW,YAAY;QACrB,OAAO,cAAc,CAAC,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC5D,CAAC;IAED,sBAAsB;IACf,uBAAuB;QAC5B,MAAM,MAAM,GAAyB,IAAI,CAAC,MAAM;YAC9C,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB;YAChC,CAAC,CAAC,iDAAiD;gBACjD,2CAAoB,CAAC,KAAK,EAAE,CAAC,iBAAiB,+BAAqB,UAAU,CAAC,CAAC;QACnF,OAAO,MAAM,CAAC,WAAW,yCAAqB,CAAC,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACvF,CAAC;CACF;AA7BD,wCA6BC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport {\n  DeclarationReference,\n  Meaning,\n  Navigation\n} from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';\nimport { ApiItemKind } from '../items/ApiItem';\nimport { type IApiDeclaredItemOptions, ApiDeclaredItem } from '../items/ApiDeclaredItem';\nimport { type IApiParameterListMixinOptions, ApiParameterListMixin } from '../mixins/ApiParameterListMixin';\nimport { ApiProtectedMixin, type IApiProtectedMixinOptions } from '../mixins/ApiProtectedMixin';\nimport { type IApiReleaseTagMixinOptions, ApiReleaseTagMixin } from '../mixins/ApiReleaseTagMixin';\n\n/**\n * Constructor options for {@link ApiConstructor}.\n * @public\n */\nexport interface IApiConstructorOptions\n  extends IApiParameterListMixinOptions,\n    IApiProtectedMixinOptions,\n    IApiReleaseTagMixinOptions,\n    IApiDeclaredItemOptions {}\n\n/**\n * Represents a TypeScript class constructor declaration that belongs to an `ApiClass`.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.\n *\n * `ApiConstructor` represents a declaration using the `constructor` keyword such as in this example:\n *\n * ```ts\n * export class Vector {\n *   public x: number;\n *   public y: number;\n *\n *   // A class constructor:\n *   public constructor(x: number, y: number) {\n *     this.x = x;\n *     this.y = y;\n *   }\n * }\n * ```\n *\n * Compare with {@link ApiConstructSignature}, which describes the construct signature for a class constructor.\n *\n * @public\n */\nexport class ApiConstructor extends ApiParameterListMixin(\n  ApiProtectedMixin(ApiReleaseTagMixin(ApiDeclaredItem))\n) {\n  public constructor(options: IApiConstructorOptions) {\n    super(options);\n  }\n\n  public static getContainerKey(overloadIndex: number): string {\n    return `|${ApiItemKind.Constructor}|${overloadIndex}`;\n  }\n\n  /** @override */\n  public get kind(): ApiItemKind {\n    return ApiItemKind.Constructor;\n  }\n\n  /** @override */\n  public get containerKey(): string {\n    return ApiConstructor.getContainerKey(this.overloadIndex);\n  }\n\n  /** @beta @override */\n  public buildCanonicalReference(): DeclarationReference {\n    const parent: DeclarationReference = this.parent\n      ? this.parent.canonicalReference\n      : // .withMeaning() requires some kind of component\n        DeclarationReference.empty().addNavigationStep(Navigation.Members, '(parent)');\n    return parent.withMeaning(Meaning.Constructor).withOverloadIndex(this.overloadIndex);\n  }\n}\n"]}

node_modules/@microsoft/api-extractor-model/lib/model/ApiEntryPoint.d.ts

@@ -0,0 +1,62 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItem, ApiItemKind } from '../items/ApiItem';
+import { ApiItemContainerMixin, type IApiItemContainerMixinOptions } from '../mixins/ApiItemContainerMixin';
+import { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';
+/**
+ * Constructor options for {@link ApiEntryPoint}.
+ * @public
+ */
+export interface IApiEntryPointOptions extends IApiItemContainerMixinOptions, IApiNameMixinOptions {
+}
+declare const ApiEntryPoint_base: typeof ApiItem & (new (...args: any[]) => ApiNameMixin) & (new (...args: any[]) => ApiItemContainerMixin);
+/**
+ * Represents the entry point for an NPM package.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiEntryPoint` represents the entry point to an NPM package.  API Extractor does not currently support
+ * analysis of multiple entry points, but the `ApiEntryPoint` object is included to support a future feature.
+ * In the current implementation, `ApiEntryPoint.importPath` is always the empty string.
+ *
+ * For example, suppose the package.json file looks like this:
+ *
+ * ```json
+ * {
+ *   "name": "example-library",
+ *   "version": "1.0.0",
+ *   "main": "./lib/index.js",
+ *   "typings": "./lib/index.d.ts"
+ * }
+ * ```
+ *
+ * In this example, the `ApiEntryPoint` would represent the TypeScript module for `./lib/index.js`.
+ *
+ * @public
+ */
+export declare class ApiEntryPoint extends ApiEntryPoint_base {
+    constructor(options: IApiEntryPointOptions);
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /**
+     * The module path for this entry point, relative to the parent `ApiPackage`.  In the current implementation,
+     * this is always the empty string, indicating the default entry point.
+     *
+     * @remarks
+     *
+     * API Extractor does not currently support analysis of multiple entry points.  If that feature is implemented
+     * in the future, then the `ApiEntryPoint.importPath` will be used to distinguish different entry points,
+     * for example: `controls/Button` in `import { Button } from "example-package/controls/Button";`.
+     *
+     * The `ApiEntryPoint.name` property stores the same value as `ApiEntryPoint.importPath`.
+     */
+    get importPath(): string;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiEntryPoint.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiEntryPoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiEntryPoint.d.ts","sourceRoot":"","sources":["../../src/model/ApiEntryPoint.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAE,MAAM,yDAAyD,CAAC;AAC/F,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,qBAAqB,EAAE,KAAK,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAC5G,OAAO,EAAE,KAAK,oBAAoB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAGjF;;;GAGG;AACH,MAAM,WAAW,qBAAsB,SAAQ,6BAA6B,EAAE,oBAAoB;CAAG;;AAErG;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,aAAc,SAAQ,kBAA4C;gBAC1D,OAAO,EAAE,qBAAqB;IAIjD,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAGhC;IAED;;;;;;;;;;;OAWG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAOvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiEntryPoint.js

@@ -0,0 +1,75 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiEntryPoint = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiItemContainerMixin_1 = require("../mixins/ApiItemContainerMixin");
+const ApiNameMixin_1 = require("../mixins/ApiNameMixin");
+const ApiPackage_1 = require("./ApiPackage");
+/**
+ * Represents the entry point for an NPM package.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiEntryPoint` represents the entry point to an NPM package.  API Extractor does not currently support
+ * analysis of multiple entry points, but the `ApiEntryPoint` object is included to support a future feature.
+ * In the current implementation, `ApiEntryPoint.importPath` is always the empty string.
+ *
+ * For example, suppose the package.json file looks like this:
+ *
+ * ```json
+ * {
+ *   "name": "example-library",
+ *   "version": "1.0.0",
+ *   "main": "./lib/index.js",
+ *   "typings": "./lib/index.d.ts"
+ * }
+ * ```
+ *
+ * In this example, the `ApiEntryPoint` would represent the TypeScript module for `./lib/index.js`.
+ *
+ * @public
+ */
+class ApiEntryPoint extends (0, ApiItemContainerMixin_1.ApiItemContainerMixin)((0, ApiNameMixin_1.ApiNameMixin)(ApiItem_1.ApiItem)) {
+    constructor(options) {
+        super(options);
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.EntryPoint;
+    }
+    /** @override */
+    get containerKey() {
+        // No prefix needed, because ApiEntryPoint is the only possible member of an ApiPackage
+        return this.name;
+    }
+    /**
+     * The module path for this entry point, relative to the parent `ApiPackage`.  In the current implementation,
+     * this is always the empty string, indicating the default entry point.
+     *
+     * @remarks
+     *
+     * API Extractor does not currently support analysis of multiple entry points.  If that feature is implemented
+     * in the future, then the `ApiEntryPoint.importPath` will be used to distinguish different entry points,
+     * for example: `controls/Button` in `import { Button } from "example-package/controls/Button";`.
+     *
+     * The `ApiEntryPoint.name` property stores the same value as `ApiEntryPoint.importPath`.
+     */
+    get importPath() {
+        return this.name;
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        if (this.parent instanceof ApiPackage_1.ApiPackage) {
+            return DeclarationReference_1.DeclarationReference.package(this.parent.name, this.importPath);
+        }
+        return DeclarationReference_1.DeclarationReference.empty();
+    }
+}
+exports.ApiEntryPoint = ApiEntryPoint;
+//# sourceMappingURL=ApiEntryPoint.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiEntryPoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiEntryPoint.js","sourceRoot":"","sources":["../../src/model/ApiEntryPoint.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,kGAA+F;AAC/F,8CAAwD;AACxD,2EAA4G;AAC5G,yDAAiF;AACjF,6CAA0C;AAQ1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAa,aAAc,SAAQ,IAAA,6CAAqB,EAAC,IAAA,2BAAY,EAAC,iBAAO,CAAC,CAAC;IAC7E,YAAmB,OAA8B;QAC/C,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAED,gBAAgB;IAChB,IAAW,IAAI;QACb,OAAO,qBAAW,CAAC,UAAU,CAAC;IAChC,CAAC;IAED,gBAAgB;IAChB,IAAW,YAAY;QACrB,uFAAuF;QACvF,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED;;;;;;;;;;;OAWG;IACH,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED,sBAAsB;IACf,uBAAuB;QAC5B,IAAI,IAAI,CAAC,MAAM,YAAY,uBAAU,EAAE;YACrC,OAAO,2CAAoB,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;SACxE;QAED,OAAO,2CAAoB,CAAC,KAAK,EAAE,CAAC;IACtC,CAAC;CACF;AAxCD,sCAwCC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';\nimport { ApiItem, ApiItemKind } from '../items/ApiItem';\nimport { ApiItemContainerMixin, type IApiItemContainerMixinOptions } from '../mixins/ApiItemContainerMixin';\nimport { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';\nimport { ApiPackage } from './ApiPackage';\n\n/**\n * Constructor options for {@link ApiEntryPoint}.\n * @public\n */\nexport interface IApiEntryPointOptions extends IApiItemContainerMixinOptions, IApiNameMixinOptions {}\n\n/**\n * Represents the entry point for an NPM package.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.\n *\n * `ApiEntryPoint` represents the entry point to an NPM package.  API Extractor does not currently support\n * analysis of multiple entry points, but the `ApiEntryPoint` object is included to support a future feature.\n * In the current implementation, `ApiEntryPoint.importPath` is always the empty string.\n *\n * For example, suppose the package.json file looks like this:\n *\n * ```json\n * {\n *   \"name\": \"example-library\",\n *   \"version\": \"1.0.0\",\n *   \"main\": \"./lib/index.js\",\n *   \"typings\": \"./lib/index.d.ts\"\n * }\n * ```\n *\n * In this example, the `ApiEntryPoint` would represent the TypeScript module for `./lib/index.js`.\n *\n * @public\n */\nexport class ApiEntryPoint extends ApiItemContainerMixin(ApiNameMixin(ApiItem)) {\n  public constructor(options: IApiEntryPointOptions) {\n    super(options);\n  }\n\n  /** @override */\n  public get kind(): ApiItemKind {\n    return ApiItemKind.EntryPoint;\n  }\n\n  /** @override */\n  public get containerKey(): string {\n    // No prefix needed, because ApiEntryPoint is the only possible member of an ApiPackage\n    return this.name;\n  }\n\n  /**\n   * The module path for this entry point, relative to the parent `ApiPackage`.  In the current implementation,\n   * this is always the empty string, indicating the default entry point.\n   *\n   * @remarks\n   *\n   * API Extractor does not currently support analysis of multiple entry points.  If that feature is implemented\n   * in the future, then the `ApiEntryPoint.importPath` will be used to distinguish different entry points,\n   * for example: `controls/Button` in `import { Button } from \"example-package/controls/Button\";`.\n   *\n   * The `ApiEntryPoint.name` property stores the same value as `ApiEntryPoint.importPath`.\n   */\n  public get importPath(): string {\n    return this.name;\n  }\n\n  /** @beta @override */\n  public buildCanonicalReference(): DeclarationReference {\n    if (this.parent instanceof ApiPackage) {\n      return DeclarationReference.package(this.parent.name, this.importPath);\n    }\n\n    return DeclarationReference.empty();\n  }\n}\n"]}

node_modules/@microsoft/api-extractor-model/lib/model/ApiEnum.d.ts

@@ -0,0 +1,51 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { ApiDeclaredItem, type IApiDeclaredItemOptions } from '../items/ApiDeclaredItem';
+import { ApiReleaseTagMixin, type IApiReleaseTagMixinOptions } from '../mixins/ApiReleaseTagMixin';
+import { ApiItemContainerMixin, type IApiItemContainerMixinOptions } from '../mixins/ApiItemContainerMixin';
+import type { ApiEnumMember } from './ApiEnumMember';
+import { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';
+import { type IApiExportedMixinOptions, ApiExportedMixin } from '../mixins/ApiExportedMixin';
+/**
+ * Constructor options for {@link ApiEnum}.
+ * @public
+ */
+export interface IApiEnumOptions extends IApiItemContainerMixinOptions, IApiNameMixinOptions, IApiReleaseTagMixinOptions, IApiDeclaredItemOptions, IApiExportedMixinOptions {
+}
+declare const ApiEnum_base: typeof ApiDeclaredItem & (new (...args: any[]) => ApiExportedMixin) & (new (...args: any[]) => ApiReleaseTagMixin) & (new (...args: any[]) => ApiNameMixin) & (new (...args: any[]) => ApiItemContainerMixin);
+/**
+ * Represents a TypeScript enum declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiEnum` represents an enum declaration such as `FontSizes` in the example below:
+ *
+ * ```ts
+ * export enum FontSizes {
+ *   Small = 100,
+ *   Medium = 200,
+ *   Large = 300
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare class ApiEnum extends ApiEnum_base {
+    constructor(options: IApiEnumOptions);
+    static getContainerKey(name: string): string;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get members(): ReadonlyArray<ApiEnumMember>;
+    /** @override */
+    get containerKey(): string;
+    /** @override */
+    addMember(member: ApiEnumMember): void;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiEnum.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiEnum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiEnum.d.ts","sourceRoot":"","sources":["../../src/model/ApiEnum.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAIrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACzF,OAAO,EAAE,kBAAkB,EAAE,KAAK,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,qBAAqB,EAAE,KAAK,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAC5G,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,KAAK,oBAAoB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,KAAK,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAE7F;;;GAGG;AACH,MAAM,WAAW,eACf,SAAQ,6BAA6B,EACnC,oBAAoB,EACpB,0BAA0B,EAC1B,uBAAuB,EACvB,wBAAwB;CAAG;;AAE/B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,OAAQ,SAAQ,YAE5B;gBACoB,OAAO,EAAE,eAAe;WAI7B,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAInD,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,OAAO,IAAI,aAAa,CAAC,aAAa,CAAC,CAEjD;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,gBAAgB;IACT,SAAS,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAO7C,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAOvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiEnum.js

@@ -0,0 +1,69 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiEnum = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiDeclaredItem_1 = require("../items/ApiDeclaredItem");
+const ApiReleaseTagMixin_1 = require("../mixins/ApiReleaseTagMixin");
+const ApiItemContainerMixin_1 = require("../mixins/ApiItemContainerMixin");
+const ApiNameMixin_1 = require("../mixins/ApiNameMixin");
+const ApiExportedMixin_1 = require("../mixins/ApiExportedMixin");
+/**
+ * Represents a TypeScript enum declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiEnum` represents an enum declaration such as `FontSizes` in the example below:
+ *
+ * ```ts
+ * export enum FontSizes {
+ *   Small = 100,
+ *   Medium = 200,
+ *   Large = 300
+ * }
+ * ```
+ *
+ * @public
+ */
+class ApiEnum extends (0, ApiItemContainerMixin_1.ApiItemContainerMixin)((0, ApiNameMixin_1.ApiNameMixin)((0, ApiReleaseTagMixin_1.ApiReleaseTagMixin)((0, ApiExportedMixin_1.ApiExportedMixin)(ApiDeclaredItem_1.ApiDeclaredItem)))) {
+    constructor(options) {
+        super(options);
+    }
+    static getContainerKey(name) {
+        return `${name}|${ApiItem_1.ApiItemKind.Enum}`;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.Enum;
+    }
+    /** @override */
+    get members() {
+        return super.members;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiEnum.getContainerKey(this.name);
+    }
+    /** @override */
+    addMember(member) {
+        if (member.kind !== ApiItem_1.ApiItemKind.EnumMember) {
+            throw new Error('Only ApiEnumMember objects can be added to an ApiEnum');
+        }
+        super.addMember(member);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const nameComponent = DeclarationReference_1.DeclarationReference.parseComponent(this.name);
+        const navigation = this.isExported ? "." /* Navigation.Exports */ : "~" /* Navigation.Locals */;
+        return (this.parent ? this.parent.canonicalReference : DeclarationReference_1.DeclarationReference.empty())
+            .addNavigationStep(navigation, nameComponent)
+            .withMeaning("enum" /* Meaning.Enum */);
+    }
+}
+exports.ApiEnum = ApiEnum;
+//# sourceMappingURL=ApiEnum.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiEnum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiEnum.js","sourceRoot":"","sources":["../../src/model/ApiEnum.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,kGAKiE;AACjE,8CAA+C;AAC/C,8DAAyF;AACzF,qEAAmG;AACnG,2EAA4G;AAE5G,yDAAiF;AACjF,iEAA6F;AAa7F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,OAAQ,SAAQ,IAAA,6CAAqB,EAChD,IAAA,2BAAY,EAAC,IAAA,uCAAkB,EAAC,IAAA,mCAAgB,EAAC,iCAAe,CAAC,CAAC,CAAC,CACpE;IACC,YAAmB,OAAwB;QACzC,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,MAAM,CAAC,eAAe,CAAC,IAAY;QACxC,OAAO,GAAG,IAAI,IAAI,qBAAW,CAAC,IAAI,EAAE,CAAC;IACvC,CAAC;IAED,gBAAgB;IAChB,IAAW,IAAI;QACb,OAAO,qBAAW,CAAC,IAAI,CAAC;IAC1B,CAAC;IAED,gBAAgB;IAChB,IAAW,OAAO;QAChB,OAAO,KAAK,CAAC,OAAuC,CAAC;IACvD,CAAC;IAED,gBAAgB;IAChB,IAAW,YAAY;QACrB,OAAO,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IAED,gBAAgB;IACT,SAAS,CAAC,MAAqB;QACpC,IAAI,MAAM,CAAC,IAAI,KAAK,qBAAW,CAAC,UAAU,EAAE;YAC1C,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;SAC1E;QACD,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED,sBAAsB;IACf,uBAAuB;QAC5B,MAAM,aAAa,GAAc,2CAAoB,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChF,MAAM,UAAU,GAAe,IAAI,CAAC,UAAU,CAAC,CAAC,8BAAoB,CAAC,4BAAkB,CAAC;QACxF,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,2CAAoB,CAAC,KAAK,EAAE,CAAC;aACjF,iBAAiB,CAAC,UAAU,EAAE,aAAa,CAAC;aAC5C,WAAW,2BAAc,CAAC;IAC/B,CAAC;CACF;AA1CD,0BA0CC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport {\n  DeclarationReference,\n  Meaning,\n  Navigation,\n  type Component\n} from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';\nimport { ApiItemKind } from '../items/ApiItem';\nimport { ApiDeclaredItem, type IApiDeclaredItemOptions } from '../items/ApiDeclaredItem';\nimport { ApiReleaseTagMixin, type IApiReleaseTagMixinOptions } from '../mixins/ApiReleaseTagMixin';\nimport { ApiItemContainerMixin, type IApiItemContainerMixinOptions } from '../mixins/ApiItemContainerMixin';\nimport type { ApiEnumMember } from './ApiEnumMember';\nimport { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';\nimport { type IApiExportedMixinOptions, ApiExportedMixin } from '../mixins/ApiExportedMixin';\n\n/**\n * Constructor options for {@link ApiEnum}.\n * @public\n */\nexport interface IApiEnumOptions\n  extends IApiItemContainerMixinOptions,\n    IApiNameMixinOptions,\n    IApiReleaseTagMixinOptions,\n    IApiDeclaredItemOptions,\n    IApiExportedMixinOptions {}\n\n/**\n * Represents a TypeScript enum declaration.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.\n *\n * `ApiEnum` represents an enum declaration such as `FontSizes` in the example below:\n *\n * ```ts\n * export enum FontSizes {\n *   Small = 100,\n *   Medium = 200,\n *   Large = 300\n * }\n * ```\n *\n * @public\n */\nexport class ApiEnum extends ApiItemContainerMixin(\n  ApiNameMixin(ApiReleaseTagMixin(ApiExportedMixin(ApiDeclaredItem)))\n) {\n  public constructor(options: IApiEnumOptions) {\n    super(options);\n  }\n\n  public static getContainerKey(name: string): string {\n    return `${name}|${ApiItemKind.Enum}`;\n  }\n\n  /** @override */\n  public get kind(): ApiItemKind {\n    return ApiItemKind.Enum;\n  }\n\n  /** @override */\n  public get members(): ReadonlyArray<ApiEnumMember> {\n    return super.members as ReadonlyArray<ApiEnumMember>;\n  }\n\n  /** @override */\n  public get containerKey(): string {\n    return ApiEnum.getContainerKey(this.name);\n  }\n\n  /** @override */\n  public addMember(member: ApiEnumMember): void {\n    if (member.kind !== ApiItemKind.EnumMember) {\n      throw new Error('Only ApiEnumMember objects can be added to an ApiEnum');\n    }\n    super.addMember(member);\n  }\n\n  /** @beta @override */\n  public buildCanonicalReference(): DeclarationReference {\n    const nameComponent: Component = DeclarationReference.parseComponent(this.name);\n    const navigation: Navigation = this.isExported ? Navigation.Exports : Navigation.Locals;\n    return (this.parent ? this.parent.canonicalReference : DeclarationReference.empty())\n      .addNavigationStep(navigation, nameComponent)\n      .withMeaning(Meaning.Enum);\n  }\n}\n"]}

node_modules/@microsoft/api-extractor-model/lib/model/ApiEnumMember.d.ts

@@ -0,0 +1,71 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { ApiDeclaredItem, type IApiDeclaredItemOptions } from '../items/ApiDeclaredItem';
+import { ApiReleaseTagMixin, type IApiReleaseTagMixinOptions } from '../mixins/ApiReleaseTagMixin';
+import { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';
+import { ApiInitializerMixin, type IApiInitializerMixinOptions } from '../mixins/ApiInitializerMixin';
+/**
+ * Constructor options for {@link ApiEnumMember}.
+ * @public
+ */
+export interface IApiEnumMemberOptions extends IApiNameMixinOptions, IApiReleaseTagMixinOptions, IApiDeclaredItemOptions, IApiInitializerMixinOptions {
+}
+/**
+ * Options for customizing the sort order of {@link ApiEnum} members.
+ *
+ * @privateRemarks
+ * This enum is currently only used by the `@microsoft/api-extractor` package; it is declared here
+ * because we anticipate that if more options are added in the future, their sorting will be implemented
+ * by the `@microsoft/api-extractor-model` package.
+ *
+ * See https://github.com/microsoft/rushstack/issues/918 for details.
+ *
+ * @public
+ */
+export declare enum EnumMemberOrder {
+    /**
+     * `ApiEnumMember` items are sorted according to their {@link ApiItem.getSortKey}.  The order is
+     * basically alphabetical by identifier name, but otherwise unspecified to allow for cosmetic improvements.
+     *
+     * This is the default behavior.
+     */
+    ByName = "by-name",
+    /**
+     * `ApiEnumMember` items preserve the original order of the declarations in the source file.
+     * (This disables the automatic sorting that is normally applied based on {@link ApiItem.getSortKey}.)
+     */
+    Preserve = "preserve"
+}
+declare const ApiEnumMember_base: typeof ApiDeclaredItem & (new (...args: any[]) => ApiInitializerMixin) & (new (...args: any[]) => ApiReleaseTagMixin) & (new (...args: any[]) => ApiNameMixin);
+/**
+ * Represents a member of a TypeScript enum declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiEnumMember` represents an enum member such as `Small = 100` in the example below:
+ *
+ * ```ts
+ * export enum FontSizes {
+ *   Small = 100,
+ *   Medium = 200,
+ *   Large = 300
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare class ApiEnumMember extends ApiEnumMember_base {
+    constructor(options: IApiEnumMemberOptions);
+    static getContainerKey(name: string): string;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiEnumMember.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiEnumMember.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiEnumMember.d.ts","sourceRoot":"","sources":["../../src/model/ApiEnumMember.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAIrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACzF,OAAO,EAAE,kBAAkB,EAAE,KAAK,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,KAAK,oBAAoB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,mBAAmB,EAAE,KAAK,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAEtG;;;GAGG;AACH,MAAM,WAAW,qBACf,SAAQ,oBAAoB,EAC1B,0BAA0B,EAC1B,uBAAuB,EACvB,2BAA2B;CAAG;AAElC;;;;;;;;;;;GAWG;AACH,oBAAY,eAAe;IACzB;;;;;OAKG;IACH,MAAM,YAAY;IAElB;;;OAGG;IACH,QAAQ,aAAa;CACtB;;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,aAAc,SAAQ,kBAAsE;gBACpF,OAAO,EAAE,qBAAqB;WAInC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAKnD,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAMvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiEnumMember.js

@@ -0,0 +1,84 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiEnumMember = exports.EnumMemberOrder = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiDeclaredItem_1 = require("../items/ApiDeclaredItem");
+const ApiReleaseTagMixin_1 = require("../mixins/ApiReleaseTagMixin");
+const ApiNameMixin_1 = require("../mixins/ApiNameMixin");
+const ApiInitializerMixin_1 = require("../mixins/ApiInitializerMixin");
+/**
+ * Options for customizing the sort order of {@link ApiEnum} members.
+ *
+ * @privateRemarks
+ * This enum is currently only used by the `@microsoft/api-extractor` package; it is declared here
+ * because we anticipate that if more options are added in the future, their sorting will be implemented
+ * by the `@microsoft/api-extractor-model` package.
+ *
+ * See https://github.com/microsoft/rushstack/issues/918 for details.
+ *
+ * @public
+ */
+var EnumMemberOrder;
+(function (EnumMemberOrder) {
+    /**
+     * `ApiEnumMember` items are sorted according to their {@link ApiItem.getSortKey}.  The order is
+     * basically alphabetical by identifier name, but otherwise unspecified to allow for cosmetic improvements.
+     *
+     * This is the default behavior.
+     */
+    EnumMemberOrder["ByName"] = "by-name";
+    /**
+     * `ApiEnumMember` items preserve the original order of the declarations in the source file.
+     * (This disables the automatic sorting that is normally applied based on {@link ApiItem.getSortKey}.)
+     */
+    EnumMemberOrder["Preserve"] = "preserve";
+})(EnumMemberOrder = exports.EnumMemberOrder || (exports.EnumMemberOrder = {}));
+/**
+ * Represents a member of a TypeScript enum declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiEnumMember` represents an enum member such as `Small = 100` in the example below:
+ *
+ * ```ts
+ * export enum FontSizes {
+ *   Small = 100,
+ *   Medium = 200,
+ *   Large = 300
+ * }
+ * ```
+ *
+ * @public
+ */
+class ApiEnumMember extends (0, ApiNameMixin_1.ApiNameMixin)((0, ApiReleaseTagMixin_1.ApiReleaseTagMixin)((0, ApiInitializerMixin_1.ApiInitializerMixin)(ApiDeclaredItem_1.ApiDeclaredItem))) {
+    constructor(options) {
+        super(options);
+    }
+    static getContainerKey(name) {
+        // No prefix needed, because ApiEnumMember is the only possible member of an ApiEnum
+        return name;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.EnumMember;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiEnumMember.getContainerKey(this.name);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const nameComponent = DeclarationReference_1.DeclarationReference.parseComponent(this.name);
+        return (this.parent ? this.parent.canonicalReference : DeclarationReference_1.DeclarationReference.empty())
+            .addNavigationStep("." /* Navigation.Exports */, nameComponent)
+            .withMeaning("member" /* Meaning.Member */);
+    }
+}
+exports.ApiEnumMember = ApiEnumMember;
+//# sourceMappingURL=ApiEnumMember.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiEnumMember.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiEnumMember.js","sourceRoot":"","sources":["../../src/model/ApiEnumMember.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,kGAKiE;AACjE,8CAA+C;AAC/C,8DAAyF;AACzF,qEAAmG;AACnG,yDAAiF;AACjF,uEAAsG;AAYtG;;;;;;;;;;;GAWG;AACH,IAAY,eAcX;AAdD,WAAY,eAAe;IACzB;;;;;OAKG;IACH,qCAAkB,CAAA;IAElB;;;OAGG;IACH,wCAAqB,CAAA;AACvB,CAAC,EAdW,eAAe,GAAf,uBAAe,KAAf,uBAAe,QAc1B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,aAAc,SAAQ,IAAA,2BAAY,EAAC,IAAA,uCAAkB,EAAC,IAAA,yCAAmB,EAAC,iCAAe,CAAC,CAAC,CAAC;IACvG,YAAmB,OAA8B;QAC/C,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,MAAM,CAAC,eAAe,CAAC,IAAY;QACxC,oFAAoF;QACpF,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gBAAgB;IAChB,IAAW,IAAI;QACb,OAAO,qBAAW,CAAC,UAAU,CAAC;IAChC,CAAC;IAED,gBAAgB;IAChB,IAAW,YAAY;QACrB,OAAO,aAAa,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,sBAAsB;IACf,uBAAuB;QAC5B,MAAM,aAAa,GAAc,2CAAoB,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChF,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,2CAAoB,CAAC,KAAK,EAAE,CAAC;aACjF,iBAAiB,+BAAqB,aAAa,CAAC;aACpD,WAAW,+BAAgB,CAAC;IACjC,CAAC;CACF;AA3BD,sCA2BC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport {\n  DeclarationReference,\n  Meaning,\n  Navigation,\n  type Component\n} from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';\nimport { ApiItemKind } from '../items/ApiItem';\nimport { ApiDeclaredItem, type IApiDeclaredItemOptions } from '../items/ApiDeclaredItem';\nimport { ApiReleaseTagMixin, type IApiReleaseTagMixinOptions } from '../mixins/ApiReleaseTagMixin';\nimport { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';\nimport { ApiInitializerMixin, type IApiInitializerMixinOptions } from '../mixins/ApiInitializerMixin';\n\n/**\n * Constructor options for {@link ApiEnumMember}.\n * @public\n */\nexport interface IApiEnumMemberOptions\n  extends IApiNameMixinOptions,\n    IApiReleaseTagMixinOptions,\n    IApiDeclaredItemOptions,\n    IApiInitializerMixinOptions {}\n\n/**\n * Options for customizing the sort order of {@link ApiEnum} members.\n *\n * @privateRemarks\n * This enum is currently only used by the `@microsoft/api-extractor` package; it is declared here\n * because we anticipate that if more options are added in the future, their sorting will be implemented\n * by the `@microsoft/api-extractor-model` package.\n *\n * See https://github.com/microsoft/rushstack/issues/918 for details.\n *\n * @public\n */\nexport enum EnumMemberOrder {\n  /**\n   * `ApiEnumMember` items are sorted according to their {@link ApiItem.getSortKey}.  The order is\n   * basically alphabetical by identifier name, but otherwise unspecified to allow for cosmetic improvements.\n   *\n   * This is the default behavior.\n   */\n  ByName = 'by-name',\n\n  /**\n   * `ApiEnumMember` items preserve the original order of the declarations in the source file.\n   * (This disables the automatic sorting that is normally applied based on {@link ApiItem.getSortKey}.)\n   */\n  Preserve = 'preserve'\n}\n\n/**\n * Represents a member of a TypeScript enum declaration.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.\n *\n * `ApiEnumMember` represents an enum member such as `Small = 100` in the example below:\n *\n * ```ts\n * export enum FontSizes {\n *   Small = 100,\n *   Medium = 200,\n *   Large = 300\n * }\n * ```\n *\n * @public\n */\nexport class ApiEnumMember extends ApiNameMixin(ApiReleaseTagMixin(ApiInitializerMixin(ApiDeclaredItem))) {\n  public constructor(options: IApiEnumMemberOptions) {\n    super(options);\n  }\n\n  public static getContainerKey(name: string): string {\n    // No prefix needed, because ApiEnumMember is the only possible member of an ApiEnum\n    return name;\n  }\n\n  /** @override */\n  public get kind(): ApiItemKind {\n    return ApiItemKind.EnumMember;\n  }\n\n  /** @override */\n  public get containerKey(): string {\n    return ApiEnumMember.getContainerKey(this.name);\n  }\n\n  /** @beta @override */\n  public buildCanonicalReference(): DeclarationReference {\n    const nameComponent: Component = DeclarationReference.parseComponent(this.name);\n    return (this.parent ? this.parent.canonicalReference : DeclarationReference.empty())\n      .addNavigationStep(Navigation.Exports, nameComponent)\n      .withMeaning(Meaning.Member);\n  }\n}\n"]}

node_modules/@microsoft/api-extractor-model/lib/model/ApiFunction.d.ts

@@ -0,0 +1,49 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { type IApiDeclaredItemOptions, ApiDeclaredItem } from '../items/ApiDeclaredItem';
+import { type IApiParameterListMixinOptions, ApiParameterListMixin } from '../mixins/ApiParameterListMixin';
+import { type IApiReleaseTagMixinOptions, ApiReleaseTagMixin } from '../mixins/ApiReleaseTagMixin';
+import { type IApiReturnTypeMixinOptions, ApiReturnTypeMixin } from '../mixins/ApiReturnTypeMixin';
+import { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';
+import { type IApiTypeParameterListMixinOptions, ApiTypeParameterListMixin } from '../mixins/ApiTypeParameterListMixin';
+import { type IApiExportedMixinOptions, ApiExportedMixin } from '../mixins/ApiExportedMixin';
+/**
+ * Constructor options for {@link ApiFunction}.
+ * @public
+ */
+export interface IApiFunctionOptions extends IApiNameMixinOptions, IApiTypeParameterListMixinOptions, IApiParameterListMixinOptions, IApiReleaseTagMixinOptions, IApiReturnTypeMixinOptions, IApiDeclaredItemOptions, IApiExportedMixinOptions {
+}
+declare const ApiFunction_base: typeof ApiDeclaredItem & (new (...args: any[]) => ApiExportedMixin) & (new (...args: any[]) => ApiReturnTypeMixin) & (new (...args: any[]) => ApiReleaseTagMixin) & (new (...args: any[]) => ApiParameterListMixin) & (new (...args: any[]) => ApiTypeParameterListMixin) & (new (...args: any[]) => ApiNameMixin);
+/**
+ * Represents a TypeScript function declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiFunction` represents a TypeScript declaration such as this example:
+ *
+ * ```ts
+ * export function getAverage(x: number, y: number): number {
+ *   return (x + y) / 2.0;
+ * }
+ * ```
+ *
+ * Functions are exported by an entry point module or by a namespace.  Compare with {@link ApiMethod}, which
+ * represents a function that is a member of a class.
+ *
+ * @public
+ */
+export declare class ApiFunction extends ApiFunction_base {
+    constructor(options: IApiFunctionOptions);
+    static getContainerKey(name: string, overloadIndex: number): string;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiFunction.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiFunction.d.ts","sourceRoot":"","sources":["../../src/model/ApiFunction.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAIrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,KAAK,uBAAuB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACzF,OAAO,EAAE,KAAK,6BAA6B,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC5G,OAAO,EAAE,KAAK,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,KAAK,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,KAAK,oBAAoB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EACL,KAAK,iCAAiC,EACtC,yBAAyB,EAC1B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,KAAK,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAE7F;;;GAGG;AACH,MAAM,WAAW,mBACf,SAAQ,oBAAoB,EAC1B,iCAAiC,EACjC,6BAA6B,EAC7B,0BAA0B,EAC1B,0BAA0B,EAC1B,uBAAuB,EACvB,wBAAwB;CAAG;;AAE/B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,WAAY,SAAQ,gBAIhC;gBACoB,OAAO,EAAE,mBAAmB;WAIjC,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM;IAI1E,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAQvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiFunction.js

@@ -0,0 +1,62 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiFunction = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiDeclaredItem_1 = require("../items/ApiDeclaredItem");
+const ApiParameterListMixin_1 = require("../mixins/ApiParameterListMixin");
+const ApiReleaseTagMixin_1 = require("../mixins/ApiReleaseTagMixin");
+const ApiReturnTypeMixin_1 = require("../mixins/ApiReturnTypeMixin");
+const ApiNameMixin_1 = require("../mixins/ApiNameMixin");
+const ApiTypeParameterListMixin_1 = require("../mixins/ApiTypeParameterListMixin");
+const ApiExportedMixin_1 = require("../mixins/ApiExportedMixin");
+/**
+ * Represents a TypeScript function declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiFunction` represents a TypeScript declaration such as this example:
+ *
+ * ```ts
+ * export function getAverage(x: number, y: number): number {
+ *   return (x + y) / 2.0;
+ * }
+ * ```
+ *
+ * Functions are exported by an entry point module or by a namespace.  Compare with {@link ApiMethod}, which
+ * represents a function that is a member of a class.
+ *
+ * @public
+ */
+class ApiFunction extends (0, ApiNameMixin_1.ApiNameMixin)((0, ApiTypeParameterListMixin_1.ApiTypeParameterListMixin)((0, ApiParameterListMixin_1.ApiParameterListMixin)((0, ApiReleaseTagMixin_1.ApiReleaseTagMixin)((0, ApiReturnTypeMixin_1.ApiReturnTypeMixin)((0, ApiExportedMixin_1.ApiExportedMixin)(ApiDeclaredItem_1.ApiDeclaredItem)))))) {
+    constructor(options) {
+        super(options);
+    }
+    static getContainerKey(name, overloadIndex) {
+        return `${name}|${ApiItem_1.ApiItemKind.Function}|${overloadIndex}`;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.Function;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiFunction.getContainerKey(this.name, this.overloadIndex);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const nameComponent = DeclarationReference_1.DeclarationReference.parseComponent(this.name);
+        const navigation = this.isExported ? "." /* Navigation.Exports */ : "~" /* Navigation.Locals */;
+        return (this.parent ? this.parent.canonicalReference : DeclarationReference_1.DeclarationReference.empty())
+            .addNavigationStep(navigation, nameComponent)
+            .withMeaning("function" /* Meaning.Function */)
+            .withOverloadIndex(this.overloadIndex);
+    }
+}
+exports.ApiFunction = ApiFunction;
+//# sourceMappingURL=ApiFunction.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiFunction.js","sourceRoot":"","sources":["../../src/model/ApiFunction.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,kGAKiE;AACjE,8CAA+C;AAC/C,8DAAyF;AACzF,2EAA4G;AAC5G,qEAAmG;AACnG,qEAAmG;AACnG,yDAAiF;AACjF,mFAG6C;AAC7C,iEAA6F;AAe7F;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAa,WAAY,SAAQ,IAAA,2BAAY,EAC3C,IAAA,qDAAyB,EACvB,IAAA,6CAAqB,EAAC,IAAA,uCAAkB,EAAC,IAAA,uCAAkB,EAAC,IAAA,mCAAgB,EAAC,iCAAe,CAAC,CAAC,CAAC,CAAC,CACjG,CACF;IACC,YAAmB,OAA4B;QAC7C,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,MAAM,CAAC,eAAe,CAAC,IAAY,EAAE,aAAqB;QAC/D,OAAO,GAAG,IAAI,IAAI,qBAAW,CAAC,QAAQ,IAAI,aAAa,EAAE,CAAC;IAC5D,CAAC;IAED,gBAAgB;IAChB,IAAW,IAAI;QACb,OAAO,qBAAW,CAAC,QAAQ,CAAC;IAC9B,CAAC;IAED,gBAAgB;IAChB,IAAW,YAAY;QACrB,OAAO,WAAW,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;IACpE,CAAC;IAED,sBAAsB;IACf,uBAAuB;QAC5B,MAAM,aAAa,GAAc,2CAAoB,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChF,MAAM,UAAU,GAAe,IAAI,CAAC,UAAU,CAAC,CAAC,8BAAoB,CAAC,4BAAkB,CAAC;QACxF,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,2CAAoB,CAAC,KAAK,EAAE,CAAC;aACjF,iBAAiB,CAAC,UAAU,EAAE,aAAa,CAAC;aAC5C,WAAW,mCAAkB;aAC7B,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC3C,CAAC;CACF;AAhCD,kCAgCC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport {\n  DeclarationReference,\n  Meaning,\n  Navigation,\n  type Component\n} from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';\nimport { ApiItemKind } from '../items/ApiItem';\nimport { type IApiDeclaredItemOptions, ApiDeclaredItem } from '../items/ApiDeclaredItem';\nimport { type IApiParameterListMixinOptions, ApiParameterListMixin } from '../mixins/ApiParameterListMixin';\nimport { type IApiReleaseTagMixinOptions, ApiReleaseTagMixin } from '../mixins/ApiReleaseTagMixin';\nimport { type IApiReturnTypeMixinOptions, ApiReturnTypeMixin } from '../mixins/ApiReturnTypeMixin';\nimport { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';\nimport {\n  type IApiTypeParameterListMixinOptions,\n  ApiTypeParameterListMixin\n} from '../mixins/ApiTypeParameterListMixin';\nimport { type IApiExportedMixinOptions, ApiExportedMixin } from '../mixins/ApiExportedMixin';\n\n/**\n * Constructor options for {@link ApiFunction}.\n * @public\n */\nexport interface IApiFunctionOptions\n  extends IApiNameMixinOptions,\n    IApiTypeParameterListMixinOptions,\n    IApiParameterListMixinOptions,\n    IApiReleaseTagMixinOptions,\n    IApiReturnTypeMixinOptions,\n    IApiDeclaredItemOptions,\n    IApiExportedMixinOptions {}\n\n/**\n * Represents a TypeScript function declaration.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.\n *\n * `ApiFunction` represents a TypeScript declaration such as this example:\n *\n * ```ts\n * export function getAverage(x: number, y: number): number {\n *   return (x + y) / 2.0;\n * }\n * ```\n *\n * Functions are exported by an entry point module or by a namespace.  Compare with {@link ApiMethod}, which\n * represents a function that is a member of a class.\n *\n * @public\n */\nexport class ApiFunction extends ApiNameMixin(\n  ApiTypeParameterListMixin(\n    ApiParameterListMixin(ApiReleaseTagMixin(ApiReturnTypeMixin(ApiExportedMixin(ApiDeclaredItem))))\n  )\n) {\n  public constructor(options: IApiFunctionOptions) {\n    super(options);\n  }\n\n  public static getContainerKey(name: string, overloadIndex: number): string {\n    return `${name}|${ApiItemKind.Function}|${overloadIndex}`;\n  }\n\n  /** @override */\n  public get kind(): ApiItemKind {\n    return ApiItemKind.Function;\n  }\n\n  /** @override */\n  public get containerKey(): string {\n    return ApiFunction.getContainerKey(this.name, this.overloadIndex);\n  }\n\n  /** @beta @override */\n  public buildCanonicalReference(): DeclarationReference {\n    const nameComponent: Component = DeclarationReference.parseComponent(this.name);\n    const navigation: Navigation = this.isExported ? Navigation.Exports : Navigation.Locals;\n    return (this.parent ? this.parent.canonicalReference : DeclarationReference.empty())\n      .addNavigationStep(navigation, nameComponent)\n      .withMeaning(Meaning.Function)\n      .withOverloadIndex(this.overloadIndex);\n  }\n}\n"]}

node_modules/@microsoft/api-extractor-model/lib/model/ApiIndexSignature.d.ts

@@ -0,0 +1,48 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { type IApiDeclaredItemOptions, ApiDeclaredItem } from '../items/ApiDeclaredItem';
+import { type IApiParameterListMixinOptions, ApiParameterListMixin } from '../mixins/ApiParameterListMixin';
+import { type IApiReleaseTagMixinOptions, ApiReleaseTagMixin } from '../mixins/ApiReleaseTagMixin';
+import { type IApiReturnTypeMixinOptions, ApiReturnTypeMixin } from '../mixins/ApiReturnTypeMixin';
+import { type IApiReadonlyMixinOptions, ApiReadonlyMixin } from '../mixins/ApiReadonlyMixin';
+/**
+ * Constructor options for {@link ApiIndexSignature}.
+ * @public
+ */
+export interface IApiIndexSignatureOptions extends IApiParameterListMixinOptions, IApiReleaseTagMixinOptions, IApiReturnTypeMixinOptions, IApiReadonlyMixinOptions, IApiDeclaredItemOptions {
+}
+declare const ApiIndexSignature_base: typeof ApiDeclaredItem & (new (...args: any[]) => ApiReadonlyMixin) & (new (...args: any[]) => ApiReturnTypeMixin) & (new (...args: any[]) => ApiReleaseTagMixin) & (new (...args: any[]) => ApiParameterListMixin);
+/**
+ * Represents a TypeScript index signature.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiIndexSignature` represents a TypeScript declaration such as `[x: number]: number` in this example:
+ *
+ * ```ts
+ * export interface INumberTable {
+ *   // An index signature
+ *   [value: number]: number;
+ *
+ *   // An overloaded index signature
+ *   [name: string]: number;
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare class ApiIndexSignature extends ApiIndexSignature_base {
+    constructor(options: IApiIndexSignatureOptions);
+    static getContainerKey(overloadIndex: number): string;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiIndexSignature.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiIndexSignature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiIndexSignature.d.ts","sourceRoot":"","sources":["../../src/model/ApiIndexSignature.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAGrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,KAAK,uBAAuB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACzF,OAAO,EAAE,KAAK,6BAA6B,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC5G,OAAO,EAAE,KAAK,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,KAAK,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,KAAK,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAE7F;;;GAGG;AACH,MAAM,WAAW,yBACf,SAAQ,6BAA6B,EACnC,0BAA0B,EAC1B,0BAA0B,EAC1B,wBAAwB,EACxB,uBAAuB;CAAG;;AAE9B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,iBAAkB,SAAQ,sBAEtC;gBACoB,OAAO,EAAE,yBAAyB;WAIvC,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM;IAI5D,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAOvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiIndexSignature.js

@@ -0,0 +1,60 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiIndexSignature = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiDeclaredItem_1 = require("../items/ApiDeclaredItem");
+const ApiParameterListMixin_1 = require("../mixins/ApiParameterListMixin");
+const ApiReleaseTagMixin_1 = require("../mixins/ApiReleaseTagMixin");
+const ApiReturnTypeMixin_1 = require("../mixins/ApiReturnTypeMixin");
+const ApiReadonlyMixin_1 = require("../mixins/ApiReadonlyMixin");
+/**
+ * Represents a TypeScript index signature.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiIndexSignature` represents a TypeScript declaration such as `[x: number]: number` in this example:
+ *
+ * ```ts
+ * export interface INumberTable {
+ *   // An index signature
+ *   [value: number]: number;
+ *
+ *   // An overloaded index signature
+ *   [name: string]: number;
+ * }
+ * ```
+ *
+ * @public
+ */
+class ApiIndexSignature extends (0, ApiParameterListMixin_1.ApiParameterListMixin)((0, ApiReleaseTagMixin_1.ApiReleaseTagMixin)((0, ApiReturnTypeMixin_1.ApiReturnTypeMixin)((0, ApiReadonlyMixin_1.ApiReadonlyMixin)(ApiDeclaredItem_1.ApiDeclaredItem)))) {
+    constructor(options) {
+        super(options);
+    }
+    static getContainerKey(overloadIndex) {
+        return `|${ApiItem_1.ApiItemKind.IndexSignature}|${overloadIndex}`;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.IndexSignature;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiIndexSignature.getContainerKey(this.overloadIndex);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const parent = this.parent
+            ? this.parent.canonicalReference
+            : // .withMeaning() requires some kind of component
+                DeclarationReference_1.DeclarationReference.empty().addNavigationStep("#" /* Navigation.Members */, '(parent)');
+        return parent.withMeaning("index" /* Meaning.IndexSignature */).withOverloadIndex(this.overloadIndex);
+    }
+}
+exports.ApiIndexSignature = ApiIndexSignature;
+//# sourceMappingURL=ApiIndexSignature.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiIndexSignature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiIndexSignature.js","sourceRoot":"","sources":["../../src/model/ApiIndexSignature.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,kGAIiE;AACjE,8CAA+C;AAC/C,8DAAyF;AACzF,2EAA4G;AAC5G,qEAAmG;AACnG,qEAAmG;AACnG,iEAA6F;AAa7F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,iBAAkB,SAAQ,IAAA,6CAAqB,EAC1D,IAAA,uCAAkB,EAAC,IAAA,uCAAkB,EAAC,IAAA,mCAAgB,EAAC,iCAAe,CAAC,CAAC,CAAC,CAC1E;IACC,YAAmB,OAAkC;QACnD,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,MAAM,CAAC,eAAe,CAAC,aAAqB;QACjD,OAAO,IAAI,qBAAW,CAAC,cAAc,IAAI,aAAa,EAAE,CAAC;IAC3D,CAAC;IAED,gBAAgB;IAChB,IAAW,IAAI;QACb,OAAO,qBAAW,CAAC,cAAc,CAAC;IACpC,CAAC;IAED,gBAAgB;IAChB,IAAW,YAAY;QACrB,OAAO,iBAAiB,CAAC,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC/D,CAAC;IAED,sBAAsB;IACf,uBAAuB;QAC5B,MAAM,MAAM,GAAyB,IAAI,CAAC,MAAM;YAC9C,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB;YAChC,CAAC,CAAC,iDAAiD;gBACjD,2CAAoB,CAAC,KAAK,EAAE,CAAC,iBAAiB,+BAAqB,UAAU,CAAC,CAAC;QACnF,OAAO,MAAM,CAAC,WAAW,sCAAwB,CAAC,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC1F,CAAC;CACF;AA7BD,8CA6BC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport {\n  DeclarationReference,\n  Meaning,\n  Navigation\n} from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';\nimport { ApiItemKind } from '../items/ApiItem';\nimport { type IApiDeclaredItemOptions, ApiDeclaredItem } from '../items/ApiDeclaredItem';\nimport { type IApiParameterListMixinOptions, ApiParameterListMixin } from '../mixins/ApiParameterListMixin';\nimport { type IApiReleaseTagMixinOptions, ApiReleaseTagMixin } from '../mixins/ApiReleaseTagMixin';\nimport { type IApiReturnTypeMixinOptions, ApiReturnTypeMixin } from '../mixins/ApiReturnTypeMixin';\nimport { type IApiReadonlyMixinOptions, ApiReadonlyMixin } from '../mixins/ApiReadonlyMixin';\n\n/**\n * Constructor options for {@link ApiIndexSignature}.\n * @public\n */\nexport interface IApiIndexSignatureOptions\n  extends IApiParameterListMixinOptions,\n    IApiReleaseTagMixinOptions,\n    IApiReturnTypeMixinOptions,\n    IApiReadonlyMixinOptions,\n    IApiDeclaredItemOptions {}\n\n/**\n * Represents a TypeScript index signature.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.\n *\n * `ApiIndexSignature` represents a TypeScript declaration such as `[x: number]: number` in this example:\n *\n * ```ts\n * export interface INumberTable {\n *   // An index signature\n *   [value: number]: number;\n *\n *   // An overloaded index signature\n *   [name: string]: number;\n * }\n * ```\n *\n * @public\n */\nexport class ApiIndexSignature extends ApiParameterListMixin(\n  ApiReleaseTagMixin(ApiReturnTypeMixin(ApiReadonlyMixin(ApiDeclaredItem)))\n) {\n  public constructor(options: IApiIndexSignatureOptions) {\n    super(options);\n  }\n\n  public static getContainerKey(overloadIndex: number): string {\n    return `|${ApiItemKind.IndexSignature}|${overloadIndex}`;\n  }\n\n  /** @override */\n  public get kind(): ApiItemKind {\n    return ApiItemKind.IndexSignature;\n  }\n\n  /** @override */\n  public get containerKey(): string {\n    return ApiIndexSignature.getContainerKey(this.overloadIndex);\n  }\n\n  /** @beta @override */\n  public buildCanonicalReference(): DeclarationReference {\n    const parent: DeclarationReference = this.parent\n      ? this.parent.canonicalReference\n      : // .withMeaning() requires some kind of component\n        DeclarationReference.empty().addNavigationStep(Navigation.Members, '(parent)');\n    return parent.withMeaning(Meaning.IndexSignature).withOverloadIndex(this.overloadIndex);\n  }\n}\n"]}

node_modules/@microsoft/api-extractor-model/lib/model/ApiInterface.d.ts

@@ -0,0 +1,60 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { ApiItemContainerMixin, type IApiItemContainerMixinOptions, type IApiItemContainerJson } from '../mixins/ApiItemContainerMixin';
+import { ApiDeclaredItem, type IApiDeclaredItemOptions, type IApiDeclaredItemJson } from '../items/ApiDeclaredItem';
+import { type IApiReleaseTagMixinOptions, ApiReleaseTagMixin, type IApiReleaseTagMixinJson } from '../mixins/ApiReleaseTagMixin';
+import type { IExcerptTokenRange } from '../mixins/Excerpt';
+import { HeritageType } from './HeritageType';
+import { type IApiNameMixinOptions, ApiNameMixin, type IApiNameMixinJson } from '../mixins/ApiNameMixin';
+import { type IApiTypeParameterListMixinOptions, type IApiTypeParameterListMixinJson, ApiTypeParameterListMixin } from '../mixins/ApiTypeParameterListMixin';
+import type { DeserializerContext } from './DeserializerContext';
+import { type IApiExportedMixinJson, type IApiExportedMixinOptions, ApiExportedMixin } from '../mixins/ApiExportedMixin';
+/**
+ * Constructor options for {@link ApiInterface}.
+ * @public
+ */
+export interface IApiInterfaceOptions extends IApiItemContainerMixinOptions, IApiNameMixinOptions, IApiTypeParameterListMixinOptions, IApiReleaseTagMixinOptions, IApiDeclaredItemOptions, IApiExportedMixinOptions {
+    extendsTokenRanges: IExcerptTokenRange[];
+}
+export interface IApiInterfaceJson extends IApiItemContainerJson, IApiNameMixinJson, IApiTypeParameterListMixinJson, IApiReleaseTagMixinJson, IApiDeclaredItemJson, IApiExportedMixinJson {
+    extendsTokenRanges: IExcerptTokenRange[];
+}
+declare const ApiInterface_base: typeof ApiDeclaredItem & (new (...args: any[]) => ApiExportedMixin) & (new (...args: any[]) => ApiReleaseTagMixin) & (new (...args: any[]) => ApiTypeParameterListMixin) & (new (...args: any[]) => ApiNameMixin) & (new (...args: any[]) => ApiItemContainerMixin);
+/**
+ * Represents a TypeScript class declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiInterface` represents a TypeScript declaration such as this:
+ *
+ * ```ts
+ * export interface X extends Y {
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare class ApiInterface extends ApiInterface_base {
+    private readonly _extendsTypes;
+    constructor(options: IApiInterfaceOptions);
+    static getContainerKey(name: string): string;
+    /** @override */
+    static onDeserializeInto(options: Partial<IApiInterfaceOptions>, context: DeserializerContext, jsonObject: IApiInterfaceJson): void;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /**
+     * The list of base interfaces that this interface inherits from using the `extends` keyword.
+     */
+    get extendsTypes(): ReadonlyArray<HeritageType>;
+    /** @override */
+    serializeInto(jsonObject: Partial<IApiInterfaceJson>): void;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiInterface.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiInterface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiInterface.d.ts","sourceRoot":"","sources":["../../src/model/ApiInterface.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAIrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EACL,qBAAqB,EACrB,KAAK,6BAA6B,EAClC,KAAK,qBAAqB,EAC3B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,eAAe,EACf,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EAC1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,KAAK,0BAA0B,EAC/B,kBAAkB,EAClB,KAAK,uBAAuB,EAC7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,KAAK,oBAAoB,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AACzG,OAAO,EACL,KAAK,iCAAiC,EACtC,KAAK,8BAA8B,EACnC,yBAAyB,EAC1B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,gBAAgB,EACjB,MAAM,4BAA4B,CAAC;AAEpC;;;GAGG;AACH,MAAM,WAAW,oBACf,SAAQ,6BAA6B,EACnC,oBAAoB,EACpB,iCAAiC,EACjC,0BAA0B,EAC1B,uBAAuB,EACvB,wBAAwB;IAC1B,kBAAkB,EAAE,kBAAkB,EAAE,CAAC;CAC1C;AAED,MAAM,WAAW,iBACf,SAAQ,qBAAqB,EAC3B,iBAAiB,EACjB,8BAA8B,EAC9B,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB;IACvB,kBAAkB,EAAE,kBAAkB,EAAE,CAAC;CAC1C;;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,YAAa,SAAQ,iBAEjC;IACC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAsB;gBAEjC,OAAO,EAAE,oBAAoB;WAQlC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAInD,gBAAgB;WACF,iBAAiB,CAC7B,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC,EACtC,OAAO,EAAE,mBAAmB,EAC5B,UAAU,EAAE,iBAAiB,GAC5B,IAAI;IAMP,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED;;OAEG;IACH,IAAW,YAAY,IAAI,aAAa,CAAC,YAAY,CAAC,CAErD;IAED,gBAAgB;IACT,aAAa,CAAC,UAAU,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,IAAI;IAMlE,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAOvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiInterface.js

@@ -0,0 +1,77 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiInterface = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiItemContainerMixin_1 = require("../mixins/ApiItemContainerMixin");
+const ApiDeclaredItem_1 = require("../items/ApiDeclaredItem");
+const ApiReleaseTagMixin_1 = require("../mixins/ApiReleaseTagMixin");
+const HeritageType_1 = require("./HeritageType");
+const ApiNameMixin_1 = require("../mixins/ApiNameMixin");
+const ApiTypeParameterListMixin_1 = require("../mixins/ApiTypeParameterListMixin");
+const ApiExportedMixin_1 = require("../mixins/ApiExportedMixin");
+/**
+ * Represents a TypeScript class declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiInterface` represents a TypeScript declaration such as this:
+ *
+ * ```ts
+ * export interface X extends Y {
+ * }
+ * ```
+ *
+ * @public
+ */
+class ApiInterface extends (0, ApiItemContainerMixin_1.ApiItemContainerMixin)((0, ApiNameMixin_1.ApiNameMixin)((0, ApiTypeParameterListMixin_1.ApiTypeParameterListMixin)((0, ApiReleaseTagMixin_1.ApiReleaseTagMixin)((0, ApiExportedMixin_1.ApiExportedMixin)(ApiDeclaredItem_1.ApiDeclaredItem))))) {
+    constructor(options) {
+        super(options);
+        this._extendsTypes = [];
+        for (const extendsTokenRange of options.extendsTokenRanges) {
+            this._extendsTypes.push(new HeritageType_1.HeritageType(this.buildExcerpt(extendsTokenRange)));
+        }
+    }
+    static getContainerKey(name) {
+        return `${name}|${ApiItem_1.ApiItemKind.Interface}`;
+    }
+    /** @override */
+    static onDeserializeInto(options, context, jsonObject) {
+        super.onDeserializeInto(options, context, jsonObject);
+        options.extendsTokenRanges = jsonObject.extendsTokenRanges;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.Interface;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiInterface.getContainerKey(this.name);
+    }
+    /**
+     * The list of base interfaces that this interface inherits from using the `extends` keyword.
+     */
+    get extendsTypes() {
+        return this._extendsTypes;
+    }
+    /** @override */
+    serializeInto(jsonObject) {
+        super.serializeInto(jsonObject);
+        jsonObject.extendsTokenRanges = this.extendsTypes.map((x) => x.excerpt.tokenRange);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const nameComponent = DeclarationReference_1.DeclarationReference.parseComponent(this.name);
+        const navigation = this.isExported ? "." /* Navigation.Exports */ : "~" /* Navigation.Locals */;
+        return (this.parent ? this.parent.canonicalReference : DeclarationReference_1.DeclarationReference.empty())
+            .addNavigationStep(navigation, nameComponent)
+            .withMeaning("interface" /* Meaning.Interface */);
+    }
+}
+exports.ApiInterface = ApiInterface;
+//# sourceMappingURL=ApiInterface.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiMethod.d.ts

@@ -0,0 +1,52 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { ApiProtectedMixin, type IApiProtectedMixinOptions } from '../mixins/ApiProtectedMixin';
+import { ApiStaticMixin, type IApiStaticMixinOptions } from '../mixins/ApiStaticMixin';
+import { type IApiDeclaredItemOptions, ApiDeclaredItem } from '../items/ApiDeclaredItem';
+import { type IApiParameterListMixinOptions, ApiParameterListMixin } from '../mixins/ApiParameterListMixin';
+import { type IApiReleaseTagMixinOptions, ApiReleaseTagMixin } from '../mixins/ApiReleaseTagMixin';
+import { ApiReturnTypeMixin, type IApiReturnTypeMixinOptions } from '../mixins/ApiReturnTypeMixin';
+import { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';
+import { type IApiAbstractMixinOptions, ApiAbstractMixin } from '../mixins/ApiAbstractMixin';
+import { ApiTypeParameterListMixin, type IApiTypeParameterListMixinOptions } from '../mixins/ApiTypeParameterListMixin';
+import { ApiOptionalMixin, type IApiOptionalMixinOptions } from '../mixins/ApiOptionalMixin';
+/**
+ * Constructor options for {@link ApiMethod}.
+ * @public
+ */
+export interface IApiMethodOptions extends IApiNameMixinOptions, IApiAbstractMixinOptions, IApiOptionalMixinOptions, IApiParameterListMixinOptions, IApiProtectedMixinOptions, IApiReleaseTagMixinOptions, IApiReturnTypeMixinOptions, IApiStaticMixinOptions, IApiTypeParameterListMixinOptions, IApiDeclaredItemOptions {
+}
+declare const ApiMethod_base: typeof ApiDeclaredItem & (new (...args: any[]) => ApiTypeParameterListMixin) & (new (...args: any[]) => ApiStaticMixin) & (new (...args: any[]) => ApiReturnTypeMixin) & (new (...args: any[]) => ApiReleaseTagMixin) & (new (...args: any[]) => ApiProtectedMixin) & (new (...args: any[]) => ApiParameterListMixin) & (new (...args: any[]) => ApiOptionalMixin) & (new (...args: any[]) => ApiAbstractMixin) & (new (...args: any[]) => ApiNameMixin);
+/**
+ * Represents a TypeScript member function declaration that belongs to an `ApiClass`.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiMethod` represents a TypeScript declaration such as the `render` member function in this example:
+ *
+ * ```ts
+ * export class Widget {
+ *   public render(): void { }
+ * }
+ * ```
+ *
+ * Compare with {@link ApiMethodSignature}, which represents a method belonging to an interface.
+ * For example, a class method can be `static` but an interface method cannot.
+ *
+ * @public
+ */
+export declare class ApiMethod extends ApiMethod_base {
+    constructor(options: IApiMethodOptions);
+    static getContainerKey(name: string, isStatic: boolean, overloadIndex: number): string;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiMethod.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiMethod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiMethod.d.ts","sourceRoot":"","sources":["../../src/model/ApiMethod.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAIrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,KAAK,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAChG,OAAO,EAAE,cAAc,EAAE,KAAK,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AACvF,OAAO,EAAE,KAAK,uBAAuB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACzF,OAAO,EAAE,KAAK,6BAA6B,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC5G,OAAO,EAAE,KAAK,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,kBAAkB,EAAE,KAAK,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,KAAK,oBAAoB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,KAAK,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC7F,OAAO,EACL,yBAAyB,EACzB,KAAK,iCAAiC,EACvC,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,KAAK,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAE7F;;;GAGG;AACH,MAAM,WAAW,iBACf,SAAQ,oBAAoB,EAC1B,wBAAwB,EACxB,wBAAwB,EACxB,6BAA6B,EAC7B,yBAAyB,EACzB,0BAA0B,EAC1B,0BAA0B,EAC1B,sBAAsB,EACtB,iCAAiC,EACjC,uBAAuB;CAAG;;AAE9B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,SAAU,SAAQ,cAU9B;gBACoB,OAAO,EAAE,iBAAiB;WAI/B,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM;IAQ7F,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAOvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiMethod.js

@@ -0,0 +1,69 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiMethod = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiProtectedMixin_1 = require("../mixins/ApiProtectedMixin");
+const ApiStaticMixin_1 = require("../mixins/ApiStaticMixin");
+const ApiDeclaredItem_1 = require("../items/ApiDeclaredItem");
+const ApiParameterListMixin_1 = require("../mixins/ApiParameterListMixin");
+const ApiReleaseTagMixin_1 = require("../mixins/ApiReleaseTagMixin");
+const ApiReturnTypeMixin_1 = require("../mixins/ApiReturnTypeMixin");
+const ApiNameMixin_1 = require("../mixins/ApiNameMixin");
+const ApiAbstractMixin_1 = require("../mixins/ApiAbstractMixin");
+const ApiTypeParameterListMixin_1 = require("../mixins/ApiTypeParameterListMixin");
+const ApiOptionalMixin_1 = require("../mixins/ApiOptionalMixin");
+/**
+ * Represents a TypeScript member function declaration that belongs to an `ApiClass`.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiMethod` represents a TypeScript declaration such as the `render` member function in this example:
+ *
+ * ```ts
+ * export class Widget {
+ *   public render(): void { }
+ * }
+ * ```
+ *
+ * Compare with {@link ApiMethodSignature}, which represents a method belonging to an interface.
+ * For example, a class method can be `static` but an interface method cannot.
+ *
+ * @public
+ */
+class ApiMethod extends (0, ApiNameMixin_1.ApiNameMixin)((0, ApiAbstractMixin_1.ApiAbstractMixin)((0, ApiOptionalMixin_1.ApiOptionalMixin)((0, ApiParameterListMixin_1.ApiParameterListMixin)((0, ApiProtectedMixin_1.ApiProtectedMixin)((0, ApiReleaseTagMixin_1.ApiReleaseTagMixin)((0, ApiReturnTypeMixin_1.ApiReturnTypeMixin)((0, ApiStaticMixin_1.ApiStaticMixin)((0, ApiTypeParameterListMixin_1.ApiTypeParameterListMixin)(ApiDeclaredItem_1.ApiDeclaredItem))))))))) {
+    constructor(options) {
+        super(options);
+    }
+    static getContainerKey(name, isStatic, overloadIndex) {
+        if (isStatic) {
+            return `${name}|${ApiItem_1.ApiItemKind.Method}|static|${overloadIndex}`;
+        }
+        else {
+            return `${name}|${ApiItem_1.ApiItemKind.Method}|instance|${overloadIndex}`;
+        }
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.Method;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiMethod.getContainerKey(this.name, this.isStatic, this.overloadIndex);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const nameComponent = DeclarationReference_1.DeclarationReference.parseComponent(this.name);
+        return (this.parent ? this.parent.canonicalReference : DeclarationReference_1.DeclarationReference.empty())
+            .addNavigationStep(this.isStatic ? "." /* Navigation.Exports */ : "#" /* Navigation.Members */, nameComponent)
+            .withMeaning("member" /* Meaning.Member */)
+            .withOverloadIndex(this.overloadIndex);
+    }
+}
+exports.ApiMethod = ApiMethod;
+//# sourceMappingURL=ApiMethod.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiMethodSignature.d.ts

@@ -0,0 +1,46 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { ApiDeclaredItem, type IApiDeclaredItemOptions } from '../items/ApiDeclaredItem';
+import { ApiParameterListMixin, type IApiParameterListMixinOptions } from '../mixins/ApiParameterListMixin';
+import { ApiReleaseTagMixin, type IApiReleaseTagMixinOptions } from '../mixins/ApiReleaseTagMixin';
+import { type IApiReturnTypeMixinOptions, ApiReturnTypeMixin } from '../mixins/ApiReturnTypeMixin';
+import { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';
+import { type IApiTypeParameterListMixinOptions, ApiTypeParameterListMixin } from '../mixins/ApiTypeParameterListMixin';
+import { ApiOptionalMixin, type IApiOptionalMixinOptions } from '../mixins/ApiOptionalMixin';
+/** @public */
+export interface IApiMethodSignatureOptions extends IApiNameMixinOptions, IApiTypeParameterListMixinOptions, IApiParameterListMixinOptions, IApiReleaseTagMixinOptions, IApiReturnTypeMixinOptions, IApiOptionalMixinOptions, IApiDeclaredItemOptions {
+}
+declare const ApiMethodSignature_base: typeof ApiDeclaredItem & (new (...args: any[]) => ApiOptionalMixin) & (new (...args: any[]) => ApiReturnTypeMixin) & (new (...args: any[]) => ApiReleaseTagMixin) & (new (...args: any[]) => ApiParameterListMixin) & (new (...args: any[]) => ApiTypeParameterListMixin) & (new (...args: any[]) => ApiNameMixin);
+/**
+ * Represents a TypeScript member function declaration that belongs to an `ApiInterface`.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiMethodSignature` represents a TypeScript declaration such as the `render` member function in this example:
+ *
+ * ```ts
+ * export interface IWidget {
+ *   render(): void;
+ * }
+ * ```
+ *
+ * Compare with {@link ApiMethod}, which represents a method belonging to a class.
+ * For example, a class method can be `static` but an interface method cannot.
+ *
+ * @public
+ */
+export declare class ApiMethodSignature extends ApiMethodSignature_base {
+    constructor(options: IApiMethodSignatureOptions);
+    static getContainerKey(name: string, overloadIndex: number): string;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiMethodSignature.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiMethodSignature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiMethodSignature.d.ts","sourceRoot":"","sources":["../../src/model/ApiMethodSignature.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAIrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACzF,OAAO,EAAE,qBAAqB,EAAE,KAAK,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAC5G,OAAO,EAAE,kBAAkB,EAAE,KAAK,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,KAAK,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,KAAK,oBAAoB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EACL,KAAK,iCAAiC,EACtC,yBAAyB,EAC1B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,KAAK,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAE7F,cAAc;AACd,MAAM,WAAW,0BACf,SAAQ,oBAAoB,EAC1B,iCAAiC,EACjC,6BAA6B,EAC7B,0BAA0B,EAC1B,0BAA0B,EAC1B,wBAAwB,EACxB,uBAAuB;CAAG;;AAE9B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,kBAAmB,SAAQ,uBAIvC;gBACoB,OAAO,EAAE,0BAA0B;WAIxC,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM;IAI1E,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAOvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiMethodSignature.js

@@ -0,0 +1,61 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiMethodSignature = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiDeclaredItem_1 = require("../items/ApiDeclaredItem");
+const ApiParameterListMixin_1 = require("../mixins/ApiParameterListMixin");
+const ApiReleaseTagMixin_1 = require("../mixins/ApiReleaseTagMixin");
+const ApiReturnTypeMixin_1 = require("../mixins/ApiReturnTypeMixin");
+const ApiNameMixin_1 = require("../mixins/ApiNameMixin");
+const ApiTypeParameterListMixin_1 = require("../mixins/ApiTypeParameterListMixin");
+const ApiOptionalMixin_1 = require("../mixins/ApiOptionalMixin");
+/**
+ * Represents a TypeScript member function declaration that belongs to an `ApiInterface`.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiMethodSignature` represents a TypeScript declaration such as the `render` member function in this example:
+ *
+ * ```ts
+ * export interface IWidget {
+ *   render(): void;
+ * }
+ * ```
+ *
+ * Compare with {@link ApiMethod}, which represents a method belonging to a class.
+ * For example, a class method can be `static` but an interface method cannot.
+ *
+ * @public
+ */
+class ApiMethodSignature extends (0, ApiNameMixin_1.ApiNameMixin)((0, ApiTypeParameterListMixin_1.ApiTypeParameterListMixin)((0, ApiParameterListMixin_1.ApiParameterListMixin)((0, ApiReleaseTagMixin_1.ApiReleaseTagMixin)((0, ApiReturnTypeMixin_1.ApiReturnTypeMixin)((0, ApiOptionalMixin_1.ApiOptionalMixin)(ApiDeclaredItem_1.ApiDeclaredItem)))))) {
+    constructor(options) {
+        super(options);
+    }
+    static getContainerKey(name, overloadIndex) {
+        return `${name}|${ApiItem_1.ApiItemKind.MethodSignature}|${overloadIndex}`;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.MethodSignature;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiMethodSignature.getContainerKey(this.name, this.overloadIndex);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const nameComponent = DeclarationReference_1.DeclarationReference.parseComponent(this.name);
+        return (this.parent ? this.parent.canonicalReference : DeclarationReference_1.DeclarationReference.empty())
+            .addNavigationStep("#" /* Navigation.Members */, nameComponent)
+            .withMeaning("member" /* Meaning.Member */)
+            .withOverloadIndex(this.overloadIndex);
+    }
+}
+exports.ApiMethodSignature = ApiMethodSignature;
+//# sourceMappingURL=ApiMethodSignature.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiMethodSignature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiMethodSignature.js","sourceRoot":"","sources":["../../src/model/ApiMethodSignature.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,kGAKiE;AACjE,8CAA+C;AAC/C,8DAAyF;AACzF,2EAA4G;AAC5G,qEAAmG;AACnG,qEAAmG;AACnG,yDAAiF;AACjF,mFAG6C;AAC7C,iEAA6F;AAY7F;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAa,kBAAmB,SAAQ,IAAA,2BAAY,EAClD,IAAA,qDAAyB,EACvB,IAAA,6CAAqB,EAAC,IAAA,uCAAkB,EAAC,IAAA,uCAAkB,EAAC,IAAA,mCAAgB,EAAC,iCAAe,CAAC,CAAC,CAAC,CAAC,CACjG,CACF;IACC,YAAmB,OAAmC;QACpD,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,MAAM,CAAC,eAAe,CAAC,IAAY,EAAE,aAAqB;QAC/D,OAAO,GAAG,IAAI,IAAI,qBAAW,CAAC,eAAe,IAAI,aAAa,EAAE,CAAC;IACnE,CAAC;IAED,gBAAgB;IAChB,IAAW,IAAI;QACb,OAAO,qBAAW,CAAC,eAAe,CAAC;IACrC,CAAC;IAED,gBAAgB;IAChB,IAAW,YAAY;QACrB,OAAO,kBAAkB,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;IAC3E,CAAC;IAED,sBAAsB;IACf,uBAAuB;QAC5B,MAAM,aAAa,GAAc,2CAAoB,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChF,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,2CAAoB,CAAC,KAAK,EAAE,CAAC;aACjF,iBAAiB,+BAAqB,aAAa,CAAC;aACpD,WAAW,+BAAgB;aAC3B,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC3C,CAAC;CACF;AA/BD,gDA+BC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport {\n  DeclarationReference,\n  Meaning,\n  Navigation,\n  type Component\n} from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';\nimport { ApiItemKind } from '../items/ApiItem';\nimport { ApiDeclaredItem, type IApiDeclaredItemOptions } from '../items/ApiDeclaredItem';\nimport { ApiParameterListMixin, type IApiParameterListMixinOptions } from '../mixins/ApiParameterListMixin';\nimport { ApiReleaseTagMixin, type IApiReleaseTagMixinOptions } from '../mixins/ApiReleaseTagMixin';\nimport { type IApiReturnTypeMixinOptions, ApiReturnTypeMixin } from '../mixins/ApiReturnTypeMixin';\nimport { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';\nimport {\n  type IApiTypeParameterListMixinOptions,\n  ApiTypeParameterListMixin\n} from '../mixins/ApiTypeParameterListMixin';\nimport { ApiOptionalMixin, type IApiOptionalMixinOptions } from '../mixins/ApiOptionalMixin';\n\n/** @public */\nexport interface IApiMethodSignatureOptions\n  extends IApiNameMixinOptions,\n    IApiTypeParameterListMixinOptions,\n    IApiParameterListMixinOptions,\n    IApiReleaseTagMixinOptions,\n    IApiReturnTypeMixinOptions,\n    IApiOptionalMixinOptions,\n    IApiDeclaredItemOptions {}\n\n/**\n * Represents a TypeScript member function declaration that belongs to an `ApiInterface`.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.\n *\n * `ApiMethodSignature` represents a TypeScript declaration such as the `render` member function in this example:\n *\n * ```ts\n * export interface IWidget {\n *   render(): void;\n * }\n * ```\n *\n * Compare with {@link ApiMethod}, which represents a method belonging to a class.\n * For example, a class method can be `static` but an interface method cannot.\n *\n * @public\n */\nexport class ApiMethodSignature extends ApiNameMixin(\n  ApiTypeParameterListMixin(\n    ApiParameterListMixin(ApiReleaseTagMixin(ApiReturnTypeMixin(ApiOptionalMixin(ApiDeclaredItem))))\n  )\n) {\n  public constructor(options: IApiMethodSignatureOptions) {\n    super(options);\n  }\n\n  public static getContainerKey(name: string, overloadIndex: number): string {\n    return `${name}|${ApiItemKind.MethodSignature}|${overloadIndex}`;\n  }\n\n  /** @override */\n  public get kind(): ApiItemKind {\n    return ApiItemKind.MethodSignature;\n  }\n\n  /** @override */\n  public get containerKey(): string {\n    return ApiMethodSignature.getContainerKey(this.name, this.overloadIndex);\n  }\n\n  /** @beta @override */\n  public buildCanonicalReference(): DeclarationReference {\n    const nameComponent: Component = DeclarationReference.parseComponent(this.name);\n    return (this.parent ? this.parent.canonicalReference : DeclarationReference.empty())\n      .addNavigationStep(Navigation.Members, nameComponent)\n      .withMeaning(Meaning.Member)\n      .withOverloadIndex(this.overloadIndex);\n  }\n}\n"]}

node_modules/@microsoft/api-extractor-model/lib/model/ApiModel.d.ts

@@ -0,0 +1,77 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItem, ApiItemKind } from '../items/ApiItem';
+import { ApiItemContainerMixin } from '../mixins/ApiItemContainerMixin';
+import { ApiPackage } from './ApiPackage';
+import { type IResolveDeclarationReferenceResult } from './ModelReferenceResolver';
+import { DocDeclarationReference } from '@microsoft/tsdoc';
+declare const ApiModel_base: typeof ApiItem & (new (...args: any[]) => ApiItemContainerMixin);
+/**
+ * A serializable representation of a collection of API declarations.
+ *
+ * @remarks
+ *
+ * An `ApiModel` represents a collection of API declarations that can be serialized to disk.  It captures all the
+ * important information needed to generate documentation, without any reliance on the TypeScript compiler engine.
+ *
+ * An `ApiModel` acts as the root of a tree of objects that all inherit from the `ApiItem` base class.
+ * The tree children are determined by the {@link (ApiItemContainerMixin:interface)} mixin base class.  The model
+ * contains packages.  Packages have an entry point (today, only one).  And the entry point can contain various types
+ * of API declarations.  The container relationships might look like this:
+ *
+ * ```
+ * Things that can contain other things:
+ *
+ * - ApiModel
+ *   - ApiPackage
+ *     - ApiEntryPoint
+ *       - ApiClass
+ *         - ApiMethod
+ *         - ApiProperty
+ *       - ApiEnum
+ *         - ApiEnumMember
+ *       - ApiInterface
+ *         - ApiMethodSignature
+ *         - ApiPropertySignature
+ *       - ApiNamespace
+ *         - (ApiClass, ApiEnum, ApiInterace, ...)
+ *
+ * ```
+ *
+ * Normally, API Extractor writes an .api.json file to disk for each project that it builds.  Then, a tool like
+ * API Documenter can load the various `ApiPackage` objects into a single `ApiModel` and process them as a group.
+ * This is useful because compilation generally occurs separately (e.g. because projects may reside in different
+ * Git repos, or because they build with different TypeScript compiler configurations that may be incompatible),
+ * whereas API Documenter cannot detect broken hyperlinks without seeing the entire documentation set.
+ *
+ * @public
+ */
+export declare class ApiModel extends ApiModel_base {
+    private readonly _resolver;
+    private _packagesByName;
+    private _apiItemsByCanonicalReference;
+    constructor();
+    loadPackage(apiJsonFilename: string): ApiPackage;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    get packages(): ReadonlyArray<ApiPackage>;
+    /** @override */
+    addMember(member: ApiPackage): void;
+    /**
+     * Efficiently finds a package by the NPM package name.
+     *
+     * @remarks
+     *
+     * If the NPM scope is omitted in the package name, it will still be found provided that it is an unambiguous match.
+     * For example, it's often convenient to write `{@link node-core-library#JsonFile}` instead of
+     * `{@link @rushstack/node-core-library#JsonFile}`.
+     */
+    tryGetPackageByName(packageName: string): ApiPackage | undefined;
+    resolveDeclarationReference(declarationReference: DocDeclarationReference | DeclarationReference, contextApiItem: ApiItem | undefined): IResolveDeclarationReferenceResult;
+    private _initApiItemsRecursive;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiModel.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiModel.d.ts","sourceRoot":"","sources":["../../src/model/ApiModel.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAE,MAAM,yDAAyD,CAAC;AAC/F,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,EAA0B,KAAK,kCAAkC,EAAE,MAAM,0BAA0B,CAAC;AAC3G,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qBAAa,QAAS,SAAQ,aAA8B;IAC1D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyB;IAEnD,OAAO,CAAC,eAAe,CAAkD;IACzE,OAAO,CAAC,6BAA6B,CAA+C;;IAO7E,WAAW,CAAC,eAAe,EAAE,MAAM,GAAG,UAAU;IAMvD,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,IAAW,QAAQ,IAAI,aAAa,CAAC,UAAU,CAAC,CAE/C;IAED,gBAAgB;IACT,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAS1C;;;;;;;;OAQG;IACI,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAsChE,2BAA2B,CAChC,oBAAoB,EAAE,uBAAuB,GAAG,oBAAoB,EACpE,cAAc,EAAE,OAAO,GAAG,SAAS,GAClC,kCAAkC;IAwCrC,OAAO,CAAC,sBAAsB;IAa9B,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAGvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiModel.js

@@ -0,0 +1,174 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiModel = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiItemContainerMixin_1 = require("../mixins/ApiItemContainerMixin");
+const ApiPackage_1 = require("./ApiPackage");
+const node_core_library_1 = require("@rushstack/node-core-library");
+const ModelReferenceResolver_1 = require("./ModelReferenceResolver");
+const tsdoc_1 = require("@microsoft/tsdoc");
+/**
+ * A serializable representation of a collection of API declarations.
+ *
+ * @remarks
+ *
+ * An `ApiModel` represents a collection of API declarations that can be serialized to disk.  It captures all the
+ * important information needed to generate documentation, without any reliance on the TypeScript compiler engine.
+ *
+ * An `ApiModel` acts as the root of a tree of objects that all inherit from the `ApiItem` base class.
+ * The tree children are determined by the {@link (ApiItemContainerMixin:interface)} mixin base class.  The model
+ * contains packages.  Packages have an entry point (today, only one).  And the entry point can contain various types
+ * of API declarations.  The container relationships might look like this:
+ *
+ * ```
+ * Things that can contain other things:
+ *
+ * - ApiModel
+ *   - ApiPackage
+ *     - ApiEntryPoint
+ *       - ApiClass
+ *         - ApiMethod
+ *         - ApiProperty
+ *       - ApiEnum
+ *         - ApiEnumMember
+ *       - ApiInterface
+ *         - ApiMethodSignature
+ *         - ApiPropertySignature
+ *       - ApiNamespace
+ *         - (ApiClass, ApiEnum, ApiInterace, ...)
+ *
+ * ```
+ *
+ * Normally, API Extractor writes an .api.json file to disk for each project that it builds.  Then, a tool like
+ * API Documenter can load the various `ApiPackage` objects into a single `ApiModel` and process them as a group.
+ * This is useful because compilation generally occurs separately (e.g. because projects may reside in different
+ * Git repos, or because they build with different TypeScript compiler configurations that may be incompatible),
+ * whereas API Documenter cannot detect broken hyperlinks without seeing the entire documentation set.
+ *
+ * @public
+ */
+class ApiModel extends (0, ApiItemContainerMixin_1.ApiItemContainerMixin)(ApiItem_1.ApiItem) {
+    constructor() {
+        super({});
+        this._packagesByName = undefined;
+        this._apiItemsByCanonicalReference = undefined;
+        this._resolver = new ModelReferenceResolver_1.ModelReferenceResolver(this);
+    }
+    loadPackage(apiJsonFilename) {
+        const apiPackage = ApiPackage_1.ApiPackage.loadFromJsonFile(apiJsonFilename);
+        this.addMember(apiPackage);
+        return apiPackage;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.Model;
+    }
+    /** @override */
+    get containerKey() {
+        return '';
+    }
+    get packages() {
+        return this.members;
+    }
+    /** @override */
+    addMember(member) {
+        if (member.kind !== ApiItem_1.ApiItemKind.Package) {
+            throw new Error('Only items of type ApiPackage may be added to an ApiModel');
+        }
+        super.addMember(member);
+        this._packagesByName = undefined; // invalidate the cache
+        this._apiItemsByCanonicalReference = undefined; // invalidate the cache
+    }
+    /**
+     * Efficiently finds a package by the NPM package name.
+     *
+     * @remarks
+     *
+     * If the NPM scope is omitted in the package name, it will still be found provided that it is an unambiguous match.
+     * For example, it's often convenient to write `{@link node-core-library#JsonFile}` instead of
+     * `{@link @rushstack/node-core-library#JsonFile}`.
+     */
+    tryGetPackageByName(packageName) {
+        // Build the lookup on demand
+        if (this._packagesByName === undefined) {
+            this._packagesByName = new Map();
+            const unscopedMap = new Map();
+            for (const apiPackage of this.packages) {
+                if (this._packagesByName.get(apiPackage.name)) {
+                    // This should not happen
+                    throw new Error(`The model contains multiple packages with the name ${apiPackage.name}`);
+                }
+                this._packagesByName.set(apiPackage.name, apiPackage);
+                const unscopedName = node_core_library_1.PackageName.parse(apiPackage.name).unscopedName;
+                if (unscopedMap.has(unscopedName)) {
+                    // If another package has the same unscoped name, then we won't register it
+                    unscopedMap.set(unscopedName, undefined);
+                }
+                else {
+                    unscopedMap.set(unscopedName, apiPackage);
+                }
+            }
+            for (const [unscopedName, apiPackage] of unscopedMap) {
+                if (apiPackage) {
+                    if (!this._packagesByName.has(unscopedName)) {
+                        // If the unscoped name is unambiguous, then we can also use it as a lookup
+                        this._packagesByName.set(unscopedName, apiPackage);
+                    }
+                }
+            }
+        }
+        return this._packagesByName.get(packageName);
+    }
+    resolveDeclarationReference(declarationReference, contextApiItem) {
+        if (declarationReference instanceof tsdoc_1.DocDeclarationReference) {
+            return this._resolver.resolve(declarationReference, contextApiItem);
+        }
+        else if (declarationReference instanceof DeclarationReference_1.DeclarationReference) {
+            // use this._apiItemsByCanonicalReference to look up ApiItem
+            // Build the lookup on demand
+            if (!this._apiItemsByCanonicalReference) {
+                this._apiItemsByCanonicalReference = new Map();
+                for (const apiPackage of this.packages) {
+                    this._initApiItemsRecursive(apiPackage, this._apiItemsByCanonicalReference);
+                }
+            }
+            const result = {
+                resolvedApiItem: undefined,
+                errorMessage: undefined
+            };
+            const apiItem = this._apiItemsByCanonicalReference.get(declarationReference.toString());
+            if (!apiItem) {
+                result.errorMessage = `${declarationReference.toString()} can not be located`;
+            }
+            else {
+                result.resolvedApiItem = apiItem;
+            }
+            return result;
+        }
+        else {
+            // NOTE: The "instanceof DeclarationReference" test assumes a specific version of the @microsoft/tsdoc package.
+            throw new Error('The "declarationReference" parameter must be an instance of' +
+                ' DocDeclarationReference or DeclarationReference');
+        }
+    }
+    _initApiItemsRecursive(apiItem, apiItemsByCanonicalReference) {
+        if (apiItem.canonicalReference && !apiItem.canonicalReference.isEmpty) {
+            apiItemsByCanonicalReference.set(apiItem.canonicalReference.toString(), apiItem);
+        }
+        // Recurse container members
+        if (ApiItemContainerMixin_1.ApiItemContainerMixin.isBaseClassOf(apiItem)) {
+            for (const apiMember of apiItem.members) {
+                this._initApiItemsRecursive(apiMember, apiItemsByCanonicalReference);
+            }
+        }
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        return DeclarationReference_1.DeclarationReference.empty();
+    }
+}
+exports.ApiModel = ApiModel;
+//# sourceMappingURL=ApiModel.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiNamespace.d.ts

@@ -0,0 +1,48 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { ApiItemContainerMixin, type IApiItemContainerMixinOptions } from '../mixins/ApiItemContainerMixin';
+import { type IApiDeclaredItemOptions, ApiDeclaredItem } from '../items/ApiDeclaredItem';
+import { ApiReleaseTagMixin, type IApiReleaseTagMixinOptions } from '../mixins/ApiReleaseTagMixin';
+import { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';
+import { type IApiExportedMixinOptions, ApiExportedMixin } from '../mixins/ApiExportedMixin';
+/**
+ * Constructor options for {@link ApiClass}.
+ * @public
+ */
+export interface IApiNamespaceOptions extends IApiItemContainerMixinOptions, IApiNameMixinOptions, IApiReleaseTagMixinOptions, IApiDeclaredItemOptions, IApiExportedMixinOptions {
+}
+declare const ApiNamespace_base: typeof ApiDeclaredItem & (new (...args: any[]) => ApiExportedMixin) & (new (...args: any[]) => ApiReleaseTagMixin) & (new (...args: any[]) => ApiNameMixin) & (new (...args: any[]) => ApiItemContainerMixin);
+/**
+ * Represents a TypeScript namespace declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiNamespace` represents a TypeScript declaration such `X` or `Y` in this example:
+ *
+ * ```ts
+ * export namespace X {
+ *   export namespace Y {
+ *     export interface IWidget {
+ *       render(): void;
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare class ApiNamespace extends ApiNamespace_base {
+    constructor(options: IApiNamespaceOptions);
+    static getContainerKey(name: string): string;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiNamespace.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiNamespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiNamespace.d.ts","sourceRoot":"","sources":["../../src/model/ApiNamespace.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAIrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,KAAK,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAC5G,OAAO,EAAE,KAAK,uBAAuB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACzF,OAAO,EAAE,kBAAkB,EAAE,KAAK,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,KAAK,oBAAoB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,KAAK,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAE7F;;;GAGG;AACH,MAAM,WAAW,oBACf,SAAQ,6BAA6B,EACnC,oBAAoB,EACpB,0BAA0B,EAC1B,uBAAuB,EACvB,wBAAwB;CAAG;;AAE/B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,YAAa,SAAQ,iBAEjC;gBACoB,OAAO,EAAE,oBAAoB;WAIlC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAInD,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAOvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiNamespace.js

@@ -0,0 +1,60 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiNamespace = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiItemContainerMixin_1 = require("../mixins/ApiItemContainerMixin");
+const ApiDeclaredItem_1 = require("../items/ApiDeclaredItem");
+const ApiReleaseTagMixin_1 = require("../mixins/ApiReleaseTagMixin");
+const ApiNameMixin_1 = require("../mixins/ApiNameMixin");
+const ApiExportedMixin_1 = require("../mixins/ApiExportedMixin");
+/**
+ * Represents a TypeScript namespace declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiNamespace` represents a TypeScript declaration such `X` or `Y` in this example:
+ *
+ * ```ts
+ * export namespace X {
+ *   export namespace Y {
+ *     export interface IWidget {
+ *       render(): void;
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @public
+ */
+class ApiNamespace extends (0, ApiItemContainerMixin_1.ApiItemContainerMixin)((0, ApiNameMixin_1.ApiNameMixin)((0, ApiReleaseTagMixin_1.ApiReleaseTagMixin)((0, ApiExportedMixin_1.ApiExportedMixin)(ApiDeclaredItem_1.ApiDeclaredItem)))) {
+    constructor(options) {
+        super(options);
+    }
+    static getContainerKey(name) {
+        return `${name}|${ApiItem_1.ApiItemKind.Namespace}`;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.Namespace;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiNamespace.getContainerKey(this.name);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const nameComponent = DeclarationReference_1.DeclarationReference.parseComponent(this.name);
+        const navigation = this.isExported ? "." /* Navigation.Exports */ : "~" /* Navigation.Locals */;
+        return (this.parent ? this.parent.canonicalReference : DeclarationReference_1.DeclarationReference.empty())
+            .addNavigationStep(navigation, nameComponent)
+            .withMeaning("namespace" /* Meaning.Namespace */);
+    }
+}
+exports.ApiNamespace = ApiNamespace;
+//# sourceMappingURL=ApiNamespace.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiNamespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiNamespace.js","sourceRoot":"","sources":["../../src/model/ApiNamespace.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,kGAKiE;AACjE,8CAA+C;AAC/C,2EAA4G;AAC5G,8DAAyF;AACzF,qEAAmG;AACnG,yDAAiF;AACjF,iEAA6F;AAa7F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,YAAa,SAAQ,IAAA,6CAAqB,EACrD,IAAA,2BAAY,EAAC,IAAA,uCAAkB,EAAC,IAAA,mCAAgB,EAAC,iCAAe,CAAC,CAAC,CAAC,CACpE;IACC,YAAmB,OAA6B;QAC9C,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,MAAM,CAAC,eAAe,CAAC,IAAY;QACxC,OAAO,GAAG,IAAI,IAAI,qBAAW,CAAC,SAAS,EAAE,CAAC;IAC5C,CAAC;IAED,gBAAgB;IAChB,IAAW,IAAI;QACb,OAAO,qBAAW,CAAC,SAAS,CAAC;IAC/B,CAAC;IAED,gBAAgB;IAChB,IAAW,YAAY;QACrB,OAAO,YAAY,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACjD,CAAC;IAED,sBAAsB;IACf,uBAAuB;QAC5B,MAAM,aAAa,GAAc,2CAAoB,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChF,MAAM,UAAU,GAAe,IAAI,CAAC,UAAU,CAAC,CAAC,8BAAoB,CAAC,4BAAkB,CAAC;QACxF,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,2CAAoB,CAAC,KAAK,EAAE,CAAC;aACjF,iBAAiB,CAAC,UAAU,EAAE,aAAa,CAAC;aAC5C,WAAW,qCAAmB,CAAC;IACpC,CAAC;CACF;AA7BD,oCA6BC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport {\n  DeclarationReference,\n  Meaning,\n  Navigation,\n  type Component\n} from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';\nimport { ApiItemKind } from '../items/ApiItem';\nimport { ApiItemContainerMixin, type IApiItemContainerMixinOptions } from '../mixins/ApiItemContainerMixin';\nimport { type IApiDeclaredItemOptions, ApiDeclaredItem } from '../items/ApiDeclaredItem';\nimport { ApiReleaseTagMixin, type IApiReleaseTagMixinOptions } from '../mixins/ApiReleaseTagMixin';\nimport { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';\nimport { type IApiExportedMixinOptions, ApiExportedMixin } from '../mixins/ApiExportedMixin';\n\n/**\n * Constructor options for {@link ApiClass}.\n * @public\n */\nexport interface IApiNamespaceOptions\n  extends IApiItemContainerMixinOptions,\n    IApiNameMixinOptions,\n    IApiReleaseTagMixinOptions,\n    IApiDeclaredItemOptions,\n    IApiExportedMixinOptions {}\n\n/**\n * Represents a TypeScript namespace declaration.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.\n *\n * `ApiNamespace` represents a TypeScript declaration such `X` or `Y` in this example:\n *\n * ```ts\n * export namespace X {\n *   export namespace Y {\n *     export interface IWidget {\n *       render(): void;\n *     }\n *   }\n * }\n * ```\n *\n * @public\n */\nexport class ApiNamespace extends ApiItemContainerMixin(\n  ApiNameMixin(ApiReleaseTagMixin(ApiExportedMixin(ApiDeclaredItem)))\n) {\n  public constructor(options: IApiNamespaceOptions) {\n    super(options);\n  }\n\n  public static getContainerKey(name: string): string {\n    return `${name}|${ApiItemKind.Namespace}`;\n  }\n\n  /** @override */\n  public get kind(): ApiItemKind {\n    return ApiItemKind.Namespace;\n  }\n\n  /** @override */\n  public get containerKey(): string {\n    return ApiNamespace.getContainerKey(this.name);\n  }\n\n  /** @beta @override */\n  public buildCanonicalReference(): DeclarationReference {\n    const nameComponent: Component = DeclarationReference.parseComponent(this.name);\n    const navigation: Navigation = this.isExported ? Navigation.Exports : Navigation.Locals;\n    return (this.parent ? this.parent.canonicalReference : DeclarationReference.empty())\n      .addNavigationStep(navigation, nameComponent)\n      .withMeaning(Meaning.Namespace);\n  }\n}\n"]}

node_modules/@microsoft/api-extractor-model/lib/model/ApiPackage.d.ts

@@ -0,0 +1,137 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind, type IApiItemJson } from '../items/ApiItem';
+import { ApiItemContainerMixin, type IApiItemContainerMixinOptions } from '../mixins/ApiItemContainerMixin';
+import { type IJsonFileSaveOptions, type JsonObject } from '@rushstack/node-core-library';
+import { ApiDocumentedItem, type IApiDocumentedItemOptions } from '../items/ApiDocumentedItem';
+import type { ApiEntryPoint } from './ApiEntryPoint';
+import { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';
+import { DeserializerContext, ApiJsonSchemaVersion } from './DeserializerContext';
+import { TSDocConfiguration } from '@microsoft/tsdoc';
+/**
+ * Constructor options for {@link ApiPackage}.
+ * @public
+ */
+export interface IApiPackageOptions extends IApiItemContainerMixinOptions, IApiNameMixinOptions, IApiDocumentedItemOptions {
+    tsdocConfiguration: TSDocConfiguration;
+    projectFolderUrl?: string;
+}
+export interface IApiPackageMetadataJson {
+    /**
+     * The NPM package name for the tool that wrote the *.api.json file.
+     * For informational purposes only.
+     */
+    toolPackage: string;
+    /**
+     * The NPM package version for the tool that wrote the *.api.json file.
+     * For informational purposes only.
+     */
+    toolVersion: string;
+    /**
+     * The schema version for the .api.json file format.  Used for determining whether the file format is
+     * supported, and for backwards compatibility.
+     */
+    schemaVersion: ApiJsonSchemaVersion;
+    /**
+     * To support forwards compatibility, the `oldestForwardsCompatibleVersion` field tracks the oldest schema version
+     * whose corresponding deserializer could safely load this file.
+     *
+     * @remarks
+     * Normally api-extractor-model should refuse to load a schema version that is newer than the latest version
+     * that its deserializer understands.  However, sometimes a schema change may merely introduce some new fields
+     * without modifying or removing any existing fields.  In this case, an older api-extractor-model library can
+     * safely deserialize the newer version (by ignoring the extra fields that it doesn't recognize).  The newer
+     * serializer can use this field to communicate that.
+     *
+     * If present, the `oldestForwardsCompatibleVersion` must be less than or equal to
+     * `IApiPackageMetadataJson.schemaVersion`.
+     */
+    oldestForwardsCompatibleVersion?: ApiJsonSchemaVersion;
+    /**
+     * The TSDoc configuration that was used when analyzing the API for this package.
+     *
+     * @remarks
+     *
+     * The structure of this objet is defined by the `@microsoft/tsdoc-config` library.
+     * Normally this configuration is loaded from the project's tsdoc.json file.  It is stored
+     * in the .api.json file so that doc comments can be parsed accurately when loading the file.
+     */
+    tsdocConfig: JsonObject;
+}
+export interface IApiPackageJson extends IApiItemJson {
+    /**
+     * A file header that stores metadata about the tool that wrote the *.api.json file.
+     */
+    metadata: IApiPackageMetadataJson;
+    /**
+     * The base URL where the project's source code can be viewed on a website such as GitHub or
+     * Azure DevOps. This URL path corresponds to the `<projectFolder>` path on disk. Provided via the
+     * `api-extractor.json` config.
+     */
+    projectFolderUrl?: string;
+}
+/**
+ * Options for {@link ApiPackage.saveToJsonFile}.
+ * @public
+ */
+export interface IApiPackageSaveOptions extends IJsonFileSaveOptions {
+    /**
+     * Optionally specifies a value for the "toolPackage" field in the output .api.json data file;
+     * otherwise, the value will be "api-extractor-model".
+     */
+    toolPackage?: string;
+    /**
+     * Optionally specifies a value for the "toolVersion" field in the output .api.json data file;
+     * otherwise, the value will be the current version of the api-extractor-model package.
+     */
+    toolVersion?: string;
+    /**
+     * Set to true only when invoking API Extractor's test harness.
+     *
+     * @remarks
+     * When `testMode` is true, the `toolVersion` field in the .api.json file is assigned an empty string
+     * to prevent spurious diffs in output files tracked for tests.
+     */
+    testMode?: boolean;
+}
+declare const ApiPackage_base: typeof ApiDocumentedItem & (new (...args: any[]) => ApiNameMixin) & (new (...args: any[]) => ApiItemContainerMixin);
+/**
+ * Represents an NPM package containing API declarations.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * @public
+ */
+export declare class ApiPackage extends ApiPackage_base {
+    private readonly _tsdocConfiguration;
+    private readonly _projectFolderUrl?;
+    constructor(options: IApiPackageOptions);
+    /** @override */
+    static onDeserializeInto(options: Partial<IApiPackageOptions>, context: DeserializerContext, jsonObject: IApiPackageJson): void;
+    static loadFromJsonFile(apiJsonFilename: string): ApiPackage;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    get entryPoints(): ReadonlyArray<ApiEntryPoint>;
+    /**
+     * The TSDoc configuration that was used when analyzing the API for this package.
+     *
+     * @remarks
+     *
+     * Normally this configuration is loaded from the project's tsdoc.json file.  It is stored
+     * in the .api.json file so that doc comments can be parsed accurately when loading the file.
+     */
+    get tsdocConfiguration(): TSDocConfiguration;
+    get projectFolderUrl(): string | undefined;
+    /** @override */
+    addMember(member: ApiEntryPoint): void;
+    findEntryPointsByPath(importPath: string): ReadonlyArray<ApiEntryPoint>;
+    saveToJsonFile(apiJsonFilename: string, options?: IApiPackageSaveOptions): void;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiPackage.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiPackage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiPackage.d.ts","sourceRoot":"","sources":["../../src/model/ApiPackage.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAE,MAAM,yDAAyD,CAAC;AAC/F,OAAO,EAAW,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,KAAK,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAC5G,OAAO,EAEL,KAAK,oBAAoB,EAGzB,KAAK,UAAU,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,iBAAiB,EAAE,KAAK,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAC/F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,KAAK,oBAAoB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAGtD;;;GAGG;AACH,MAAM,WAAW,kBACf,SAAQ,6BAA6B,EACnC,oBAAoB,EACpB,yBAAyB;IAC3B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,aAAa,EAAE,oBAAoB,CAAC;IAEpC;;;;;;;;;;;;;OAaG;IACH,+BAA+B,CAAC,EAAE,oBAAoB,CAAC;IAEvD;;;;;;;;OAQG;IACH,WAAW,EAAE,UAAU,CAAC;CACzB;AAED,MAAM,WAAW,eAAgB,SAAQ,YAAY;IACnD;;OAEG;IACH,QAAQ,EAAE,uBAAuB,CAAC;IAElC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAuB,SAAQ,oBAAoB;IAClE;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;;AAED;;;;;;;;;GASG;AACH,qBAAa,UAAW,SAAQ,eAAsD;IACpF,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;IACzD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAS;gBAEzB,OAAO,EAAE,kBAAkB;IAO9C,gBAAgB;WACF,iBAAiB,CAC7B,OAAO,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACpC,OAAO,EAAE,mBAAmB,EAC5B,UAAU,EAAE,eAAe,GAC1B,IAAI;WAMO,gBAAgB,CAAC,eAAe,EAAE,MAAM,GAAG,UAAU;IAwEnE,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAGhC;IAED,IAAW,WAAW,IAAI,aAAa,CAAC,aAAa,CAAC,CAErD;IAED;;;;;;;OAOG;IACH,IAAW,kBAAkB,IAAI,kBAAkB,CAElD;IAED,IAAW,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAEhD;IAED,gBAAgB;IACT,SAAS,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAOtC,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa,CAAC,aAAa,CAAC;IAIvE,cAAc,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,IAAI;IA8BtF,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAGvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiPackage.js

@@ -0,0 +1,152 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiPackage = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiItemContainerMixin_1 = require("../mixins/ApiItemContainerMixin");
+const node_core_library_1 = require("@rushstack/node-core-library");
+const ApiDocumentedItem_1 = require("../items/ApiDocumentedItem");
+const ApiNameMixin_1 = require("../mixins/ApiNameMixin");
+const DeserializerContext_1 = require("./DeserializerContext");
+const tsdoc_1 = require("@microsoft/tsdoc");
+const tsdoc_config_1 = require("@microsoft/tsdoc-config");
+/**
+ * Represents an NPM package containing API declarations.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * @public
+ */
+class ApiPackage extends (0, ApiItemContainerMixin_1.ApiItemContainerMixin)((0, ApiNameMixin_1.ApiNameMixin)(ApiDocumentedItem_1.ApiDocumentedItem)) {
+    constructor(options) {
+        super(options);
+        this._tsdocConfiguration = options.tsdocConfiguration;
+        this._projectFolderUrl = options.projectFolderUrl;
+    }
+    /** @override */
+    static onDeserializeInto(options, context, jsonObject) {
+        super.onDeserializeInto(options, context, jsonObject);
+        options.projectFolderUrl = jsonObject.projectFolderUrl;
+    }
+    static loadFromJsonFile(apiJsonFilename) {
+        const jsonObject = node_core_library_1.JsonFile.load(apiJsonFilename);
+        if (!jsonObject || !jsonObject.metadata || typeof jsonObject.metadata.schemaVersion !== 'number') {
+            throw new Error(`Error loading ${apiJsonFilename}:` +
+                `\nThe file format is not recognized; the "metadata.schemaVersion" field is missing or invalid`);
+        }
+        const schemaVersion = jsonObject.metadata.schemaVersion;
+        if (schemaVersion < DeserializerContext_1.ApiJsonSchemaVersion.OLDEST_SUPPORTED) {
+            throw new Error(`Error loading ${apiJsonFilename}:` +
+                `\nThe file format is version ${schemaVersion},` +
+                ` whereas ${DeserializerContext_1.ApiJsonSchemaVersion.OLDEST_SUPPORTED} is the oldest version supported by this tool`);
+        }
+        let oldestForwardsCompatibleVersion = schemaVersion;
+        if (jsonObject.metadata.oldestForwardsCompatibleVersion) {
+            // Sanity check
+            if (jsonObject.metadata.oldestForwardsCompatibleVersion > schemaVersion) {
+                throw new Error(`Error loading ${apiJsonFilename}:` +
+                    `\nInvalid file format; "oldestForwardsCompatibleVersion" cannot be newer than "schemaVersion"`);
+            }
+            oldestForwardsCompatibleVersion = jsonObject.metadata.oldestForwardsCompatibleVersion;
+        }
+        let versionToDeserialize = schemaVersion;
+        if (versionToDeserialize > DeserializerContext_1.ApiJsonSchemaVersion.LATEST) {
+            // If the file format is too new, can we treat it as some earlier compatible version
+            // as indicated by oldestForwardsCompatibleVersion?
+            versionToDeserialize = Math.max(oldestForwardsCompatibleVersion, DeserializerContext_1.ApiJsonSchemaVersion.LATEST);
+            if (versionToDeserialize > DeserializerContext_1.ApiJsonSchemaVersion.LATEST) {
+                // Nope, still too new
+                throw new Error(`Error loading ${apiJsonFilename}:` +
+                    `\nThe file format version ${schemaVersion} was written by a newer release of` +
+                    ` the api-extractor-model library; you may need to upgrade your software`);
+            }
+        }
+        const tsdocConfiguration = new tsdoc_1.TSDocConfiguration();
+        if (versionToDeserialize >= DeserializerContext_1.ApiJsonSchemaVersion.V_1004) {
+            const tsdocConfigFile = tsdoc_config_1.TSDocConfigFile.loadFromObject(jsonObject.metadata.tsdocConfig);
+            if (tsdocConfigFile.hasErrors) {
+                throw new Error(`Error loading ${apiJsonFilename}:\n` + tsdocConfigFile.getErrorSummary());
+            }
+            tsdocConfigFile.configureParser(tsdocConfiguration);
+        }
+        const context = new DeserializerContext_1.DeserializerContext({
+            apiJsonFilename,
+            toolPackage: jsonObject.metadata.toolPackage,
+            toolVersion: jsonObject.metadata.toolVersion,
+            versionToDeserialize: versionToDeserialize,
+            tsdocConfiguration
+        });
+        return ApiItem_1.ApiItem.deserialize(jsonObject, context);
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.Package;
+    }
+    /** @override */
+    get containerKey() {
+        // No prefix needed, because ApiPackage is the only possible member of an ApiModel
+        return this.name;
+    }
+    get entryPoints() {
+        return this.members;
+    }
+    /**
+     * The TSDoc configuration that was used when analyzing the API for this package.
+     *
+     * @remarks
+     *
+     * Normally this configuration is loaded from the project's tsdoc.json file.  It is stored
+     * in the .api.json file so that doc comments can be parsed accurately when loading the file.
+     */
+    get tsdocConfiguration() {
+        return this._tsdocConfiguration;
+    }
+    get projectFolderUrl() {
+        return this._projectFolderUrl;
+    }
+    /** @override */
+    addMember(member) {
+        if (member.kind !== ApiItem_1.ApiItemKind.EntryPoint) {
+            throw new Error('Only items of type ApiEntryPoint may be added to an ApiPackage');
+        }
+        super.addMember(member);
+    }
+    findEntryPointsByPath(importPath) {
+        return this.findMembersByName(importPath);
+    }
+    saveToJsonFile(apiJsonFilename, options) {
+        if (!options) {
+            options = {};
+        }
+        const packageJson = node_core_library_1.PackageJsonLookup.loadOwnPackageJson(__dirname);
+        const tsdocConfigFile = tsdoc_config_1.TSDocConfigFile.loadFromParser(this.tsdocConfiguration);
+        const tsdocConfig = tsdocConfigFile.saveToObject();
+        const jsonObject = {
+            metadata: {
+                toolPackage: options.toolPackage || packageJson.name,
+                // In test mode, we don't write the real version, since that would cause spurious diffs whenever
+                // the version is bumped.  Instead we write a placeholder string.
+                toolVersion: options.testMode ? '[test mode]' : options.toolVersion || packageJson.version,
+                schemaVersion: DeserializerContext_1.ApiJsonSchemaVersion.LATEST,
+                oldestForwardsCompatibleVersion: DeserializerContext_1.ApiJsonSchemaVersion.OLDEST_FORWARDS_COMPATIBLE,
+                tsdocConfig
+            }
+        };
+        if (this.projectFolderUrl) {
+            jsonObject.projectFolderUrl = this.projectFolderUrl;
+        }
+        this.serializeInto(jsonObject);
+        node_core_library_1.JsonFile.save(jsonObject, apiJsonFilename, options);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        return DeclarationReference_1.DeclarationReference.package(this.name);
+    }
+}
+exports.ApiPackage = ApiPackage;
+//# sourceMappingURL=ApiPackage.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiProperty.d.ts

@@ -0,0 +1,60 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { ApiAbstractMixin, type IApiAbstractMixinOptions } from '../mixins/ApiAbstractMixin';
+import { ApiProtectedMixin, type IApiProtectedMixinOptions } from '../mixins/ApiProtectedMixin';
+import { ApiStaticMixin, type IApiStaticMixinOptions } from '../mixins/ApiStaticMixin';
+import { ApiInitializerMixin, type IApiInitializerMixinOptions } from '../mixins/ApiInitializerMixin';
+import { ApiPropertyItem, type IApiPropertyItemOptions } from '../items/ApiPropertyItem';
+/**
+ * Constructor options for {@link ApiProperty}.
+ * @public
+ */
+export interface IApiPropertyOptions extends IApiPropertyItemOptions, IApiAbstractMixinOptions, IApiProtectedMixinOptions, IApiStaticMixinOptions, IApiInitializerMixinOptions {
+}
+declare const ApiProperty_base: typeof ApiPropertyItem & (new (...args: any[]) => ApiInitializerMixin) & (new (...args: any[]) => ApiStaticMixin) & (new (...args: any[]) => ApiProtectedMixin) & (new (...args: any[]) => ApiAbstractMixin);
+/**
+ * Represents a TypeScript property declaration that belongs to an `ApiClass`.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiProperty` represents a TypeScript declaration such as the `width` and `height` members in this example:
+ *
+ * ```ts
+ * export class Widget {
+ *   public width: number = 100;
+ *
+ *   public get height(): number {
+ *     if (this.isSquashed()) {
+ *       return 0;
+ *     } else {
+ *       return this.clientArea.height;
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Note that member variables are also considered to be properties.
+ *
+ * If the property has both a getter function and setter function, they will be represented by a single `ApiProperty`
+ * and must have a single documentation comment.
+ *
+ * Compare with {@link ApiPropertySignature}, which represents a property belonging to an interface.
+ * For example, a class property can be `static` but an interface property cannot.
+ *
+ * @public
+ */
+export declare class ApiProperty extends ApiProperty_base {
+    constructor(options: IApiPropertyOptions);
+    static getContainerKey(name: string, isStatic: boolean): string;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiProperty.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiProperty.d.ts","sourceRoot":"","sources":["../../src/model/ApiProperty.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAIrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,KAAK,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAC7F,OAAO,EAAE,iBAAiB,EAAE,KAAK,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAChG,OAAO,EAAE,cAAc,EAAE,KAAK,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AACvF,OAAO,EAAE,mBAAmB,EAAE,KAAK,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AACtG,OAAO,EAAE,eAAe,EAAE,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAEzF;;;GAGG;AACH,MAAM,WAAW,mBACf,SAAQ,uBAAuB,EAC7B,wBAAwB,EACxB,yBAAyB,EACzB,sBAAsB,EACtB,2BAA2B;CAAG;;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,WAAY,SAAQ,gBAEhC;gBACoB,OAAO,EAAE,mBAAmB;WAIjC,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM;IAQtE,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAMvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiProperty.js

@@ -0,0 +1,76 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiProperty = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiAbstractMixin_1 = require("../mixins/ApiAbstractMixin");
+const ApiProtectedMixin_1 = require("../mixins/ApiProtectedMixin");
+const ApiStaticMixin_1 = require("../mixins/ApiStaticMixin");
+const ApiInitializerMixin_1 = require("../mixins/ApiInitializerMixin");
+const ApiPropertyItem_1 = require("../items/ApiPropertyItem");
+/**
+ * Represents a TypeScript property declaration that belongs to an `ApiClass`.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiProperty` represents a TypeScript declaration such as the `width` and `height` members in this example:
+ *
+ * ```ts
+ * export class Widget {
+ *   public width: number = 100;
+ *
+ *   public get height(): number {
+ *     if (this.isSquashed()) {
+ *       return 0;
+ *     } else {
+ *       return this.clientArea.height;
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Note that member variables are also considered to be properties.
+ *
+ * If the property has both a getter function and setter function, they will be represented by a single `ApiProperty`
+ * and must have a single documentation comment.
+ *
+ * Compare with {@link ApiPropertySignature}, which represents a property belonging to an interface.
+ * For example, a class property can be `static` but an interface property cannot.
+ *
+ * @public
+ */
+class ApiProperty extends (0, ApiAbstractMixin_1.ApiAbstractMixin)((0, ApiProtectedMixin_1.ApiProtectedMixin)((0, ApiStaticMixin_1.ApiStaticMixin)((0, ApiInitializerMixin_1.ApiInitializerMixin)(ApiPropertyItem_1.ApiPropertyItem)))) {
+    constructor(options) {
+        super(options);
+    }
+    static getContainerKey(name, isStatic) {
+        if (isStatic) {
+            return `${name}|${ApiItem_1.ApiItemKind.Property}|static`;
+        }
+        else {
+            return `${name}|${ApiItem_1.ApiItemKind.Property}|instance`;
+        }
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.Property;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiProperty.getContainerKey(this.name, this.isStatic);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const nameComponent = DeclarationReference_1.DeclarationReference.parseComponent(this.name);
+        return (this.parent ? this.parent.canonicalReference : DeclarationReference_1.DeclarationReference.empty())
+            .addNavigationStep(this.isStatic ? "." /* Navigation.Exports */ : "#" /* Navigation.Members */, nameComponent)
+            .withMeaning("member" /* Meaning.Member */);
+    }
+}
+exports.ApiProperty = ApiProperty;
+//# sourceMappingURL=ApiProperty.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiProperty.js","sourceRoot":"","sources":["../../src/model/ApiProperty.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,kGAKiE;AACjE,8CAA+C;AAC/C,iEAA6F;AAC7F,mEAAgG;AAChG,6DAAuF;AACvF,uEAAsG;AACtG,8DAAyF;AAazF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAa,WAAY,SAAQ,IAAA,mCAAgB,EAC/C,IAAA,qCAAiB,EAAC,IAAA,+BAAc,EAAC,IAAA,yCAAmB,EAAC,iCAAe,CAAC,CAAC,CAAC,CACxE;IACC,YAAmB,OAA4B;QAC7C,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,MAAM,CAAC,eAAe,CAAC,IAAY,EAAE,QAAiB;QAC3D,IAAI,QAAQ,EAAE;YACZ,OAAO,GAAG,IAAI,IAAI,qBAAW,CAAC,QAAQ,SAAS,CAAC;SACjD;aAAM;YACL,OAAO,GAAG,IAAI,IAAI,qBAAW,CAAC,QAAQ,WAAW,CAAC;SACnD;IACH,CAAC;IAED,gBAAgB;IAChB,IAAW,IAAI;QACb,OAAO,qBAAW,CAAC,QAAQ,CAAC;IAC9B,CAAC;IAED,gBAAgB;IAChB,IAAW,YAAY;QACrB,OAAO,WAAW,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC/D,CAAC;IAED,sBAAsB;IACf,uBAAuB;QAC5B,MAAM,aAAa,GAAc,2CAAoB,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChF,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,2CAAoB,CAAC,KAAK,EAAE,CAAC;aACjF,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,8BAAoB,CAAC,6BAAmB,EAAE,aAAa,CAAC;aACzF,WAAW,+BAAgB,CAAC;IACjC,CAAC;CACF;AAhCD,kCAgCC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport {\n  DeclarationReference,\n  Meaning,\n  Navigation,\n  type Component\n} from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';\nimport { ApiItemKind } from '../items/ApiItem';\nimport { ApiAbstractMixin, type IApiAbstractMixinOptions } from '../mixins/ApiAbstractMixin';\nimport { ApiProtectedMixin, type IApiProtectedMixinOptions } from '../mixins/ApiProtectedMixin';\nimport { ApiStaticMixin, type IApiStaticMixinOptions } from '../mixins/ApiStaticMixin';\nimport { ApiInitializerMixin, type IApiInitializerMixinOptions } from '../mixins/ApiInitializerMixin';\nimport { ApiPropertyItem, type IApiPropertyItemOptions } from '../items/ApiPropertyItem';\n\n/**\n * Constructor options for {@link ApiProperty}.\n * @public\n */\nexport interface IApiPropertyOptions\n  extends IApiPropertyItemOptions,\n    IApiAbstractMixinOptions,\n    IApiProtectedMixinOptions,\n    IApiStaticMixinOptions,\n    IApiInitializerMixinOptions {}\n\n/**\n * Represents a TypeScript property declaration that belongs to an `ApiClass`.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.\n *\n * `ApiProperty` represents a TypeScript declaration such as the `width` and `height` members in this example:\n *\n * ```ts\n * export class Widget {\n *   public width: number = 100;\n *\n *   public get height(): number {\n *     if (this.isSquashed()) {\n *       return 0;\n *     } else {\n *       return this.clientArea.height;\n *     }\n *   }\n * }\n * ```\n *\n * Note that member variables are also considered to be properties.\n *\n * If the property has both a getter function and setter function, they will be represented by a single `ApiProperty`\n * and must have a single documentation comment.\n *\n * Compare with {@link ApiPropertySignature}, which represents a property belonging to an interface.\n * For example, a class property can be `static` but an interface property cannot.\n *\n * @public\n */\nexport class ApiProperty extends ApiAbstractMixin(\n  ApiProtectedMixin(ApiStaticMixin(ApiInitializerMixin(ApiPropertyItem)))\n) {\n  public constructor(options: IApiPropertyOptions) {\n    super(options);\n  }\n\n  public static getContainerKey(name: string, isStatic: boolean): string {\n    if (isStatic) {\n      return `${name}|${ApiItemKind.Property}|static`;\n    } else {\n      return `${name}|${ApiItemKind.Property}|instance`;\n    }\n  }\n\n  /** @override */\n  public get kind(): ApiItemKind {\n    return ApiItemKind.Property;\n  }\n\n  /** @override */\n  public get containerKey(): string {\n    return ApiProperty.getContainerKey(this.name, this.isStatic);\n  }\n\n  /** @beta @override */\n  public buildCanonicalReference(): DeclarationReference {\n    const nameComponent: Component = DeclarationReference.parseComponent(this.name);\n    return (this.parent ? this.parent.canonicalReference : DeclarationReference.empty())\n      .addNavigationStep(this.isStatic ? Navigation.Exports : Navigation.Members, nameComponent)\n      .withMeaning(Meaning.Member);\n  }\n}\n"]}

node_modules/@microsoft/api-extractor-model/lib/model/ApiPropertySignature.d.ts

@@ -0,0 +1,42 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { ApiPropertyItem, type IApiPropertyItemOptions } from '../items/ApiPropertyItem';
+/**
+ * Constructor options for {@link ApiPropertySignature}.
+ * @public
+ */
+export interface IApiPropertySignatureOptions extends IApiPropertyItemOptions {
+}
+/**
+ * Represents a TypeScript property declaration that belongs to an `ApiInterface`.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiPropertySignature` represents a TypeScript declaration such as the `width` and `height` members in this example:
+ *
+ * ```ts
+ * export interface IWidget {
+ *   readonly width: number;
+ *   height: number;
+ * }
+ * ```
+ *
+ * Compare with {@link ApiProperty}, which represents a property belonging to a class.
+ * For example, a class property can be `static` but an interface property cannot.
+ *
+ * @public
+ */
+export declare class ApiPropertySignature extends ApiPropertyItem {
+    constructor(options: IApiPropertySignatureOptions);
+    static getContainerKey(name: string): string;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+//# sourceMappingURL=ApiPropertySignature.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiPropertySignature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiPropertySignature.d.ts","sourceRoot":"","sources":["../../src/model/ApiPropertySignature.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAIrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAEzF;;;GAGG;AACH,MAAM,WAAW,4BAA6B,SAAQ,uBAAuB;CAAG;AAEhF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,oBAAqB,SAAQ,eAAe;gBACpC,OAAO,EAAE,4BAA4B;WAI1C,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAInD,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAMvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiPropertySignature.js

@@ -0,0 +1,55 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiPropertySignature = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiPropertyItem_1 = require("../items/ApiPropertyItem");
+/**
+ * Represents a TypeScript property declaration that belongs to an `ApiInterface`.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiPropertySignature` represents a TypeScript declaration such as the `width` and `height` members in this example:
+ *
+ * ```ts
+ * export interface IWidget {
+ *   readonly width: number;
+ *   height: number;
+ * }
+ * ```
+ *
+ * Compare with {@link ApiProperty}, which represents a property belonging to a class.
+ * For example, a class property can be `static` but an interface property cannot.
+ *
+ * @public
+ */
+class ApiPropertySignature extends ApiPropertyItem_1.ApiPropertyItem {
+    constructor(options) {
+        super(options);
+    }
+    static getContainerKey(name) {
+        return `${name}|${ApiItem_1.ApiItemKind.PropertySignature}`;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.PropertySignature;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiPropertySignature.getContainerKey(this.name);
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const nameComponent = DeclarationReference_1.DeclarationReference.parseComponent(this.name);
+        return (this.parent ? this.parent.canonicalReference : DeclarationReference_1.DeclarationReference.empty())
+            .addNavigationStep("#" /* Navigation.Members */, nameComponent)
+            .withMeaning("member" /* Meaning.Member */);
+    }
+}
+exports.ApiPropertySignature = ApiPropertySignature;
+//# sourceMappingURL=ApiPropertySignature.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiPropertySignature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiPropertySignature.js","sourceRoot":"","sources":["../../src/model/ApiPropertySignature.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,kGAKiE;AACjE,8CAA+C;AAC/C,8DAAyF;AAQzF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,oBAAqB,SAAQ,iCAAe;IACvD,YAAmB,OAAqC;QACtD,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,MAAM,CAAC,eAAe,CAAC,IAAY;QACxC,OAAO,GAAG,IAAI,IAAI,qBAAW,CAAC,iBAAiB,EAAE,CAAC;IACpD,CAAC;IAED,gBAAgB;IAChB,IAAW,IAAI;QACb,OAAO,qBAAW,CAAC,iBAAiB,CAAC;IACvC,CAAC;IAED,gBAAgB;IAChB,IAAW,YAAY;QACrB,OAAO,oBAAoB,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzD,CAAC;IAED,sBAAsB;IACf,uBAAuB;QAC5B,MAAM,aAAa,GAAc,2CAAoB,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChF,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,2CAAoB,CAAC,KAAK,EAAE,CAAC;aACjF,iBAAiB,+BAAqB,aAAa,CAAC;aACpD,WAAW,+BAAgB,CAAC;IACjC,CAAC;CACF;AA1BD,oDA0BC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport {\n  DeclarationReference,\n  Meaning,\n  Navigation,\n  type Component\n} from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';\nimport { ApiItemKind } from '../items/ApiItem';\nimport { ApiPropertyItem, type IApiPropertyItemOptions } from '../items/ApiPropertyItem';\n\n/**\n * Constructor options for {@link ApiPropertySignature}.\n * @public\n */\nexport interface IApiPropertySignatureOptions extends IApiPropertyItemOptions {}\n\n/**\n * Represents a TypeScript property declaration that belongs to an `ApiInterface`.\n *\n * @remarks\n *\n * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of\n * API declarations.\n *\n * `ApiPropertySignature` represents a TypeScript declaration such as the `width` and `height` members in this example:\n *\n * ```ts\n * export interface IWidget {\n *   readonly width: number;\n *   height: number;\n * }\n * ```\n *\n * Compare with {@link ApiProperty}, which represents a property belonging to a class.\n * For example, a class property can be `static` but an interface property cannot.\n *\n * @public\n */\nexport class ApiPropertySignature extends ApiPropertyItem {\n  public constructor(options: IApiPropertySignatureOptions) {\n    super(options);\n  }\n\n  public static getContainerKey(name: string): string {\n    return `${name}|${ApiItemKind.PropertySignature}`;\n  }\n\n  /** @override */\n  public get kind(): ApiItemKind {\n    return ApiItemKind.PropertySignature;\n  }\n\n  /** @override */\n  public get containerKey(): string {\n    return ApiPropertySignature.getContainerKey(this.name);\n  }\n\n  /** @beta @override */\n  public buildCanonicalReference(): DeclarationReference {\n    const nameComponent: Component = DeclarationReference.parseComponent(this.name);\n    return (this.parent ? this.parent.canonicalReference : DeclarationReference.empty())\n      .addNavigationStep(Navigation.Members, nameComponent)\n      .withMeaning(Meaning.Member);\n  }\n}\n"]}

node_modules/@microsoft/api-extractor-model/lib/model/ApiTypeAlias.d.ts

@@ -0,0 +1,74 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import type { Excerpt, IExcerptTokenRange } from '../mixins/Excerpt';
+import { ApiItemKind } from '../items/ApiItem';
+import { ApiDeclaredItem, type IApiDeclaredItemOptions, type IApiDeclaredItemJson } from '../items/ApiDeclaredItem';
+import { ApiReleaseTagMixin, type IApiReleaseTagMixinOptions } from '../mixins/ApiReleaseTagMixin';
+import { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';
+import { ApiTypeParameterListMixin, type IApiTypeParameterListMixinOptions, type IApiTypeParameterListMixinJson } from '../mixins/ApiTypeParameterListMixin';
+import type { DeserializerContext } from './DeserializerContext';
+import { type IApiExportedMixinJson, type IApiExportedMixinOptions, ApiExportedMixin } from '../mixins/ApiExportedMixin';
+/**
+ * Constructor options for {@link ApiTypeAlias}.
+ * @public
+ */
+export interface IApiTypeAliasOptions extends IApiNameMixinOptions, IApiReleaseTagMixinOptions, IApiDeclaredItemOptions, IApiTypeParameterListMixinOptions, IApiExportedMixinOptions {
+    typeTokenRange: IExcerptTokenRange;
+}
+export interface IApiTypeAliasJson extends IApiDeclaredItemJson, IApiTypeParameterListMixinJson, IApiExportedMixinJson {
+    typeTokenRange: IExcerptTokenRange;
+}
+declare const ApiTypeAlias_base: typeof ApiDeclaredItem & (new (...args: any[]) => ApiExportedMixin) & (new (...args: any[]) => ApiReleaseTagMixin) & (new (...args: any[]) => ApiNameMixin) & (new (...args: any[]) => ApiTypeParameterListMixin);
+/**
+ * Represents a TypeScript type alias declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiTypeAlias` represents a definition such as one of these examples:
+ *
+ * ```ts
+ * // A union type:
+ * export type Shape = Square | Triangle | Circle;
+ *
+ * // A generic type alias:
+ * export type BoxedValue<T> = { value: T };
+ *
+ * export type BoxedArray<T> = { array: T[] };
+ *
+ * // A conditional type alias:
+ * export type Boxed<T> = T extends any[] ? BoxedArray<T[number]> : BoxedValue<T>;
+ *
+ * ```
+ *
+ * @public
+ */
+export declare class ApiTypeAlias extends ApiTypeAlias_base {
+    /**
+     * An {@link Excerpt} that describes the type of the alias.
+     *
+     * @remarks
+     * In the example below, the `typeExcerpt` would correspond to the subexpression
+     * `T extends any[] ? BoxedArray<T[number]> : BoxedValue<T>;`:
+     *
+     * ```ts
+     * export type Boxed<T> = T extends any[] ? BoxedArray<T[number]> : BoxedValue<T>;
+     * ```
+     */
+    readonly typeExcerpt: Excerpt;
+    constructor(options: IApiTypeAliasOptions);
+    /** @override */
+    static onDeserializeInto(options: Partial<IApiTypeAliasOptions>, context: DeserializerContext, jsonObject: IApiTypeAliasJson): void;
+    static getContainerKey(name: string): string;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /** @override */
+    serializeInto(jsonObject: Partial<IApiTypeAliasJson>): void;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiTypeAlias.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiTypeAlias.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiTypeAlias.d.ts","sourceRoot":"","sources":["../../src/model/ApiTypeAlias.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAIrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EACL,eAAe,EACf,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EAC1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,kBAAkB,EAAE,KAAK,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,KAAK,oBAAoB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EACL,yBAAyB,EACzB,KAAK,iCAAiC,EACtC,KAAK,8BAA8B,EACpC,MAAM,qCAAqC,CAAC;AAC7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,gBAAgB,EACjB,MAAM,4BAA4B,CAAC;AAEpC;;;GAGG;AACH,MAAM,WAAW,oBACf,SAAQ,oBAAoB,EAC1B,0BAA0B,EAC1B,uBAAuB,EACvB,iCAAiC,EACjC,wBAAwB;IAC1B,cAAc,EAAE,kBAAkB,CAAC;CACpC;AAED,MAAM,WAAW,iBACf,SAAQ,oBAAoB,EAC1B,8BAA8B,EAC9B,qBAAqB;IACvB,cAAc,EAAE,kBAAkB,CAAC;CACpC;;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,YAAa,SAAQ,iBAEjC;IACC;;;;;;;;;;OAUG;IACH,SAAgB,WAAW,EAAE,OAAO,CAAC;gBAElB,OAAO,EAAE,oBAAoB;IAMhD,gBAAgB;WACF,iBAAiB,CAC7B,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC,EACtC,OAAO,EAAE,mBAAmB,EAC5B,UAAU,EAAE,iBAAiB,GAC5B,IAAI;WAMO,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAInD,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,gBAAgB;IACT,aAAa,CAAC,UAAU,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,IAAI;IAMlE,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAOvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiTypeAlias.js

@@ -0,0 +1,75 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiTypeAlias = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiDeclaredItem_1 = require("../items/ApiDeclaredItem");
+const ApiReleaseTagMixin_1 = require("../mixins/ApiReleaseTagMixin");
+const ApiNameMixin_1 = require("../mixins/ApiNameMixin");
+const ApiTypeParameterListMixin_1 = require("../mixins/ApiTypeParameterListMixin");
+const ApiExportedMixin_1 = require("../mixins/ApiExportedMixin");
+/**
+ * Represents a TypeScript type alias declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiTypeAlias` represents a definition such as one of these examples:
+ *
+ * ```ts
+ * // A union type:
+ * export type Shape = Square | Triangle | Circle;
+ *
+ * // A generic type alias:
+ * export type BoxedValue<T> = { value: T };
+ *
+ * export type BoxedArray<T> = { array: T[] };
+ *
+ * // A conditional type alias:
+ * export type Boxed<T> = T extends any[] ? BoxedArray<T[number]> : BoxedValue<T>;
+ *
+ * ```
+ *
+ * @public
+ */
+class ApiTypeAlias extends (0, ApiTypeParameterListMixin_1.ApiTypeParameterListMixin)((0, ApiNameMixin_1.ApiNameMixin)((0, ApiReleaseTagMixin_1.ApiReleaseTagMixin)((0, ApiExportedMixin_1.ApiExportedMixin)(ApiDeclaredItem_1.ApiDeclaredItem)))) {
+    constructor(options) {
+        super(options);
+        this.typeExcerpt = this.buildExcerpt(options.typeTokenRange);
+    }
+    /** @override */
+    static onDeserializeInto(options, context, jsonObject) {
+        super.onDeserializeInto(options, context, jsonObject);
+        options.typeTokenRange = jsonObject.typeTokenRange;
+    }
+    static getContainerKey(name) {
+        return `${name}|${ApiItem_1.ApiItemKind.TypeAlias}`;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.TypeAlias;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiTypeAlias.getContainerKey(this.name);
+    }
+    /** @override */
+    serializeInto(jsonObject) {
+        super.serializeInto(jsonObject);
+        jsonObject.typeTokenRange = this.typeExcerpt.tokenRange;
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const nameComponent = DeclarationReference_1.DeclarationReference.parseComponent(this.name);
+        const navigation = this.isExported ? "." /* Navigation.Exports */ : "~" /* Navigation.Locals */;
+        return (this.parent ? this.parent.canonicalReference : DeclarationReference_1.DeclarationReference.empty())
+            .addNavigationStep(navigation, nameComponent)
+            .withMeaning("type" /* Meaning.TypeAlias */);
+    }
+}
+exports.ApiTypeAlias = ApiTypeAlias;
+//# sourceMappingURL=ApiTypeAlias.js.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiVariable.d.ts

@@ -0,0 +1,61 @@
+import { DeclarationReference } from '@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference';
+import { ApiItemKind } from '../items/ApiItem';
+import { ApiDeclaredItem, type IApiDeclaredItemOptions, type IApiDeclaredItemJson } from '../items/ApiDeclaredItem';
+import { ApiReleaseTagMixin, type IApiReleaseTagMixinOptions } from '../mixins/ApiReleaseTagMixin';
+import { ApiReadonlyMixin, type IApiReadonlyMixinOptions } from '../mixins/ApiReadonlyMixin';
+import { type IApiNameMixinOptions, ApiNameMixin } from '../mixins/ApiNameMixin';
+import { ApiInitializerMixin, type IApiInitializerMixinOptions } from '../mixins/ApiInitializerMixin';
+import type { IExcerptTokenRange, Excerpt } from '../mixins/Excerpt';
+import type { DeserializerContext } from './DeserializerContext';
+import { type IApiExportedMixinJson, type IApiExportedMixinOptions, ApiExportedMixin } from '../mixins/ApiExportedMixin';
+/**
+ * Constructor options for {@link ApiVariable}.
+ * @public
+ */
+export interface IApiVariableOptions extends IApiNameMixinOptions, IApiReleaseTagMixinOptions, IApiReadonlyMixinOptions, IApiDeclaredItemOptions, IApiInitializerMixinOptions, IApiExportedMixinOptions {
+    variableTypeTokenRange: IExcerptTokenRange;
+}
+export interface IApiVariableJson extends IApiDeclaredItemJson, IApiExportedMixinJson {
+    variableTypeTokenRange: IExcerptTokenRange;
+}
+declare const ApiVariable_base: typeof ApiDeclaredItem & (new (...args: any[]) => ApiExportedMixin) & (new (...args: any[]) => ApiInitializerMixin) & (new (...args: any[]) => ApiReadonlyMixin) & (new (...args: any[]) => ApiReleaseTagMixin) & (new (...args: any[]) => ApiNameMixin);
+/**
+ * Represents a TypeScript variable declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiVariable` represents an exported `const` or `let` object such as these examples:
+ *
+ * ```ts
+ * // A variable declaration
+ * export let verboseLogging: boolean;
+ *
+ * // A constant variable declaration with an initializer
+ * export const canvas: IWidget = createCanvas();
+ * ```
+ *
+ * @public
+ */
+export declare class ApiVariable extends ApiVariable_base {
+    /**
+     * An {@link Excerpt} that describes the type of the variable.
+     */
+    readonly variableTypeExcerpt: Excerpt;
+    constructor(options: IApiVariableOptions);
+    /** @override */
+    static onDeserializeInto(options: Partial<IApiVariableOptions>, context: DeserializerContext, jsonObject: IApiVariableJson): void;
+    static getContainerKey(name: string): string;
+    /** @override */
+    get kind(): ApiItemKind;
+    /** @override */
+    get containerKey(): string;
+    /** @override */
+    serializeInto(jsonObject: Partial<IApiVariableJson>): void;
+    /** @beta @override */
+    buildCanonicalReference(): DeclarationReference;
+}
+export {};
+//# sourceMappingURL=ApiVariable.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ApiVariable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiVariable.d.ts","sourceRoot":"","sources":["../../src/model/ApiVariable.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,oBAAoB,EAIrB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EACL,eAAe,EACf,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EAC1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,kBAAkB,EAAE,KAAK,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AACnG,OAAO,EAAE,gBAAgB,EAAE,KAAK,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAC7F,OAAO,EAAE,KAAK,oBAAoB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,mBAAmB,EAAE,KAAK,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AACtG,OAAO,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,gBAAgB,EACjB,MAAM,4BAA4B,CAAC;AAEpC;;;GAGG;AACH,MAAM,WAAW,mBACf,SAAQ,oBAAoB,EAC1B,0BAA0B,EAC1B,wBAAwB,EACxB,uBAAuB,EACvB,2BAA2B,EAC3B,wBAAwB;IAC1B,sBAAsB,EAAE,kBAAkB,CAAC;CAC5C;AAED,MAAM,WAAW,gBAAiB,SAAQ,oBAAoB,EAAE,qBAAqB;IACnF,sBAAsB,EAAE,kBAAkB,CAAC;CAC5C;;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,WAAY,SAAQ,gBAEhC;IACC;;OAEG;IACH,SAAgB,mBAAmB,EAAE,OAAO,CAAC;gBAE1B,OAAO,EAAE,mBAAmB;IAM/C,gBAAgB;WACF,iBAAiB,CAC7B,OAAO,EAAE,OAAO,CAAC,mBAAmB,CAAC,EACrC,OAAO,EAAE,mBAAmB,EAC5B,UAAU,EAAE,gBAAgB,GAC3B,IAAI;WAMO,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAInD,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,gBAAgB;IAChB,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,gBAAgB;IACT,aAAa,CAAC,UAAU,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI;IAMjE,sBAAsB;IACf,uBAAuB,IAAI,oBAAoB;CAOvD"}

node_modules/@microsoft/api-extractor-model/lib/model/ApiVariable.js

@@ -0,0 +1,70 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiVariable = void 0;
+const DeclarationReference_1 = require("@microsoft/tsdoc/lib-commonjs/beta/DeclarationReference");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiDeclaredItem_1 = require("../items/ApiDeclaredItem");
+const ApiReleaseTagMixin_1 = require("../mixins/ApiReleaseTagMixin");
+const ApiReadonlyMixin_1 = require("../mixins/ApiReadonlyMixin");
+const ApiNameMixin_1 = require("../mixins/ApiNameMixin");
+const ApiInitializerMixin_1 = require("../mixins/ApiInitializerMixin");
+const ApiExportedMixin_1 = require("../mixins/ApiExportedMixin");
+/**
+ * Represents a TypeScript variable declaration.
+ *
+ * @remarks
+ *
+ * This is part of the {@link ApiModel} hierarchy of classes, which are serializable representations of
+ * API declarations.
+ *
+ * `ApiVariable` represents an exported `const` or `let` object such as these examples:
+ *
+ * ```ts
+ * // A variable declaration
+ * export let verboseLogging: boolean;
+ *
+ * // A constant variable declaration with an initializer
+ * export const canvas: IWidget = createCanvas();
+ * ```
+ *
+ * @public
+ */
+class ApiVariable extends (0, ApiNameMixin_1.ApiNameMixin)((0, ApiReleaseTagMixin_1.ApiReleaseTagMixin)((0, ApiReadonlyMixin_1.ApiReadonlyMixin)((0, ApiInitializerMixin_1.ApiInitializerMixin)((0, ApiExportedMixin_1.ApiExportedMixin)(ApiDeclaredItem_1.ApiDeclaredItem))))) {
+    constructor(options) {
+        super(options);
+        this.variableTypeExcerpt = this.buildExcerpt(options.variableTypeTokenRange);
+    }
+    /** @override */
+    static onDeserializeInto(options, context, jsonObject) {
+        super.onDeserializeInto(options, context, jsonObject);
+        options.variableTypeTokenRange = jsonObject.variableTypeTokenRange;
+    }
+    static getContainerKey(name) {
+        return `${name}|${ApiItem_1.ApiItemKind.Variable}`;
+    }
+    /** @override */
+    get kind() {
+        return ApiItem_1.ApiItemKind.Variable;
+    }
+    /** @override */
+    get containerKey() {
+        return ApiVariable.getContainerKey(this.name);
+    }
+    /** @override */
+    serializeInto(jsonObject) {
+        super.serializeInto(jsonObject);
+        jsonObject.variableTypeTokenRange = this.variableTypeExcerpt.tokenRange;
+    }
+    /** @beta @override */
+    buildCanonicalReference() {
+        const nameComponent = DeclarationReference_1.DeclarationReference.parseComponent(this.name);
+        const navigation = this.isExported ? "." /* Navigation.Exports */ : "~" /* Navigation.Locals */;
+        return (this.parent ? this.parent.canonicalReference : DeclarationReference_1.DeclarationReference.empty())
+            .addNavigationStep(navigation, nameComponent)
+            .withMeaning("var" /* Meaning.Variable */);
+    }
+}
+exports.ApiVariable = ApiVariable;
+//# sourceMappingURL=ApiVariable.js.map

node_modules/@microsoft/api-extractor-model/lib/model/Deserializer.d.ts

@@ -0,0 +1,6 @@
+import { type IApiItemJson, type ApiItem } from '../items/ApiItem';
+import type { DeserializerContext } from './DeserializerContext';
+export declare class Deserializer {
+    static deserialize(context: DeserializerContext, jsonObject: IApiItemJson): ApiItem;
+}
+//# sourceMappingURL=Deserializer.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/Deserializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Deserializer.d.ts","sourceRoot":"","sources":["../../src/model/Deserializer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,YAAY,EAAwB,KAAK,OAAO,EAAe,MAAM,kBAAkB,CAAC;AAsBtG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,qBAAa,YAAY;WACT,WAAW,CAAC,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,YAAY,GAAG,OAAO;CAgE3F"}

node_modules/@microsoft/api-extractor-model/lib/model/Deserializer.js

@@ -0,0 +1,92 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deserializer = void 0;
+const ApiItem_1 = require("../items/ApiItem");
+const ApiClass_1 = require("./ApiClass");
+const ApiEntryPoint_1 = require("./ApiEntryPoint");
+const ApiMethod_1 = require("./ApiMethod");
+const ApiModel_1 = require("./ApiModel");
+const ApiNamespace_1 = require("./ApiNamespace");
+const ApiPackage_1 = require("./ApiPackage");
+const ApiInterface_1 = require("./ApiInterface");
+const ApiPropertySignature_1 = require("./ApiPropertySignature");
+const ApiMethodSignature_1 = require("./ApiMethodSignature");
+const ApiProperty_1 = require("./ApiProperty");
+const ApiEnumMember_1 = require("./ApiEnumMember");
+const ApiEnum_1 = require("./ApiEnum");
+const ApiConstructor_1 = require("./ApiConstructor");
+const ApiConstructSignature_1 = require("./ApiConstructSignature");
+const ApiFunction_1 = require("./ApiFunction");
+const ApiCallSignature_1 = require("./ApiCallSignature");
+const ApiIndexSignature_1 = require("./ApiIndexSignature");
+const ApiTypeAlias_1 = require("./ApiTypeAlias");
+const ApiVariable_1 = require("./ApiVariable");
+class Deserializer {
+    static deserialize(context, jsonObject) {
+        const options = {};
+        switch (jsonObject.kind) {
+            case ApiItem_1.ApiItemKind.Class:
+                ApiClass_1.ApiClass.onDeserializeInto(options, context, jsonObject);
+                return new ApiClass_1.ApiClass(options);
+            case ApiItem_1.ApiItemKind.CallSignature:
+                ApiCallSignature_1.ApiCallSignature.onDeserializeInto(options, context, jsonObject);
+                return new ApiCallSignature_1.ApiCallSignature(options);
+            case ApiItem_1.ApiItemKind.Constructor:
+                ApiConstructor_1.ApiConstructor.onDeserializeInto(options, context, jsonObject);
+                return new ApiConstructor_1.ApiConstructor(options);
+            case ApiItem_1.ApiItemKind.ConstructSignature:
+                ApiConstructSignature_1.ApiConstructSignature.onDeserializeInto(options, context, jsonObject);
+                return new ApiConstructSignature_1.ApiConstructSignature(options);
+            case ApiItem_1.ApiItemKind.EntryPoint:
+                ApiEntryPoint_1.ApiEntryPoint.onDeserializeInto(options, context, jsonObject);
+                return new ApiEntryPoint_1.ApiEntryPoint(options);
+            case ApiItem_1.ApiItemKind.Enum:
+                ApiEnum_1.ApiEnum.onDeserializeInto(options, context, jsonObject);
+                return new ApiEnum_1.ApiEnum(options);
+            case ApiItem_1.ApiItemKind.EnumMember:
+                ApiEnumMember_1.ApiEnumMember.onDeserializeInto(options, context, jsonObject);
+                return new ApiEnumMember_1.ApiEnumMember(options);
+            case ApiItem_1.ApiItemKind.Function:
+                ApiFunction_1.ApiFunction.onDeserializeInto(options, context, jsonObject);
+                return new ApiFunction_1.ApiFunction(options);
+            case ApiItem_1.ApiItemKind.IndexSignature:
+                ApiIndexSignature_1.ApiIndexSignature.onDeserializeInto(options, context, jsonObject);
+                return new ApiIndexSignature_1.ApiIndexSignature(options);
+            case ApiItem_1.ApiItemKind.Interface:
+                ApiInterface_1.ApiInterface.onDeserializeInto(options, context, jsonObject);
+                return new ApiInterface_1.ApiInterface(options);
+            case ApiItem_1.ApiItemKind.Method:
+                ApiMethod_1.ApiMethod.onDeserializeInto(options, context, jsonObject);
+                return new ApiMethod_1.ApiMethod(options);
+            case ApiItem_1.ApiItemKind.MethodSignature:
+                ApiMethodSignature_1.ApiMethodSignature.onDeserializeInto(options, context, jsonObject);
+                return new ApiMethodSignature_1.ApiMethodSignature(options);
+            case ApiItem_1.ApiItemKind.Model:
+                return new ApiModel_1.ApiModel();
+            case ApiItem_1.ApiItemKind.Namespace:
+                ApiNamespace_1.ApiNamespace.onDeserializeInto(options, context, jsonObject);
+                return new ApiNamespace_1.ApiNamespace(options);
+            case ApiItem_1.ApiItemKind.Package:
+                ApiPackage_1.ApiPackage.onDeserializeInto(options, context, jsonObject);
+                return new ApiPackage_1.ApiPackage(options);
+            case ApiItem_1.ApiItemKind.Property:
+                ApiProperty_1.ApiProperty.onDeserializeInto(options, context, jsonObject);
+                return new ApiProperty_1.ApiProperty(options);
+            case ApiItem_1.ApiItemKind.PropertySignature:
+                ApiPropertySignature_1.ApiPropertySignature.onDeserializeInto(options, context, jsonObject);
+                return new ApiPropertySignature_1.ApiPropertySignature(options);
+            case ApiItem_1.ApiItemKind.TypeAlias:
+                ApiTypeAlias_1.ApiTypeAlias.onDeserializeInto(options, context, jsonObject);
+                return new ApiTypeAlias_1.ApiTypeAlias(options);
+            case ApiItem_1.ApiItemKind.Variable:
+                ApiVariable_1.ApiVariable.onDeserializeInto(options, context, jsonObject);
+                return new ApiVariable_1.ApiVariable(options);
+            default:
+                throw new Error(`Failed to deserialize unsupported API item type ${JSON.stringify(jsonObject.kind)}`);
+        }
+    }
+}
+exports.Deserializer = Deserializer;
+//# sourceMappingURL=Deserializer.js.map

node_modules/@microsoft/api-extractor-model/lib/model/DeserializerContext.d.ts

@@ -0,0 +1,123 @@
+import type { TSDocConfiguration } from '@microsoft/tsdoc';
+export declare enum ApiJsonSchemaVersion {
+    /**
+     * The initial release.
+     */
+    V_1000 = 1000,
+    /**
+     * Add support for type parameters and type alias types.
+     */
+    V_1001 = 1001,
+    /**
+     * Remove `canonicalReference` field.  This field was for diagnostic purposes only and was never deserialized.
+     */
+    V_1002 = 1002,
+    /**
+     * Reintroduce the `canonicalReference` field using the experimental new TSDoc declaration reference notation.
+     *
+     * This is not a breaking change because this field is never deserialized; it is provided for informational
+     * purposes only.
+     */
+    V_1003 = 1003,
+    /**
+     * Add a `tsdocConfig` field that tracks the TSDoc configuration for parsing doc comments.
+     *
+     * This is not a breaking change because an older implementation will still work correctly.  The
+     * custom tags will be skipped over by the parser.
+     */
+    V_1004 = 1004,
+    /**
+     * Add an `isOptional` field to `Parameter` and `TypeParameter` to track whether a function parameter is optional.
+     *
+     * When loading older JSON files, the value defaults to `false`.
+     */
+    V_1005 = 1005,
+    /**
+     * Add an `isProtected` field to `ApiConstructor`, `ApiMethod`, and `ApiProperty` to
+     * track whether a class member has the `protected` modifier.
+     *
+     * Add an `isReadonly` field to `ApiProperty`, `ApiPropertySignature`, and `ApiVariable` to
+     * track whether the item is readonly.
+     *
+     * When loading older JSON files, the values default to `false`.
+     */
+    V_1006 = 1006,
+    /**
+     * Add `ApiItemContainerMixin.preserveMemberOrder` to support enums that preserve their original sort order.
+     *
+     * When loading older JSON files, the value default to `false`.
+     */
+    V_1007 = 1007,
+    /**
+     * Add an `initializerTokenRange` field to `ApiProperty` and `ApiVariable` to track the item's
+     * initializer.
+     *
+     * When loading older JSON files, this range is empty.
+     */
+    V_1008 = 1008,
+    /**
+     * Add an `isReadonly` field to `ApiIndexSignature` to track whether the item is readonly.
+     *
+     * When loading older JSON files, the values defaults to `false`.
+     */
+    V_1009 = 1009,
+    /**
+     * Add a `fileUrlPath` field to `ApiDeclaredItem` to track the URL to a declared item's source file.
+     *
+     * When loading older JSON files, the value defaults to `undefined`.
+     */
+    V_1010 = 1010,
+    /**
+     * Add an `isAbstract` field to `ApiClass`, `ApiMethod`, and `ApiProperty` to
+     * track whether the item is abstract.
+     *
+     * When loading older JSON files, the value defaults to `false`.
+     */
+    V_1011 = 1011,
+    /**
+     * The current latest .api.json schema version.
+     *
+     * IMPORTANT: When incrementing this number, consider whether `OLDEST_SUPPORTED` or `OLDEST_FORWARDS_COMPATIBLE`
+     * should be updated.
+     */
+    LATEST = 1011,
+    /**
+     * The oldest .api.json schema version that is still supported for backwards compatibility.
+     *
+     * This must be updated if you change to the file format and do not implement compatibility logic for
+     * deserializing the older representation.
+     */
+    OLDEST_SUPPORTED = 1001,
+    /**
+     * Used to assign `IApiPackageMetadataJson.oldestForwardsCompatibleVersion`.
+     *
+     * This value must be \<= `ApiJsonSchemaVersion.LATEST`.  It must be reset to the `LATEST` value
+     * if the older library would not be able to deserialize your new file format.  Adding a nonessential field
+     * is generally okay.  Removing, modifying, or reinterpreting existing fields is NOT safe.
+     */
+    OLDEST_FORWARDS_COMPATIBLE = 1001
+}
+export declare class DeserializerContext {
+    /**
+     * The path of the file being deserialized, which may be useful for diagnostic purposes.
+     */
+    readonly apiJsonFilename: string;
+    /**
+     * Metadata from `IApiPackageMetadataJson.toolPackage`.
+     */
+    readonly toolPackage: string;
+    /**
+     * Metadata from `IApiPackageMetadataJson.toolVersion`.
+     */
+    readonly toolVersion: string;
+    /**
+     * The version of the schema being deserialized, as obtained from `IApiPackageMetadataJson.schemaVersion`.
+     */
+    readonly versionToDeserialize: ApiJsonSchemaVersion;
+    /**
+     * The TSDoc configuration for the context.
+     */
+    readonly tsdocConfiguration: TSDocConfiguration;
+    constructor(options: DeserializerContext);
+}
+//# sourceMappingURL=DeserializerContext.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/DeserializerContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeserializerContext.d.ts","sourceRoot":"","sources":["../../src/model/DeserializerContext.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,oBAAY,oBAAoB;IAC9B;;OAEG;IACH,MAAM,OAAO;IAEb;;OAEG;IACH,MAAM,OAAO;IAEb;;OAEG;IACH,MAAM,OAAO;IAEb;;;;;OAKG;IACH,MAAM,OAAO;IAEb;;;;;OAKG;IACH,MAAM,OAAO;IAEb;;;;OAIG;IACH,MAAM,OAAO;IAEb;;;;;;;;OAQG;IACH,MAAM,OAAO;IAEb;;;;OAIG;IACH,MAAM,OAAO;IAEb;;;;;OAKG;IACH,MAAM,OAAO;IAEb;;;;OAIG;IACH,MAAM,OAAO;IAEb;;;;OAIG;IACH,MAAM,OAAO;IAEb;;;;;OAKG;IACH,MAAM,OAAO;IAEb;;;;;OAKG;IACH,MAAM,OAAS;IAEf;;;;;OAKG;IACH,gBAAgB,OAAS;IAEzB;;;;;;OAMG;IACH,0BAA0B,OAAS;CACpC;AAED,qBAAa,mBAAmB;IAC9B;;OAEG;IACH,SAAgB,eAAe,EAAE,MAAM,CAAC;IAExC;;OAEG;IACH,SAAgB,WAAW,EAAE,MAAM,CAAC;IAEpC;;OAEG;IACH,SAAgB,WAAW,EAAE,MAAM,CAAC;IAEpC;;OAEG;IACH,SAAgB,oBAAoB,EAAE,oBAAoB,CAAC;IAE3D;;OAEG;IACH,SAAgB,kBAAkB,EAAE,kBAAkB,CAAC;gBAEpC,OAAO,EAAE,mBAAmB;CAOhD"}

node_modules/@microsoft/api-extractor-model/lib/model/DeserializerContext.js

@@ -0,0 +1,115 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeserializerContext = exports.ApiJsonSchemaVersion = void 0;
+var ApiJsonSchemaVersion;
+(function (ApiJsonSchemaVersion) {
+    /**
+     * The initial release.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["V_1000"] = 1000] = "V_1000";
+    /**
+     * Add support for type parameters and type alias types.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["V_1001"] = 1001] = "V_1001";
+    /**
+     * Remove `canonicalReference` field.  This field was for diagnostic purposes only and was never deserialized.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["V_1002"] = 1002] = "V_1002";
+    /**
+     * Reintroduce the `canonicalReference` field using the experimental new TSDoc declaration reference notation.
+     *
+     * This is not a breaking change because this field is never deserialized; it is provided for informational
+     * purposes only.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["V_1003"] = 1003] = "V_1003";
+    /**
+     * Add a `tsdocConfig` field that tracks the TSDoc configuration for parsing doc comments.
+     *
+     * This is not a breaking change because an older implementation will still work correctly.  The
+     * custom tags will be skipped over by the parser.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["V_1004"] = 1004] = "V_1004";
+    /**
+     * Add an `isOptional` field to `Parameter` and `TypeParameter` to track whether a function parameter is optional.
+     *
+     * When loading older JSON files, the value defaults to `false`.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["V_1005"] = 1005] = "V_1005";
+    /**
+     * Add an `isProtected` field to `ApiConstructor`, `ApiMethod`, and `ApiProperty` to
+     * track whether a class member has the `protected` modifier.
+     *
+     * Add an `isReadonly` field to `ApiProperty`, `ApiPropertySignature`, and `ApiVariable` to
+     * track whether the item is readonly.
+     *
+     * When loading older JSON files, the values default to `false`.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["V_1006"] = 1006] = "V_1006";
+    /**
+     * Add `ApiItemContainerMixin.preserveMemberOrder` to support enums that preserve their original sort order.
+     *
+     * When loading older JSON files, the value default to `false`.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["V_1007"] = 1007] = "V_1007";
+    /**
+     * Add an `initializerTokenRange` field to `ApiProperty` and `ApiVariable` to track the item's
+     * initializer.
+     *
+     * When loading older JSON files, this range is empty.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["V_1008"] = 1008] = "V_1008";
+    /**
+     * Add an `isReadonly` field to `ApiIndexSignature` to track whether the item is readonly.
+     *
+     * When loading older JSON files, the values defaults to `false`.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["V_1009"] = 1009] = "V_1009";
+    /**
+     * Add a `fileUrlPath` field to `ApiDeclaredItem` to track the URL to a declared item's source file.
+     *
+     * When loading older JSON files, the value defaults to `undefined`.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["V_1010"] = 1010] = "V_1010";
+    /**
+     * Add an `isAbstract` field to `ApiClass`, `ApiMethod`, and `ApiProperty` to
+     * track whether the item is abstract.
+     *
+     * When loading older JSON files, the value defaults to `false`.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["V_1011"] = 1011] = "V_1011";
+    /**
+     * The current latest .api.json schema version.
+     *
+     * IMPORTANT: When incrementing this number, consider whether `OLDEST_SUPPORTED` or `OLDEST_FORWARDS_COMPATIBLE`
+     * should be updated.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["LATEST"] = 1011] = "LATEST";
+    /**
+     * The oldest .api.json schema version that is still supported for backwards compatibility.
+     *
+     * This must be updated if you change to the file format and do not implement compatibility logic for
+     * deserializing the older representation.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["OLDEST_SUPPORTED"] = 1001] = "OLDEST_SUPPORTED";
+    /**
+     * Used to assign `IApiPackageMetadataJson.oldestForwardsCompatibleVersion`.
+     *
+     * This value must be \<= `ApiJsonSchemaVersion.LATEST`.  It must be reset to the `LATEST` value
+     * if the older library would not be able to deserialize your new file format.  Adding a nonessential field
+     * is generally okay.  Removing, modifying, or reinterpreting existing fields is NOT safe.
+     */
+    ApiJsonSchemaVersion[ApiJsonSchemaVersion["OLDEST_FORWARDS_COMPATIBLE"] = 1001] = "OLDEST_FORWARDS_COMPATIBLE";
+})(ApiJsonSchemaVersion = exports.ApiJsonSchemaVersion || (exports.ApiJsonSchemaVersion = {}));
+class DeserializerContext {
+    constructor(options) {
+        this.apiJsonFilename = options.apiJsonFilename;
+        this.toolPackage = options.toolPackage;
+        this.toolVersion = options.toolVersion;
+        this.versionToDeserialize = options.versionToDeserialize;
+        this.tsdocConfiguration = options.tsdocConfiguration;
+    }
+}
+exports.DeserializerContext = DeserializerContext;
+//# sourceMappingURL=DeserializerContext.js.map

node_modules/@microsoft/api-extractor-model/lib/model/HeritageType.d.ts

@@ -0,0 +1,37 @@
+import type { Excerpt } from '../mixins/Excerpt';
+/**
+ * Represents a type referenced via an "extends" or "implements" heritage clause for a TypeScript class
+ * or interface.
+ *
+ * @remarks
+ *
+ * For example, consider this declaration:
+ *
+ * ```ts
+ * export class Widget extends Controls.WidgetBase implements Controls.IWidget, IDisposable {
+ *   // . . .
+ * }
+ * ```
+ *
+ * The heritage types are `Controls.WidgetBase`, `Controls.IWidget`, and `IDisposable`.
+ * @public
+ */
+export declare class HeritageType {
+    /**
+     * An excerpt corresponding to the referenced type.
+     * @remarks
+     *
+     * For example, consider this declaration:
+     *
+     * ```ts
+     * export class Widget extends Controls.WidgetBase implements Controls.IWidget, IDisposable {
+     *   // . . .
+     * }
+     * ```
+     *
+     * The excerpt might be `Controls.WidgetBase`, `Controls.IWidget`, or `IDisposable`.
+     */
+    readonly excerpt: Excerpt;
+    constructor(excerpt: Excerpt);
+}
+//# sourceMappingURL=HeritageType.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/HeritageType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeritageType.d.ts","sourceRoot":"","sources":["../../src/model/HeritageType.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,YAAY;IACvB;;;;;;;;;;;;;OAaG;IACH,SAAgB,OAAO,EAAE,OAAO,CAAC;gBAEd,OAAO,EAAE,OAAO;CAGpC"}

node_modules/@microsoft/api-extractor-model/lib/model/HeritageType.js

@@ -0,0 +1,29 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeritageType = void 0;
+/**
+ * Represents a type referenced via an "extends" or "implements" heritage clause for a TypeScript class
+ * or interface.
+ *
+ * @remarks
+ *
+ * For example, consider this declaration:
+ *
+ * ```ts
+ * export class Widget extends Controls.WidgetBase implements Controls.IWidget, IDisposable {
+ *   // . . .
+ * }
+ * ```
+ *
+ * The heritage types are `Controls.WidgetBase`, `Controls.IWidget`, and `IDisposable`.
+ * @public
+ */
+class HeritageType {
+    constructor(excerpt) {
+        this.excerpt = excerpt;
+    }
+}
+exports.HeritageType = HeritageType;
+//# sourceMappingURL=HeritageType.js.map

node_modules/@microsoft/api-extractor-model/lib/model/HeritageType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeritageType.js","sourceRoot":"","sources":["../../src/model/HeritageType.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAI3D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAa,YAAY;IAiBvB,YAAmB,OAAgB;QACjC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;CACF;AApBD,oCAoBC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport type { Excerpt } from '../mixins/Excerpt';\n\n/**\n * Represents a type referenced via an \"extends\" or \"implements\" heritage clause for a TypeScript class\n * or interface.\n *\n * @remarks\n *\n * For example, consider this declaration:\n *\n * ```ts\n * export class Widget extends Controls.WidgetBase implements Controls.IWidget, IDisposable {\n *   // . . .\n * }\n * ```\n *\n * The heritage types are `Controls.WidgetBase`, `Controls.IWidget`, and `IDisposable`.\n * @public\n */\nexport class HeritageType {\n  /**\n   * An excerpt corresponding to the referenced type.\n   * @remarks\n   *\n   * For example, consider this declaration:\n   *\n   * ```ts\n   * export class Widget extends Controls.WidgetBase implements Controls.IWidget, IDisposable {\n   *   // . . .\n   * }\n   * ```\n   *\n   * The excerpt might be `Controls.WidgetBase`, `Controls.IWidget`, or `IDisposable`.\n   */\n  public readonly excerpt: Excerpt;\n\n  public constructor(excerpt: Excerpt) {\n    this.excerpt = excerpt;\n  }\n}\n"]}

node_modules/@microsoft/api-extractor-model/lib/model/ModelReferenceResolver.d.ts

@@ -0,0 +1,35 @@
+import { type DocDeclarationReference } from '@microsoft/tsdoc';
+import { type ApiItem } from '../items/ApiItem';
+import type { ApiModel } from './ApiModel';
+/**
+ * Result object for {@link ApiModel.resolveDeclarationReference}.
+ *
+ * @public
+ */
+export interface IResolveDeclarationReferenceResult {
+    /**
+     * The referenced ApiItem, if the declaration reference could be resolved.
+     */
+    resolvedApiItem: ApiItem | undefined;
+    /**
+     * If resolvedApiItem is undefined, then this will always contain an error message explaining why the
+     * resolution failed.
+     */
+    errorMessage: string | undefined;
+}
+/**
+ * This resolves a TSDoc declaration reference by walking the `ApiModel` hierarchy.
+ *
+ * @remarks
+ *
+ * This class is analogous to `AstReferenceResolver` from the `@microsoft/api-extractor` project,
+ * which resolves declaration references by walking the compiler state.
+ */
+export declare class ModelReferenceResolver {
+    private readonly _apiModel;
+    constructor(apiModel: ApiModel);
+    resolve(declarationReference: DocDeclarationReference, contextApiItem: ApiItem | undefined): IResolveDeclarationReferenceResult;
+    private _selectUsingSystemSelector;
+    private _selectUsingIndexSelector;
+}
+//# sourceMappingURL=ModelReferenceResolver.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/ModelReferenceResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelReferenceResolver.d.ts","sourceRoot":"","sources":["../../src/model/ModelReferenceResolver.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,uBAAuB,EAAwC,MAAM,kBAAkB,CAAC;AACtG,OAAO,EAAE,KAAK,OAAO,EAAe,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAM3C;;;;GAIG;AACH,MAAM,WAAW,kCAAkC;IACjD;;OAEG;IACH,eAAe,EAAE,OAAO,GAAG,SAAS,CAAC;IAErC;;;OAGG;IACH,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;gBAElB,QAAQ,EAAE,QAAQ;IAI9B,OAAO,CACZ,oBAAoB,EAAE,uBAAuB,EAC7C,cAAc,EAAE,OAAO,GAAG,SAAS,GAClC,kCAAkC;IAiGrC,OAAO,CAAC,0BAA0B;IAsDlC,OAAO,CAAC,yBAAyB;CAoClC"}

node_modules/@microsoft/api-extractor-model/lib/model/ModelReferenceResolver.js

@@ -0,0 +1,181 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelReferenceResolver = void 0;
+const tsdoc_1 = require("@microsoft/tsdoc");
+const ApiItem_1 = require("../items/ApiItem");
+const ApiItemContainerMixin_1 = require("../mixins/ApiItemContainerMixin");
+const ApiParameterListMixin_1 = require("../mixins/ApiParameterListMixin");
+/**
+ * This resolves a TSDoc declaration reference by walking the `ApiModel` hierarchy.
+ *
+ * @remarks
+ *
+ * This class is analogous to `AstReferenceResolver` from the `@microsoft/api-extractor` project,
+ * which resolves declaration references by walking the compiler state.
+ */
+class ModelReferenceResolver {
+    constructor(apiModel) {
+        this._apiModel = apiModel;
+    }
+    resolve(declarationReference, contextApiItem) {
+        const result = {
+            resolvedApiItem: undefined,
+            errorMessage: undefined
+        };
+        let apiPackage = undefined;
+        // Is this an absolute reference?
+        if (declarationReference.packageName !== undefined) {
+            apiPackage = this._apiModel.tryGetPackageByName(declarationReference.packageName);
+            if (apiPackage === undefined) {
+                result.errorMessage = `The package "${declarationReference.packageName}" could not be located`;
+                return result;
+            }
+        }
+        else {
+            // If the package name is omitted, try to infer it from the context
+            if (contextApiItem !== undefined) {
+                apiPackage = contextApiItem.getAssociatedPackage();
+            }
+            if (apiPackage === undefined) {
+                result.errorMessage =
+                    `The reference does not include a package name, and the package could not be inferred` +
+                        ` from the context`;
+                return result;
+            }
+        }
+        const importPath = declarationReference.importPath || '';
+        const foundEntryPoints = apiPackage.findEntryPointsByPath(importPath);
+        if (foundEntryPoints.length !== 1) {
+            result.errorMessage = `The import path "${importPath}" could not be resolved`;
+            return result;
+        }
+        let currentItem = foundEntryPoints[0];
+        // Now search for the member reference
+        for (const memberReference of declarationReference.memberReferences) {
+            if (memberReference.memberSymbol !== undefined) {
+                result.errorMessage = `Symbols are not yet supported in declaration references`;
+                return result;
+            }
+            if (memberReference.memberIdentifier === undefined) {
+                result.errorMessage = `Missing member identifier`;
+                return result;
+            }
+            const identifier = memberReference.memberIdentifier.identifier;
+            if (!ApiItemContainerMixin_1.ApiItemContainerMixin.isBaseClassOf(currentItem)) {
+                // For example, {@link MyClass.myMethod.X} is invalid because methods cannot contain members
+                result.errorMessage = `Unable to resolve ${JSON.stringify(identifier)} because ${currentItem.getScopedNameWithinPackage()} cannot act as a container`;
+                return result;
+            }
+            const foundMembers = currentItem.findMembersByName(identifier);
+            if (foundMembers.length === 0) {
+                result.errorMessage = `The member reference ${JSON.stringify(identifier)} was not found`;
+                return result;
+            }
+            const memberSelector = memberReference.selector;
+            if (memberSelector === undefined) {
+                if (foundMembers.length > 1) {
+                    result.errorMessage = `The member reference ${JSON.stringify(identifier)} was ambiguous`;
+                    return result;
+                }
+                currentItem = foundMembers[0];
+            }
+            else {
+                let memberSelectorResult;
+                switch (memberSelector.selectorKind) {
+                    case tsdoc_1.SelectorKind.System:
+                        memberSelectorResult = this._selectUsingSystemSelector(foundMembers, memberSelector, identifier);
+                        break;
+                    case tsdoc_1.SelectorKind.Index:
+                        memberSelectorResult = this._selectUsingIndexSelector(foundMembers, memberSelector, identifier);
+                        break;
+                    default:
+                        result.errorMessage = `The selector "${memberSelector.selector}" is not a supported selector type`;
+                        return result;
+                }
+                if (memberSelectorResult.resolvedApiItem === undefined) {
+                    return memberSelectorResult;
+                }
+                currentItem = memberSelectorResult.resolvedApiItem;
+            }
+        }
+        result.resolvedApiItem = currentItem;
+        return result;
+    }
+    _selectUsingSystemSelector(foundMembers, memberSelector, identifier) {
+        const result = {
+            resolvedApiItem: undefined,
+            errorMessage: undefined
+        };
+        const selectorName = memberSelector.selector;
+        let selectorItemKind;
+        switch (selectorName) {
+            case 'class':
+                selectorItemKind = ApiItem_1.ApiItemKind.Class;
+                break;
+            case 'enum':
+                selectorItemKind = ApiItem_1.ApiItemKind.Enum;
+                break;
+            case 'function':
+                selectorItemKind = ApiItem_1.ApiItemKind.Function;
+                break;
+            case 'interface':
+                selectorItemKind = ApiItem_1.ApiItemKind.Interface;
+                break;
+            case 'namespace':
+                selectorItemKind = ApiItem_1.ApiItemKind.Namespace;
+                break;
+            case 'type':
+                selectorItemKind = ApiItem_1.ApiItemKind.TypeAlias;
+                break;
+            case 'variable':
+                selectorItemKind = ApiItem_1.ApiItemKind.Variable;
+                break;
+            default:
+                result.errorMessage = `Unsupported system selector "${selectorName}"`;
+                return result;
+        }
+        const matches = foundMembers.filter((x) => x.kind === selectorItemKind);
+        if (matches.length === 0) {
+            result.errorMessage =
+                `A declaration for "${identifier}" was not found that matches the` +
+                    ` TSDoc selector "${selectorName}"`;
+            return result;
+        }
+        if (matches.length > 1) {
+            result.errorMessage = `More than one declaration "${identifier}" matches the TSDoc selector "${selectorName}"`;
+        }
+        result.resolvedApiItem = matches[0];
+        return result;
+    }
+    _selectUsingIndexSelector(foundMembers, memberSelector, identifier) {
+        const result = {
+            resolvedApiItem: undefined,
+            errorMessage: undefined
+        };
+        const selectedMembers = [];
+        const selectorOverloadIndex = parseInt(memberSelector.selector, 10);
+        for (const foundMember of foundMembers) {
+            if (ApiParameterListMixin_1.ApiParameterListMixin.isBaseClassOf(foundMember)) {
+                if (foundMember.overloadIndex === selectorOverloadIndex) {
+                    selectedMembers.push(foundMember);
+                }
+            }
+        }
+        if (selectedMembers.length === 0) {
+            result.errorMessage =
+                `An overload for ${JSON.stringify(identifier)} was not found that matches` +
+                    ` the TSDoc selector ":${selectorOverloadIndex}"`;
+            return result;
+        }
+        if (selectedMembers.length === 1) {
+            result.resolvedApiItem = selectedMembers[0];
+            return result;
+        }
+        result.errorMessage = `The member reference ${JSON.stringify(identifier)} was ambiguous`;
+        return result;
+    }
+}
+exports.ModelReferenceResolver = ModelReferenceResolver;
+//# sourceMappingURL=ModelReferenceResolver.js.map

node_modules/@microsoft/api-extractor-model/lib/model/Parameter.d.ts

@@ -0,0 +1,51 @@
+import type * as tsdoc from '@microsoft/tsdoc';
+import type { Excerpt } from '../mixins/Excerpt';
+import type { ApiParameterListMixin } from '../mixins/ApiParameterListMixin';
+/**
+ * Constructor options for {@link Parameter}.
+ * @public
+ */
+export interface IParameterOptions {
+    name: string;
+    parameterTypeExcerpt: Excerpt;
+    isOptional: boolean;
+    parent: ApiParameterListMixin;
+}
+/**
+ * Represents a named parameter for a function-like declaration.
+ *
+ * @remarks
+ *
+ * `Parameter` represents a TypeScript declaration such as `x: number` in this example:
+ *
+ * ```ts
+ * export function add(x: number, y: number): number {
+ *   return x + y;
+ * }
+ * ```
+ *
+ * `Parameter` objects belong to the {@link (ApiParameterListMixin:interface).parameters} collection.
+ *
+ * @public
+ */
+export declare class Parameter {
+    /**
+     * An {@link Excerpt} that describes the type of the parameter.
+     */
+    readonly parameterTypeExcerpt: Excerpt;
+    /**
+     * The parameter name.
+     */
+    name: string;
+    /**
+     * Whether the parameter is optional.
+     */
+    isOptional: boolean;
+    private _parent;
+    constructor(options: IParameterOptions);
+    /**
+     * Returns the `@param` documentation for this parameter, if present.
+     */
+    get tsdocParamBlock(): tsdoc.DocParamBlock | undefined;
+}
+//# sourceMappingURL=Parameter.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/Parameter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Parameter.d.ts","sourceRoot":"","sources":["../../src/model/Parameter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAG/C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAE7E;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,EAAE,OAAO,CAAC;IAC9B,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,qBAAqB,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,SAAS;IACpB;;OAEG;IACH,SAAgB,oBAAoB,EAAE,OAAO,CAAC;IAE9C;;OAEG;IACI,IAAI,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACI,UAAU,EAAE,OAAO,CAAC;IAE3B,OAAO,CAAC,OAAO,CAAwB;gBAEpB,OAAO,EAAE,iBAAiB;IAO7C;;OAEG;IACH,IAAW,eAAe,IAAI,KAAK,CAAC,aAAa,GAAG,SAAS,CAM5D;CACF"}

node_modules/@microsoft/api-extractor-model/lib/model/Parameter.js

@@ -0,0 +1,43 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parameter = void 0;
+const ApiDocumentedItem_1 = require("../items/ApiDocumentedItem");
+/**
+ * Represents a named parameter for a function-like declaration.
+ *
+ * @remarks
+ *
+ * `Parameter` represents a TypeScript declaration such as `x: number` in this example:
+ *
+ * ```ts
+ * export function add(x: number, y: number): number {
+ *   return x + y;
+ * }
+ * ```
+ *
+ * `Parameter` objects belong to the {@link (ApiParameterListMixin:interface).parameters} collection.
+ *
+ * @public
+ */
+class Parameter {
+    constructor(options) {
+        this.name = options.name;
+        this.parameterTypeExcerpt = options.parameterTypeExcerpt;
+        this.isOptional = options.isOptional;
+        this._parent = options.parent;
+    }
+    /**
+     * Returns the `@param` documentation for this parameter, if present.
+     */
+    get tsdocParamBlock() {
+        if (this._parent instanceof ApiDocumentedItem_1.ApiDocumentedItem) {
+            if (this._parent.tsdocComment) {
+                return this._parent.tsdocComment.params.tryGetBlockByName(this.name);
+            }
+        }
+    }
+}
+exports.Parameter = Parameter;
+//# sourceMappingURL=Parameter.js.map

node_modules/@microsoft/api-extractor-model/lib/model/Parameter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Parameter.js","sourceRoot":"","sources":["../../src/model/Parameter.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAI3D,kEAA+D;AAe/D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAa,SAAS;IAkBpB,YAAmB,OAA0B;QAC3C,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QACzB,IAAI,CAAC,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC;QACzD,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;QACrC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,IAAW,eAAe;QACxB,IAAI,IAAI,CAAC,OAAO,YAAY,qCAAiB,EAAE;YAC7C,IAAI,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE;gBAC7B,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACtE;SACF;IACH,CAAC;CACF;AAnCD,8BAmCC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport type * as tsdoc from '@microsoft/tsdoc';\n\nimport { ApiDocumentedItem } from '../items/ApiDocumentedItem';\nimport type { Excerpt } from '../mixins/Excerpt';\nimport type { ApiParameterListMixin } from '../mixins/ApiParameterListMixin';\n\n/**\n * Constructor options for {@link Parameter}.\n * @public\n */\nexport interface IParameterOptions {\n  name: string;\n  parameterTypeExcerpt: Excerpt;\n  isOptional: boolean;\n  parent: ApiParameterListMixin;\n}\n\n/**\n * Represents a named parameter for a function-like declaration.\n *\n * @remarks\n *\n * `Parameter` represents a TypeScript declaration such as `x: number` in this example:\n *\n * ```ts\n * export function add(x: number, y: number): number {\n *   return x + y;\n * }\n * ```\n *\n * `Parameter` objects belong to the {@link (ApiParameterListMixin:interface).parameters} collection.\n *\n * @public\n */\nexport class Parameter {\n  /**\n   * An {@link Excerpt} that describes the type of the parameter.\n   */\n  public readonly parameterTypeExcerpt: Excerpt;\n\n  /**\n   * The parameter name.\n   */\n  public name: string;\n\n  /**\n   * Whether the parameter is optional.\n   */\n  public isOptional: boolean;\n\n  private _parent: ApiParameterListMixin;\n\n  public constructor(options: IParameterOptions) {\n    this.name = options.name;\n    this.parameterTypeExcerpt = options.parameterTypeExcerpt;\n    this.isOptional = options.isOptional;\n    this._parent = options.parent;\n  }\n\n  /**\n   * Returns the `@param` documentation for this parameter, if present.\n   */\n  public get tsdocParamBlock(): tsdoc.DocParamBlock | undefined {\n    if (this._parent instanceof ApiDocumentedItem) {\n      if (this._parent.tsdocComment) {\n        return this._parent.tsdocComment.params.tryGetBlockByName(this.name);\n      }\n    }\n  }\n}\n"]}

node_modules/@microsoft/api-extractor-model/lib/model/SourceLocation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Constructor options for `SourceLocation`.
+ * @public
+ */
+export interface ISourceLocationOptions {
+    /**
+     * The project folder URL as defined by the `api-extractor.json` config `projectFolderUrl`
+     * setting.
+     */
+    projectFolderUrl?: string;
+    /**
+     * The file URL path relative to the `projectFolder` and `projectFolderURL` fields as
+     * defined in the `api-extractor.json` config.
+     */
+    fileUrlPath?: string;
+}
+/**
+ * The source location where a given API item is declared.
+ *
+ * @remarks
+ * The source location points to the `.ts` source file where the API item was originally
+   declared. However, in some cases, if source map resolution fails, it falls back to pointing
+   to the `.d.ts` file instead.
+ *
+ * @public
+ */
+export declare class SourceLocation {
+    private readonly _projectFolderUrl?;
+    private readonly _fileUrlPath?;
+    constructor(options: ISourceLocationOptions);
+    /**
+     * Returns the file URL to the given source location. Returns `undefined` if the file URL
+     * cannot be determined.
+     */
+    get fileUrl(): string | undefined;
+}
+//# sourceMappingURL=SourceLocation.d.ts.map

node_modules/@microsoft/api-extractor-model/lib/model/SourceLocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SourceLocation.d.ts","sourceRoot":"","sources":["../../src/model/SourceLocation.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;GASG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAS;gBAEpB,OAAO,EAAE,sBAAsB;IAKlD;;;OAGG;IACH,IAAW,OAAO,IAAI,MAAM,GAAG,SAAS,CAYvC;CACF"}

node_modules/@microsoft/api-extractor-model/lib/model/SourceLocation.js

@@ -0,0 +1,39 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceLocation = void 0;
+const url_1 = require("url");
+/**
+ * The source location where a given API item is declared.
+ *
+ * @remarks
+ * The source location points to the `.ts` source file where the API item was originally
+   declared. However, in some cases, if source map resolution fails, it falls back to pointing
+   to the `.d.ts` file instead.
+ *
+ * @public
+ */
+class SourceLocation {
+    constructor(options) {
+        this._projectFolderUrl = options.projectFolderUrl;
+        this._fileUrlPath = options.fileUrlPath;
+    }
+    /**
+     * Returns the file URL to the given source location. Returns `undefined` if the file URL
+     * cannot be determined.
+     */
+    get fileUrl() {
+        if (this._projectFolderUrl === undefined || this._fileUrlPath === undefined) {
+            return undefined;
+        }
+        let projectFolderUrl = this._projectFolderUrl;
+        if (!projectFolderUrl.endsWith('/')) {
+            projectFolderUrl += '/';
+        }
+        const url = new url_1.URL(this._fileUrlPath, projectFolderUrl);
+        return url.href;
+    }
+}
+exports.SourceLocation = SourceLocation;
+//# sourceMappingURL=SourceLocation.js.map

node_modules/@microsoft/api-extractor-model/lib/model/SourceLocation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SourceLocation.js","sourceRoot":"","sources":["../../src/model/SourceLocation.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,6BAA0B;AAoB1B;;;;;;;;;GASG;AACH,MAAa,cAAc;IAIzB,YAAmB,OAA+B;QAChD,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;QAClD,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IAC1C,CAAC;IAED;;;OAGG;IACH,IAAW,OAAO;QAChB,IAAI,IAAI,CAAC,iBAAiB,KAAK,SAAS,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;YAC3E,OAAO,SAAS,CAAC;SAClB;QAED,IAAI,gBAAgB,GAAW,IAAI,CAAC,iBAAiB,CAAC;QACtD,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;YACnC,gBAAgB,IAAI,GAAG,CAAC;SACzB;QAED,MAAM,GAAG,GAAQ,IAAI,SAAG,CAAC,IAAI,CAAC,YAAY,EAAE,gBAAgB,CAAC,CAAC;QAC9D,OAAO,GAAG,CAAC,IAAI,CAAC;IAClB,CAAC;CACF;AA1BD,wCA0BC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport { URL } from 'url';\n\n/**\n * Constructor options for `SourceLocation`.\n * @public\n */\nexport interface ISourceLocationOptions {\n  /**\n   * The project folder URL as defined by the `api-extractor.json` config `projectFolderUrl`\n   * setting.\n   */\n  projectFolderUrl?: string;\n\n  /**\n   * The file URL path relative to the `projectFolder` and `projectFolderURL` fields as\n   * defined in the `api-extractor.json` config.\n   */\n  fileUrlPath?: string;\n}\n\n/**\n * The source location where a given API item is declared.\n *\n * @remarks\n * The source location points to the `.ts` source file where the API item was originally\n   declared. However, in some cases, if source map resolution fails, it falls back to pointing\n   to the `.d.ts` file instead.\n *\n * @public\n */\nexport class SourceLocation {\n  private readonly _projectFolderUrl?: string;\n  private readonly _fileUrlPath?: string;\n\n  public constructor(options: ISourceLocationOptions) {\n    this._projectFolderUrl = options.projectFolderUrl;\n    this._fileUrlPath = options.fileUrlPath;\n  }\n\n  /**\n   * Returns the file URL to the given source location. Returns `undefined` if the file URL\n   * cannot be determined.\n   */\n  public get fileUrl(): string | undefined {\n    if (this._projectFolderUrl === undefined || this._fileUrlPath === undefined) {\n      return undefined;\n    }\n\n    let projectFolderUrl: string = this._projectFolderUrl;\n    if (!projectFolderUrl.endsWith('/')) {\n      projectFolderUrl += '/';\n    }\n\n    const url: URL = new URL(this._fileUrlPath, projectFolderUrl);\n    return url.href;\n  }\n}\n"]}