@uzum-tech/ui 2.3.4 → 2.3.6

package/lib/_utils/markdown/create-markdown-renderer.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMarkdownRenderer = createMarkdownRenderer;
+const markdown_it_1 = __importDefault(require("markdown-it"));
+const clamp_heading_1 = __importDefault(require("./rulers/clamp-heading"));
+const equals_divider_1 = __importDefault(require("./rulers/equals-divider"));
+const prune_empty_blocks_1 = __importDefault(require("./rulers/prune-empty-blocks"));
+const strikethrough_1 = __importDefault(require("./rulers/strikethrough"));
+const strip_html_1 = __importDefault(require("./rulers/strip-html"));
+function applyFeatureRendererOverrides(md, enabled) {
+    const unwrap = () => '';
+    if (!enabled.has('bold')) {
+        md.renderer.rules.strong_open = unwrap;
+        md.renderer.rules.strong_close = unwrap;
+    }
+    if (!enabled.has('italic')) {
+        md.renderer.rules.em_open = unwrap;
+        md.renderer.rules.em_close = unwrap;
+    }
+    if (!enabled.has('strikethrough')) {
+        md.renderer.rules.s_open = unwrap;
+        md.renderer.rules.s_close = unwrap;
+    }
+    if (!enabled.has('blockquote')) {
+        md.renderer.rules.blockquote_open = unwrap;
+        md.renderer.rules.blockquote_close = unwrap;
+    }
+    if (!enabled.has('orderedList')) {
+        md.renderer.rules.ordered_list_open = unwrap;
+        md.renderer.rules.ordered_list_close = unwrap;
+    }
+    if (!enabled.has('bulletList')) {
+        md.renderer.rules.bullet_list_open = unwrap;
+        md.renderer.rules.bullet_list_close = unwrap;
+    }
+    if (!enabled.has('divider')) {
+        md.renderer.rules.hr = unwrap;
+    }
+}
+function createMarkdownRenderer(resolved) {
+    const enabled = new Set(resolved.features);
+    const markdown = new markdown_it_1.default('zero', {
+        html: false,
+        linkify: false,
+        breaks: resolved.breaks,
+        typographer: false
+    });
+    markdown.enable([
+        'emphasis',
+        'strikethrough',
+        'heading',
+        'list',
+        'blockquote',
+        'hr',
+        'newline',
+        'escape',
+        'link',
+        'image',
+        'autolink'
+    ]);
+    markdown.core.ruler.before('normalize', 'u_strip_html', strip_html_1.default);
+    markdown.block.ruler.before('paragraph', 'u_equals_divider', equals_divider_1.default, {
+        alt: ['paragraph', 'reference', 'blockquote', 'list']
+    });
+    markdown.inline.ruler.before('strikethrough', 'u_strikethrough', strikethrough_1.default);
+    if (!enabled.has('heading')) {
+        markdown.disable('heading');
+    }
+    else {
+        markdown.core.ruler.after('block', 'u_clamp_heading', (0, clamp_heading_1.default)(resolved.maxHeadingLevel));
+    }
+    markdown.core.ruler.push('u_prune_empty_blocks', prune_empty_blocks_1.default);
+    markdown.validateLink = () => true;
+    markdown.renderer.rules.link_open = () => '';
+    markdown.renderer.rules.link_close = () => '';
+    markdown.renderer.rules.image = () => '';
+    markdown.renderer.rules.html_block = () => '';
+    markdown.renderer.rules.html_inline = () => '';
+    applyFeatureRendererOverrides(markdown, enabled);
+    return markdown;
+}

package/lib/_utils/markdown/index.d.ts

@@ -0,0 +1,2 @@
+export type { MarkdownFeature, MarkdownOptions } from './interface';
+export { renderMarkdown, sanitizeMarkdown } from './render-markdown';

