icopilot 2.2.0

package/dist/context/dep-context.js

@@ -0,0 +1,329 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const STATIC_IMPORT_RE = /\bimport\s+(?:type\s+)?(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
+const DYNAMIC_IMPORT_RE = /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+const REQUIRE_RE = /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+const RESOLVABLE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
+export class DependencyResolver {
+    cwd;
+    tsconfigPath;
+    importCache = new Map();
+    nearestTsConfigCache = new Map();
+    tsConfigCache = new Map();
+    constructor(options = {}) {
+        this.cwd = path.resolve(options.cwd ?? process.cwd());
+        this.tsconfigPath = options.tsconfigPath
+            ? path.resolve(this.cwd, options.tsconfigPath)
+            : undefined;
+    }
+    resolveImports(filePath) {
+        const resolvedFile = this.resolveInputFile(filePath);
+        if (!resolvedFile)
+            return [];
+        const cached = this.importCache.get(resolvedFile);
+        if (cached)
+            return [...cached];
+        const source = this.readFile(resolvedFile);
+        if (source === null) {
+            this.importCache.set(resolvedFile, []);
+            return [];
+        }
+        const imports = dedupe(extractImportSpecifiers(source)
+            .map((specifier) => this.resolveSpecifier(specifier, resolvedFile))
+            .filter((value) => Boolean(value)));
+        this.importCache.set(resolvedFile, imports);
+        return [...imports];
+    }
+    getRelatedFiles(filePath, depth = 1) {
+        if (depth < 1)
+            return [];
+        const entryFile = this.resolveInputFile(filePath);
+        if (!entryFile)
+            return [];
+        const seen = new Set([entryFile]);
+        const related = [];
+        const walk = (currentFile, remainingDepth) => {
+            if (remainingDepth < 1)
+                return;
+            for (const importedFile of this.resolveImports(currentFile)) {
+                if (seen.has(importedFile))
+                    continue;
+                seen.add(importedFile);
+                related.push(importedFile);
+                walk(importedFile, remainingDepth - 1);
+            }
+        };
+        walk(entryFile, depth);
+        return related;
+    }
+    buildDependencyGraph(entryFile) {
+        const rootFile = this.resolveInputFile(entryFile);
+        const nodes = new Map();
+        if (!rootFile)
+            return { nodes };
+        const visited = new Set();
+        const walk = (currentFile) => {
+            if (visited.has(currentFile))
+                return;
+            visited.add(currentFile);
+            const imports = this.resolveImports(currentFile);
+            nodes.set(currentFile, imports);
+            for (const importedFile of imports) {
+                walk(importedFile);
+            }
+        };
+        walk(rootFile);
+        return { nodes };
+    }
+    resolveInputFile(filePath) {
+        const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(this.cwd, filePath);
+        return this.resolveWithExtensions(absolutePath);
+    }
+    resolveSpecifier(specifier, importerFile) {
+        if (!specifier)
+            return null;
+        if (specifier.startsWith('.') || path.isAbsolute(specifier)) {
+            return this.resolveWithExtensions(path.resolve(path.dirname(importerFile), specifier));
+        }
+        const tsConfig = this.getTsConfigForFile(importerFile);
+        if (tsConfig) {
+            for (const [pattern, targets] of Object.entries(tsConfig.paths)) {
+                const match = matchPathAlias(specifier, pattern);
+                if (!match.matches)
+                    continue;
+                for (const target of targets) {
+                    const replaced = target.includes('*') ? target.replace('*', match.value) : target;
+                    const candidate = path.resolve(tsConfig.baseUrl ?? tsConfig.tsconfigDir, replaced);
+                    const resolved = this.resolveWithExtensions(candidate);
+                    if (resolved)
+                        return resolved;
+                }
+            }
+        }
+        return isNodeModulesSpecifier(specifier) ? null : this.resolveWithExtensions(specifier);
+    }
+    resolveWithExtensions(candidatePath) {
+        const normalizedPath = path.resolve(candidatePath);
+        if (normalizedPath.includes(`${path.sep}node_modules${path.sep}`))
+            return null;
+        const candidates = new Set();
+        const extension = path.extname(normalizedPath);
+        const basePath = extension ? normalizedPath.slice(0, -extension.length) : normalizedPath;
+        candidates.add(normalizedPath);
+        if (extension) {
+            for (const knownExtension of RESOLVABLE_EXTENSIONS) {
+                candidates.add(`${basePath}${knownExtension}`);
+            }
+        }
+        else {
+            for (const knownExtension of RESOLVABLE_EXTENSIONS) {
+                candidates.add(`${normalizedPath}${knownExtension}`);
+            }
+        }
+        for (const knownExtension of RESOLVABLE_EXTENSIONS) {
+            candidates.add(path.join(normalizedPath, `index${knownExtension}`));
+            if (extension) {
+                candidates.add(path.join(basePath, `index${knownExtension}`));
+            }
+        }
+        for (const candidate of candidates) {
+            try {
+                if (fs.statSync(candidate).isFile()) {
+                    return path.resolve(candidate);
+                }
+            }
+            catch {
+                // Ignore missing candidates.
+            }
+        }
+        return null;
+    }
+    getTsConfigForFile(filePath) {
+        const tsconfigPath = this.findNearestTsConfig(path.dirname(filePath));
+        if (!tsconfigPath)
+            return null;
+        return this.loadTsConfig(tsconfigPath);
+    }
+    findNearestTsConfig(startDir) {
+        if (this.tsconfigPath)
+            return fs.existsSync(this.tsconfigPath) ? this.tsconfigPath : null;
+        const normalizedStart = path.resolve(startDir);
+        const cached = this.nearestTsConfigCache.get(normalizedStart);
+        if (cached !== undefined)
+            return cached;
+        let currentDir = normalizedStart;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const candidate = path.join(currentDir, 'tsconfig.json');
+            if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+                this.nearestTsConfigCache.set(normalizedStart, candidate);
+                return candidate;
+            }
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir)
+                break;
+            currentDir = parentDir;
+        }
+        this.nearestTsConfigCache.set(normalizedStart, null);
+        return null;
+    }
+    loadTsConfig(tsconfigPath) {
+        const normalizedPath = path.resolve(tsconfigPath);
+        const cached = this.tsConfigCache.get(normalizedPath);
+        if (cached)
+            return cached;
+        const loaded = this.loadRawTsConfig(normalizedPath, new Set());
+        const compilerOptions = loaded.compilerOptions ?? {};
+        const options = {
+            baseUrl: compilerOptions.baseUrl
+                ? path.resolve(path.dirname(normalizedPath), compilerOptions.baseUrl)
+                : undefined,
+            paths: compilerOptions.paths ?? {},
+            tsconfigDir: path.dirname(normalizedPath),
+        };
+        this.tsConfigCache.set(normalizedPath, options);
+        return options;
+    }
+    loadRawTsConfig(tsconfigPath, visited) {
+        const normalizedPath = path.resolve(tsconfigPath);
+        if (visited.has(normalizedPath))
+            return {};
+        visited.add(normalizedPath);
+        const localConfig = parseJsoncFile(normalizedPath) ?? {};
+        const inheritedPath = resolveExtendsPath(localConfig.extends, normalizedPath);
+        if (!inheritedPath)
+            return localConfig;
+        const parentConfig = this.loadRawTsConfig(inheritedPath, visited);
+        return mergeTsConfigs(parentConfig, localConfig);
+    }
+    readFile(filePath) {
+        try {
+            return fs.readFileSync(filePath, 'utf8');
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function extractImportSpecifiers(source) {
+    const specifiers = [];
+    collectMatches(STATIC_IMPORT_RE, source, specifiers);
+    collectMatches(DYNAMIC_IMPORT_RE, source, specifiers);
+    collectMatches(REQUIRE_RE, source, specifiers);
+    return specifiers;
+}
+function collectMatches(pattern, source, output) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(source))) {
+        output.push(match[1]);
+    }
+}
+function dedupe(values) {
+    return [...new Set(values)];
+}
+function isNodeModulesSpecifier(specifier) {
+    return !specifier.startsWith('.') && !path.isAbsolute(specifier);
+}
+function matchPathAlias(specifier, pattern) {
+    if (!pattern.includes('*')) {
+        return { matches: specifier === pattern, value: '' };
+    }
+    const [prefix, suffix] = pattern.split('*');
+    if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix)) {
+        return { matches: false, value: '' };
+    }
+    return {
+        matches: true,
+        value: specifier.slice(prefix.length, specifier.length - suffix.length),
+    };
+}
+function parseJsoncFile(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, 'utf8');
+        return JSON.parse(stripTrailingCommas(stripJsonComments(raw)));
+    }
+    catch {
+        return null;
+    }
+}
+function stripJsonComments(input) {
+    let output = '';
+    let inString = false;
+    let stringDelimiter = '';
+    let escapeNext = false;
+    let i = 0;
+    while (i < input.length) {
+        const current = input[i];
+        const next = input[i + 1];
+        if (inString) {
+            output += current;
+            if (escapeNext) {
+                escapeNext = false;
+            }
+            else if (current === '\\') {
+                escapeNext = true;
+            }
+            else if (current === stringDelimiter) {
+                inString = false;
+                stringDelimiter = '';
+            }
+            i += 1;
+            continue;
+        }
+        if (current === '"' || current === "'") {
+            inString = true;
+            stringDelimiter = current;
+            output += current;
+            i += 1;
+            continue;
+        }
+        if (current === '/' && next === '/') {
+            while (i < input.length && input[i] !== '\n')
+                i += 1;
+            continue;
+        }
+        if (current === '/' && next === '*') {
+            i += 2;
+            while (i < input.length && !(input[i] === '*' && input[i + 1] === '/'))
+                i += 1;
+            i += 2;
+            continue;
+        }
+        output += current;
+        i += 1;
+    }
+    return output;
+}
+function stripTrailingCommas(input) {
+    return input.replace(/,\s*([}\]])/g, '$1');
+}
+function resolveExtendsPath(extendsValue, tsconfigPath) {
+    if (!extendsValue)
+        return null;
+    if (!extendsValue.startsWith('.') && !path.isAbsolute(extendsValue))
+        return null;
+    const candidate = path.isAbsolute(extendsValue)
+        ? extendsValue
+        : path.resolve(path.dirname(tsconfigPath), extendsValue);
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile())
+        return candidate;
+    const withJsonExtension = candidate.endsWith('.json') ? candidate : `${candidate}.json`;
+    if (fs.existsSync(withJsonExtension) && fs.statSync(withJsonExtension).isFile())
+        return withJsonExtension;
+    return null;
+}
+function mergeTsConfigs(baseConfig, overrideConfig) {
+    return {
+        ...baseConfig,
+        ...overrideConfig,
+        compilerOptions: {
+            ...(baseConfig.compilerOptions ?? {}),
+            ...(overrideConfig.compilerOptions ?? {}),
+            paths: {
+                ...(baseConfig.compilerOptions?.paths ?? {}),
+                ...(overrideConfig.compilerOptions?.paths ?? {}),
+            },
+        },
+    };
+}

