@playcraft/build 0.0.13 → 0.0.15

package/dist/vite/platform-configs.js

@@ -22,7 +22,7 @@ export const PLATFORM_CONFIGS = {
         },
         esmSupport: {
             enabled: true,
-            preferIIFE: false, // 通用构建支持现代 ESM
+            preferIIFE: true, // 使用 IIFE 确保 pc 全局可用，避免 ESM 模块作用域问题
         },
         playable: {
             patchXhrOut: false,
@@ -415,4 +415,32 @@ export const PLATFORM_CONFIGS = {
             configJsonInline: true,
         },
     },
+    mintegral: {
+        sizeLimit: 5 * 1024 * 1024, // 5MB (ZIP)
+        outputFormat: 'zip',
+        minifyCSS: true,
+        minifyJS: true,
+        compressImages: false, // 禁用图片压缩，原图输出效果更好
+        compressModels: true,
+        injectScripts: ['mintegralSdk'],
+        outputFileName: 'index.html',
+        includeSourcemap: false,
+        imageQuality: {
+            jpg: 80,
+            png: [0.75, 0.85],
+            webp: 80,
+        },
+        modelCompression: {
+            method: 'draco',
+            quality: 0.85,
+        },
+        esmSupport: {
+            enabled: true,
+            preferIIFE: true, // Mintegral 推荐 IIFE 确保兼容性
+        },
+        playable: {
+            inlineGameScripts: true,
+            externFiles: true, // Mintegral ZIP 支持外部文件（但非 JS/HTML 资源需 base64）
+        },
+    },
 };

package/dist/vite/plugin-compress-js.d.ts

@@ -0,0 +1,21 @@
+import type { Plugin } from 'vite';
+export interface CompressJSPluginOptions {
+    /** 是否启用 JS 代码混淆保护 */
+    enabled: boolean;
+}
+/**
+ * JS 代码混淆保护插件
+ *
+ * 使用 javascript-obfuscator 对 HTML 中所有内联 <script> 标签的 JS 代码
+ * 进行深度混淆，包括：
+ * - 变量名混淆
+ * - 字符串混淆（字面量转为十六进制/unicode 编码）
+ * - 控制流平坦化
+ * - 死代码注入
+ *
+ * 混淆后的代码在浏览器中无法直接阅读理解。
+ *
+ * 注意：这个插件必须在 vite-plugin-singlefile 之后执行，
+ * 确保所有资源已内联到 HTML 中。
+ */
+export declare function viteCompressJSPlugin(options: CompressJSPluginOptions): Plugin | null;

package/dist/vite/plugin-compress-js.js

