technology software

entertainment media

documentation technical

adult content

cryptocurrency blockchain

English

Within the developer-focused generic top-level domain (.dev), 'phantomgenesisprotocol-tsts3fti8m.edgeone.dev' is registered and includes subdomain 'phantomgenesisprotocol-tsts3fti8m'. The core label 'edgeone' covers 7 characters split between four vowels and 3 consonants. Word splitting yields two words: edge, one. Average segment length settles at 3.5 characters. No strong language cues emerged from the frequency lists.

html/28/25/2825ca52-ae4a-4c75-bc5b-25842ea23d36.html.gz

111d70859c1c60611dae8f4f680b7e55f80ac0643d47babac9dc57f4c59f03b4

bf73a3a347427fae5d5b31c72f37c87da7d7648a19fa2a3e32f3db6f391d6cf4

74a1d6443affb31635bdedcefb754bce5bbab0cbd3df99cf34de8170bbeff66d

c35547830300d0f6234c80403c9f5aefa560979816b8fecc3ad6f794585e3211

1fe9d1117ee1ae7d907be807e6a1d7da1d1f0462ce654ed337b90b39bd18f554

2f0b713d8ef19a2ce674d835626d53a57b24de96c32f9f16f039b0620a15a0e0

fca570442e8ec3788c76164a2f47e6da11943f34c9ce1103e7cdfe9a6b5a9e16

width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no

viewport

default-src * 'self' 'unsafe-inline' 'unsafe-eval' data: blob:

theme-color

html/28/25/2825ca52-ae4a-4c75-bc5b-25842ea23d36_nodriver.html.gz

幻元协议

Prudence Malinki

MarkMonitor Inc.

edgeone.dev

IRT-SG-ACE

ACE administrator