package/lib/_utils/markdown/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeMarkdown = exports.renderMarkdown = void 0;
+var render_markdown_1 = require("./render-markdown");
+Object.defineProperty(exports, "renderMarkdown", { enumerable: true, get: function () { return render_markdown_1.renderMarkdown; } });
+Object.defineProperty(exports, "sanitizeMarkdown", { enumerable: true, get: function () { return render_markdown_1.sanitizeMarkdown; } });

package/lib/_utils/markdown/interface.d.ts

@@ -0,0 +1,14 @@
+export declare enum TOKEN_TYPE {
+    HEADING_OPEN = "heading_open",
+    HEADING_CLOSE = "heading_close",
+    PARAGRAPH_OPEN = "paragraph_open",
+    PARAGRAPH_CLOSE = "paragraph_close"
+}
+export interface MarkdownOptions {
+    features?: MarkdownFeature[];
+    maxHeadingLevel?: number;
+    breaks?: boolean;
+}
+export interface NormalizedMarkdownOptions extends Required<MarkdownOptions> {
+}
+export type MarkdownFeature = 'bold' | 'italic' | 'strikethrough' | 'heading' | 'orderedList' | 'bulletList' | 'blockquote' | 'divider';

package/lib/_utils/markdown/interface.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOKEN_TYPE = void 0;
+var TOKEN_TYPE;
+(function (TOKEN_TYPE) {
+    TOKEN_TYPE["HEADING_OPEN"] = "heading_open";
+    TOKEN_TYPE["HEADING_CLOSE"] = "heading_close";
+    TOKEN_TYPE["PARAGRAPH_OPEN"] = "paragraph_open";
+    TOKEN_TYPE["PARAGRAPH_CLOSE"] = "paragraph_close";
+})(TOKEN_TYPE || (exports.TOKEN_TYPE = TOKEN_TYPE = {}));

package/lib/_utils/markdown/render-markdown.d.ts

@@ -0,0 +1,3 @@
+import type { MarkdownOptions } from './interface';
+export declare function renderMarkdown(content: string, options?: MarkdownOptions): string;
+export declare function sanitizeMarkdown(content: string, options?: MarkdownOptions): string;

package/lib/_utils/markdown/render-markdown.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMarkdown = renderMarkdown;
+exports.sanitizeMarkdown = sanitizeMarkdown;
+const constants_1 = require("./constants");
+const create_markdown_renderer_1 = require("./create-markdown-renderer");
+const rendererCache = new Map();
+function normalizeOptions(options) {
+    var _a, _b, _c;
+    return {
+        features: [...((_a = options === null || options === void 0 ? void 0 : options.features) !== null && _a !== void 0 ? _a : constants_1.ALL_MARKDOWN_FEATURES)],
+        maxHeadingLevel: Math.min(constants_1.MAX_HEADING_LEVEL, Math.max(1, (_b = options === null || options === void 0 ? void 0 : options.maxHeadingLevel) !== null && _b !== void 0 ? _b : constants_1.MAX_HEADING_LEVEL)),
+        breaks: (_c = options === null || options === void 0 ? void 0 : options.breaks) !== null && _c !== void 0 ? _c : true
+    };
+}
+function getMarkdownRenderer(options) {
+    const normalizedOptions = normalizeOptions(options);
+    const instance = rendererCache.get(normalizedOptions);
+    if (!instance) {
+        const renderer = (0, create_markdown_renderer_1.createMarkdownRenderer)(normalizedOptions);
+        rendererCache.set(normalizedOptions, renderer);
+        return renderer;
+    }
+    return instance;
+}
+function renderMarkdown(content, options) {
+    if (!content)
+        return '';
+    return getMarkdownRenderer(options).render(content).trim();
+}
+function sanitizeMarkdown(content, options) {
+    if (!content)
+        return '';
+    let text = renderMarkdown(content, options).replace(constants_1.ANY_HTML_TAG_REGEX, ' ');
+    for (const [pattern, replacement] of constants_1.HTML_ENTITY_REPLACEMENTS)
+        text = text.replace(pattern, replacement);
+    return text.replace(constants_1.WHITESPACE_REGEX, ' ').trim();
+}