@@ -0,0 +1,213 @@
+import JavaScriptObfuscator from 'javascript-obfuscator';
+import { minify } from 'terser';
+/**
+ * JS 代码混淆保护插件
+ *
+ * 使用 javascript-obfuscator 对 HTML 中所有内联 <script> 标签的 JS 代码
+ * 进行深度混淆，包括：
+ * - 变量名混淆
+ * - 字符串混淆（字面量转为十六进制/unicode 编码）
+ * - 控制流平坦化
+ * - 死代码注入
+ *
+ * 混淆后的代码在浏览器中无法直接阅读理解。
+ *
+ * 注意：这个插件必须在 vite-plugin-singlefile 之后执行，
+ * 确保所有资源已内联到 HTML 中。
+ */
+export function viteCompressJSPlugin(options) {
+    if (!options.enabled) {
+        return null;
+    }
+    return {
+        name: 'vite-plugin-compress-js',
+        enforce: 'post',
+        async generateBundle(_outputOptions, bundle) {
+            for (const [fileName, asset] of Object.entries(bundle)) {
+                if (!fileName.endsWith('.html'))
+                    continue;
+                if (asset.type !== 'asset')
+                    continue;
+                const html = typeof asset.source === 'string'
+                    ? asset.source
+                    : new TextDecoder().decode(asset.source);
+                console.log('[CompressJS] 开始混淆 HTML 中的 JS 代码...');
+                const result = await obfuscateAllInlineScripts(html);
+                if (result.obfuscatedCount > 0) {
+                    asset.source = result.html;
+                    console.log(`[CompressJS] 混淆完成: ${result.obfuscatedCount} 个脚本块`);
+                    console.log(`[CompressJS] 原始大小: ${formatBytes(result.originalSize)}`);
+                    console.log(`[CompressJS] 混淆后大小: ${formatBytes(result.obfuscatedSize)}`);
+                }
+                else {
+                    console.log('[CompressJS] 未找到需要混淆的脚本块');
+                }
+            }
+        },
+    };
+}
+/**
+ * 检测一个 <script> 标签内容是否是 lz4.js 运行时
+ */
+function isLz4Runtime(content) {
+    return content.includes('window.lz4') && content.includes('window.Buffer') && content.includes('lz4js');
+}
+/**
+ * 检测一个 <script> 标签内容是否是 LZ4 自解压 bootstrap（由 compressEngine 生成）
+ */
+function isLz4Bootstrap(content) {
+    return content.includes('lz4.decompress') && content.includes('new Buffer(') && content.includes('textContent');
+}
+/**
+ * 混淆 HTML 中所有内联 <script> 标签的 JS 代码
+ */
+async function obfuscateAllInlineScripts(html) {
+    // 阶段 1：收集所有需要混淆的脚本块及其位置
+    const scriptRegex = /<script(?:\s[^>]*)?>([\s\S]*?)<\/script>/gi;
+    const entries = [];
+    let match;
+    while ((match = scriptRegex.exec(html)) !== null) {
+        const fullMatch = match[0];
+        const content = match[1];
+        const tagAttributes = fullMatch.substring(0, fullMatch.indexOf('>'));
+        let skip = false;
+        // 跳过有 src 属性的外部脚本
+        if (/\bsrc\s*=/i.test(tagAttributes))
+            skip = true;
+        // 跳过 type 不是 javascript 的
+        if (!skip) {
+            const typeMatch = tagAttributes.match(/\btype\s*=\s*["']([^"']+)["']/i);
+            if (typeMatch) {
+                const type = typeMatch[1].toLowerCase();
+                if (type !== 'text/javascript' && type !== 'application/javascript' && type !== '') {
+                    skip = true;
+                }
+            }
+        }
+        // 跳过空脚本
+        if (!skip && !content.trim())
+            skip = true;
+        // 跳过 lz4.js 运行时和 bootstrap
+        if (!skip && (isLz4Runtime(content) || isLz4Bootstrap(content)))
+            skip = true;
+        // 跳过太短的脚本
+        if (!skip && content.trim().length < 100)
+            skip = true;
+        entries.push({
+            fullMatch,
+            content,
+            index: match.index,
+            skip,
+            replacement: fullMatch,
+        });
+    }
+    // 阶段 2：混淆 + 二次压缩（async）
+    let obfuscatedCount = 0;
+    let originalSize = 0;
+    let obfuscatedSize = 0;
+    for (const entry of entries) {
+        if (entry.skip)
+            continue;
+        try {
+            const originalLen = Buffer.from(entry.content).length;
+            originalSize += originalLen;
+            console.log(`[CompressJS] 混淆脚本 (${formatBytes(originalLen)})...`);
+            // javascript-obfuscator：标识符混淆（关闭 stringArray 避免体积膨胀和运行时冲突）
+            const obfuscatedRaw = JavaScriptObfuscator.obfuscate(entry.content, {
+                compact: true,
+                controlFlowFlattening: false,
+                deadCodeInjection: false,
+                identifierNamesGenerator: 'hexadecimal',
+                stringArray: false,
+                splitStrings: false,
+                numbersToExpressions: false,
+                transformObjectKeys: false,
+                unicodeEscapeSequence: false,
+                disableConsoleOutput: false,
+                selfDefending: false,
+                target: 'browser',
+                // ========== 保留名单 ==========
+                reservedNames: [
+                    '^pc$', '^app$', '^entity$', '^pcBootstrap$',
+                    '^ASSET_PREFIX$', '^SCRIPT_PREFIX$', '^SCENE_PATH$',
+                    '^CONTEXT_OPTIONS$', '^SCRIPTS$', '^INPUT_SETTINGS$',
+                    '^PRELOAD_MODULES$', '^CONFIG_FILENAME$',
+                    '^PlayCraftCTA$', '^jump2AppStore$', '^loadModules$',
+                    '^__esmScriptClasses$', '^__esmScriptSchemas$',
+                    '^__deferredESMScripts$', '^__pendingScriptRegistrations$',
+                    '^Application$', '^Entity$', '^ScriptHandler$',
+                    '^ScriptType$', '^Http$', '^Asset$', '^AssetRegistry$',
+                    '^GraphNode$', '^Vec2$', '^Vec3$', '^Vec4$', '^Quat$',
+                    '^Mat4$', '^Color$', '^Curve$', '^CurveSet$',
+                    '^BoundingBox$', '^BoundingSphere$', '^Ray$',
+                    '^Texture$', '^Material$', '^StandardMaterial$',
+                    '^Mesh$', '^MeshInstance$', '^Model$',
+                    '^AnimComponent$', '^RigidBodyComponent$',
+                    '^CollisionComponent$', '^ElementComponent$',
+                    '^SpriteComponent$', '^ParticleSystemComponent$',
+                    '^ScreenComponent$', '^LayoutGroupComponent$',
+                    '^ScrollViewComponent$', '^ButtonComponent$',
+                    '^CameraComponent$', '^LightComponent$',
+                    '^RenderComponent$', '^SoundComponent$',
+                    '^ScriptComponent$',
+                    '^GameplaySystem$', '^GameRule$',
+                    '^FbPlayableAd$', '^mraid$', '^dapi$', '^ExitApi$',
+                    '^BGY_MRAID$', '^snapchatCta$', '^openAppStore$',
+                    '^install$', '^TJ_API$', '^NUC$', '^smxTracking$',
+                ],
+            }).getObfuscatedCode();
+            // Terser 二次压缩：只做 compress，不做 mangle
+            let obfuscated = obfuscatedRaw;
+            try {
+                const terserResult = await minify(obfuscatedRaw, {
+                    compress: {
+                        passes: 2,
+                        drop_console: true,
+                        drop_debugger: true,
+                    },
+                    mangle: false,
+                    format: {
+                        comments: false,
+                    },
+                });
+                if (terserResult.code) {
+                    obfuscated = terserResult.code;
+                    console.log(`[CompressJS] 二次压缩: ${formatBytes(Buffer.from(obfuscatedRaw).length)} → ${formatBytes(Buffer.from(obfuscated).length)}`);
+                }
+            }
+            catch (e) {
+                console.warn(`[CompressJS] 二次压缩失败，使用混淆后原始代码: ${e.message}`);
+            }
+            const obfuscatedLen = Buffer.from(obfuscated).length;
+            obfuscatedSize += obfuscatedLen;
+            obfuscatedCount++;
+            const tagOpen = entry.fullMatch.substring(0, entry.fullMatch.indexOf('>') + 1);
+            entry.replacement = `${tagOpen}${obfuscated}</script>`;
+        }
+        catch (error) {
+            console.warn(`[CompressJS] 混淆脚本失败: ${error.message}`);
+        }
+    }
+    // 阶段 3：从后往前替换，避免偏移量变化
+    let newHtml = html;
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.skip)
+            continue;
+        newHtml = newHtml.substring(0, entry.index) + entry.replacement + newHtml.substring(entry.index + entry.fullMatch.length);
+    }
+    return {
+        html: newHtml,
+        obfuscatedCount,
+        originalSize,
+        obfuscatedSize,
+    };
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}

