@diplodoc/transform 4.69.1 → 4.69.2

package/src/transform/plugins/term/index.ts

@@ -1,4 +1,5 @@
 import type StateCore from 'markdown-it/lib/rules_core/state_core';
+import type StateInline from 'markdown-it/lib/rules_inline/state_inline';
 import type Token from 'markdown-it/lib/token';
 import type {MarkdownItPluginCb} from '../typings';
 
@@ -7,12 +8,129 @@ import {generateID} from '../utils';
 import {termDefinitions} from './termDefinitions';
 import {BASIC_TERM_REGEXP} from './constants';
 
+function setTermAttrs(token: Token, termKey: string): void {
+    token.attrSet('class', 'yfm yfm-term_title');
+    token.attrSet('term-key', ':' + termKey);
+    token.attrSet('role', 'button');
+    token.attrSet('aria-describedby', ':' + termKey + '_element');
+    token.attrSet('tabindex', '0');
+    token.attrSet('id', generateID());
+}
+
+interface TermMatch {
+    labelEnd: number;
+    termId: string;
+    endPos: number;
+}
+
+/**
+ * Scans src for [text](*termId) starting at `start`.
+ *
+ * @param src - source string
+ * @param start - position of the opening `[`
+ * @param max - maximum position to scan
+ * @returns match info or null
+ */
+function matchTermPattern(src: string, start: number, max: number): TermMatch | null {
+    // Scan for closing ] (no nested [ allowed, matching the original regex)
+    let pos = start + 1;
+    while (
+        pos <= max &&
+        src.charCodeAt(pos) !== 0x5d /* ] */ &&
+        src.charCodeAt(pos) !== 0x5b /* [ */
+    ) {
+        if (src.charCodeAt(pos) === 0x5c /* \ */) {
+            pos++;
+        }
+        pos++;
+    }
+
+    if (pos > max || src.charCodeAt(pos) !== 0x5d /* ] */) {
+        return null;
+    }
+
+    const labelEnd = pos;
+    if (labelEnd === start + 1) {
+        return null;
+    }
+
+    // Expect (*
+    pos = labelEnd + 1;
+    if (
+        pos + 1 > max ||
+        src.charCodeAt(pos) !== 0x28 /* ( */ ||
+        src.charCodeAt(pos + 1) !== 0x2a /* * */
+    ) {
+        return null;
+    }
+    pos += 2;
+
+    // Read term id until )
+    const termIdStart = pos;
+    while (
+        pos <= max &&
+        src.charCodeAt(pos) !== 0x29 /* ) */ &&
+        src.charCodeAt(pos) !== 0x0a /* \n */
+    ) {
+        pos++;
+    }
+
+    if (pos > max || src.charCodeAt(pos) !== 0x29 /* ) */) {
+        return null;
+    }
+
+    const termId = src.slice(termIdStart, pos);
+    if (!termId) {
+        return null;
+    }
+
+    return {labelEnd, termId, endPos: pos + 1};
+}
+
+/**
+ * Inline rule that matches [text](*termId) for defined terms.
+ * Runs before the link rule so that * characters inside the
+ * pattern are consumed and never trigger emphasis.
+ *
+ * @param state - inline parser state
+ * @param silent - if true, only validate without creating tokens
+ * @returns true if the pattern was matched
+ */
+function termInlineRule(state: StateInline, silent: boolean): boolean {
+    if (state.src.charCodeAt(state.pos) !== 0x5b /* [ */ || !state.env.terms) {
+        return false;
+    }
+
+    const match = matchTermPattern(state.src, state.pos, state.posMax);
+    if (!match || !state.env.terms[':' + match.termId]) {
+        return false;
+    }
+
+    if (silent) {
+        return true;
+    }
+
+    const labelContent = state.src.slice(state.pos + 1, match.labelEnd).replace(/\\(.)/g, '$1');
+
+    const termOpen = state.push('term_open', 'i', 1);
+    setTermAttrs(termOpen, match.termId);
+
+    const textToken = state.push('text', '', 0);
+    textToken.content = labelContent;
+
+    state.push('term_close', 'i', -1);
+
+    state.pos = match.endPos;
+    return true;
+}
+
 const term: MarkdownItPluginCb = (md, options) => {
     const escapeRE = md.utils.escapeRE;
     const arrayReplaceAt = md.utils.arrayReplaceAt;
 
     const {isLintRun} = options;
-    // Don't parse urls that starts with *
+
+    // Prevent * URLs from being parsed as regular links (backward compatibility)
     const defaultLinkValidation = md.validateLink;
     md.validateLink = function (url) {
         if (url.startsWith('*')) {
@@ -22,8 +140,11 @@ const term: MarkdownItPluginCb = (md, options) => {
         return defaultLinkValidation(url);
     };
 
+    // Inline rule: handles [text](*termId) before emphasis can interfere with *
+    md.inline.ruler.before('link', 'term_inline', termInlineRule);
+
     function termReplace(state: StateCore) {
-        let i, j, l, tokens, token, text, nodes, pos, term, currentToken;
+        let i, j, l, tokens, token, text, nodes, pos, termMatch, currentToken;
 
         const blockTokens = state.tokens;
 
@@ -61,7 +182,7 @@ const term: MarkdownItPluginCb = (md, options) => {
                     continue;
                 }
 
-                if (!(currentToken.type === 'text')) {
+                if (currentToken.type !== 'text') {
                     continue;
                 }
 
@@ -87,23 +208,18 @@ const term: MarkdownItPluginCb = (md, options) => {
                     nodes.push(token);
                 }
 
-                while ((term = reg.exec(text))) {
-                    const termTitle = term[1];
-                    const termKey = term[3];
+                while ((termMatch = reg.exec(text))) {
+                    const termTitle = termMatch[1];
+                    const termKey = termMatch[3];
 
-                    if (term.index > 0 || term[1].length > 0) {
+                    if (termMatch.index > 0 || termMatch[1].length > 0) {
                         token = new state.Token('text', '', 0);
-                        token.content = text.slice(pos, term.index);
+                        token.content = text.slice(pos, termMatch.index);
                         nodes.push(token);
                     }
 
                     token = new state.Token('term_open', 'i', 1);
-                    token.attrSet('class', 'yfm yfm-term_title');
-                    token.attrSet('term-key', ':' + termKey);
-                    token.attrSet('role', 'button');
-                    token.attrSet('aria-describedby', ':' + termKey + '_element');
-                    token.attrSet('tabindex', '0');
-                    token.attrSet('id', generateID());
+                    setTermAttrs(token, termKey);
                     nodes.push(token);
 
                     token = new state.Token('text', '', 0);