Lines Matching refs:blob
1557 function parse_extra_field(blob/*:CFBlob*/)/*:any*/ { argument
1558 prep_blob(blob, 0);
1561 while(blob.l <= blob.length - 4) {
1562 var type = blob.read_shift(2);
1563 var sz = blob.read_shift(2), tgt = blob.l + sz;
1568 flags = blob.read_shift(1);
1569 if(flags & 1) p.mtime = blob.read_shift(4);
1572 if(flags & 2) p.atime = blob.read_shift(4);
1573 if(flags & 4) p.ctime = blob.read_shift(4);
1579 var sz1 = blob.read_shift(4), sz2 = blob.read_shift(4);
1581 sz1 = blob.read_shift(4); sz2 = blob.read_shift(4);
1586 blob.l = tgt;
1608 var blob/*:CFBlob*/ = /*::(*/file.slice(0,512)/*:: :any)*/;
1609 prep_blob(blob, 0);
1612 var mv = check_get_mver(blob);
1622 if(ssz !== 512) { blob = /*::(*/file.slice(0,ssz)/*:: :any)*/; prep_blob(blob, 28 /* blob.l */); }
1626 check_shifts(blob, mver);
1629 var dir_cnt/*:number*/ = blob.read_shift(4, 'i');
1633 blob.l += 4;
1636 dir_start = blob.read_shift(4, 'i');
1639 blob.l += 4;
1642 blob.chk('00100000', 'Mini Stream Cutoff Size: ');
1645 minifat_start = blob.read_shift(4, 'i');
1648 nmfs = blob.read_shift(4, 'i');
1651 difat_start = blob.read_shift(4, 'i');
1654 difat_sec_cnt = blob.read_shift(4, 'i');
1657 for(var q = -1, j = 0; j < 109; ++j) { /* 109 = (512 - blob.l)>>>2; */
1658 q = blob.read_shift(4, 'i');
1695 function check_get_mver(blob/*:CFBlob*/)/*:[number, number]*/ { argument
1696 if(blob[blob.l] == 0x50 && blob[blob.l + 1] == 0x4b) return [0, 0];
1698 blob.chk(HEADER_SIGNATURE, 'Header Signature: ');
1701 //blob.chk(HEADER_CLSID, 'CLSID: ');
1702 blob.l += 16;
1705 var mver/*:number*/ = blob.read_shift(2, 'u');
1707 return [blob.read_shift(2,'u'), mver];
1709 function check_shifts(blob/*:CFBlob*/, mver/*:number*/)/*:void*/ { argument
1713 //blob.chk('feff', 'Byte Order: '); // note: some writers put 0xffff
1714 blob.l += 2;
1717 switch((shift = blob.read_shift(2))) {
1724 blob.chk('0600', 'Mini Sector Shift: ');
1727 blob.chk('000000000000', 'Reserved: ');
1861 var blob/*:CFBlob*/ = /*::(*/sector.slice(i, i+128)/*:: :any)*/;
1862 prep_blob(blob, 64);
1863 namelen = blob.read_shift(2);
1864 name = __utf16le(blob,0,namelen-pl);
1868 type: blob.read_shift(1),
1869 color: blob.read_shift(1),
1870 L: blob.read_shift(4, 'i'),
1871 R: blob.read_shift(4, 'i'),
1872 C: blob.read_shift(4, 'i'),
1873 clsid: blob.read_shift(16),
1874 state: blob.read_shift(4, 'i'),
1878 …var ctime/*:number*/ = blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2) + blob.read_sh…
1879 if(ctime !== 0) o.ct = read_date(blob, blob.l-8);
1880 …var mtime/*:number*/ = blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2) + blob.read_sh…
1881 if(mtime !== 0) o.mt = read_date(blob, blob.l-8);
1882 o.start = blob.read_shift(4, 'i');
1883 o.size = blob.read_shift(4, 'i');
1907 function read_date(blob/*:RawBytes|CFBlob*/, offset/*:number*/)/*:Date*/ {
1908 …return new Date(( ( (__readUInt32LE(blob,offset+4)/1e7)*Math.pow(2,32)+__readUInt32LE(blob,offset)…
1916 function read(blob/*:RawBytes|string*/, options/*:CFBReadOpts*/) {
1919 if(has_buf && Buffer.isBuffer(blob)) type = "buffer";
1922 …case "file": /*:: if(typeof blob !== 'string') throw "Must pass a filename when type='file'"; */re…
1923 …/*:: if(typeof blob !== 'string') throw "Must pass a base64-encoded binary string when type='file'…
1924 …ase "binary": /*:: if(typeof blob !== 'string') throw "Must pass a binary string when type='file'"…
1926 return parse(/*::typeof blob == 'string' ? new Buffer(blob, 'utf-8') : */blob, options);
2734 var blob/*:CFBlob*/ = /*::(*/file/*:: :any)*/;
2735 prep_blob(blob, 0);
2745 var i = blob.length - 4;
2746 …while((blob[i] != 0x50 || blob[i+1] != 0x4b || blob[i+2] != 0x05 || blob[i+3] != 0x06) && i >= 0) …
2747 blob.l = i + 4;
2750 blob.l += 4;
2751 var fcnt = blob.read_shift(2);
2752 blob.l += 6;
2753 var start_cd = blob.read_shift(4);
2756 blob.l = start_cd;
2760 blob.l += 20;
2761 var csz = blob.read_shift(4);
2762 var usz = blob.read_shift(4);
2763 var namelen = blob.read_shift(2);
2764 var efsz = blob.read_shift(2);
2765 var fcsz = blob.read_shift(2);
2766 blob.l += 8;
2767 var offset = blob.read_shift(4);
2768 var EF = parse_extra_field(/*::(*/blob.slice(blob.l+namelen, blob.l+namelen+efsz)/*:: :any)*/);
2769 blob.l += namelen + efsz + fcsz;
2771 var L = blob.l;
2772 blob.l = offset + 4;
2778 parse_local_file(blob, csz, usz, o, EF);
2779 blob.l = L;
2787 function parse_local_file(blob/*:CFBlob*/, csz/*:number*/, usz/*:number*/, o/*:CFBContainer*/, EF) {
2789 blob.l += 2;
2790 var flags = blob.read_shift(2);
2791 var meth = blob.read_shift(2);
2792 var date = parse_dos_date(blob);
2795 var crc32 = blob.read_shift(4);
2796 var _csz = blob.read_shift(4);
2797 var _usz = blob.read_shift(4);
2799 var namelen = blob.read_shift(2);
2800 var efsz = blob.read_shift(2);
2803 var name = ""; for(var i = 0; i < namelen; ++i) name += String.fromCharCode(blob[blob.l++]);
2805 var ef = parse_extra_field(/*::(*/blob.slice(blob.l, blob.l + efsz)/*:: :any)*/);
2815 blob.l += efsz;
2820 var data = blob.slice(blob.l, blob.l + _csz);
2822 case 8: data = _inflateRawSync(blob, _usz); break;
2830 crc32 = blob.read_shift(4);
2831 if(crc32 == 0x08074b50) { crc32 = blob.read_shift(4); wrn = true; }
2832 _csz = blob.read_shift(4);
2833 _usz = blob.read_shift(4);
3237 /* normalize data for blob ctor */
3261 var blob = new Blob([blobify(data)], {type:"application/octet-stream"});
3263 …if(typeof navigator !== 'undefined' && navigator.msSaveBlob) return navigator.msSaveBlob(blob, fna…
3265 if(typeof saveAs !== 'undefined') return saveAs(blob, fname);
3267 var url = URL.createObjectURL(blob);
4136 function prep_blob(blob, pos/*:number*/)/*:void*/ { argument
4137 blob.l = pos;
4138 blob.read_shift = /*::(*/ReadShift/*:: :any)*/;
4139 blob.chk = CheckField;
4140 blob.write_shift = WriteShift;
4143 function parsenoop(blob, length/*:: :number, opts?:any */) { blob.l += length; } argument
5924 function parse_FILETIME(blob) { argument
5925 var dwLowDateTime = blob.read_shift(4), dwHighDateTime = blob.read_shift(4);
5939 function parse_lpstr(blob, type, pad/*:?number*/) { argument
5940 var start = blob.l;
5941 var str = blob.read_shift(0, 'lpstr-cp');
5942 if(pad) while((blob.l - start) & 3) ++blob.l;
5947 function parse_lpwstr(blob, type, pad) { argument
5948 var str = blob.read_shift(0, 'lpwstr');
5949 if(pad) blob.l += (4 - ((str.length+1) & 3)) & 3;
5956 function parse_VtStringBase(blob, stringType, pad) { argument
5957 if(stringType === 0x1F /*VT_LPWSTR*/) return parse_lpwstr(blob);
5958 return parse_lpstr(blob, stringType, pad);
5961 function parse_VtString(blob, t/*:number*/, pad/*:?boolean*/) { return parse_VtStringBase(blob, t, … argument
5962 …nalignedString(blob, t/*:number*/) { if(!t) throw new Error("VtUnalignedString must have positive … argument
5965 function parse_VtVecLpwstrValue(blob)/*:Array<string>*/ { argument
5966 var length = blob.read_shift(4);
5969 var start = blob.l;
5970 ret[i] = blob.read_shift(0, 'lpwstr').replace(chr0,'');
5971 if((blob.l - start) & 0x02) blob.l += 2;
5977 function parse_VtVecUnalignedLpstrValue(blob)/*:Array<string>*/ { argument
5978 var length = blob.read_shift(4);
5980 for(var i = 0; i != length; ++i) ret[i] = blob.read_shift(0, 'lpstr-cp').replace(chr0,'');
5986 function parse_VtHeadingPair(blob) { argument
5987 var start = blob.l;
5988 var headingString = parse_TypedPropertyValue(blob, VT_USTR);
5989 if(blob[blob.l] == 0x00 && blob[blob.l+1] == 0x00 && ((blob.l - start) & 0x02)) blob.l += 2;
5990 var headerParts = parse_TypedPropertyValue(blob, VT_I4);
5995 function parse_VtVecHeadingPairValue(blob) { argument
5996 var cElements = blob.read_shift(4);
5998 for(var i = 0; i < cElements / 2; ++i) out.push(parse_VtHeadingPair(blob));
6003 function parse_dictionary(blob,CodePage) { argument
6004 var cnt = blob.read_shift(4);
6007 var pid = blob.read_shift(4);
6008 var len = blob.read_shift(4);
6009 …dict[pid] = blob.read_shift(len, (CodePage === 0x4B0 ?'utf16le':'utf8')).replace(chr0,'').replace(…
6010 if(CodePage === 0x4B0 && (len % 2)) blob.l += 2;
6012 if(blob.l & 3) blob.l = (blob.l>>2+1)<<2;
6017 function parse_BLOB(blob) { argument
6018 var size = blob.read_shift(4);
6019 var bytes = blob.slice(blob.l,blob.l+size);
6020 blob.l += size;
6021 if((size & 3) > 0) blob.l += (4 - (size & 3)) & 3;
6026 function parse_ClipboardData(blob) { argument
6029 o.Size = blob.read_shift(4);
6030 //o.Format = blob.read_shift(4);
6031 blob.l += o.Size + 3 - (o.Size - 1) % 4;
6036 function parse_TypedPropertyValue(blob, type/*:number*/, _opts)/*:any*/ { argument
6037 var t = blob.read_shift(2), ret, opts = _opts||{};
6038 blob.l += 2;
6042 case 0x02 /*VT_I2*/: ret = blob.read_shift(2, 'i'); if(!opts.raw) blob.l += 2; return ret;
6043 case 0x03 /*VT_I4*/: ret = blob.read_shift(4, 'i'); return ret;
6044 case 0x0B /*VT_BOOL*/: return blob.read_shift(4) !== 0x0;
6045 case 0x13 /*VT_UI4*/: ret = blob.read_shift(4); return ret;
6046 case 0x1E /*VT_LPSTR*/: return parse_lpstr(blob, t, 4).replace(chr0,'');
6047 case 0x1F /*VT_LPWSTR*/: return parse_lpwstr(blob);
6048 case 0x40 /*VT_FILETIME*/: return parse_FILETIME(blob);
6049 case 0x41 /*VT_BLOB*/: return parse_BLOB(blob);
6050 case 0x47 /*VT_CF*/: return parse_ClipboardData(blob);
6051 case 0x50 /*VT_STRING*/: return parse_VtString(blob, t, !opts.raw).replace(chr0,'');
6052 case 0x51 /*VT_USTR*/: return parse_VtUnalignedString(blob, t/*, 4*/).replace(chr0,'');
6053 case 0x100C /*VT_VECTOR|VT_VARIANT*/: return parse_VtVecHeadingPairValue(blob);
6056 return t == 0x101F ? parse_VtVecLpwstrValue(blob) : parse_VtVecUnalignedLpstrValue(blob);
6082 function parse_PropertySet(blob, PIDSI) { argument
6083 var start_addr = blob.l;
6084 var size = blob.read_shift(4);
6085 var NumProps = blob.read_shift(4);
6090 var PropID = blob.read_shift(4);
6091 var Offset = blob.read_shift(4);
6097 if(blob.l !== Props[i][1]) {
6100 case 0x02 /*VT_I2*/: if(blob.l+2 === Props[i][1]) { blob.l+=2; fail = false; } break;
6101 case 0x50 /*VT_STRING*/: if(blob.l <= Props[i][1]) { blob.l=Props[i][1]; fail = false; } break;
6102 …case 0x100C /*VT_VECTOR|VT_VARIANT*/: if(blob.l <= Props[i][1]) { blob.l=Props[i][1]; fail = false…
6104 if((!PIDSI||i==0) && blob.l <= Props[i][1]) { fail=false; blob.l = Props[i][1]; }
6105 …if(fail) throw new Error("Read Error: Expected address " + Props[i][1] + ' at ' + blob.l + ' :' + …
6110 PropH[piddsi.n] = parse_TypedPropertyValue(blob, piddsi.t, {raw:true});
6139 CodePage = PropH.CodePage = (parse_TypedPropertyValue(blob, VT_I2)/*:number*/);
6142 var oldpos = blob.l;
6143 blob.l = Props[Dictionary][1];
6144 DictObj = parse_dictionary(blob,CodePage);
6145 blob.l = oldpos;
6148 if(CodePage === 0) { Dictionary = i; blob.l = Props[i+1][1]; continue; }
6149 DictObj = parse_dictionary(blob,CodePage);
6154 switch(blob[blob.l]) {
6155 case 0x41 /*VT_BLOB*/: blob.l += 4; val = parse_BLOB(blob); break;
6156 …case 0x1E /*VT_LPSTR*/: blob.l += 4; val = parse_VtString(blob, blob[blob.l-4]).replace(/\u0000+$/…
6157 …case 0x1F /*VT_LPWSTR*/: blob.l += 4; val = parse_VtString(blob, blob[blob.l-4]).replace(/\u0000+$…
6158 case 0x03 /*VT_I4*/: blob.l += 4; val = blob.read_shift(4, 'i'); break;
6159 case 0x13 /*VT_UI4*/: blob.l += 4; val = blob.read_shift(4); break;
6160 case 0x05 /*VT_R8*/: blob.l += 4; val = blob.read_shift(8, 'f'); break;
6161 case 0x0B /*VT_BOOL*/: blob.l += 4; val = parsebool(blob, 4); break;
6162 case 0x40 /*VT_FILETIME*/: blob.l += 4; val = parseDate(parse_FILETIME(blob)); break;
6163 default: throw new Error("unparsed value: " + blob[blob.l]);
6169 blob.l = start_addr + size; /* step ahead to skip padding */
6252 var blob = file.content;
6253 if(!blob) return ({}/*:any*/);
6254 prep_blob(blob, 0);
6257 blob.chk('feff', 'Byte Order: ');
6259 /*var vers = */blob.read_shift(2); // TODO: check version
6260 var SystemIdentifier = blob.read_shift(4);
6261 var CLSID = blob.read_shift(16);
6263 NumSets = blob.read_shift(4);
6265 FMTID0 = blob.read_shift(16); Offset0 = blob.read_shift(4);
6267 …if(NumSets === 1 && Offset0 !== blob.l) throw new Error("Length mismatch: " + Offset0 + " !== " + …
6268 else if(NumSets === 2) { FMTID1 = blob.read_shift(16); Offset1 = blob.read_shift(4); }
6269 var PSet0 = parse_PropertySet(blob, PIDSI);
6273 //rval.blob = blob;
6277 if(Offset1 - blob.l == 2) blob.l += 2;
6278 if(blob.l !== Offset1) throw new Error("Length mismatch 2: " + blob.l + " !== " + Offset1);
6280 try { PSet1 = parse_PropertySet(blob, null); } catch(e) {/* empty */}
6307 function parsenoop2(blob, length) { blob.read_shift(length); return null; } argument
6310 function parslurp(blob, length, cb) { argument
6311 var arr = [], target = blob.l + length;
6312 while(blob.l < target) arr.push(cb(blob, target - blob.l));
6313 if(target !== blob.l) throw new Error("Slurp error");
6317 function parsebool(blob, length/*:number*/) { return blob.read_shift(length) === 0x1; } argument
6320 function parseuint16(blob/*::, length:?number, opts:?any*/) { return blob.read_shift(2, 'u'); } argument
6322 function parseuint16a(blob, length/*:: :?number, opts:?any*/) { return parslurp(blob,length,parseui… argument
6327 function parse_Bes(blob/*::, length*/) { argument
6328 var v = blob.read_shift(1), t = blob.read_shift(1);
6339 function parse_ShortXLUnicodeString(blob, length, opts) { argument
6340 var cch = blob.read_shift(opts && opts.biff >= 12 ? 2 : 1);
6345 var fHighByte = blob.read_shift(1);
6351 var o = cch ? blob.read_shift(cch, encoding) : "";
6357 function parse_XLUnicodeRichExtendedString(blob) { argument
6360 var cch = blob.read_shift(2), flags = blob.read_shift(1);
6365 if(fRichSt) cRun = blob.read_shift(2);
6366 if(fExtSt) cbExtRst = blob.read_shift(4);
6368 var msg = cch === 0 ? "" : blob.read_shift(cch, encoding);
6369 if(fRichSt) blob.l += 4 * cRun; //TODO: parse this
6370 if(fExtSt) blob.l += cbExtRst; //TODO: parse this
6393 function parse_XLUnicodeStringNoCch(blob, cch, opts) { argument
6396 if(opts.biff >= 2 && opts.biff <= 5) return blob.read_shift(cch, 'cpstr');
6397 if(opts.biff >= 12) return blob.read_shift(cch, 'dbcs-cont');
6399 var fHighByte = blob.read_shift(1);
6400 if(fHighByte===0) { retval = blob.read_shift(cch, 'sbcs-cont'); }
6401 else { retval = blob.read_shift(cch, 'dbcs-cont'); }
6406 function parse_XLUnicodeString(blob, length, opts) { argument
6407 var cch = blob.read_shift(opts && opts.biff == 2 ? 1 : 2);
6408 if(cch === 0) { blob.l++; return ""; }
6409 return parse_XLUnicodeStringNoCch(blob, cch, opts);
6412 function parse_XLUnicodeString2(blob, length, opts) { argument
6413 if(opts.biff > 5) return parse_XLUnicodeString(blob, length, opts);
6414 var cch = blob.read_shift(1);
6415 if(cch === 0) { blob.l++; return ""; }
6416 return blob.read_shift(cch, (opts.biff <= 4 || !blob.lens ) ? 'cpstr' : 'sbcs-cont');
6428 function parse_ControlInfo(blob/*::, length, opts*/) { argument
6429 var flags = blob.read_shift(1);
6430 blob.l++;
6431 var accel = blob.read_shift(2);
6432 blob.l += 2;
6437 function parse_URLMoniker(blob/*::, length, opts*/) { argument
6438 var len = blob.read_shift(4), start = blob.l;
6442 blob.l += len - 24;
6443 if(blob.read_shift(16) === "795881f43b1d7f48af2c825dc4852763") extra = true;
6444 blob.l = start;
6446 var url = blob.read_shift((extra?len-24:len)>>1, 'utf16le').replace(chr0,"");
6447 if(extra) blob.l += 24;
6452 function parse_FileMoniker(blob/*::, length*/) { argument
6453 var cAnti = blob.read_shift(2);
6455 var ansiPath = blob.read_shift(0, 'lpstr-ansi');
6456 blob.l += 2; //var endServer = blob.read_shift(2);
6457 if(blob.read_shift(2) != 0xDEAD) throw new Error("Bad FileMoniker");
6458 var sz = blob.read_shift(4);
6460 var bytes = blob.read_shift(4);
6461 if(blob.read_shift(2) != 3) throw new Error("Bad FileMoniker");
6462 var unicodePath = blob.read_shift(bytes>>1, 'utf16le').replace(chr0,"");
6467 function parse_HyperlinkMoniker(blob, length) { argument
6468 var clsid = blob.read_shift(16); length -= 16;
6470 case "e0c9ea79f9bace118c8200aa004ba90b": return parse_URLMoniker(blob, length);
6471 case "0303000000000000c000000000000046": return parse_FileMoniker(blob, length);
6477 function parse_HyperlinkString(blob/*::, length*/) { argument
6478 var len = blob.read_shift(4);
6479 var o = len > 0 ? blob.read_shift(len, 'utf16le').replace(chr0, "") : "";
6491 function parse_Hyperlink(blob, length)/*:Hyperlink*/ { argument
6492 var end = blob.l + length;
6493 var sVer = blob.read_shift(4);
6495 var flags = blob.read_shift(2);
6496 blob.l += 2;
6498 if(flags & 0x0010) displayName = parse_HyperlinkString(blob, end - blob.l);
6499 if(flags & 0x0080) targetFrameName = parse_HyperlinkString(blob, end - blob.l);
6500 if((flags & 0x0101) === 0x0101) moniker = parse_HyperlinkString(blob, end - blob.l);
6501 if((flags & 0x0101) === 0x0001) oleMoniker = parse_HyperlinkMoniker(blob, end - blob.l);
6502 if(flags & 0x0008) Loc = parse_HyperlinkString(blob, end - blob.l);
6503 if(flags & 0x0020) guid = blob.read_shift(16);
6504 if(flags & 0x0040) fileTime = parse_FILETIME(blob/*, 8*/);
6505 blob.l = end;
6553 …unction parse_LongRGBA(blob/*::, length*/) { var r = blob.read_shift(1), g = blob.read_shift(1), b… argument
6556 function parse_LongRGB(blob, length) { var x = parse_LongRGBA(blob, length); x[3] = 0; return x; } argument
6560 function parse_XLSCell(blob/*::, length*/)/*:Cell*/ { argument
6561 var rw = blob.read_shift(2); // 0-indexed
6562 var col = blob.read_shift(2);
6563 var ixfe = blob.read_shift(2);
6575 function parse_frtHeader(blob) { argument
6576 var rt = blob.read_shift(2);
6577 var flags = blob.read_shift(2); // TODO: parse these flags
6578 blob.l += 8;
6584 function parse_OptXLUnicodeString(blob, length, opts) { return length === 0 ? "" : parse_XLUnicodeS… argument
6587 function parse_XTI(blob, length, opts) { argument
6589 …var iSupBook = blob.read_shift(w), itabFirst = blob.read_shift(w,'i'), itabLast = blob.read_shift(…
6594 function parse_RkRec(blob) { argument
6595 var ixfe = blob.read_shift(2);
6596 var RK = parse_RkNumber(blob);
6601 function parse_AddinUdf(blob, length, opts) { argument
6602 blob.l += 4; length -= 4;
6603 var l = blob.l + length;
6604 var udfName = parse_ShortXLUnicodeString(blob, length, opts);
6605 var cb = blob.read_shift(2);
6606 l -= blob.l;
6608 blob.l += cb;
6613 function parse_Ref8U(blob/*::, length*/) { argument
6614 var rwFirst = blob.read_shift(2);
6615 var rwLast = blob.read_shift(2);
6616 var colFirst = blob.read_shift(2);
6617 var colLast = blob.read_shift(2);
6630 function parse_RefU(blob/*::, length*/) { argument
6631 var rwFirst = blob.read_shift(2);
6632 var rwLast = blob.read_shift(2);
6633 var colFirst = blob.read_shift(1);
6634 var colLast = blob.read_shift(1);
6642 function parse_FtCmo(blob/*::, length*/) { argument
6643 blob.l += 4;
6644 var ot = blob.read_shift(2);
6645 var id = blob.read_shift(2);
6646 var flags = blob.read_shift(2);
6647 blob.l+=12;
6652 function parse_FtNts(blob) { argument
6654 blob.l += 4;
6655 blob.l += 16; // GUID TODO
6656 out.fSharedNote = blob.read_shift(2);
6657 blob.l += 4;
6662 function parse_FtCf(blob) { argument
6664 blob.l += 4;
6665 blob.cf = blob.read_shift(2);
6670 function parse_FtSkip(blob) { blob.l += 2; blob.l += blob.read_shift(2); } argument
6692 function parse_FtArray(blob, length/*::, ot*/) { argument
6693 var tgt = blob.l + length;
6695 while(blob.l < tgt) {
6696 var ft = blob.read_shift(2);
6697 blob.l-=2;
6699 fts.push(FtTab[ft](blob, tgt - blob.l));
6700 } catch(e) { blob.l = tgt; return fts; }
6702 if(blob.l != tgt) blob.l = tgt; //throw new Error("bad Object Ft-sequence");
6709 function parse_BOF(blob, length) { argument
6711 o.BIFFVer = blob.read_shift(2); length -= 2;
6712 if(length >= 2) { o.dt = blob.read_shift(2); blob.l -= 2; }
6724 blob.read_shift(length);
6754 function parse_InterfaceHdr(blob, length) { argument
6756 if((blob.read_shift(2))!==0x04b0){/* empty */}
6762 function parse_WriteAccess(blob, length, opts) { argument
6763 if(opts.enc) { blob.l += length; return ""; }
6764 var l = blob.l;
6766 var UserName = parse_XLUnicodeString2(blob, 0, opts);
6767 blob.read_shift(length + l - blob.l);
6782 function parse_WsBool(blob, length, opts) { argument
6783 var flags = opts && opts.biff == 8 || length == 2 ? blob.read_shift(2) : (blob.l += length, 0);
6788 function parse_BoundSheet8(blob, length, opts) { argument
6789 var pos = blob.read_shift(4);
6790 var hidden = blob.read_shift(1) & 0x03;
6791 var dt = blob.read_shift(1);
6798 var name = parse_ShortXLUnicodeString(blob, 0, opts);
6816 function parse_SST(blob, length)/*:SST*/ { argument
6817 var end = blob.l + length;
6818 var cnt = blob.read_shift(4);
6819 var ucnt = blob.read_shift(4);
6821 for(var i = 0; i != ucnt && blob.l < end; ++i) {
6822 strs.push(parse_XLUnicodeRichExtendedString(blob));
6839 function parse_ExtSST(blob, length) { argument
6841 extsst.dsst = blob.read_shift(2);
6842 blob.l += length-2;
6848 function parse_Row(blob) { argument
6850 z.r = blob.read_shift(2);
6851 z.c = blob.read_shift(2);
6852 z.cnt = blob.read_shift(2) - z.c;
6853 var miyRw = blob.read_shift(2);
6854 blob.l += 4; // reserved(2), unused(2)
6855 var flags = blob.read_shift(1); // various flags
6856 blob.l += 3; // reserved(8), ixfe(12), flags(4)
6866 function parse_ForceFullCalculation(blob) { argument
6867 var header = parse_frtHeader(blob);
6869 var fullcalc = blob.read_shift(4);
6878 function parse_RecalcId(blob) { argument
6879 blob.read_shift(2);
6880 return blob.read_shift(4);
6884 function parse_DefaultRowHeight(blob, length, opts) { argument
6887 f = blob.read_shift(2);
6889 var miyRw = blob.read_shift(2);
6898 function parse_Window1(blob) { argument
6899 …var xWn = blob.read_shift(2), yWn = blob.read_shift(2), dxWn = blob.read_shift(2), dyWn = blob.rea…
6900 var flags = blob.read_shift(2), iTabCur = blob.read_shift(2), iTabFirst = blob.read_shift(2);
6901 var ctabSel = blob.read_shift(2), wTabRatio = blob.read_shift(2);
6919 function parse_Window2(blob, length, opts) { argument
6921 var f = blob.read_shift(2);
6936 function parse_Pane(/*blob, length, opts*/) {
6940 function parse_Font(blob, length, opts) { argument
6942 dyHeight: blob.read_shift(2),
6943 fl: blob.read_shift(2)
6947 case 3: case 4: blob.l += 2; break;
6948 default: blob.l += 10; break;
6950 o.name = parse_ShortXLUnicodeString(blob, 0, opts);
6969 function parse_LabelSst(blob) { argument
6970 var cell = parse_XLSCell(blob);
6971 cell.isst = blob.read_shift(4);
6982 function parse_Label(blob, length, opts) { argument
6984 var target = blob.l + length;
6985 var cell = parse_XLSCell(blob, 6);
6986 if(opts.biff == 2) blob.l++;
6987 var str = parse_XLUnicodeString(blob, target - blob.l, opts);
7003 function parse_Format(blob, length, opts) { argument
7004 var numFmtId = blob.read_shift(2);
7005 var fmtstr = parse_XLUnicodeString2(blob, 0, opts);
7022 function parse_Dimensions(blob, length, opts) { argument
7023 var end = blob.l + length;
7025 var r = blob.read_shift(w), R = blob.read_shift(w);
7026 var c = blob.read_shift(2), C = blob.read_shift(2);
7027 blob.l = end;
7042 function parse_RK(blob) { argument
7043 var rw = blob.read_shift(2), col = blob.read_shift(2);
7044 var rkrec = parse_RkRec(blob);
7049 function parse_MulRk(blob, length) { argument
7050 var target = blob.l + length - 2;
7051 var rw = blob.read_shift(2), col = blob.read_shift(2);
7053 while(blob.l < target) rkrecs.push(parse_RkRec(blob));
7054 if(blob.l !== target) throw new Error("MulRK read error");
7055 var lastcol = blob.read_shift(2);
7060 function parse_MulBlank(blob, length) { argument
7061 var target = blob.l + length - 2;
7062 var rw = blob.read_shift(2), col = blob.read_shift(2);
7064 while(blob.l < target) ixfes.push(blob.read_shift(2));
7065 if(blob.l !== target) throw new Error("MulBlank read error");
7066 var lastcol = blob.read_shift(2);
7072 function parse_CellStyleXF(blob, length, style, opts) { argument
7074 var a = blob.read_shift(4), b = blob.read_shift(4);
7075 var c = blob.read_shift(4), d = blob.read_shift(2);
7112 //function parse_CellXF(blob, length, opts) {return parse_CellStyleXF(blob,length,0, opts);}
7113 //function parse_StyleXF(blob, length, opts) {return parse_CellStyleXF(blob,length,1, opts);}
7116 function parse_XF(blob, length, opts) { argument
7118 o.ifnt = blob.read_shift(2); o.numFmtId = blob.read_shift(2); o.flags = blob.read_shift(2);
7121 o.data = parse_CellStyleXF(blob, length, o.fStyle, opts);
7145 function parse_Guts(blob) { argument
7146 blob.l += 4;
7147 var out = [blob.read_shift(2), blob.read_shift(2)];
7162 function parse_BoolErr(blob, length, opts) { argument
7163 var cell = parse_XLSCell(blob, 6);
7164 if(opts.biff == 2 || length == 9) ++blob.l;
7165 var val = parse_Bes(blob, 2);
7178 function parse_Number(blob, length, opts) { argument
7180 var cell = parse_XLSCell(blob, 6);
7181 var xnum = parse_Xnum(blob, 8);
7195 function parse_SupBook(blob, length, opts) { argument
7196 var end = blob.l + length;
7197 var ctab = blob.read_shift(2);
7198 var cch = blob.read_shift(2);
7202 var virtPath = parse_XLUnicodeStringNoCch(blob, cch);
7205 while(end > blob.l) rgst.push(parse_XLUnicodeString(blob));
7210 function parse_ExternName(blob, length, opts) { argument
7211 var flags = blob.read_shift(2);
7222 if(opts.sbcch === 0x3A01) body = parse_AddinUdf(blob, length-2, opts);
7224 o.body = body || blob.read_shift(length-2);
7230 function parse_Lbl(blob, length, opts) { argument
7231 var target = blob.l + length;
7232 var flags = blob.read_shift(2);
7233 var chKey = blob.read_shift(1);
7234 var cch = blob.read_shift(1);
7235 var cce = blob.read_shift(opts && opts.biff == 2 ? 1 : 2);
7238 if(opts.biff != 5) blob.l += 2;
7239 itab = blob.read_shift(2);
7240 if(opts.biff == 5) blob.l += 2;
7241 blob.l += 4;
7243 var name = parse_XLUnicodeStringNoCch(blob, cch, opts);
7245 var npflen = target - blob.l; if(opts && opts.biff == 2) --npflen;
7247 …var rgce = (target == blob.l || cce === 0 || !(npflen > 0)) ? [] : parse_NameParsedFormula(blob, n…
7258 function parse_ExternSheet(blob, length, opts) { argument
7259 if(opts.biff < 8) return parse_BIFF5ExternSheet(blob, length, opts);
7260 var o = [], target = blob.l + length, len = blob.read_shift(opts.biff > 8 ? 4 : 2);
7261 while(len-- !== 0) o.push(parse_XTI(blob, opts.biff > 8 ? 12 : 6, opts));
7263 if(blob.l != target) throw new Error("Bad ExternSheet: " + blob.l + " != " + target);
7266 function parse_BIFF5ExternSheet(blob, length, opts) { argument
7267 if(blob[blob.l + 1] == 0x03) blob[blob.l]++;
7268 var o = parse_ShortXLUnicodeString(blob, length, opts);
7273 function parse_NameCmt(blob, length, opts) { argument
7274 if(opts.biff < 8) { blob.l += length; return; }
7275 var cchName = blob.read_shift(2);
7276 var cchComment = blob.read_shift(2);
7277 var name = parse_XLUnicodeStringNoCch(blob, cchName, opts);
7278 var comment = parse_XLUnicodeStringNoCch(blob, cchComment, opts);
7283 function parse_ShrFmla(blob, length, opts) { argument
7284 var ref = parse_RefU(blob, 6);
7285 blob.l++;
7286 var cUse = blob.read_shift(1);
7288 return [parse_SharedParsedFormula(blob, length, opts), cUse, ref];
7292 function parse_Array(blob, length, opts) { argument
7293 var ref = parse_Ref(blob, 6);
7296 case 2: blob.l ++; length -= 7; break;
7297 case 3: case 4: blob.l += 2; length -= 8; break;
7298 default: blob.l += 6; length -= 12;
7300 return [ref, parse_ArrayParsedFormula(blob, length, opts, ref)];
7304 function parse_MTRSettings(blob) { argument
7305 var fMTREnabled = blob.read_shift(4) !== 0x00;
7306 var fUserSetThreadCount = blob.read_shift(4) !== 0x00;
7307 var cUserThreadCount = blob.read_shift(4);
7312 function parse_NoteSh(blob, length, opts) { argument
7314 var row = blob.read_shift(2), col = blob.read_shift(2);
7315 var flags = blob.read_shift(2), idObj = blob.read_shift(2);
7316 var stAuthor = parse_XLUnicodeString2(blob, 0, opts);
7317 if(opts.biff < 8) blob.read_shift(1);
7322 function parse_Note(blob, length, opts) { argument
7324 return parse_NoteSh(blob, length, opts);
7328 function parse_MergeCells(blob, length)/*:Array<Range>*/ { argument
7330 var cmcs = blob.read_shift(2);
7331 while (cmcs--) merges.push(parse_Ref8U(blob,length));
7342 function parse_Obj(blob, length, opts) { argument
7343 if(opts && opts.biff < 8) return parse_BIFF5Obj(blob, length, opts);
7344 var cmo = parse_FtCmo(blob, 22); // id, ot, flags
7345 var fts = parse_FtArray(blob, length-22, cmo[1]);
7350 0x08: function(blob, length) { argument
7351 var tgt = blob.l + length;
7352 blob.l += 10; // todo
7353 var cf = blob.read_shift(2);
7354 blob.l += 4;
7355 blob.l += 2; //var cbPictFmla = blob.read_shift(2);
7356 blob.l += 2;
7357 blob.l += 2; //var grbit = blob.read_shift(2);
7358 blob.l += 4;
7359 var cchName = blob.read_shift(1);
7360 blob.l += cchName; // TODO: stName
7361 blob.l = tgt; // TODO: fmla
7366 function parse_BIFF5Obj(blob, length, opts) { argument
7367 blob.l += 4; //var cnt = blob.read_shift(4);
7368 var ot = blob.read_shift(2);
7369 var id = blob.read_shift(2);
7370 var grbit = blob.read_shift(2);
7371 blob.l += 2; //var colL = blob.read_shift(2);
7372 blob.l += 2; //var dxL = blob.read_shift(2);
7373 blob.l += 2; //var rwT = blob.read_shift(2);
7374 blob.l += 2; //var dyT = blob.read_shift(2);
7375 blob.l += 2; //var colR = blob.read_shift(2);
7376 blob.l += 2; //var dxR = blob.read_shift(2);
7377 blob.l += 2; //var rwB = blob.read_shift(2);
7378 blob.l += 2; //var dyB = blob.read_shift(2);
7379 blob.l += 2; //var cbMacro = blob.read_shift(2);
7380 blob.l += 6;
7383 fts.push((parse_BIFF5OT[ot]||parsenoop)(blob, length, opts));
7388 function parse_TxO(blob, length, opts) { argument
7389 var s = blob.l;
7392 blob.l += 4;
7395 if([0,5,7,11,12,14].indexOf(ot) == -1) blob.l += 6;
7396 else controlInfo = parse_ControlInfo(blob, 6, opts); // eslint-disable-line no-unused-vars
7397 var cchText = blob.read_shift(2);
7398 /*var cbRuns = */blob.read_shift(2);
7399 /*var ifntEmpty = */parseuint16(blob, 2);
7400 var len = blob.read_shift(2);
7401 blob.l += len;
7402 //var fmla = parse_ObjFmla(blob, s + length - blob.l);
7404 for(var i = 1; i < blob.lens.length-1; ++i) {
7405 if(blob.l-s != blob.lens[i]) throw new Error("TxO: bad continue record");
7406 var hdr = blob[blob.l];
7407 var t = parse_XLUnicodeStringNoCch(blob, blob.lens[i+1]-blob.lens[i]-1);
7415 blob.l = s + length;
7418 // for(var j = 0; j != cbRuns/8-1; ++j) blob.l += 8;
7419 // var cchText2 = blob.read_shift(2);
7421 // blob.l += 6;
7422 // if(s + length != blob.l) throw new Error("TxO " + (s + length) + ", at " + blob.l);
7424 } catch(e) { blob.l = s + length; return { t: texts }; }
7428 function parse_HLink(blob, length) { argument
7429 var ref = parse_Ref8U(blob, 8);
7430 blob.l += 16; /* CLSID */
7431 var hlink = parse_Hyperlink(blob, length-24);
7446 function parse_HLinkTooltip(blob, length) { argument
7447 blob.read_shift(2);
7448 var ref = parse_Ref8U(blob, 8);
7449 var wzTooltip = blob.read_shift((length-10)/2, 'dbcs-cont');
7466 function parse_Country(blob)/*:[string|number, string|number]*/ { argument
7468 d = blob.read_shift(2); o[0] = CountryEnum[d] || d;
7469 d = blob.read_shift(2); o[1] = CountryEnum[d] || d;
7480 function parse_ClrtClient(blob) { argument
7481 var ccv = blob.read_shift(2);
7483 while(ccv-->0) o.push(parse_LongRGB(blob, 8));
7488 function parse_Palette(blob) { argument
7489 var ccv = blob.read_shift(2);
7491 while(ccv-->0) o.push(parse_LongRGB(blob, 8));
7496 function parse_XFCRC(blob) { argument
7497 blob.l += 2;
7499 o.cxfs = blob.read_shift(2);
7500 o.crc = blob.read_shift(4);
7506 function parse_ColInfo(blob, length, opts) { argument
7507 if(!opts.cellStyles) return parsenoop(blob, length);
7509 var colFirst = blob.read_shift(w);
7510 var colLast = blob.read_shift(w);
7511 var coldx = blob.read_shift(w);
7512 var ixfe = blob.read_shift(w);
7513 var flags = blob.read_shift(2);
7514 if(w == 2) blob.l += 2;
7535 function parse_Setup(blob, length) { argument
7538 blob.l += 16;
7539 o.header = parse_Xnum(blob, 8);
7540 o.footer = parse_Xnum(blob, 8);
7541 blob.l += 2;
7546 function parse_ShtProps(blob, length, opts) { argument
7548 if(opts.biff != 5) { blob.l += length; return def; }
7549 var d = blob.read_shift(1); blob.l += 3;
7566 function parse_ImData(blob) { argument
7567 var cf = blob.read_shift(2);
7568 var env = blob.read_shift(2);
7569 var lcb = blob.read_shift(4);
7570 var o = {fmt:cf, env:env, len:lcb, data:blob.slice(blob.l,blob.l+lcb)};
7571 blob.l += lcb;
7576 function parse_BIFF2STR(blob, length, opts) { argument
7578 var cell = parse_XLSCell(blob, 6);
7579 ++blob.l;
7580 var str = parse_XLUnicodeString2(blob, length-7, opts);
7586 function parse_BIFF2NUM(blob/*::, length*/) { argument
7587 var cell = parse_XLSCell(blob, 6);
7588 ++blob.l;
7589 var num = parse_Xnum(blob, 8);
7601 function parse_BIFF2INT(blob) { argument
7602 var cell = parse_XLSCell(blob, 6);
7603 ++blob.l;
7604 var num = blob.read_shift(2);
7616 function parse_BIFF2STRING(blob) { argument
7617 var cch = blob.read_shift(1);
7618 if(cch === 0) { blob.l++; return ""; }
7619 return blob.read_shift(cch, 'sbcs-cont');
7623 function parse_BIFF2FONTXTRA(blob, length) { argument
7624 blob.l += 6; // unknown
7625 blob.l += 2; // font weight "bls"
7626 blob.l += 1; // charset
7627 blob.l += 3; // unknown
7628 blob.l += 1; // font family
7629 blob.l += length - 13;
7633 function parse_RString(blob, length, opts) { argument
7634 var end = blob.l + length;
7635 var cell = parse_XLSCell(blob, 6);
7636 var cch = blob.read_shift(2);
7637 var str = parse_XLUnicodeStringNoCch(blob, cch, opts);
7638 blob.l = end;
8977 function parse_RANGE(blob, length, opts) {
8980 o.s.c = blob.read_shift(1);
8981 blob.l++;
8982 o.s.r = blob.read_shift(2);
8983 o.e.c = blob.read_shift(1);
8984 blob.l++;
8985 o.e.r = blob.read_shift(2);
8988 o.s.c = blob.read_shift(2);
8989 o.s.r = blob.read_shift(2);
8990 if(length == 12 && opts.qpro) blob.l += 2;
8991 o.e.c = blob.read_shift(2);
8992 o.e.r = blob.read_shift(2);
8993 if(length == 12 && opts.qpro) blob.l += 2;
9006 function parse_cell(blob, length, opts) {
9009 o[0].c = blob.read_shift(1);
9010 o[3] = blob.read_shift(1);
9011 o[0].r = blob.read_shift(2);
9012 blob.l+=2;
9014 o[0].c = blob.read_shift(2); o[0].r = blob.read_shift(2);
9015 o[2] = blob.read_shift(2);
9017 o[2] = blob.read_shift(1);
9018 o[0].c = blob.read_shift(2); o[0].r = blob.read_shift(2);
9023 function parse_LABEL(blob, length, opts) {
9024 var tgt = blob.l + length;
9025 var o = parse_cell(blob, length, opts);
9028 blob.l++;
9029 var len = blob.read_shift(1);
9030 o[1].v = blob.read_shift(len, 'utf8');
9033 if(opts.qpro) blob.l++;
9034 o[1].v = blob.read_shift(tgt - blob.l, 'cstr');
9051 function parse_STRING(blob, length, opts) {
9052 var tgt = blob.l + length;
9053 var o = parse_cell(blob, length, opts);
9056 var len = blob.read_shift(1);
9057 o[1].v = blob.read_shift(len, 'utf8');
9060 o[1].v = blob.read_shift(tgt - blob.l, 'cstr');
9064 function parse_INTEGER(blob, length, opts) {
9065 var o = parse_cell(blob, length, opts);
9066 o[1].v = blob.read_shift(2, 'i');
9078 function parse_NUMBER(blob, length, opts) {
9079 var o = parse_cell(blob, length, opts);
9080 o[1].v = blob.read_shift(8, 'f');
9092 function parse_FORMULA(blob, length, opts) {
9093 var tgt = blob.l + length;
9094 var o = parse_cell(blob, length, opts);
9096 o[1].v = blob.read_shift(8, 'f');
9097 if(opts.qpro) blob.l = tgt;
9099 var flen = blob.read_shift(2);
9100 wk1_fmla_to_csf(blob.slice(blob.l, blob.l + flen), o);
9101 blob.l += flen;
9208 function wk1_fmla_to_csf(blob, o) {
9209 prep_blob(blob, 0);
9211 while(blob.l < blob.length) {
9212 var cc = blob[blob.l++];
9214 case 0x00: out.push(blob.read_shift(8, 'f')); break;
9216 C = wk1_parse_rc(o[0].c, blob.read_shift(2), true);
9217 R = wk1_parse_rc(o[0].r, blob.read_shift(2), false);
9221 var c = wk1_parse_rc(o[0].c, blob.read_shift(2), true);
9222 var r = wk1_parse_rc(o[0].r, blob.read_shift(2), false);
9223 C = wk1_parse_rc(o[0].c, blob.read_shift(2), true);
9224 R = wk1_parse_rc(o[0].r, blob.read_shift(2), false);
9228 if(blob.l < blob.length) { console.error("WK1 premature formula end"); return; }
9231 case 0x05: out.push(blob.read_shift(2)); break;
9234 var Z = ""; while((cc = blob[blob.l++])) Z += String.fromCharCode(cc);
9253 if(argc == 69) argc = blob[blob.l++];
9272 function parse_cell_3(blob/*::, length*/) {
9274 o[0].r = blob.read_shift(2); o[3] = blob[blob.l++]; o[0].c = blob[blob.l++];
9278 function parse_LABEL_16(blob, length) {
9279 var o = parse_cell_3(blob, length);
9281 o[1].v = blob.read_shift(length - 4, 'cstr');
9299 function parse_NUMBER_18(blob, length) {
9300 var o = parse_cell_3(blob, length);
9301 o[1].v = blob.read_shift(2);
9319 function parse_NUMBER_17(blob, length) {
9320 var o = parse_cell_3(blob, length);
9321 var v1 = blob.read_shift(4);
9322 var v2 = blob.read_shift(4);
9323 var e = blob.read_shift(2);
9363 function parse_FORMULA_19(blob, length) {
9364 var o = parse_NUMBER_17(blob, 14);
9365 blob.l += length - 14; /* TODO: WK3 formula */
9369 function parse_NUMBER_25(blob, length) {
9370 var o = parse_cell_3(blob, length);
9371 var v1 = blob.read_shift(4);
9376 function parse_NUMBER_27(blob, length) {
9377 var o = parse_cell_3(blob, length);
9378 var v1 = blob.read_shift(8,'f');
9383 function parse_FORMULA_28(blob, length) {
9384 var o = parse_NUMBER_27(blob, 12);
9385 blob.l += length - 12; /* TODO: formula */
9389 function parse_SHEETNAMECS(blob, length) {
9390 return blob[blob.l + length - 1] == 0 ? blob.read_shift(length, 'cstr') : "";
9393 function parse_SHEETNAMELP(blob, length) {
9394 var len = blob[blob.l++];
9396 var o = ""; while(o.length < len) o += String.fromCharCode(blob[blob.l++]);
9400 function parse_SHEETINFOQP(blob, length, opts) {
9402 var id = blob.read_shift(1);
9403 blob.l += 17;
9404 blob.l += 1; //var len = blob.read_shift(1);
9405 blob.l += 2;
9406 var nm = blob.read_shift(length - 21, 'cstr');
9410 function parse_XFORMAT(blob, length) {
9411 var o = {}, tgt = blob.l + length;
9412 while(blob.l < tgt) {
9413 var dt = blob.read_shift(2);
9416 o[dt][0] = blob.read_shift(2);
9417 while(blob[blob.l]) { o[dt][1] += String.fromCharCode(blob[blob.l]); blob.l++; } blob.l++;
10069 function parse_CRYPTOVersion(blob, length/*:?number*/) { argument
10071 o.Major = blob.read_shift(2);
10072 o.Minor = blob.read_shift(2);
10074 if(length >= 4) blob.l += length - 4;
10079 function parse_DataSpaceVersionInfo(blob) { argument
10081 o.id = blob.read_shift(0, 'lpp4');
10082 o.R = parse_CRYPTOVersion(blob, 4);
10083 o.U = parse_CRYPTOVersion(blob, 4);
10084 o.W = parse_CRYPTOVersion(blob, 4);
10089 function parse_DataSpaceMapEntry(blob) { argument
10090 var len = blob.read_shift(4);
10091 var end = blob.l + len - 4;
10093 var cnt = blob.read_shift(4);
10096 while(cnt-- > 0) comps.push({ t: blob.read_shift(4), v: blob.read_shift(0, 'lpp4') });
10097 o.name = blob.read_shift(0, 'lpp4');
10099 if(blob.l != end) throw new Error("Bad DataSpaceMapEntry: " + blob.l + " != " + end);
10104 function parse_DataSpaceMap(blob) { argument
10106 blob.l += 4; // must be 0x8
10107 var cnt = blob.read_shift(4);
10108 while(cnt-- > 0) o.push(parse_DataSpaceMapEntry(blob));
10113 function parse_DataSpaceDefinition(blob)/*:Array<string>*/ { argument
10115 blob.l += 4; // must be 0x8
10116 var cnt = blob.read_shift(4);
10117 while(cnt-- > 0) o.push(blob.read_shift(0, 'lpp4'));
10122 function parse_TransformInfoHeader(blob) { argument
10124 /*var len = */blob.read_shift(4);
10125 blob.l += 4; // must be 0x1
10126 o.id = blob.read_shift(0, 'lpp4');
10127 o.name = blob.read_shift(0, 'lpp4');
10128 o.R = parse_CRYPTOVersion(blob, 4);
10129 o.U = parse_CRYPTOVersion(blob, 4);
10130 o.W = parse_CRYPTOVersion(blob, 4);
10134 function parse_Primary(blob) { argument
10136 var hdr = parse_TransformInfoHeader(blob);
10138 hdr.ename = blob.read_shift(0, '8lpp4');
10139 hdr.blksz = blob.read_shift(4);
10140 hdr.cmode = blob.read_shift(4);
10141 if(blob.read_shift(4) != 0x04) throw new Error("Bad !Primary record");
10146 function parse_EncryptionHeader(blob, length/*:number*/) { argument
10147 var tgt = blob.l + length;
10149 o.Flags = (blob.read_shift(4) & 0x3F);
10150 blob.l += 4;
10151 o.AlgID = blob.read_shift(4);
10160 o.AlgIDHash = blob.read_shift(4);
10161 o.KeySize = blob.read_shift(4);
10162 o.ProviderType = blob.read_shift(4);
10163 blob.l += 8;
10164 o.CSPName = blob.read_shift((tgt-blob.l)>>1, 'utf16le');
10165 blob.l = tgt;
10170 function parse_EncryptionVerifier(blob, length/*:number*/) { argument
10171 var o = {}, tgt = blob.l + length;
10172 blob.l += 4; // SaltSize must be 0x10
10173 o.Salt = blob.slice(blob.l, blob.l+16); blob.l += 16;
10174 o.Verifier = blob.slice(blob.l, blob.l+16); blob.l += 16;
10175 /*var sz = */blob.read_shift(4);
10176 o.VerifierHash = blob.slice(blob.l, tgt); blob.l = tgt;
10181 function parse_EncryptionInfo(blob) { argument
10182 var vers = parse_CRYPTOVersion(blob);
10184 case 0x02: return [vers.Minor, parse_EncInfoStd(blob, vers)];
10185 case 0x03: return [vers.Minor, parse_EncInfoExt(blob, vers)];
10186 case 0x04: return [vers.Minor, parse_EncInfoAgl(blob, vers)];
10192 function parse_EncInfoStd(blob/*::, vers*/) { argument
10193 var flags = blob.read_shift(4);
10195 var sz = blob.read_shift(4);
10196 //var tgt = blob.l + sz;
10197 var hdr = parse_EncryptionHeader(blob, sz);
10198 var verifier = parse_EncryptionVerifier(blob, blob.length - blob.l);
10202 function parse_EncInfoExt(/*::blob, vers*/) { throw new Error("File is password-protected: ECMA-376…
10204 function parse_EncInfoAgl(blob/*::, vers*/) { argument
10206 blob.l+=4;
10207 var xml = blob.read_shift(blob.length - blob.l, 'utf8');
10229 function parse_RC4CryptoHeader(blob, length/*:number*/) { argument
10231 var vers = o.EncryptionVersionInfo = parse_CRYPTOVersion(blob, 4); length -= 4;
10234 o.Flags = blob.read_shift(4); length -= 4;
10235 var sz = blob.read_shift(4); length -= 4;
10236 o.EncryptionHeader = parse_EncryptionHeader(blob, sz); length -= sz;
10237 o.EncryptionVerifier = parse_EncryptionVerifier(blob, length);
10241 function parse_RC4Header(blob/*::, length*/) { argument
10243 var vers = o.EncryptionVersionInfo = parse_CRYPTOVersion(blob, 4);
10245 o.Salt = blob.read_shift(16);
10246 o.EncryptedVerifier = blob.read_shift(16);
10247 o.EncryptedVerifierHash = blob.read_shift(16);
10354 function parse_XORObfuscation(blob, length, opts, out) { argument
10355 var o = ({ key: parseuint16(blob), verificationBytes: parseuint16(blob) }/*:any*/);
10363 function parse_FilePassHeader(blob, length/*:number*/, oo) { argument
10364 var o = oo || {}; o.Info = blob.read_shift(2); blob.l -= 2;
10365 if(o.Info === 1) o.Data = parse_RC4Header(blob, length);
10366 else o.Data = parse_RC4CryptoHeader(blob, length);
10369 function parse_FilePass(blob, length/*:number*/, opts) { argument
10370 var o = ({ Type: opts.biff >= 8 ? blob.read_shift(2) : 0 }/*:any*/); /* wEncryptionType */
10371 if(o.Type) parse_FilePassHeader(blob, length-2, o);
10372 else parse_XORObfuscation(blob, opts.biff >= 8 ? length : length - 2, opts, o);
11695 function parse_Theme(blob, length, opts) { argument
11696 var end = blob.l + length;
11697 var dwThemeVersion = blob.read_shift(4);
11699 if(!opts.cellStyles) { blob.l = end; return; }
11700 var data = blob.slice(blob.l);
11701 blob.l = end;
11709 function parse_ColorTheme(blob/*::, length*/) { return blob.read_shift(4); } argument
11712 function parse_FullColorExt(blob/*::, length*/) { argument
11714 o.xclrType = blob.read_shift(2);
11715 o.nTintShade = blob.read_shift(2);
11717 case 0: blob.l += 4; break;
11718 case 1: o.xclrValue = parse_IcvXF(blob, 4); break;
11719 case 2: o.xclrValue = parse_LongRGBA(blob, 4); break;
11720 case 3: o.xclrValue = parse_ColorTheme(blob, 4); break;
11721 case 4: blob.l += 4; break;
11723 blob.l += 8;
11728 function parse_IcvXF(blob, length) { argument
11729 return parsenoop(blob, length);
11733 function parse_XFExtGradient(blob, length) { argument
11734 return parsenoop(blob, length);
11738 function parse_ExtProp(blob/*::, length*/)/*:Array<any>*/ { argument
11739 var extType = blob.read_shift(2);
11740 var cb = blob.read_shift(2) - 4;
11745 o[1] = parse_FullColorExt(blob, cb); break;
11746 case 0x06: o[1] = parse_XFExtGradient(blob, cb); break;
11747 case 0x0E: case 0x0F: o[1] = blob.read_shift(cb === 1 ? 1 : 2); break;
11754 function parse_XFExt(blob, length) { argument
11755 var end = blob.l + length;
11756 blob.l += 2;
11757 var ixfe = blob.read_shift(2);
11758 blob.l += 2;
11759 var cexts = blob.read_shift(2);
11761 while(cexts-- > 0) ext.push(parse_ExtProp(blob, end-blob.l));
12565 function parseread1(blob) { blob.l+=1; return; } argument
12568 function parse_ColRelU(blob, length) { argument
12569 var c = blob.read_shift(length == 1 ? 1 : 2);
12574 function parse_RgceArea(blob, length, opts) { argument
12577 if(opts.biff >= 2 && opts.biff <= 5) return parse_RgceArea_BIFF2(blob, length, opts);
12580 var r=blob.read_shift(w), R=blob.read_shift(w);
12581 var c=parse_ColRelU(blob, 2);
12582 var C=parse_ColRelU(blob, 2);
12586 function parse_RgceArea_BIFF2(blob/*::, length, opts*/) { argument
12587 var r=parse_ColRelU(blob, 2), R=parse_ColRelU(blob, 2);
12588 var c=blob.read_shift(1);
12589 var C=blob.read_shift(1);
12594 function parse_RgceAreaRel(blob, length, opts) { argument
12595 if(opts.biff < 8) return parse_RgceArea_BIFF2(blob, length, opts);
12596 var r=blob.read_shift(opts.biff == 12 ? 4 : 2), R=blob.read_shift(opts.biff == 12 ? 4 : 2);
12597 var c=parse_ColRelU(blob, 2);
12598 var C=parse_ColRelU(blob, 2);
12603 function parse_RgceLoc(blob, length, opts) { argument
12604 if(opts && opts.biff >= 2 && opts.biff <= 5) return parse_RgceLoc_BIFF2(blob, length, opts);
12605 var r = blob.read_shift(opts && opts.biff == 12 ? 4 : 2);
12606 var c = parse_ColRelU(blob, 2);
12609 function parse_RgceLoc_BIFF2(blob/*::, length, opts*/) { argument
12610 var r = parse_ColRelU(blob, 2);
12611 var c = blob.read_shift(1);
12616 function parse_RgceElfLoc(blob/*::, length, opts*/) { argument
12617 var r = blob.read_shift(2);
12618 var c = blob.read_shift(2);
12623 function parse_RgceLocRel(blob, length, opts) { argument
12625 if(biff >= 2 && biff <= 5) return parse_RgceLocRel_BIFF2(blob, length, opts);
12626 var r = blob.read_shift(biff >= 12 ? 4 : 2);
12627 var cl = blob.read_shift(2);
12634 function parse_RgceLocRel_BIFF2(blob/*::, length:number, opts*/) { argument
12635 var rl = blob.read_shift(2);
12636 var c = blob.read_shift(1);
12645 function parse_PtgArea(blob, length, opts) { argument
12646 var type = (blob[blob.l++] & 0x60) >> 5;
12647 var area = parse_RgceArea(blob, opts.biff >= 2 && opts.biff <= 5 ? 6 : 8, opts);
12652 function parse_PtgArea3d(blob, length, opts) { argument
12653 var type = (blob[blob.l++] & 0x60) >> 5;
12654 var ixti = blob.read_shift(2, 'i');
12657 case 5: blob.l += 12; w = 6; break;
12660 var area = parse_RgceArea(blob, w, opts);
12665 function parse_PtgAreaErr(blob, length, opts) { argument
12666 var type = (blob[blob.l++] & 0x60) >> 5;
12667 blob.l += opts && (opts.biff > 8) ? 12 : (opts.biff < 8 ? 6 : 8);
12671 function parse_PtgAreaErr3d(blob, length, opts) { argument
12672 var type = (blob[blob.l++] & 0x60) >> 5;
12673 var ixti = blob.read_shift(2);
12676 case 5: blob.l += 12; w = 6; break;
12679 blob.l += w;
12684 function parse_PtgAreaN(blob, length, opts) { argument
12685 var type = (blob[blob.l++] & 0x60) >> 5;
12686 var area = parse_RgceAreaRel(blob, length - 1, opts);
12691 function parse_PtgArray(blob, length, opts) { argument
12692 var type = (blob[blob.l++] & 0x60) >> 5;
12693 blob.l += opts.biff == 2 ? 6 : opts.biff == 12 ? 14 : 7;
12698 function parse_PtgAttrBaxcel(blob) { argument
12699 var bitSemi = blob[blob.l+1] & 0x01; /* 1 = volatile */
12701 blob.l += 4;
12706 function parse_PtgAttrChoose(blob, length, opts)/*:Array<number>*/ { argument
12707 blob.l +=2;
12708 var offset = blob.read_shift(opts && opts.biff == 2 ? 1 : 2);
12711 for(var i = 0; i <= offset; ++i) o.push(blob.read_shift(opts && opts.biff == 2 ? 1 : 2));
12716 function parse_PtgAttrGoto(blob, length, opts) { argument
12717 var bitGoto = (blob[blob.l+1] & 0xFF) ? 1 : 0;
12718 blob.l += 2;
12719 return [bitGoto, blob.read_shift(opts && opts.biff == 2 ? 1 : 2)];
12723 function parse_PtgAttrIf(blob, length, opts) { argument
12724 var bitIf = (blob[blob.l+1] & 0xFF) ? 1 : 0;
12725 blob.l += 2;
12726 return [bitIf, blob.read_shift(opts && opts.biff == 2 ? 1 : 2)];
12730 function parse_PtgAttrIfError(blob) { argument
12731 var bitIf = (blob[blob.l+1] & 0xFF) ? 1 : 0;
12732 blob.l += 2;
12733 return [bitIf, blob.read_shift(2)];
12737 function parse_PtgAttrSemi(blob, length, opts) { argument
12738 var bitSemi = (blob[blob.l+1] & 0xFF) ? 1 : 0;
12739 blob.l += opts && opts.biff == 2 ? 3 : 4;
12744 function parse_PtgAttrSpaceType(blob/*::, length*/) { argument
12745 var type = blob.read_shift(1), cch = blob.read_shift(1);
12750 function parse_PtgAttrSpace(blob) { argument
12751 blob.read_shift(2);
12752 return parse_PtgAttrSpaceType(blob, 2);
12756 function parse_PtgAttrSpaceSemi(blob) { argument
12757 blob.read_shift(2);
12758 return parse_PtgAttrSpaceType(blob, 2);
12762 function parse_PtgRef(blob, length, opts) { argument
12763 //var ptg = blob[blob.l] & 0x1F;
12764 var type = (blob[blob.l] & 0x60)>>5;
12765 blob.l += 1;
12766 var loc = parse_RgceLoc(blob, 0, opts);
12771 function parse_PtgRefN(blob, length, opts) { argument
12772 var type = (blob[blob.l] & 0x60)>>5;
12773 blob.l += 1;
12774 var loc = parse_RgceLocRel(blob, 0, opts);
12779 function parse_PtgRef3d(blob, length, opts) { argument
12780 var type = (blob[blob.l] & 0x60)>>5;
12781 blob.l += 1;
12782 var ixti = blob.read_shift(2); // XtiIndex
12783 if(opts && opts.biff == 5) blob.l += 12;
12784 var loc = parse_RgceLoc(blob, 0, opts); // TODO: or RgceLocRel
12790 function parse_PtgFunc(blob, length, opts) { argument
12791 //var ptg = blob[blob.l] & 0x1F;
12792 var type = (blob[blob.l] & 0x60)>>5;
12793 blob.l += 1;
12794 var iftab = blob.read_shift(opts && opts.biff <= 3 ? 1 : 2);
12798 function parse_PtgFuncVar(blob, length, opts) { argument
12799 var type = blob[blob.l++];
12800 …var cparams = blob.read_shift(1), tab = opts && opts.biff <= 3 ? [(type == 0x58 ? -1 : 0), blob.re…
12804 function parsetab(blob) { argument
12805 return [blob[blob.l+1]>>7, blob.read_shift(2) & 0x7FFF];
12809 function parse_PtgAttrSum(blob, length, opts) { argument
12810 blob.l += opts && opts.biff == 2 ? 3 : 4; return;
12814 function parse_PtgExp(blob, length, opts) { argument
12815 blob.l++;
12816 if(opts && opts.biff == 12) return [blob.read_shift(4, 'i'), 0];
12817 var row = blob.read_shift(2);
12818 var col = blob.read_shift(opts && opts.biff == 2 ? 1 : 2);
12823 function parse_PtgErr(blob) { blob.l++; return BErr[blob.read_shift(1)]; } argument
12826 function parse_PtgInt(blob) { blob.l++; return blob.read_shift(2); } argument
12829 function parse_PtgBool(blob) { blob.l++; return blob.read_shift(1)!==0;} argument
12832 function parse_PtgNum(blob) { blob.l++; return parse_Xnum(blob, 8); } argument
12835 function parse_PtgStr(blob, length, opts) { blob.l++; return parse_ShortXLUnicodeString(blob, lengt… argument
12839 function parse_SerAr(blob, biff/*:number*/) { argument
12840 var val = [blob.read_shift(1)];
12849 val[1] = parsebool(blob, 1) ? 'TRUE' : 'FALSE';
12850 if(biff != 12) blob.l += 7; break;
12853 val[1] = BErr[blob[blob.l]];
12854 blob.l += ((biff == 12) ? 4 : 8); break;
12856 blob.l += 8; break;
12858 val[1] = parse_Xnum(blob, 8); break;
12860 val[1] = parse_XLUnicodeString2(blob, 0, {biff:biff > 0 && biff < 8 ? 2 : biff}); break;
12867 function parse_PtgExtraMem(blob, cce, opts) { argument
12868 var count = blob.read_shift((opts.biff == 12) ? 4 : 2);
12870 … i = 0; i != count; ++i) out.push(((opts.biff == 12) ? parse_UncheckedRfX : parse_Ref8U)(blob, 8));
12875 function parse_PtgExtraArray(blob, length, opts) { argument
12878 rows = blob.read_shift(4); // DRw
12879 cols = blob.read_shift(4); // DCol
12881 cols = 1 + blob.read_shift(1); //DColByteU
12882 rows = 1 + blob.read_shift(2); //DRw
12887 for(var j = 0; j != cols; ++j) o[i][j] = parse_SerAr(blob, opts.biff);
12892 function parse_PtgName(blob, length, opts) { argument
12893 var type = (blob.read_shift(1) >>> 5) & 0x03;
12895 var nameindex = blob.read_shift(w);
12897 case 2: blob.l += 5; break;
12898 case 3: case 4: blob.l += 8; break;
12899 case 5: blob.l += 12; break;
12905 function parse_PtgNameX(blob, length, opts) { argument
12906 if(opts.biff == 5) return parse_PtgNameX_BIFF5(blob, length, opts);
12907 var type = (blob.read_shift(1) >>> 5) & 0x03;
12908 var ixti = blob.read_shift(2); // XtiIndex
12909 var nameindex = blob.read_shift(4);
12912 function parse_PtgNameX_BIFF5(blob/*::, length, opts*/) { argument
12913 var type = (blob.read_shift(1) >>> 5) & 0x03;
12914 var ixti = blob.read_shift(2, 'i'); // XtiIndex
12915 blob.l += 8;
12916 var nameindex = blob.read_shift(2);
12917 blob.l += 12;
12922 function parse_PtgMemArea(blob, length, opts) { argument
12923 var type = (blob.read_shift(1) >>> 5) & 0x03;
12924 blob.l += (opts && opts.biff == 2 ? 3 : 4);
12925 var cce = blob.read_shift(opts && opts.biff == 2 ? 1 : 2);
12930 function parse_PtgMemFunc(blob, length, opts) { argument
12931 var type = (blob.read_shift(1) >>> 5) & 0x03;
12932 var cce = blob.read_shift(opts && opts.biff == 2 ? 1 : 2);
12938 function parse_PtgRefErr(blob, length, opts) { argument
12939 var type = (blob.read_shift(1) >>> 5) & 0x03;
12940 blob.l += 4;
12941 if(opts.biff < 8) blob.l--;
12942 if(opts.biff == 12) blob.l += 2;
12947 function parse_PtgRefErr3d(blob, length, opts) { argument
12948 var type = (blob[blob.l++] & 0x60) >> 5;
12949 var ixti = blob.read_shift(2);
12955 blob.l += w;
12966 function parse_PtgElfLoc(blob, length, opts) { argument
12967 blob.l += 2;
12968 return [parse_RgceElfLoc(blob, 4, opts)];
12970 function parse_PtgElfNoop(blob/*::, length, opts*/) { argument
12971 blob.l += 6;
12983 function parse_PtgElfLel(blob/*::, length, opts*/) { argument
12984 blob.l += 2;
12985 return [parseuint16(blob), blob.read_shift(2) & 0x01];
13018 function parse_PtgList(blob/*::, length, opts*/) { argument
13019 blob.l += 2;
13020 var ixti = blob.read_shift(2);
13021 var flags = blob.read_shift(2);
13022 var idx = blob.read_shift(4);
13023 var c = blob.read_shift(2);
13024 var C = blob.read_shift(2);
13029 function parse_PtgSxName(blob/*::, length, opts*/) { argument
13030 blob.l += 2;
13031 return [blob.read_shift(4)];
13035 function parse_PtgSheet(blob, length, opts) { argument
13036 blob.l += 5;
13037 blob.l += 2;
13038 blob.l += (opts.biff == 2 ? 1 : 4);
13041 function parse_PtgEndSheet(blob, length, opts) { argument
13042 blob.l += (opts.biff == 2 ? 4 : 5);
13045 function parse_PtgMemAreaN(blob/*::, length, opts*/) { argument
13046 var type = (blob.read_shift(1) >>> 5) & 0x03;
13047 var cce = blob.read_shift(2);
13050 function parse_PtgMemNoMemN(blob/*::, length, opts*/) { argument
13051 var type = (blob.read_shift(1) >>> 5) & 0x03;
13052 var cce = blob.read_shift(2);
13055 function parse_PtgAttrNoop(blob/*::, length, opts*/) { argument
13056 blob.l += 4;
13171 function parse_RgbExtra(blob, length, rgce, opts) { argument
13172 if(opts.biff < 8) return parsenoop(blob, length);
13173 var target = blob.l + length;
13178 rgce[i][1] = parse_PtgExtraArray(blob, 0, opts);
13182 rgce[i][2] = parse_PtgExtraMem(blob, rgce[i][1], opts);
13187 rgce[i][1][1] = blob.read_shift(4);
13198 length = target - blob.l;
13200 //if(target !== blob.l && blob.l !== target - length) throw new Error(target + " != " + blob.l);
13201 if(length !== 0) o.push(parsenoop(blob, length));
13206 function parse_Rgce(blob, length, opts) { argument
13207 var target = blob.l + length;
13209 while(target != blob.l) {
13210 length = target - blob.l;
13211 id = blob[blob.l];
13213 if(id === 0x18 || id === 0x19) R = (id === 0x18 ? Ptg18 : Ptg19)[blob[blob.l + 1]];
13214 if(!R || !R.f) { /*ptgs.push*/(parsenoop(blob, length)); }
13215 else { ptgs.push([R.n, R.f(blob, length, opts)]); }
13613 function parse_ArrayParsedFormula(blob, length, opts/*::, ref*/) { argument
13614 var target = blob.l + length, len = opts.biff == 2 ? 1 : 2;
13615 var rgcb, cce = blob.read_shift(len); // length of rgce
13616 if(cce == 0xFFFF) return [[],parsenoop(blob, length-2)];
13617 var rgce = parse_Rgce(blob, cce, opts);
13618 if(length !== cce + len) rgcb = parse_RgbExtra(blob, length - cce - len, rgce, opts);
13619 blob.l = target;
13624 function parse_XLSCellParsedFormula(blob, length, opts) { argument
13625 var target = blob.l + length, len = opts.biff == 2 ? 1 : 2;
13626 var rgcb, cce = blob.read_shift(len); // length of rgce
13627 if(cce == 0xFFFF) return [[],parsenoop(blob, length-2)];
13628 var rgce = parse_Rgce(blob, cce, opts);
13629 if(length !== cce + len) rgcb = parse_RgbExtra(blob, length - cce - len, rgce, opts);
13630 blob.l = target;
13635 function parse_NameParsedFormula(blob, length, opts, cce) { argument
13636 var target = blob.l + length;
13637 var rgce = parse_Rgce(blob, cce, opts);
13639 if(target !== blob.l) rgcb = parse_RgbExtra(blob, target - blob.l, rgce, opts);
13644 function parse_SharedParsedFormula(blob, length, opts) { argument
13645 var target = blob.l + length;
13646 var rgcb, cce = blob.read_shift(2); // length of rgce
13647 var rgce = parse_Rgce(blob, cce, opts);
13648 if(cce == 0xFFFF) return [[],parsenoop(blob, length-2)];
13649 if(length !== cce + 2) rgcb = parse_RgbExtra(blob, target - cce - 2, rgce, opts);
13654 function parse_FormulaValue(blob/*::, length*/) { argument
13656 if(__readUInt16LE(blob,blob.l + 6) !== 0xFFFF) return [parse_Xnum(blob),'n'];
13657 switch(blob[blob.l]) {
13658 case 0x00: blob.l += 8; return ["String", 's'];
13659 case 0x01: b = blob[blob.l+2] === 0x1; blob.l += 8; return [b,'b'];
13660 case 0x02: b = blob[blob.l+2]; blob.l += 8; return [b,'e'];
13661 case 0x03: blob.l += 8; return ["",'s'];
13680 function parse_Formula(blob, length, opts) { argument
13681 var end = blob.l + length;
13682 var cell = parse_XLSCell(blob, 6);
13683 if(opts.biff == 2) ++blob.l;
13684 var val = parse_FormulaValue(blob,8);
13685 var flags = blob.read_shift(1);
13687 blob.read_shift(1);
13689 /*var chn = */blob.read_shift(4);
13692 var cbf = parse_XLSCellParsedFormula(blob, end - blob.l, opts);
19180 function slurp(RecordType, R, blob, length/*:number*/, opts)/*:any*/ { argument
19183 var d = blob.slice(blob.l,blob.l+l);
19193 blob.l += l;
19194 var nextrt = __readUInt16LE(blob,blob.l), next = XLSRecordEnum[nextrt];
19197 l = __readUInt16LE(blob,blob.l+2);
19198 start = blob.l + 4;
19203 d = blob.slice(start,blob.l+4+l);
19205 blob.l += 4+l;
19206 next = (XLSRecordEnum[nextrt = __readUInt16LE(blob, blob.l)]);
19245 function parse_workbook(blob, options/*:ParseOpts*/)/*:Workbook*/ { argument
19343 while(blob.l < blob.length - 1) {
19344 var s = blob.l;
19345 var RecordType = blob.read_shift(2);
19347 var length = (blob.l === blob.length ? 0 : blob.read_shift(2));
19350 //console.log(RecordType.toString(16), RecordType, R, blob.l, length, blob.length);
19351 //if(!R) console.log(blob.slice(blob.l, blob.l + length));
19358 var rt = blob.read_shift(2); length -= 2;
19361 blob.l += 10; length -= 10;
19364 //console.error(R,blob.l,length,blob.length);
19366 if(RecordType === 0x000a /* EOF */) val = /*::(*/R.f(blob, length, opts)/*:: :any)*/;
19367 else val = /*::(*/slurp(RecordType, R, blob, length, opts)/*:: :any)*/;
19376 if(!opts.enc) blob.l = 0;
19497 var fakebs8 = {pos: blob.l - length, name:cur_sheet};
19729 blob.l += length;
22466 case 'binary-data': break; // 10.4.5 TODO: b64 blob