efront 4.29.1 → 4.30.1

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/coms/zimoli/hookmedia.js

@@ -0,0 +1,29 @@
+var hooked = false;
+var keydown = code => function () {
+    var event = document.createEvent("KeyboardEvent");
+    Object.defineProperty(event, 'keyCode', { value: code });
+    event.initEvent("keydown", false, false);
+    dispatch(window, event);
+};
+try {
+    var { mediaSession } = navigator;
+} catch { }
+if (!mediaSession) return function () { };
+var metadata = window.MediaMetadata ? new window.MediaMetadata : null;
+return function () {
+    if (hooked) return metadata;
+    hooked = true;
+    var Next = 176;
+    var Prev = 177;
+    var pause = 179;
+    var play = 179;
+    var volumeup = 175;
+    var volumedown = 174;
+    var mute = 173;
+    mediaSession.setActionHandler('play', keydown(play));
+    mediaSession.setActionHandler('pause', keydown(pause));
+    mediaSession.setActionHandler("nexttrack", keydown(Next));
+    mediaSession.setActionHandler("previoustrack", keydown(Prev));
+    if (metadata) mediaSession.metadata = metadata;
+    return metadata;
+};

package/coms/zimoli/vbox.js

@@ -148,12 +148,17 @@ function ybox(generator) {
         var wheelTime = 0;
         onmousewheel(_box, function (event) {
             event.preventDefault();
-            if (event.timeStamp - wheelTime > 40 && Math.abs(event.deltaY) < 12) {
-                wheelTime = event.timeStamp;
+            var isNew = event.timeStamp - wheelTime > 120;
+            wheelTime = event.timeStamp;
+            var absY = Math.abs(event.deltaY);
+            if (isNew && absY < 12) {
                 return;
             }
             if (event.moveLocked) return;
             var deltay = -event.deltaY;
+            if (isNew && absY > 80 && (absY | 0) === absY) {
+                deltay /= 3;
+            }
             if (!deltay && _box.bindX) deltay = -event.deltaX;
             event.moveLocked = true;
             var box;

package/package.json

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