@libs-ui/components-preview-text-data 0.2.357-1 → 0.2.357-10

package/esm2022/editor/editor-forbidden.mjs

@@ -0,0 +1,65 @@
+import { syntaxTree } from '@codemirror/language';
+import { linter } from '@codemirror/lint';
+import { EditorState, Transaction } from '@codemirror/state';
+const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const toGlobalRegex = (pattern) => {
+    if (pattern instanceof RegExp) {
+        const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+        return new RegExp(pattern.source, flags);
+    }
+    return new RegExp(escapeRegex(pattern), 'gi');
+};
+/**
+ * Extension bảo mật gồm 2 layer:
+ * 1. Linter: highlight đỏ tại đúng vị trí match (bỏ qua match trong comment) + gọi `emitViolations`.
+ * 2. Transaction filter: chặn paste nếu nội dung paste chứa pattern cấm.
+ */
+export const buildForbiddenExtension = (patterns, emitViolations) => {
+    const forbiddenLinter = linter((view) => {
+        const diagnostics = [];
+        const violations = [];
+        const text = view.state.doc.toString();
+        const commentRanges = [];
+        syntaxTree(view.state).iterate({
+            enter: (node) => {
+                if (node.type.name.toLowerCase().includes('comment')) {
+                    commentRanges.push({ from: node.from, to: node.to });
+                }
+            },
+        });
+        const isInComment = (from, to) => commentRanges.some((r) => from >= r.from && to <= r.to);
+        for (const pattern of patterns) {
+            const re = toGlobalRegex(pattern);
+            re.lastIndex = 0;
+            let match;
+            while ((match = re.exec(text)) !== null) {
+                const from = match.index;
+                const to = from + match[0].length;
+                if (isInComment(from, to))
+                    continue;
+                const line = view.state.doc.lineAt(from).number;
+                const patternLabel = pattern instanceof RegExp ? pattern.source : pattern;
+                diagnostics.push({ from, to, severity: 'error', message: `Mã bị cấm: "${match[0]}" — vi phạm chính sách bảo mật` });
+                violations.push({ from, to, line, pattern: patternLabel, matched: match[0] });
+            }
+        }
+        emitViolations(violations);
+        return diagnostics;
+    });
+    const pasteFilter = EditorState.transactionFilter.of((tr) => {
+        if (!tr.docChanged)
+            return tr;
+        if (!tr.annotation(Transaction.userEvent)?.startsWith('input.paste'))
+            return tr;
+        const newText = tr.newDoc.toString();
+        for (const pattern of patterns) {
+            const re = toGlobalRegex(pattern);
+            re.lastIndex = 0;
+            if (re.test(newText))
+                return [];
+        }
+        return tr;
+    });
+    return [forbiddenLinter, pasteFilter];
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor-forbidden.js","sourceRoot":"","sources":["../../../../../../libs-ui/components/preview-text-data/src/editor/editor-forbidden.ts"],"names":[],"mappings":"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","sourcesContent":["import { syntaxTree } from '@codemirror/language';\nimport { Diagnostic, linter } from '@codemirror/lint';\nimport { EditorState, Extension, Transaction } from '@codemirror/state';\nimport type { SyntaxNodeRef } from '@lezer/common';\nimport { IPreviewTextDataViolation, T_ForbiddenPattern } from '../preview-text-data.interfaces';\n\nconst escapeRegex = (str: string): string => str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\nconst toGlobalRegex = (pattern: T_ForbiddenPattern): RegExp => {\n  if (pattern instanceof RegExp) {\n    const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;\n    return new RegExp(pattern.source, flags);\n  }\n  return new RegExp(escapeRegex(pattern), 'gi');\n};\n\n/**\n * Extension bảo mật gồm 2 layer:\n * 1. Linter: highlight đỏ tại đúng vị trí match (bỏ qua match trong comment) + gọi `emitViolations`.\n * 2. Transaction filter: chặn paste nếu nội dung paste chứa pattern cấm.\n */\nexport const buildForbiddenExtension = (patterns: T_ForbiddenPattern[], emitViolations: (violations: IPreviewTextDataViolation[]) => void): Extension => {\n  const forbiddenLinter = linter((view) => {\n    const diagnostics: Diagnostic[] = [];\n    const violations: IPreviewTextDataViolation[] = [];\n    const text = view.state.doc.toString();\n\n    const commentRanges: { from: number; to: number }[] = [];\n    syntaxTree(view.state).iterate({\n      enter: (node: SyntaxNodeRef) => {\n        if (node.type.name.toLowerCase().includes('comment')) {\n          commentRanges.push({ from: node.from, to: node.to });\n        }\n      },\n    });\n    const isInComment = (from: number, to: number): boolean => commentRanges.some((r) => from >= r.from && to <= r.to);\n\n    for (const pattern of patterns) {\n      const re = toGlobalRegex(pattern);\n      re.lastIndex = 0;\n      let match: RegExpExecArray | null;\n      while ((match = re.exec(text)) !== null) {\n        const from = match.index;\n        const to = from + match[0].length;\n        if (isInComment(from, to)) continue;\n        const line = view.state.doc.lineAt(from).number;\n        const patternLabel = pattern instanceof RegExp ? pattern.source : pattern;\n        diagnostics.push({ from, to, severity: 'error', message: `Mã bị cấm: \"${match[0]}\" — vi phạm chính sách bảo mật` });\n        violations.push({ from, to, line, pattern: patternLabel, matched: match[0] });\n      }\n    }\n\n    emitViolations(violations);\n    return diagnostics;\n  });\n\n  const pasteFilter = EditorState.transactionFilter.of((tr: Transaction) => {\n    if (!tr.docChanged) return tr;\n    if (!tr.annotation(Transaction.userEvent)?.startsWith('input.paste')) return tr;\n    const newText = tr.newDoc.toString();\n    for (const pattern of patterns) {\n      const re = toGlobalRegex(pattern);\n      re.lastIndex = 0;\n      if (re.test(newText)) return [];\n    }\n    return tr;\n  });\n\n  return [forbiddenLinter, pasteFilter];\n};\n"]}

package/esm2022/editor/editor-height.mjs

@@ -0,0 +1,87 @@
+/** Parse giá trị CSS px → number. Trả về undefined nếu không phải px hợp lệ (vd `none`, `0`). */
+export const parsePx = (raw) => {
+    if (!raw || !raw.endsWith('px')) {
+        return undefined;
+    }
+    const value = parseFloat(raw);
+    return Number.isFinite(value) && value > 0 ? value : undefined;
+};
+/** Bù dòng trống cho đủ `minLines` (xử lý 1 lần khi khởi tạo). Đủ rồi giữ nguyên, không cắt bớt. */
+export const applyMinLines = (content, minLines) => {
+    const value = content ?? '';
+    if (!minLines || minLines <= 0) {
+        return value;
+    }
+    const currentLines = value === '' ? 1 : value.split('\n').length;
+    if (currentLines >= minLines) {
+        return value;
+    }
+    return value + '\n'.repeat(minLines - currentLines);
+};
+/**
+ * Tính min/max-height vùng cuộn theo CSS của container ngoài, snap về bội số dòng.
+ * Trừ offset phần header/toolbar (giữa đỉnh container và đỉnh vùng cuộn) để vừa khít container.
+ */
+export const applyContainerHeight = (view, container) => {
+    const style = getComputedStyle(container);
+    const minPx = parsePx(style.minHeight);
+    const maxPx = parsePx(style.maxHeight);
+    if (minPx === undefined && maxPx === undefined) {
+        return;
+    }
+    view.requestMeasure({
+        read: (measureView) => {
+            const line = measureView.contentDOM.querySelector('.cm-line');
+            const lineHeight = (line ? line.getBoundingClientRect().height : measureView.defaultLineHeight) || 20;
+            const offsetTop = Math.max(measureView.scrollDOM.getBoundingClientRect().top - container.getBoundingClientRect().top, 0);
+            const toLines = (px) => Math.max(1, Math.floor((px - offsetTop - 8) / lineHeight));
+            return { lineHeight, minLines: minPx === undefined ? undefined : toLines(minPx), maxLines: maxPx === undefined ? undefined : toLines(maxPx) };
+        },
+        write: ({ lineHeight, minLines, maxLines }, writeView) => {
+            if (maxLines !== undefined) {
+                writeView.scrollDOM.style.maxHeight = `${maxLines * lineHeight + 8}px`;
+                writeView.scrollDOM.style.overflowY = 'auto';
+            }
+            // min-height: bù dòng trống vào content (hiện đủ line-number 1..N), giống cơ chế minLines.
+            if (minLines !== undefined) {
+                const currentLines = writeView.state.doc.lines;
+                if (currentLines < minLines) {
+                    queueMicrotask(() => writeView.dispatch({ changes: { from: writeView.state.doc.length, insert: '\n'.repeat(minLines - currentLines) } }));
+                }
+            }
+        },
+    });
+};
+/**
+ * Giới hạn chiều cao editor (xử lý 1 lần). 2 chế độ loại trừ nhau:
+ * - `maxLines`: cap theo số dòng truyền vào.
+ * - `container`: tự tính số dòng theo `min-height`/`max-height` (CSS) của container, snap bội số dòng.
+ * Cấu hình đồng thời `container` + `minLines`/`maxLines` → throw.
+ */
+export const applyMaxHeight = (view, options) => {
+    const { minLines, maxLines, container } = options;
+    if (container && (minLines || maxLines)) {
+        throw new Error('[preview-text-data] CẤM cấu hình [containerElement] cùng [minLines]/[maxLines]. Container tự quản lý min/max height.');
+    }
+    if (!view) {
+        return;
+    }
+    if (container) {
+        applyContainerHeight(view, container);
+        return;
+    }
+    if (!maxLines || maxLines <= 0) {
+        return;
+    }
+    view.requestMeasure({
+        read: (measureView) => {
+            const line = measureView.contentDOM.querySelector('.cm-line');
+            return (line ? line.getBoundingClientRect().height : measureView.defaultLineHeight) || 20;
+        },
+        write: (lineHeight, writeView) => {
+            writeView.scrollDOM.style.maxHeight = `${maxLines * lineHeight + 8}px`;
+            writeView.scrollDOM.style.overflowY = 'auto';
+        },
+    });
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor-height.js","sourceRoot":"","sources":["../../../../../../libs-ui/components/preview-text-data/src/editor/editor-height.ts"],"names":[],"mappings":"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","sourcesContent":["import { EditorView } from '@codemirror/view';\n\n/** Parse giá trị CSS px → number. Trả về undefined nếu không phải px hợp lệ (vd `none`, `0`). */\nexport const parsePx = (raw: string): number | undefined => {\n  if (!raw || !raw.endsWith('px')) {\n    return undefined;\n  }\n  const value = parseFloat(raw);\n  return Number.isFinite(value) && value > 0 ? value : undefined;\n};\n\n/** Bù dòng trống cho đủ `minLines` (xử lý 1 lần khi khởi tạo). Đủ rồi giữ nguyên, không cắt bớt. */\nexport const applyMinLines = (content: string, minLines?: number): string => {\n  const value = content ?? '';\n  if (!minLines || minLines <= 0) {\n    return value;\n  }\n  const currentLines = value === '' ? 1 : value.split('\\n').length;\n  if (currentLines >= minLines) {\n    return value;\n  }\n  return value + '\\n'.repeat(minLines - currentLines);\n};\n\n/**\n * Tính min/max-height vùng cuộn theo CSS của container ngoài, snap về bội số dòng.\n * Trừ offset phần header/toolbar (giữa đỉnh container và đỉnh vùng cuộn) để vừa khít container.\n */\nexport const applyContainerHeight = (view: EditorView, container: HTMLElement): void => {\n  const style = getComputedStyle(container);\n  const minPx = parsePx(style.minHeight);\n  const maxPx = parsePx(style.maxHeight);\n  if (minPx === undefined && maxPx === undefined) {\n    return;\n  }\n  view.requestMeasure({\n    read: (measureView) => {\n      const line = measureView.contentDOM.querySelector('.cm-line');\n      const lineHeight = (line ? line.getBoundingClientRect().height : measureView.defaultLineHeight) || 20;\n      const offsetTop = Math.max(measureView.scrollDOM.getBoundingClientRect().top - container.getBoundingClientRect().top, 0);\n      const toLines = (px: number) => Math.max(1, Math.floor((px - offsetTop - 8) / lineHeight));\n      return { lineHeight, minLines: minPx === undefined ? undefined : toLines(minPx), maxLines: maxPx === undefined ? undefined : toLines(maxPx) };\n    },\n    write: ({ lineHeight, minLines, maxLines }, writeView) => {\n      if (maxLines !== undefined) {\n        writeView.scrollDOM.style.maxHeight = `${maxLines * lineHeight + 8}px`;\n        writeView.scrollDOM.style.overflowY = 'auto';\n      }\n      // min-height: bù dòng trống vào content (hiện đủ line-number 1..N), giống cơ chế minLines.\n      if (minLines !== undefined) {\n        const currentLines = writeView.state.doc.lines;\n        if (currentLines < minLines) {\n          queueMicrotask(() => writeView.dispatch({ changes: { from: writeView.state.doc.length, insert: '\\n'.repeat(minLines - currentLines) } }));\n        }\n      }\n    },\n  });\n};\n\n/**\n * Giới hạn chiều cao editor (xử lý 1 lần). 2 chế độ loại trừ nhau:\n * - `maxLines`: cap theo số dòng truyền vào.\n * - `container`: tự tính số dòng theo `min-height`/`max-height` (CSS) của container, snap bội số dòng.\n * Cấu hình đồng thời `container` + `minLines`/`maxLines` → throw.\n */\nexport const applyMaxHeight = (view: EditorView | undefined, options: { minLines?: number; maxLines?: number; container?: HTMLElement }): void => {\n  const { minLines, maxLines, container } = options;\n  if (container && (minLines || maxLines)) {\n    throw new Error('[preview-text-data] CẤM cấu hình [containerElement] cùng [minLines]/[maxLines]. Container tự quản lý min/max height.');\n  }\n  if (!view) {\n    return;\n  }\n  if (container) {\n    applyContainerHeight(view, container);\n    return;\n  }\n  if (!maxLines || maxLines <= 0) {\n    return;\n  }\n  view.requestMeasure({\n    read: (measureView) => {\n      const line = measureView.contentDOM.querySelector('.cm-line');\n      return (line ? line.getBoundingClientRect().height : measureView.defaultLineHeight) || 20;\n    },\n    write: (lineHeight, writeView) => {\n      writeView.scrollDOM.style.maxHeight = `${maxLines * lineHeight + 8}px`;\n      writeView.scrollDOM.style.overflowY = 'auto';\n    },\n  });\n};\n"]}

package/esm2022/linters/js-linter.mjs

@@ -0,0 +1,348 @@
+import { get } from '@libs-ui/utils';
+import { astSkipKeys, astTypeKeys, tsValueNodes } from '../preview-text-data.define';
+import { getTokenBefore } from './linter-shared';
+// Cache module-level (chia sẻ giữa các instance editor) — đều immutable, lazy-load 1 lần.
+let babelParserModule;
+let knownGlobalsSet;
+/** Lazy-load + cache module @babel/parser (chỉ tải lần đầu khi lint JS/TS). */
+const getBabelParser = async () => {
+    if (!babelParserModule) {
+        babelParserModule = await import('@babel/parser');
+    }
+    return babelParserModule;
+};
+/** Lazy-load + cache tập biến toàn cục JS/DOM hợp lệ từ package `globals` (JSON thuần, browser-safe). */
+const getKnownGlobals = async () => {
+    if (!knownGlobalsSet) {
+        const globalsModule = (await import('globals'));
+        const globalsData = (globalsModule.default ?? globalsModule);
+        knownGlobalsSet = new Set([...Object.keys(globalsData['builtin'] ?? {}), ...Object.keys(globalsData['browser'] ?? {}), ...Object.keys(globalsData['es2021'] ?? {})]);
+    }
+    return knownGlobalsSet;
+};
+/**
+ * Parse code, trả về vừa danh sách lỗi cú pháp vừa AST (nếu parse sạch).
+ * `errorRecovery` gom nhiều lỗi vào `result.errors`; lỗi nặng vẫn `throw` → bắt thêm ở catch.
+ */
+export const parseJs = (parser, code) => {
+    try {
+        const result = parser.parse(code, {
+            sourceType: 'module',
+            errorRecovery: true,
+            plugins: ['typescript', 'jsx'],
+            allowReturnOutsideFunction: true,
+            allowAwaitOutsideFunction: true,
+            allowImportExportEverywhere: true,
+            allowSuperOutsideMethod: true,
+            allowNewTargetOutsideFunction: true,
+            allowUndeclaredExports: true,
+        });
+        return { errors: result.errors, ast: result };
+    }
+    catch (error) {
+        const loc = get(error, 'loc');
+        const message = get(error, 'message') || 'JavaScript syntax error';
+        return { errors: [{ loc, message }] };
+    }
+};
+/** Giữ cho test/back-compat: chỉ lấy danh sách lỗi cú pháp. */
+export const collectBabelErrors = (parser, code) => parseJs(parser, code).errors;
+/**
+ * Quét text từng dòng, flag dấu "." cuối dòng (incomplete property access) tại ĐÚNG vị trí dấu chấm.
+ * Thu thập `taintedLines` (dòng có trailing dot) + `dotPositions` (offset dấu chấm để vá khi parse).
+ */
+export const collectTrailingDotDiagnostics = (doc, diagnostics, taintedLines, dotPositions) => {
+    for (let lineNumber = 1; lineNumber <= doc.lines; lineNumber++) {
+        const line = doc.line(lineNumber);
+        const trimmed = line.text.trimEnd();
+        const match = /(\w+)\.\s*$/.exec(trimmed);
+        if (!match) {
+            continue;
+        }
+        taintedLines.add(lineNumber);
+        const dotPosition = line.from + trimmed.lastIndexOf('.');
+        dotPositions.push(dotPosition);
+        diagnostics.push({ from: dotPosition, to: dotPosition + 1, severity: 'error', message: `Incomplete property access on "${match[1]}"` });
+    }
+};
+/** Thay các ký tự tại `positions` bằng space, giữ nguyên độ dài chuỗi (để offset không đổi). */
+const replaceCharsWithSpace = (code, positions) => {
+    if (!positions.length) {
+        return code;
+    }
+    const chars = code.split('');
+    for (const position of positions) {
+        if (position >= 0 && position < chars.length) {
+            chars[position] = ' ';
+        }
+    }
+    return chars.join('');
+};
+/** VariableDeclaration ở `for(let i=0;...)` / `for..in` / `for..of` KHÔNG cần `;` cuối. */
+const requiresSemicolon = (nodeType, parentType, keyInParent) => {
+    if (nodeType === 'VariableDeclaration') {
+        if (parentType === 'ForStatement' && keyInParent === 'init')
+            return false;
+        if ((parentType === 'ForInStatement' || parentType === 'ForOfStatement') && keyInParent === 'left')
+            return false;
+    }
+    return true;
+};
+/**
+ * Rule custom "require semicolon": câu lệnh (const/let/return/expression...) không kết thúc bằng `;` → báo lỗi.
+ * Dùng vị trí `node.end` của AST babel; bỏ qua dòng tainted (trailing dot) để không chồng lỗi.
+ */
+export const collectMissingSemicolonDiagnostics = (ast, code, diagnostics, taintedLines) => {
+    const semiNodes = new Set(['ExpressionStatement', 'VariableDeclaration', 'ReturnStatement', 'ThrowStatement', 'BreakStatement', 'ContinueStatement', 'DoWhileStatement', 'DebuggerStatement']);
+    const seen = new Set();
+    const lineOf = (offset) => code.slice(0, offset).split('\n').length;
+    const walk = (node, parentType, keyInParent) => {
+        if (Array.isArray(node)) {
+            for (const item of node)
+                walk(item, parentType, keyInParent);
+            return;
+        }
+        if (!node || typeof node !== 'object')
+            return;
+        const current = node;
+        if (typeof current.type !== 'string')
+            return;
+        if (semiNodes.has(current.type) && requiresSemicolon(current.type, parentType, keyInParent) && typeof current.end === 'number') {
+            const end = Math.min(current.end, code.length);
+            if (end > 0 && code.charAt(end - 1) !== ';' && !seen.has(end) && !taintedLines.has(lineOf(end - 1))) {
+                seen.add(end);
+                diagnostics.push({ from: end - 1, to: end, severity: 'error', message: 'Missing semicolon' });
+            }
+        }
+        for (const childKey of Object.keys(current)) {
+            if (astSkipKeys.has(childKey))
+                continue;
+            walk(current[childKey], current.type, childKey);
+        }
+    };
+    walk(ast.program ?? ast, '', '');
+};
+/** Chuẩn hóa message: thân thiện cho trailing dot + heuristic kiểu cũ cho "Unexpected token"; bỏ hậu tố "(line:col)". */
+export const buildJsErrorMessage = (doc, from, rawMessage) => {
+    const charBefore = from > 0 ? doc.sliceString(from - 1, from) : '';
+    if (charBefore === '.') {
+        const owner = getTokenBefore(doc, from).replace(/\.$/, '');
+        return owner ? `Incomplete property access on "${owner}"` : 'Incomplete property access';
+    }
+    const cleaned = rawMessage.replace(/\s*\(\d+:\d+\)\s*$/, '').trim();
+    if (/missing semicolon/i.test(cleaned)) {
+        return 'Unexpected token — missing operator or separator between expressions';
+    }
+    if (/^unexpected token$/i.test(cleaned)) {
+        const prevToken = getTokenBefore(doc, from);
+        if (prevToken.endsWith('('))
+            return 'Missing closing ")"';
+        if (prevToken.endsWith('['))
+            return 'Missing closing "]"';
+        if (/^function$/i.test(prevToken))
+            return 'Expected function name or "("';
+        if (/^return$/i.test(prevToken))
+            return 'Invalid expression after "return"';
+        if (/^=>$/.test(prevToken))
+            return 'Expected function body after "=>"';
+        if (/^const$|^let$|^var$/i.test(prevToken))
+            return 'Expected variable name';
+    }
+    return `JavaScript syntax error: ${cleaned}`;
+};
+/** Lấy tên binding từ pattern (Identifier, destructuring object/array, default, rest). */
+const collectPatternNames = (node, declared) => {
+    if (!node || typeof node.type !== 'string')
+        return;
+    switch (node.type) {
+        case 'Identifier':
+            if (node.name)
+                declared.add(node.name);
+            return;
+        case 'ObjectPattern':
+            if (node.properties)
+                for (const property of node.properties)
+                    collectPatternNames(property.type === 'RestElement' ? property.argument : property.value, declared);
+            return;
+        case 'ArrayPattern':
+            if (node.elements)
+                for (const element of node.elements)
+                    collectPatternNames(element, declared);
+            return;
+        case 'AssignmentPattern':
+            collectPatternNames(node.left, declared);
+            return;
+        case 'RestElement':
+            collectPatternNames(node.argument, declared);
+            return;
+        case 'TSParameterProperty':
+            collectPatternNames(node.parameter, declared);
+            return;
+        default:
+            return;
+    }
+};
+/** Thu thập tên binding (biến/hàm/class/param/import/enum...) từ 1 node vào tập `declared`. */
+const collectBindingNames = (node, declared) => {
+    switch (node.type) {
+        case 'VariableDeclarator':
+            collectPatternNames(node.id, declared);
+            return;
+        case 'FunctionDeclaration':
+        case 'FunctionExpression':
+        case 'ClassDeclaration':
+        case 'ClassExpression':
+            if (node.id?.name)
+                declared.add(node.id.name);
+            if (node.params)
+                for (const param of node.params)
+                    collectPatternNames(param, declared);
+            return;
+        case 'ArrowFunctionExpression':
+            if (node.params)
+                for (const param of node.params)
+                    collectPatternNames(param, declared);
+            return;
+        case 'CatchClause':
+            collectPatternNames(node.param, declared);
+            return;
+        case 'ImportDefaultSpecifier':
+        case 'ImportNamespaceSpecifier':
+        case 'ImportSpecifier':
+            if (node.local?.name)
+                declared.add(node.local.name);
+            return;
+        case 'TSEnumDeclaration':
+        case 'TSModuleDeclaration':
+            if (node.id?.name)
+                declared.add(node.id.name);
+            return;
+        default:
+            return;
+    }
+};
+/** Xác định 1 Identifier có phải tham chiếu giá trị không (loại property access, key object, declaration id, label...). */
+const isReferenceIdentifier = (parent, keyInParent) => {
+    if (!parent)
+        return true;
+    const parentType = parent.type;
+    if ((parentType === 'MemberExpression' || parentType === 'OptionalMemberExpression') && keyInParent === 'property' && !parent.computed)
+        return false;
+    if ((parentType === 'ObjectProperty' || parentType === 'ObjectMethod' || parentType === 'ClassMethod' || parentType === 'ClassProperty' || parentType === 'ClassPrivateProperty' || parentType === 'PropertyDefinition') && keyInParent === 'key' && !parent.computed)
+        return false;
+    if (keyInParent === 'label')
+        return false;
+    if (parentType === 'TSQualifiedName' && keyInParent === 'right')
+        return false;
+    if (parentType === 'VariableDeclarator' && keyInParent === 'id')
+        return false;
+    if ((parentType === 'FunctionDeclaration' || parentType === 'FunctionExpression' || parentType === 'ClassDeclaration' || parentType === 'ClassExpression') && keyInParent === 'id')
+        return false;
+    if (parentType === 'ImportSpecifier' || parentType === 'ImportDefaultSpecifier' || parentType === 'ImportNamespaceSpecifier' || parentType === 'ExportSpecifier')
+        return false;
+    if (parentType === 'MetaProperty')
+        return false;
+    if (parentType === 'TSEnumMember' && keyInParent === 'id')
+        return false;
+    return true;
+};
+/** Duyệt đệ quy AST: gom binding name vào `declared`, gom identifier tham chiếu vào `references`. */
+const walkAstNode = (node, parent, keyInParent, inType, declared, references) => {
+    if (Array.isArray(node)) {
+        for (const item of node)
+            walkAstNode(item, parent, keyInParent, inType, declared, references);
+        return;
+    }
+    if (!node || typeof node !== 'object')
+        return;
+    const current = node;
+    if (typeof current.type !== 'string')
+        return;
+    collectBindingNames(current, declared);
+    if (current.type === 'Identifier' && !inType && isReferenceIdentifier(parent, keyInParent)) {
+        const start = current.loc?.start;
+        if (current.name && start)
+            references.push({ name: current.name, line: start.line, column: start.column });
+    }
+    const opensType = inType || (current.type.startsWith('TS') && !tsValueNodes.has(current.type));
+    for (const childKey of Object.keys(current)) {
+        if (astSkipKeys.has(childKey))
+            continue;
+        const child = current[childKey];
+        const childOpensType = typeof child === 'object' && child !== null && typeof child.type === 'string' && child.type.startsWith('TS') && !tsValueNodes.has(child.type);
+        const childInType = opensType || astTypeKeys.has(childKey) || childOpensType;
+        walkAstNode(child, current, childKey, childInType, declared, references);
+    }
+};
+/**
+ * Pass ngữ nghĩa: báo biến CHƯA KHAI BÁO. Tự duyệt AST (object thuần) — KHÔNG dùng `@babel/traverse`
+ * (cần `process` của Node → crash browser). Hợp lệ = binding trong code + global JS/DOM + `completionLabels`.
+ */
+export const collectUndeclaredIdentifiers = async (ast, doc, completionLabels, taintedLines = new Set()) => {
+    const globalsSet = await getKnownGlobals();
+    const declared = new Set();
+    const references = [];
+    walkAstNode(ast, null, '', false, declared, references);
+    const diagnostics = [];
+    const seen = new Set();
+    for (const reference of references) {
+        const { name, line: startLine, column: startColumn } = reference;
+        if (declared.has(name) || globalsSet.has(name) || completionLabels.has(name))
+            continue;
+        if (taintedLines.has(startLine))
+            continue;
+        const dedupeKey = `${startLine}:${startColumn}:${name}`;
+        if (seen.has(dedupeKey))
+            continue;
+        seen.add(dedupeKey);
+        const line = doc.line(Math.min(Math.max(startLine, 1), doc.lines));
+        const from = Math.min(line.from + Math.max(startColumn, 0), doc.length);
+        const to = Math.min(from + name.length, doc.length);
+        diagnostics.push({ from, to: Math.max(from + 1, to), severity: 'error', message: `"${name}" is not defined` });
+    }
+    return diagnostics;
+};
+/**
+ * Toàn bộ pipeline validate JS/TS:
+ * - Pass 1: trailing dot (text) — flag đúng vị trí dấu `.` cuối dòng + đánh dấu dòng tainted.
+ * - Pass 2: lỗi cú pháp babel — bỏ lỗi trên dòng tainted (cascading).
+ * - Pass 3: rule cần AST (thiếu `;`, biến chưa khai báo). Trailing dot được "vá" (`.`→space) để babel
+ *   vẫn parse được phần còn lại → rule vẫn chạy cho các dòng KHÁC.
+ */
+export const computeJsDiagnostics = async (doc, code, completionLabels) => {
+    const diagnostics = [];
+    if (code.trim() === '') {
+        return diagnostics;
+    }
+    const taintedLines = new Set();
+    const dotPositions = [];
+    collectTrailingDotDiagnostics(doc, diagnostics, taintedLines, dotPositions);
+    const parseCode = replaceCharsWithSpace(code, dotPositions);
+    const parser = await getBabelParser();
+    const { errors, ast } = parseJs(parser, parseCode);
+    const seen = new Set();
+    for (const error of errors) {
+        const location = error.loc;
+        if (!location)
+            continue;
+        const lineNumber = Math.min(Math.max(location.line, 1), doc.lines);
+        if (taintedLines.has(lineNumber))
+            continue;
+        const line = doc.line(lineNumber);
+        const errorPos = Math.min(line.from + Math.max(location.column, 0), doc.length);
+        const to = Math.min(errorPos + 1, doc.length);
+        const from = errorPos >= to && errorPos > 0 ? errorPos - 1 : errorPos;
+        const message = buildJsErrorMessage(doc, errorPos, error.message);
+        const dedupeKey = `${from}:${message}`;
+        if (seen.has(dedupeKey))
+            continue;
+        seen.add(dedupeKey);
+        diagnostics.push({ from, to: Math.max(from + 1, to), severity: 'error', message });
+    }
+    if (errors.length === 0 && ast) {
+        collectMissingSemicolonDiagnostics(ast, code, diagnostics, taintedLines);
+        diagnostics.push(...(await collectUndeclaredIdentifiers(ast, doc, completionLabels, taintedLines)));
+    }
+    return diagnostics;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"js-linter.js","sourceRoot":"","sources":["../../../../../../libs-ui/components/preview-text-data/src/linters/js-linter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAErF,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAKjD,0FAA0F;AAC1F,IAAI,iBAA6D,CAAC;AAClE,IAAI,eAAwC,CAAC;AAE7C,+EAA+E;AAC/E,MAAM,cAAc,GAAG,KAAK,IAA6C,EAAE;IACzE,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACvB,iBAAiB,GAAG,MAAM,MAAM,CAAC,eAAe,CAAC,CAAC;IACpD,CAAC;IACD,OAAO,iBAAiB,CAAC;AAC3B,CAAC,CAAC;AAEF,yGAAyG;AACzG,MAAM,eAAe,GAAG,KAAK,IAA0B,EAAE;IACvD,IAAI,CAAC,eAAe,EAAE,CAAC;QACrB,MAAM,aAAa,GAAG,CAAC,MAAM,MAAM,CAAC,SAAS,CAAC,CAAqE,CAAC;QACpH,MAAM,WAAW,GAAG,CAAC,aAAa,CAAC,OAAO,IAAI,aAAa,CAA4C,CAAC;QACxG,eAAe,GAAG,IAAI,GAAG,CAAS,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAC/K,CAAC;IACD,OAAO,eAAe,CAAC;AACzB,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,MAAsC,EAAE,IAAY,EAA4C,EAAE;IACxH,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE;YAChC,UAAU,EAAE,QAAQ;YACpB,aAAa,EAAE,IAAI;YACnB,OAAO,EAAE,CAAC,YAAY,EAAE,KAAK,CAAC;YAC9B,0BAA0B,EAAE,IAAI;YAChC,yBAAyB,EAAE,IAAI;YAC/B,2BAA2B,EAAE,IAAI;YACjC,uBAAuB,EAAE,IAAI;YAC7B,6BAA6B,EAAE,IAAI;YACnC,sBAAsB,EAAE,IAAI;SAC7B,CAAC,CAAC;QACH,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAwB,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC;IAClE,CAAC;IAAC,OAAO,KAAc,EAAE,CAAC;QACxB,MAAM,GAAG,GAAG,GAAG,CAAC,KAAK,EAAE,KAAK,CAAiD,CAAC;QAC9E,MAAM,OAAO,GAAI,GAAG,CAAC,KAAK,EAAE,SAAS,CAAY,IAAI,yBAAyB,CAAC;QAC/E,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IACxC,CAAC;AACH,CAAC,CAAC;AAEF,+DAA+D;AAC/D,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,MAAsC,EAAE,IAAY,EAAkB,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC;AAEzI;;;GAGG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,GAAS,EAAE,WAAyB,EAAE,YAAyB,EAAE,YAAsB,EAAQ,EAAE;IAC7I,KAAK,IAAI,UAAU,GAAG,CAAC,EAAE,UAAU,IAAI,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,CAAC;QAC/D,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAClC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QACpC,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC1C,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,SAAS;QACX,CAAC;QACD,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAC7B,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACzD,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC/B,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,WAAW,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,kCAAkC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;IAC1I,CAAC;AACH,CAAC,CAAC;AAEF,gGAAgG;AAChG,MAAM,qBAAqB,GAAG,CAAC,IAAY,EAAE,SAAmB,EAAU,EAAE;IAC1E,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC7B,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,IAAI,QAAQ,IAAI,CAAC,IAAI,QAAQ,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;YAC7C,KAAK,CAAC,QAAQ,CAAC,GAAG,GAAG,CAAC;QACxB,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AACxB,CAAC,CAAC;AAEF,2FAA2F;AAC3F,MAAM,iBAAiB,GAAG,CAAC,QAAgB,EAAE,UAAkB,EAAE,WAAmB,EAAW,EAAE;IAC/F,IAAI,QAAQ,KAAK,qBAAqB,EAAE,CAAC;QACvC,IAAI,UAAU,KAAK,cAAc,IAAI,WAAW,KAAK,MAAM;YAAE,OAAO,KAAK,CAAC;QAC1E,IAAI,CAAC,UAAU,KAAK,gBAAgB,IAAI,UAAU,KAAK,gBAAgB,CAAC,IAAI,WAAW,KAAK,MAAM;YAAE,OAAO,KAAK,CAAC;IACnH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,kCAAkC,GAAG,CAAC,GAAW,EAAE,IAAY,EAAE,WAAyB,EAAE,YAAyB,EAAQ,EAAE;IAC1I,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,CAAC,qBAAqB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAC/L,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,MAAM,GAAG,CAAC,MAAc,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;IAC5E,MAAM,IAAI,GAAG,CAAC,IAAa,EAAE,UAAkB,EAAE,WAAmB,EAAQ,EAAE;QAC5E,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACxB,KAAK,MAAM,IAAI,IAAI,IAAI;gBAAE,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,WAAW,CAAC,CAAC;YAC7D,OAAO;QACT,CAAC;QACD,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,OAAO;QAC9C,MAAM,OAAO,GAAG,IAAiB,CAAC;QAClC,IAAI,OAAO,OAAO,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO;QAE7C,IAAI,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,iBAAiB,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,WAAW,CAAC,IAAI,OAAO,OAAO,CAAC,GAAG,KAAK,QAAQ,EAAE,CAAC;YAC/H,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;YAC/C,IAAI,GAAG,GAAG,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;gBACpG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBACd,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,GAAG,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,CAAC,CAAC;YAChG,CAAC;QACH,CAAC;QAED,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5C,IAAI,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC;gBAAE,SAAS;YACxC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QAClD,CAAC;IACH,CAAC,CAAC;IACF,IAAI,CAAE,GAA6B,CAAC,OAAO,IAAI,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;AAC9D,CAAC,CAAC;AAEF,yHAAyH;AACzH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,GAAS,EAAE,IAAY,EAAE,UAAkB,EAAU,EAAE;IACzF,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACnE,IAAI,UAAU,KAAK,GAAG,EAAE,CAAC;QACvB,MAAM,KAAK,GAAG,cAAc,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAC3D,OAAO,KAAK,CAAC,CAAC,CAAC,kCAAkC,KAAK,GAAG,CAAC,CAAC,CAAC,4BAA4B,CAAC;IAC3F,CAAC;IAED,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,oBAAoB,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IACpE,IAAI,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QACvC,OAAO,sEAAsE,CAAC;IAChF,CAAC;IACD,IAAI,qBAAqB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QACxC,MAAM,SAAS,GAAG,cAAc,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAC5C,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC;YAAE,OAAO,qBAAqB,CAAC;QAC1D,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC;YAAE,OAAO,qBAAqB,CAAC;QAC1D,IAAI,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC;YAAE,OAAO,+BAA+B,CAAC;QAC1E,IAAI,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC;YAAE,OAAO,mCAAmC,CAAC;QAC5E,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC;YAAE,OAAO,mCAAmC,CAAC;QACvE,IAAI,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC;YAAE,OAAO,wBAAwB,CAAC;IAC9E,CAAC;IACD,OAAO,4BAA4B,OAAO,EAAE,CAAC;AAC/C,CAAC,CAAC;AAEF,0FAA0F;AAC1F,MAAM,mBAAmB,GAAG,CAAC,IAAkC,EAAE,QAAqB,EAAQ,EAAE;IAC9F,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ;QAAE,OAAO;IACnD,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,YAAY;YACf,IAAI,IAAI,CAAC,IAAI;gBAAE,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACvC,OAAO;QACT,KAAK,eAAe;YAClB,IAAI,IAAI,CAAC,UAAU;gBAAE,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,UAAU;oBAAE,mBAAmB,CAAC,QAAQ,CAAC,IAAI,KAAK,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YACjK,OAAO;QACT,KAAK,cAAc;YACjB,IAAI,IAAI,CAAC,QAAQ;gBAAE,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ;oBAAE,mBAAmB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;YAC/F,OAAO;QACT,KAAK,mBAAmB;YACtB,mBAAmB,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;YACzC,OAAO;QACT,KAAK,aAAa;YAChB,mBAAmB,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAC7C,OAAO;QACT,KAAK,qBAAqB;YACxB,mBAAmB,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;YAC9C,OAAO;QACT;YACE,OAAO;IACX,CAAC;AACH,CAAC,CAAC;AAEF,+FAA+F;AAC/F,MAAM,mBAAmB,GAAG,CAAC,IAAe,EAAE,QAAqB,EAAQ,EAAE;IAC3E,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,oBAAoB;YACvB,mBAAmB,CAAC,IAAI,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;YACvC,OAAO;QACT,KAAK,qBAAqB,CAAC;QAC3B,KAAK,oBAAoB,CAAC;QAC1B,KAAK,kBAAkB,CAAC;QACxB,KAAK,iBAAiB;YACpB,IAAI,IAAI,CAAC,EAAE,EAAE,IAAI;gBAAE,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;YAC9C,IAAI,IAAI,CAAC,MAAM;gBAAE,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM;oBAAE,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YACvF,OAAO;QACT,KAAK,yBAAyB;YAC5B,IAAI,IAAI,CAAC,MAAM;gBAAE,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM;oBAAE,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YACvF,OAAO;QACT,KAAK,aAAa;YAChB,mBAAmB,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YAC1C,OAAO;QACT,KAAK,wBAAwB,CAAC;QAC9B,KAAK,0BAA0B,CAAC;QAChC,KAAK,iBAAiB;YACpB,IAAI,IAAI,CAAC,KAAK,EAAE,IAAI;gBAAE,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACpD,OAAO;QACT,KAAK,mBAAmB,CAAC;QACzB,KAAK,qBAAqB;YACxB,IAAI,IAAI,CAAC,EAAE,EAAE,IAAI;gBAAE,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;YAC9C,OAAO;QACT;YACE,OAAO;IACX,CAAC;AACH,CAAC,CAAC;AAEF,2HAA2H;AAC3H,MAAM,qBAAqB,GAAG,CAAC,MAAwB,EAAE,WAAmB,EAAW,EAAE;IACvF,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC;IAC/B,IAAI,CAAC,UAAU,KAAK,kBAAkB,IAAI,UAAU,KAAK,0BAA0B,CAAC,IAAI,WAAW,KAAK,UAAU,IAAI,CAAC,MAAM,CAAC,QAAQ;QAAE,OAAO,KAAK,CAAC;IACrJ,IAAI,CAAC,UAAU,KAAK,gBAAgB,IAAI,UAAU,KAAK,cAAc,IAAI,UAAU,KAAK,aAAa,IAAI,UAAU,KAAK,eAAe,IAAI,UAAU,KAAK,sBAAsB,IAAI,UAAU,KAAK,oBAAoB,CAAC,IAAI,WAAW,KAAK,KAAK,IAAI,CAAC,MAAM,CAAC,QAAQ;QAAE,OAAO,KAAK,CAAC;IACpR,IAAI,WAAW,KAAK,OAAO;QAAE,OAAO,KAAK,CAAC;IAC1C,IAAI,UAAU,KAAK,iBAAiB,IAAI,WAAW,KAAK,OAAO;QAAE,OAAO,KAAK,CAAC;IAC9E,IAAI,UAAU,KAAK,oBAAoB,IAAI,WAAW,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9E,IAAI,CAAC,UAAU,KAAK,qBAAqB,IAAI,UAAU,KAAK,oBAAoB,IAAI,UAAU,KAAK,kBAAkB,IAAI,UAAU,KAAK,iBAAiB,CAAC,IAAI,WAAW,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IACjM,IAAI,UAAU,KAAK,iBAAiB,IAAI,UAAU,KAAK,wBAAwB,IAAI,UAAU,KAAK,0BAA0B,IAAI,UAAU,KAAK,iBAAiB;QAAE,OAAO,KAAK,CAAC;IAC/K,IAAI,UAAU,KAAK,cAAc;QAAE,OAAO,KAAK,CAAC;IAChD,IAAI,UAAU,KAAK,cAAc,IAAI,WAAW,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IACxE,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AAEF,qGAAqG;AACrG,MAAM,WAAW,GAAG,CAAC,IAAa,EAAE,MAAwB,EAAE,WAAmB,EAAE,MAAe,EAAE,QAAqB,EAAE,UAA4B,EAAQ,EAAE;IAC/J,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QACxB,KAAK,MAAM,IAAI,IAAI,IAAI;YAAE,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;QAC9F,OAAO;IACT,CAAC;IACD,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO;IAC9C,MAAM,OAAO,GAAG,IAAiB,CAAC;IAClC,IAAI,OAAO,OAAO,CAAC,IAAI,KAAK,QAAQ;QAAE,OAAO;IAE7C,mBAAmB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAEvC,IAAI,OAAO,CAAC,IAAI,KAAK,YAAY,IAAI,CAAC,MAAM,IAAI,qBAAqB,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE,CAAC;QAC3F,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC;QACjC,IAAI,OAAO,CAAC,IAAI,IAAI,KAAK;YAAE,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IAC7G,CAAC;IAED,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IAC/F,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QAC5C,IAAI,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC;YAAE,SAAS;QACxC,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;QAChC,MAAM,cAAc,GAAG,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,OAAQ,KAAmB,CAAC,IAAI,KAAK,QAAQ,IAAK,KAAmB,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAE,KAAmB,CAAC,IAAI,CAAC,CAAC;QAClN,MAAM,WAAW,GAAG,SAAS,IAAI,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,cAAc,CAAC;QAC7E,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;IAC3E,CAAC;AACH,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,KAAK,EAAE,GAAW,EAAE,GAAS,EAAE,gBAA6B,EAAE,eAA4B,IAAI,GAAG,EAAE,EAAyB,EAAE;IACxK,MAAM,UAAU,GAAG,MAAM,eAAe,EAAE,CAAC;IAC3C,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;IACnC,MAAM,UAAU,GAAqB,EAAE,CAAC;IAExC,WAAW,CAAC,GAAgB,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;IAErE,MAAM,WAAW,GAAiB,EAAE,CAAC;IACrC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,SAAS,CAAC;QACjE,IAAI,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,SAAS;QACvF,IAAI,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,SAAS;QAE1C,MAAM,SAAS,GAAG,GAAG,SAAS,IAAI,WAAW,IAAI,IAAI,EAAE,CAAC;QACxD,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,SAAS;QAClC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAEpB,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;QACnE,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QACxE,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QACpD,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,IAAI,kBAAkB,EAAE,CAAC,CAAC;IACjH,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,KAAK,EAAE,GAAS,EAAE,IAAY,EAAE,gBAA6B,EAAyB,EAAE;IAC1H,MAAM,WAAW,GAAiB,EAAE,CAAC;IACrC,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QACvB,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;IACvC,MAAM,YAAY,GAAa,EAAE,CAAC;IAClC,6BAA6B,CAAC,GAAG,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;IAE5E,MAAM,SAAS,GAAG,qBAAqB,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IAC5D,MAAM,MAAM,GAAG,MAAM,cAAc,EAAE,CAAC;IACtC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACnD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC;QAC3B,IAAI,CAAC,QAAQ;YAAE,SAAS;QACxB,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;QACnE,IAAI,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC;YAAE,SAAS;QAC3C,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAClC,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QAChF,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,GAAG,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QAC9C,MAAM,IAAI,GAAG,QAAQ,IAAI,EAAE,IAAI,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QACtE,MAAM,OAAO,GAAG,mBAAmB,CAAC,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;QAClE,MAAM,SAAS,GAAG,GAAG,IAAI,IAAI,OAAO,EAAE,CAAC;QACvC,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,SAAS;QAClC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACpB,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;IACrF,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,GAAG,EAAE,CAAC;QAC/B,kCAAkC,CAAC,GAAG,EAAE,IAAI,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC;QACzE,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,4BAA4B,CAAC,GAAG,EAAE,GAAG,EAAE,gBAAgB,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IACtG,CAAC;IAED,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC","sourcesContent":["import { Diagnostic } from '@codemirror/lint';\nimport { Text } from '@codemirror/state';\nimport { get } from '@libs-ui/utils';\nimport { astSkipKeys, astTypeKeys, tsValueNodes } from '../preview-text-data.define';\nimport { T_AstNode } from '../preview-text-data.type';\nimport { getTokenBefore } from './linter-shared';\n\ntype T_BabelError = { loc?: { line: number; column: number }; message: string };\ntype T_AstReference = { name: string; line: number; column: number };\n\n// Cache module-level (chia sẻ giữa các instance editor) — đều immutable, lazy-load 1 lần.\nlet babelParserModule: typeof import('@babel/parser') | undefined;\nlet knownGlobalsSet: Set<string> | undefined;\n\n/** Lazy-load + cache module @babel/parser (chỉ tải lần đầu khi lint JS/TS). */\nconst getBabelParser = async (): Promise<typeof import('@babel/parser')> => {\n  if (!babelParserModule) {\n    babelParserModule = await import('@babel/parser');\n  }\n  return babelParserModule;\n};\n\n/** Lazy-load + cache tập biến toàn cục JS/DOM hợp lệ từ package `globals` (JSON thuần, browser-safe). */\nconst getKnownGlobals = async (): Promise<Set<string>> => {\n  if (!knownGlobalsSet) {\n    const globalsModule = (await import('globals')) as unknown as { default?: Record<string, Record<string, boolean>> };\n    const globalsData = (globalsModule.default ?? globalsModule) as Record<string, Record<string, boolean>>;\n    knownGlobalsSet = new Set<string>([...Object.keys(globalsData['builtin'] ?? {}), ...Object.keys(globalsData['browser'] ?? {}), ...Object.keys(globalsData['es2021'] ?? {})]);\n  }\n  return knownGlobalsSet;\n};\n\n/**\n * Parse code, trả về vừa danh sách lỗi cú pháp vừa AST (nếu parse sạch).\n * `errorRecovery` gom nhiều lỗi vào `result.errors`; lỗi nặng vẫn `throw` → bắt thêm ở catch.\n */\nexport const parseJs = (parser: typeof import('@babel/parser'), code: string): { errors: T_BabelError[]; ast?: object } => {\n  try {\n    const result = parser.parse(code, {\n      sourceType: 'module',\n      errorRecovery: true,\n      plugins: ['typescript', 'jsx'],\n      allowReturnOutsideFunction: true,\n      allowAwaitOutsideFunction: true,\n      allowImportExportEverywhere: true,\n      allowSuperOutsideMethod: true,\n      allowNewTargetOutsideFunction: true,\n      allowUndeclaredExports: true,\n    });\n    return { errors: result.errors as T_BabelError[], ast: result };\n  } catch (error: unknown) {\n    const loc = get(error, 'loc') as { line: number; column: number } | undefined;\n    const message = (get(error, 'message') as string) || 'JavaScript syntax error';\n    return { errors: [{ loc, message }] };\n  }\n};\n\n/** Giữ cho test/back-compat: chỉ lấy danh sách lỗi cú pháp. */\nexport const collectBabelErrors = (parser: typeof import('@babel/parser'), code: string): T_BabelError[] => parseJs(parser, code).errors;\n\n/**\n * Quét text từng dòng, flag dấu \".\" cuối dòng (incomplete property access) tại ĐÚNG vị trí dấu chấm.\n * Thu thập `taintedLines` (dòng có trailing dot) + `dotPositions` (offset dấu chấm để vá khi parse).\n */\nexport const collectTrailingDotDiagnostics = (doc: Text, diagnostics: Diagnostic[], taintedLines: Set<number>, dotPositions: number[]): void => {\n  for (let lineNumber = 1; lineNumber <= doc.lines; lineNumber++) {\n    const line = doc.line(lineNumber);\n    const trimmed = line.text.trimEnd();\n    const match = /(\\w+)\\.\\s*$/.exec(trimmed);\n    if (!match) {\n      continue;\n    }\n    taintedLines.add(lineNumber);\n    const dotPosition = line.from + trimmed.lastIndexOf('.');\n    dotPositions.push(dotPosition);\n    diagnostics.push({ from: dotPosition, to: dotPosition + 1, severity: 'error', message: `Incomplete property access on \"${match[1]}\"` });\n  }\n};\n\n/** Thay các ký tự tại `positions` bằng space, giữ nguyên độ dài chuỗi (để offset không đổi). */\nconst replaceCharsWithSpace = (code: string, positions: number[]): string => {\n  if (!positions.length) {\n    return code;\n  }\n  const chars = code.split('');\n  for (const position of positions) {\n    if (position >= 0 && position < chars.length) {\n      chars[position] = ' ';\n    }\n  }\n  return chars.join('');\n};\n\n/** VariableDeclaration ở `for(let i=0;...)` / `for..in` / `for..of` KHÔNG cần `;` cuối. */\nconst requiresSemicolon = (nodeType: string, parentType: string, keyInParent: string): boolean => {\n  if (nodeType === 'VariableDeclaration') {\n    if (parentType === 'ForStatement' && keyInParent === 'init') return false;\n    if ((parentType === 'ForInStatement' || parentType === 'ForOfStatement') && keyInParent === 'left') return false;\n  }\n  return true;\n};\n\n/**\n * Rule custom \"require semicolon\": câu lệnh (const/let/return/expression...) không kết thúc bằng `;` → báo lỗi.\n * Dùng vị trí `node.end` của AST babel; bỏ qua dòng tainted (trailing dot) để không chồng lỗi.\n */\nexport const collectMissingSemicolonDiagnostics = (ast: object, code: string, diagnostics: Diagnostic[], taintedLines: Set<number>): void => {\n  const semiNodes = new Set(['ExpressionStatement', 'VariableDeclaration', 'ReturnStatement', 'ThrowStatement', 'BreakStatement', 'ContinueStatement', 'DoWhileStatement', 'DebuggerStatement']);\n  const seen = new Set<number>();\n  const lineOf = (offset: number) => code.slice(0, offset).split('\\n').length;\n  const walk = (node: unknown, parentType: string, keyInParent: string): void => {\n    if (Array.isArray(node)) {\n      for (const item of node) walk(item, parentType, keyInParent);\n      return;\n    }\n    if (!node || typeof node !== 'object') return;\n    const current = node as T_AstNode;\n    if (typeof current.type !== 'string') return;\n\n    if (semiNodes.has(current.type) && requiresSemicolon(current.type, parentType, keyInParent) && typeof current.end === 'number') {\n      const end = Math.min(current.end, code.length);\n      if (end > 0 && code.charAt(end - 1) !== ';' && !seen.has(end) && !taintedLines.has(lineOf(end - 1))) {\n        seen.add(end);\n        diagnostics.push({ from: end - 1, to: end, severity: 'error', message: 'Missing semicolon' });\n      }\n    }\n\n    for (const childKey of Object.keys(current)) {\n      if (astSkipKeys.has(childKey)) continue;\n      walk(current[childKey], current.type, childKey);\n    }\n  };\n  walk((ast as { program?: unknown }).program ?? ast, '', '');\n};\n\n/** Chuẩn hóa message: thân thiện cho trailing dot + heuristic kiểu cũ cho \"Unexpected token\"; bỏ hậu tố \"(line:col)\". */\nexport const buildJsErrorMessage = (doc: Text, from: number, rawMessage: string): string => {\n  const charBefore = from > 0 ? doc.sliceString(from - 1, from) : '';\n  if (charBefore === '.') {\n    const owner = getTokenBefore(doc, from).replace(/\\.$/, '');\n    return owner ? `Incomplete property access on \"${owner}\"` : 'Incomplete property access';\n  }\n\n  const cleaned = rawMessage.replace(/\\s*\\(\\d+:\\d+\\)\\s*$/, '').trim();\n  if (/missing semicolon/i.test(cleaned)) {\n    return 'Unexpected token — missing operator or separator between expressions';\n  }\n  if (/^unexpected token$/i.test(cleaned)) {\n    const prevToken = getTokenBefore(doc, from);\n    if (prevToken.endsWith('(')) return 'Missing closing \")\"';\n    if (prevToken.endsWith('[')) return 'Missing closing \"]\"';\n    if (/^function$/i.test(prevToken)) return 'Expected function name or \"(\"';\n    if (/^return$/i.test(prevToken)) return 'Invalid expression after \"return\"';\n    if (/^=>$/.test(prevToken)) return 'Expected function body after \"=>\"';\n    if (/^const$|^let$|^var$/i.test(prevToken)) return 'Expected variable name';\n  }\n  return `JavaScript syntax error: ${cleaned}`;\n};\n\n/** Lấy tên binding từ pattern (Identifier, destructuring object/array, default, rest). */\nconst collectPatternNames = (node: T_AstNode | null | undefined, declared: Set<string>): void => {\n  if (!node || typeof node.type !== 'string') return;\n  switch (node.type) {\n    case 'Identifier':\n      if (node.name) declared.add(node.name);\n      return;\n    case 'ObjectPattern':\n      if (node.properties) for (const property of node.properties) collectPatternNames(property.type === 'RestElement' ? property.argument : property.value, declared);\n      return;\n    case 'ArrayPattern':\n      if (node.elements) for (const element of node.elements) collectPatternNames(element, declared);\n      return;\n    case 'AssignmentPattern':\n      collectPatternNames(node.left, declared);\n      return;\n    case 'RestElement':\n      collectPatternNames(node.argument, declared);\n      return;\n    case 'TSParameterProperty':\n      collectPatternNames(node.parameter, declared);\n      return;\n    default:\n      return;\n  }\n};\n\n/** Thu thập tên binding (biến/hàm/class/param/import/enum...) từ 1 node vào tập `declared`. */\nconst collectBindingNames = (node: T_AstNode, declared: Set<string>): void => {\n  switch (node.type) {\n    case 'VariableDeclarator':\n      collectPatternNames(node.id, declared);\n      return;\n    case 'FunctionDeclaration':\n    case 'FunctionExpression':\n    case 'ClassDeclaration':\n    case 'ClassExpression':\n      if (node.id?.name) declared.add(node.id.name);\n      if (node.params) for (const param of node.params) collectPatternNames(param, declared);\n      return;\n    case 'ArrowFunctionExpression':\n      if (node.params) for (const param of node.params) collectPatternNames(param, declared);\n      return;\n    case 'CatchClause':\n      collectPatternNames(node.param, declared);\n      return;\n    case 'ImportDefaultSpecifier':\n    case 'ImportNamespaceSpecifier':\n    case 'ImportSpecifier':\n      if (node.local?.name) declared.add(node.local.name);\n      return;\n    case 'TSEnumDeclaration':\n    case 'TSModuleDeclaration':\n      if (node.id?.name) declared.add(node.id.name);\n      return;\n    default:\n      return;\n  }\n};\n\n/** Xác định 1 Identifier có phải tham chiếu giá trị không (loại property access, key object, declaration id, label...). */\nconst isReferenceIdentifier = (parent: T_AstNode | null, keyInParent: string): boolean => {\n  if (!parent) return true;\n  const parentType = parent.type;\n  if ((parentType === 'MemberExpression' || parentType === 'OptionalMemberExpression') && keyInParent === 'property' && !parent.computed) return false;\n  if ((parentType === 'ObjectProperty' || parentType === 'ObjectMethod' || parentType === 'ClassMethod' || parentType === 'ClassProperty' || parentType === 'ClassPrivateProperty' || parentType === 'PropertyDefinition') && keyInParent === 'key' && !parent.computed) return false;\n  if (keyInParent === 'label') return false;\n  if (parentType === 'TSQualifiedName' && keyInParent === 'right') return false;\n  if (parentType === 'VariableDeclarator' && keyInParent === 'id') return false;\n  if ((parentType === 'FunctionDeclaration' || parentType === 'FunctionExpression' || parentType === 'ClassDeclaration' || parentType === 'ClassExpression') && keyInParent === 'id') return false;\n  if (parentType === 'ImportSpecifier' || parentType === 'ImportDefaultSpecifier' || parentType === 'ImportNamespaceSpecifier' || parentType === 'ExportSpecifier') return false;\n  if (parentType === 'MetaProperty') return false;\n  if (parentType === 'TSEnumMember' && keyInParent === 'id') return false;\n  return true;\n};\n\n/** Duyệt đệ quy AST: gom binding name vào `declared`, gom identifier tham chiếu vào `references`. */\nconst walkAstNode = (node: unknown, parent: T_AstNode | null, keyInParent: string, inType: boolean, declared: Set<string>, references: T_AstReference[]): void => {\n  if (Array.isArray(node)) {\n    for (const item of node) walkAstNode(item, parent, keyInParent, inType, declared, references);\n    return;\n  }\n  if (!node || typeof node !== 'object') return;\n  const current = node as T_AstNode;\n  if (typeof current.type !== 'string') return;\n\n  collectBindingNames(current, declared);\n\n  if (current.type === 'Identifier' && !inType && isReferenceIdentifier(parent, keyInParent)) {\n    const start = current.loc?.start;\n    if (current.name && start) references.push({ name: current.name, line: start.line, column: start.column });\n  }\n\n  const opensType = inType || (current.type.startsWith('TS') && !tsValueNodes.has(current.type));\n  for (const childKey of Object.keys(current)) {\n    if (astSkipKeys.has(childKey)) continue;\n    const child = current[childKey];\n    const childOpensType = typeof child === 'object' && child !== null && typeof (child as T_AstNode).type === 'string' && (child as T_AstNode).type.startsWith('TS') && !tsValueNodes.has((child as T_AstNode).type);\n    const childInType = opensType || astTypeKeys.has(childKey) || childOpensType;\n    walkAstNode(child, current, childKey, childInType, declared, references);\n  }\n};\n\n/**\n * Pass ngữ nghĩa: báo biến CHƯA KHAI BÁO. Tự duyệt AST (object thuần) — KHÔNG dùng `@babel/traverse`\n * (cần `process` của Node → crash browser). Hợp lệ = binding trong code + global JS/DOM + `completionLabels`.\n */\nexport const collectUndeclaredIdentifiers = async (ast: object, doc: Text, completionLabels: Set<string>, taintedLines: Set<number> = new Set()): Promise<Diagnostic[]> => {\n  const globalsSet = await getKnownGlobals();\n  const declared = new Set<string>();\n  const references: T_AstReference[] = [];\n\n  walkAstNode(ast as T_AstNode, null, '', false, declared, references);\n\n  const diagnostics: Diagnostic[] = [];\n  const seen = new Set<string>();\n  for (const reference of references) {\n    const { name, line: startLine, column: startColumn } = reference;\n    if (declared.has(name) || globalsSet.has(name) || completionLabels.has(name)) continue;\n    if (taintedLines.has(startLine)) continue;\n\n    const dedupeKey = `${startLine}:${startColumn}:${name}`;\n    if (seen.has(dedupeKey)) continue;\n    seen.add(dedupeKey);\n\n    const line = doc.line(Math.min(Math.max(startLine, 1), doc.lines));\n    const from = Math.min(line.from + Math.max(startColumn, 0), doc.length);\n    const to = Math.min(from + name.length, doc.length);\n    diagnostics.push({ from, to: Math.max(from + 1, to), severity: 'error', message: `\"${name}\" is not defined` });\n  }\n  return diagnostics;\n};\n\n/**\n * Toàn bộ pipeline validate JS/TS:\n * - Pass 1: trailing dot (text) — flag đúng vị trí dấu `.` cuối dòng + đánh dấu dòng tainted.\n * - Pass 2: lỗi cú pháp babel — bỏ lỗi trên dòng tainted (cascading).\n * - Pass 3: rule cần AST (thiếu `;`, biến chưa khai báo). Trailing dot được \"vá\" (`.`→space) để babel\n *   vẫn parse được phần còn lại → rule vẫn chạy cho các dòng KHÁC.\n */\nexport const computeJsDiagnostics = async (doc: Text, code: string, completionLabels: Set<string>): Promise<Diagnostic[]> => {\n  const diagnostics: Diagnostic[] = [];\n  if (code.trim() === '') {\n    return diagnostics;\n  }\n\n  const taintedLines = new Set<number>();\n  const dotPositions: number[] = [];\n  collectTrailingDotDiagnostics(doc, diagnostics, taintedLines, dotPositions);\n\n  const parseCode = replaceCharsWithSpace(code, dotPositions);\n  const parser = await getBabelParser();\n  const { errors, ast } = parseJs(parser, parseCode);\n  const seen = new Set<string>();\n  for (const error of errors) {\n    const location = error.loc;\n    if (!location) continue;\n    const lineNumber = Math.min(Math.max(location.line, 1), doc.lines);\n    if (taintedLines.has(lineNumber)) continue;\n    const line = doc.line(lineNumber);\n    const errorPos = Math.min(line.from + Math.max(location.column, 0), doc.length);\n    const to = Math.min(errorPos + 1, doc.length);\n    const from = errorPos >= to && errorPos > 0 ? errorPos - 1 : errorPos;\n    const message = buildJsErrorMessage(doc, errorPos, error.message);\n    const dedupeKey = `${from}:${message}`;\n    if (seen.has(dedupeKey)) continue;\n    seen.add(dedupeKey);\n    diagnostics.push({ from, to: Math.max(from + 1, to), severity: 'error', message });\n  }\n\n  if (errors.length === 0 && ast) {\n    collectMissingSemicolonDiagnostics(ast, code, diagnostics, taintedLines);\n    diagnostics.push(...(await collectUndeclaredIdentifiers(ast, doc, completionLabels, taintedLines)));\n  }\n\n  return diagnostics;\n};\n"]}

package/esm2022/linters/json-linter.mjs

@@ -0,0 +1,14 @@
+import { get } from '@libs-ui/utils';
+/** Validate JSON bằng `JSON.parse`. Lỗi → 1 diagnostic phủ toàn bộ nội dung. */
+export const computeJsonDiagnostics = (view) => {
+    const text = view.state.doc.toString();
+    const diagnostics = [];
+    try {
+        JSON.parse(text);
+    }
+    catch (error) {
+        diagnostics.push({ from: 0, to: text.length, severity: 'error', message: get(error, 'message', '') });
+    }
+    return diagnostics;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNvbi1saW50ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzLXVpL2NvbXBvbmVudHMvcHJldmlldy10ZXh0LWRhdGEvc3JjL2xpbnRlcnMvanNvbi1saW50ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRXJDLGdGQUFnRjtBQUNoRixNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxDQUFDLElBQWdCLEVBQWdCLEVBQUU7SUFDdkUsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDdkMsTUFBTSxXQUFXLEdBQWlCLEVBQUUsQ0FBQztJQUNyQyxJQUFJLENBQUM7UUFDSCxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ25CLENBQUM7SUFBQyxPQUFPLEtBQWMsRUFBRSxDQUFDO1FBQ3hCLFdBQVcsQ0FBQyxJQUFJLENBQUMsRUFBRSxJQUFJLEVBQUUsQ0FBQyxFQUFFLEVBQUUsRUFBRSxJQUFJLENBQUMsTUFBTSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLEdBQUcsQ0FBQyxLQUFLLEVBQUUsU0FBUyxFQUFFLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUN4RyxDQUFDO0lBQ0QsT0FBTyxXQUFXLENBQUM7QUFDckIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlhZ25vc3RpYyB9IGZyb20gJ0Bjb2RlbWlycm9yL2xpbnQnO1xuaW1wb3J0IHsgRWRpdG9yVmlldyB9IGZyb20gJ0Bjb2RlbWlycm9yL3ZpZXcnO1xuaW1wb3J0IHsgZ2V0IH0gZnJvbSAnQGxpYnMtdWkvdXRpbHMnO1xuXG4vKiogVmFsaWRhdGUgSlNPTiBi4bqxbmcgYEpTT04ucGFyc2VgLiBM4buXaSDihpIgMSBkaWFnbm9zdGljIHBo4bunIHRvw6BuIGLhu5kgbuG7mWkgZHVuZy4gKi9cbmV4cG9ydCBjb25zdCBjb21wdXRlSnNvbkRpYWdub3N0aWNzID0gKHZpZXc6IEVkaXRvclZpZXcpOiBEaWFnbm9zdGljW10gPT4ge1xuICBjb25zdCB0ZXh0ID0gdmlldy5zdGF0ZS5kb2MudG9TdHJpbmcoKTtcbiAgY29uc3QgZGlhZ25vc3RpY3M6IERpYWdub3N0aWNbXSA9IFtdO1xuICB0cnkge1xuICAgIEpTT04ucGFyc2UodGV4dCk7XG4gIH0gY2F0Y2ggKGVycm9yOiB1bmtub3duKSB7XG4gICAgZGlhZ25vc3RpY3MucHVzaCh7IGZyb206IDAsIHRvOiB0ZXh0Lmxlbmd0aCwgc2V2ZXJpdHk6ICdlcnJvcicsIG1lc3NhZ2U6IGdldChlcnJvciwgJ21lc3NhZ2UnLCAnJykgfSk7XG4gIH1cbiAgcmV0dXJuIGRpYWdub3N0aWNzO1xufTtcbiJdfQ==