efront 4.29.1 → 4.30.0

package/coms/basic/concatByte.js

@@ -1,15 +0,0 @@
-function concatTypedArray(buffs) {
-    var total = 0;
-    buffs.forEach(a => total += a.byteLength || a.length);
-    var res = new Uint8Array(total);
-    var offset = 0, inc = 0;
-    while (offset < total) {
-        var b = buffs[inc++];
-        if (b.buffer) b = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
-        res.set(b, offset);
-        offset += b.length;
-    }
-    return res;
-}
-
-module.exports = concatTypedArray;

package/coms/basic/decodePack.js

@@ -1,203 +0,0 @@
-"include ./encodePack.h";
-var readBinary = require("./readBinary");
-var decodeRange = require("./decodeRange");
-function decodeFlat(buff, start = 0) {
-    var tcount = buff[start];
-    var total = 0;
-    var t = buff[start + 1] & 0x1f;
-    var bitoffset = start + 2 << 3, inc = 0;
-    var counts = [];
-    while (inc < tcount) {
-        var v = readBinary(buff, bitoffset, t);
-        bitoffset += t;
-        var k = readBinary(buff, bitoffset, t);
-        bitoffset += t;
-        counts.unshift(k, v);
-        total += v;
-        inc++;
-    }
-    var rest = new Array(total);
-    while (counts.length) {
-        var t = counts[counts.length - 2];
-        var n = readBinary(buff, bitoffset, t);
-        rest[--total] = [n, t];
-        bitoffset += t;
-        if (--counts[counts.length - 1] <= 0) {
-            counts.pop();
-            counts.pop();
-        }
-    }
-    rest.offset = bitoffset;
-    return rest;
-}
-function fromhuff(buff, result = [], scanstart, type) {
-    type = type === repeat_huffman;
-    var huf = decodeFlat(buff, scanstart);
-    var byteoffset = huf.offset + 7 >> 3;
-    var map = [];
-    var codeend = byteoffset + (huf.length - 1);
-    while (byteoffset < codeend) {
-        var [k, v] = huf.shift();
-        if (!map[v]) {
-            map[v] = {};
-        }
-        if (type) {
-            if (buff[byteoffset] >= 128) {
-                codeend++;
-                map[v][k] = buff[byteoffset++] - 128 << 8 | buff[byteoffset++];
-            } else {
-                map[v][k] = buff[byteoffset++];
-            }
-        } else {
-            map[v][k] = buff[byteoffset++];
-        }
-    }
-    var bitoffset = byteoffset << 3;
-    codeend = buff.length << 3;
-    var endflag = huf[huf.length - 1];
-    var t = 1, s = endflag[1];
-    do {
-        if (!(t in map)) {
-            continue;
-        }
-        var sum = readBinary(buff, bitoffset, t);
-        if (sum in map[t]) {
-            bitoffset += t;
-            result.push(map[t][sum]);
-            t = 0;
-        }
-    } while (bitoffset < codeend && ++t <= s);
-
-    if (sum !== endflag[0]) {
-        console.log(
-            "result:", result,
-            "\r\ndataend:", codeend,
-            "\r\nendflag:", endflag,
-            "\r\ncodefound:", sum,
-            "\r\nbitwidth:", t,
-            "\r\ncodemap:", map
-        );
-        throw console.warn(i18n`数据异常！`);
-    }
-    bitoffset = bitoffset + endflag[1];
-    return bitoffset;
-}
-
-function inflate(buff) {
-    var result = [];
-    for (var cx = 0, dx = buff.length; cx < dx; cx++) {
-        var b = buff[cx];
-        if (b < 256) {
-            result.push(b);
-        }
-        else {
-            b = ((b & 0x7f) << 8 | buff[++cx]) + 1;
-            var c = buff[++cx] << 9 | buff[++cx] << 4 | buff[++cx];
-            var s = result.length - c - b;
-            var code = result.slice(s, s + b);
-            while (code.length) {
-                result.push.apply(result, code.splice(0, 1024));
-            }
-        }
-    }
-    return result;
-}
-
-function repeat(a, count) {
-    var result = [];
-    while (count-- > 0) {
-        result.push(a);
-    }
-    return new Uint8Array(result);
-}
-function readint(buff) {
-    var n = 0;
-    for (var cx = 0, dx = buff.length; cx < dx; cx++) {
-        var b = buff[cx];
-        n = n * 256 + b;
-    }
-    return n;
-}
-var concatByte = require("./concatByte");
-function unpack(buff) {
-    if (buff.length < 2) return buff;
-    var result = [];
-    var byteoffset = 0;
-    do {
-        var type = buff[byteoffset + 1] >> 5;
-        switch (type) {
-            case normal_huffman:
-                var res = [];
-                var bitoffset = fromhuff(buff, res, byteoffset);
-                result.push(new Uint8Array(res));
-                byteoffset = bitoffset + 7 >> 3;
-                break;
-            case repeat_huffman:
-                var res = [];
-                var bitoffset = fromhuff(buff, res, byteoffset, type);
-                res = new Uint16Array(res);
-                res = inflate(res);
-                res = new Uint8Array(res);
-                result.push(res);
-                var tempoffset = bitoffset + 7 >> 3;
-                byteoffset = tempoffset;
-                break;
-            case normal_repeat1:
-                var count = buff[byteoffset + 1] & 0x1f;
-                var res = repeat(buff[byteoffset], count);
-                result.push(res);
-                byteoffset += 2;
-                break;
-            case normal_repeat2:
-                var count = (buff[byteoffset + 1] & 0x1f) << 8 | buff[byteoffset + 2];
-                var res = repeat(buff[byteoffset], count);
-                result.push(res);
-                byteoffset += 3;
-                break;
-            case normal_nocode1:
-                var count = buff[byteoffset] << 5 | buff[byteoffset + 1] & 0x1f;
-                byteoffset += 2;
-                var res = buff.slice(byteoffset, byteoffset + count);
-                result.push(res);
-                byteoffset += count;
-                break;
-            case normal_nocode2:
-                var count = buff[byteoffset] << 13 | buff[byteoffset + 1] << 8 & 0x1f00 | buff[byteoffset + 2];
-                byteoffset += 3;
-                var res = buff.slice(byteoffset, byteoffset + count);
-                result.push(res);
-                byteoffset += count;
-                break;
-            case normal_nocode3:
-                var count = buff[byteoffset] << 21 | buff[byteoffset + 1] << 16 & 0x1f0000 | buff[byteoffset + 2] << 8 | buff[byteoffset + 3];
-                byteoffset += 4;
-                var res = buff.slice(byteoffset, byteoffset + count);
-                result.push(res);
-                byteoffset += count;
-                break;
-            case other_compress:
-                var size = buff[byteoffset + 1] & 0x1f;
-                var type1 = buff[byteoffset];
-                var count = buff.slice(byteoffset += 2, byteoffset += size);
-                count = readint(count);
-                switch (type1) {
-                    case range_compress:
-                        var res = buff.slice(byteoffset, byteoffset += count);
-                        res = decodeRange(res);
-                        res = new Uint16Array(res);
-                        res = inflate(res);
-                        res = new Uint8Array(res);
-                        result.push(res);
-                        break;
-                    default:
-                        throw new Error(i18n`编码异常！`);
-                }
-                break;
-            default:
-                throw new Error(i18n`数据异常！`);
-        }
-    } while (byteoffset + 1 < buff.length);
-    result = concatByte(result);
-    return result;
-}
-module.exports = unpack;

