markdownlint 0.26.2 → 0.28.0

package/doc/md051.md

@@ -0,0 +1,50 @@
+# `MD051` - Link fragments should be valid
+
+Tags: `links`
+
+Aliases: `link-fragments`
+
+Fixable: Some violations can be fixed by tooling
+
+This rule is triggered when a link fragment does not match any of the fragments
+that are automatically generated for headings in a document:
+
+```markdown
+# Title
+
+[Link](#fragment)
+```
+
+To fix this issue, change the link fragment to reference an existing heading:
+
+```markdown
+# Title
+
+[Link](#title)
+```
+
+Alternatively, an HTML `a` tag with an `id` or a `name` attribute can be used to
+define a fragment:
+
+```markdown
+<a id="bookmark"></a>
+
+[Link](#bookmark)
+```
+
+An `a` tag can be useful in scenarios where a heading is not appropriate or for
+control over the text of the fragment identifier.
+
+Rationale: [GitHub section links][github-section-links] are created
+automatically for every heading when Markdown content is displayed on GitHub.
+This makes it easy to link directly to different sections within a document.
+However, section links change if headings are renamed or removed. This rule
+helps identify broken section links within a document.
+
+Section links are **not** part of the CommonMark specification. This rule
+enforces the [GitHub heading algorithm][github-heading-algorithm] which is:
+convert heading to lowercase, remove punctuation, convert spaces to dashes,
+append an incrementing integer as needed for uniqueness.
+
+[github-section-links]: https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax#section-links
+[github-heading-algorithm]: https://github.com/gjtorikian/html-pipeline/blob/f13a1534cb650ba17af400d1acd3a22c28004c09/lib/html/pipeline/toc_filter.rb

package/doc/md052.md

@@ -0,0 +1,33 @@
+# `MD052` - Reference links and images should use a label that is defined
+
+Tags: `images`, `links`
+
+Aliases: `reference-links-images`
+
+Links and images in Markdown can provide the link destination or image source
+at the time of use or can define it elsewhere and use a label for reference.
+The reference format is convenient for keeping paragraph text clutter-free
+and makes it easy to reuse the same URL in multiple places.
+
+There are three kinds of reference links and images:
+
+```markdown
+Full: [text][label]
+Collapsed: [label][]
+Shortcut: [label]
+
+Full: ![text][image]
+Collapsed: ![image][]
+Shortcut: ![image]
+
+[label]: https://example.com/label
+[image]: https://example.com/image
+```
+
+A link or image renders correctly when a corresponding label is defined, but
+the text displays with brackets if the label is not present. This rule warns
+of undefined labels for "full" and "collapsed" reference syntax.
+
+> "Shortcut" syntax is ambiguous and a missing label will not generate an
+  error. For example, `[shortcut]` could be a shortcut link or the text
+  "shortcut" in brackets.

package/doc/md053.md

@@ -0,0 +1,38 @@
+# `MD053` - Link and image reference definitions should be needed
+
+Tags: `images`, `links`
+
+Aliases: `link-image-reference-definitions`
+
+Parameters:
+
+- `ignored_definitions`: Ignored definitions (`string[]`, default `["//"]`)
+
+Fixable: Some violations can be fixed by tooling
+
+Links and images in Markdown can provide the link destination or image source
+at the time of use or can define it elsewhere and use a label for reference.
+The reference format is convenient for keeping paragraph text clutter-free
+and makes it easy to reuse the same URL in multiple places.
+
+Because link and image reference definitions are located separately from
+where they are used, there are two scenarios where a definition can be
+unnecessary:
+
+1. If a label is not referenced by any link or image in a document, that
+   definition is unused and can be deleted.
+2. If a label is defined multiple times in a document, the first definition is
+   used and the others can be deleted.
+
+This rule considers a reference definition to be used if any link or image
+reference has the corresponding label. The "full", "collapsed", and "shortcut"
+formats are all supported.
+
+If there are reference definitions that are deliberately unreferenced, they can
+be ignored by setting the `ignored_definitions` parameter. The default value of
+this parameter ignores the following convention for adding non-HTML comments to
+Markdown:
+
+```markdown
+[//]: # (This behaves like a comment)
+```

package/helpers/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-2022 David Anson
+Copyright (c) David Anson
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/helpers/README.md

@@ -4,23 +4,24 @@
 
 ## Overview
 
