text: var DO_NOT_EXPORT_CFB = true;
  /*::
  declare var Base64:any;
  declare var ReadShift:any;
  declare var CheckField:any;
  declare var prep_blob:any;
  declare var __readUInt32LE:any;
  declare var __readInt32LE:any;
  declare var __toBuffer:any;
  declare var __utf16le:any;
  declare var bconcat:any;
  declare var s2a:any;
  declare var chr0:any;
  declare var chr1:any;
  declare var new_buf:any;
  */
  /* cfb.js (C) 2013-present SheetJS -- http://sheetjs.com */
  /* vim: set ts=2: */
  /*jshint eqnull:true */
  /*exported CFB */
  /*global module, require:false, process:false, Buffer:false, Uint8Array:false */
  
  /*::
  declare var DO_NOT_EXPORT_CFB:?boolean;
  type SectorEntry = {
  	name?:string;
  	nodes?:Array<number>;
  	data:RawBytes;
  };
  type SectorList = {
  	[k:string|number]:SectorEntry;
  	name:?string;
  	fat_addrs:Array<number>;
  	ssz:number;
  }
  type CFBFiles = {[n:string]:CFBEntry};
  */
  /* [MS-CFB] v20130118 */
  var CFB = (function _CFB(){
  var exports/*:CFBModule*/ = /*::(*/{}/*:: :any)*/;
  exports.version = '0.13.2';
  /* [MS-CFB] 2.6.4 */
  function namecmp(l/*:string*/, r/*:string*/)/*:number*/ {
  	var L = l.split("/"), R = r.split("/");
  	for(var i = 0, c = 0, Z = Math.min(L.length, R.length); i < Z; ++i) {
  		if((c = L[i].length - R[i].length)) return c;
  		if(L[i] != R[i]) return L[i] < R[i] ? -1 : 1;
  	}
  	return L.length - R.length;
  }
  function dirname(p/*:string*/)/*:string*/ {
  	if(p.charAt(p.length - 1) == "/") return (p.slice(0,-1).indexOf("/") === -1) ? p : dirname(p.slice(0, -1));
  	var c = p.lastIndexOf("/");
  	return (c === -1) ? p : p.slice(0, c+1);
  }
  
  function filename(p/*:string*/)/*:string*/ {
  	if(p.charAt(p.length - 1) == "/") return filename(p.slice(0, -1));
  	var c = p.lastIndexOf("/");
  	return (c === -1) ? p : p.slice(c+1);
  }
  var fs/*:: = require('fs'); */;
  function get_fs() { return fs || (fs = require('fs')); }
  function parse(file/*:RawBytes*/, options/*:CFBReadOpts*/)/*:CFBContainer*/ {
  var mver = 3;
  var ssz = 512;
  var nmfs = 0; // number of mini FAT sectors
  var difat_sec_cnt = 0;
  var dir_start = 0;
  var minifat_start = 0;
  var difat_start = 0;
  
  var fat_addrs/*:Array<number>*/ = []; // locations of FAT sectors
  
  /* [MS-CFB] 2.2 Compound File Header */
  var blob/*:CFBlob*/ = /*::(*/file.slice(0,512)/*:: :any)*/;
  prep_blob(blob, 0);
  
  /* major version */
  var mv = check_get_mver(blob);
  mver = mv[0];
  switch(mver) {
  	case 3: ssz = 512; break; case 4: ssz = 4096; break;
  	default: throw new Error("Major Version: Expected 3 or 4 saw " + mver);
  }
  
  /* reprocess header */
  if(ssz !== 512) { blob = /*::(*/file.slice(0,ssz)/*:: :any)*/; prep_blob(blob, 28 /* blob.l */); }
  /* Save header for final object */
  var header/*:RawBytes*/ = file.slice(0,ssz);
  
  check_shifts(blob, mver);
  
  // Number of Directory Sectors
  var dir_cnt/*:number*/ = blob.read_shift(4, 'i');
  if(mver === 3 && dir_cnt !== 0) throw new Error('# Directory Sectors: Expected 0 saw ' + dir_cnt);
  
  // Number of FAT Sectors
  blob.l += 4;
  
  // First Directory Sector Location
  dir_start = blob.read_shift(4, 'i');
  
  // Transaction Signature
  blob.l += 4;
  
  // Mini Stream Cutoff Size
  blob.chk('00100000', 'Mini Stream Cutoff Size: ');
  
  // First Mini FAT Sector Location
  minifat_start = blob.read_shift(4, 'i');
  
  // Number of Mini FAT Sectors
  nmfs = blob.read_shift(4, 'i');
  
  // First DIFAT sector location
  difat_start = blob.read_shift(4, 'i');
  
  // Number of DIFAT Sectors
  difat_sec_cnt = blob.read_shift(4, 'i');
  
  // Grab FAT Sector Locations
  for(var q = -1, j = 0; j < 109; ++j) { /* 109 = (512 - blob.l)>>>2; */
  	q = blob.read_shift(4, 'i');
  	if(q<0) break;
  	fat_addrs[j] = q;
  }
  
  /** Break the file up into sectors */
  var sectors/*:Array<RawBytes>*/ = sectorify(file, ssz);
  
  sleuth_fat(difat_start, difat_sec_cnt, sectors, ssz, fat_addrs);
  
  /** Chains */
  var sector_list/*:SectorList*/ = make_sector_list(sectors, dir_start, fat_addrs, ssz);
  
  sector_list[dir_start].name = "!Directory";
  if(nmfs > 0 && minifat_start !== ENDOFCHAIN) sector_list[minifat_start].name = "!MiniFAT";
  sector_list[fat_addrs[0]].name = "!FAT";
  sector_list.fat_addrs = fat_addrs;
  sector_list.ssz = ssz;
  
  /* [MS-CFB] 2.6.1 Compound File Directory Entry */
  var files/*:CFBFiles*/ = {}, Paths/*:Array<string>*/ = [], FileIndex/*:CFBFileIndex*/ = [], FullPaths/*:Array<string>*/ = [], FullPathDir = {};
  read_directory(dir_start, sector_list, sectors, Paths, nmfs, files, FileIndex);
  
  build_full_paths(FileIndex, FullPathDir, FullPaths, Paths);
  Paths.shift();
  
  var o = {
  	FileIndex: FileIndex,
  	FullPaths: FullPaths,
  	FullPathDir: FullPathDir
  };
  
  // $FlowIgnore
  if(options && options.raw) o.raw = {header: header, sectors: sectors};
  return o;
  } // parse
  
  /* [MS-CFB] 2.2 Compound File Header -- read up to major version */
  function check_get_mver(blob/*:CFBlob*/)/*:[number, number]*/ {
  	// header signature 8
  	blob.chk(HEADER_SIGNATURE, 'Header Signature: ');
  
  	// clsid 16
  	blob.chk(HEADER_CLSID, 'CLSID: ');
  
  	// minor version 2
  	var mver/*:number*/ = blob.read_shift(2, 'u');
  
  	return [blob.read_shift(2,'u'), mver];
  }
  function check_shifts(blob/*:CFBlob*/, mver/*:number*/)/*:void*/ {
  	var shift = 0x09;
  
  	// Byte Order
  	//blob.chk('feff', 'Byte Order: '); // note: some writers put 0xffff
  	blob.l += 2;
  
  	// Sector Shift
  	switch((shift = blob.read_shift(2))) {
  		case 0x09: if(mver != 3) throw new Error('Sector Shift: Expected 9 saw ' + shift); break;
  		case 0x0c: if(mver != 4) throw new Error('Sector Shift: Expected 12 saw ' + shift); break;
  		default: throw new Error('Sector Shift: Expected 9 or 12 saw ' + shift);
  	}
  
  	// Mini Sector Shift
  	blob.chk('0600', 'Mini Sector Shift: ');
  
  	// Reserved
  	blob.chk('000000000000', 'Reserved: ');
  }
  
  /** Break the file up into sectors */
  function sectorify(file/*:RawBytes*/, ssz/*:number*/)/*:Array<RawBytes>*/ {
  	var nsectors = Math.ceil(file.length/ssz)-1;
  	var sectors/*:Array<RawBytes>*/ = [];
  	for(var i=1; i < nsectors; ++i) sectors[i-1] = file.slice(i*ssz,(i+1)*ssz);
  	sectors[nsectors-1] = file.slice(nsectors*ssz);
  	return sectors;
  }
  
  /* [MS-CFB] 2.6.4 Red-Black Tree */
  function build_full_paths(FI/*:CFBFileIndex*/, FPD/*:CFBFullPathDir*/, FP/*:Array<string>*/, Paths/*:Array<string>*/)/*:void*/ {
  	var i = 0, L = 0, R = 0, C = 0, j = 0, pl = Paths.length;
  	var dad/*:Array<number>*/ = [], q/*:Array<number>*/ = [];
  
  	for(; i < pl; ++i) { dad[i]=q[i]=i; FP[i]=Paths[i]; }
  
  	for(; j < q.length; ++j) {
  		i = q[j];
  		L = FI[i].L; R = FI[i].R; C = FI[i].C;
  		if(dad[i] === i) {
  			if(L !== -1 /*NOSTREAM*/ && dad[L] !== L) dad[i] = dad[L];
  			if(R !== -1 && dad[R] !== R) dad[i] = dad[R];
  		}
  		if(C !== -1 /*NOSTREAM*/) dad[C] = i;
  		if(L !== -1) { dad[L] = dad[i]; q.push(L); }
  		if(R !== -1) { dad[R] = dad[i]; q.push(R); }
  	}
  	for(i=1; i !== pl; ++i) if(dad[i] === i) {
  		if(R !== -1 /*NOSTREAM*/ && dad[R] !== R) dad[i] = dad[R];
  		else if(L !== -1 && dad[L] !== L) dad[i] = dad[L];
  	}
  
  	for(i=1; i < pl; ++i) {
  		if(FI[i].type === 0 /* unknown */) continue;
  		j = dad[i];
  		if(j === 0) FP[i] = FP[0] + "/" + FP[i];
  		else while(j !== 0 && j !== dad[j]) {
  			FP[i] = FP[j] + "/" + FP[i];
  			j = dad[j];
  		}
  		dad[i] = 0;
  	}
  
  	FP[0] += "/";
  	for(i=1; i < pl; ++i) {
  		if(FI[i].type !== 2 /* stream */) FP[i] += "/";
  		FPD[FP[i]] = FI[i];
  	}
  }
  
  /** Chase down the rest of the DIFAT chain to build a comprehensive list
      DIFAT chains by storing the next sector number as the last 32 bits */
  function sleuth_fat(idx/*:number*/, cnt/*:number*/, sectors/*:Array<RawBytes>*/, ssz/*:number*/, fat_addrs)/*:void*/ {
  	var q/*:number*/ = ENDOFCHAIN;
  	if(idx === ENDOFCHAIN) {
  		if(cnt !== 0) throw new Error("DIFAT chain shorter than expected");
  	} else if(idx !== -1 /*FREESECT*/) {
  		var sector = sectors[idx], m = (ssz>>>2)-1;
  		if(!sector) return;
  		for(var i = 0; i < m; ++i) {
  			if((q = __readInt32LE(sector,i*4)) === ENDOFCHAIN) break;
  			fat_addrs.push(q);
  		}
  		sleuth_fat(__readInt32LE(sector,ssz-4),cnt - 1, sectors, ssz, fat_addrs);
  	}
  }
  
  /** Follow the linked list of sectors for a given starting point */
  function get_sector_list(sectors/*:Array<RawBytes>*/, start/*:number*/, fat_addrs/*:Array<number>*/, ssz/*:number*/, chkd/*:?Array<boolean>*/)/*:SectorEntry*/ {
  	var buf/*:Array<number>*/ = [], buf_chain/*:Array<any>*/ = [];
  	if(!chkd) chkd = [];
  	var modulus = ssz - 1, j = 0, jj = 0;
  	for(j=start; j>=0;) {
  		chkd[j] = true;
  		buf[buf.length] = j;
  		buf_chain.push(sectors[j]);
  		var addr = fat_addrs[Math.floor(j*4/ssz)];
  		jj = ((j*4) & modulus);
  		if(ssz < 4 + jj) throw new Error("FAT boundary crossed: " + j + " 4 "+ssz);
  		if(!sectors[addr]) break;
  		j = __readInt32LE(sectors[addr], jj);
  	}
  	return {nodes: buf, data:__toBuffer([buf_chain])};
  }
  
  /** Chase down the sector linked lists */
  function make_sector_list(sectors/*:Array<RawBytes>*/, dir_start/*:number*/, fat_addrs/*:Array<number>*/, ssz/*:number*/)/*:SectorList*/ {
  	var sl = sectors.length, sector_list/*:SectorList*/ = ([]/*:any*/);
  	var chkd/*:Array<boolean>*/ = [], buf/*:Array<number>*/ = [], buf_chain/*:Array<RawBytes>*/ = [];
  	var modulus = ssz - 1, i=0, j=0, k=0, jj=0;
  	for(i=0; i < sl; ++i) {
  		buf = ([]/*:Array<number>*/);
  		k = (i + dir_start); if(k >= sl) k-=sl;
  		if(chkd[k]) continue;
  		buf_chain = [];
  		for(j=k; j>=0;) {
  			chkd[j] = true;
  			buf[buf.length] = j;
  			buf_chain.push(sectors[j]);
  			var addr/*:number*/ = fat_addrs[Math.floor(j*4/ssz)];
  			jj = ((j*4) & modulus);
  			if(ssz < 4 + jj) throw new Error("FAT boundary crossed: " + j + " 4 "+ssz);
  			if(!sectors[addr]) break;
  			j = __readInt32LE(sectors[addr], jj);
  		}
  		sector_list[k] = ({nodes: buf, data:__toBuffer([buf_chain])}/*:SectorEntry*/);
  	}
  	return sector_list;
  }
  
  /* [MS-CFB] 2.6.1 Compound File Directory Entry */
  function read_directory(dir_start/*:number*/, sector_list/*:SectorList*/, sectors/*:Array<RawBytes>*/, Paths/*:Array<string>*/, nmfs, files, FileIndex) {
  	var minifat_store = 0, pl = (Paths.length?2:0);
  	var sector = sector_list[dir_start].data;
  	var i = 0, namelen = 0, name;
  	for(; i < sector.length; i+= 128) {
  		var blob/*:CFBlob*/ = /*::(*/sector.slice(i, i+128)/*:: :any)*/;
  		prep_blob(blob, 64);
  		namelen = blob.read_shift(2);
  		name = __utf16le(blob,0,namelen-pl);
  		Paths.push(name);
  		var o/*:CFBEntry*/ = ({
  			name:  name,
  			type:  blob.read_shift(1),
  			color: blob.read_shift(1),
  			L:     blob.read_shift(4, 'i'),
  			R:     blob.read_shift(4, 'i'),
  			C:     blob.read_shift(4, 'i'),
  			clsid: blob.read_shift(16),
  			state: blob.read_shift(4, 'i'),
  			start: 0,
  			size: 0
  		});
  		var ctime/*:number*/ = blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2);
  		if(ctime !== 0) o.ct = read_date(blob, blob.l-8);
  		var mtime/*:number*/ = blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2);
  		if(mtime !== 0) o.mt = read_date(blob, blob.l-8);
  		o.start = blob.read_shift(4, 'i');
  		o.size = blob.read_shift(4, 'i');
  		if(o.size < 0 && o.start < 0) { o.size = o.type = 0; o.start = ENDOFCHAIN; o.name = ""; }
  		if(o.type === 5) { /* root */
  			minifat_store = o.start;
  			if(nmfs > 0 && minifat_store !== ENDOFCHAIN) sector_list[minifat_store].name = "!StreamData";
  			/*minifat_size = o.size;*/
  		} else if(o.size >= 4096 /* MSCSZ */) {
  			o.storage = 'fat';
  			if(sector_list[o.start] === undefined) sector_list[o.start] = get_sector_list(sectors, o.start, sector_list.fat_addrs, sector_list.ssz);
  			sector_list[o.start].name = o.name;
  			o.content = (sector_list[o.start].data.slice(0,o.size)/*:any*/);
  			prep_blob(o.content, 0);
  		} else {
  			o.storage = 'minifat';
  			if(minifat_store !== ENDOFCHAIN && o.start !== ENDOFCHAIN && sector_list[minifat_store]) {
  				o.content = (sector_list[minifat_store].data.slice(o.start*MSSZ,o.start*MSSZ+o.size)/*:any*/);
  				prep_blob(o.content, 0);
  			}
  		}
  		files[name] = o;
  		FileIndex.push(o);
  	}
  }
  
  function read_date(blob/*:RawBytes|CFBlob*/, offset/*:number*/)/*:Date*/ {
  	return new Date(( ( (__readUInt32LE(blob,offset+4)/1e7)*Math.pow(2,32)+__readUInt32LE(blob,offset)/1e7 ) - 11644473600)*1000);
  }
  
  function read_file(filename/*:string*/, options/*:CFBReadOpts*/) {
  	get_fs();
  	return parse(fs.readFileSync(filename), options);
  }
  
  function read(blob/*:RawBytes|string*/, options/*:CFBReadOpts*/) {
  	switch(options && options.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);
  	}
  	return parse(/*::typeof blob == 'string' ? new Buffer(blob, 'utf-8') : */blob, options);
  }
  
  function init_cfb(cfb/*:CFBContainer*/, opts/*:?any*/)/*:void*/ {
  	var o = opts || {}, root = o.root || "Root Entry";
  	if(!cfb.FullPaths) cfb.FullPaths = [];
  	if(!cfb.FileIndex) cfb.FileIndex = [];
  	if(cfb.FullPaths.length !== cfb.FileIndex.length) throw new Error("inconsistent CFB structure");
  	if(cfb.FullPaths.length === 0) {
  		cfb.FullPaths[0] = root + "/";
  		cfb.FileIndex[0] = ({ name: root, type: 5 }/*:any*/);
  	}
  	if(o.CLSID) cfb.FileIndex[0].clsid = o.CLSID;
  	seed_cfb(cfb);
  }
  function seed_cfb(cfb/*:CFBContainer*/)/*:void*/ {
  	var nm = "\u0001Sh33tJ5";
  	if(CFB.find(cfb, "/" + nm)) return;
  	var p = new_buf(4); p[0] = 55; p[1] = p[3] = 50; p[2] = 54;
  	cfb.FileIndex.push(({ name: nm, type: 2, content:p, size:4, L:69, R:69, C:69 }/*:any*/));
  	cfb.FullPaths.push(cfb.FullPaths[0] + nm);
  	rebuild_cfb(cfb);
  }
  function rebuild_cfb(cfb/*:CFBContainer*/, f/*:?boolean*/)/*:void*/ {
  	init_cfb(cfb);
  	var gc = false, s = false;
  	for(var i = cfb.FullPaths.length - 1; i >= 0; --i) {
  		var _file = cfb.FileIndex[i];
  		switch(_file.type) {
  			case 0:
  				if(s) gc = true;
  				else { cfb.FileIndex.pop(); cfb.FullPaths.pop(); }
  				break;
  			case 1: case 2: case 5:
  				s = true;
  				if(isNaN(_file.R * _file.L * _file.C)) gc = true;
  				if(_file.R > -1 && _file.L > -1 && _file.R == _file.L) gc = true;
  				break;
  			default: gc = true; break;
  		}
  	}
  	if(!gc && !f) return;
  
  	var now = new Date(1987, 1, 19), j = 0;
  	var data/*:Array<[string, CFBEntry]>*/ = [];
  	for(i = 0; i < cfb.FullPaths.length; ++i) {
  		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*/)]);
  	}
  
  	data.sort(function(x,y) { return namecmp(x[0], y[0]); });
  	cfb.FullPaths = []; cfb.FileIndex = [];
  	for(i = 0; i < data.length; ++i) { cfb.FullPaths[i] = data[i][0]; cfb.FileIndex[i] = data[i][1]; }
  	for(i = 0; i < data.length; ++i) {
  		var elt = cfb.FileIndex[i];
  		var nm = cfb.FullPaths[i];
  
  		elt.name =  filename(nm).replace("/","");
  		elt.L = elt.R = elt.C = -(elt.color = 1);
  		elt.size = elt.content ? elt.content.length : 0;
  		elt.start = 0;
  		elt.clsid = (elt.clsid || HEADER_CLSID);
  		if(i === 0) {
  			elt.C = data.length > 1 ? 1 : -1;
  			elt.size = 0;
  			elt.type = 5;
  		} else if(nm.slice(-1) == "/") {
  			for(j=i+1;j < data.length; ++j) if(dirname(cfb.FullPaths[j])==nm) break;
  			elt.C = j >= data.length ? -1 : j;
  			for(j=i+1;j < data.length; ++j) if(dirname(cfb.FullPaths[j])==dirname(nm)) break;
  			elt.R = j >= data.length ? -1 : j;
  			elt.type = 1;
  		} else {
  			if(dirname(cfb.FullPaths[i+1]||"") == dirname(nm)) elt.R = i + 1;
  			elt.type = 2;
  		}
  	}
  
  }
  
  function _write(cfb/*:CFBContainer*/, options/*:CFBWriteOpts*/)/*:RawBytes*/ {
  	rebuild_cfb(cfb);
  	var L = (function(cfb/*:CFBContainer*/)/*:Array<number>*/{
  		var mini_size = 0, fat_size = 0;
  		for(var i = 0; i < cfb.FileIndex.length; ++i) {
  			var file = cfb.FileIndex[i];
  			if(!file.content) continue;
  			/*:: if(file.content == null) throw new Error("unreachable"); */
  			var flen = file.content.length;
  			if(flen === 0){}
  			else if(flen < 0x1000) mini_size += (flen + 0x3F) >> 6;
  			else fat_size += (flen + 0x01FF) >> 9;
  		}
  		var dir_cnt = (cfb.FullPaths.length +3) >> 2;
  		var mini_cnt = (mini_size + 7) >> 3;
  		var mfat_cnt = (mini_size + 0x7F) >> 7;
  		var fat_base = mini_cnt + fat_size + dir_cnt + mfat_cnt;
  		var fat_cnt = (fat_base + 0x7F) >> 7;
  		var difat_cnt = fat_cnt <= 109 ? 0 : Math.ceil((fat_cnt-109)/0x7F);
  		while(((fat_base + fat_cnt + difat_cnt + 0x7F) >> 7) > fat_cnt) difat_cnt = ++fat_cnt <= 109 ? 0 : Math.ceil((fat_cnt-109)/0x7F);
  		var L =  [1, difat_cnt, fat_cnt, mfat_cnt, dir_cnt, fat_size, mini_size, 0];
  		cfb.FileIndex[0].size = mini_size << 6;
  		L[7] = (cfb.FileIndex[0].start=L[0]+L[1]+L[2]+L[3]+L[4]+L[5])+((L[6]+7) >> 3);
  		return L;
  	})(cfb);
  	var o = new_buf(L[7] << 9);
  	var i = 0, T = 0;
  	{
  		for(i = 0; i < 8; ++i) o.write_shift(1, HEADER_SIG[i]);
  		for(i = 0; i < 8; ++i) o.write_shift(2, 0);
  		o.write_shift(2, 0x003E);
  		o.write_shift(2, 0x0003);
  		o.write_shift(2, 0xFFFE);
  		o.write_shift(2, 0x0009);
  		o.write_shift(2, 0x0006);
  		for(i = 0; i < 3; ++i) o.write_shift(2, 0);
  		o.write_shift(4, 0);
  		o.write_shift(4, L[2]);
  		o.write_shift(4, L[0] + L[1] + L[2] + L[3] - 1);
  		o.write_shift(4, 0);
  		o.write_shift(4, 1<<12);
  		o.write_shift(4, L[3] ? L[0] + L[1] + L[2] - 1: ENDOFCHAIN);
  		o.write_shift(4, L[3]);
  		o.write_shift(-4, L[1] ? L[0] - 1: ENDOFCHAIN);
  		o.write_shift(4, L[1]);
  		for(i = 0; i < 109; ++i) o.write_shift(-4, i < L[2] ? L[1] + i : -1);
  	}
  	if(L[1]) {
  		for(T = 0; T < L[1]; ++T) {
  			for(; i < 236 + T * 127; ++i) o.write_shift(-4, i < L[2] ? L[1] + i : -1);
  			o.write_shift(-4, T === L[1] - 1 ? ENDOFCHAIN : T + 1);
  		}
  	}
  	var chainit = function(w/*:number*/)/*:void*/ {
  		for(T += w; i<T-1; ++i) o.write_shift(-4, i+1);
  		if(w) { ++i; o.write_shift(-4, ENDOFCHAIN); }
  	};
  	T = i = 0;
  	for(T+=L[1]; i<T; ++i) o.write_shift(-4, consts.DIFSECT);
  	for(T+=L[2]; i<T; ++i) o.write_shift(-4, consts.FATSECT);
  	chainit(L[3]);
  	chainit(L[4]);
  	var j/*:number*/ = 0, flen/*:number*/ = 0;
  	var file/*:CFBEntry*/ = cfb.FileIndex[0];
  	for(; j < cfb.FileIndex.length; ++j) {
  		file = cfb.FileIndex[j];
  		if(!file.content) continue;
  		/*:: if(file.content == null) throw new Error("unreachable"); */
  		flen = file.content.length;
  		if(flen < 0x1000) continue;
  		file.start = T;
  		chainit((flen + 0x01FF) >> 9);
  	}
  	chainit((L[6] + 7) >> 3);
  	while(o.l & 0x1FF) o.write_shift(-4, consts.ENDOFCHAIN);
  	T = i = 0;
  	for(j = 0; j < cfb.FileIndex.length; ++j) {
  		file = cfb.FileIndex[j];
  		if(!file.content) continue;
  		/*:: if(file.content == null) throw new Error("unreachable"); */
  		flen = file.content.length;
  		if(!flen || flen >= 0x1000) continue;
  		file.start = T;
  		chainit((flen + 0x3F) >> 6);
  	}
  	while(o.l & 0x1FF) o.write_shift(-4, consts.ENDOFCHAIN);
  	for(i = 0; i < L[4]<<2; ++i) {
  		var nm = cfb.FullPaths[i];
  		if(!nm || nm.length === 0) {
  			for(j = 0; j < 17; ++j) o.write_shift(4, 0);
  			for(j = 0; j < 3; ++j) o.write_shift(4, -1);
  			for(j = 0; j < 12; ++j) o.write_shift(4, 0);
  			continue;
  		}
  		file = cfb.FileIndex[i];
  		if(i === 0) file.start = file.size ? file.start - 1 : ENDOFCHAIN;
  		flen = 2*(file.name.length+1);
  		o.write_shift(64, file.name, "utf16le");
  		o.write_shift(2, flen);
  		o.write_shift(1, file.type);
  		o.write_shift(1, file.color);
  		o.write_shift(-4, file.L);
  		o.write_shift(-4, file.R);
  		o.write_shift(-4, file.C);
  		if(!file.clsid) for(j = 0; j < 4; ++j) o.write_shift(4, 0);
  		else o.write_shift(16, file.clsid, "hex");
  		o.write_shift(4, file.state || 0);
  		o.write_shift(4, 0); o.write_shift(4, 0);
  		o.write_shift(4, 0); o.write_shift(4, 0);
  		o.write_shift(4, file.start);
  		o.write_shift(4, file.size); o.write_shift(4, 0);
  	}
  	for(i = 1; i < cfb.FileIndex.length; ++i) {
  		file = cfb.FileIndex[i];
  		/*:: 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);
  		}
  	}
  	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);
  		}
  	}
  	while(o.l < o.length) o.write_shift(1, 0);
  	return o;
  }
  /* [MS-CFB] 2.6.4 (Unicode 3.0.1 case conversion) */
  function find(cfb/*:CFBContainer*/, path/*:string*/)/*:?CFBEntry*/ {
  	//return cfb.find(path);
  	var UCFullPaths/*:Array<string>*/ = cfb.FullPaths.map(function(x) { return x.toUpperCase(); });
  	var UCPaths/*:Array<string>*/ = UCFullPaths.map(function(x) { var y = x.split("/"); return y[y.length - (x.slice(-1) == "/" ? 2 : 1)]; });
  	var k/*:boolean*/ = false;
  	if(path.charCodeAt(0) === 47 /* "/" */) { k = true; path = UCFullPaths[0].slice(0, -1) + path; }
  	else k = path.indexOf("/") !== -1;
  	var UCPath/*:string*/ = path.toUpperCase();
  	var w/*:number*/ = k === true ? UCFullPaths.indexOf(UCPath) : UCPaths.indexOf(UCPath);
  	if(w !== -1) return cfb.FileIndex[w];
  
  	UCPath = UCPath.replace(chr0,'').replace(chr1,'!');
  	for(w = 0; w < UCFullPaths.length; ++w) {
  		if(UCFullPaths[w].replace(chr0,'').replace(chr1,'!') == UCPath) return cfb.FileIndex[w];
  		if(UCPaths[w].replace(chr0,'').replace(chr1,'!') == UCPath) return cfb.FileIndex[w];
  	}
  	return null;
  }
  /** CFB Constants */
  var MSSZ = 64; /* Mini Sector Size = 1<<6 */
  //var MSCSZ = 4096; /* Mini Stream Cutoff Size */
  /* 2.1 Compound File Sector Numbers and Types */
  var ENDOFCHAIN = -2;
  /* 2.2 Compound File Header */
  var HEADER_SIGNATURE = 'd0cf11e0a1b11ae1';
  var HEADER_SIG = [0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1];
  var HEADER_CLSID = '00000000000000000000000000000000';
  var consts = {
  	/* 2.1 Compund File Sector Numbers and Types */
  	MAXREGSECT: -6,
  	DIFSECT: -4,
  	FATSECT: -3,
  	ENDOFCHAIN: ENDOFCHAIN,
  	FREESECT: -1,
  	/* 2.2 Compound File Header */
  	HEADER_SIGNATURE: HEADER_SIGNATURE,
  	HEADER_MINOR_VERSION: '3e00',
  	MAXREGSID: -6,
  	NOSTREAM: -1,
  	HEADER_CLSID: HEADER_CLSID,
  	/* 2.6.1 Compound File Directory Entry */
  	EntryTypes: ['unknown','storage','stream','lockbytes','property','root']
  };
  
  function write_file(cfb/*:CFBContainer*/, filename/*:string*/, options/*:CFBWriteOpts*/)/*:void*/ {
  	get_fs();
  	var o = _write(cfb, options);
  	/*:: if(typeof Buffer == 'undefined' || !Buffer.isBuffer(o) || !(o instanceof Buffer)) throw new Error("unreachable"); */
  	fs.writeFileSync(filename, o);
  }
  
  function a2s(o/*:RawBytes*/)/*:string*/ {
  	var out = new Array(o.length);
  	for(var i = 0; i < o.length; ++i) out[i] = String.fromCharCode(o[i]);
  	return out.join("");
  }
  
  function write(cfb/*:CFBContainer*/, options/*:CFBWriteOpts*/)/*:RawBytes|string*/ {
  	var o = _write(cfb, options);
  	switch(options && options.type) {
  		case "file": get_fs(); fs.writeFileSync(options.filename, (o/*:any*/)); return o;
  		case "binary": return a2s(o);
  		case "base64": return Base64.encode(a2s(o));
  	}
  	return o;
  }
  function cfb_new(opts/*:?any*/)/*:CFBContainer*/ {
  	var o/*:CFBContainer*/ = ({}/*:any*/);
  	init_cfb(o, opts);
  	return o;
  }
  
  function cfb_add(cfb/*:CFBContainer*/, name/*:string*/, content/*:?RawBytes*/, opts/*:?any*/)/*:CFBEntry*/ {
  	init_cfb(cfb);
  	var file = CFB.find(cfb, name);
  	if(!file) {
  		var fpath/*:string*/ = cfb.FullPaths[0];
  		if(name.slice(0, fpath.length) == fpath) fpath = name;
  		else {
  			if(fpath.slice(-1) != "/") fpath += "/";
  			fpath = (fpath + name).replace("//","/");
  		}
  		file = ({name: filename(name), type: 2}/*:any*/);
  		cfb.FileIndex.push(file);
  		cfb.FullPaths.push(fpath);
  		CFB.utils.cfb_gc(cfb);
  	}
  	/*:: if(!file) throw new Error("unreachable"); */
  	file.content = (content/*:any*/);
  	file.size = content ? content.length : 0;
  	if(opts) {
  		if(opts.CLSID) file.clsid = opts.CLSID;
  	}
  	return file;
  }
  
  function cfb_del(cfb/*:CFBContainer*/, name/*:string*/)/*:boolean*/ {
  	init_cfb(cfb);
  	var file = CFB.find(cfb, name);
  	if(file) for(var j = 0; j < cfb.FileIndex.length; ++j) if(cfb.FileIndex[j] == file) {
  		cfb.FileIndex.splice(j, 1);
  		cfb.FullPaths.splice(j, 1);
  		return true;
  	}
  	return false;
  }
  
  function cfb_mov(cfb/*:CFBContainer*/, old_name/*:string*/, new_name/*:string*/)/*:boolean*/ {
  	init_cfb(cfb);
  	var file = CFB.find(cfb, old_name);
  	if(file) for(var j = 0; j < cfb.FileIndex.length; ++j) if(cfb.FileIndex[j] == file) {
  		cfb.FileIndex[j].name = filename(new_name);
  		cfb.FullPaths[j] = new_name;
  		return true;
  	}
  	return false;
  }
  
  function cfb_gc(cfb/*:CFBContainer*/)/*:void*/ { rebuild_cfb(cfb, true); }
  
  exports.find = find;
  exports.read = read;
  exports.parse = parse;
  exports.write = write;
  exports.writeFile = write_file;
  exports.utils = {
  	cfb_new: cfb_new,
  	cfb_add: cfb_add,
  	cfb_del: cfb_del,
  	cfb_mov: cfb_mov,
  	cfb_gc: cfb_gc,
  	ReadShift: ReadShift,
  	CheckField: CheckField,
  	prep_blob: prep_blob,
  	bconcat: bconcat,
  	consts: consts
  };
  
  return exports;
  })();
  
  if(typeof require !== 'undefined' && typeof module !== 'undefined' && typeof DO_NOT_EXPORT_CFB === 'undefined') { module.exports = CFB; }
  