package/coms/basic/decodeRange.js

@@ -1,68 +0,0 @@
-"include ./encodeRange.h";
-var R = R_max,
-	L = 0,
-	d = 0;
-var __buff;
-var __input = 0;
-
-function init() {
-	L = 0;
-	R = R_max;
-	d = 0;
-	var i = code_bits + 1;
-	do {
-		i -= 8;
-		d = shl(d, 8) | input();
-	} while (i > 0);
-}
-
-function input() {
-	if (__input >= __buff.length) return 0;
-	return __buff[__input++];
-}
-
-function guess(T) {// DecodeTarget
-	var code = T;
-	code = shr(d, 1);
-	R = R / T | 0;
-	var result;
-	if (code < L) {
-		result = (code + R_max - L) / R | 0;
-	}
-	else {
-		result = (code - L) / R | 0;
-	}
-	return result;
-}
-
-function decode(cf, f) {
-	L += cf * R;
-	R = f * R;
-	while (R <= R_min) {
-		L = shl(L, 8) & R_max - 1;
-		R = shl(R, 8);
-		d = shl(d, 8) | input();
-	}
-}
-
-function main(buff) {
-	var [total, offset] = readLEB128(buff, 0);
-	__input = offset;
-	__buff = buff;
-	init();
-	var tree = new BitTree(symbol_no);
-	var f, cf;
-	var result = [];
-	while (result.length < total) {
-		var g = guess(tree.total);
-		var i = tree.find2(g);
-		var cf = tree.sumTo(i);
-		var f = tree.counts[i];
-		decode(cf, f);
-		tree.count(i);
-		result.push(i);
-	}
-	__buff = null;
-	return result;
-}
-module.exports = main;