package/lib/_utils/markdown/rulers/clamp-heading.d.ts

@@ -0,0 +1,2 @@
+import type { StateCore } from 'markdown-it';
+export default function createClampHeadingRule(maxLevel: number): (state: StateCore) => void;

package/lib/_utils/markdown/rulers/clamp-heading.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createClampHeadingRule;
+const interface_1 = require("../interface");
+function toParagraph(token, type) {
+    token.type = type;
+    token.tag = 'p';
+    token.markup = '';
+}
+function createClampHeadingRule(maxLevel) {
+    return (state) => {
+        for (let index = 0; index < state.tokens.length; index++) {
+            const openToken = state.tokens[index];
+            if (openToken.type !== interface_1.TOKEN_TYPE.HEADING_OPEN)
+                continue;
+            const level = Number(openToken.tag.slice(1));
+            if (!Number.isFinite(level) || level <= maxLevel)
+                continue;
+            const inlineToken = state.tokens[index + 1];
+            const closeToken = state.tokens[index + 2];
+            toParagraph(openToken, interface_1.TOKEN_TYPE.PARAGRAPH_OPEN);
+            if ((closeToken === null || closeToken === void 0 ? void 0 : closeToken.type) === interface_1.TOKEN_TYPE.HEADING_CLOSE) {
+                toParagraph(closeToken, interface_1.TOKEN_TYPE.PARAGRAPH_CLOSE);
+            }
+            if ((inlineToken === null || inlineToken === void 0 ? void 0 : inlineToken.type) === 'inline') {
+                inlineToken.content = `${'#'.repeat(level)} ${inlineToken.content}`;
+            }
+        }
+    };
+}

package/lib/_utils/markdown/rulers/equals-divider.d.ts

@@ -0,0 +1,2 @@
+import type { StateBlock } from 'markdown-it';
+export default function equalsDivider(state: StateBlock, startLine: number, endLine: number, silent: boolean): boolean;

package/lib/_utils/markdown/rulers/equals-divider.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = equalsDivider;
+const constants_1 = require("../constants");
+function equalsDivider(state, startLine, endLine, silent) {
+    if (state.sCount[startLine] - state.blkIndent >= constants_1.MAX_DIVIDER_INDENT)
+        return false;
+    let position = state.bMarks[startLine] + state.tShift[startLine];
+    const max = state.eMarks[startLine];
+    let count = 0;
+    while (position < max) {
+        const charCode = state.src.charCodeAt(position);
+        if (charCode === constants_1.CHAR_CODES.EQUALS)
+            count++;
+        else if (charCode !== constants_1.CHAR_CODES.SPACE && charCode !== constants_1.CHAR_CODES.TAB)
+            return false;
+        position++;
+    }
+    if (count < constants_1.MIN_DIVIDER_MARKERS)
+        return false;
+    if (silent)
+        return true;
+    state.line = startLine + 1;
+    const token = state.push('hr', 'hr', 0);
+    token.map = [startLine, state.line];
+    token.markup = '='.repeat(count);
+    return true;
+}

package/lib/_utils/markdown/rulers/prune-empty-blocks.d.ts

@@ -0,0 +1,2 @@
+import type { StateCore } from 'markdown-it';
+export default function pruneEmptyBlocksCoreRule(state: StateCore): void;