-The [Markdown](https://en.wikipedia.org/wiki/Markdown) linter
-[`markdownlint`](https://github.com/DavidAnson/markdownlint) offers a variety of built-in validation
-[rules](https://github.com/DavidAnson/markdownlint/blob/main/doc/Rules.md) and supports the
-creation of [custom rules](https://github.com/DavidAnson/markdownlint/blob/main/doc/CustomRules.md).
-The internal rules share various helper functions; this package exposes those for reuse by custom rules.
+The [Markdown][markdown] linter [`markdownlint`][markdownlint] offers a variety
+of built-in validation [rules][rules] and supports the creation of [custom
+rules][custom-rules]. The internal rules share various helper functions; this
+package exposes those for reuse by custom rules.
 
 ## API
 
-_Undocumented_ - This package exports the internal functions as-is. The APIs were not originally meant
-to be public, are not officially supported, and may change from release to release. There are brief
-descriptive comments above each function, but no [JSDoc](https://en.m.wikipedia.org/wiki/JSDoc)
-annotations. That said, some of what's here will be useful to custom rule authors and may avoid
-duplicating code.
+*Undocumented* - This package exports the internal functions as-is. The APIs
+were not originally meant to be public, are not officially supported, and may
+change from release to release. There are brief descriptive comments above each
+function, but no [JSDoc][jsdoc] annotations. That said, some of what's here will
+be useful to custom rule authors and may avoid duplicating code.
 
-## Example
+## Examples
 
-```js
+### Using Helpers from a Custom Rule
+
+```javascript
 const { forEachLine, getLineMetadata } = require("markdownlint-rule-helpers");
 
 module.exports = {
@@ -42,9 +43,28 @@ module.exports = {
 };
 ```
 
-See also: [`markdownlint` built-in rule implementations](https://github.com/DavidAnson/markdownlint/tree/main/lib).
+### Applying Recommended Fixes
+
+```javascript
+const { "sync": markdownlintSync } = require("markdownlint");
+const markdownlintRuleHelpers = require("markdownlint-rule-helpers");
+
+function fixMarkdownlintViolations(content) {
+  const fixResults = markdownlintSync({ strings: { content } });
+  return markdownlintRuleHelpers.applyFixes(content, fixResults.content);
+}
+```
+
+See also: [`markdownlint` built-in rule implementations][lib].
 
 ## Tests
 
-_None_ - The entire body of code is tested to 100% coverage by the core `markdownlint` project,
-so there are no additional tests here.
+*None* - The entire body of code is tested to 100% coverage by the core
+`markdownlint` project, so there are no additional tests here.
+
+[custom-rules]: https://github.com/DavidAnson/markdownlint/blob/main/doc/CustomRules.md
+[jsdoc]: https://en.m.wikipedia.org/wiki/JSDoc
+[lib]: https://github.com/DavidAnson/markdownlint/tree/main/lib
+[markdown]: https://en.wikipedia.org/wiki/Markdown
+[markdownlint]: https://github.com/DavidAnson/markdownlint
+[rules]: https://github.com/DavidAnson/markdownlint/blob/main/doc/Rules.md

package/helpers/helpers.js

@@ -2,6 +2,8 @@
 
 "use strict";
 
+const micromark = require("./micromark.cjs");
+
 // Regular expression for matching common newline characters
 // See NEWLINES_RE in markdown-it/lib/rules_core/normalize.js
 const newLineRe = /\r\n?|\n/g;
@@ -10,20 +12,19 @@ module.exports.newLineRe = newLineRe;
 // Regular expression for matching common front matter (YAML and TOML)
 module.exports.frontMatterRe =
   // eslint-disable-next-line max-len
-  /((^---\s*$[^]*?^---\s*$)|(^\+\+\+\s*$[^]*?^(\+\+\+|\.\.\.)\s*$)|(^\{\s*$[^]*?^\}\s*$))(\r\n|\r|\n|$)/m;
+  /((^---\s*$[\s\S]*?^---\s*)|(^\+\+\+\s*$[\s\S]*?^(\+\+\+|\.\.\.)\s*)|(^\{\s*$[\s\S]*?^\}\s*))(\r\n|\r|\n|$)/m;
 
 // Regular expression for matching the start of inline disable/enable comments
 const inlineCommentStartRe =
   // eslint-disable-next-line max-len
-  /(<!--\s*markdownlint-(disable|enable|capture|restore|disable-file|enable-file|disable-line|disable-next-line|configure-file))(?:\s|-->)/ig;
+  /(<!--\s*markdownlint-(disable|enable|capture|restore|disable-file|enable-file|disable-line|disable-next-line|configure-file))(?:\s|-->)/gi;
 module.exports.inlineCommentStartRe = inlineCommentStartRe;
 
 // Regular expression for matching HTML elements
-const htmlElementRe = /<(([A-Za-z][A-Za-z0-9-]*)(?:\s[^`>]*)?)\/?>/g;
+const htmlElementRe = /<(([A-Za-z][A-Za-z\d-]*)(?:\s[^`>]*)?)\/?>/g;
 module.exports.htmlElementRe = htmlElementRe;
 
 // Regular expressions for range matching
-module.exports.bareUrlRe = /(?:http|ftp)s?:\/\/[^\s\]"']*(?:\/|[^\s\]"'\W])/ig;
 module.exports.listItemMarkerRe = /^([\s>]*)(?:[*+-]|\d+[.)])\s+/;
 module.exports.orderedListItemMarkerRe = /^[\s>]*0*(\d+)[.)]/;
 
@@ -34,12 +35,8 @@ const emphasisMarkersRe = /[_*]/g;
 const blockquotePrefixRe = /^[>\s]*/;
 module.exports.blockquotePrefixRe = blockquotePrefixRe;
 
-// Regular expression for reference links (full, collapsed, and shortcut)
-const referenceLinkRe =
-  /!?\\?\[((?:\[[^\]\0]*]|[^\]\0])*)](?:(?:\[([^\]\0]*)\])|([^(])|$)/g;
-
 // Regular expression for link reference definitions
-const linkReferenceDefinitionRe = /^ {0,3}\[([^\]]*[^\\])]:/;
+const linkReferenceDefinitionRe = /^ {0,3}\[([^\]]*[^\\])\]:/;
 module.exports.linkReferenceDefinitionRe = linkReferenceDefinitionRe;
 
 // All punctuation characters (normal and full-width)
@@ -142,6 +139,12 @@ module.exports.includesSorted = function includesSorted(array, element) {
 // https://spec.commonmark.org/0.29/#html-comment
 const htmlCommentBegin = "<!--";
 const htmlCommentEnd = "-->";
+const safeCommentCharacter = ".";
+const startsWithPipeRe = /^ *\|/;
+const notCrLfRe = /[^\r\n]/g;
+const notSpaceCrLfRe = /[^ \r\n]/g;
+const trailingSpaceRe = / +[\r\n]/g;
+const replaceTrailingSpace = (s) => s.replace(notCrLfRe, safeCommentCharacter);
 module.exports.clearHtmlCommentText = function clearHtmlCommentText(text) {
   let i = 0;
   while ((i = text.indexOf(htmlCommentBegin, i)) !== -1) {
@@ -152,24 +155,30 @@ module.exports.clearHtmlCommentText = function clearHtmlCommentText(text) {
     }
     // If the comment has content...
     if (j > i + htmlCommentBegin.length) {
-      let k = i - 1;
-      while (text[k] === " ") {
-        k--;
-      }
-      // If comment is not within an indented code block...
-      if (k >= i - 4) {
-        const content = text.slice(i + htmlCommentBegin.length, j);
-        const isBlock = (k < 0) || (text[k] === "\n");
-        const isValid = isBlock ||
-          (!content.startsWith(">") && !content.startsWith("->") &&
-           !content.endsWith("-") && !content.includes("--"));
-        // If a valid block/inline comment...
-        if (isValid) {
-          text =
-            text.slice(0, i + htmlCommentBegin.length) +
-            content.replace(/[^\r\n]/g, ".") +
-            text.slice(j);
-        }
+      const content = text.slice(i + htmlCommentBegin.length, j);
+      const lastLf = text.lastIndexOf("\n", i) + 1;
+      const preText = text.slice(lastLf, i);
+      const isBlock = preText.trim().length === 0;
+      const couldBeTable = startsWithPipeRe.test(preText);
+      const spansTableCells = couldBeTable && content.includes("\n");
+      const isValid =
+        isBlock ||
+        !(
+          spansTableCells ||
+          content.startsWith(">") ||
+          content.startsWith("->") ||
+          content.endsWith("-") ||
+          content.includes("--")
+        );
+      // If a valid block/inline comment...
+      if (isValid) {
+        const clearedContent = content
+          .replace(notSpaceCrLfRe, safeCommentCharacter)
+          .replace(trailingSpaceRe, replaceTrailingSpace);
+        text =
+          text.slice(0, i + htmlCommentBegin.length) +
+          clearedContent +
+          text.slice(j);
       }
     }
     i = j + htmlCommentEnd.length;
@@ -182,19 +191,6 @@ module.exports.escapeForRegExp = function escapeForRegExp(str) {
   return str.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
 };
 
-// Un-escapes Markdown content (simple algorithm; not a parser)
-const escapedMarkdownRe = /\\./g;
-module.exports.unescapeMarkdown =
-  function unescapeMarkdown(markdown, replacement) {
-    return markdown.replace(escapedMarkdownRe, (match) => {
-      const char = match[1];
-      if ("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~".includes(char)) {
-        return replacement || char;
-      }
-      return match;
-    });
-  };
-
 /**
  * Return the string representation of a fence markup character.
  *
@@ -277,7 +273,7 @@ module.exports.unorderedListStyleFor = function unorderedListStyleFor(token) {
  * @returns {void}
  */
 function filterTokens(params, type, handler) {
-  for (const token of params.tokens) {
+  for (const token of params.parsers.markdownit.tokens) {
     if (token.type === type) {
       handler(token);
     }
@@ -332,7 +328,7 @@ module.exports.getLineMetadata = function getLineMetadata(params) {
   filterTokens(params, "hr", (token) => {
     lineMetadata[token.map[0]][6] = true;
   });
-  for (const token of params.tokens.filter(isMathBlock)) {
+  for (const token of params.parsers.markdownit.tokens.filter(isMathBlock)) {
     for (let i = token.map[0]; i < token.map[1]; i++) {
       lineMetadata[i][7] = true;
     }
@@ -406,22 +402,27 @@ module.exports.flattenLists = function flattenLists(tokens) {
   return flattenedLists;
 };
 
-// Calls the provided function for each specified inline child token
-module.exports.forEachInlineChild =
+/**
+ * Calls the provided function for each specified inline child token.
+ *
+ * @param {Object} params RuleParams instance.
+ * @param {string} type Token type identifier.
+ * @param {Function} handler Callback function.
+ * @returns {void}
+ */
 function forEachInlineChild(params, type, handler) {
-  filterTokens(params, "inline", function forToken(token) {
-    for (const child of token.children) {
-      if (child.type === type) {
-        handler(child, token);
-      }
+  filterTokens(params, "inline", (token) => {
+    for (const child of token.children.filter((c) => c.type === type)) {
+      handler(child, token);
     }
   });
-};
+}
+module.exports.forEachInlineChild = forEachInlineChild;
 
 // Calls the provided function for each heading's content
 module.exports.forEachHeading = function forEachHeading(params, handler) {
   let heading = null;
-  for (const token of params.tokens) {
+  for (const token of params.parsers.markdownit.tokens) {
     if (token.type === "heading_open") {
       heading = token;
     } else if (token.type === "heading_close") {
@@ -596,6 +597,7 @@ module.exports.codeBlockAndSpanRanges = (params, lineMetadata) => {
  */
 module.exports.htmlElementRanges = (params, lineMetadata) => {
   const exclusions = [];
+  // Match with htmlElementRe
   forEachLine(lineMetadata, (line, lineIndex, inCode) => {
     let match = null;
     // eslint-disable-next-line no-unmodified-loop-condition
@@ -603,6 +605,31 @@ module.exports.htmlElementRanges = (params, lineMetadata) => {
       exclusions.push([ lineIndex, match.index, match[0].length ]);
     }
   });
+  // Match with html_inline
+  forEachInlineChild(params, "html_inline", (token, parent) => {
+    const parentContent = parent.content;
+    let tokenContent = token.content;
+    const parentIndex = parentContent.indexOf(tokenContent);
+    let deltaLines = 0;
+    let indent = 0;
+    for (let i = parentIndex - 1; i >= 0; i--) {
+      if (parentContent[i] === "\n") {
+        deltaLines++;
+      } else if (deltaLines === 0) {
+        indent++;
+      }
+    }
+    let lineIndex = token.lineNumber - 1 + deltaLines;
+    do {
+      const index = tokenContent.indexOf("\n");
+      const length = (index === -1) ? tokenContent.length : index;
+      exclusions.push([ lineIndex, indent, length ]);
+      tokenContent = tokenContent.slice(length + 1);
+      lineIndex++;
+      indent = 0;
+    } while (tokenContent.length > 0);
+  });
+  // Return results
   return exclusions;
 };
 
@@ -776,132 +803,125 @@ module.exports.emphasisMarkersInContent = emphasisMarkersInContent;
 /**
  * Returns an object with information about reference links and images.
  *
- * @param {Object} lineMetadata Line metadata object.
+ * @param {Object} params RuleParams instance.
  * @returns {Object} Reference link/image data.
  */
-function getReferenceLinkImageData(lineMetadata) {
-  // Initialize return values
-  const references = new Map();
-  const shortcuts = new Set();
+function getReferenceLinkImageData(params) {
+  const normalizeReference = (s) => s.toLowerCase().trim().replace(/\s+/g, " ");
   const definitions = new Map();
+  const definitionLineIndices = [];
   const duplicateDefinitions = [];
-  // Define helper functions
-  const normalizeLabel = (s) => s.toLowerCase().trim().replace(/\s+/g, " ");
-  const exclusions = [];
-  const excluded = (match) => withinAnyRange(
-    exclusions, 0, match.index, match[0].length - (match[3] || "").length
-  );
-  // Convert input to single-line so multi-line links/images are easier
-  const lineOffsets = [];
-  let currentOffset = 0;
-  const contentLines = [];
-  forEachLine(lineMetadata, (line, lineIndex, inCode) => {
-    lineOffsets[lineIndex] = currentOffset;
-    if (!inCode) {
-      line = line.replace(blockquotePrefixRe, "");
-      if (line.trim().length === 0) {
-        // Allow RegExp to detect the end of a block
-        line = "\0";
-      }
-      contentLines.push(line);
-      currentOffset += line.length + 1;
-    }
-  });
-  lineOffsets.push(currentOffset);
-  const contentLine = contentLines.join(" ");
-  // Determine single-line exclusions for inline code spans
-  forEachInlineCodeSpan(contentLine, (code, lineIndex, columnIndex) => {
-    exclusions.push([ 0, columnIndex, code.length ]);
-  });
-  // Identify all link/image reference definitions
-  forEachLine(lineMetadata, (line, lineIndex, inCode) => {
-    if (!inCode) {
-      const linkReferenceDefinitionMatch = linkReferenceDefinitionRe.exec(line);
-      if (linkReferenceDefinitionMatch) {
-        const label = normalizeLabel(linkReferenceDefinitionMatch[1]);
-        if (definitions.has(label)) {
-          duplicateDefinitions.push([ label, lineIndex ]);
-        } else {
-          definitions.set(label, lineIndex);
+  const references = new Map();
+  const shortcuts = new Map();
+  const filteredTokens =
+    micromark.filterByTypes(
+      params.parsers.micromark.tokens,
+      [
+        // definitionLineIndices
+        "definition", "gfmFootnoteDefinition",
+        // definitions and definitionLineIndices
+        "definitionLabelString", "gfmFootnoteDefinitionLabelString",
+        // references and shortcuts
+        "gfmFootnoteCall", "image", "link"
+      ]
+    );
+  for (const token of filteredTokens) {
+    let labelPrefix = "";
+    // eslint-disable-next-line default-case
+    switch (token.type) {
+      case "definition":
+      case "gfmFootnoteDefinition":
+        // definitionLineIndices
+        for (let i = token.startLine; i <= token.endLine; i++) {
+          definitionLineIndices.push(i - 1);
         }
-        exclusions.push([ 0, lineOffsets[lineIndex], line.length ]);
-      }
-    }
-  });
-  // Identify all link and image references
-  let lineIndex = 0;
-  const pendingContents = [
-    {
-      "content": contentLine,
-      "contentLineIndex": 0,
-      "contentIndex": 0,
-      "topLevel": true
-    }
-  ];
-  let pendingContent = null;
-  while ((pendingContent = pendingContents.shift())) {
-    const { content, contentLineIndex, contentIndex, topLevel } =
-      pendingContent;
-    let referenceLinkMatch = null;
-    while ((referenceLinkMatch = referenceLinkRe.exec(content)) !== null) {
-      const [ matchString, matchText, matchLabel ] = referenceLinkMatch;
-      if (
-        !matchString.startsWith("\\") &&
-        !matchString.startsWith("!\\") &&
-        !matchText.endsWith("\\") &&
-        !(matchLabel || "").endsWith("\\") &&
-        !(topLevel && excluded(referenceLinkMatch))
-      ) {
-        const shortcutLink = (matchLabel === undefined);
-        const collapsedLink =
-          (!shortcutLink && (matchLabel.length === 0));
-        const label = normalizeLabel(
-          (shortcutLink || collapsedLink) ? matchText : matchLabel
-        );
-        if (label.length > 0) {
-          const referenceindex = referenceLinkMatch.index;
-          if (topLevel) {
-            // Calculate line index
-            while (lineOffsets[lineIndex + 1] <= referenceindex) {
-              lineIndex++;
-            }
+        break;
+      case "gfmFootnoteDefinitionLabelString":
+        labelPrefix = "^";
+      case "definitionLabelString": // eslint-disable-line no-fallthrough
+        {
+          // definitions and definitionLineIndices
+          const reference = normalizeReference(`${labelPrefix}${token.text}`);
+          if (definitions.has(reference)) {
+            duplicateDefinitions.push([ reference, token.startLine - 1 ]);
           } else {
-            // Use provided line index
-            lineIndex = contentLineIndex;
+            definitions.set(reference, token.startLine - 1);
           }
-          const referenceIndex = referenceindex +
-            (topLevel ? -lineOffsets[lineIndex] : contentIndex);
-          if (shortcutLink) {
-            // Track separately due to ambiguity in "text [text] text"
-            shortcuts.add(label);
-          } else {
-            // Track reference and location
-            const referenceData = references.get(label) || [];
-            referenceData.push([
-              lineIndex,
-              referenceIndex,
-              matchString.length
-            ]);
-            references.set(label, referenceData);
+        }
+        break;
+      case "gfmFootnoteCall":
+      case "image":
+      case "link":
+        {
+          let isShortcut = false;
+          let isFullOrCollapsed = false;
+          let labelText = null;
+          let referenceStringText = null;
+          const shortcutCandidate =
+            micromark.matchAndGetTokensByType(token.children, [ "label" ]);
+          if (shortcutCandidate) {
+            labelText =
+              micromark.getTokenTextByType(
+                shortcutCandidate[0].children, "labelText"
+              );
+            isShortcut = (labelText !== null);
+          }
+          const fullAndCollapsedCandidate =
+            micromark.matchAndGetTokensByType(
+              token.children, [ "label", "reference" ]
+            );
+          if (fullAndCollapsedCandidate) {
+            labelText =
+              micromark.getTokenTextByType(
+                fullAndCollapsedCandidate[0].children, "labelText"
+              );
+            referenceStringText =
+              micromark.getTokenTextByType(
+                fullAndCollapsedCandidate[1].children, "referenceString"
+              );
+            isFullOrCollapsed = (labelText !== null);
+          }
+          const footnote = micromark.matchAndGetTokensByType(
+            token.children,
+            [
+              "gfmFootnoteCallLabelMarker", "gfmFootnoteCallMarker",
+              "gfmFootnoteCallString", "gfmFootnoteCallLabelMarker"
+            ],
+            [ "gfmFootnoteCallMarker", "gfmFootnoteCallString" ]
+          );
+          if (footnote) {
+            const callMarkerText = footnote[0].text;
+            const callString = footnote[1].text;
+            labelText = `${callMarkerText}${callString}`;
+            isShortcut = true;
           }
-          // Check for links embedded in brackets
-          if (!matchString.startsWith("!")) {
-            pendingContents.push({
-              "content": matchText,
-              "contentLineIndex": lineIndex,
-              "contentIndex": referenceIndex + 1,
-              "topLevel": false
-            });
+          // Track shortcuts separately due to ambiguity in "text [text] text"
+          if (isShortcut || isFullOrCollapsed) {
+            const referenceDatum = [
+              token.startLine - 1,
+              token.startColumn - 1,
+              token.text.length,
+              // @ts-ignore
+              labelText.length,
+              (referenceStringText || "").length
+            ];
+            const reference =
+              normalizeReference(referenceStringText || labelText);
+            const dictionary = isShortcut ? shortcuts : references;
+            const referenceData = dictionary.get(reference) || [];
+            referenceData.push(referenceDatum);
+            dictionary.set(reference, referenceData);
           }
         }
-      }
+        break;
     }
   }
   return {
     references,
     shortcuts,
     definitions,
-    duplicateDefinitions
+    duplicateDefinitions,
+    definitionLineIndices
   };
 }
 module.exports.getReferenceLinkImageData = getReferenceLinkImageData;
@@ -989,7 +1009,7 @@ module.exports.applyFix = applyFix;
  * @returns {string} Corrected content.
  */
 function applyFixes(input, errors) {
-  const lineEnding = getPreferredLineEnding(input, require("os"));
+  const lineEnding = getPreferredLineEnding(input, require("node:os"));
   const lines = input.split(newLineRe);
   // Normalize fixInfo objects
   let fixInfos = errors