package/dist/context/file-refs.js

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { config } from '../config.js';
+const FILE_REF_RE = /(^|\s)@([^\s@`'"<>]+)/g;
+const MAX_BYTES = 256 * 1024; // 256KB per file
+export function parseFileRefs(input) {
+    const out = [];
+    const seen = new Set();
+    let m;
+    FILE_REF_RE.lastIndex = 0;
+    while ((m = FILE_REF_RE.exec(input))) {
+        const rel = m[2];
+        if (seen.has(rel))
+            continue;
+        seen.add(rel);
+        const abs = path.resolve(config.cwd, rel);
+        const ref = { raw: `@${rel}`, rel, abs };
+        try {
+            const st = fs.statSync(abs);
+            if (!st.isFile()) {
+                ref.error = 'not a file';
+            }
+            else if (st.size > MAX_BYTES) {
+                ref.error = `file too large (${st.size} bytes; cap ${MAX_BYTES})`;
+                ref.content = fs.readFileSync(abs, 'utf8').slice(0, MAX_BYTES);
+            }
+            else {
+                ref.content = fs.readFileSync(abs, 'utf8');
+            }
+        }
+        catch (e) {
+            ref.error = e?.code || e?.message || 'read error';
+        }
+        out.push(ref);
+    }
+    return out;
+}
+/** Build a system-style context block from file refs. */
+export function renderFileRefBlock(refs) {
+    if (!refs.length)
+        return null;
+    const parts = ['### Referenced files'];
+    for (const r of refs) {
+        if (r.error && !r.content) {
+            parts.push(`\n#### ${r.rel}\n_[error: ${r.error}]_`);
+            continue;
+        }
+        const lang = path.extname(r.rel).replace(/^\./, '') || '';
+        parts.push(`\n#### ${r.rel}\n\`\`\`${lang}\n${r.content}\n\`\`\``);
+        if (r.error)
+            parts.push(`_[note: ${r.error}]_`);
+    }
+    return parts.join('\n');
+}

