zcw-shared 1.32.0 → 1.32.2

package/dist/functions/platform/uniapp/detectProjectType.js

@@ -0,0 +1,68 @@
+export var UniAppProjectType;
+(function (UniAppProjectType) {
+    UniAppProjectType["HBUILDERX"] = "hbuilderx";
+    UniAppProjectType["CLI"] = "cli";
+})(UniAppProjectType || (UniAppProjectType = {}));
+export function isHBuilderXProject(projectPath, deps) {
+    const hbuilderxPath = `${projectPath}/.hbuilderx`;
+    const uniModulesPath = `${projectPath}/uni_modules`;
+    return deps.existsSync(hbuilderxPath) || deps.existsSync(uniModulesPath);
+}
+export function isCLIProject(projectPath, deps) {
+    const packagePath = `${projectPath}/package.json`;
+    const nodeModulesPath = `${projectPath}/node_modules`;
+    const vueConfigPath = `${projectPath}/vue.config.js`;
+    const viteConfigPath = `${projectPath}/vite.config.js`;
+    const hasPackageJson = deps.existsSync(packagePath);
+    const hasNodeModules = deps.existsSync(nodeModulesPath);
+    const hasVueConfig = deps.existsSync(vueConfigPath);
+    const hasViteConfig = deps.existsSync(viteConfigPath);
+    return hasPackageJson && (hasNodeModules || hasVueConfig || hasViteConfig);
+}
+export function detectUniAppProjectType(projectPath, deps) {
+    if (isHBuilderXProject(projectPath, deps)) {
+        return UniAppProjectType.HBUILDERX;
+    }
+    if (isCLIProject(projectPath, deps)) {
+        return UniAppProjectType.CLI;
+    }
+    return UniAppProjectType.CLI;
+}
+export function detectProjectType(projectPath, deps) {
+    try {
+        const manifestSrcPath = deps.join(projectPath, 'src', 'manifest.json');
+        const manifestRootPath = deps.join(projectPath, 'manifest.json');
+        const hasManifest = deps.existsSync(manifestSrcPath) || deps.existsSync(manifestRootPath);
+        if (!hasManifest) {
+            return {
+                isUniApp: false,
+                error: '未找到 manifest.json 文件，不是 UniApp 项目'
+            };
+        }
+        const pagesSrcPath = deps.join(projectPath, 'src', 'pages.json');
+        const pagesRootPath = deps.join(projectPath, 'pages.json');
+        const hasPages = deps.existsSync(pagesSrcPath) || deps.existsSync(pagesRootPath);
+        if (!hasPages) {
+            return {
+                isUniApp: false,
+                error: '未找到 pages.json 文件，不是 UniApp 项目'
+            };
+        }
+        const projectType = detectUniAppProjectType(projectPath, deps);
+        const manifestPath = deps.existsSync(manifestSrcPath) ? manifestSrcPath : manifestRootPath;
+        const pagesPath = deps.existsSync(pagesSrcPath) ? pagesSrcPath : pagesRootPath;
+        return {
+            isUniApp: true,
+            projectType,
+            manifestPath,
+            pagesPath
+        };
+    }
+    catch (error) {
+        return {
+            isUniApp: false,
+            error: `检测项目类型时发生错误: ${error instanceof Error ? error.message : String(error)}`
+        };
+    }
+}
+//# sourceMappingURL=detectProjectType.js.map

package/dist/functions/platform/uniapp/detectProjectType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detectProjectType.js","sourceRoot":"","sources":["../../../../src/functions/platform/uniapp/detectProjectType.ts"],"names":[],"mappings":"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"}

package/dist/functions/platform/uniapp/parseManifest.d.ts

@@ -0,0 +1,18 @@
+import type { FileSystem, Path } from '../../../references/node.d';
+import type { JSON5Parser } from '../../../references/json5.d';
+export interface ParseManifestDeps {
+    existsSync: FileSystem['existsSync'];
+    readFileSync: FileSystem['readFileSync'];
+    join: Path['join'];
+    parse: JSON5Parser['parse'];
+}
+export interface UniAppManifest {
+    appid: string;
+    name: string;
+    description?: string;
+}
+export declare function parseManifest(projectPath: string, deps: ParseManifestDeps): {
+    success: boolean;
+    manifest?: UniAppManifest;
+    error?: string;
+};

package/dist/functions/platform/uniapp/parseManifest.js

