forked from sheetjs/sheetjs
switch to cfb
for zip operations
This commit is contained in:
parent
f78c866cf4
commit
43a7a5ea07
@ -17,7 +17,6 @@
|
||||
.*/xlsx.mini.js
|
||||
.*/xlsx.mini.flow.js
|
||||
.*/xlsxworker.js
|
||||
.*/jszip.js
|
||||
.*/tests/.*
|
||||
.*/demos/.*
|
||||
|
||||
|
2
Makefile
2
Makefile
@ -1,7 +1,7 @@
|
||||
SHELL=/bin/bash
|
||||
LIB=xlsx
|
||||
FMT=xlsx xlsm xlsb ods xls xml misc full
|
||||
REQS=jszip.js
|
||||
REQS=
|
||||
ADDONS=dist/cpexcel.js
|
||||
AUXTARGETS=
|
||||
CMDS=bin/xlsx.njs
|
||||
|
@ -14,13 +14,13 @@ if(typeof Buffer !== 'undefined') {
|
||||
|
||||
function new_raw_buf(len/*:number*/) {
|
||||
/* jshint -W056 */
|
||||
return has_buf ? Buffer.alloc(len) : new Array(len);
|
||||
return has_buf ? Buffer.alloc(len) : typeof Uint8Array != "undefined" ? new Uint8Array(len) : new Array(len);
|
||||
/* jshint +W056 */
|
||||
}
|
||||
|
||||
function new_unsafe_buf(len/*:number*/) {
|
||||
/* jshint -W056 */
|
||||
return has_buf ? Buffer.allocUnsafe(len) : new Array(len);
|
||||
return has_buf ? Buffer.allocUnsafe(len) : typeof Uint8Array != "undefined" ? new Uint8Array(len) : new Array(len);
|
||||
/* jshint +W056 */
|
||||
}
|
||||
|
||||
@ -55,6 +55,52 @@ function ab2a(data/*:ArrayBuffer|Uint8Array*/)/*:Array<number>*/ {
|
||||
return o;
|
||||
}
|
||||
|
||||
var bconcat = function(bufs) { return [].concat.apply([], bufs); };
|
||||
function utf8decode(content/*:string*/) {
|
||||
var out = [], widx = 0;
|
||||
var o = new_raw_buf(content.length + 255);
|
||||
for(var ridx = 0; ridx < content.length; ++ridx) {
|
||||
var c = content.charCodeAt(ridx);
|
||||
if(c < 0x80) o[widx++] = c;
|
||||
else if(c < 0x800) {
|
||||
o[widx++] = (192|((c>>6)&31));
|
||||
o[widx++] = (128|(c&63));
|
||||
} else if(c >= 0xD800 && c < 0xE000) {
|
||||
c = (c&1023)+64;
|
||||
var d = str.charCodeAt(++ridx)&1023;
|
||||
o[widx++] = (240|((c>>8)&7));
|
||||
o[widx++] = (128|((c>>2)&63));
|
||||
o[widx++] = (128|((d>>6)&15)|((c&3)<<4));
|
||||
o[widx++] = (128|(d&63));
|
||||
} else {
|
||||
o[widx++] = (224|((c>>12)&15));
|
||||
o[widx++] = (128|((c>>6)&63));
|
||||
o[widx++] = (128|(c&63));
|
||||
}
|
||||
if(widx > 65530) {
|
||||
out.push(o.slice(0, widx));
|
||||
widx = 0;
|
||||
o = new_raw_buf(65535);
|
||||
}
|
||||
}
|
||||
out.push(o.slice(0, widx));
|
||||
return bconcat(out);
|
||||
}
|
||||
|
||||
var bconcat = function(bufs) {
|
||||
if(typeof Uint8Array !== "undefined") {
|
||||
var i = 0, maxlen = 0;
|
||||
for(i = 0; i < bufs.length; ++i) maxlen += bufs[i].length;
|
||||
var o = new Uint8Array(maxlen);
|
||||
var len = 0;
|
||||
for(i = 0, maxlen = 0; i < bufs.length; maxlen += len, ++i) {
|
||||
len = bufs[i].length;
|
||||
if(bufs[i] instanceof Uint8Array) o.set(bufs[i], maxlen);
|
||||
else if(typeof bufs[i] == "string") { throw "wtf"; }
|
||||
else o.set(new Uint8Array(bufs[i]), maxlen);
|
||||
}
|
||||
return o;
|
||||
}
|
||||
return [].concat.apply([], bufs.map(function(buf) { return Array.isArray(buf) ? buf : [].slice.call(buf); }));
|
||||
};
|
||||
|
||||
var chr0 = /\u0000/g, chr1 = /[\u0001-\u0006]/g;
|
||||
|
589
bits/18_cfb.js
589
bits/18_cfb.js
@ -16,12 +16,13 @@ declare var has_buf:boolean;
|
||||
declare var new_buf:any;
|
||||
declare var new_raw_buf:any;
|
||||
declare var new_unsafe_buf:any;
|
||||
declare var Buffer_from:any;
|
||||
*/
|
||||
/* cfb.js (C) 2013-present SheetJS -- http://sheetjs.com */
|
||||
/* vim: set ts=2: */
|
||||
/*jshint eqnull:true */
|
||||
/*exported CFB */
|
||||
/*global Uint8Array:false, Uint16Array:false */
|
||||
/*global module, require:false, process:false, Buffer:false, Uint8Array:false, Uint16Array:false */
|
||||
|
||||
/*::
|
||||
declare var DO_NOT_EXPORT_CFB:?boolean;
|
||||
@ -71,70 +72,68 @@ function signed_crc_table()/*:any*/ {
|
||||
return typeof Int32Array !== 'undefined' ? new Int32Array(table) : table;
|
||||
}
|
||||
|
||||
var T = signed_crc_table();
|
||||
var T0 = signed_crc_table();
|
||||
function slice_by_16_tables(T) {
|
||||
var c = 0, v = 0, n = 0, table/*:Array<number>*/ = typeof Int32Array !== 'undefined' ? new Int32Array(4096) : new Array(4096) ;
|
||||
|
||||
for(n = 0; n != 256; ++n) table[n] = T[n];
|
||||
for(n = 0; n != 256; ++n) {
|
||||
v = T[n];
|
||||
for(c = 256 + n; c < 4096; c += 256) v = table[c] = (v >>> 8) ^ T[v & 0xFF];
|
||||
}
|
||||
var out = [];
|
||||
for(n = 1; n != 16; ++n) out[n - 1] = typeof Int32Array !== 'undefined' ? table.subarray(n * 256, n * 256 + 256) : table.slice(n * 256, n * 256 + 256);
|
||||
return out;
|
||||
}
|
||||
var TT = slice_by_16_tables(T0);
|
||||
var T1 = TT[0], T2 = TT[1], T3 = TT[2], T4 = TT[3], T5 = TT[4];
|
||||
var T6 = TT[5], T7 = TT[6], T8 = TT[7], T9 = TT[8], Ta = TT[9];
|
||||
var Tb = TT[10], Tc = TT[11], Td = TT[12], Te = TT[13], Tf = TT[14];
|
||||
function crc32_bstr(bstr/*:string*/, seed/*:number*/)/*:number*/ {
|
||||
var C = seed ^ -1, L = bstr.length - 1;
|
||||
for(var i = 0; i < L;) {
|
||||
C = (C>>>8) ^ T[(C^bstr.charCodeAt(i++))&0xFF];
|
||||
C = (C>>>8) ^ T[(C^bstr.charCodeAt(i++))&0xFF];
|
||||
}
|
||||
if(i === L) C = (C>>>8) ^ T[(C ^ bstr.charCodeAt(i))&0xFF];
|
||||
return C ^ -1;
|
||||
var C = seed/*:: ? 0 : 0 */ ^ -1;
|
||||
for(var i = 0, L = bstr.length; i < L;) C = (C>>>8) ^ T0[(C^bstr.charCodeAt(i++))&0xFF];
|
||||
return ~C;
|
||||
}
|
||||
|
||||
function crc32_buf(buf/*:Uint8Array|Array<number>*/, seed/*:number*/)/*:number*/ {
|
||||
if(buf.length > 10000) return crc32_buf_8(buf, seed);
|
||||
var C = seed ^ -1, L = buf.length - 3;
|
||||
for(var i = 0; i < L;) {
|
||||
C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
|
||||
C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
|
||||
C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
|
||||
C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
|
||||
}
|
||||
while(i < L+3) C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
|
||||
return C ^ -1;
|
||||
}
|
||||
|
||||
function crc32_buf_8(buf/*:Uint8Array|Array<number>*/, seed/*:number*/)/*:number*/ {
|
||||
var C = seed ^ -1, L = buf.length - 7;
|
||||
for(var i = 0; i < L;) {
|
||||
C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
|
||||
C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
|
||||
C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
|
||||
C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
|
||||
C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
|
||||
C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
|
||||
C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
|
||||
C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
|
||||
}
|
||||
while(i < L+7) C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
|
||||
return C ^ -1;
|
||||
function crc32_buf(B/*:Uint8Array|Array<number>*/, seed/*:number*/)/*:number*/ {
|
||||
var C = seed/*:: ? 0 : 0 */ ^ -1, L = B.length - 15, i = 0;
|
||||
for(; i < L;) C =
|
||||
Tf[B[i++] ^ (C & 255)] ^
|
||||
Te[B[i++] ^ ((C >> 8) & 255)] ^
|
||||
Td[B[i++] ^ ((C >> 16) & 255)] ^
|
||||
Tc[B[i++] ^ (C >>> 24)] ^
|
||||
Tb[B[i++]] ^ Ta[B[i++]] ^ T9[B[i++]] ^ T8[B[i++]] ^
|
||||
T7[B[i++]] ^ T6[B[i++]] ^ T5[B[i++]] ^ T4[B[i++]] ^
|
||||
T3[B[i++]] ^ T2[B[i++]] ^ T1[B[i++]] ^ T0[B[i++]];
|
||||
L += 15;
|
||||
while(i < L) C = (C>>>8) ^ T0[(C^B[i++])&0xFF];
|
||||
return ~C;
|
||||
}
|
||||
|
||||
function crc32_str(str/*:string*/, seed/*:number*/)/*:number*/ {
|
||||
var C = seed ^ -1;
|
||||
for(var i = 0, L=str.length, c, d; i < L;) {
|
||||
for(var i = 0, L = str.length, c = 0, d = 0; i < L;) {
|
||||
c = str.charCodeAt(i++);
|
||||
if(c < 0x80) {
|
||||
C = (C>>>8) ^ T[(C ^ c)&0xFF];
|
||||
C = (C>>>8) ^ T0[(C^c)&0xFF];
|
||||
} else if(c < 0x800) {
|
||||
C = (C>>>8) ^ T[(C ^ (192|((c>>6)&31)))&0xFF];
|
||||
C = (C>>>8) ^ T[(C ^ (128|(c&63)))&0xFF];
|
||||
C = (C>>>8) ^ T0[(C ^ (192|((c>>6)&31)))&0xFF];
|
||||
C = (C>>>8) ^ T0[(C ^ (128|(c&63)))&0xFF];
|
||||
} else if(c >= 0xD800 && c < 0xE000) {
|
||||
c = (c&1023)+64; d = str.charCodeAt(i++)&1023;
|
||||
C = (C>>>8) ^ T[(C ^ (240|((c>>8)&7)))&0xFF];
|
||||
C = (C>>>8) ^ T[(C ^ (128|((c>>2)&63)))&0xFF];
|
||||
C = (C>>>8) ^ T[(C ^ (128|((d>>6)&15)|((c&3)<<4)))&0xFF];
|
||||
C = (C>>>8) ^ T[(C ^ (128|(d&63)))&0xFF];
|
||||
C = (C>>>8) ^ T0[(C ^ (240|((c>>8)&7)))&0xFF];
|
||||
C = (C>>>8) ^ T0[(C ^ (128|((c>>2)&63)))&0xFF];
|
||||
C = (C>>>8) ^ T0[(C ^ (128|((d>>6)&15)|((c&3)<<4)))&0xFF];
|
||||
C = (C>>>8) ^ T0[(C ^ (128|(d&63)))&0xFF];
|
||||
} else {
|
||||
C = (C>>>8) ^ T[(C ^ (224|((c>>12)&15)))&0xFF];
|
||||
C = (C>>>8) ^ T[(C ^ (128|((c>>6)&63)))&0xFF];
|
||||
C = (C>>>8) ^ T[(C ^ (128|(c&63)))&0xFF];
|
||||
C = (C>>>8) ^ T0[(C ^ (224|((c>>12)&15)))&0xFF];
|
||||
C = (C>>>8) ^ T0[(C ^ (128|((c>>6)&63)))&0xFF];
|
||||
C = (C>>>8) ^ T0[(C ^ (128|(c&63)))&0xFF];
|
||||
}
|
||||
}
|
||||
return C ^ -1;
|
||||
return ~C;
|
||||
}
|
||||
CRC32.table = T;
|
||||
CRC32.table = T0;
|
||||
CRC32.bstr = crc32_bstr;
|
||||
CRC32.buf = crc32_buf;
|
||||
CRC32.str = crc32_str;
|
||||
@ -142,7 +141,7 @@ CRC32.str = crc32_str;
|
||||
/* [MS-CFB] v20171201 */
|
||||
var CFB = (function _CFB(){
|
||||
var exports/*:CFBModule*/ = /*::(*/{}/*:: :any)*/;
|
||||
exports.version = '1.1.4';
|
||||
exports.version = '1.2.1';
|
||||
/* [MS-CFB] 2.6.4 */
|
||||
function namecmp(l/*:string*/, r/*:string*/)/*:number*/ {
|
||||
var L = l.split("/"), R = r.split("/");
|
||||
@ -232,6 +231,7 @@ var fs/*:: = require('fs'); */;
|
||||
function get_fs() { return fs || (fs = require('fs')); }
|
||||
function parse(file/*:RawBytes*/, options/*:CFBReadOpts*/)/*:CFBContainer*/ {
|
||||
if(file[0] == 0x50 && file[1] == 0x4b) return parse_zip(file, options);
|
||||
if((file[0] | 0x20) == 0x6d && (file[1]|0x20) == 0x69) return parse_mad(file, options);
|
||||
if(file.length < 512) throw new Error("CFB file size " + file.length + " < 512");
|
||||
var mver = 3;
|
||||
var ssz = 512;
|
||||
@ -441,7 +441,7 @@ function sleuth_fat(idx/*:number*/, cnt/*:number*/, sectors/*:Array<RawBytes>*/,
|
||||
if((q = __readInt32LE(sector,i*4)) === ENDOFCHAIN) break;
|
||||
fat_addrs.push(q);
|
||||
}
|
||||
if(cnt >= 1) sleuth_fat(__readInt32LE(sector,ssz-4),cnt - 1, sectors, ssz, fat_addrs);
|
||||
sleuth_fat(__readInt32LE(sector,ssz-4),cnt - 1, sectors, ssz, fat_addrs);
|
||||
}
|
||||
}
|
||||
|
||||
@ -553,7 +553,11 @@ function read_file(filename/*:string*/, options/*:CFBReadOpts*/) {
|
||||
}
|
||||
|
||||
function read(blob/*:RawBytes|string*/, options/*:CFBReadOpts*/) {
|
||||
switch(options && options.type || "base64") {
|
||||
var type = options && options.type;
|
||||
if(!type) {
|
||||
if(has_buf && Buffer.isBuffer(blob)) type = "buffer";
|
||||
}
|
||||
switch(type || "base64") {
|
||||
case "file": /*:: if(typeof blob !== 'string') throw "Must pass a filename when type='file'"; */return read_file(blob, options);
|
||||
case "base64": /*:: if(typeof blob !== 'string') throw "Must pass a base64-encoded binary string when type='file'"; */return parse(s2a(Base64.decode(blob)), options);
|
||||
case "binary": /*:: if(typeof blob !== 'string') throw "Must pass a binary string when type='file'"; */return parse(s2a(blob), options);
|
||||
@ -602,22 +606,28 @@ function rebuild_cfb(cfb/*:CFBContainer*/, f/*:?boolean*/)/*:void*/ {
|
||||
if(!gc && !f) return;
|
||||
|
||||
var now = new Date(1987, 1, 19), j = 0;
|
||||
// Track which names exist
|
||||
var fullPaths = Object.create ? Object.create(null) : {};
|
||||
var data/*:Array<[string, CFBEntry]>*/ = [];
|
||||
for(i = 0; i < cfb.FullPaths.length; ++i) {
|
||||
fullPaths[cfb.FullPaths[i]] = true;
|
||||
if(cfb.FileIndex[i].type === 0) continue;
|
||||
data.push([cfb.FullPaths[i], cfb.FileIndex[i]]);
|
||||
}
|
||||
for(i = 0; i < data.length; ++i) {
|
||||
var dad = dirname(data[i][0]);
|
||||
s = false;
|
||||
for(j = 0; j < data.length; ++j) if(data[j][0] === dad) s = true;
|
||||
if(!s) data.push([dad, ({
|
||||
name: filename(dad).replace("/",""),
|
||||
type: 1,
|
||||
clsid: HEADER_CLSID,
|
||||
ct: now, mt: now,
|
||||
content: null
|
||||
}/*:any*/)]);
|
||||
s = fullPaths[dad];
|
||||
if(!s) {
|
||||
data.push([dad, ({
|
||||
name: filename(dad).replace("/",""),
|
||||
type: 1,
|
||||
clsid: HEADER_CLSID,
|
||||
ct: now, mt: now,
|
||||
content: null
|
||||
}/*:any*/)]);
|
||||
// Add name to set
|
||||
fullPaths[dad] = true;
|
||||
}
|
||||
}
|
||||
|
||||
data.sort(function(x,y) { return namecmp(x[0], y[0]); });
|
||||
@ -650,10 +660,15 @@ function rebuild_cfb(cfb/*:CFBContainer*/, f/*:?boolean*/)/*:void*/ {
|
||||
|
||||
}
|
||||
|
||||
function _write(cfb/*:CFBContainer*/, options/*:CFBWriteOpts*/)/*:RawBytes*/ {
|
||||
function _write(cfb/*:CFBContainer*/, options/*:CFBWriteOpts*/)/*:RawBytes|string*/ {
|
||||
var _opts = options || {};
|
||||
/* MAD is order-sensitive, skip rebuild and sort */
|
||||
if(_opts.fileType == 'mad') return write_mad(cfb, _opts);
|
||||
rebuild_cfb(cfb);
|
||||
if(_opts.fileType == 'zip') return write_zip(cfb, _opts);
|
||||
switch(_opts.fileType) {
|
||||
case 'zip': return write_zip(cfb, _opts);
|
||||
//case 'mad': return write_mad(cfb, _opts);
|
||||
}
|
||||
var L = (function(cfb/*:CFBContainer*/)/*:Array<number>*/{
|
||||
var mini_size = 0, fat_size = 0;
|
||||
for(var i = 0; i < cfb.FileIndex.length; ++i) {
|
||||
@ -771,19 +786,36 @@ function _write(cfb/*:CFBContainer*/, options/*:CFBWriteOpts*/)/*:RawBytes*/ {
|
||||
/*:: if(!file.content) throw new Error("unreachable"); */
|
||||
if(file.size >= 0x1000) {
|
||||
o.l = (file.start+1) << 9;
|
||||
for(j = 0; j < file.size; ++j) o.write_shift(1, file.content[j]);
|
||||
for(; j & 0x1FF; ++j) o.write_shift(1, 0);
|
||||
if (has_buf && Buffer.isBuffer(file.content)) {
|
||||
file.content.copy(o, o.l, 0, file.size);
|
||||
// o is a 0-filled Buffer so just set next offset
|
||||
o.l += (file.size + 511) & -512;
|
||||
} else {
|
||||
for(j = 0; j < file.size; ++j) o.write_shift(1, file.content[j]);
|
||||
for(; j & 0x1FF; ++j) o.write_shift(1, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
for(i = 1; i < cfb.FileIndex.length; ++i) {
|
||||
file = cfb.FileIndex[i];
|
||||
/*:: if(!file.content) throw new Error("unreachable"); */
|
||||
if(file.size > 0 && file.size < 0x1000) {
|
||||
for(j = 0; j < file.size; ++j) o.write_shift(1, file.content[j]);
|
||||
for(; j & 0x3F; ++j) o.write_shift(1, 0);
|
||||
if (has_buf && Buffer.isBuffer(file.content)) {
|
||||
file.content.copy(o, o.l, 0, file.size);
|
||||
// o is a 0-filled Buffer so just set next offset
|
||||
o.l += (file.size + 63) & -64;
|
||||
} else {
|
||||
for(j = 0; j < file.size; ++j) o.write_shift(1, file.content[j]);
|
||||
for(; j & 0x3F; ++j) o.write_shift(1, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
while(o.l < o.length) o.write_shift(1, 0);
|
||||
if (has_buf) {
|
||||
o.l = o.length;
|
||||
} else {
|
||||
// When using Buffer, already 0-filled
|
||||
while(o.l < o.length) o.write_shift(1, 0);
|
||||
}
|
||||
return o;
|
||||
}
|
||||
/* [MS-CFB] 2.6.4 (Unicode 3.0.1 case conversion) */
|
||||
@ -847,10 +879,13 @@ function a2s(o/*:RawBytes*/)/*:string*/ {
|
||||
|
||||
function write(cfb/*:CFBContainer*/, options/*:CFBWriteOpts*/)/*:RawBytes|string*/ {
|
||||
var o = _write(cfb, options);
|
||||
switch(options && options.type) {
|
||||
switch(options && options.type || "buffer") {
|
||||
case "file": get_fs(); fs.writeFileSync(options.filename, (o/*:any*/)); return o;
|
||||
case "binary": return a2s(o);
|
||||
case "base64": return Base64.encode(a2s(o));
|
||||
case "binary": return typeof o == "string" ? o : a2s(o);
|
||||
case "base64": return Base64.encode(typeof o == "string" ? o : a2s(o));
|
||||
case "buffer": if(has_buf) return Buffer.isBuffer(o) ? o : Buffer_from(o);
|
||||
/* falls through */
|
||||
case "array": return typeof o == "string" ? s2a(o) : o;
|
||||
}
|
||||
return o;
|
||||
}
|
||||
@ -920,6 +955,38 @@ function read_bits_n(buf, bl, n) {
|
||||
return v & f;
|
||||
}
|
||||
|
||||
/* helpers for unaligned bit writes */
|
||||
function write_bits_3(buf, bl, v) { var w = bl & 7, h = bl >>> 3;
|
||||
if(w <= 5) buf[h] |= (v & 7) << w;
|
||||
else {
|
||||
buf[h] |= (v << w) & 0xFF;
|
||||
buf[h+1] = (v&7) >> (8-w);
|
||||
}
|
||||
return bl + 3;
|
||||
}
|
||||
|
||||
function write_bits_1(buf, bl, v) {
|
||||
var w = bl & 7, h = bl >>> 3;
|
||||
v = (v&1) << w;
|
||||
buf[h] |= v;
|
||||
return bl + 1;
|
||||
}
|
||||
function write_bits_8(buf, bl, v) {
|
||||
var w = bl & 7, h = bl >>> 3;
|
||||
v <<= w;
|
||||
buf[h] |= v & 0xFF; v >>>= 8;
|
||||
buf[h+1] = v;
|
||||
return bl + 8;
|
||||
}
|
||||
function write_bits_16(buf, bl, v) {
|
||||
var w = bl & 7, h = bl >>> 3;
|
||||
v <<= w;
|
||||
buf[h] |= v & 0xFF; v >>>= 8;
|
||||
buf[h+1] = v & 0xFF;
|
||||
buf[h+2] = v >>> 8;
|
||||
return bl + 16;
|
||||
}
|
||||
|
||||
/* until ArrayBuffer#realloc is a thing, fake a realloc */
|
||||
function realloc(b, sz/*:number*/) {
|
||||
var L = b.length, M = 2*L > sz ? 2*L : sz + 5, i = 0;
|
||||
@ -933,7 +1000,7 @@ function realloc(b, sz/*:number*/) {
|
||||
} else if(use_typed_arrays) {
|
||||
var a = new Uint8Array(M);
|
||||
if(a.set) a.set(b);
|
||||
else for(; i < b.length; ++i) a[i] = b[i];
|
||||
else for(; i < L; ++i) a[i] = b[i];
|
||||
return a;
|
||||
}
|
||||
b.length = M;
|
||||
@ -945,30 +1012,7 @@ function zero_fill_array(n) {
|
||||
var o = new Array(n);
|
||||
for(var i = 0; i < n; ++i) o[i] = 0;
|
||||
return o;
|
||||
}var _deflate = (function() {
|
||||
var _deflateRaw = (function() {
|
||||
return function deflateRaw(data, out) {
|
||||
var boff = 0;
|
||||
while(boff < data.length) {
|
||||
var L = Math.min(0xFFFF, data.length - boff);
|
||||
var h = boff + L == data.length;
|
||||
/* TODO: this is only type 0 stored */
|
||||
out.write_shift(1, +h);
|
||||
out.write_shift(2, L);
|
||||
out.write_shift(2, (~L) & 0xFFFF);
|
||||
while(L-- > 0) out[out.l++] = data[boff++];
|
||||
}
|
||||
return out.l;
|
||||
};
|
||||
})();
|
||||
|
||||
return function(data) {
|
||||
var buf = new_buf(50+Math.floor(data.length*1.1));
|
||||
var off = _deflateRaw(data, buf);
|
||||
return buf.slice(0, off);
|
||||
};
|
||||
})();
|
||||
/* modified inflate function also moves original read head */
|
||||
}
|
||||
|
||||
/* build tree (used for literals and lengths) */
|
||||
function build_tree(clens, cmap, MAX/*:number*/)/*:number*/ {
|
||||
@ -1008,6 +1052,7 @@ function build_tree(clens, cmap, MAX/*:number*/)/*:number*/ {
|
||||
return maxlen;
|
||||
}
|
||||
|
||||
/* Fixed Huffman */
|
||||
var fix_lmap = use_typed_arrays ? new Uint16Array(512) : zero_fill_array(512);
|
||||
var fix_dmap = use_typed_arrays ? new Uint16Array(32) : zero_fill_array(32);
|
||||
if(!use_typed_arrays) {
|
||||
@ -1027,8 +1072,125 @@ if(!use_typed_arrays) {
|
||||
for(; i<=279; i++) clens.push(7);
|
||||
for(; i<=287; i++) clens.push(8);
|
||||
build_tree(clens, fix_lmap, 288);
|
||||
})();var _deflateRaw = (function _deflateRawIIFE() {
|
||||
var DST_LN_RE = use_typed_arrays ? new Uint8Array(0x8000) : [];
|
||||
var j = 0, k = 0;
|
||||
for(; j < DST_LN.length - 1; ++j) {
|
||||
for(; k < DST_LN[j+1]; ++k) DST_LN_RE[k] = j;
|
||||
}
|
||||
for(;k < 32768; ++k) DST_LN_RE[k] = 29;
|
||||
|
||||
var LEN_LN_RE = use_typed_arrays ? new Uint8Array(0x103) : [];
|
||||
for(j = 0, k = 0; j < LEN_LN.length - 1; ++j) {
|
||||
for(; k < LEN_LN[j+1]; ++k) LEN_LN_RE[k] = j;
|
||||
}
|
||||
|
||||
function write_stored(data, out) {
|
||||
var boff = 0;
|
||||
while(boff < data.length) {
|
||||
var L = Math.min(0xFFFF, data.length - boff);
|
||||
var h = boff + L == data.length;
|
||||
out.write_shift(1, +h);
|
||||
out.write_shift(2, L);
|
||||
out.write_shift(2, (~L) & 0xFFFF);
|
||||
while(L-- > 0) out[out.l++] = data[boff++];
|
||||
}
|
||||
return out.l;
|
||||
}
|
||||
|
||||
/* Fixed Huffman */
|
||||
function write_huff_fixed(data, out) {
|
||||
var bl = 0;
|
||||
var boff = 0;
|
||||
var addrs = use_typed_arrays ? new Uint16Array(0x8000) : [];
|
||||
while(boff < data.length) {
|
||||
var L = /* data.length - boff; */ Math.min(0xFFFF, data.length - boff);
|
||||
|
||||
/* write a stored block for short data */
|
||||
if(L < 10) {
|
||||
bl = write_bits_3(out, bl, +!!(boff + L == data.length)); // jshint ignore:line
|
||||
if(bl & 7) bl += 8 - (bl & 7);
|
||||
out.l = (bl / 8) | 0;
|
||||
out.write_shift(2, L);
|
||||
out.write_shift(2, (~L) & 0xFFFF);
|
||||
while(L-- > 0) out[out.l++] = data[boff++];
|
||||
bl = out.l * 8;
|
||||
continue;
|
||||
}
|
||||
|
||||
bl = write_bits_3(out, bl, +!!(boff + L == data.length) + 2); // jshint ignore:line
|
||||
var hash = 0;
|
||||
while(L-- > 0) {
|
||||
var d = data[boff];
|
||||
hash = ((hash << 5) ^ d) & 0x7FFF;
|
||||
|
||||
var match = -1, mlen = 0;
|
||||
|
||||
if((match = addrs[hash])) {
|
||||
match |= boff & ~0x7FFF;
|
||||
if(match > boff) match -= 0x8000;
|
||||
if(match < boff) while(data[match + mlen] == data[boff + mlen] && mlen < 250) ++mlen;
|
||||
}
|
||||
|
||||
if(mlen > 2) {
|
||||
/* Copy Token */
|
||||
d = LEN_LN_RE[mlen];
|
||||
if(d <= 22) bl = write_bits_8(out, bl, bitswap8[d+1]>>1) - 1;
|
||||
else {
|
||||
write_bits_8(out, bl, 3);
|
||||
bl += 5;
|
||||
write_bits_8(out, bl, bitswap8[d-23]>>5);
|
||||
bl += 3;
|
||||
}
|
||||
var len_eb = (d < 8) ? 0 : ((d - 4)>>2);
|
||||
if(len_eb > 0) {
|
||||
write_bits_16(out, bl, mlen - LEN_LN[d]);
|
||||
bl += len_eb;
|
||||
}
|
||||
|
||||
d = DST_LN_RE[boff - match];
|
||||
bl = write_bits_8(out, bl, bitswap8[d]>>3);
|
||||
bl -= 3;
|
||||
|
||||
var dst_eb = d < 4 ? 0 : (d-2)>>1;
|
||||
if(dst_eb > 0) {
|
||||
write_bits_16(out, bl, boff - match - DST_LN[d]);
|
||||
bl += dst_eb;
|
||||
}
|
||||
for(var q = 0; q < mlen; ++q) {
|
||||
addrs[hash] = boff & 0x7FFF;
|
||||
hash = ((hash << 5) ^ data[boff]) & 0x7FFF;
|
||||
++boff;
|
||||
}
|
||||
L-= mlen - 1;
|
||||
} else {
|
||||
/* Literal Token */
|
||||
if(d <= 143) d = d + 48;
|
||||
else bl = write_bits_1(out, bl, 1);
|
||||
bl = write_bits_8(out, bl, bitswap8[d]);
|
||||
addrs[hash] = boff & 0x7FFF;
|
||||
++boff;
|
||||
}
|
||||
}
|
||||
|
||||
bl = write_bits_8(out, bl, 0) - 1;
|
||||
}
|
||||
out.l = ((bl + 7)/8)|0;
|
||||
return out.l;
|
||||
}
|
||||
return function _deflateRaw(data, out) {
|
||||
if(data.length < 8) return write_stored(data, out);
|
||||
return write_huff_fixed(data, out);
|
||||
};
|
||||
})();
|
||||
|
||||
function _deflate(data) {
|
||||
var buf = new_buf(50+Math.floor(data.length*1.1));
|
||||
var off = _deflateRaw(data, buf);
|
||||
return buf.slice(0, off);
|
||||
}
|
||||
/* modified inflate function also moves original read head */
|
||||
|
||||
var dyn_lmap = use_typed_arrays ? new Uint16Array(32768) : zero_fill_array(32768);
|
||||
var dyn_dmap = use_typed_arrays ? new Uint16Array(32768) : zero_fill_array(32768);
|
||||
var dyn_cmap = use_typed_arrays ? new Uint16Array(128) : zero_fill_array(128);
|
||||
@ -1132,14 +1294,12 @@ function inflate(data, usz/*:number*/) {
|
||||
var sz = data[boff>>>3] | data[(boff>>>3)+1]<<8;
|
||||
boff += 32;
|
||||
/* push sz bytes */
|
||||
if(!usz && OL < woff + sz) { outbuf = realloc(outbuf, woff + sz); OL = outbuf.length; }
|
||||
if(typeof data.copy === 'function') {
|
||||
// $FlowIgnore
|
||||
data.copy(outbuf, woff, boff>>>3, (boff>>>3)+sz);
|
||||
woff += sz; boff += 8*sz;
|
||||
} else while(sz-- > 0) { outbuf[woff++] = data[boff>>>3]; boff += 8; }
|
||||
if(sz > 0) {
|
||||
if(!usz && OL < woff + sz) { outbuf = realloc(outbuf, woff + sz); OL = outbuf.length; }
|
||||
while(sz-- > 0) { outbuf[woff++] = data[boff>>>3]; boff += 8; }
|
||||
}
|
||||
continue;
|
||||
} else if((header >>> 1) == 1) {
|
||||
} else if((header >> 1) == 1) {
|
||||
/* Fixed Huffman */
|
||||
max_len_1 = 9; max_len_2 = 5;
|
||||
} else {
|
||||
@ -1147,8 +1307,8 @@ function inflate(data, usz/*:number*/) {
|
||||
boff = dyn(data, boff);
|
||||
max_len_1 = dyn_len_1; max_len_2 = dyn_len_2;
|
||||
}
|
||||
if(!usz && (OL < woff + 32767)) { outbuf = realloc(outbuf, woff + 32767); OL = outbuf.length; }
|
||||
for(;;) { // while(true) is apparently out of vogue in modern JS circles
|
||||
if(!usz && (OL < woff + 32767)) { outbuf = realloc(outbuf, woff + 32767); OL = outbuf.length; }
|
||||
/* ingest code and move read head */
|
||||
var bits = read_bits_n(data, boff, max_len_1);
|
||||
var code = (header>>>1) == 1 ? fix_lmap[bits] : dyn_lmap[bits];
|
||||
@ -1179,12 +1339,13 @@ function inflate(data, usz/*:number*/) {
|
||||
}
|
||||
|
||||
/* in the common case, manual byte copy is faster than TA set / Buffer copy */
|
||||
if(!usz && OL < tgt) { outbuf = realloc(outbuf, tgt); OL = outbuf.length; }
|
||||
if(!usz && OL < tgt) { outbuf = realloc(outbuf, tgt + 100); OL = outbuf.length; }
|
||||
while(woff < tgt) { outbuf[woff] = outbuf[woff - dst]; ++woff; }
|
||||
}
|
||||
}
|
||||
}
|
||||
return [usz ? outbuf : outbuf.slice(0, woff), (boff+7)>>>3];
|
||||
if(usz) return [outbuf, (boff+7)>>>3];
|
||||
return [outbuf.slice(0, woff), (boff+7)>>>3];
|
||||
}
|
||||
|
||||
function _inflate(payload, usz) {
|
||||
@ -1242,7 +1403,6 @@ function parse_zip(file/*:RawBytes*/, options/*:CFBReadOpts*/)/*:CFBContainer*/
|
||||
parse_local_file(blob, csz, usz, o, EF);
|
||||
blob.l = L;
|
||||
}
|
||||
|
||||
return o;
|
||||
}
|
||||
|
||||
@ -1278,7 +1438,7 @@ function parse_local_file(blob/*:CFBlob*/, csz/*:number*/, usz/*:number*/, o/*:C
|
||||
var data = blob.slice(blob.l, blob.l + _csz);
|
||||
switch(meth) {
|
||||
case 8: data = _inflateRawSync(blob, _usz); break;
|
||||
case 0: break;
|
||||
case 0: break; // TODO: scan for magic number
|
||||
default: throw new Error("Unsupported ZIP Compression method " + meth);
|
||||
}
|
||||
|
||||
@ -1293,8 +1453,8 @@ function parse_local_file(blob/*:CFBlob*/, csz/*:number*/, usz/*:number*/, o/*:C
|
||||
|
||||
if(_csz != csz) warn_or_throw(wrn, "Bad compressed size: " + csz + " != " + _csz);
|
||||
if(_usz != usz) warn_or_throw(wrn, "Bad uncompressed size: " + usz + " != " + _usz);
|
||||
var _crc32 = CRC32.buf(data, 0);
|
||||
if((crc32>>0) != (_crc32>>0)) warn_or_throw(wrn, "Bad CRC32 checksum: " + crc32 + " != " + _crc32);
|
||||
//var _crc32 = CRC32.buf(data, 0);
|
||||
//if((crc32>>0) != (_crc32>>0)) warn_or_throw(wrn, "Bad CRC32 checksum: " + crc32 + " != " + _crc32);
|
||||
cfb_add(o, name, data, {unsafe: true, mt: date});
|
||||
}
|
||||
function write_zip(cfb/*:CFBContainer*/, options/*:CFBWriteOpts*/)/*:RawBytes*/ {
|
||||
@ -1345,7 +1505,10 @@ function write_zip(cfb/*:CFBContainer*/, options/*:CFBWriteOpts*/)/*:RawBytes*/
|
||||
start_cd += namebuf.length;
|
||||
out.push(namebuf);
|
||||
|
||||
/* TODO: extra fields? */
|
||||
|
||||
/* TODO: encryption header ? */
|
||||
|
||||
start_cd += outbuf.length;
|
||||
out.push(outbuf);
|
||||
|
||||
@ -1399,6 +1562,212 @@ function write_zip(cfb/*:CFBContainer*/, options/*:CFBWriteOpts*/)/*:RawBytes*/
|
||||
|
||||
return bconcat(([bconcat((out/*:any*/)), bconcat(cdirs), o]/*:any*/));
|
||||
}
|
||||
var ContentTypeMap = ({
|
||||
"htm": "text/html",
|
||||
"xml": "text/xml",
|
||||
|
||||
"gif": "image/gif",
|
||||
"jpg": "image/jpeg",
|
||||
"png": "image/png",
|
||||
|
||||
"mso": "application/x-mso",
|
||||
"thmx": "application/vnd.ms-officetheme",
|
||||
"sh33tj5": "application/octet-stream"
|
||||
}/*:any*/);
|
||||
|
||||
function get_content_type(fi/*:CFBEntry*/, fp/*:string*/)/*:string*/ {
|
||||
if(fi.ctype) return fi.ctype;
|
||||
|
||||
var ext = fi.name || "", m = ext.match(/\.([^\.]+)$/);
|
||||
if(m && ContentTypeMap[m[1]]) return ContentTypeMap[m[1]];
|
||||
|
||||
if(fp) {
|
||||
m = (ext = fp).match(/[\.\\]([^\.\\])+$/);
|
||||
if(m && ContentTypeMap[m[1]]) return ContentTypeMap[m[1]];
|
||||
}
|
||||
|
||||
return "application/octet-stream";
|
||||
}
|
||||
|
||||
/* 76 character chunks TODO: intertwine encoding */
|
||||
function write_base64_76(bstr/*:string*/)/*:string*/ {
|
||||
var data = Base64.encode(bstr);
|
||||
var o = [];
|
||||
for(var i = 0; i < data.length; i+= 76) o.push(data.slice(i, i+76));
|
||||
return o.join("\r\n") + "\r\n";
|
||||
}
|
||||
|
||||
/*
|
||||
Rules for QP:
|
||||
- escape =## applies for all non-display characters and literal "="
|
||||
- space or tab at end of line must be encoded
|
||||
- \r\n newlines can be preserved, but bare \r and \n must be escaped
|
||||
- lines must not exceed 76 characters, use soft breaks =\r\n
|
||||
|
||||
TODO: Some files from word appear to write line extensions with bare equals:
|
||||
|
||||
```
|
||||
<table class=3DMsoTableGrid border=3D1 cellspacing=3D0 cellpadding=3D0 width=
|
||||
="70%"
|
||||
```
|
||||
*/
|
||||
function write_quoted_printable(text/*:string*/)/*:string*/ {
|
||||
var encoded = text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7E-\xFF=]/g, function(c) {
|
||||
var w = c.charCodeAt(0).toString(16).toUpperCase();
|
||||
return "=" + (w.length == 1 ? "0" + w : w);
|
||||
});
|
||||
|
||||
encoded = encoded.replace(/ $/mg, "=20").replace(/\t$/mg, "=09");
|
||||
|
||||
if(encoded.charAt(0) == "\n") encoded = "=0D" + encoded.slice(1);
|
||||
encoded = encoded.replace(/\r(?!\n)/mg, "=0D").replace(/\n\n/mg, "\n=0A").replace(/([^\r\n])\n/mg, "$1=0A");
|
||||
|
||||
var o/*:Array<string>*/ = [], split = encoded.split("\r\n");
|
||||
for(var si = 0; si < split.length; ++si) {
|
||||
var str = split[si];
|
||||
if(str.length == 0) { o.push(""); continue; }
|
||||
for(var i = 0; i < str.length;) {
|
||||
var end = 76;
|
||||
var tmp = str.slice(i, i + end);
|
||||
if(tmp.charAt(end - 1) == "=") end --;
|
||||
else if(tmp.charAt(end - 2) == "=") end -= 2;
|
||||
else if(tmp.charAt(end - 3) == "=") end -= 3;
|
||||
tmp = str.slice(i, i + end);
|
||||
i += end;
|
||||
if(i < str.length) tmp += "=";
|
||||
o.push(tmp);
|
||||
}
|
||||
}
|
||||
|
||||
return o.join("\r\n");
|
||||
}
|
||||
function parse_quoted_printable(data/*:Array<string>*/)/*:RawBytes*/ {
|
||||
var o = [];
|
||||
|
||||
/* unify long lines */
|
||||
for(var di = 0; di < data.length; ++di) {
|
||||
var line = data[di];
|
||||
while(di <= data.length && line.charAt(line.length - 1) == "=") line = line.slice(0, line.length - 1) + data[++di];
|
||||
o.push(line);
|
||||
}
|
||||
|
||||
/* decode */
|
||||
for(var oi = 0; oi < o.length; ++oi) o[oi] = o[oi].replace(/[=][0-9A-Fa-f]{2}/g, function($$) { return String.fromCharCode(parseInt($$.slice(1), 16)); });
|
||||
return s2a(o.join("\r\n"));
|
||||
}
|
||||
|
||||
|
||||
function parse_mime(cfb/*:CFBContainer*/, data/*:Array<string>*/, root/*:string*/)/*:void*/ {
|
||||
var fname = "", cte = "", ctype = "", fdata;
|
||||
var di = 0;
|
||||
for(;di < 10; ++di) {
|
||||
var line = data[di];
|
||||
if(!line || line.match(/^\s*$/)) break;
|
||||
var m = line.match(/^(.*?):\s*([^\s].*)$/);
|
||||
if(m) switch(m[1].toLowerCase()) {
|
||||
case "content-location": fname = m[2].trim(); break;
|
||||
case "content-type": ctype = m[2].trim(); break;
|
||||
case "content-transfer-encoding": cte = m[2].trim(); break;
|
||||
}
|
||||
}
|
||||
++di;
|
||||
switch(cte.toLowerCase()) {
|
||||
case 'base64': fdata = s2a(Base64.decode(data.slice(di).join(""))); break;
|
||||
case 'quoted-printable': fdata = parse_quoted_printable(data.slice(di)); break;
|
||||
default: throw new Error("Unsupported Content-Transfer-Encoding " + cte);
|
||||
}
|
||||
var file = cfb_add(cfb, fname.slice(root.length), fdata, {unsafe: true});
|
||||
if(ctype) file.ctype = ctype;
|
||||
}
|
||||
|
||||
function parse_mad(file/*:RawBytes*/, options/*:CFBReadOpts*/)/*:CFBContainer*/ {
|
||||
if(a2s(file.slice(0,13)).toLowerCase() != "mime-version:") throw new Error("Unsupported MAD header");
|
||||
var root = (options && options.root || "");
|
||||
// $FlowIgnore
|
||||
var data = (has_buf && Buffer.isBuffer(file) ? file.toString("binary") : a2s(file)).split("\r\n");
|
||||
var di = 0, row = "";
|
||||
|
||||
/* if root is not specified, scan for the common prefix */
|
||||
for(di = 0; di < data.length; ++di) {
|
||||
row = data[di];
|
||||
if(!/^Content-Location:/i.test(row)) continue;
|
||||
row = row.slice(row.indexOf("file"));
|
||||
if(!root) root = row.slice(0, row.lastIndexOf("/") + 1);
|
||||
if(row.slice(0, root.length) == root) continue;
|
||||
while(root.length > 0) {
|
||||
root = root.slice(0, root.length - 1);
|
||||
root = root.slice(0, root.lastIndexOf("/") + 1);
|
||||
if(row.slice(0,root.length) == root) break;
|
||||
}
|
||||
}
|
||||
|
||||
var mboundary = (data[1] || "").match(/boundary="(.*?)"/);
|
||||
if(!mboundary) throw new Error("MAD cannot find boundary");
|
||||
var boundary = "--" + (mboundary[1] || "");
|
||||
|
||||
var FileIndex/*:CFBFileIndex*/ = [], FullPaths/*:Array<string>*/ = [];
|
||||
var o = {
|
||||
FileIndex: FileIndex,
|
||||
FullPaths: FullPaths
|
||||
};
|
||||
init_cfb(o);
|
||||
var start_di, fcnt = 0;
|
||||
for(di = 0; di < data.length; ++di) {
|
||||
var line = data[di];
|
||||
if(line !== boundary && line !== boundary + "--") continue;
|
||||
if(fcnt++) parse_mime(o, data.slice(start_di, di), root);
|
||||
start_di = di;
|
||||
}
|
||||
return o;
|
||||
}
|
||||
|
||||
function write_mad(cfb/*:CFBContainer*/, options/*:CFBWriteOpts*/)/*:string*/ {
|
||||
var opts = options || {};
|
||||
var boundary = opts.boundary || "SheetJS";
|
||||
boundary = '------=' + boundary;
|
||||
|
||||
var out = [
|
||||
'MIME-Version: 1.0',
|
||||
'Content-Type: multipart/related; boundary="' + boundary.slice(2) + '"',
|
||||
'',
|
||||
'',
|
||||
''
|
||||
];
|
||||
|
||||
var root = cfb.FullPaths[0], fp = root, fi = cfb.FileIndex[0];
|
||||
for(var i = 1; i < cfb.FullPaths.length; ++i) {
|
||||
fp = cfb.FullPaths[i].slice(root.length);
|
||||
fi = cfb.FileIndex[i];
|
||||
if(!fi.size || !fi.content || fp == "\u0001Sh33tJ5") continue;
|
||||
|
||||
/* Normalize filename */
|
||||
fp = fp.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7E-\xFF]/g, function(c) {
|
||||
return "_x" + c.charCodeAt(0).toString(16) + "_";
|
||||
}).replace(/[\u0080-\uFFFF]/g, function(u) {
|
||||
return "_u" + u.charCodeAt(0).toString(16) + "_";
|
||||
});
|
||||
|
||||
/* Extract content as binary string */
|
||||
var ca = fi.content;
|
||||
// $FlowIgnore
|
||||
var cstr = has_buf && Buffer.isBuffer(ca) ? ca.toString("binary") : a2s(ca);
|
||||
|
||||
/* 4/5 of first 1024 chars ascii -> quoted printable, else base64 */
|
||||
var dispcnt = 0, L = Math.min(1024, cstr.length), cc = 0;
|
||||
for(var csl = 0; csl <= L; ++csl) if((cc=cstr.charCodeAt(csl)) >= 0x20 && cc < 0x80) ++dispcnt;
|
||||
var qp = dispcnt >= L * 4 / 5;
|
||||
|
||||
out.push(boundary);
|
||||
out.push('Content-Location: ' + (opts.root || 'file:///C:/SheetJS/') + fp);
|
||||
out.push('Content-Transfer-Encoding: ' + (qp ? 'quoted-printable' : 'base64'));
|
||||
out.push('Content-Type: ' + get_content_type(fi, fp));
|
||||
out.push('');
|
||||
|
||||
out.push(qp ? write_quoted_printable(cstr) : write_base64_76(cstr));
|
||||
}
|
||||
out.push(boundary + '--\r\n');
|
||||
return out.join("\r\n");
|
||||
}
|
||||
function cfb_new(opts/*:?any*/)/*:CFBContainer*/ {
|
||||
var o/*:CFBContainer*/ = ({}/*:any*/);
|
||||
init_cfb(o, opts);
|
||||
|
@ -101,10 +101,18 @@ function parseDate(str/*:string|Date*/, fixdate/*:?number*/)/*:Date*/ {
|
||||
return out;
|
||||
}
|
||||
|
||||
function cc2str(arr/*:Array<number>*/)/*:string*/ {
|
||||
var o = "";
|
||||
for(var i = 0; i != arr.length; ++i) o += String.fromCharCode(arr[i]);
|
||||
return o;
|
||||
function cc2str(arr/*:Array<number>*/, debomit)/*:string*/ {
|
||||
if(has_buf && Buffer.isBuffer(arr)) {
|
||||
if(debomit) {
|
||||
if(arr[0] == 0xFF && arr[1] == 0xFE) return arr.slice(2).toString("utf16le");
|
||||
if(arr[1] == 0xFE && arr[2] == 0xFF) return utf16beread(arr.slice(2).toString("binary"));
|
||||
}
|
||||
return arr.toString("binary");
|
||||
}
|
||||
/* TODO: investigate performance degradation of TextEncoder in Edge 13 */
|
||||
var o = [];
|
||||
for(var i = 0; i != arr.length; ++i) o.push(String.fromCharCode(arr[i]));
|
||||
return o.join("");
|
||||
}
|
||||
|
||||
function dup(o/*:any*/)/*:any*/ {
|
||||
|
@ -1,10 +1,10 @@
|
||||
function getdatastr(data)/*:?string*/ {
|
||||
if(!data) return null;
|
||||
if(data.content && data.type) return cc2str(data.content, true);
|
||||
if(data.data) return debom(data.data);
|
||||
if(data.asNodeBuffer && has_buf) return debom(data.asNodeBuffer().toString('binary'));
|
||||
if(data.asBinary) return debom(data.asBinary());
|
||||
if(data._data && data._data.getContent) return debom(cc2str(Array.prototype.slice.call(data._data.getContent(),0)));
|
||||
if(data.content && data.type) return debom(cc2str(data.content));
|
||||
return null;
|
||||
}
|
||||
|
||||
@ -66,40 +66,29 @@ function zipentries(zip) {
|
||||
}
|
||||
|
||||
function zip_add_file(zip, path, content) {
|
||||
if(zip.FullPaths) CFB.utils.cfb_add(zip, path, content);
|
||||
if(zip.FullPaths) {
|
||||
if(typeof content == "string") {
|
||||
var res;
|
||||
if(has_buf) res = Buffer_from(content);
|
||||
/* TODO: investigate performance in Edge 13 */
|
||||
//else if(typeof TextEncoder !== "undefined") res = new TextEncoder().encode(content);
|
||||
else res = utf8decode(content);
|
||||
return CFB.utils.cfb_add(zip, path, res);
|
||||
}
|
||||
CFB.utils.cfb_add(zip, path, content);
|
||||
}
|
||||
else zip.file(path, content);
|
||||
}
|
||||
|
||||
var jszip;
|
||||
/*:: declare var JSZipSync:any; */
|
||||
/*global JSZipSync:true */
|
||||
if(typeof JSZipSync !== 'undefined') jszip = JSZipSync;
|
||||
if(typeof exports !== 'undefined') {
|
||||
if(typeof module !== 'undefined' && module.exports) {
|
||||
if(typeof jszip === 'undefined') jszip = require('./jszip.js');
|
||||
}
|
||||
}
|
||||
|
||||
function zip_new() {
|
||||
if(!jszip) return CFB.utils.cfb_new();
|
||||
return new jszip();
|
||||
}
|
||||
function zip_new() { return CFB.utils.cfb_new(); }
|
||||
|
||||
function zip_read(d, o) {
|
||||
var zip;
|
||||
if(jszip) switch(o.type) {
|
||||
case "base64": zip = new jszip(d, { base64:true }); break;
|
||||
case "binary": case "array": zip = new jszip(d, { base64:false }); break;
|
||||
case "buffer": zip = new jszip(d); break;
|
||||
default: throw new Error("Unrecognized type " + o.type);
|
||||
switch(o.type) {
|
||||
case "base64": return CFB.read(d, { type: "base64" });
|
||||
case "binary": return CFB.read(d, { type: "binary" });
|
||||
case "buffer": case "array": return CFB.read(d, { type: "buffer" });
|
||||
}
|
||||
else switch(o.type) {
|
||||
case "base64": zip = CFB.read(d, { type: "base64" }); break;
|
||||
case "binary": zip = CFB.read(d, { type: "binary" }); break;
|
||||
case "buffer": case "array": zip = CFB.read(d, { type: "buffer" }); break;
|
||||
default: throw new Error("Unrecognized type " + o.type);
|
||||
}
|
||||
return zip;
|
||||
throw new Error("Unrecognized type " + o.type);
|
||||
}
|
||||
|
||||
function resolve_path(path/*:string*/, base/*:string*/)/*:string*/ {
|
||||
|
@ -45,7 +45,7 @@ var __8lpp4 = function(b/*:RawBytes|CFBlob*/,i/*:number*/) { var len = __readUIn
|
||||
var ___8lpp4 = __8lpp4;
|
||||
var __double, ___double;
|
||||
__double = ___double = function(b/*:RawBytes|CFBlob*/, idx/*:number*/) { return read_double_le(b, idx);};
|
||||
var is_buf = function is_buf_a(a) { return Array.isArray(a); };
|
||||
var is_buf = function is_buf_a(a) { return Array.isArray(a) || (typeof Uint8Array !== "undefined" && a instanceof Uint8Array); };
|
||||
|
||||
if(has_buf/*:: && typeof Buffer !== 'undefined'*/) {
|
||||
__utf16le = function(b/*:RawBytes|CFBlob*/,s/*:number*/,e/*:number*/)/*:string*/ { if(!Buffer.isBuffer(b)/*:: || !(b instanceof Buffer)*/) return ___utf16le(b,s,e); return b.toString('utf16le',s,e).replace(chr0,'')/*.replace(chr1,'!')*/; };
|
||||
@ -56,10 +56,10 @@ if(has_buf/*:: && typeof Buffer !== 'undefined'*/) {
|
||||
__lpp4 = function lpp4_b(b/*:RawBytes|CFBlob*/, i/*:number*/) { if(!Buffer.isBuffer(b)/*:: || !(b instanceof Buffer)*/) return ___lpp4(b, i); var len = b.readUInt32LE(i); return b.toString('utf16le',i+4,i+4+len);};
|
||||
__8lpp4 = function lpp4_8b(b/*:RawBytes|CFBlob*/, i/*:number*/) { if(!Buffer.isBuffer(b)/*:: || !(b instanceof Buffer)*/) return ___8lpp4(b, i); var len = b.readUInt32LE(i); return b.toString('utf8',i+4,i+4+len);};
|
||||
__utf8 = function utf8_b(b/*:RawBytes|CFBlob*/, s/*:number*/, e/*:number*/) { return (Buffer.isBuffer(b)/*:: && (b instanceof Buffer)*/) ? b.toString('utf8',s,e) : ___utf8(b,s,e); };
|
||||
__toBuffer = function(bufs) { return (bufs[0].length > 0 && Buffer.isBuffer(bufs[0][0])) ? Buffer.concat(bufs[0]) : ___toBuffer(bufs);};
|
||||
bconcat = function(bufs) { return Buffer.isBuffer(bufs[0]) ? Buffer.concat(bufs) : [].concat.apply([], bufs); };
|
||||
__toBuffer = function(bufs) { return (bufs[0].length > 0 && Buffer.isBuffer(bufs[0][0])) ? Buffer.concat(bufs[0].map(function(x) { return Buffer.isBuffer(x) ? x : Buffer_from(x); })) : ___toBuffer(bufs);};
|
||||
bconcat = function(bufs) { return Buffer.concat(bufs.map(function(buf) { return Buffer.isBuffer(buf) ? buf : Buffer_from(buf); })); };
|
||||
__double = function double_(b/*:RawBytes|CFBlob*/, i/*:number*/) { if(Buffer.isBuffer(b)/*::&& b instanceof Buffer*/) return b.readDoubleLE(i); return ___double(b,i); };
|
||||
is_buf = function is_buf_b(a) { return Buffer.isBuffer(a) || Array.isArray(a); };
|
||||
is_buf = function is_buf_b(a) { return Buffer.isBuffer(a) || Array.isArray(a) || (typeof Uint8Array !== "undefined" && a instanceof Uint8Array); };
|
||||
}
|
||||
|
||||
/* from js-xls */
|
||||
|
@ -44,7 +44,7 @@ function buf_array()/*:BufArray*/ {
|
||||
|
||||
var end = function ba_end() {
|
||||
endbuf();
|
||||
return __toBuffer([bufs]);
|
||||
return bconcat(bufs);
|
||||
};
|
||||
|
||||
var push = function ba_push(buf) { endbuf(); curbuf = buf; if(curbuf.l == null) curbuf.l = curbuf.length; next(blksz); };
|
||||
|
@ -350,7 +350,7 @@ function write_biff8_global(wb/*:Workbook*/, bufs, opts/*:WriteOpts*/) {
|
||||
if(a.length) out.push(a);
|
||||
if(b.length) out.push(b);
|
||||
if(c.length) out.push(c);
|
||||
return __toBuffer([out]);
|
||||
return bconcat(out);
|
||||
}
|
||||
|
||||
/* [MS-XLS] 2.1.7.20 Workbook Stream */
|
||||
@ -378,7 +378,7 @@ function write_biff8_buf(wb/*:Workbook*/, opts/*:WriteOpts*/) {
|
||||
|
||||
for(var i = 0; i < wb.SheetNames.length; ++i) bufs[bufs.length] = write_ws_biff8(i, o, wb);
|
||||
bufs.unshift(write_biff8_global(wb, bufs, o));
|
||||
return __toBuffer([bufs]);
|
||||
return bconcat(bufs);
|
||||
}
|
||||
|
||||
function write_biff_buf(wb/*:Workbook*/, opts/*:WriteOpts*/) {
|
||||
|
@ -1,4 +1,4 @@
|
||||
var NUMBERS = (function() {
|
||||
var NUMBERS = !Object.defineProperty ? (void 0) :(function() {
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
|
@ -1,7 +1,7 @@
|
||||
{
|
||||
"name": "js-xlsx",
|
||||
"homepage": "https://github.com/SheetJS/js-xlsx",
|
||||
"main": ["jszip.js", "xlsx.js"],
|
||||
"main": ["xlsx.js"],
|
||||
"ignore": [
|
||||
"bin",
|
||||
"bits",
|
||||
|
32
dist/xlsx.core.min.js
generated
vendored
32
dist/xlsx.core.min.js
generated
vendored
File diff suppressed because one or more lines are too long
2
dist/xlsx.core.min.map
generated
vendored
2
dist/xlsx.core.min.map
generated
vendored
File diff suppressed because one or more lines are too long
12374
dist/xlsx.extendscript.js
generated
vendored
12374
dist/xlsx.extendscript.js
generated
vendored
File diff suppressed because it is too large
Load Diff
44
dist/xlsx.full.min.js
generated
vendored
44
dist/xlsx.full.min.js
generated
vendored
File diff suppressed because one or more lines are too long
2
dist/xlsx.full.min.map
generated
vendored
2
dist/xlsx.full.min.map
generated
vendored
File diff suppressed because one or more lines are too long
3373
dist/xlsx.js
generated
vendored
3373
dist/xlsx.js
generated
vendored
File diff suppressed because it is too large
Load Diff
29
dist/xlsx.min.js
generated
vendored
29
dist/xlsx.min.js
generated
vendored
File diff suppressed because one or more lines are too long
2
dist/xlsx.min.map
generated
vendored
2
dist/xlsx.min.map
generated
vendored
File diff suppressed because one or more lines are too long
16
dist/xlsx.mini.min.js
generated
vendored
16
dist/xlsx.mini.min.js
generated
vendored
File diff suppressed because one or more lines are too long
2
dist/xlsx.mini.min.map
generated
vendored
2
dist/xlsx.mini.min.map
generated
vendored
File diff suppressed because one or more lines are too long
@ -48,7 +48,6 @@ Use Web Workers: (when available) <input type="checkbox" name="useworker" checke
|
||||
<!-- uncomment the next line here and in xlsxworker.js for encoding support -->
|
||||
<script src="dist/cpexcel.js"></script>
|
||||
<script src="shim.js"></script>
|
||||
<script src="jszip.js"></script>
|
||||
<script src="xlsx.js"></script>
|
||||
<script>
|
||||
/*jshint browser:true */
|
||||
|
@ -64,8 +64,6 @@ function zip_add_file(zip, path, content) {
|
||||
else zip.file(path, content);
|
||||
}
|
||||
|
||||
var jszip;
|
||||
|
||||
function zip_new() {
|
||||
return CFB.utils.cfb_new();
|
||||
}
|
||||
|
@ -5,7 +5,6 @@ declare module 'xlsx' { declare module.exports:XLSXModule; };
|
||||
declare module '../' { declare module.exports:XLSXModule; };
|
||||
|
||||
declare module 'commander' { declare module.exports:any; };
|
||||
declare module './jszip.js' { declare module.exports:any; };
|
||||
declare module './dist/cpexcel.js' { declare module.exports:any; };
|
||||
declare module 'crypto' { declare module.exports:any; };
|
||||
declare module 'fs' { declare module.exports:any; };
|
||||
|
@ -1,2 +1 @@
|
||||
var DO_NOT_EXPORT_CODEPAGE = true;
|
||||
var DO_NOT_EXPORT_JSZIP = true;
|
||||
|
@ -1,4 +1,4 @@
|
||||