package/dist/context/git-context.js

@@ -0,0 +1,229 @@
+import { execSync } from 'node:child_process';
+import { config } from '../config.js';
+const DEFAULT_RECENT_COMMITS = 5;
+const DEFAULT_CONTEXT_LIMIT = 8;
+const MAX_DIFF_CHARS = 4_000;
+export class GitContextProvider {
+    cwd;
+    constructor(cwd = config.cwd) {
+        this.cwd = cwd;
+    }
+    async getRecentlyModified(options = {}) {
+        if (!this.isRepository())
+            return [];
+        const args = [
+            'log',
+            '--name-status',
+            '--format=format:',
+            `-n ${Math.max(1, options.commits ?? DEFAULT_RECENT_COMMITS)}`,
+        ];
+        if (options.since)
+            args.push(`--since=${quote(options.since)}`);
+        if (options.author)
+            args.push(`--author=${quote(options.author)}`);
+        if (options.paths?.length)
+            args.push(`-- ${options.paths.map(quote).join(' ')}`);
+        const output = this.runGit(args.join(' '));
+        return dedupeGitFiles(parseNameStatusOutput(output));
+    }
+    async getStagedFiles() {
+        return this.getDiffFiles('--cached');
+    }
+    async getUnstagedFiles() {
+        if (!this.isRepository())
+            return [];
+        const output = this.runGit('status --porcelain=v1');
+        const files = output
+            .split(/\r?\n/)
+            .map((line) => line.trimEnd())
+            .filter(Boolean)
+            .flatMap((line) => parsePorcelainLine(line, 'unstaged'));
+        return Promise.resolve(dedupeGitFiles(files.map((file) => ({
+            ...file,
+            diff: file.status === 'added' ? undefined : this.getFileDiff('', file.path),
+        }))));
+    }
+    async getBranchDiff(base) {
+        if (!this.isRepository())
+            return [];
+        const resolvedBase = base || this.detectBaseBranch();
+        const range = `${resolvedBase}...HEAD`;
+        const output = this.runGit(`diff --name-status ${quote(range)}`);
+        const files = parseNameStatusOutput(output).map((file) => ({
+            ...file,
+            diff: this.getFileDiff(quote(range), file.path),
+        }));
+        return dedupeGitFiles(files);
+    }
+    async getBlameContext(file, line) {
+        if (!this.isRepository()) {
+            throw new Error(`Not a git repository: ${this.cwd}`);
+        }
+        const safeLine = Math.max(1, Math.floor(line));
+        const output = this.runGit(`blame -L ${safeLine},${safeLine} --porcelain -- ${quote(file)}`);
+        return parseBlameOutput(output);
+    }
+    async getSessionContextFiles() {
+        if (!this.isRepository())
+            return [];
+        const [staged, unstaged, branchDiff] = await Promise.all([
+            this.getStagedFiles(),
+            this.getUnstagedFiles(),
+            this.getBranchDiff().catch(() => []),
+        ]);
+        const merged = dedupeGitFiles([...staged, ...unstaged, ...branchDiff]).slice(0, DEFAULT_CONTEXT_LIMIT);
+        if (merged.length > 0)
+            return merged;
+        return (await this.getRecentlyModified({ commits: 3 })).slice(0, DEFAULT_CONTEXT_LIMIT);
+    }
+    async getDiffFiles(diffMode) {
+        if (!this.isRepository())
+            return [];
+        const output = this.runGit(`diff ${diffMode} --name-status`.trim());
+        const files = parseNameStatusOutput(output).map((file) => ({
+            ...file,
+            diff: this.getFileDiff(diffMode, file.path),
+        }));
+        return dedupeGitFiles(files);
+    }
+    getFileDiff(diffMode, filePath) {
+        try {
+            const output = this.runGit(`diff ${diffMode} -- ${quote(filePath)}`.trim());
+            return output.trim() ? output.trim() : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    detectBaseBranch() {
+        try {
+            const remoteHead = this.runGit('symbolic-ref refs/remotes/origin/HEAD').trim();
+            const match = remoteHead.match(/refs\/remotes\/origin\/(.+)/);
+            if (match?.[1])
+                return match[1].trim();
+        }
+        catch {
+            /* fall through */
+        }
+        for (const branch of ['main', 'master', 'develop']) {
+            try {
+                this.runGit(`rev-parse --verify ${quote(branch)}`);
+                return branch;
+            }
+            catch {
+                /* keep trying */
+            }
+        }
+        return 'HEAD~1';
+    }
+    isRepository() {
+        try {
+            return this.runGit('rev-parse --is-inside-work-tree').trim() === 'true';
+        }
+        catch {
+            return false;
+        }
+    }
+    runGit(args) {
+        return execSync(`git ${args}`, {
+            cwd: this.cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+}
+export function renderGitContextBlock(files) {
+    if (!files.length)
+        return '';
+    const parts = ['### Git context', '', 'Recently modified files to keep in mind:'];
+    for (const file of files) {
+        parts.push(`- ${file.status}: ${file.path}`);
+        if (file.diff?.trim()) {
+            parts.push('');
+            parts.push('```diff');
+            parts.push(truncateDiff(file.diff.trim()));
+            parts.push('```');
+            parts.push('');
+        }
+    }
+    return parts.join('\n').trim();
+}
+function truncateDiff(diff) {
+    return diff.length > MAX_DIFF_CHARS ? `${diff.slice(0, MAX_DIFF_CHARS)}\n... [truncated]` : diff;
+}
+function parseNameStatusOutput(output) {
+    return output
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .flatMap((line) => {
+        const parts = line.split('\t').filter(Boolean);
+        if (parts.length < 2)
+            return [];
+        const [rawStatus, ...rawPaths] = parts;
+        const targetPath = rawPaths.at(-1);
+        if (!targetPath)
+            return [];
+        return [{ path: targetPath, status: normalizeStatus(rawStatus) }];
+    });
+}
+function parsePorcelainLine(line, mode) {
+    const indexStatus = line[0] ?? ' ';
+    const workTreeStatus = line[1] ?? ' ';
+    const rawPath = line.slice(3).trim();
+    const filePath = rawPath.includes(' -> ') ? rawPath.split(' -> ').at(-1)?.trim() : rawPath;
+    if (!filePath)
+        return [];
+    if (line.startsWith('??')) {
+        return [{ path: filePath, status: 'added' }];
+    }
+    if (mode === 'unstaged' && workTreeStatus !== ' ') {
+        return [{ path: filePath, status: normalizeStatus(workTreeStatus) }];
+    }
+    if (mode === 'unstaged' && indexStatus === 'U') {
+        return [{ path: filePath, status: 'modified' }];
+    }
+    return [];
+}
+function normalizeStatus(status) {
+    const normalized = status.trim().charAt(0);
+    if (normalized === 'A' || normalized === '?')
+        return 'added';
+    if (normalized === 'D')
+        return 'deleted';
+    return 'modified';
+}
+function parseBlameOutput(output) {
+    const lines = output.split(/\r?\n/);
+    const commit = lines[0]?.split(' ')[0]?.trim();
+    const author = extractBlameField(lines, 'author') || 'Unknown';
+    const message = extractBlameField(lines, 'summary') || '';
+    const authorTime = Number(extractBlameField(lines, 'author-time') || '0');
+    return {
+        author,
+        date: authorTime > 0 ? new Date(authorTime * 1000).toISOString() : '',
+        commit: commit || '',
+        message,
+    };
+}
+function extractBlameField(lines, field) {
+    const prefix = `${field} `;
+    return lines
+        .find((line) => line.startsWith(prefix))
+        ?.slice(prefix.length)
+        .trim();
+}
+function dedupeGitFiles(files) {
+    const seen = new Set();
+    const result = [];
+    for (const file of files) {
+        if (seen.has(file.path))
+            continue;
+        seen.add(file.path);
+        result.push(file);
+    }
+    return result;
+}
+function quote(value) {
+    return JSON.stringify(value);
+}

package/dist/context/image-input.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const IMAGE_EXTENSION_PATTERN = /\.(png|jpe?g|gif|webp|svg)$/i;
+const IMAGE_PATH_PATTERN = /"([^"\r\n]+\.(?:png|jpe?g|gif|webp|svg))"|'([^'\r\n]+\.(?:png|jpe?g|gif|webp|svg))'|((?:[A-Za-z]:[\\/]|\.{1,2}[\\/]|~[\\/]|\/)?[^\s"'`<>]+\.(?:png|jpe?g|gif|webp|svg))/gi;
+const MIME_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+};
+const VISION_MODEL_PATTERNS = [
+    /^gpt-4o(?:$|-)/i,
+    /^gpt-4\.1(?:$|-)/i,
+    /^gpt-4-turbo(?:$|-)/i,
+    /^gpt-4-vision(?:$|-)/i,
+    /^o4(?:$|-)/i,
+    /^claude-(?:3|3\.5|3\.7|sonnet-4|opus-4|haiku-4)/i,
+    /^gemini/i,
+];
+export function detectImagePaths(message) {
+    const paths = [];
+    const seen = new Set();
+    for (const match of message.matchAll(IMAGE_PATH_PATTERN)) {
+        const candidate = normalizeDetectedPath(match[1] ?? match[2] ?? match[3] ?? '');
+        if (!candidate)
+            continue;
+        const key = candidate.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        paths.push(candidate);
+    }
+    return paths;
+}
+export function encodeImageToBase64(filePath) {
+    const resolvedPath = path.resolve(filePath);
+    const extension = path.extname(resolvedPath).toLowerCase();
+    const mimeType = MIME_TYPES[extension];
+    if (!mimeType) {
+        throw new Error(`unsupported image type: ${filePath}`);
+    }
+    const base64 = fs.readFileSync(resolvedPath).toString('base64');
+    return { base64, mimeType };
+}
+export function buildImageContent(filePaths) {
+    return filePaths.map((filePath) => {
+        const { base64, mimeType } = encodeImageToBase64(filePath);
+        return {
+            type: 'image_url',
+            image_url: {
+                url: `data:${mimeType};base64,${base64}`,
+            },
+        };
+    });
+}
+export function isVisionCapableModel(model) {
+    return VISION_MODEL_PATTERNS.some((pattern) => pattern.test(model.trim()));
+}
+function normalizeDetectedPath(rawValue) {
+    const value = rawValue.trim().replace(/[),.;:!?]+$/g, '');
+    if (!value || /^(?:https?:|data:)/i.test(value))
+        return null;
+    return IMAGE_EXTENSION_PATTERN.test(value) ? value : null;
+}