ACE-SG


    // 全局检测是否为移动端（供后续代码复用）
    window.isMobileDevice = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
    // 移动端默认1倍（不会模糊），电脑端默认4倍（最佳画质）
    window._superSampleRatio = window.isMobileDevice ? 1 : 4;
    console.log = console.warn = console.debug = console.info = function(){};



    // ========== 全局工具函数 ==========
    // 延迟任务到浏览器空闲时执行
    const scheduleIdleTask = (callback, timeout = 2000) => {
      if ('requestIdleCallback' in window) {
        return requestIdleCallback(callback, { timeout });
      } else {
        return setTimeout(callback, 100);
      }
    };
    
    // 多任务并行执行器
    const parallel = async (tasks, concurrency = 4) => {
      const results = [];
      const executing = [];
      
      for (const [index, task] of tasks.entries()) {
        const promise = Promise.resolve().then(() => task()).then(result => ({ index, result }));
        results.push(promise);
        
        if (tasks.length >= concurrency) {
          executing.push(promise);
          if (executing.length >= concurrency) {
            await Promise.race(executing);
            executing.splice(executing.findIndex(p => p === promise), 1);
          }
        }
      }
      
      return Promise.all(results).then(results => 
        results.sort((a, b) => a.index - b.index).map(r => r.result)
      );
    };
    
    // ========== 非线性过渡效果工具 ==========
    const TransitionEffects = {
      // 非线性缓动函数 (ease-out-cubic)
      easeOutCubic(t) {
        return 1 - Math.pow(1 - t, 3);
      },
      
      // 虚像模糊淡出
      async blurFadeOut(element, duration = 800) {
        const startTime = performance.now();
        
        return new Promise(resolve => {
          const animate = (currentTime) => {
            const elapsed = currentTime - startTime;
            const progress = Math.min(elapsed / duration, 1);
            const easedProgress = this.easeOutCubic(progress);
            
            const blurAmount = easedProgress * 20;
            const opacity = 1 - easedProgress;
            const scale = 1 + (easedProgress * 0.05);
            
            element.style.filter = `blur(${blurAmount}px)`;
            element.style.opacity = opacity;
            element.style.transform = `scale(${scale})`;
            element.style.transition = 'none';
            
            if (progress < 1) {
              requestAnimationFrame(animate);
            } else {
              element.style.filter = '';
              element.style.transform = '';
              element.style.opacity = '';
              resolve();
            }
          };
          
          requestAnimationFrame(animate);
        });
      },
      
      // 画布非线性淡入
      async canvasFadeIn(canvas, duration = 600) {
        canvas.style.opacity = '0';
        canvas.style.transform = 'scale(0.95)';
        canvas.style.filter = 'blur(10px)';
        
        const startTime = performance.now();
        
        return new Promise(resolve => {
          const animate = (currentTime) => {
            const elapsed = currentTime - startTime;
            const progress = Math.min(elapsed / duration, 1);
            const easedProgress = this.easeOutCubic(progress);
            
            canvas.style.opacity = easedProgress;
            canvas.style.transform = `scale(${0.95 + (easedProgress * 0.05)})`;
            canvas.style.filter = `blur(${(1 - easedProgress) * 10}px)`;
            
            if (progress < 1) {
              requestAnimationFrame(animate);
            } else {
              canvas.style.filter = '';
              canvas.style.transform = '';
              resolve();
            }
          };
          
          requestAnimationFrame(animate);
        });
      }
    };
    // ========== 过渡效果工具结束 ==========

    // ========== 项目解析结果缓存系统 ==========
    const ProjectCache = {
      CACHE_KEY: 'scratch_project_parsed_v1',
      PROJECT_HASH_KEY: 'scratch_project_hash',
      
      // 计算项目数据哈希（用于检测是否变化）
      async hashProject(data) {
        // 兼容性检查：如果浏览器不支持 Web Crypto API
        if (!crypto || !crypto.subtle || !crypto.subtle.digest) {
          // 回退方案：使用简单的字符串转换（降低缓存准确性，但保证可用性）
          const buffer = data instanceof ArrayBuffer ? data : await data.arrayBuffer();
          const bytes = new Uint8Array(buffer);
          // 简单哈希：累加所有字节并转换为十六进制
          let hash = 0;
          for (let i = 0; i < Math.min(bytes.length, 10000); i++) {
            hash = ((hash << 5) - hash + bytes[i]) & 0xffffffff;
          }
          return hash.toString(16).padStart(8, '0');
        }
        
        try {
          const buffer = data instanceof ArrayBuffer ? data : await data.arrayBuffer();
          const hashBuffer = await crypto.subtle.digest('SHA-256', buffer);
          const hashArray = Array.from(new Uint8Array(hashBuffer));
          return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
        } catch (e) {
          // 如果加密失败，返回时间戳作为哈希（每次都会重新加载）
          return Date.now().toString(16);
        }
      },
      
      // 保存解析后的项目状态
      async save(runtime, projectHash) {
        try {
          const state = {
            hash: projectHash,
            timestamp: Date.now(),
            // 保存目标的基础数据（位置、方向、造型等）
            targets: runtime.targets.map(t => ({
              id: t.id,
              name: t.name,
              x: t.x,
              y: t.y,
              direction: t.direction,
              scale: t.scale,
              visible: t.visible,
              currentCostume: t.currentCostume,
              variables: t.variables ? Object.fromEntries(
                Object.entries(t.variables).map(([k, v]) => [k, { value: v?.value }])
              ) : {},
              lists: t.lists ? Object.fromEntries(
                Object.entries(t.lists).map(([k, v]) => [k, v?.value])
              ) : {}
            })),
            // 保存全局变量
            globalVariables: (() => {
              const stage = runtime.getTargetForStage();
              return stage && stage.variables ? Object.fromEntries(
                Object.entries(stage.variables).map(([k, v]) => [k, { value: v?.value }])
              ) : {};
            })()
          };
          
          localStorage.setItem(this.CACHE_KEY, JSON.stringify(state));
          localStorage.setItem(this.PROJECT_HASH_KEY, projectHash);
          console.log('‰项目状态已缓存');
        } catch(e) {
          console.warn('缓存项目状态失败:', e);
        }
      },
      
      // 加载缓存的项目状态
      async load(runtime, currentHash) {
        try {
          const cachedHash = localStorage.getItem(this.PROJECT_HASH_KEY);
          if (cachedHash !== currentHash) {
            console.log('‰项目已变更，需要重新解析');
            return false;
          }
          
          const cached = localStorage.getItem(this.CACHE_KEY);
          if (!cached) return false;
          
          const state = JSON.parse(cached);
          
          // 恢复目标状态
          state.targets.forEach(cachedTarget => {
            const target = runtime.targets.find(t => t.id === cachedTarget.id);
            if (target) {
              target.x = cachedTarget.x;
              target.y = cachedTarget.y;
              target.direction = cachedTarget.direction;
              target.scale = cachedTarget.scale;
              target.visible = cachedTarget.visible;
              target.currentCostume = cachedTarget.currentCostume;
              
              // 恢复变量
              if (cachedTarget.variables && target.variables) {
                Object.entries(cachedTarget.variables).forEach(([k, v]) => {
                  if (target.variables[k] && v) target.variables[k].value = v.value;
                });
              }
              
              // 恢复列表
              if (cachedTarget.lists && target.lists) {
                Object.entries(cachedTarget.lists).forEach(([k, v]) => {
                  if (target.lists[k]) target.lists[k].value = v;
                });
              }
            }
          });
          
          console.log('‰项目状态已从缓存恢复');
          return true;
        } catch(e) {
          console.warn('恢复项目状态失败:', e);
          return false;
        }
      }
    };
    
    const run = async () => {
      const projectData = await getProjectData();
      
      // 计算项目哈希
      updateLoadingHint('正在检查缓存...');
      const projectHash = await ProjectCache.hashProject(projectData);
      // ZIP缓存有效时视为有效缓存（跳过网络下载）
      const hasValidCache = window.__zipCacheValid || localStorage.getItem(ProjectCache.PROJECT_HASH_KEY) === projectHash;
      
      if (hasValidCache) {
        updateLoadingHint('使用缓存快速启动...');
      } else {
        updateLoadingHint('首次加载，正在解析项目...');
      }
      
      // ========== 关键优化：渐进式加载 ==========
      // 阶段1：加载项目（解析JSON、创建目标、编译脚本）
      // 使用 requestIdleCallback 或 setTimeout 分解任务，避免阻塞UI
      
      // 先设置一个初始进度，让用户看到进度条在移动
      setProgress(0.85);
      
      // 让出UI线程，让进度条有机会渲染
      await new Promise(r => setTimeout(r, 0));
      
      // 继续加载
      setProgress(0.92);
      
      // 将 loadProject 分解，让进度条有机会更新
      const loadPromise = scaffolding.loadProject(projectData);
      
      // 同时更新进度条动画，让用户感觉"正在工作"
      let progress = 0.92;
      const progressInterval = setInterval(() => {
        progress += 0.003;
        if (progress < 0.995) {
          setProgress(progress);
        }
      }, 30);
      
      await loadPromise;
      clearInterval(progressInterval);
      
      // 阶段2：如果有缓存，尝试恢复状态
      if (hasValidCache) {
        await ProjectCache.load(vm.runtime, projectHash);
      }
      
      setProgress(0.995);
      
      // 阶段3：启动项目
      updateLoadingHint('正在启动...');
      scaffolding.start();
      
      // 阶段4：保存当前状态到缓存（供下次使用）- 延迟到空闲时执行
      scheduleIdleTask(() => {
        ProjectCache.save(vm.runtime, projectHash);
        console.log('‰项目状态已缓存（空闲时）');
      });
      
      setProgress(1);
      
      // 阶段5：延迟加载非关键资源（不阻塞启动）
      setTimeout(() => {
        console.log('‰后台加载非关键资源...');
      }, 3000);
      
      // 等待几帧让画布有内容
      await new Promise(r => requestAnimationFrame(r));
      await new Promise(r => requestAnimationFrame(r));
      await new Promise(r => setTimeout(r, 50));
      
      // 执行淡出动画
      const loadingScreen = document.getElementById('loading');
      if (loadingScreen) {
        loadingScreen.style.opacity = '0';
        loadingScreen.style.transition = 'opacity 0.3s ease';
        await new Promise(r => setTimeout(r, 300));
        loadingScreen.hidden = true;
      }
    };
    run().catch(window.handleError);
    
    // 辅助函数：更新加载提示
    function updateLoadingHint(text) {
      const hintText = document.getElementById('hint-text');
      if (hintText) hintText.textContent = text;
    }
  


    // 使用并行 Promise 替代 Web Worker（更稳定）
    console.log('‰并行加载模式已启用');
  


    if ('serviceWorker' in navigator) {
      const swCode = `
        self.addEventListener('install', e => {
          self.skipWaiting();
        });
        self.addEventListener('fetch', e => {
          e.respondWith(
            caches.match(e.request).then(response => {
              if (response) return response;
              return fetch(e.request).then(r => {
                if (r.status === 200) {
                  const clone = r.clone();
                  caches.open('scratch-v1').then(cache => cache.put(e.request, clone));
                }
                return r;
              });
            })
          );
        });
      `;
      const blob = new Blob([swCode], { type: 'application/javascript' });
      const swUrl = URL.createObjectURL(blob);
      navigator.serviceWorker.register(swUrl).then(() => {
        console.log('Service Worker 已激活，下次访问将秒开！');
      }).catch(() => {});
    }
  

✅ Low Risk - https://phantomgenesisprotocol-tsts3fti8m.edgeone.dev/

Requests	IP Address	Location	AS Autonomous System
6	43.174.246.29	Singapore	AS139341
6	1	-	-

Security Scan Report: phantomgenesisprotocol-tsts3fti8m.edgeone.dev

Summary

AI Security Verdict

Safe Website

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History