@mnaoumov/typescript-dev-toolkit 1.3.1 → 2.1.0

package/dist/lib/cjs/commitlint-config.d.cts

@@ -11,4 +11,10 @@ import type { UserConfig } from '@commitlint/types' with { 'resolution-mode': 'i
  * a rule spellchecking the header the way the release spellchecks the changelog bullet it becomes (a no-op in a
  * project with no `spellcheck` script).
  */
+export declare const commitlintConfig: UserConfig;
+/**
+ * The previous name of {@link commitlintConfig}.
+ *
+ * @deprecated Use {@link commitlintConfig}. This alias is removed in the next major.
+ */
 export declare const obsidianDevUtilsConfig: UserConfig;

package/dist/lib/cjs/commitlint-forbidden-patterns.cjs

@@ -29,7 +29,7 @@ __export(commitlint_forbidden_patterns_exports, {
 });
 module.exports = __toCommonJS(commitlint_forbidden_patterns_exports);
 var import_forbidden_patterns = require('./forbidden-patterns.cjs');
-const NO_FORBIDDEN_PATTERNS_RULE_NAME = "obsidian-dev-utils/no-forbidden-patterns";
+const NO_FORBIDDEN_PATTERNS_RULE_NAME = "typescript-dev-toolkit/no-forbidden-patterns";
 async function noForbiddenPatternsRule(commit) {
   const patterns = await (0, import_forbidden_patterns.readForbiddenPatterns)();
   const text = [commit.header, commit.body, commit.footer].filter((part) => part !== null).join("\n");
@@ -52,4 +52,4 @@ const forbiddenPatternsPlugin = {
   forbiddenPatternsPlugin,
   noForbiddenPatternsRule
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/commitlint-forbidden-patterns.d.cts

@@ -18,7 +18,7 @@ import type { AsyncRule, Plugin, RuleOutcome } from '@commitlint/types' with { '
 /**
  * The name the rule is registered under.
  */
-export declare const NO_FORBIDDEN_PATTERNS_RULE_NAME = "obsidian-dev-utils/no-forbidden-patterns";
+export declare const NO_FORBIDDEN_PATTERNS_RULE_NAME = "typescript-dev-toolkit/no-forbidden-patterns";
 type Commit = Parameters<AsyncRule>[0];
 /**
  * Checks the whole commit message — header, body and footer — against the forbidden patterns.

package/dist/lib/cjs/commitlint-spellcheck-header.cjs

@@ -32,7 +32,7 @@ var import_cspell_content = require('./linters/cspell-content.cjs');
 var import_npm = require('./npm.cjs');
 var import_repo_paths = require('./repo-paths.cjs');
 var import_root = require('./root.cjs');
-const SPELLCHECK_HEADER_RULE_NAME = "obsidian-dev-utils/spellcheck-header";
+const SPELLCHECK_HEADER_RULE_NAME = "typescript-dev-toolkit/spellcheck-header";
 const SPELLCHECK_SCRIPT_NAME = "spellcheck";
 async function spellcheckHeaderRule(commit) {
   if (!commit.header) {
@@ -68,4 +68,4 @@ const spellcheckHeaderPlugin = {
   spellcheckHeaderPlugin,
   spellcheckHeaderRule
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2NvbW1pdGxpbnQtc3BlbGxjaGVjay1oZWFkZXIudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBBIGNvbW1pdGxpbnQgcnVsZSB0aGF0IHNwZWxsY2hlY2tzIGEgY29tbWl0IEhFQURFUiB3aXRoIHRoZSBwcm9qZWN0J3Mgb3duIGBzcGVsbGNoZWNrYCBjb25maWd1cmF0aW9uLlxuICpcbiAqIFRoZSBoZWFkZXIgaXMgdGhlIG9uZSBwYXJ0IG9mIGEgY29tbWl0IG1lc3NhZ2UgdGhhdCBzaGlwcyB2ZXJiYXRpbTogYSByZWxlYXNlIHR1cm5zIGV2ZXJ5IGNvbW1pdCBzdWJqZWN0XG4gKiBzaW5jZSB0aGUgbGFzdCB0YWcgaW50byBhIGAtIDxzdWJqZWN0PmAgYnVsbGV0IG9mIHRoZSBuZXcgYENIQU5HRUxPRy5tZGAgc2VjdGlvbiwgYW5kIHNwZWxsY2hlY2tzIHRoYXRcbiAqIHNlY3Rpb24gYmVmb3JlIHdyaXRpbmcgaXQuIFRoYXQgY2hlY2sgd29ya3MsIGJ1dCBpdCBydW5zIGF0IHJlbGVhc2UgdGltZSwgYWZ0ZXIgdGhlIHdob2xlIHByZWZsaWdodCBnYXRlLFxuICogYW5kIHdlZWtzIGFmdGVyIHRoZSBzdWJqZWN0IHdhcyBwdXNoZWQgdG8gdGhlIGRlZmF1bHQgYnJhbmNoLiBBdCB0aGF0IHBvaW50IHRoZSBvbmx5IGZpeGVzIGFyZSByZXdyaXRpbmdcbiAqIHB1Ymxpc2hlZCBoaXN0b3J5IG9yIHN1cHBseWluZyB0aGUgcmVsZWFzZSBub3RlcyBieSBoYW5kLiBUaGUgY29tbWl0LW1zZyBob29rIGlzIHRoZSBsYXN0IHBvaW50IGF0IHdoaWNoXG4gKiB0aGUgd29yZCBjYW4gc3RpbGwgYmUgY2hhbmdlZCBmb3IgZnJlZS5cbiAqXG4gKiBUaGUgaGVhZGVyIGlzIGNoZWNrZWQgQVMgdGhlIGJ1bGxldCBpdCB3aWxsIGJlY29tZSwgYXR0cmlidXRlZCB0byBgQ0hBTkdFTE9HLm1kYCwgc28gdGhlIHZlcmRpY3QgaXMgdGhlIG9uZVxuICogdGhlIHJlbGVhc2Ugd291bGQgZ2l2ZTogdGhlIHNhbWUgYGNzcGVsbGAgY29uZmlndXJhdGlvbiwgdGhlIHNhbWUgYHdvcmRzYCwgdGhlIHNhbWUgYGlnbm9yZVBhdGhzYC4gQW5kIGl0XG4gKiBydW5zIG9ubHkgd2hlcmUgdGhlIHByb2plY3QgZGVmaW5lcyBhIGBzcGVsbGNoZWNrYCBzY3JpcHQsIHdoaWNoIGlzIHRoZSBjb25kaXRpb24gdGhlIHJlbGVhc2UgYXBwbGllcyB0b28uXG4gKiBBIHByb2plY3Qgd2l0aCBubyBzcGVsbGluZyBjb25maWd1cmF0aW9uIHdvdWxkIG90aGVyd2lzZSBoYXZlIGl0cyBjb21taXRzIGp1ZGdlZCBhZ2FpbnN0IHRoZSBzdG9ja1xuICogZGljdGlvbmFyaWVzIGFsb25lLCBhbmQgcmVmdXNlZCBvdmVyIGl0cyBvd24gbmFtZS5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7XG4gIEFzeW5jUnVsZSxcbiAgUGx1Z2luLFxuICBSdWxlT3V0Y29tZVxufSBmcm9tICdAY29tbWl0bGludC90eXBlcyc7XG5cbmltcG9ydCB7IHNwZWxsY2hlY2tDb250ZW50IH0gZnJvbSAnLi9saW50ZXJzL2NzcGVsbC1jb250ZW50LnRzJztcbmltcG9ydCB7IHJlYWRQYWNrYWdlSnNvbiB9IGZyb20gJy4vbnBtLnRzJztcbmltcG9ydCB7IFJlcG9QYXRocyB9IGZyb20gJy4vcmVwby1wYXRocy50cyc7XG5pbXBvcnQgeyByZXNvbHZlUGF0aEZyb21Sb290U2FmZSB9IGZyb20gJy4vcm9vdC50cyc7XG5cbi8qKlxuICogVGhlIG5hbWUgdGhlIHJ1bGUgaXMgcmVnaXN0ZXJlZCB1bmRlci5cbiAqL1xuZXhwb3J0IGNvbnN0IFNQRUxMQ0hFQ0tfSEVBREVSX1JVTEVfTkFNRSA9ICdvYnNpZGlhbi1kZXYtdXRpbHMvc3BlbGxjaGVjay1oZWFkZXInO1xuXG4vKipcbiAqIFRoZSBucG0gc2NyaXB0IHdob3NlIHByZXNlbmNlIG9wdHMgYSBwcm9qZWN0IGludG8gdGhlIGNoZWNrLlxuICovXG5jb25zdCBTUEVMTENIRUNLX1NDUklQVF9OQU1FID0gJ3NwZWxsY2hlY2snO1xuXG50eXBlIENvbW1pdCA9IFBhcmFtZXRlcnM8QXN5bmNSdWxlPlswXTtcblxuLyoqXG4gKiBTcGVsbGNoZWNrcyB0aGUgY29tbWl0IGhlYWRlciBhcyB0aGUgY2hhbmdlbG9nIGJ1bGxldCBpdCB3aWxsIGJlY29tZS5cbiAqXG4gKiBPbmx5IHRoZSBgYWx3YXlzYCBjb25kaXRpb24gaXMgbWVhbmluZ2Z1bDogYG5ldmVyYCB3b3VsZCByZXF1aXJlIHRoZSBoZWFkZXIgdG8gYmUgbWlzc3BlbGxlZCwgc28gaXQgaXNcbiAqIHRyZWF0ZWQgdGhlIHNhbWUgd2F5IHJhdGhlciB0aGFuIGludmVydGVkLlxuICpcbiAqIEBwYXJhbSBjb21taXQgLSBUaGUgcGFyc2VkIGNvbW1pdC5cbiAqIEByZXR1cm5zIEEge0BsaW5rIFByb21pc2V9IHRoYXQgcmVzb2x2ZXMgdG8gdGhlIHJ1bGUgb3V0Y29tZSwgbmFtaW5nIGVhY2ggdW5rbm93biB3b3JkLlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gc3BlbGxjaGVja0hlYWRlclJ1bGUoY29tbWl0OiBDb21taXQpOiBQcm9taXNlPFJ1bGVPdXRjb21lPiB7XG4gIGlmICghY29tbWl0LmhlYWRlcikge1xuICAgIHJldHVybiBbdHJ1ZV07XG4gIH1cblxuICBjb25zdCBwYWNrYWdlSnNvbiA9IGF3YWl0IHJlYWRQYWNrYWdlSnNvbigpO1xuICBpZiAoIU9iamVjdC5rZXlzKHBhY2thZ2VKc29uLnNjcmlwdHMgPz8ge30pLmluY2x1ZGVzKFNQRUxMQ0hFQ0tfU0NSSVBUX05BTUUpKSB7XG4gICAgcmV0dXJuIFt0cnVlXTtcbiAgfVxuXG4gIGNvbnN0IGZpbmRpbmdzID0gYXdhaXQgc3BlbGxjaGVja0NvbnRlbnQoe1xuICAgIGNvbnRlbnQ6IGAtICR7Y29tbWl0LmhlYWRlcn1cXG5gLFxuICAgIGZpbGVQYXRoOiByZXNvbHZlUGF0aEZyb21Sb290U2FmZSh7IHBhdGg6IFJlcG9QYXRocy5DaGFuZ2Vsb2dNZCB9KVxuICB9KTtcblxuICBpZiAoZmluZGluZ3MubGVuZ3RoID09PSAwKSB7XG4gICAgcmV0dXJuIFt0cnVlXTtcbiAgfVxuXG4gIHJldHVybiBbXG4gICAgZmFsc2UsXG4gICAgYHRoZSBoZWFkZXIgZG9lcyBub3QgcGFzcyBcXGAke1NQRUxMQ0hFQ0tfU0NSSVBUX05BTUV9XFxgLCBhbmQgaXQgc2hpcHMgdmVyYmF0aW0gaW50byB0aGUgbmV4dCByZWxlYXNlJ3MgY2hhbmdlbG9nOlxcbmBcbiAgICArIGAke2ZpbmRpbmdzLmpvaW4oJ1xcbicpfVxcbmBcbiAgICArICdSZXdvcmQgaXQsIG9yLCBmb3IgYSB3b3JkIHRoaXMgcHJvamVjdCByZWFsbHkgZG9lcyB1c2UsIGFkZCBpdCB0byB0aGUgcHJvamVjdFxcJ3MgYGNzcGVsbGAgY29uZmlndXJhdGlvbi4nXG4gIF07XG59XG5cbi8qKlxuICogVGhlIGNvbW1pdGxpbnQgcGx1Z2luIGNhcnJ5aW5nIHtAbGluayBzcGVsbGNoZWNrSGVhZGVyUnVsZX0uXG4gKi9cbmV4cG9ydCBjb25zdCBzcGVsbGNoZWNrSGVhZGVyUGx1Z2luOiBQbHVnaW4gPSB7XG4gIHJ1bGVzOiB7XG4gICAgW1NQRUxMQ0hFQ0tfSEVBREVSX1JVTEVfTkFNRV06IHNwZWxsY2hlY2tIZWFkZXJSdWxlXG4gIH1cbn07XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBeUJBLDRCQUFrQztBQUNsQyxpQkFBZ0M7QUFDaEMsd0JBQTBCO0FBQzFCLGtCQUF3QztBQUtqQyxNQUFNLDhCQUE4QjtBQUszQyxNQUFNLHlCQUF5QjtBQWEvQixlQUFzQixxQkFBcUIsUUFBc0M7QUFDL0UsTUFBSSxDQUFDLE9BQU8sUUFBUTtBQUNsQixXQUFPLENBQUMsSUFBSTtBQUFBLEVBQ2Q7QUFFQSxRQUFNLGNBQWMsVUFBTSw0QkFBZ0I7QUFDMUMsTUFBSSxDQUFDLE9BQU8sS0FBSyxZQUFZLFdBQVcsQ0FBQyxDQUFDLEVBQUUsU0FBUyxzQkFBc0IsR0FBRztBQUM1RSxXQUFPLENBQUMsSUFBSTtBQUFBLEVBQ2Q7QUFFQSxRQUFNLFdBQVcsVUFBTSx5Q0FBa0I7QUFBQSxJQUN2QyxTQUFTLEtBQUssT0FBTyxNQUFNO0FBQUE7QUFBQSxJQUMzQixjQUFVLHFDQUF3QixFQUFFLE1BQU0sNEJBQVUsWUFBWSxDQUFDO0FBQUEsRUFDbkUsQ0FBQztBQUVELE1BQUksU0FBUyxXQUFXLEdBQUc7QUFDekIsV0FBTyxDQUFDLElBQUk7QUFBQSxFQUNkO0FBRUEsU0FBTztBQUFBLElBQ0w7QUFBQSxJQUNBLDhCQUE4QixzQkFBc0I7QUFBQSxFQUMvQyxTQUFTLEtBQUssSUFBSSxDQUFDO0FBQUE7QUFBQSxFQUUxQjtBQUNGO0FBS08sTUFBTSx5QkFBaUM7QUFBQSxFQUM1QyxPQUFPO0FBQUEsSUFDTCxDQUFDLDJCQUEyQixHQUFHO0FBQUEsRUFDakM7QUFDRjsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/commitlint-spellcheck-header.d.cts

@@ -21,7 +21,7 @@ import type { AsyncRule, Plugin, RuleOutcome } from '@commitlint/types' with { '
 /**
  * The name the rule is registered under.
  */
-export declare const SPELLCHECK_HEADER_RULE_NAME = "obsidian-dev-utils/spellcheck-header";
+export declare const SPELLCHECK_HEADER_RULE_NAME = "typescript-dev-toolkit/spellcheck-header";
 type Commit = Parameters<AsyncRule>[0];
 /**
  * Spellchecks the commit header as the changelog bullet it will become.

package/dist/lib/cjs/docs-site/api-doc-constants.cjs

@@ -0,0 +1,171 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_doc_constants_exports = {};
+__export(api_doc_constants_exports, {
+  EVENT_METHODS: () => EVENT_METHODS,
+  GENERIC_TYPE_PARAMS: () => GENERIC_TYPE_PARAMS,
+  TS_GLOBAL_TYPES: () => TS_GLOBAL_TYPES,
+  TS_PRIMITIVE_TYPES: () => TS_PRIMITIVE_TYPES,
+  TS_UTILITY_TYPES: () => TS_UTILITY_TYPES
+});
+module.exports = __toCommonJS(api_doc_constants_exports);
+const EVENT_METHODS = /* @__PURE__ */ new Set(["off", "on", "trigger", "tryTrigger"]);
+const GENERIC_TYPE_PARAMS = /* @__PURE__ */ new Set([
+  "Arg",
+  "Args",
+  // Short identifiers / enum-like values that aren't types
+  "ASC",
+  "Callback",
+  "ComponentType",
+  "DESC",
+  "DOMContentLoaded",
+  "GET",
+  "HookCallback",
+  "HookName",
+  "ID",
+  "Input",
+  "Instance",
+  "Item",
+  "K",
+  "Key",
+  "Marked",
+  "O",
+  "Output",
+  "Owner",
+  "P",
+  "POST",
+  "R",
+  "S",
+  "Suspects",
+  "T",
+  "TFunction",
+  "TModal",
+  "TView",
+  "TViewType",
+  "U",
+  "UserProperties",
+  "V",
+  "VIEW"
+]);
+const TS_HANDBOOK = "https://www.typescriptlang.org/docs/handbook";
+const TS_PRIMITIVE_TYPES = {
+  any: `${TS_HANDBOOK}/2/everyday-types.html#any`,
+  boolean: `${TS_HANDBOOK}/basic-types.html#boolean`,
+  never: `${TS_HANDBOOK}/basic-types.html#never`,
+  null: `${TS_HANDBOOK}/basic-types.html#null-and-undefined`,
+  number: `${TS_HANDBOOK}/basic-types.html#number`,
+  object: `${TS_HANDBOOK}/basic-types.html#object`,
+  string: `${TS_HANDBOOK}/basic-types.html#string`,
+  symbol: `${TS_HANDBOOK}/symbols.html`,
+  undefined: `${TS_HANDBOOK}/basic-types.html#null-and-undefined`,
+  unknown: `${TS_HANDBOOK}/2/functions.html#unknown`,
+  void: `${TS_HANDBOOK}/basic-types.html#void`
+};
+const TS_UTILITY_TYPES = /* @__PURE__ */ new Map([
+  ["Awaited", "awaitedtype"],
+  ["Capitalize", "capitalizestringtype"],
+  ["ConstructorParameters", "constructorparameterstype"],
+  ["Exclude", "excludeuniontype-excludedmembers"],
+  ["Extract", "extracttype-union"],
+  ["InstanceType", "instancetypetype"],
+  ["Iterable", "iterable-interface"],
+  ["Lowercase", "lowercasestringtype"],
+  ["NoInfer", "noinfertype"],
+  ["NonNullable", "nonnullabletype"],
+  ["Omit", "omittype-keys"],
+  ["OmitThisParameter", "omitthisparametertype"],
+  ["Parameters", "parameterstype"],
+  ["Partial", "partialtype"],
+  ["Pick", "picktype-keys"],
+  ["Readonly", "readonlytype"],
+  ["Record", "recordkeys-type"],
+  ["Required", "requiredtype"],
+  ["ReturnType", "returntypetype"],
+  ["ThisParameterType", "thisparametertypetype"],
+  ["ThisType", "thistypetype"],
+  ["Uncapitalize", "uncapitalizestringtype"],
+  ["Uppercase", "uppercasestringtype"]
+]);
+const TS_GLOBAL_TYPES = {
+  AddEventListenerOptions: "https://developer.mozilla.org/docs/Web/API/EventTarget/addEventListener#options",
+  AnimationFrameProvider: "https://raw.githubusercontent.com/microsoft/TypeScript/38c3279e29e45c274c408d909394b7bf45c24fdc/src/lib/dom.generated.d.ts#L3756",
+  Array: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array",
+  ArrayBufferLike: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer",
+  ArrayLike: "https://www.typescriptlang.org/docs/handbook/2/indexed-access-types.html",
+  BodyInit: "https://developer.mozilla.org/docs/Web/API/Request/Request#body",
+  Buffer: "https://nodejs.org/api/buffer.html#class-buffer",
+  CanvasRenderingContext2DSettings: "https://developer.mozilla.org/docs/Web/API/HTMLCanvasElement/getContext#contextattributes",
+  DocumentEventMap: "https://developer.mozilla.org/docs/Web/API/Document#events",
+  DocumentOrShadowRoot: "https://developer.mozilla.org/docs/Web/API/Document",
+  Error: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error",
+  EventListenerOptions: "https://developer.mozilla.org/docs/Web/API/EventTarget/removeEventListener#options",
+  EventListenerOrEventListenerObject: "https://developer.mozilla.org/docs/Web/API/EventTarget/addEventListener#the_event_listener_callback",
+  FSWatcher: "https://nodejs.org/api/fs.html#class-fsfswatcher",
+  Function: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Function",
+  GlobalEventHandlers: "https://raw.githubusercontent.com/microsoft/TypeScript/38c3279e29e45c274c408d909394b7bf45c24fdc/src/lib/dom.generated.d.ts#L16746",
+  HeadersInit: "https://developer.mozilla.org/docs/Web/API/Headers/Headers#init",
+  HTMLElementEventMap: "https://developer.mozilla.org/docs/Web/API/HTMLElement#events",
+  HTMLElementTagNameMap: "https://developer.mozilla.org/docs/Web/API/Document/createElement",
+  Iterable: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Iteration_protocols",
+  Iterator: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Iterator",
+  Map: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Map",
+  NonElementParentNode: "https://raw.githubusercontent.com/microsoft/TypeScript/38c3279e29e45c274c408d909394b7bf45c24fdc/src/lib/dom.generated.d.ts#L26373",
+  Object: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object",
+  ParentNode: "https://developer.mozilla.org/docs/Web/API/ParentNode",
+  Promise: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise",
+  PromiseLike: "https://github.com/Microsoft/TypeScript/blob/38c3279/src/lib/es5.d.ts#L1519",
+  PromiseWithResolvers: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers",
+  PropertyDescriptor: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty",
+  PropertyDescriptorMap: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties",
+  PropertyKey: "https://www.typescriptlang.org/docs/handbook/2/keyof-types.html",
+  Proxy: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Proxy",
+  RegExp: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/RegExp",
+  RequestInfo: "https://developer.mozilla.org/docs/Web/API/Request/Request#input",
+  RequestInit: "https://developer.mozilla.org/docs/Web/API/Request/Request#options",
+  ResponseInit: "https://developer.mozilla.org/docs/Web/API/Response/Response#init",
+  Set: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Set",
+  Stats: "https://nodejs.org/api/fs.html#class-fsstats",
+  SVGElementTagNameMap: "https://developer.mozilla.org/docs/Web/API/Document/createElementNS",
+  Symbol: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Symbol",
+  TypedPropertyDescriptor: "https://www.typescriptlang.org/docs/handbook/decorators.html",
+  WeakMap: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WeakMap",
+  WeakRef: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WeakRef",
+  WeakSet: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WeakSet",
+  WebGLContextAttributes: "https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/getContextAttributes",
+  WebGLPowerPreference: "https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/getContextAttributes",
+  WindowEventHandlers: "https://raw.githubusercontent.com/microsoft/TypeScript/38c3279e29e45c274c408d909394b7bf45c24fdc/src/lib/dom.generated.d.ts#L41634",
+  WindowEventMap: "https://developer.mozilla.org/docs/Web/API/Window#events",
+  WindowLocalStorage: "https://raw.githubusercontent.com/microsoft/TypeScript/38c3279e29e45c274c408d909394b7bf45c24fdc/src/lib/dom.generated.d.ts#L41685",
+  WindowOrWorkerGlobalScope: "https://raw.githubusercontent.com/microsoft/TypeScript/38c3279e29e45c274c408d909394b7bf45c24fdc/src/lib/dom.generated.d.ts#L41690",
+  WindowSessionStorage: "https://raw.githubusercontent.com/microsoft/TypeScript/38c3279e29e45c274c408d909394b7bf45c24fdc/src/lib/dom.generated.d.ts#L41736"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EVENT_METHODS,
+  GENERIC_TYPE_PARAMS,
+  TS_GLOBAL_TYPES,
+  TS_PRIMITIVE_TYPES,
+  TS_UTILITY_TYPES
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/docs-site/api-doc-constants.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Constants and the generic external-type link maps for the API documentation generator: the TypeScript handbook,\n * MDN and Node. A layer that documents another ecosystem adds its own maps through `externalTypeLinks`.\n */\n\n/**\nEvent-like method names that should be split by string literal first param\n */\nexport const EVENT_METHODS = new Set(['off', 'on', 'trigger', 'tryTrigger']);\n\n/**\nSingle-letter and common generic type parameter names \u2014 not linkable\n */\nexport const GENERIC_TYPE_PARAMS = new Set([\n  'Arg',\n  'Args', // Short identifiers / enum-like values that aren't types\n  'ASC',\n  'Callback',\n  'ComponentType',\n  'DESC',\n  'DOMContentLoaded',\n  'GET',\n  'HookCallback',\n  'HookName',\n  'ID',\n  'Input',\n  'Instance',\n  'Item',\n  'K',\n  'Key',\n  'Marked',\n  'O',\n  'Output',\n  'Owner',\n  'P',\n  'POST',\n  'R',\n  'S',\n  'Suspects',\n  'T',\n  'TFunction',\n  'TModal',\n  'TView',\n  'TViewType',\n  'U',\n  'UserProperties',\n  'V',\n  'VIEW'\n]);\n\nconst TS_HANDBOOK = 'https://www.typescriptlang.org/docs/handbook';\n\nexport const TS_PRIMITIVE_TYPES: Record<string, string> = {\n  any: `${TS_HANDBOOK}/2/everyday-types.html#any`,\n  boolean: `${TS_HANDBOOK}/basic-types.html#boolean`,\n  never: `${TS_HANDBOOK}/basic-types.html#never`,\n  null: `${TS_HANDBOOK}/basic-types.html#null-and-undefined`,\n  number: `${TS_HANDBOOK}/basic-types.html#number`,\n  object: `${TS_HANDBOOK}/basic-types.html#object`,\n  string: `${TS_HANDBOOK}/basic-types.html#string`,\n  symbol: `${TS_HANDBOOK}/symbols.html`,\n  undefined: `${TS_HANDBOOK}/basic-types.html#null-and-undefined`,\n  unknown: `${TS_HANDBOOK}/2/functions.html#unknown`,\n  void: `${TS_HANDBOOK}/basic-types.html#void`\n};\n\n// Cspell:disable -- URL fragments are not words\nexport const TS_UTILITY_TYPES = new Map<string, string>([\n  ['Awaited', 'awaitedtype'],\n  ['Capitalize', 'capitalizestringtype'],\n  ['ConstructorParameters', 'constructorparameterstype'],\n  ['Exclude', 'excludeuniontype-excludedmembers'],\n  ['Extract', 'extracttype-union'],\n  ['InstanceType', 'instancetypetype'],\n  ['Iterable', 'iterable-interface'],\n  ['Lowercase', 'lowercasestringtype'],\n  ['NoInfer', 'noinfertype'],\n  ['NonNullable', 'nonnullabletype'],\n  ['Omit', 'omittype-keys'],\n  ['OmitThisParameter', 'omitthisparametertype'],\n  ['Parameters', 'parameterstype'],\n  ['Partial', 'partialtype'],\n  ['Pick', 'picktype-keys'],\n  ['Readonly', 'readonlytype'],\n  ['Record', 'recordkeys-type'],\n  ['Required', 'requiredtype'],\n  ['ReturnType', 'returntypetype'],\n  ['ThisParameterType', 'thisparametertypetype'],\n  ['ThisType', 'thistypetype'],\n  ['Uncapitalize', 'uncapitalizestringtype'],\n  ['Uppercase', 'uppercasestringtype']\n]);\n\nexport const TS_GLOBAL_TYPES: Record<string, string> = {\n  AddEventListenerOptions: 'https://developer.mozilla.org/docs/Web/API/EventTarget/addEventListener#options',\n  AnimationFrameProvider: 'https://raw.githubusercontent.com/microsoft/TypeScript/38c3279e29e45c274c408d909394b7bf45c24fdc/src/lib/dom.generated.d.ts#L3756',\n  Array: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array',\n  ArrayBufferLike: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer',\n  ArrayLike: 'https://www.typescriptlang.org/docs/handbook/2/indexed-access-types.html',\n  BodyInit: 'https://developer.mozilla.org/docs/Web/API/Request/Request#body',\n  Buffer: 'https://nodejs.org/api/buffer.html#class-buffer',\n  CanvasRenderingContext2DSettings: 'https://developer.mozilla.org/docs/Web/API/HTMLCanvasElement/getContext#contextattributes',\n  DocumentEventMap: 'https://developer.mozilla.org/docs/Web/API/Document#events',\n  DocumentOrShadowRoot: 'https://developer.mozilla.org/docs/Web/API/Document',\n  Error: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error',\n  EventListenerOptions: 'https://developer.mozilla.org/docs/Web/API/EventTarget/removeEventListener#options',\n  EventListenerOrEventListenerObject: 'https://developer.mozilla.org/docs/Web/API/EventTarget/addEventListener#the_event_listener_callback',\n  FSWatcher: 'https://nodejs.org/api/fs.html#class-fsfswatcher',\n  Function: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Function',\n  GlobalEventHandlers: 'https://raw.githubusercontent.com/microsoft/TypeScript/38c3279e29e45c274c408d909394b7bf45c24fdc/src/lib/dom.generated.d.ts#L16746',\n  HeadersInit: 'https://developer.mozilla.org/docs/Web/API/Headers/Headers#init',\n  HTMLElementEventMap: 'https://developer.mozilla.org/docs/Web/API/HTMLElement#events',\n  HTMLElementTagNameMap: 'https://developer.mozilla.org/docs/Web/API/Document/createElement',\n  Iterable: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Iteration_protocols',\n  Iterator: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Iterator',\n  Map: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Map',\n  NonElementParentNode: 'https://raw.githubusercontent.com/microsoft/TypeScript/38c3279e29e45c274c408d909394b7bf45c24fdc/src/lib/dom.generated.d.ts#L26373',\n  Object: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object',\n  ParentNode: 'https://developer.mozilla.org/docs/Web/API/ParentNode',\n  Promise: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise',\n  PromiseLike: 'https://github.com/Microsoft/TypeScript/blob/38c3279/src/lib/es5.d.ts#L1519',\n  PromiseWithResolvers: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers',\n  PropertyDescriptor: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty',\n  PropertyDescriptorMap: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties',\n  PropertyKey: 'https://www.typescriptlang.org/docs/handbook/2/keyof-types.html',\n  Proxy: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Proxy',\n  RegExp: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/RegExp',\n  RequestInfo: 'https://developer.mozilla.org/docs/Web/API/Request/Request#input',\n  RequestInit: 'https://developer.mozilla.org/docs/Web/API/Request/Request#options',\n  ResponseInit: 'https://developer.mozilla.org/docs/Web/API/Response/Response#init',\n  Set: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Set',\n  Stats: 'https://nodejs.org/api/fs.html#class-fsstats',\n  SVGElementTagNameMap: 'https://developer.mozilla.org/docs/Web/API/Document/createElementNS',\n  Symbol: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Symbol',\n  TypedPropertyDescriptor: 'https://www.typescriptlang.org/docs/handbook/decorators.html',\n  WeakMap: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WeakMap',\n  WeakRef: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WeakRef',\n  WeakSet: 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/WeakSet',\n  WebGLContextAttributes: 'https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/getContextAttributes',\n  WebGLPowerPreference: 'https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/getContextAttributes',\n  WindowEventHandlers: 'https://raw.githubusercontent.com/microsoft/TypeScript/38c3279e29e45c274c408d909394b7bf45c24fdc/src/lib/dom.generated.d.ts#L41634',\n  WindowEventMap: 'https://developer.mozilla.org/docs/Web/API/Window#events',\n  WindowLocalStorage: 'https://raw.githubusercontent.com/microsoft/TypeScript/38c3279e29e45c274c408d909394b7bf45c24fdc/src/lib/dom.generated.d.ts#L41685',\n  WindowOrWorkerGlobalScope: 'https://raw.githubusercontent.com/microsoft/TypeScript/38c3279e29e45c274c408d909394b7bf45c24fdc/src/lib/dom.generated.d.ts#L41690',\n  WindowSessionStorage: 'https://raw.githubusercontent.com/microsoft/TypeScript/38c3279e29e45c274c408d909394b7bf45c24fdc/src/lib/dom.generated.d.ts#L41736'\n};\n// Cspell:enable\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/docs-site/api-doc-constants.d.cts

@@ -0,0 +1,18 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Constants and the generic external-type link maps for the API documentation generator: the TypeScript handbook,
+ * MDN and Node. A layer that documents another ecosystem adds its own maps through `externalTypeLinks`.
+ */
+/**
+Event-like method names that should be split by string literal first param
+ */
+export declare const EVENT_METHODS: Set<string>;
+/**
+Single-letter and common generic type parameter names — not linkable
+ */
+export declare const GENERIC_TYPE_PARAMS: Set<string>;
+export declare const TS_PRIMITIVE_TYPES: Record<string, string>;
+export declare const TS_UTILITY_TYPES: Map<string, string>;
+export declare const TS_GLOBAL_TYPES: Record<string, string>;