efront 4.30.0 → 4.30.1

package/coms/basic/decodeLEB128.js

@@ -1,9 +1,23 @@
+var pow = Math.pow;
+var min = Math.min;
 function decodeLEB128(buff) {
     var dist = [];
     var temp = 0, delta = 0;
-    for (var cx = 0, dx = buff.length; cx < dx; cx++) {
+    var blength = buff.length;
+    for (var cx = 0, dx = min(4, blength); cx < dx; cx++) {
         var b = buff[cx];
-        temp = temp + ((b & 0x7f) << delta)
+        temp = temp + ((b & 0x7f) << delta);
+        if (b >> 7) {
+            delta += 7;
+            continue;
+        }
+        dist.push(temp);
+        temp = 0;
+        delta = 0;
+    }
+    for (var cx = 4, dx = blength; cx < dx; cx++) {
+        var b = buff[cx];
+        temp = temp + (b & 0x7f) * pow(2, delta)
         if (b >> 7) {
             delta += 7;
             continue;

package/coms/basic/decodePackW.asm

@@ -1,6 +1,13 @@
 .data
+; LzmaLib.inc 
+LzmaUncompress PROTO :PTR BYTE, :PTR DWORD, :PTR BYTE, :PTR DWORD
+includelib LzmaLib.lib; https://github.com/yunxu1019/7zip 编译命令为 wasm\build-lib.bat
+include windows.inc
+includelib Kernel32.lib
 errortext db "数据异常"
 errortitle db "错误"
+errorcode db "编码错误"
+mtime FILETIME <0,0>
 normal_huffman equ 0
 normal_repeat1 equ 1
 normal_repeat2 equ 2
@@ -8,7 +15,11 @@ normal_nocode1 equ 3
 normal_nocode2 equ 4
 normal_nocode3 equ 5
 repeat_huffman equ 6
-
+other_compress equ 7
+    normal_nocode4 equ 3
+    mtime_stamp equ 5;
+    access_mode equ 6;
+    lzma_3rd_party equ 7;
 .code
 
 fill proc start,leng,a
@@ -479,8 +490,55 @@ memcopy proc start,len,dist
     ret
 memcopy endp 
 
+
+; 输入：EDX:EAX = JavaScript时间戳（64位毫秒值）
+; 输出：EDX:EAX = Windows FileTime（64位）
+jsDateToFileTime proc
+    push ebx
+    push ecx
+    push esi
+    push edi
+    
+    ; 保存原始输入值
+    mov ebx, eax    ; 低32位
+    mov ecx, edx    ; 高32位
+    ; 乘以10000 (0x2710)
+    ; 先计算低32位 * 10000
+    mov eax, ebx
+    mov edx, 10000
+    mul edx         ; EDX:EAX = EBX * 10000
+    mov esi, eax    ; 保存乘积低32位
+    mov edi, edx    ; 保存乘积高32位
+    
+    ; 再计算高32位 * 10000
+    mov eax, ecx
+    mov edx, 10000
+    mul edx         ; EDX:EAX = ECX * 10000
+    add edi, eax    ; 累加到乘积高32位
+    
+; 19db1ded53e8000
+    ; 加上基准差值低32位
+    add esi, 0d53e8000h
+    adc edi, 0
+    
+    ; 加上基准差值高32位
+    mov eax, 019db1deh
+    add edi, eax
+    
+    ; 返回结果
+    mov eax, esi    ; 低32位
+    mov edx, edi    ; 高32位
+    
+    pop edi
+    pop esi
+    pop ecx
+    pop ebx
+    ret
+jsDateToFileTime endp
+
+
 unpack proc start,len,dsth,passed
-    local writed,buff,bufflen,byteoffset,decoded,count,to
+    local writed,buff,bufflen,byteoffset,decoded,count,to,type1
     local passed0
     mov writed,0
     mov eax,len
@@ -622,6 +680,87 @@ unpack proc start,len,dsth,passed
             add ecx,4
             add ecx,count
             mov to,ecx
+        .elseif eax==other_compress
+            movzx eax,byte ptr[ecx]
+            local srclen,clen
+            mov type1,eax
+            xor eax, eax
+            mov al, byte ptr[ecx+1];
+            and al, 01fh;
+            .if eax>4
+                invoke MessageBox,NULL,offset errortext,offset errortitle,MB_OK
+                invoke ExitProcess,1
+            .endif
+            xor ebx,ebx
+            add ecx,2
+            .while eax>0
+                shl ebx,8
+                mov bl,byte ptr[ecx]
+                inc ecx
+                dec eax
+            .endw
+            mov clen,ebx
+            mov count,ebx
+            mov to,ecx
+            mov eax,type1;
+            .if eax == normal_nocode4
+                invoke GlobalAlloc,GMEM_FIXED or GMEM_ZEROINIT,count
+                mov decoded,eax
+                mov ecx,to
+                invoke memcopy,ecx,clen,decoded
+                mov ecx,to
+                add ecx,clen
+            .elseif eax == lzma_3rd_party
+                mov ecx,to
+                mov eax,[ecx]
+                mov count,eax
+                invoke GlobalAlloc,GMEM_FIXED or GMEM_ZEROINIT,count
+                mov decoded,eax
+                mov ecx,to
+                add ecx,4
+                mov eax,clen
+                sub eax,4
+                mov srclen,eax
+                invoke LzmaUncompress,decoded,addr count,ecx,addr srclen
+            .elseif eax == mtime_stamp;
+                mov eax,20250722h
+                mov eax,clen
+                mov ecx,to
+                push edx
+                xor ebx,ebx
+                push esi
+                xor edx,edx
+                .while eax>0
+                    dec eax
+                    push eax
+                    mov esi,edx
+                    shld edx,ebx,7
+                    shl ebx,7
+                    mov al,[ecx+eax]
+                    shl al,1
+                    mov bl,al
+                    pop eax
+                .endw
+                mov eax,esi
+                shrd ebx,edx,1
+                pop esi
+                shl eax,7;
+                rcr edx,1
+                mov eax,ebx
+                call jsDateToFileTime
+                mov mtime.dwHighDateTime,edx
+                mov mtime.dwLowDateTime,eax
+                pop edx
+                mov count,0
+            .elseif eax == access_mode;暂不支持
+                mov count,0
+            .else
+                invoke MessageBox,NULL,offset errorcode, offset errortitle,MB_OK
+                invoke ExitProcess,1
+            .endif
+            mov ecx,to
+            add ecx,clen
+            mov to, ecx
         .else
             invoke MessageBox,NULL,offset errortext,offset errortitle,MB_OK
             invoke ExitProcess,1
@@ -667,7 +806,9 @@ decodePackW proc srch,start,len,dsth,passed
     mov eax,95577h
     mov eax,DWORD ptr[ecx]
     shr eax,5
+    invoke GetSystemTimeAsFileTime,offset mtime
     invoke unpack,buff,len,dsth,passed
+    invoke SetFileTime,dsth,NULL,NULL,offset mtime
     invoke GlobalFree,buff
     ret
 decodePackW endp

package/coms/basic/encodeLEB128.js

@@ -2,10 +2,15 @@ function encodeLEB128(buff) {
     var dist = [];
     for (var cx = 0, dx = buff.length; cx < dx; cx++) {
         var b = buff[cx];
+        while (b > 0xffffffff) {
+            var t = b % 0x80;
+            dist.push(t | 0b10000000);
+            b = (b - t) / 0x80;
+        }
         while (b > 127) {
             var t = b & 0x7f;
             dist.push(t | 0b10000000);
-            b = b >> 7;
+            b = b >>> 7;
         }
         dist.push(b);
     }

package/coms/compile/Program.js

@@ -894,7 +894,6 @@ class Program {
                             if (last.isExpress && powermap[m] <= powermap["++"]) {
                                 break test;
                             }
-                            console.log(last.isExpress, queue.inExpress, last.entry, last.prev?.text, m);
                             if (queue.inExpress && !iscomment) break test;
                             break;
                         case STAMP:

package/coms/reptile/window.js

@@ -11,17 +11,20 @@ else {
         'Date', 'Promise', 'Function',
         'RegExp', 'Object', 'String',
         'Array', 'Number', 'Boolean',
-        'Error', 'TypeError', 'Uint8Array',
+        'Error', 'TypeError', 'Uint8Array',"DataView",
         'Uint16Array', 'Uint32Array', 'Uint8ClampedArray',
         'ArrayBuffer', 'Int8Array', 'Int16Array',
         'Int32Array', 'Float32Array', 'Float64Array',
         'Map', 'Set', 'Proxy',
         'WeakMap', 'Reflect', 'console',
+        "WebAssembly",
         'Math', 'JSON', 'NaN',
         'Infinity', 'isNaN', 'isFinite',
         'parseInt', 'parseFloat', 'decodeURI',
         'encodeURI', 'decodeURIComponent', 'encodeURIComponent',
         'document', 'navigator', 'process',
+        "BigUint64Array",
+        "i18n",
         'BigInt64Array', 'Buffer', 'Intl',
         'BigInt', 'Symbol', 'SharedArrayBuffer',
         'escape', 'unescape', 'clearImmediate',
@@ -34,4 +37,5 @@ else {
     });
     window.globalThis = window.global = window.top = window.window = window;
     module.exports = window;
+for(var k in global)if((!(k in window)))console.log(k)
 }

package/coms/third-party/lzma.js

@@ -0,0 +1,286 @@
+
+var Module = typeof Module != "undefined" ? Module : {};
+var quit_ = (status, toThrow) => { throw toThrow };
+var scriptDirectory = "";
+function locateFile(path) {
+    if (Module["locateFile"]) { return Module["locateFile"](path, scriptDirectory) }
+    return scriptDirectory + path
+}
+var readAsync, readBinary;
+var fs = require("fs");
+scriptDirectory = __dirname + "/";
+readBinary = filename => {
+    filename = isFileURI(filename) ? new URL(filename) : filename;
+    var ret = fs.readFileSync(filename);
+    return ret
+};
+readAsync = async (filename, binary = true) => {
+    filename = isFileURI(filename) ? new URL(filename) : filename;
+    var ret = fs.readFileSync(filename, binary ? undefined : "utf8");
+    return ret
+};
+if (process.argv.length > 1) { thisProgram = process.argv[1].replace(/\\/g, "/") }
+arguments_ = process.argv.slice(2);
+if (typeof module != "undefined") { module["exports"] = Module }
+quit_ = (status, toThrow) => {
+    process.exitCode = status;
+    throw toThrow
+}
+var err = console.error.bind(console);
+var wasmBinary;
+var ABORT = false;
+var isFileURI = filename => filename.startsWith("file://");
+var wasmMemory;
+var HEAP8, HEAPU8;
+function updateMemoryViews() {
+    var b = wasmMemory.buffer;
+    HEAP8 = new Int8Array(b);
+    HEAPU8 = new Uint8Array(b);
+}
+function preRun() {
+    if (Module["preRun"]) {
+        if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
+        while (Module["preRun"].length) { addOnPreRun(Module["preRun"].shift()) }
+    }
+    callRuntimeCallbacks(onPreRuns)
+}
+function initRuntime() {
+    runtimeInitialized = true;
+    wasmExports["c"]()
+}
+function postRun() {
+    if (Module["postRun"]) {
+        if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
+        while (Module["postRun"].length) { addOnPostRun(Module["postRun"].shift()) }
+    }
+    callRuntimeCallbacks(onPostRuns)
+}
+var runDependencies = 0;
+var dependenciesFulfilled = null;
+function addRunDependency(id) {
+    runDependencies++;
+    Module["monitorRunDependencies"]?.(runDependencies)
+}
+function removeRunDependency(id) {
+    runDependencies--;
+    Module["monitorRunDependencies"]?.(runDependencies);
+    if (runDependencies == 0) {
+        if (dependenciesFulfilled) {
+            var callback = dependenciesFulfilled;
+            dependenciesFulfilled = null;
+            callback()
+        }
+    }
+}
+function abort(what) {
+    Module["onAbort"]?.(what);
+    what = "Aborted(" + what + ")";
+    err(what);
+    ABORT = true;
+    what += ". Build with -sASSERTIONS for more info.";
+    var e = new WebAssembly.RuntimeError(what);
+    throw e
+}
+var wasmBinaryFile;
+function findWasmBinary() { return locateFile("lzma.wasm") }
+function getBinarySync(file) {
+    if (file == wasmBinaryFile && wasmBinary) { return new Uint8Array(wasmBinary) }
+    if (readBinary) { return readBinary(file) }
+    throw "both async and sync fetching of the wasm failed"
+}
+async function getWasmBinary(binaryFile) {
+    if (!wasmBinary) {
+        try {
+            var response = await readAsync(binaryFile);
+            return new Uint8Array(response)
+        } catch { }
+    }
+    return getBinarySync(binaryFile)
+}
+async function instantiateArrayBuffer(binaryFile, imports) {
+    try {
+        var binary = await getWasmBinary(binaryFile);
+        var instance = await WebAssembly.instantiate(binary, imports);
+        return instance
+    } catch (reason) {
+        err(`failed to asynchronously prepare wasm: ${reason}`);
+        abort(reason)
+    }
+}
+async function instantiateAsync(binary, binaryFile, imports) {
+    return instantiateArrayBuffer(binaryFile, imports)
+}
+function getWasmImports() {
+    return {
+        a: wasmImports
+    }
+}
+async function createWasm() {
+    function receiveInstance(instance, module) {
+        wasmExports = instance.exports;
+        wasmMemory = wasmExports["b"];
+        updateMemoryViews();
+        assignWasmExports(wasmExports);
+        removeRunDependency("wasm-instantiate");
+        return wasmExports
+    }
+    addRunDependency("wasm-instantiate");
+    function receiveInstantiationResult(result) { return receiveInstance(result["instance"]) }
+    var info = getWasmImports();
+    if (Module["instantiateWasm"]) { return new Promise((resolve, reject) => { Module["instantiateWasm"](info, (mod, inst) => { resolve(receiveInstance(mod, inst)) }) }) }
+    wasmBinaryFile ??= findWasmBinary();
+    var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
+    var exports = receiveInstantiationResult(result);
+    return exports
+}
+var callRuntimeCallbacks = callbacks => { while (callbacks.length > 0) { callbacks.shift()(Module) } };
+var onPostRuns = [];
+var addOnPostRun = cb => onPostRuns.push(cb);
+var onPreRuns = [];
+var addOnPreRun = cb => onPreRuns.push(cb);
+var stackRestore = val => __emscripten_stack_restore(val);
+var stackSave = () => _emscripten_stack_get_current();
+var getHeapMax = () => 2147483648;
+var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
+var growMemory = size => {
+    var oldHeapSize = wasmMemory.buffer.byteLength;
+    var pages = (size - oldHeapSize + 65535) / 65536 | 0;
+    try {
+        wasmMemory.grow(pages);
+        updateMemoryViews();
+        return 1
+    }
+    catch (e) { }
+};
+var _emscripten_resize_heap = requestedSize => {
+    var oldSize = HEAPU8.length;
+    requestedSize >>>= 0;
+    var maxHeapSize = getHeapMax();
+    if (requestedSize > maxHeapSize) { return false }
+    for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+        var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+        var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+        var replacement = growMemory(newSize);
+        if (replacement) { return true }
+    }
+    return false
+};
+
+var writeArrayToMemory = (array, buffer) => { HEAP8.set(array, buffer) };
+var stackAlloc = sz => __emscripten_stack_alloc(sz);
+var toC = {
+    array: arr => {
+        if (!arr) return arr;
+        if (arr.buffer === HEAP8.buffer) return arr.byteOffset;
+        var ret = stackAlloc(arr.length);
+        writeArrayToMemory(arr, ret);
+        return ret
+    }
+};
+var setUint32LE = function (a, v) {
+    a[0] = v & 0xff;
+    a[1] = v >>> 8 & 0xff
+    a[2] = v >>> 16 & 0xff
+    a[3] = v >>> 24 & 0xff
+};
+var getUint32LE = function (a) {
+    return (a[0] | a[1] << 8 | a[2] << 16 | a[3] << 24) >>> 0;
+};
+
+var fcall = function (func, input, outLength) {
+    var cArgs = [];
+    var stack = stackSave();
+    var argTypes = ["array", "number", "array", "number"];
+    var output = outLength > 0 ? alloc(outLength) : null;
+    var outOffset = output?.byteOffset;
+    var args = [output, outLength, input, input.length];
+    if (args) {
+        for (var i = 0; i < args.length; i++) {
+            var converter = toC[argTypes[i]];
+            if (converter) {
+                cArgs[i] = converter(args[i])
+            }
+            else { cArgs[i] = args[i] }
+        }
+    }
+    function onDone(ret) {
+        if (ret > 0) {
+            var result = new Uint8Array(ret + 4);
+            setUint32LE(result, input.length);
+            result.set(HEAP8.subarray(outOffset, outOffset + ret), 4);
+        }
+        if (ret < 0) throw console.log(ret), new Error("编码错误！");
+        return result;
+    }
+    var ret = func(...cArgs);
+    if (outLength > 0) ret = onDone(ret);
+    stackRestore(stack);
+    return ret;
+}
+
+Module.decompress = function (input) {
+    var size = getUint32LE(input);
+    var output = fcall(decompress, input.subarray(4, input.length), size);
+    return output.subarray(4, output.length);
+};
+Module.compress = function (input) {
+    return fcall(compress, input, input.length + (input.length >> 1) + 200);
+};
+
+var alloc = function (size) {
+    var offset = stackAlloc(size);
+    if (offset < 0) throw new Error('申请内存失败');
+    var res = new Uint8Array(HEAP8.buffer, offset, size);
+    return res;
+}
+var __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current;
+var compress, decompress;
+function assignWasmExports(wasmExports) {
+    compress = wasmExports["d"];
+    decompress = wasmExports["e"];
+    __emscripten_stack_restore = wasmExports["f"];
+    __emscripten_stack_alloc = wasmExports["g"];
+    _emscripten_stack_get_current = wasmExports["h"]
+}
+var wasmImports = {
+    a: _emscripten_resize_heap
+};
+var wasmExports;
+createWasm();
+function run() {
+    if (runDependencies > 0) {
+        dependenciesFulfilled = run;
+        return
+    }
+    preRun();
+    if (runDependencies > 0) {
+        dependenciesFulfilled = run;
+        return
+    }
+    function doRun() {
+        Module["calledRun"] = true;
+        if (ABORT) return;
+        initRuntime();
+        Module["onRuntimeInitialized"]?.();
+        postRun()
+    }
+    if (Module["setStatus"]) {
+        Module["setStatus"]("Running...");
+        setTimeout(() => {
+            setTimeout(() => Module["setStatus"](""), 1);
+            doRun()
+        }, 1)
+    }
+    else { doRun() }
+}
+function preInit() {
+    if (Module["preInit"]) {
+        if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
+        while (Module["preInit"].length > 0) { Module["preInit"].shift()() }
+    }
+}
+preInit();
+run();
+
+

package/coms/third-party//344/273/243/347/240/201/346/235/245/346/272/220.txt

@@ -1,4 +1,6 @@
 第三方代码来源及日期，后续版本请自行更新
+2025-07-17 https://github.com/ip7z/7zip
+           https://github.com/yunxu1019/7zip 已编译为 lzma.wasm, lzma.js 已改写
 2022-12-30 https://npmjs.com/package/crypto-js
 2022-11-12 https://github.com/kazuhikoarase/qrcode-generator 逻辑有修改 qrcode.js
 2021-06-15 https://www.npmjs.com/package/html2canvas

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "efront",
-    "version": "4.30.0",
+    "version": "4.30.1",
     "description": "一个开发环境，提供一种自由的前端开发模式，也可作为辅助工具使用。",
     "main": "public/efront.js",
     "directories": {