package/coms/basic/encodePack.h

@@ -1,9 +0,0 @@
-const normal_huffman = 0;
-const normal_repeat1 = 1;
-const normal_repeat2 = 2;
-const normal_nocode1 = 3;
-const normal_nocode2 = 4;
-const normal_nocode3 = 5;
-const repeat_huffman = 6;
-const other_compress = 7;
-const range_compress = 1;

package/coms/basic/encodePack.js

@@ -1,301 +0,0 @@
-"include ./encodePack.h";
-var getIndexFromOrderedArray = require("./getIndexFromOrderedArray");
-var saveToOrderedArray = require("./saveToOrderedArray");
-var writeBinary = require("./writeBinary");
-var encodeRange = require("./encodeRange");
-var createHuffman = function (counts) {
-    var rest = [];
-    var counts = [].slice.call(counts);
-    do {
-        var a = counts.pop();
-        var b = counts.pop();
-        var p = [+a + +b];
-        if (!a.length) rest.unshift([0, p]);
-        else a[1] = p, a[0] = 0;
-        if (!b.length) rest.unshift([1, p]);
-        else b[1] = p, b[0] = 1;
-        saveToOrderedArray(counts, p, (a, b) => a >= b);
-    } while (counts.length > 1);
-
-    rest = rest.map(a => {
-        var sum = a[0];
-        var i = 1;
-        while (a[1] !== p) {
-            a = a[1];
-            sum |= a[0] << i++;
-        }
-        return [sum, i];
-    });
-    rest = rest.sort((a, b) => a[1] - b[1]);
-    return rest;
-};
-
-function encodeFlat(rest) {
-    var countMap = {};
-    var dist = [];
-    rest = [].slice.call(rest);
-    rest.forEach(sum => {
-        sum = sum[1];
-        if (!countMap[sum]) countMap[sum] = 1;
-        else countMap[sum]++;
-    });
-    var max = 0, total = 0;
-    for (var k in countMap) {
-        var v = countMap[k];
-        k = +k;
-        if (k > max) max = k;
-        if (v > max) max = v;
-        total += k * v;
-        dist.push(+k, v);
-    }
-    var t = 1;
-    while (max >> t) t++;
-    var buff = new Uint8Array(t * dist.length + total + 23 >> 3);
-    buff[0] = dist.length >> 1;
-    buff[1] = t;
-    var offset = 16;
-    while (dist.length > 0) {
-        writeBinary(buff, offset, t, dist.pop());
-        offset += t;
-    }
-    while (rest.length) {
-        var s = rest.pop();
-        writeBinary(buff, offset, s[1], s[0]);
-        offset += s[1];
-    }
-    return buff;
-}
-function tohuff(buff, result = [], type_limit) {
-    var a = new Uint32Array(type_limit);
-    for (var cx = 0, dx = buff.length; cx < dx; cx++) {
-        a[buff[cx]]++;
-    }
-    var b = new Uint32Array(type_limit);
-    for (var cx = 0, dx = b.length; cx < dx; cx++) {
-        b[cx] = cx;
-    }
-    b.sort(function (m, n) {
-        return a[n] - a[m];
-    });
-    var size = getIndexFromOrderedArray(b, 1, (m, n) => a[m] >= n, false);
-    if (a[b[size]] > 0) size++;
-    if (size + 1 > b.length) console.log(a.slice(420), buff.filter(a => a > 512), b.slice(420))
-
-    var c = new Uint32Array(b.buffer, 0, size + 1).map(_ => a[_]);
-    c = createHuffman(c);
-    var d = new Uint32Array(type_limit);
-    var f = [].slice.call(encodeFlat(c));
-    c.forEach((s, i) => {
-        if (type_limit > 258) {
-            if (b[i] < 128) {
-                f.push(b[i]);
-            } else {
-                f.push((b[i] >> 8) + 128, b[i] & 0xff);
-            }
-        } else {
-            f.push(b[i]);
-        }
-        a[b[i]] = s[0];
-        d[b[i]] = s[1];
-    });
-    if (type_limit > 258 && b[c.length - 1] >= 128) f.pop();
-    f.pop();
-    result.push.apply(result, f);
-    var bitoffset = result.length * 8;
-    buff.forEach(s => {
-        writeBinary(result, bitoffset, d[s], a[s]);
-        bitoffset += d[s];
-    });
-    var endflag = c[c.length - 1];
-    writeBinary(result, bitoffset, endflag[1], endflag[0]);
-    return bitoffset + endflag[1];
-}
-function scan(buff) {
-    var cache = [], cacheLength = 0, cacheLimit = 32768;
-    var writeCache = function (length) {
-        for (var cy = cx, dy = cx + length; cy < dy; cy++) {
-            var b = buff[cy] << 8 | buff[cy + 1] ^ buff[cy + 2];
-            if (cacheLength >= cacheLimit) {
-                var t = cy - cacheLength;
-                var a = buff[t++] << 8 | buff[t++] ^ buff[t];
-                cache[a].shift();
-            } else {
-                cacheLength++;
-            }
-            if (!cache[b]) cache[b] = [];
-            cache[b].push(cy);
-        }
-    };
-    var readCache = function () {
-        var sign = buff[cx] << 8 | buff[cx + 1] ^ buff[cx + 2];
-        if (!cache[sign]) return buff[cx];
-        var list = cache[sign];
-        var max_length = 2, match_position;
-        for (var cy = list.length - 1; cy > 0; cy--) {
-            var inc = list[cy];
-            for (var cz = 1, dz = Math.min(cx - inc, buff.length - cx); cz < dz; cz++) {
-                if (buff[cx + cz] !== buff[inc + cz]) break;
-            }
-            if (cz > max_length) {
-                max_length = cz;
-                match_position = inc;
-            }
-        }
-        if (max_length > 2) {
-            sign = [max_length - 1, cx - match_position - max_length];
-        } else {
-            sign = buff[cx];
-        }
-        return sign;
-    };
-    var result = new Uint16Array(buff.length), result_index = 0;
-    for (var cx = 0, dx = buff.length; cx < dx; cx++) {
-        var b = readCache();
-        if (b.length) {
-            result[result_index++] = b[0] >> 8 | 0x100;
-            result[result_index++] = b[0] & 0xff;
-            result[result_index++] = b[1] >> 9;
-            result[result_index++] = b[1] >> 4 & 0x1f;
-            result[result_index++] = b[1] & 0xf;
-            writeCache(1 + b[0]);
-            cx += b[0];
-        } else {
-            result[result_index++] = b;
-            writeCache(1);
-        }
-    }
-    return result.slice(0, result_index);
-}
-function repeat(buff, readstart = 0) {
-    var s = buff[readstart], f = [s], c = 0;
-    for (var cx = readstart + 1, dx = buff.length; cx < dx; cx++) {
-        if (buff[cx] !== s) break;
-    }
-    var length = cx - readstart;
-    length = length & 0x1fff;
-    if (length < 32) {
-        f[1] = normal_repeat1 << 5 | length;
-    } else {
-        f[1] = normal_repeat2 << 5 | length >> 8;
-        f[2] = length & 0xff;
-    }
-    f.byteoffset = cx;
-    return f;
-}
-var concatTypedArray = require("./concatByte");
-
-function pack(buff) {
-    if (buff.length < 2) return buff;
-    var byteoffset = 0;
-    var samples = []; var count1 = 0, countp;
-    var tempoffset = byteoffset;
-    var result = [];
-    var reset = function () {
-        tempoffset = byteoffset;
-        samples = [];
-        count1 = 0;
-        countp = samples.length;
-    };
-    do {
-        var s = buff[tempoffset++];
-        var sl = samples.length;
-        saveToOrderedArray(samples, s);
-        if (sl === samples.length && tempoffset < buff.length && tempoffset - byteoffset < 8192 << 12) {
-            continue;
-        }
-
-        switch (samples.length) {
-            case 1:
-                if (tempoffset - byteoffset > 8) {
-                    var f = repeat(buff, byteoffset);
-                    result.push(f);
-                    byteoffset = f.byteoffset;
-                    reset();
-                    break;
-                }
-            default:
-                var length = tempoffset - byteoffset;
-                if (tempoffset >= buff.length || length > 8192 << 12) {
-                    var res = [];
-                    var _buff = buff.slice(byteoffset, byteoffset + length);
-                    var _buff1 = scan(_buff);
-                    var huffman_type = repeat_huffman;
-                    var type_limit = 516;
-                    if (_buff.length <= _buff1.length) {
-                        type_limit = 258;
-                        huffman_type = normal_huffman;
-                    } else {
-                        _buff = _buff1;
-                    }
-                    tohuff(_buff, res, type_limit);
-                    res[1] |= huffman_type << 5;
-                    result.push(res);
-                    byteoffset = tempoffset;
-                    reset();
-                }
-        }
-    } while (tempoffset < buff.length);
-    result = concatTypedArray(result);
-    return pack0(buff, result);
-}
-
-function pack0(buff, result) {
-    var length = buff.length;
-    if (length < 8192 && result.length - length > 2) {
-        result = concatTypedArray([
-            [length >> 5, normal_nocode1 << 5 | length & 0x1f],
-            buff
-        ]);
-    }
-    else if (length < 8192 << 8 && result.length - length > 3) {
-        result = concatTypedArray([
-            [length >> 13, normal_nocode2 << 5 | length >> 8 & 0x1f, length & 0xff],
-            buff
-        ]);
-    }
-    else if (length < 8192 << 16 && result.length - length > 4) {
-        result = concatTypedArray([
-            [length >> 21, normal_nocode3 << 5 | length >> 16 & 0x1f, length >> 8 & 0xff, length & 0xff],
-            buff
-        ]);
-    }
-    return result;
-}
-
-function int(n) {
-    var dist = [];
-    while (n > 0) {
-        dist.push(n & 0xff);
-        n = n / 256 | 0;
-    }
-    dist.reverse();
-    return dist;
-}
-
-
-function pack2(buff) {
-    var result = [];
-    for (var cx = 0, dx = buff.length, bx = 32 * 1024 * 1024; cx < dx; cx += bx) {
-        var b = buff.slice(cx, cx + bx);
-        var b = scan(b);
-        var e = encodeRange(b);
-        var el = int(e.length);
-        result.push(concatTypedArray([
-            [
-                range_compress,
-                other_compress << 5 | el.length,
-            ],
-            el, e]));
-    }
-    result = concatTypedArray(result);
-    return pack0(buff, result);
-}
-module.exports = function (buff, type) {
-    switch (type) {
-        case 1:
-            return pack(buff);
-        case 2:
-            return pack2(buff);
-    }
-    return pack2(buff);
-};

package/coms/basic/encodeRange.h

@@ -1,17 +0,0 @@
-const symbol_no = 512;
-const eom = symbol_no;
-const code_bits = 31;
-const shift_bits = code_bits - 8; //shift_bits
-const R_max = shl(1, code_bits);
-const R_min = shl(1, shift_bits);
-const max_freq = 0xffff;
-function shl(a, n) {
-	a = a << n;
-	if (a < 0) {
-		a += 0x100000000;
-	}
-	return a;
-}
-function shr(a, n) {
-	return a >>> n;
-}