@cjser/es-joy__jsdoccomment 0.96.0-cjser.2

package/dist-cjser/index.cjs

@@ -0,0 +1,1224 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/@cjser/es-joy__jsdoccomment.tmp-26-1788540365480/src/index.js
+var index_exports = {};
+__export(index_exports, {
+  commentHandler: () => commentHandler,
+  commentParserToESTree: () => commentParserToESTree,
+  defaultNoNames: () => defaultNoNames,
+  defaultNoTypes: () => defaultNoTypes,
+  estreeToString: () => estreeToString,
+  findJSDocComment: () => findJSDocComment,
+  getDecorator: () => getDecorator,
+  getFollowingComment: () => getFollowingComment,
+  getJSDocComment: () => getJSDocComment,
+  getNonJsdocComment: () => getNonJsdocComment,
+  getReducedASTNode: () => getReducedASTNode,
+  getTokenizers: () => getTokenizers,
+  hasSeeWithLink: () => hasSeeWithLink,
+  jsdocTypeVisitorKeys: () => import_jsdoc_type_pratt_parser4.visitorKeys,
+  jsdocVisitorKeys: () => jsdocVisitorKeys,
+  parseComment: () => parseComment,
+  parseInlineTags: () => parseInlineTags
+});
+module.exports = __toCommonJS(index_exports);
+var import_jsdoc_type_pratt_parser4 = require("@cjser/jsdoc-type-pratt-parser");
+__reExport(index_exports, require("@cjser/jsdoc-type-pratt-parser"), module.exports);
+
+// packages/@cjser/es-joy__jsdoccomment.tmp-26-1788540365480/src/commentHandler.js
+var import_esquery = __toESM(require("esquery"), 1);
+var import_jsdoc_type_pratt_parser2 = require("@cjser/jsdoc-type-pratt-parser");
+
+// packages/@cjser/es-joy__jsdoccomment.tmp-26-1788540365480/src/commentParserToESTree.js
+var import_jsdoc_type_pratt_parser = require("@cjser/jsdoc-type-pratt-parser");
+var stripEncapsulatingBrackets = (container, isArr) => {
+  if (isArr) {
+    const firstItem = (
+      /** @type {JsdocTypeLine[]} */
+      container[0]
+    );
+    firstItem.rawType = firstItem.rawType.replace(
+      new RegExp("^\\{", "v"),
+      ""
+    );
+    const lastItem = (
+      /** @type {JsdocTypeLine} */
+      /** @type {JsdocTypeLine[]} */
+      container.at(-1)
+    );
+    lastItem.rawType = lastItem.rawType.replace(new RegExp("\\}$", "v"), "");
+    return;
+  }
+  container.rawType = /** @type {JsdocTag} */
+  container.rawType.replace(
+    new RegExp("^\\{", "v"),
+    ""
+  ).replace(new RegExp("\\}$", "v"), "");
+};
+var inlineTagToAST = ({ text, tag, format, namepathOrURL }) => ({
+  text,
+  tag,
+  format,
+  namepathOrURL,
+  type: "JsdocInlineTag"
+});
+var commentParserToESTree = (jsdoc, mode = "typescript", {
+  spacing = "compact",
+  throwOnTypeParsingErrors = false,
+  jsdocTypePrattParserArgs
+} = {}) => {
+  const cleanUpLastTag = (lastTag2) => {
+    stripEncapsulatingBrackets(lastTag2);
+    if (lastTag2.typeLines.length) {
+      stripEncapsulatingBrackets(lastTag2.typeLines, true);
+    }
+    if (lastTag2.descriptionLines.length === 1 && lastTag2.descriptionLines[0].description === "") {
+      lastTag2.descriptionLines.length = 0;
+    }
+    let parsedType = null;
+    try {
+      parsedType = (0, import_jsdoc_type_pratt_parser.parse)(
+        lastTag2.rawType,
+        mode,
+        jsdocTypePrattParserArgs
+      );
+    } catch (err) {
+      if (throwOnTypeParsingErrors && lastTag2.rawType) {
+        err.message = `Tag @${lastTag2.tag} with raw type \`${lastTag2.rawType}\` had parsing error: ${/** @type {Error} */
+        err.message}`;
+        throw err;
+      }
+    }
+    lastTag2.parsedType = parsedType;
+  };
+  const { source, inlineTags: blockInlineTags } = jsdoc;
+  const { tokens: {
+    delimiter: delimiterRoot,
+    lineEnd: lineEndRoot,
+    postDelimiter: postDelimiterRoot,
+    start: startRoot,
+    end: endRoot
+  } } = source[0];
+  const endLine = source.length - 1;
+  const ast = {
+    delimiter: delimiterRoot,
+    delimiterLineBreak: "\n",
+    description: "",
+    descriptionLines: [],
+    inlineTags: blockInlineTags.map((t) => inlineTagToAST(t)),
+    initial: startRoot,
+    tags: [],
+    // `terminal` will be overwritten if there are other entries
+    terminal: endRoot,
+    preterminalLineBreak: "\n",
+    hasPreterminalDescription: 0,
+    endLine,
+    postDelimiter: postDelimiterRoot,
+    lineEnd: lineEndRoot,
+    type: "JsdocBlock"
+  };
+  const tags = [];
+  let lastDescriptionLine;
+  let lastTag = null;
+  let tagDescriptionSeen = false;
+  let descLineStateOpen = true;
+  source.forEach((info, idx) => {
+    const { tokens } = info;
+    const {
+      delimiter,
+      description,
+      postDelimiter,
+      start: initial,
+      tag,
+      end,
+      type: rawType
+    } = tokens;
+    if (!tag && description && descLineStateOpen) {
+      if (ast.descriptionStartLine === void 0) {
+        ast.descriptionStartLine = idx;
+      }
+      ast.descriptionEndLine = idx;
+    }
+    if (tag || end) {
+      descLineStateOpen = false;
+      if (lastDescriptionLine === void 0) {
+        lastDescriptionLine = idx;
+      }
+      if (lastTag) {
+        cleanUpLastTag(lastTag);
+      }
+      if (end && !tag) {
+        ast.terminal = end;
+        const isDelimiterLine = ast.descriptionLines.length === 0 && delimiter === "/**";
+        if (isDelimiterLine) {
+          ast.delimiterLineBreak = "";
+        }
+        if (description) {
+          if (ast.terminal === "*/") {
+            ast.preterminalLineBreak = "";
+          }
+          if (lastTag) {
+            ast.hasPreterminalTagDescription = 1;
+          } else {
+            ast.hasPreterminalDescription = 1;
+          }
+          const holder = lastTag || ast;
+          holder.description += (holder.description ? "\n" : "") + description;
+          holder.descriptionLines.push({
+            delimiter: isDelimiterLine ? "" : delimiter,
+            description,
+            postDelimiter: isDelimiterLine ? "" : postDelimiter,
+            initial,
+            type: "JsdocDescriptionLine"
+          });
+        }
+        return;
+      }
+      const {
+        // eslint-disable-next-line no-unused-vars -- Discarding
+        end: ed,
+        delimiter: de,
+        postDelimiter: pd,
+        start: init,
+        ...tkns
+      } = tokens;
+      if (!tokens.name) {
+        let i = 1;
+        while (Object.hasOwn(source, idx + i)) {
+          const { tokens: {
+            name,
+            postName,
+            postType,
+            tag: tg
+          } } = source[idx + i];
+          if (tg) {
+            break;
+          }
+          if (name) {
+            tkns.postType = postType;
+            tkns.name = name;
+            tkns.postName = postName;
+            break;
+          }
+          i++;
+        }
+      }
+      const tagInlineTags = tag ? (
+        /**
+         * @type {import('comment-parser').Spec & {
+         *   inlineTags: JsdocInlineTagNoType[]
+         * }}
+         */
+        jsdoc.tags[tags.length].inlineTags.map(
+          (t) => inlineTagToAST(t)
+        )
+      ) : [];
+      const tagObj = {
+        ...tkns,
+        initial: endLine ? init : "",
+        postDelimiter: lastDescriptionLine ? pd : "",
+        delimiter: lastDescriptionLine ? de : "",
+        descriptionLines: [],
+        inlineTags: tagInlineTags,
+        parsedType: null,
+        rawType: "",
+        type: "JsdocTag",
+        typeLines: []
+      };
+      tagObj.tag = tagObj.tag.replace(new RegExp("^@", "v"), "");
+      lastTag = tagObj;
+      tagDescriptionSeen = false;
+      tags.push(tagObj);
+    }
+    if (rawType) {
+      lastTag.typeLines.push(
+        /** @type {JsdocTag} */
+        lastTag.typeLines.length ? {
+          delimiter,
+          postDelimiter,
+          rawType,
+          initial,
+          type: "JsdocTypeLine"
+        } : {
+          delimiter: "",
+          postDelimiter: "",
+          rawType,
+          initial: "",
+          type: "JsdocTypeLine"
+        }
+      );
+      lastTag.rawType += /** @type {JsdocTag} */
+      lastTag.rawType ? "\n" + rawType : rawType;
+    }
+    if (lastTag || spacing === "compact" && description || spacing === "preserve" && (description || delimiter !== "/**")) {
+      const holder = lastTag || ast;
+      const isDelimiterLine = holder.descriptionLines.length === 0 && delimiter === "/**";
+      if (isDelimiterLine) {
+        ast.delimiterLineBreak = "";
+      }
+      tagDescriptionSeen ||= Boolean(lastTag && (rawType === "" || (rawType == null ? void 0 : rawType.endsWith("}"))));
+      if (lastTag) {
+        if (tagDescriptionSeen) {
+          const isFirstDescriptionLine = holder.descriptionLines.length === 0;
+          if (spacing === "preserve" || spacing === "compact" && (description || isFirstDescriptionLine)) {
+            holder.descriptionLines.push({
+              delimiter: isFirstDescriptionLine ? "" : delimiter,
+              description,
+              postDelimiter: isFirstDescriptionLine ? "" : postDelimiter,
+              initial: isFirstDescriptionLine ? "" : initial,
+              type: "JsdocDescriptionLine"
+            });
+          }
+        }
+      } else {
+        holder.descriptionLines.push({
+          delimiter: isDelimiterLine ? "" : delimiter,
+          description,
+          postDelimiter: isDelimiterLine ? "" : postDelimiter,
+          initial: isDelimiterLine ? `` : initial,
+          type: "JsdocDescriptionLine"
+        });
+      }
+      if (!tag) {
+        if (lastTag) {
+          if (tagDescriptionSeen && !(spacing === "compact" && description === "" && holder.description)) {
+            holder.description += !holder.description ? description : "\n" + description;
+          }
+        } else {
+          holder.description += !holder.description ? description : "\n" + description;
+        }
+      }
+    }
+    if (end && tag) {
+      ast.terminal = end;
+      ast.hasPreterminalTagDescription = 1;
+      if (ast.terminal === "*/") {
+        ast.preterminalLineBreak = "";
+      }
+      cleanUpLastTag(
+        /** @type {JsdocTag} */
+        lastTag
+      );
+    }
+  });
+  ast.lastDescriptionLine = lastDescriptionLine;
+  ast.tags = tags;
+  return ast;
+};
+var jsdocVisitorKeys = {
+  JsdocBlock: ["descriptionLines", "tags", "inlineTags"],
+  JsdocDescriptionLine: [],
+  JsdocTypeLine: [],
+  JsdocTag: ["parsedType", "typeLines", "descriptionLines", "inlineTags"],
+  JsdocInlineTag: []
+};
+
+// packages/@cjser/es-joy__jsdoccomment.tmp-26-1788540365480/src/commentHandler.js
+var commentHandler = (settings, commentParserToESTreeOptions) => {
+  return (commentSelector, jsdoc) => {
+    const { mode } = settings;
+    const selector = import_esquery.default.parse(commentSelector);
+    const ast = commentParserToESTree(
+      jsdoc,
+      mode,
+      commentParserToESTreeOptions
+    );
+    const castAst = (
+      /** @type {unknown} */
+      ast
+    );
+    return import_esquery.default.matches(
+      /** @type {import('estree').Node} */
+      castAst,
+      selector,
+      void 0,
+      {
+        visitorKeys: {
+          ...import_jsdoc_type_pratt_parser2.visitorKeys,
+          ...jsdocVisitorKeys
+        }
+      }
+    );
+  };
+};
+
+// packages/@cjser/es-joy__jsdoccomment.tmp-26-1788540365480/src/estreeToString.js
+var import_jsdoc_type_pratt_parser3 = require("@cjser/jsdoc-type-pratt-parser");
+
+// packages/@cjser/es-joy__jsdoccomment.tmp-26-1788540365480/src/inlineTagEscapes.js
+function getLabelDelimiter(format) {
+  return format === "prefix" ? "]" : "}";
+}
+function decodeInlineTagText(text, format) {
+  const delimiter = getLabelDelimiter(format);
+  let decoded = "";
+  let idx = 0;
+  while (idx < text.length) {
+    const character = text[idx];
+    if (character === "\\") {
+      const nextCharacter = text[idx + 1];
+      if (nextCharacter === "\\" || nextCharacter === delimiter) {
+        decoded += nextCharacter;
+        idx += 2;
+        continue;
+      }
+    }
+    decoded += character;
+    idx++;
+  }
+  return decoded;
+}
+function encodeInlineTagText(text, format) {
+  const delimiter = getLabelDelimiter(format);
+  let encoded = "";
+  for (let idx = 0; idx < text.length; idx++) {
+    const character = text[idx];
+    if (character === delimiter) {
+      encoded += `\\${delimiter}`;
+      continue;
+    }
+    if (character === "\\") {
+      const nextCharacter = text[idx + 1];
+      if ([void 0, "\\", delimiter].includes(nextCharacter)) {
+        encoded += "\\\\";
+        continue;
+      }
+    }
+    encoded += character;
+  }
+  return encoded;
+}
+
+// packages/@cjser/es-joy__jsdoccomment.tmp-26-1788540365480/src/estreeToString.js
+var stringifiers = {
+  /* eslint-enable jsdoc/reject-function-type -- Different functions */
+  JsdocBlock,
+  /**
+   * @param {import('./commentParserToESTree.js').JsdocDescriptionLine} node
+   * @returns {string}
+   */
+  JsdocDescriptionLine({
+    initial,
+    delimiter,
+    postDelimiter,
+    description
+  }) {
+    return `${initial}${delimiter}${postDelimiter}${description}`;
+  },
+  /**
+   * @param {import('./commentParserToESTree.js').JsdocTypeLine} node
+   * @returns {string}
+   */
+  JsdocTypeLine({
+    initial,
+    delimiter,
+    postDelimiter,
+    rawType
+  }) {
+    return `${initial}${delimiter}${postDelimiter}${rawType}`;
+  },
+  /**
+   * @param {import('./commentParserToESTree.js').JsdocInlineTag} node
+   */
+  JsdocInlineTag({ format, namepathOrURL, tag, text }) {
+    const encodedText = encodeInlineTagText(text, format);
+    return format === "pipe" ? `{@${tag} ${namepathOrURL}|${encodedText}}` : format === "plain" ? `{@${tag} ${namepathOrURL}}` : format === "prefix" ? `[${encodedText}]{@${tag} ${namepathOrURL}}` : `{@${tag} ${namepathOrURL} ${encodedText}}`;
+  },
+  JsdocTag
+};
+function estreeToString(node, opts = {}) {
+  if (Object.hasOwn(stringifiers, node.type)) {
+    return stringifiers[
+      /**
+       * @type {import('./commentParserToESTree.js').JsdocBlock|
+       *   import('./commentParserToESTree.js').JsdocDescriptionLine|
+       *   import('./commentParserToESTree.js').JsdocTypeLine|
+       *   import('./commentParserToESTree.js').JsdocTag}
+       */
+      node.type
+    ](
+      node,
+      opts
+    );
+  }
+  if (node.type.startsWith("JsdocType")) {
+    return opts.preferRawType ? "" : `{${(0, import_jsdoc_type_pratt_parser3.stringify)(
+      /** @type {import('@cjser/jsdoc-type-pratt-parser').RootResult} */
+      node,
+      opts.jtppStringificationRules
+    )}}`;
+  }
+  throw new Error(`Unhandled node type: ${node.type}`);
+}
+function JsdocBlock(node, opts) {
+  const {
+    delimiter,
+    delimiterLineBreak,
+    descriptionLines,
+    initial,
+    postDelimiter,
+    preterminalLineBreak,
+    tags,
+    terminal
+  } = node;
+  const terminalPrepend = preterminalLineBreak !== "" ? `${preterminalLineBreak}${initial} ` : "";
+  let result = `${initial}${delimiter}${postDelimiter}${delimiterLineBreak}`;
+  for (let i = 0; i < descriptionLines.length; i++) {
+    result += estreeToString(descriptionLines[i]);
+    if (i !== descriptionLines.length - 1 || tags.length) {
+      result += "\n";
+    }
+  }
+  for (let i = 0; i < tags.length; i++) {
+    result += estreeToString(tags[i], opts);
+    if (i !== tags.length - 1) {
+      result += "\n";
+    }
+  }
+  result += `${terminalPrepend}${terminal}`;
+  return result;
+}
+function JsdocTag(node, opts) {
+  const {
+    delimiter,
+    descriptionLines,
+    initial,
+    name,
+    parsedType,
+    postDelimiter,
+    postName,
+    postTag,
+    postType,
+    tag,
+    typeLines
+  } = node;
+  let result = `${initial}${delimiter}${postDelimiter}@${tag}${postTag}`;
+  if (!parsedType || opts.preferRawType) {
+    if (typeLines.length) {
+      result += "{";
+      for (let i = 0; i < typeLines.length; i++) {
+        result += estreeToString(typeLines[i]);
+        if (i !== typeLines.length - 1) {
+          result += "\n";
+        }
+      }
+      result += "}";
+    }
+  } else if (parsedType == null ? void 0 : parsedType.type.startsWith("JsdocType")) {
+    result += `{${(0, import_jsdoc_type_pratt_parser3.stringify)(
+      /** @type {import('@cjser/jsdoc-type-pratt-parser').RootResult} */
+      parsedType
+    )}}`;
+  }
+  let nameLineOffset = 0;
+  if (name && postTag === "" && postType === "") {
+    result += "\n";
+    if (descriptionLines.length > 0) {
+      const firstDescLine = descriptionLines[0];
+      if (firstDescLine.description === "" && firstDescLine.delimiter === "" && firstDescLine.postDelimiter === "" && firstDescLine.initial === "") {
+        if (descriptionLines.length > 1) {
+          const nameLine = descriptionLines[1];
+          result += `${nameLine.initial}${nameLine.delimiter}${nameLine.postDelimiter}${name}${postName}${nameLine.description}`;
+          nameLineOffset = 2;
+        } else {
+          result += name + postName;
+          nameLineOffset = 1;
+        }
+      } else {
+        const nameLine = descriptionLines[0];
+        result += `${nameLine.initial}${nameLine.delimiter}${nameLine.postDelimiter}${name}${postName}${nameLine.description}`;
+        nameLineOffset = 1;
+      }
+    } else {
+      result += `${initial}${delimiter}${postDelimiter}${name}${postName}`;
+    }
+  } else {
+    result += name ? `${postType}${name}${postName}` : postType;
+  }
+  for (let i = nameLineOffset; i < descriptionLines.length; i++) {
+    const descriptionLine = descriptionLines[i];
+    if (i > 0 || nameLineOffset > 0) {
+      result += "\n";
+    }
+    result += estreeToString(descriptionLine);
+  }
+  return result;
+}
+
+// packages/@cjser/es-joy__jsdoccomment.tmp-26-1788540365480/src/jsdoccomment.js
+var isCommentToken = (token) => {
+  return ["Line", "Block", "Shebang"].includes(token.type);
+};
+var getDecorator = (node) => {
+  var _a, _b, _c, _d, _e;
+  return ((_b = (_a = node == null ? void 0 : node.declaration) == null ? void 0 : _a.decorators) == null ? void 0 : _b[0]) || // @ts-expect-error -- Loose checking
+  ((_c = node == null ? void 0 : node.decorators) == null ? void 0 : _c[0]) || // @ts-expect-error -- Loose checking
+  ((_e = (_d = node == null ? void 0 : node.parent) == null ? void 0 : _d.decorators) == null ? void 0 : _e[0]);
+};
+var looksLikeExport = function(astNode) {
+  return [
+    "ExportDefaultDeclaration",
+    "ExportNamedDeclaration",
+    "ExportAllDeclaration",
+    "ExportSpecifier"
+  ].includes(astNode.type);
+};
+var getTSFunctionComment = function(astNode) {
+  const { parent } = astNode;
+  if (!parent) {
+    return astNode;
+  }
+  const grandparent = parent.parent;
+  if (!grandparent) {
+    return astNode;
+  }
+  if (
+    /** @type {ESLintOrTSNode} */
+    parent.type !== "TSTypeAnnotation"
+  ) {
+    if (parent.type === "TSTypeAliasDeclaration" && grandparent.type === "ExportNamedDeclaration") {
+      return grandparent;
+    }
+    return astNode;
+  }
+  const greatGrandparent = grandparent.parent;
+  const greatGreatGrandparent = greatGrandparent && greatGrandparent.parent;
+  switch (
+    /** @type {ESLintOrTSNode} */
+    grandparent.type
+  ) {
+    // @ts-expect-error -- For `ClassProperty`.
+    case "PropertyDefinition":
+    case "ClassProperty":
+    case "TSDeclareFunction":
+    case "TSMethodSignature":
+    case "TSPropertySignature":
+      return grandparent;
+    case "ArrowFunctionExpression":
+      if (!greatGrandparent) {
+        return astNode;
+      }
+      if (greatGrandparent.type === "VariableDeclarator") {
+        if (!greatGreatGrandparent || !greatGreatGrandparent.parent) {
+          return astNode;
+        }
+        return greatGreatGrandparent.parent;
+      }
+      return astNode;
+    /* v8 ignore stop */
+    case "FunctionExpression":
+      if (!greatGreatGrandparent) {
+        return astNode;
+      }
+      if (greatGrandparent.type === "MethodDefinition") {
+        return greatGrandparent;
+      }
+    // Fallthrough
+    default:
+      if (grandparent.type !== "Identifier") {
+        return astNode;
+      }
+  }
+  if (!greatGreatGrandparent) {
+    return astNode;
+  }
+  switch (greatGrandparent.type) {
+    case "ArrowFunctionExpression":
+      if (greatGreatGrandparent.type === "VariableDeclarator" && greatGreatGrandparent.parent.type === "VariableDeclaration") {
+        return greatGreatGrandparent.parent;
+      }
+      return astNode;
+    case "FunctionDeclaration":
+      return greatGrandparent;
+    case "VariableDeclarator":
+      if (greatGreatGrandparent.type === "VariableDeclaration") {
+        return greatGreatGrandparent;
+      }
+    /* v8 ignore next 2 */
+    // Fallthrough
+    default:
+      return astNode;
+  }
+};
+var invokedExpression = /* @__PURE__ */ new Set(
+  ["CallExpression", "OptionalCallExpression", "NewExpression"]
+);
+var allowableCommentNode = /* @__PURE__ */ new Set([
+  "AssignmentPattern",
+  "VariableDeclaration",
+  "ExpressionStatement",
+  "MethodDefinition",
+  "Property",
+  "ObjectProperty",
+  "ClassProperty",
+  "PropertyDefinition",
+  "ExportDefaultDeclaration",
+  "ReturnStatement"
+]);
+var getReducedASTNode = function(node, sourceCode, settings) {
+  let { parent } = node;
+  switch (
+    /** @type {ESLintOrTSNode} */
+    node.type
+  ) {
+    case "TSFunctionType":
+      return getTSFunctionComment(node);
+    case "TSInterfaceDeclaration":
+    case "TSTypeAliasDeclaration":
+    case "TSEnumDeclaration":
+    case "ClassDeclaration":
+    case "FunctionDeclaration":
+      if (!parent) {
+        return node;
+      }
+      return looksLikeExport(parent) ? parent : node;
+    case "TSDeclareFunction":
+    case "ClassExpression":
+    case "ObjectExpression":
+    case "ArrowFunctionExpression":
+    case "TSEmptyBodyFunctionExpression":
+    case "FunctionExpression":
+      if (!parent) {
+        return node;
+      }
+      if (!invokedExpression.has(parent.type) || (settings == null ? void 0 : settings.skipInvokedExpressionsForCommentFinding)) {
+        let token = node;
+        do {
+          token = sourceCode.getTokenBefore(
+            /** @type {import('eslint').Rule.Node|import('eslint').AST.Token} */
+            token,
+            { includeComments: true }
+          );
+        } while (token && token.type === "Punctuator" && token.value === "(");
+        if (token && token.type === "Block") {
+          return node;
+        }
+        if (sourceCode.getCommentsBefore(
+          /** @type {import('eslint').Rule.Node} */
+          node
+        ).length) {
+          return node;
+        }
+        while (!sourceCode.getCommentsBefore(
+          /** @type {import('eslint').Rule.Node} */
+          parent
+        ).length && !new RegExp("Function", "v").test(parent.type) && !allowableCommentNode.has(parent.type)) {
+          ({ parent } = parent);
+          if (!parent) {
+            break;
+          }
+        }
+        if (parent && parent.type !== "FunctionDeclaration" && parent.type !== "Program") {
+          if (parent.parent && parent.parent.type === "ExportNamedDeclaration") {
+            return parent.parent;
+          }
+          return parent;
+        }
+      }
+      return node;
+    default:
+      return node;
+  }
+};
+var findJSDocComment = (astNode, sourceCode, settings, opts = {}) => {
+  const { nonJSDoc } = opts;
+  const { minLines, maxLines } = settings;
+  let currentNode = astNode;
+  let tokenBefore = null;
+  let parenthesisToken = null;
+  while (currentNode) {
+    const decorator = getDecorator(currentNode);
+    if (decorator) {
+      const dec = (
+        /** @type {unknown} */
+        decorator
+      );
+      currentNode = /** @type {import('eslint').Rule.Node} */
+      dec;
+    }
+    tokenBefore = sourceCode.getTokenBefore(
+      /** @type {import('eslint').Rule.Node} */
+      currentNode,
+      { includeComments: true }
+    );
+    if (tokenBefore && tokenBefore.type === "Punctuator" && tokenBefore.value === "(") {
+      parenthesisToken = tokenBefore;
+      [tokenBefore] = sourceCode.getTokensBefore(
+        /** @type {import('eslint').Rule.Node} */
+        currentNode,
+        {
+          count: 2,
+          includeComments: true
+        }
+      );
+    }
+    if (!tokenBefore || !isCommentToken(tokenBefore)) {
+      return null;
+    }
+    if (!nonJSDoc && tokenBefore.type === "Line") {
+      currentNode = tokenBefore;
+      continue;
+    }
+    break;
+  }
+  if (!tokenBefore || !currentNode.loc || !tokenBefore.loc) {
+    return null;
+  }
+  if ((nonJSDoc && (tokenBefore.type !== "Block" || !new RegExp("^\\*\\s", "v").test(tokenBefore.value)) || !nonJSDoc && tokenBefore.type === "Block" && new RegExp("^\\*\\s", "v").test(tokenBefore.value)) && currentNode.loc.start.line - /** @type {import('eslint').AST.Token} */
+  (parenthesisToken ?? tokenBefore).loc.end.line >= minLines && currentNode.loc.start.line - /** @type {import('eslint').AST.Token} */
+  (parenthesisToken ?? tokenBefore).loc.end.line <= maxLines) {
+    return tokenBefore;
+  }
+  return null;
+};
+var overloadMethodNode = /* @__PURE__ */ new Set([
+  "MethodDefinition",
+  "TSAbstractMethodDefinition"
+]);
+var getOverloadStatementSiblings = (node) => {
+  if (node && // eslint-disable-next-line @stylistic/max-len -- Long
+  // eslint-disable-next-line unicorn/prefer-includes-over-repeated-comparisons -- TS
+  (node.type === "BlockStatement" || node.type === "Program" || node.type === "StaticBlock" || node.type === "TSModuleBlock")) {
+    return (
+      /** @type {ESLintOrTSNode[]} */
+      node.body
+    );
+  }
+  return void 0;
+};
+var getMethodOverloadInfo = (node) => {
+  var _a, _b;
+  if (!overloadMethodNode.has(node.type)) {
+    return null;
+  }
+  const method = node;
+  if (method.computed || !method.kind || !["method", "constructor"].includes(
+    /** @type {string} */
+    method.kind
+  ) || !((_a = method.key) == null ? void 0 : _a.name)) {
+    return null;
+  }
+  return {
+    bodyless: node.type === "TSAbstractMethodDefinition" || ((_b = method.value) == null ? void 0 : _b.type) === "TSEmptyBodyFunctionExpression",
+    kind: method.kind,
+    name: method.key.name,
+    static: Boolean(method.static)
+  };
+};
+var isMatchingMethodOverloadSibling = (node, prevSibling) => {
+  const current = getMethodOverloadInfo(node);
+  const previous = getMethodOverloadInfo(prevSibling);
+  return Boolean(
+    current && (previous == null ? void 0 : previous.bodyless) && previous.name === current.name && previous.kind === current.kind && previous.static === current.static
+  );
+};
+var getCurrentOverloadName = (node) => {
+  var _a, _b, _c;
+  if (node.type === "TSDeclareFunction" || node.type === "FunctionDeclaration") {
+    return (
+      /** @type {{id?: {name?: string}}} */
+      (_a = node.id) == null ? void 0 : _a.name
+    );
+  }
+  if (node.type === "ExportNamedDeclaration") {
+    const { declaration } = (
+      /** @type {{declaration?: {type?: string, id?: {name?: string}}}} */
+      node
+    );
+    if ((declaration == null ? void 0 : declaration.type) === "FunctionDeclaration" || (declaration == null ? void 0 : declaration.type) === "TSDeclareFunction") {
+      return (_b = declaration.id) == null ? void 0 : _b.name;
+    }
+  }
+  if (overloadMethodNode.has(node.type)) {
+    const method = (
+      /** @type {{computed?: boolean, key?: {name?: string}}} */
+      node
+    );
+    if (!method.computed) {
+      return (_c = method.key) == null ? void 0 : _c.name;
+    }
+  }
+  return void 0;
+};
+var getPreviousOverloadName = (node) => {
+  var _a, _b, _c;
+  if (node.type === "TSDeclareFunction") {
+    return (
+      /** @type {{id?: {name?: string}}} */
+      (_a = node.id) == null ? void 0 : _a.name
+    );
+  }
+  if (node.type === "ExportNamedDeclaration") {
+    const { declaration } = (
+      /** @type {{declaration?: {type?: string, id?: {name?: string}}}} */
+      node
+    );
+    if ((declaration == null ? void 0 : declaration.type) === "TSDeclareFunction") {
+      return (_b = declaration.id) == null ? void 0 : _b.name;
+    }
+  }
+  if (overloadMethodNode.has(node.type)) {
+    const method = (
+      /** @type {{computed?: boolean, key?: {name?: string}}} */
+      node
+    );
+    if (!method.computed) {
+      return (_c = method.key) == null ? void 0 : _c.name;
+    }
+  }
+  return void 0;
+};
+var getPreviousOverloadSibling = (node) => {
+  const { parent } = node;
+  let childNode = node;
+  let siblings;
+  if (overloadMethodNode.has(node.type) && (parent == null ? void 0 : parent.type) === "ClassBody") {
+    siblings = /** @type {ESLintOrTSNode[]} */
+    parent.body;
+  } else if ((parent == null ? void 0 : parent.type) === "ExportNamedDeclaration") {
+    childNode = parent;
+    siblings = getOverloadStatementSiblings(parent.parent);
+  } else {
+    siblings = getOverloadStatementSiblings(parent);
+  }
+  if (!siblings) {
+    return null;
+  }
+  const idx = siblings.indexOf(childNode);
+  return idx > 0 ? siblings[idx - 1] : null;
+};
+var getJSDocComment = function(sourceCode, node, settings, opts = {}) {
+  const reducedNode = getReducedASTNode(node, sourceCode, settings);
+  const comment = findJSDocComment(reducedNode, sourceCode, settings);
+  if (!comment && opts.checkOverloads) {
+    const functionName = getCurrentOverloadName(reducedNode);
+    const prevSibling = getPreviousOverloadSibling(reducedNode);
+    if (prevSibling && functionName && getPreviousOverloadName(prevSibling) === functionName && (!overloadMethodNode.has(reducedNode.type) || isMatchingMethodOverloadSibling(reducedNode, prevSibling))) {
+      return getJSDocComment(sourceCode, prevSibling, settings, opts);
+    }
+  }
+  return comment;
+};
+var getNonJsdocComment = function(sourceCode, node, settings) {
+  const reducedNode = getReducedASTNode(node, sourceCode, settings);
+  return findJSDocComment(reducedNode, sourceCode, settings, {
+    nonJSDoc: true
+  });
+};
+var compareLocEndToStart = (nodeA, nodeB) => {
+  var _a, _b;
+  return (((_a = nodeA.loc) == null ? void 0 : _a.end.line) ?? 0) === (((_b = nodeB.loc) == null ? void 0 : _b.start.line) ?? 0);
+};
+var getFollowingComment = function(sourceCode, astNode) {
+  const getTokensAfterIgnoringSemis = (node) => {
+    let tokenAfter2 = sourceCode.getTokenAfter(
+      /** @type {import('eslint').Rule.Node} */
+      node,
+      { includeComments: true }
+    );
+    while (tokenAfter2 && tokenAfter2.type === "Punctuator" && // tokenAfter.value === ')' // Don't apparently need to ignore
+    tokenAfter2.value === ";") {
+      [tokenAfter2] = sourceCode.getTokensAfter(tokenAfter2, {
+        includeComments: true
+      });
+    }
+    return tokenAfter2;
+  };
+  const tokenAfterIgnoringSemis = (node) => {
+    const tokenAfter2 = getTokensAfterIgnoringSemis(node);
+    return tokenAfter2 && isCommentToken(tokenAfter2) && compareLocEndToStart(node, tokenAfter2) ? tokenAfter2 : null;
+  };
+  let tokenAfter = tokenAfterIgnoringSemis(astNode);
+  if (!tokenAfter) {
+    switch (astNode.type) {
+      case "FunctionDeclaration":
+        tokenAfter = tokenAfterIgnoringSemis(
+          /** @type {ESLintOrTSNode} */
+          astNode.body
+        );
+        break;
+      case "ExpressionStatement":
+        tokenAfter = tokenAfterIgnoringSemis(
+          /** @type {ESLintOrTSNode} */
+          astNode.expression
+        );
+        break;
+      /* v8 ignore next 3 */
+      default:
+        break;
+    }
+  }
+  return tokenAfter;
+};
+
+// packages/@cjser/es-joy__jsdoccomment.tmp-26-1788540365480/src/parseComment.js
+var import_comment_parser = require("comment-parser");
+
+// packages/@cjser/es-joy__jsdoccomment.tmp-26-1788540365480/src/parseInlineTags.js
+function determineFormat(match) {
+  const { separator, text } = match.groups;
+  const [, textEnd] = match.indices.groups.text;
+  const [tagStart] = match.indices.groups.tag;
+  if (!text) {
+    return "plain";
+  }
+  if (separator === "|") {
+    return "pipe";
+  }
+  if (textEnd < tagStart) {
+    return "prefix";
+  }
+  return "space";
+}
+function parseDescription(description) {
+  const result = [];
+  const prefixedTextPattern = new RegExp("(?:\\[(?<text>(?:[^\\\\\\]]|\\\\[\\s\\S])+)\\])\\{@(?<tag>[^\\}\\s]+)\\s?(?<namepathOrURL>[^\\}\\s\\|]*)\\}", "gvd");
+  const suffixedAfterPattern = new RegExp("(?<!\\])\\{@(?<tag>[^\\}\\s]+)\\s?(?<namepathOrURL>[^\\}\\s\\|]*)\\s*(?<separator>[\\s\\|])?\\s*(?<text>(?:[^\\\\\\}]|\\\\[\\s\\S])*)\\}", "gvd");
+  const matches = [
+    ...description.matchAll(prefixedTextPattern),
+    ...description.matchAll(suffixedAfterPattern)
+  ];
+  for (const mtch of matches) {
+    const match = (
+      /**
+       * @type {RegExpMatchArray & {
+       *   indices: {
+       *     groups: {
+       *       [key: string]: [number, number]
+       *     }
+       *   }
+       *   groups: {[key: string]: string}
+       * }}
+       */
+      mtch
+    );
+    const { tag, namepathOrURL, text } = match.groups;
+    const [start, end] = match.indices[0];
+    const format = determineFormat(match);
+    const decodedText = decodeInlineTagText(text, format);
+    result.push({
+      tag,
+      namepathOrURL,
+      text: decodedText,
+      format,
+      start,
+      end
+    });
+  }
+  return result;
+}
+function parseInlineTags(block) {
+  const inlineTags = (
+    /**
+     * @type {(import('./commentParserToESTree.js').JsdocInlineTagNoType & {
+     *   line?: import('./commentParserToESTree.js').Integer
+     * })[]}
+     */
+    parseDescription(block.description)
+  );
+  block.inlineTags = inlineTags;
+  for (const tag of block.tags) {
+    tag.inlineTags = parseDescription(tag.description);
+  }
+  return (
+    /**
+     * @type {import('./index.js').JsdocBlockWithInline}
+     */
+    block
+  );
+}
+
+// packages/@cjser/es-joy__jsdoccomment.tmp-26-1788540365480/src/parseComment.js
+var {
+  name: nameTokenizer,
+  tag: tagTokenizer,
+  type: typeTokenizer,
+  description: descriptionTokenizer
+} = import_comment_parser.tokenizers;
+var hasSeeWithLink = (spec) => {
+  return spec.tag === "see" && new RegExp("\\{@link.+?\\}", "v").test(spec.source[0].source);
+};
+var defaultNoTypes = [
+  "default",
+  "defaultvalue",
+  "description",
+  "example",
+  "file",
+  "fileoverview",
+  "license",
+  "overview",
+  "see",
+  "summary"
+];
+var defaultNoNames = [
+  "access",
+  "author",
+  "default",
+  "defaultvalue",
+  "description",
+  "example",
+  "exception",
+  "file",
+  "fileoverview",
+  "kind",
+  "license",
+  "overview",
+  "return",
+  "returns",
+  "since",
+  "summary",
+  "throws",
+  "version",
+  "variation"
+];
+var optionalBrackets = new RegExp("^\\[(?<name>[^=]*)=[^\\]]*\\]", "v");
+var preserveTypeTokenizer = typeTokenizer("preserve");
+var preserveDescriptionTokenizer = descriptionTokenizer("preserve");
+var plainNameTokenizer = nameTokenizer();
+var getTokenizers = ({
+  noTypes = defaultNoTypes,
+  noNames = defaultNoNames
+} = {}) => {
+  return [
+    // Tag
+    tagTokenizer(),
+    /**
+     * Type tokenizer.
+     * @param {import('comment-parser').Spec} spec
+     * @returns {import('comment-parser').Spec}
+     */
+    (spec) => {
+      if (noTypes.includes(spec.tag)) {
+        return spec;
+      }
+      return preserveTypeTokenizer(spec);
+    },
+    /**
+     * Name tokenizer.
+     * @param {import('comment-parser').Spec} spec
+     * @returns {import('comment-parser').Spec}
+     */
+    (spec) => {
+      if (spec.tag === "template") {
+        const remainder = spec.source[0].tokens.description;
+        let pos;
+        if (remainder.startsWith("[") && remainder.includes("]")) {
+          const endingBracketPos = remainder.lastIndexOf("]");
+          pos = remainder.slice(endingBracketPos).search(new RegExp("(?<![\\s,])\\s", "v"));
+          if (pos > -1) {
+            pos += endingBracketPos;
+          }
+        } else {
+          pos = remainder.search(new RegExp("(?<![\\s,])\\s", "v"));
+        }
+        const name = pos === -1 ? remainder : remainder.slice(0, pos);
+        const extra = remainder.slice(pos);
+        let postName = "", description = "", lineEnd = "";
+        if (pos > -1) {
+          [, postName, description, lineEnd] = /** @type {RegExpMatchArray} */
+          extra.match(new RegExp("(\\s*)([^\\r]*)(\\r)?", "v"));
+        }
+        spec.optional = optionalBrackets.test(name);
+        spec.name = name;
+        const { tokens } = spec.source[0];
+        tokens.name = name;
+        tokens.postName = postName;
+        tokens.description = description;
+        tokens.lineEnd = lineEnd || "";
+        return spec;
+      }
+      if (noNames.includes(spec.tag) || hasSeeWithLink(spec)) {
+        return spec;
+      }
+      return plainNameTokenizer(spec);
+    },
+    /**
+     * Description tokenizer.
+     * @param {import('comment-parser').Spec} spec
+     * @returns {import('comment-parser').Spec}
+     */
+    (spec) => {
+      return preserveDescriptionTokenizer(spec);
+    }
+  ];
+};
+var parseComment = (commentOrNode, indent = "") => {
+  let result;
+  switch (typeof commentOrNode) {
+    case "string":
+      result = (0, import_comment_parser.parse)(`${indent}${commentOrNode}`, {
+        // @see https://github.com/yavorskiy/comment-parser/issues/21
+        tokenizers: getTokenizers()
+      });
+      break;
+    case "object":
+      if (commentOrNode === null) {
+        throw new TypeError(`'commentOrNode' is not a string or object.`);
+      }
+      result = (0, import_comment_parser.parse)(`${indent}/*${commentOrNode.value}*/`, {
+        // @see https://github.com/yavorskiy/comment-parser/issues/21
+        tokenizers: getTokenizers()
+      });
+      break;
+    default:
+      throw new TypeError(`'commentOrNode' is not a string or object.`);
+  }
+  if (!result.length) {
+    throw new Error("There were no results for comment parsing");
+  }
+  const [block] = result;
+  return parseInlineTags(block);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  commentHandler,
+  commentParserToESTree,
+  defaultNoNames,
+  defaultNoTypes,
+  estreeToString,
+  findJSDocComment,
+  getDecorator,
+  getFollowingComment,
+  getJSDocComment,
+  getNonJsdocComment,
+  getReducedASTNode,
+  getTokenizers,
+  hasSeeWithLink,
+  jsdocTypeVisitorKeys,
+  jsdocVisitorKeys,
+  parseComment,
+  parseInlineTags,
+  ...require("@cjser/jsdoc-type-pratt-parser")
+});
+/**
+ * Obtained originally from {@link https://github.com/eslint/eslint/blob/master/lib/util/source-code.js#L313}.
+ *
+ * @license MIT
+ */