package/lib/_utils/markdown/rulers/prune-empty-blocks.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = pruneEmptyBlocksCoreRule;
+const constants_1 = require("../constants");
+const interface_1 = require("../interface");
+function inlineHasVisibleContent(children) {
+    if (!children || children.length === 0)
+        return false;
+    for (const child of children) {
+        if (child.type === 'text') {
+            if (child.content.trim().length > 0)
+                return true;
+            continue;
+        }
+        if (!constants_1.INVISIBLE_INLINE_TOKEN_TYPES.includes(child.type))
+            return true;
+    }
+    return false;
+}
+function pruneEmptyBlocksCoreRule(state) {
+    const { tokens } = state;
+    for (let index = 0; index < tokens.length; index++) {
+        const openToken = tokens[index];
+        const isPrunableBlock = openToken.type === interface_1.TOKEN_TYPE.PARAGRAPH_OPEN
+            || openToken.type === interface_1.TOKEN_TYPE.HEADING_OPEN;
+        if (!isPrunableBlock)
+            continue;
+        const inlineToken = tokens[index + 1];
+        const closeToken = tokens[index + 2];
+        const closeType = openToken.type === interface_1.TOKEN_TYPE.PARAGRAPH_OPEN
+            ? interface_1.TOKEN_TYPE.PARAGRAPH_CLOSE
+            : interface_1.TOKEN_TYPE.HEADING_CLOSE;
+        if ((inlineToken === null || inlineToken === void 0 ? void 0 : inlineToken.type) !== 'inline' || (closeToken === null || closeToken === void 0 ? void 0 : closeToken.type) !== closeType)
+            continue;
+        if (!inlineHasVisibleContent(inlineToken.children)) {
+            tokens.splice(index, constants_1.EMPTY_BLOCK_TOKEN_COUNT);
+            index -= 1;
+        }
+    }
+}

package/lib/_utils/markdown/rulers/strikethrough.d.ts

@@ -0,0 +1,3 @@
+import type { StateInline } from 'markdown-it';
+declare function strikethroughInlineRule(state: StateInline, silent: boolean): boolean;
+export default strikethroughInlineRule;

package/lib/_utils/markdown/rulers/strikethrough.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+function strikethroughInlineRule(state, silent) {
+    const max = state.posMax;
+    const start = state.pos;
+    if (state.src.charCodeAt(start) !== constants_1.CHAR_CODES.TILDE)
+        return false;
+    if (silent)
+        return false;
+    if (start + 2 >= max)
+        return false;
+    state.pos = start + 1;
+    let found = false;
+    while (state.pos < max) {
+        if (state.src.charCodeAt(state.pos) === constants_1.CHAR_CODES.TILDE) {
+            found = true;
+            break;
+        }
+        state.md.inline.skipToken(state);
+    }
+    if (!found || start + 1 === state.pos) {
+        state.pos = start;
+        return false;
+    }
+    const content = state.src.slice(start + 1, state.pos);
+    if (content.includes(constants_1.MARKDOWN_SYMBOL.NEWLINE)) {
+        state.pos = start;
+        return false;
+    }
+    state.posMax = state.pos;
+    state.pos = start + 1;
+    let token = state.push('s_open', constants_1.MARKDOWN_SYMBOL.STRIKETHROUGH_TAG, 1);
+    token.markup = constants_1.MARKDOWN_SYMBOL.TILDE;
+    token = state.push('text', '', 0);
+    token.content = content.replace(/\\(.)/g, '$1');
+    token = state.push('s_close', constants_1.MARKDOWN_SYMBOL.STRIKETHROUGH_TAG, -1);
+    token.markup = constants_1.MARKDOWN_SYMBOL.TILDE;
+    state.pos = state.posMax + 1;
+    state.posMax = max;
+    return true;
+}
+exports.default = strikethroughInlineRule;

package/lib/_utils/markdown/rulers/strip-html.d.ts

@@ -0,0 +1,2 @@
+import type { StateCore } from 'markdown-it';
+export default function stripHtmlCoreRule(state: StateCore): void;

package/lib/_utils/markdown/rulers/strip-html.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = stripHtmlCoreRule;
+const constants_1 = require("../constants");
+function stripHtml(source) {
+    return source
+        .replace(constants_1.HTML_COMMENT_REGEX, '')
+        .replace(constants_1.HTML_CDATA_REGEX, '')
+        .replace(constants_1.HTML_RAW_BLOCK_REGEX, '')
+        .replace(constants_1.HTML_DECLARATION_REGEX, '')
+        .replace(constants_1.HTML_TAG_REGEX, '');
+}
+function stripHtmlCoreRule(state) {
+    state.src = stripHtml(state.src);
+}