package/dist/vite/plugin-esm-html-generator.js

@@ -730,9 +730,13 @@ ${deferWrapper}`);
                     compress: {
                         drop_console: true,
                         drop_debugger: true,
+                        passes: 3,
+                    },
+                    mangle: {
+                        toplevel: true,
                     },
                     format: {
-                        comments: false, // 移除所有注释
+                        comments: false,
                     },
                 } : undefined,
                 rollupOptions: {

package/dist/vite/plugin-obfuscate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Vite 插件：代码混淆 + fflate 压缩
+ *
+ * 在所有其他插件处理完成后，对最终 HTML 中的 IIFE 脚本进行：
+ * 1. javascript-obfuscator 混淆
+ * 2. fflate deflate 压缩
+ * 3. base64 编码 + 自解压 bootstrap 包装
+ */
+import type { Plugin } from 'vite';
+import { type ObfuscateLevel } from '../utils/obfuscate.js';
+export interface ObfuscatePluginOptions {
+    enabled: boolean;
+    level: ObfuscateLevel;
+    /** 是否已经注入了 fflate 运行时（如 compressEngine 已启用） */
+    fflateRuntimeInjected: boolean;
+}
+/**
+ * 代码混淆插件
+ *
+ * 在 generateBundle 阶段对 HTML 中的 IIFE 脚本块进行混淆+压缩
+ */
+export declare function viteObfuscatePlugin(options: ObfuscatePluginOptions): Plugin;

package/dist/vite/plugin-obfuscate.js

@@ -0,0 +1,52 @@
+import { obfuscateAndCompress } from '../utils/obfuscate.js';
+/**
+ * 代码混淆插件
+ *
+ * 在 generateBundle 阶段对 HTML 中的 IIFE 脚本块进行混淆+压缩
+ */
+export function viteObfuscatePlugin(options) {
+    return {
+        name: 'vite-plugin-obfuscate',
+        enforce: 'post',
+        async generateBundle(_outputOptions, bundle) {
+            if (!options.enabled)
+                return;
+            // 找到 HTML 文件
+            for (const [fileName, chunk] of Object.entries(bundle)) {
+                if (!fileName.endsWith('.html') || chunk.type !== 'asset')
+                    continue;
+                const html = typeof chunk.source === 'string' ? chunk.source : new TextDecoder().decode(chunk.source);
+                // 查找 IIFE 脚本块（包含 "Bundled ESM Scripts (IIFE)" 注释的 <script> 标签）
+                const iifePattern = /<script>\s*\/\*\s*Bundled ESM Scripts \(IIFE\)\s*\*\/\s*([\s\S]*?)\s*<\/script>/;
+                const match = html.match(iifePattern);
+                if (!match) {
+                    console.log('[Obfuscate] 未找到 IIFE 脚本块，跳过混淆');
+                    continue;
+                }
+                const iifeCode = match[1];
+                console.log(`[Obfuscate] 找到 IIFE 脚本块 (${(iifeCode.length / 1024).toFixed(0)} KB)，开始混淆...`);
+                try {
+                    const result = await obfuscateAndCompress(iifeCode, options.level);
+                    // 构建替换内容
+                    // 如果 fflate 运行时已经通过 compressEngine 注入，则不重复注入
+                    const runtimeScript = options.fflateRuntimeInjected
+                        ? ''
+                        : result.runtime;
+                    // 替换原始 IIFE 块为：fflate runtime（如需） + 自解压 bootstrap
+                    const replacement = `${runtimeScript}${result.bootstrap}`;
+                    const newHtml = html.replace(match[0], replacement);
+                    // 更新 bundle
+                    chunk.source = newHtml;
+                    console.log(`[Obfuscate] 混淆完成！`);
+                    console.log(`  原始: ${(result.originalSize / 1024).toFixed(0)} KB`);
+                    console.log(`  混淆后: ${(result.obfuscatedSize / 1024).toFixed(0)} KB (+${((result.obfuscatedSize / result.originalSize - 1) * 100).toFixed(0)}%)`);
+                    console.log(`  压缩后: ${(result.compressedSize / 1024).toFixed(0)} KB (压缩率 ${((1 - result.compressedSize / result.obfuscatedSize) * 100).toFixed(0)}%)`);
+                    console.log(`  最终: ${(result.finalSize / 1024).toFixed(0)} KB (vs 原始 ${((result.finalSize / result.originalSize * 100)).toFixed(0)}%)`);
+                }
+                catch (error) {
+                    console.error('[Obfuscate] 混淆失败，保留原始代码:', error);
+                }
+            }
+        },
+    };
+}

package/dist/vite/plugin-platform.d.ts

@@ -9,6 +9,11 @@ export interface PlatformPluginOptions {
     outputFormat: 'html' | 'zip';
     externFiles?: import('../types.js').ExternFilesConfig;
     mraidSupport?: boolean;
+    inlineUnsupportedAssets?: boolean;
+    /** ZIP 格式输出时，是否对 JS 文件进行 Terser 压缩混淆 */
+    minifyJSInZip?: boolean;
+    /** Ammo 物理引擎替换方案 */
+    ammoReplacement?: 'p2' | 'cannon';
 }
 /**
  * 平台 Vite 插件