@@ -0,0 +1,49 @@
+import { detectProjectType } from './detectProjectType';
+export function parseManifest(projectPath, deps) {
+    const typeResult = detectProjectType(projectPath, {
+        existsSync: deps.existsSync,
+        join: deps.join
+    });
+    if (!typeResult.isUniApp) {
+        return { success: false, error: typeResult.error || '不是 UniApp 项目' };
+    }
+    if (!typeResult.manifestPath) {
+        return { success: false, error: '无法确定 manifest.json 路径' };
+    }
+    let manifest;
+    try {
+        const manifestContent = deps.readFileSync(typeResult.manifestPath, 'utf8');
+        manifest = deps.parse(manifestContent);
+    }
+    catch (error) {
+        return { success: false, error: `解析 manifest.json 失败: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    if (!manifest.appid) {
+        return { success: false, error: '未配置 appid，请在 manifest.json 中配置 appid 字段' };
+    }
+    if (typeof manifest.appid !== 'string' || manifest.appid.trim() === '') {
+        return { success: false, error: 'appid 不能为空，请在 manifest.json 中正确配置' };
+    }
+    if (!manifest.name) {
+        return { success: false, error: '未配置应用名称，请在 manifest.json 中配置 name 字段' };
+    }
+    if (typeof manifest.name !== 'string' || manifest.name.trim() === '') {
+        return { success: false, error: '应用名称不能为空，请在 manifest.json 中正确配置' };
+    }
+    const uniappIdPattern = /^__UNI__[A-F0-9]+$/;
+    if (!uniappIdPattern.test(manifest.appid)) {
+        return {
+            success: false,
+            error: `应用 ID 格式不正确: ${manifest.appid}。请使用 UniApp appid 格式（如 __UNI__7AE6056）`
+        };
+    }
+    return {
+        success: true,
+        manifest: {
+            appid: manifest.appid,
+            name: manifest.name,
+            description: manifest.description
+        }
+    };
+}
+//# sourceMappingURL=parseManifest.js.map

package/dist/functions/platform/uniapp/parseManifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseManifest.js","sourceRoot":"","sources":["../../../../src/functions/platform/uniapp/parseManifest.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AA+BvD,MAAM,UAAU,aAAa,CAC3B,WAAmB,EACnB,IAAuB;IAGvB,MAAM,UAAU,GAAG,iBAAiB,CAAC,WAAW,EAAE;QAChD,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,IAAI,EAAE,IAAI,CAAC,IAAI;KAChB,CAAC,CAAA;IAEF,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;QACzB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,IAAI,cAAc,EAAE,CAAA;IACtE,CAAC;IAED,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,CAAC;QAC7B,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,uBAAuB,EAAE,CAAA;IAC3D,CAAC;IAED,IAAI,QAAa,CAAA;IACjB,IAAI,CAAC;QACH,MAAM,eAAe,GAAG,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,YAAY,EAAE,MAAM,CAAC,CAAA;QAC1E,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAA;IACxC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,wBAAwB,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,CAAA;IACpH,CAAC;IAGD,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACpB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,yCAAyC,EAAE,CAAA;IAC7E,CAAC;IAED,IAAI,OAAO,QAAQ,CAAC,KAAK,KAAK,QAAQ,IAAI,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QACvE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,mCAAmC,EAAE,CAAA;IACvE,CAAC;IAGD,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACnB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,sCAAsC,EAAE,CAAA;IAC1E,CAAC;IAED,IAAI,OAAO,QAAQ,CAAC,IAAI,KAAK,QAAQ,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QACrE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,iCAAiC,EAAE,CAAA;IACrE,CAAC;IAGD,MAAM,eAAe,GAAG,oBAAoB,CAAA;IAE5C,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1C,OAAO;YACL,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,gBAAgB,QAAQ,CAAC,KAAK,wCAAwC;SAC9E,CAAA;IACH,CAAC;IAED,OAAO;QACL,OAAO,EAAE,IAAI;QACb,QAAQ,EAAE;YACR,KAAK,EAAE,QAAQ,CAAC,KAAK;YACrB,IAAI,EAAE,QAAQ,CAAC,IAAI;YACnB,WAAW,EAAE,QAAQ,CAAC,WAAW;SAClC;KACF,CAAA;AACH,CAAC"}

package/dist/functions/platform/uniapp/waitForPages.d.ts

@@ -0,0 +1,7 @@
+import type { UniApp } from '../../../references/uniapp.d';
+import type { setTimeout } from '../../../references/timer.d';
+export interface WaitForPagesDeps {
+    getCurrentPages: UniApp['getCurrentPages'];
+    setTimeout: typeof setTimeout;
+}
+export declare function waitForPages(deps: WaitForPagesDeps, timeout?: number): Promise<any[]>;

package/dist/functions/platform/uniapp/waitForPages.js

@@ -0,0 +1,20 @@
+export function waitForPages(deps, timeout = 5000) {
+    return new Promise((resolve, reject) => {
+        const startTime = Date.now();
+        const checkPages = () => {
+            const pages = deps.getCurrentPages();
+            if (pages.length > 0) {
+                resolve(pages);
+                return;
+            }
+            if (Date.now() - startTime > timeout) {
+                reject(new Error('等待页面栈超时'));
+                return;
+            }
+            deps.setTimeout(checkPages, 100);
+        };
+        checkPages();
+    });
+}
+;
+//# sourceMappingURL=waitForPages.js.map

package/dist/functions/platform/uniapp/waitForPages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"waitForPages.js","sourceRoot":"","sources":["../../../../src/functions/platform/uniapp/waitForPages.ts"],"names":[],"mappings":"AAwBA,MAAM,UAAU,YAAY,CAAC,IAAsB,EAAE,OAAO,GAAG,IAAI;IACjE,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAE7B,MAAM,UAAU,GAAG,GAAG,EAAE;YACtB,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;YAErC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACrB,OAAO,CAAC,KAAK,CAAC,CAAC;gBACf,OAAO;YACT,CAAC;YAGD,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,GAAG,OAAO,EAAE,CAAC;gBACrC,MAAM,CAAC,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;gBAC7B,OAAO;YACT,CAAC;YAGD,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;QACnC,CAAC,CAAC;QAEF,UAAU,EAAE,CAAC;IACf,CAAC,CAAC,CAAC;AACL,CAAC;AAAA,CAAC"}

package/dist/functions/string/visualizeRegexSteps.d.ts

@@ -0,0 +1,39 @@
+export interface RegexStep {
+    stepNumber: number;
+    textPosition: number;
+    regexPosition: number;
+    action: string;
+    status: 'matching' | 'matched' | 'failed' | 'backtrack';
+    matchedText: string;
+    captureGroups: CaptureGroupState[];
+    backtrackStack: BacktrackPoint[];
+    quantifierState?: QuantifierState;
+    explanation: string;
+}
+export interface CaptureGroupState {
+    index: number;
+    name?: string;
+    text: string;
+    completed: boolean;
+}
+export interface BacktrackPoint {
+    textPos: number;
+    regexPos: number;
+    description: string;
+}
+export interface QuantifierState {
+    symbol: string;
+    currentCount: number;
+    minCount: number;
+    maxCount: number;
+    greedy: boolean;
+}
+export interface RegexVisualization {
+    steps: RegexStep[];
+    finalMatch: {
+        success: boolean;
+        matchedText: string;
+        captureGroups: CaptureGroupState[];
+    };
+}
+export declare function visualizeRegexSteps(pattern: string, text: string, maxSteps?: number): RegexVisualization;

package/dist/functions/string/visualizeRegexSteps.js

@@ -0,0 +1,446 @@
+function parseSimpleRegex(pattern) {
+    const components = [];
+    let i = 0;
+    while (i < pattern.length) {
+        const char = pattern[i];
+        if (char === '\\' && i + 1 < pattern.length) {
+            components.push({
+                type: 'escape',
+                text: pattern.substring(i, i + 2),
+                value: pattern[i + 1]
+            });
+            i += 2;
+            continue;
+        }
+        if (['+', '*', '?'].includes(char)) {
+            const quantMap = {
+                '+': [1, Infinity],
+                '*': [0, Infinity],
+                '?': [0, 1]
+            };
+            const [min, max] = quantMap[char];
+            components.push({
+                type: 'quantifier',
+                text: char,
+                min,
+                max
+            });
+            i++;
+            continue;
+        }
+        if (char === '[') {
+            let j = i + 1;
+            while (j < pattern.length && pattern[j] !== ']') {
+                if (pattern[j] === '\\')
+                    j++;
+                j++;
+            }
+            components.push({
+                type: 'charset',
+                text: pattern.substring(i, j + 1)
+            });
+            i = j + 1;
+            continue;
+        }
+        if (char === '(') {
+            let depth = 1;
+            let j = i + 1;
+            while (j < pattern.length && depth > 0) {
+                if (pattern[j] === '\\') {
+                    j += 2;
+                    continue;
+                }
+                if (pattern[j] === '(')
+                    depth++;
+                if (pattern[j] === ')')
+                    depth--;
+                j++;
+            }
+            components.push({
+                type: 'group',
+                text: pattern.substring(i, j)
+            });
+            i = j;
+            continue;
+        }
+        if (char === '^' || char === '$') {
+            components.push({
+                type: 'anchor',
+                text: char
+            });
+            i++;
+            continue;
+        }
+        components.push({
+            type: 'literal',
+            text: char,
+            value: char
+        });
+        i++;
+    }
+    return components;
+}
+function matchEscape(escapeChar, textChar) {
+    const escapeMap = {
+        'd': (c) => /[0-9]/.test(c),
+        'D': (c) => /[^0-9]/.test(c),
+        'w': (c) => /[a-zA-Z0-9_]/.test(c),
+        'W': (c) => /[^a-zA-Z0-9_]/.test(c),
+        's': (c) => /\s/.test(c),
+        'S': (c) => /\S/.test(c)
+    };
+    return escapeMap[escapeChar]?.(textChar) || false;
+}
+function matchCharset(charset, textChar) {
+    const isNegated = charset[1] === '^';
+    const chars = charset.substring(isNegated ? 2 : 1, charset.length - 1);
+    let matches = false;
+    for (let i = 0; i < chars.length; i++) {
+        if (chars[i + 1] === '-' && i + 2 < chars.length) {
+            const start = chars.charCodeAt(i);
+            const end = chars.charCodeAt(i + 2);
+            const code = textChar.charCodeAt(0);
+            if (code >= start && code <= end) {
+                matches = true;
+                break;
+            }
+            i += 2;
+        }
+        else {
+            if (chars[i] === textChar) {
+                matches = true;
+                break;
+            }
+        }
+    }
+    return isNegated ? !matches : matches;
+}
+function tryMatchAt(components, text, startPos, steps, stepNumber) {
+    let textPos = startPos;
+    let regexPos = 0;
+    let matchedText = '';
+    const captureGroups = [];
+    const backtrackStack = [];
+    steps.push({
+        stepNumber: stepNumber++,
+        textPosition: textPos,
+        regexPosition: regexPos,
+        action: `尝试从位置 ${startPos} 开始匹配`,
+        status: 'matching',
+        matchedText: '',
+        captureGroups: [],
+        backtrackStack: [],
+        explanation: `将正则引擎定位到文本位置 ${startPos}，准备开始匹配`
+    });
+    while (regexPos < components.length && textPos < text.length) {
+        const component = components[regexPos];
+        const currentChar = text[textPos];
+        const nextComponent = components[regexPos + 1];
+        const hasQuantifier = nextComponent?.type === 'quantifier';
+        if (component.type === 'literal') {
+            steps.push({
+                stepNumber: stepNumber++,
+                textPosition: textPos,
+                regexPosition: regexPos,
+                action: `匹配字面字符 "${component.text}"`,
+                status: 'matching',
+                matchedText,
+                captureGroups: [...captureGroups],
+                backtrackStack: [...backtrackStack],
+                explanation: `检查文本位置 ${textPos} 的字符 "${currentChar}" 是否等于 "${component.text}"`
+            });
+            if (currentChar === component.value) {
+                matchedText += currentChar;
+                textPos++;
+                regexPos++;
+                steps.push({
+                    stepNumber: stepNumber++,
+                    textPosition: textPos,
+                    regexPosition: regexPos,
+                    action: '匹配成功',
+                    status: 'matched',
+                    matchedText,
+                    captureGroups: [...captureGroups],
+                    backtrackStack: [...backtrackStack],
+                    explanation: `字符 "${currentChar}" 匹配成功，继续向前`
+                });
+            }
+            else {
+                steps.push({
+                    stepNumber: stepNumber++,
+                    textPosition: textPos,
+                    regexPosition: regexPos,
+                    action: '匹配失败',
+                    status: 'failed',
+                    matchedText,
+                    captureGroups: [...captureGroups],
+                    backtrackStack: [...backtrackStack],
+                    explanation: `字符 "${currentChar}" 不匹配 "${component.text}"，匹配失败`
+                });
+                break;
+            }
+        }
+        else if (component.type === 'escape') {
+            steps.push({
+                stepNumber: stepNumber++,
+                textPosition: textPos,
+                regexPosition: regexPos,
+                action: `匹配转义字符 ${component.text}`,
+                status: 'matching',
+                matchedText,
+                captureGroups: [...captureGroups],
+                backtrackStack: [...backtrackStack],
+                explanation: `检查文本位置 ${textPos} 的字符 "${currentChar}" 是否符合 ${component.text} 的规则`
+            });
+            if (matchEscape(component.value, currentChar)) {
+                if (hasQuantifier) {
+                    const quantifier = nextComponent;
+                    const quantState = {
+                        symbol: quantifier.text,
+                        currentCount: 0,
+                        minCount: quantifier.min,
+                        maxCount: quantifier.max,
+                        greedy: true
+                    };
+                    steps.push({
+                        stepNumber: stepNumber++,
+                        textPosition: textPos,
+                        regexPosition: regexPos,
+                        action: `进入量词 ${quantifier.text}`,
+                        status: 'matching',
+                        matchedText,
+                        captureGroups: [...captureGroups],
+                        backtrackStack: [...backtrackStack],
+                        quantifierState: quantState,
+                        explanation: `检测到量词 ${quantifier.text}，要求匹配 ${quantifier.min} 到 ${quantifier.max === Infinity ? '∞' : quantifier.max} 次`
+                    });
+                    let count = 0;
+                    let tempPos = textPos;
+                    while (count < quantifier.max && tempPos < text.length) {
+                        const nextChar = text[tempPos];
+                        if (matchEscape(component.value, nextChar)) {
+                            matchedText += nextChar;
+                            count++;
+                            tempPos++;
+                            quantState.currentCount = count;
+                            steps.push({
+                                stepNumber: stepNumber++,
+                                textPosition: tempPos,
+                                regexPosition: regexPos,
+                                action: `量词匹配（第 ${count} 次）`,
+                                status: 'matched',
+                                matchedText,
+                                captureGroups: [...captureGroups],
+                                backtrackStack: [...backtrackStack],
+                                quantifierState: { ...quantState },
+                                explanation: `字符 "${nextChar}" 匹配成功，已匹配 ${count} 次`
+                            });
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    if (count >= quantifier.min) {
+                        textPos = tempPos;
+                        regexPos += 2;
+                        steps.push({
+                            stepNumber: stepNumber++,
+                            textPosition: textPos,
+                            regexPosition: regexPos,
+                            action: '✓ 量词匹配完成',
+                            status: 'matched',
+                            matchedText,
+                            captureGroups: [...captureGroups],
+                            backtrackStack: [...backtrackStack],
+                            quantifierState: { ...quantState },
+                            explanation: `量词 ${quantifier.text} 成功匹配 ${count} 次，满足要求 [${quantifier.min}, ${quantifier.max === Infinity ? '∞' : quantifier.max}]`
+                        });
+                    }
+                    else {
+                        steps.push({
+                            stepNumber: stepNumber++,
+                            textPosition: textPos,
+                            regexPosition: regexPos,
+                            action: '✗ 量词不满足',
+                            status: 'failed',
+                            matchedText,
+                            captureGroups: [...captureGroups],
+                            backtrackStack: [...backtrackStack],
+                            quantifierState: { ...quantState },
+                            explanation: `量词 ${quantifier.text} 只匹配 ${count} 次，不满足最小要求 ${quantifier.min}`
+                        });
+                        break;
+                    }
+                }
+                else {
+                    matchedText += currentChar;
+                    textPos++;
+                    regexPos++;
+                    steps.push({
+                        stepNumber: stepNumber++,
+                        textPosition: textPos,
+                        regexPosition: regexPos,
+                        action: '✓ 匹配成功',
+                        status: 'matched',
+                        matchedText,
+                        captureGroups: [...captureGroups],
+                        backtrackStack: [...backtrackStack],
+                        explanation: `字符 "${currentChar}" 符合 ${component.text} 规则`
+                    });
+                }
+            }
+            else {
+                steps.push({
+                    stepNumber: stepNumber++,
+                    textPosition: textPos,
+                    regexPosition: regexPos,
+                    action: '匹配失败',
+                    status: 'failed',
+                    matchedText,
+                    captureGroups: [...captureGroups],
+                    backtrackStack: [...backtrackStack],
+                    explanation: `字符 "${currentChar}" 不符合 ${component.text} 规则，匹配失败`
+                });
+                break;
+            }
+        }
+        else if (component.type === 'charset') {
+            steps.push({
+                stepNumber: stepNumber++,
+                textPosition: textPos,
+                regexPosition: regexPos,
+                action: `匹配字符集 ${component.text}`,
+                status: 'matching',
+                matchedText,
+                captureGroups: [...captureGroups],
+                backtrackStack: [...backtrackStack],
+                explanation: `检查字符 "${currentChar}" 是否在字符集 ${component.text} 中`
+            });
+            if (matchCharset(component.text, currentChar)) {
+                matchedText += currentChar;
+                textPos++;
+                regexPos++;
+                steps.push({
+                    stepNumber: stepNumber++,
+                    textPosition: textPos,
+                    regexPosition: regexPos,
+                    action: '匹配成功',
+                    status: 'matched',
+                    matchedText,
+                    captureGroups: [...captureGroups],
+                    backtrackStack: [...backtrackStack],
+                    explanation: `字符 "${currentChar}" 在字符集中，匹配成功`
+                });
+            }
+            else {
+                steps.push({
+                    stepNumber: stepNumber++,
+                    textPosition: textPos,
+                    regexPosition: regexPos,
+                    action: '匹配失败',
+                    status: 'failed',
+                    matchedText,
+                    captureGroups: [...captureGroups],
+                    backtrackStack: [...backtrackStack],
+                    explanation: `字符 "${currentChar}" 不在字符集中，匹配失败`
+                });
+                break;
+            }
+        }
+        else {
+            regexPos++;
+        }
+    }
+    const success = regexPos >= components.length;
+    if (success) {
+        steps.push({
+            stepNumber: stepNumber++,
+            textPosition: textPos,
+            regexPosition: regexPos,
+            action: '✅ 匹配成功',
+            status: 'matched',
+            matchedText,
+            captureGroups: [],
+            backtrackStack: [],
+            explanation: `所有模式都已匹配成功！最终匹配结果："${matchedText}"`
+        });
+    }
+    else {
+        steps.push({
+            stepNumber: stepNumber++,
+            textPosition: textPos,
+            regexPosition: regexPos,
+            action: '❌ 本次尝试失败',
+            status: 'failed',
+            matchedText,
+            captureGroups: [],
+            backtrackStack: [],
+            explanation: `从位置 ${startPos} 开始的匹配尝试失败`
+        });
+    }
+    return { success, matchedText, steps, stepNumber };
+}
+export function visualizeRegexSteps(pattern, text, maxSteps = 200) {
+    const steps = [];
+    const components = parseSimpleRegex(pattern);
+    let stepNumber = 0;
+    steps.push({
+        stepNumber: stepNumber++,
+        textPosition: 0,
+        regexPosition: 0,
+        action: '🎬 开始正则匹配',
+        status: 'matching',
+        matchedText: '',
+        captureGroups: [],
+        backtrackStack: [],
+        explanation: `准备在文本中搜索模式 /${pattern}/，文本内容："${text}"`
+    });
+    for (let i = 0; i < text.length; i++) {
+        const result = tryMatchAt(components, text, i, steps, stepNumber);
+        stepNumber = result.stepNumber;
+        if (result.success) {
+            return {
+                steps,
+                finalMatch: {
+                    success: true,
+                    matchedText: result.matchedText,
+                    captureGroups: []
+                }
+            };
+        }
+        if (steps.length >= maxSteps) {
+            steps.push({
+                stepNumber: stepNumber++,
+                textPosition: i + 1,
+                regexPosition: 0,
+                action: '⏸ 步骤过多，暂停',
+                status: 'failed',
+                matchedText: '',
+                captureGroups: [],
+                backtrackStack: [],
+                explanation: `已生成 ${steps.length} 个步骤，为避免过长暂停执行`
+            });
+            break;
+        }
+    }
+    steps.push({
+        stepNumber: stepNumber++,
+        textPosition: text.length,
+        regexPosition: 0,
+        action: '❌ 匹配失败',
+        status: 'failed',
+        matchedText: '',
+        captureGroups: [],
+        backtrackStack: [],
+        explanation: `已扫描整个文本，未找到匹配项`
+    });
+    return {
+        steps,
+        finalMatch: {
+            success: false,
+            matchedText: '',
+            captureGroups: []
+        }
+    };
+}
+//# sourceMappingURL=visualizeRegexSteps.js.map