@diplodoc/transform 4.57.7 → 4.58.1

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

@@ -1,9 +1,9 @@
-import StateBlock from 'markdown-it/lib/rules_block/state_block';
-import Token from 'markdown-it/lib/token';
+import type StateBlock from 'markdown-it/lib/rules_block/state_block';
+import type Token from 'markdown-it/lib/token';
+import type {MarkdownItPluginCb} from '../typings';
+import type {YfmTablePluginOptions} from './types';
 
-import {MarkdownItPluginCb} from '../typings';
-
-import {AttrsParser} from './attrs';
+import {AttrsParser} from '@diplodoc/utils';
 
 const pluginName = 'yfm_table';
 const pipeChar = 0x7c; // |
@@ -12,6 +12,7 @@ const hashChar = 0x23; // #
 const backSlashChar = 0x5c; // \
 const curlyBraceOpen = 123;
 const curlyBraceClose = 125;
+const dollarChar = 36; // $
 
 const checkCharsOrder = (order: number[], src: string, pos: number) => {
     const currentOrder = [...order];
@@ -39,10 +40,21 @@ const isLiquidVariableEnd: CheckFn = (src, pos) =>
 const codeBlockOrder = [apostropheChar, apostropheChar, apostropheChar];
 const isCodeBlockOrder: CheckFn = (src, pos) => checkCharsOrder(codeBlockOrder, src, pos);
 
+const mathBlockOrder = [dollarChar, dollarChar];
+const isMathBlockOrder: CheckFn = (src, pos) => checkCharsOrder(mathBlockOrder, src, pos);
+
 const openTableOrder = [hashChar, pipeChar];
 const isOpenTableOrder: CheckFn = (src, pos) => checkCharsOrder(openTableOrder, src, pos);
 
-const notEscaped: CheckFn = (src, pos) => src.charCodeAt(pos - 1) !== backSlashChar;
+const isEscaped: CheckFn = (src, pos) => {
+    const start = pos;
+    pos--;
+    while (src.charCodeAt(pos) === backSlashChar) {
+        pos--;
+    }
+    return (start - pos) % 2 === 0;
+};
+const notEscaped: CheckFn = (src, pos) => !isEscaped(src, pos);
 
 const rowStartOrder = [pipeChar, pipeChar];
 const isRowOrder: CheckFn = (src, pos) =>
@@ -55,41 +67,159 @@ const isCellOrder: CheckFn = (src, pos) =>
 const closeTableOrder = [pipeChar, hashChar];
 const isCloseTableOrder: CheckFn = (src, pos) => checkCharsOrder(closeTableOrder, src, pos);
 
+type SkipInlineFn = (src: string, pos: number, max: number) => false | SkipInlineResult;
+type SkipInlineResult = {
+    end: number;
+    steps: number;
+};
+
+const skipInlineCode: SkipInlineFn = (src, pos, max) => {
+    // this function is an adaptation of original markdown-it backticks plugin
+    // https://github.com/markdown-it/markdown-it/blob/master/lib/rules_inline/backticks.mjs
+
+    if (src.charCodeAt(pos) !== apostropheChar) {
+        return false;
+    }
+    if (pos > 0 && isEscaped(src, pos)) {
+        return false;
+    }
+
+    const start = pos;
+
+    // scan marker length
+    while (pos < max && src.charCodeAt(pos) === apostropheChar) {
+        pos++;
+    }
+
+    const marker = src.slice(start, pos);
+    const openerLength = marker.length;
+
+    let matchEnd = pos;
+    let matchStart: number;
+
+    while ((matchStart = src.indexOf('`', matchEnd)) !== -1) {
+        matchEnd = matchStart + 1;
+
+        // scan marker length
+        while (matchEnd < max && src.charCodeAt(matchEnd) === apostropheChar) {
+            matchEnd++;
+        }
+
+        const closerLength = matchEnd - matchStart;
+
+        if (closerLength === openerLength) {
+            return {
+                end: matchEnd,
+                steps: matchEnd - start,
+            };
+        }
+    }
+
+    return false;
+};
+
+const skipInlineMath: SkipInlineFn = (src, pos, max) => {
+    // this function is an adaptation of latex-extension plugin
+    // https://github.com/diplodoc-platform/latex-extension/blob/master/src/plugin/transform.ts
+
+    if (src.charCodeAt(pos) !== dollarChar) {
+        return false;
+    }
+    if (pos > 0 && !notEscaped(src, pos)) {
+        return false;
+    }
+
+    {
+        const nextChar = pos + 1 <= max ? src.charCodeAt(pos + 1) : -1;
+        if (nextChar === 0x20 /* " " */ || nextChar === 0x09 /* \t */) {
+            return false;
+        }
+        if (nextChar === dollarChar) {
+            return {
+                end: pos + 2,
+                steps: 2,
+            };
+        }
+    }
+
+    const start = pos + 1;
+    let match = start;
+    // eslint-disable-next-line no-cond-assign
+    while ((match = src.indexOf('$', match))) {
+        if (match === -1 || match > max) {
+            return false;
+        }
+        if (isEscaped(src, match)) {
+            match++;
+            continue;
+        }
+
+        const prevChar = src.charCodeAt(match - 1);
+        const nextChar = match + 1 <= max ? src.charCodeAt(match + 1) : -1;
+        if (
+            prevChar === 0x20 /* " " */ ||
+            prevChar === 0x09 /* \t */ ||
+            (nextChar >= 0x30 /* "0" */ && nextChar <= 0x39) /* "9" */
+        ) {
+            return false;
+        }
+
+        return {
+            end: match + 1,
+            steps: match + 1 - start,
+        };
+    }
+
+    return false;
+};
+
 type Stats = {line: number; pos: number};
 
 class StateIterator {
-    pos: number;
-    line: number;
+    private _pos: number;
+    private _line: number;
+    private _lineEnds: number;
 
     private state: StateBlock;
-    private lineEnds: number;
+
+    get pos() {
+        return this._pos;
+    }
+
+    get line() {
+        return this._line;
+    }
+
+    get lineEnds() {
+        return this._lineEnds;
+    }
 
     constructor(state: StateBlock, pos: number, line: number) {
         this.state = state;
-        this.line = line;
-        this.pos = pos;
-        this.lineEnds = this.state.eMarks[this.line];
+        this._line = line;
+        this._pos = pos;
+        this._lineEnds = this.state.eMarks[this._line];
     }
 
     stats(): Stats {
         return {
-            line: this.line,
-            pos: this.pos,
+            line: this._line,
+            pos: this._pos,
         };
     }
 
     get symbol() {
-        return this.state.src[this.pos];
+        return this.state.src[this._pos];
     }
 
     next(steps = 1) {
         for (let i = 0; i < steps; i++) {
-            this.pos++;
+            this._pos++;
 
-            if (this.pos > this.lineEnds) {
-                this.line++;
-                this.pos = this.state.bMarks[this.line] + this.state.tShift[this.line];
-                this.lineEnds = this.state.eMarks[this.line];
+            if (this._pos > this._lineEnds) {
+                this._line++;
+                this._pos = this.state.bMarks[this._line] + this.state.tShift[this._line];
+                this._lineEnds = this.state.eMarks[this._line];
             }
         }
     }
@@ -101,11 +231,13 @@ interface RowPositions {
     pos: number;
 }
 
+// eslint-disable-next-line complexity
 function getTableRowPositions(
     state: StateBlock,
     startPosition: number,
     endPosition: number,
     startLine: number,
+    opts: YfmTablePluginOptions = {},
 ): RowPositions {
     let endOfTable = null;
     let tableLevel = 0;
@@ -118,7 +250,7 @@ function getTableRowPositions(
     const rows: [number, number, typeof currentRow][] = [];
 
     let isInsideCode = false;
-    let isInsideTable = false;
+    let isInsideMath = false;
     let isInsideLiquidVariable = false;
     const rowMap = new Map();
 
@@ -139,12 +271,21 @@ function getTableRowPositions(
             break;
         }
 
-        if (isCodeBlockOrder(state.src, iter.pos)) {
-            isInsideCode = !isInsideCode;
-            iter.next(codeBlockOrder.length);
+        if (opts.table_ignoreSplittersInBlockCode !== false) {
+            if (!isInsideMath && isCodeBlockOrder(state.src, iter.pos)) {
+                isInsideCode = !isInsideCode;
+                iter.next(codeBlockOrder.length);
+            }
+        }
+
+        if (opts.table_ignoreSplittersInBlockMath) {
+            if (!isInsideCode && isMathBlockOrder(state.src, iter.pos)) {
+                isInsideMath = !isInsideMath;
+                iter.next(mathBlockOrder.length);
+            }
         }
 
-        if (isInsideCode) {
+        if (isInsideCode || isInsideMath) {
             iter.next();
             continue;
         }
@@ -164,8 +305,23 @@ function getTableRowPositions(
             continue;
         }
 
+        if (opts.table_ignoreSplittersInInlineCode) {
+            const result = skipInlineCode(state.src, iter.pos, iter.lineEnds);
+            if (result !== false) {
+                iter.next(result.steps);
+                continue;
+            }
+        }
+
+        if (opts.table_ignoreSplittersInInlineMath) {
+            const result = skipInlineMath(state.src, iter.pos, iter.lineEnds);
+            if (result !== false) {
+                iter.next(result.steps);
+                continue;
+            }
+        }
+
         if (isOpenTableOrder(state.src, iter.pos)) {
-            isInsideTable = true;
             tableLevel++;
             iter.next(openTableOrder.length);
             continue;
@@ -178,16 +334,18 @@ function getTableRowPositions(
                 endOfTable = iter.line + 2;
                 break;
             } else {
-                isInsideTable = false;
                 tableLevel--;
                 iter.next(closeTableOrder.length);
                 continue;
             }
         }
 
-        if (isInsideTable) {
-            iter.next();
-            continue;
+        {
+            const isInsideTable = tableLevel > 0;
+            if (isInsideTable) {
+                iter.next();
+                continue;
+            }
         }
 
         if (isRowOrder(state.src, iter.pos)) {
@@ -359,7 +517,7 @@ const clearTokens = (tableStart: number, tokens: Token[]): void => {
     });
 };
 
-const yfmTable: MarkdownItPluginCb = (md) => {
+const yfmTable: MarkdownItPluginCb<YfmTablePluginOptions> = (md, opts) => {
     md.block.ruler.before(
         'code',
         pluginName,
@@ -386,6 +544,7 @@ const yfmTable: MarkdownItPluginCb = (md) => {
                 startPosition,
                 endPosition,
                 startLine,
+                opts,
             );
 
             const attrs = extractAttributes(state, pos);

package/src/transform/plugins/table/types.ts

@@ -0,0 +1,35 @@
+export type YfmTablePluginOptions = {
+    /**
+     * Sets whether to interpret the pipe symbol inside the code block as a table separator.
+     *
+     * Set to false if the fence rule is disabled in the parser.
+     *
+     * @default true
+     */
+    table_ignoreSplittersInBlockCode?: boolean;
+    // TODO: set table_ignoreSplittersInInlineCode=true by default in next major version
+    /**
+     * Sets whether to interpret the pipe symbol inside the inline code as a table separator.
+     *
+     * Set to true if the code_inline rule is enabled in the parser.
+     *
+     * @default false
+     */
+    table_ignoreSplittersInInlineCode?: boolean;
+    /**
+     * Sets whether to interpret the pipe symbol inside the math block as a table separator.
+     *
+     * Set to true if the math_block rule is enabled in the parser.
+     *
+     * @default false
+     */
+    table_ignoreSplittersInBlockMath?: boolean;
+    /**
+     * Sets whether to interpret the pipe symbol inside the inline math as a table separator.
+     *
+     * Set to true if the math_inline rule is enabled in the parser.
+     *
+     * @default false
+     */
+    table_ignoreSplittersInInlineMath?: boolean;
+};

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

@@ -1,7 +1,7 @@
-import StateCore from 'markdown-it/lib/rules_core/state_core';
-import Token from 'markdown-it/lib/token';
+import type StateCore from 'markdown-it/lib/rules_core/state_core';
+import type Token from 'markdown-it/lib/token';
+import type {MarkdownItPluginCb} from '../typings';
 
-import {MarkdownItPluginCb} from '../typings';
 import {generateID} from '../utils';
 
 import {termDefinitions} from './termDefinitions';

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

@@ -1,7 +1,6 @@
-import StateBlock from 'markdown-it/lib/rules_block/state_block';
-
-import {MarkdownIt} from '../../typings';
-import {MarkdownItPluginOpts} from '../typings';
+import type StateBlock from 'markdown-it/lib/rules_block/state_block';
+import type {MarkdownIt} from '../../typings';
+import type {MarkdownItPluginOpts} from '../typings';
 
 import {BASIC_TERM_REGEXP} from './constants';
 

package/src/transform/plugins/utils.ts

@@ -1,8 +1,8 @@
+import type Token from 'markdown-it/lib/token';
+import type {Logger} from '../log';
+
 import {bold} from 'chalk';
 import {platform} from 'process';
-import Token from 'markdown-it/lib/token';
-
-import {Logger} from '../log';
 
 export type MatchTokenFunction = (
     tokens: Token[],

package/src/transform/plugins/video/parsers.ts

@@ -1,5 +1,5 @@
-import {VideoService} from './const';
-import {Services} from './types';
+import type {VideoService} from './const';
+import type {Services} from './types';
 
 const ytRegex = /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#&?]*).*/;
 export function youtubeParser(url: string) {

package/src/transform/preprocessors/included/index.ts

@@ -1,6 +1,7 @@
+import type {MarkdownItPreprocessorCb} from '../../typings';
+import type {MarkdownItIncluded} from '../../plugins/includes/types';
+
 import {getFullIncludePath} from '../../utilsFS';
-import {MarkdownItPreprocessorCb} from '../../typings';
-import {MarkdownItIncluded} from '../../plugins/includes/types';
 
 const INCLUDE_REGEXP = /^\s*{%\s*included\s*\((.+?)\)\s*%}\s*$/;
 const INCLUDE_END_REGEXP = /^\s*{% endincluded %}\s*$/;

package/src/transform/sanitize.ts

@@ -1,10 +1,12 @@
-import sanitizeHtml, {Attributes, Tag} from 'sanitize-html';
+import type {Attributes, Tag} from 'sanitize-html';
+import type {CssWhiteList} from './typings';
+
+import sanitizeHtml from 'sanitize-html';
 // @ts-ignore
 import cssfilter from 'cssfilter';
 import * as cheerio from 'cheerio';
 import css from 'css';
 
-import {CssWhiteList} from './typings';
 import log from './log';
 
 export type SanitizeFunction = (

package/src/transform/title.ts

@@ -1,4 +1,4 @@
-import Token from 'markdown-it/lib/token';
+import type Token from 'markdown-it/lib/token';
 
 export = function extractTitle(tokens: Token[]) {
     let title = '',

package/src/transform/typings.ts

@@ -1,10 +1,10 @@
-import {LanguageFn} from 'highlight.js';
-import DefaultMarkdownIt, {Token} from 'markdown-it';
-import DefaultStateCore from 'markdown-it/lib/rules_core/state_core';
-
-import {SanitizeFunction, SanitizeOptions} from './sanitize';
-import {LogLevels, Logger} from './log';
-import {ChangelogItem} from './plugins/changelog/types';
+import type {LanguageFn} from 'highlight.js';
+import type {Token} from 'markdown-it';
+import type DefaultMarkdownIt from 'markdown-it';
+import type DefaultStateCore from 'markdown-it/lib/rules_core/state_core';
+import type {SanitizeFunction, SanitizeOptions} from './sanitize';
+import type {LogLevels, Logger} from './log';
+import type {ChangelogItem} from './plugins/changelog/types';
 
 export interface MarkdownIt extends DefaultMarkdownIt {
     assets?: string[];

package/src/transform/utils.ts

@@ -1,5 +1,6 @@
+import type Token from 'markdown-it/lib/token';
+
 import url from 'url';
-import Token from 'markdown-it/lib/token';
 
 export function isLocalUrl(url: string) {
     return !/^(?:[a-z]+:)?\/\//i.test(url);

package/src/transform/utilsFS.ts

@@ -1,4 +1,5 @@
 import type {Dictionary} from 'lodash';
+import type {StateCore} from './typings';
 
 import {readFileSync, realpathSync, statSync} from 'fs';
 import escapeRegExp from 'lodash/escapeRegExp';
@@ -6,7 +7,6 @@ import {join, parse, relative, resolve, sep} from 'path';
 import QuickLRU from 'quick-lru';
 
 import liquidSnippet from './liquid';
-import {StateCore} from './typings';
 import {defaultTransformLink} from './utils';
 import {preprocess} from './preprocessors';
 

package/src/transform/yfmlint/index.ts

@@ -1,11 +1,13 @@
 import type {Dictionary} from 'lodash';
+import type {Rule} from 'markdownlint';
+import type {LogLevels, Logger} from '../log';
+import type {Options} from './typings';
 
-import {Rule, sync} from 'markdownlint';
+import {sync} from 'markdownlint';
 import merge from 'lodash/merge';
 import union from 'lodash/union';
 import attrs from 'markdown-it-attrs';
 
-import {LogLevels, Logger} from '../log';
 import {preprocess} from '../preprocessors';
 
 import baseDefaultLintConfig from './yfmlint';
@@ -20,7 +22,6 @@ import {
     yfm008,
 } from './markdownlint-custom-rule';
 import {errorToString, getLogLevel} from './utils';
-import {Options} from './typings';
 import {yfm009} from './markdownlint-custom-rule/yfm009';
 
 const defaultLintRules = [yfm001, yfm002, yfm003, yfm004, yfm005, yfm006, yfm007, yfm008, yfm009];

package/src/transform/yfmlint/markdownlint-custom-rule/yfm001.ts

@@ -1,6 +1,7 @@
+import type {MarkdownItToken, Rule} from 'markdownlint';
+
 // @ts-expect-error
 import {addErrorDetailIf, filterTokens, forEachInlineCodeSpan} from 'markdownlint-rule-helpers';
-import {MarkdownItToken, Rule} from 'markdownlint';
 
 export const yfm001: Rule = {
     names: ['YFM001', 'inline-code-length'],

package/src/transform/yfmlint/markdownlint-custom-rule/yfm002.ts

@@ -1,4 +1,4 @@
-import {Rule} from 'markdownlint';
+import type {Rule} from 'markdownlint';
 
 export const yfm002: Rule = {
     names: ['YFM002', 'no-header-found-for-link'],

package/src/transform/yfmlint/markdownlint-custom-rule/yfm003.ts

@@ -1,4 +1,4 @@
-import {Rule} from 'markdownlint';
+import type {Rule} from 'markdownlint';
 
 export const yfm003: Rule = {
     names: ['YFM003', 'unreachable-link'],

package/src/transform/yfmlint/markdownlint-custom-rule/yfm004.ts

@@ -1,4 +1,4 @@
-import {Rule} from 'markdownlint';
+import type {Rule} from 'markdownlint';
 
 export const yfm004: Rule = {
     names: ['YFM004', 'table-not-closed'],

package/src/transform/yfmlint/markdownlint-custom-rule/yfm005.ts

@@ -1,4 +1,4 @@
-import {Rule} from 'markdownlint';
+import type {Rule} from 'markdownlint';
 
 export const yfm005: Rule = {
     names: ['YFM005', 'tab-list-not-closed'],

package/src/transform/yfmlint/markdownlint-custom-rule/yfm006.ts

@@ -1,4 +1,4 @@
-import {Rule} from 'markdownlint';
+import type {Rule} from 'markdownlint';
 
 export const yfm006: Rule = {
     names: ['YFM006', 'term-definition-duplicated'],

package/src/transform/yfmlint/markdownlint-custom-rule/yfm007.ts

@@ -1,4 +1,4 @@
-import {Rule} from 'markdownlint';
+import type {Rule} from 'markdownlint';
 
 export const yfm007: Rule = {
     names: ['YFM007', 'term-used-without-definition'],

package/src/transform/yfmlint/markdownlint-custom-rule/yfm008.ts

@@ -1,4 +1,4 @@
-import {Rule} from 'markdownlint';
+import type {Rule} from 'markdownlint';
 
 export const yfm008: Rule = {
     names: ['YFM008', 'term-inside-definition-not-allowed'],

package/src/transform/yfmlint/markdownlint-custom-rule/yfm009.ts

@@ -1,4 +1,4 @@
-import {Rule} from 'markdownlint';
+import type {Rule} from 'markdownlint';
 
 export const yfm009: Rule = {
     names: ['YFM009', 'no-term-definition-in-content'],

package/src/transform/yfmlint/typings.ts

@@ -1,11 +1,8 @@
 import type {Dictionary} from 'lodash';
-
 // eslint-disable-next-line @typescript-eslint/no-redeclare
-import {Plugin, Rule} from 'markdownlint';
-
-import {MarkdownItPreprocessorCb} from '../typings';
-
-import {LintConfig, PluginOptions} from '.';
+import type {Plugin, Rule} from 'markdownlint';
+import type {MarkdownItPreprocessorCb} from '../typings';
+import type {LintConfig, PluginOptions} from '.';
 
 export interface Options {
     input: string;

package/src/transform/yfmlint/utils.ts

@@ -1,10 +1,9 @@
 import type {Dictionary} from 'lodash';
+import type {LintError} from 'markdownlint';
+import type {LogLevels} from '../log';
 
-import {LintError} from 'markdownlint';
 import {sep} from 'path';
 
-import {LogLevels} from '../log';
-
 export function errorToString(path: string, error: LintError, sourceMap?: Dictionary<string>) {
     const ruleMoniker = error.ruleNames
         ? error.ruleNames.join(sep)

package/src/transform/yfmlint/yfmlint.ts

@@ -1,6 +1,6 @@
-import {LogLevels} from '../log';
+import type {LintConfig} from '.';
 
-import {LintConfig} from '.';
+import {LogLevels} from '../log';
 
 const index: LintConfig = {
     // Default state for all rules

package/lib/plugins/table/attrs.d.ts

@@ -1,18 +0,0 @@
-export declare class AttrsParser {
-    #private;
-    DELIMITER: string;
-    SEPARATOR: string;
-    QUOTATION: string;
-    ALLOWED_CHARS: RegExp;
-    VALIDATION_CHARS: RegExp;
-    parse(target: string): Record<string, string[]>;
-    private extract;
-    private next;
-    private type;
-    private append;
-    private clear;
-    private isDelimiter;
-    private isSeparator;
-    private isQuotation;
-    private isAllowedChar;
-}