{"version":3,"file":"vendors-63656810.xxxxxxxxxxxxxxxxxxxx.bundle.js","mappings":";;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AC1FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;ACxHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;AChMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;AClEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;ACtEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;AC1DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;AChHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;AC7ZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;ACrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;ACvFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACjGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","sources":["webpack://contact-management-web/./node_modules/read-excel-file/modules/read/coordinates.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/dropEmptyColumns.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/dropEmptyRows.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/getData.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/isDateTimestamp.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/parseCell.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/parseCellValue.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/parseCells.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/parseDate.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/parseDimensions.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/parseFilePaths.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/parseProperties.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/parseSharedStrings.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/parseSheet.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/parseStyles.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/readSheetNamesBrowser.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/readXlsx.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/readXlsxFileBrowser.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/readXlsxFileContents.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/schema/convertMapToSchema.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/schema/mapToObjects.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/schema/mapToObjects.legacy.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/schema/mapToObjects.spreadsheet.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/read/unpackXlsxFileBrowser.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/types/Boolean.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/types/Date.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/types/InvalidError.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/types/Number.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/types/String.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/xml/dom.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/xml/xlsx.js","webpack://contact-management-web/./node_modules/read-excel-file/modules/xml/xmlBrowser.js"],"sourcesContent":["// Maps \"A1\"-like coordinates to `{ row, column }` numeric coordinates.\nvar LETTERS = [\"\", \"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\", \"H\", \"I\", \"J\", \"K\", \"L\", \"M\", \"N\", \"O\", \"P\", \"Q\", \"R\", \"S\", \"T\", \"U\", \"V\", \"W\", \"X\", \"Y\", \"Z\"];\nexport function calculateDimensions(cells) {\n  var comparator = function comparator(a, b) {\n    return a - b;\n  };\n  var allRows = cells.map(function (cell) {\n    return cell.row;\n  }).sort(comparator);\n  var allCols = cells.map(function (cell) {\n    return cell.column;\n  }).sort(comparator);\n  var minRow = allRows[0];\n  var maxRow = allRows[allRows.length - 1];\n  var minCol = allCols[0];\n  var maxCol = allCols[allCols.length - 1];\n  return [{\n    row: minRow,\n    column: minCol\n  }, {\n    row: maxRow,\n    column: maxCol\n  }];\n}\n\n// Converts a letter coordinate to a digit coordinate.\n// Examples: \"A\" -> 1, \"B\" -> 2, \"Z\" -> 26, \"AA\" -> 27, etc.\nfunction columnLettersToNumber(columnLetters) {\n  // `for ... of ...` would require Babel polyfill for iterating a string.\n  var n = 0;\n  var i = 0;\n  while (i < columnLetters.length) {\n    n *= 26;\n    n += LETTERS.indexOf(columnLetters[i]);\n    i++;\n  }\n  return n;\n}\nexport function parseCellCoordinates(coords) {\n  // Coordinate examples: \"AA2091\", \"R988\", \"B1\".\n  coords = coords.split(/(\\d+)/);\n  return [\n  // Row.\n  parseInt(coords[1]),\n  // Column.\n  columnLettersToNumber(coords[0].trim())];\n}\n//# sourceMappingURL=coordinates.js.map","function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nexport default function dropEmptyColumns(data) {\n  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n    _ref$accessor = _ref.accessor,\n    accessor = _ref$accessor === void 0 ? function (_) {\n      return _;\n    } : _ref$accessor,\n    onlyTrimAtTheEnd = _ref.onlyTrimAtTheEnd;\n  var i = data[0].length - 1;\n  while (i >= 0) {\n    var empty = true;\n    for (var _iterator = _createForOfIteratorHelperLoose(data), _step; !(_step = _iterator()).done;) {\n      var row = _step.value;\n      if (accessor(row[i]) !== null) {\n        empty = false;\n        break;\n      }\n    }\n    if (empty) {\n      var j = 0;\n      while (j < data.length) {\n        data[j].splice(i, 1);\n        j++;\n      }\n    } else if (onlyTrimAtTheEnd) {\n      break;\n    }\n    i--;\n  }\n  return data;\n}\n//# sourceMappingURL=dropEmptyColumns.js.map","function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nexport default function dropEmptyRows(data) {\n  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n    rowIndexMap = _ref.rowIndexMap,\n    _ref$accessor = _ref.accessor,\n    accessor = _ref$accessor === void 0 ? function (_) {\n      return _;\n    } : _ref$accessor,\n    onlyTrimAtTheEnd = _ref.onlyTrimAtTheEnd;\n  // Drop empty rows.\n  var i = data.length - 1;\n  while (i >= 0) {\n    // Check if the row is empty.\n    var empty = true;\n    for (var _iterator = _createForOfIteratorHelperLoose(data[i]), _step; !(_step = _iterator()).done;) {\n      var cell = _step.value;\n      if (accessor(cell) !== null) {\n        empty = false;\n        break;\n      }\n    }\n    // Remove the empty row.\n    if (empty) {\n      data.splice(i, 1);\n      if (rowIndexMap) {\n        rowIndexMap.splice(i, 1);\n      }\n    } else if (onlyTrimAtTheEnd) {\n      break;\n    }\n    i--;\n  }\n  return data;\n}\n//# sourceMappingURL=dropEmptyRows.js.map","function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nfunction _iterableToArrayLimit(r, l) { var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t[\"return\"] && (u = t[\"return\"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nimport dropEmptyRows from './dropEmptyRows.js';\nimport dropEmptyColumns from './dropEmptyColumns.js';\nexport default function getData(sheet, options) {\n  var dimensions = sheet.dimensions,\n    cells = sheet.cells;\n\n  // If the sheet is empty.\n  if (cells.length === 0) {\n    return [];\n  }\n  var _dimensions = _slicedToArray(dimensions, 2),\n    leftTop = _dimensions[0],\n    rightBottom = _dimensions[1];\n\n  // Don't discard empty rows or columns at the start.\n  // https://github.com/catamphetamine/read-excel-file/issues/102\n  // const colsCount = (rightBottom.column - leftTop.column) + 1\n  // const rowsCount = (rightBottom.row - leftTop.row) + 1\n\n  var colsCount = rightBottom.column;\n  var rowsCount = rightBottom.row;\n\n  // Initialize spreadsheet data structure.\n  var data = new Array(rowsCount);\n  var i = 0;\n  while (i < rowsCount) {\n    data[i] = new Array(colsCount);\n    var j = 0;\n    while (j < colsCount) {\n      data[i][j] = null;\n      j++;\n    }\n    i++;\n  }\n\n  // Fill in spreadsheet `data`.\n  // (this code implies that `cells` aren't necessarily sorted by row and column:\n  //  maybe that's not correct, this piece code was initially copy-pasted\n  //  from some other library that used `XPath`)\n  for (var _iterator = _createForOfIteratorHelperLoose(cells), _step; !(_step = _iterator()).done;) {\n    var cell = _step.value;\n    // Don't discard empty rows or columns at the start.\n    // https://github.com/catamphetamine/read-excel-file/issues/102\n    // const rowIndex = cell.row - leftTop.row\n    // const columnIndex = cell.column - leftTop.column\n    var rowIndex = cell.row - 1;\n    var columnIndex = cell.column - 1;\n    // Ignore the data in the cell if it's outside of the spreadsheet's \"dimensions\".\n    if (columnIndex < colsCount && rowIndex < rowsCount) {\n      data[rowIndex][columnIndex] = cell.value;\n    }\n  }\n\n  // Fill in the row map.\n  var rowIndexMap = options.rowMap;\n  if (rowIndexMap) {\n    var _i = 0;\n    while (_i < data.length) {\n      rowIndexMap[_i] = _i;\n      _i++;\n    }\n  }\n\n  // Drop empty columns or rows.\n  data = dropEmptyRows(dropEmptyColumns(data, {\n    onlyTrimAtTheEnd: true\n  }), {\n    onlyTrimAtTheEnd: true,\n    rowIndexMap: rowIndexMap\n  });\n\n  // Optionally transform data before applying `schema`.\n  if (options.transformData) {\n    data = options.transformData(data);\n    // data = options.transformData(data, {\n    //   dropEmptyRowsAndColumns(data) {\n    //     return dropEmptyRows(dropEmptyColumns(data), { rowIndexMap })\n    //   }\n    // })\n  }\n\n  return data;\n}\n//# sourceMappingURL=getData.js.map","function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\n// XLSX does have \"d\" type for dates, but it's not commonly used.\n// Instead, it prefers using \"n\" type for storing dates as timestamps.\n//\n// Whether a numeric value is a number or a date timestamp, it sometimes could be\n// detected by looking at the value \"format\" and seeing if it's a date-specific one.\n// https://github.com/catamphetamine/read-excel-file/issues/3#issuecomment-395770777\n//\n// The list of generic numeric value \"formats\":\n// https://xlsxwriter.readthedocs.io/format.html#format-set-num-format\n//\nexport default function isDateTimestamp(styleId, styles, options) {\n  if (styleId) {\n    var style = styles[styleId];\n    if (!style) {\n      throw new Error(\"Cell style not found: \".concat(styleId));\n    }\n    if (!style.numberFormat) {\n      return false;\n    }\n    if (\n    // Whether it's a \"number format\" that's conventionally used for storing date timestamps.\n    BUILT_IN_DATE_NUMBER_FORMAT_IDS.indexOf(Number(style.numberFormat.id)) >= 0 ||\n    // Whether it's a \"number format\" that uses a \"formatting template\"\n    // that the developer is certain is a date formatting template.\n    options.dateFormat && style.numberFormat.template === options.dateFormat ||\n    // Whether the \"smart formatting template\" feature is not disabled\n    // and it has detected that it's a date formatting template by looking at it.\n    options.smartDateParser !== false && style.numberFormat.template && isDateTemplate(style.numberFormat.template)) {\n      return true;\n    }\n  }\n}\n\n// https://hexdocs.pm/xlsxir/number_styles.html\nvar BUILT_IN_DATE_NUMBER_FORMAT_IDS = [14, 15, 16, 17, 18, 19, 20, 21, 22, 27, 30, 36, 45, 46, 47, 50, 57];\n\n// On some date formats, there's an \"[$-414]\" prefix.\n// I don't have any idea what that is.\n//\n// https://stackoverflow.com/questions/4730152/what-indicates-an-office-open-xml-cell-contains-a-date-time-value\n//\n// Examples:\n//\n// * 27 (built-in format) \"[$-404]e/m/d\"\n// * 164 (custom format) \"[$-414]mmmm\\ yyyy;@\"\n//\nvar DATE_FORMAT_WEIRD_PREFIX = /^\\[\\$-414\\]/;\n\n// On some date formats, there's an \";@\" postfix.\n// I don't have any idea what that is.\n// Examples:\n//\n// * 164 (custom format) \"m/d/yyyy;@\"\n// * 164 (custom format) \"[$-414]mmmm\\ yyyy;@\"\n//\nvar DATE_FORMAT_WEIRD_POSTFIX = /;@$/;\nfunction isDateTemplate(template) {\n  // Date format tokens could be in upper case or in lower case.\n  // There seems to be no single standard.\n  // So lowercase the template first.\n  template = template.toLowerCase();\n\n  // On some date formats, there's an \"[$-414]\" prefix.\n  // I don't have any idea what that is. Trim it.\n  template = template.replace(DATE_FORMAT_WEIRD_PREFIX, '');\n\n  // On some date formats, there's an \";@\" postfix.\n  // I don't have any idea what that is. Trim it.\n  template = template.replace(DATE_FORMAT_WEIRD_POSTFIX, '');\n  var tokens = template.split(/\\W+/);\n  for (var _iterator = _createForOfIteratorHelperLoose(tokens), _step; !(_step = _iterator()).done;) {\n    var token = _step.value;\n    if (DATE_TEMPLATE_TOKENS.indexOf(token) < 0) {\n      return false;\n    }\n  }\n  return true;\n}\n\n// These tokens could be in upper case or in lower case.\n// There seems to be no single standard, so using lower case.\nvar DATE_TEMPLATE_TOKENS = [\n// Seconds (min two digits). Example: \"05\".\n'ss',\n// Minutes (min two digits). Example: \"05\". Could also be \"Months\". Weird.\n'mm',\n// Hours. Example: \"1\".\n'h',\n// Hours (min two digits). Example: \"01\".\n'hh',\n// \"AM\" part of \"AM/PM\". Lowercased just in case.\n'am',\n// \"PM\" part of \"AM/PM\". Lowercased just in case.\n'pm',\n// Day. Example: \"1\"\n'd',\n// Day (min two digits). Example: \"01\"\n'dd',\n// Month (numeric). Example: \"1\".\n'm',\n// Month (numeric, min two digits). Example: \"01\". Could also be \"Minutes\". Weird.\n'mm',\n// Month (shortened month name). Example: \"Jan\".\n'mmm',\n// Month (full month name). Example: \"January\".\n'mmmm',\n// Two-digit year. Example: \"20\".\n'yy',\n// Full year. Example: \"2020\".\n'yyyy',\n// I don't have any idea what \"e\" means.\n// It's used in \"built-in\" XLSX formats:\n// * 27 '[$-404]e/m/d';\n// * 36 '[$-404]e/m/d';\n// * 50 '[$-404]e/m/d';\n// * 57 '[$-404]e/m/d';\n'e'];\n//# sourceMappingURL=isDateTimestamp.js.map","import parseCellValue from './parseCellValue.js';\nimport { parseCellCoordinates } from './coordinates.js';\nimport { getCellValue, getCellInlineStringValue } from '../xml/xlsx.js';\nimport { getOuterXml } from '../xml/dom.js';\n\n// Example of a `<c/>`ell element:\n//\n// <c>\n//    <f>string</f> — formula.\n//    <v>string</v> — formula pre-computed value.\n//    <is>\n//       <t>string</t> — an `inlineStr` string (rather than a \"common string\" from a dictionary).\n//       <r>\n//          <rPr>\n//            ...\n//          </rPr>\n//          <t>string</t>\n//       </r>\n//       <rPh sb=\"1\" eb=\"1\">\n//          <t>string</t>\n//       </rPh>\n//       <phoneticPr fontId=\"1\"/>\n//    </is>\n//    <extLst>\n//       <ext>\n//          <!--any element-->\n//       </ext>\n//    </extLst>\n// </c>\n//\nexport default function parseCell(node, sheet, xml, values, styles, properties, options) {\n  var coords = parseCellCoordinates(node.getAttribute('r'));\n  var valueElement = getCellValue(sheet, node);\n\n  // For `xpath`, `value` can be `undefined` while for native `DOMParser` it's `null`.\n  // So using `value && ...` instead of `if (value !== undefined) { ... }` here\n  // for uniform compatibility with both `xpath` and native `DOMParser`.\n  var value = valueElement && valueElement.textContent;\n  var type;\n  if (node.hasAttribute('t')) {\n    type = node.getAttribute('t');\n  }\n  return {\n    row: coords[0],\n    column: coords[1],\n    value: parseCellValue(value, type, {\n      getInlineStringValue: function getInlineStringValue() {\n        return getCellInlineStringValue(sheet, node);\n      },\n      getInlineStringXml: function getInlineStringXml() {\n        return getOuterXml(node);\n      },\n      getStyleId: function getStyleId() {\n        return node.getAttribute('s');\n      },\n      styles: styles,\n      values: values,\n      properties: properties,\n      options: options\n    })\n  };\n}\n//# sourceMappingURL=parseCell.js.map","import parseDate from './parseDate.js';\nimport isDateTimestamp from './isDateTimestamp.js';\n\n// Parses a string `value` of a cell.\nexport default function parseCellValue(value, type, _ref) {\n  var getInlineStringValue = _ref.getInlineStringValue,\n    getInlineStringXml = _ref.getInlineStringXml,\n    getStyleId = _ref.getStyleId,\n    styles = _ref.styles,\n    values = _ref.values,\n    properties = _ref.properties,\n    options = _ref.options;\n  if (!type) {\n    // Default cell type is \"n\" (numeric).\n    // http://www.datypic.com/sc/ooxml/t-ssml_CT_Cell.html\n    type = 'n';\n  }\n\n  // Available Excel cell types:\n  // https://github.com/SheetJS/sheetjs/blob/19620da30be2a7d7b9801938a0b9b1fd3c4c4b00/docbits/52_datatype.md\n  //\n  // Some other document (seems to be old):\n  // http://webapp.docx4java.org/OnlineDemo/ecma376/SpreadsheetML/ST_CellType.html\n  //\n  switch (type) {\n    // XLSX tends to store all strings as \"shared\" (indexed) ones\n    // using \"s\" cell type (for saving on strage space).\n    // \"str\" cell type is then generally only used for storing\n    // formula-pre-calculated cell values.\n    case 'str':\n      value = parseString(value, options);\n      break;\n\n    // Sometimes, XLSX stores strings as \"inline\" strings rather than \"shared\" (indexed) ones.\n    // Perhaps the specification doesn't force it to use one or another.\n    // Example: `<sheetData><row r=\"1\"><c r=\"A1\" s=\"1\" t=\"inlineStr\"><is><t>Test 123</t></is></c></row></sheetData>`.\n    case 'inlineStr':\n      value = getInlineStringValue();\n      if (value === undefined) {\n        throw new Error(\"Unsupported \\\"inline string\\\" cell value structure: \".concat(getInlineStringXml()));\n      }\n      value = parseString(value, options);\n      break;\n\n    // XLSX tends to store string values as \"shared\" (indexed) ones.\n    // \"Shared\" strings is a way for an Excel editor to reduce\n    // the file size by storing \"commonly used\" strings in a dictionary\n    // and then referring to such strings by their index in that dictionary.\n    // Example: `<sheetData><row r=\"1\"><c r=\"A1\" s=\"1\" t=\"s\"><v>0</v></c></row></sheetData>`.\n    case 's':\n      // If a cell has no value then there's no `<c/>` element for it.\n      // If a `<c/>` element exists then it's not empty.\n      // The `<v/>`alue is a key in the \"shared strings\" dictionary of the\n      // XLSX file, so look it up in the `values` dictionary by the numeric key.\n      var sharedStringIndex = Number(value);\n      if (isNaN(sharedStringIndex)) {\n        throw new Error(\"Invalid \\\"shared\\\" string index: \".concat(value));\n      }\n      if (sharedStringIndex >= values.length) {\n        throw new Error(\"An out-of-bounds \\\"shared\\\" string index: \".concat(value));\n      }\n      value = values[sharedStringIndex];\n      value = parseString(value, options);\n      break;\n\n    // Boolean (TRUE/FALSE) values are stored as either \"1\" or \"0\"\n    // in cells of type \"b\".\n    case 'b':\n      if (value === '1') {\n        value = true;\n      } else if (value === '0') {\n        value = false;\n      } else {\n        throw new Error(\"Unsupported \\\"boolean\\\" cell value: \".concat(value));\n      }\n      break;\n\n    // XLSX specification seems to support cells of type \"z\":\n    // blank \"stub\" cells that should be ignored by data processing utilities.\n    case 'z':\n      value = undefined;\n      break;\n\n    // XLSX specification also defines cells of type \"e\" containing a numeric \"error\" code.\n    // It's not clear what that means though.\n    // They also wrote: \"and `w` property stores its common name\".\n    // It's unclear what they meant by that.\n    case 'e':\n      value = decodeError(value);\n      break;\n\n    // XLSX supports date cells of type \"d\", though seems like it (almost?) never\n    // uses it for storing dates, preferring \"n\" numeric timestamp cells instead.\n    // The value of a \"d\" cell is supposedly a string in \"ISO 8601\" format.\n    // I haven't seen an XLSX file having such cells.\n    // Example: `<sheetData><row r=\"1\"><c r=\"A1\" s=\"1\" t=\"d\"><v>2021-06-10T00:47:45.700Z</v></c></row></sheetData>`.\n    case 'd':\n      if (value === undefined) {\n        break;\n      }\n      var parsedDate = new Date(value);\n      if (isNaN(parsedDate.valueOf())) {\n        throw new Error(\"Unsupported \\\"date\\\" cell value: \".concat(value));\n      }\n      value = parsedDate;\n      break;\n\n    // Numeric cells have type \"n\".\n    case 'n':\n      if (value === undefined) {\n        break;\n      }\n      var isDateTimestampNumber = isDateTimestamp(getStyleId(), styles, options);\n      // XLSX does have \"d\" type for dates, but it's not commonly used.\n      // Instead, it prefers using \"n\" type for storing dates as timestamps.\n      if (isDateTimestampNumber) {\n        // Parse the number from string.\n        value = parseNumberDefault(value);\n        // Parse the number as a date timestamp.\n        value = parseDate(value, properties);\n      } else {\n        // Parse the number from string.\n        // Supports custom parsing function to work around javascript number encoding precision issues.\n        // https://gitlab.com/catamphetamine/read-excel-file/-/issues/85\n        value = (options.parseNumber || parseNumberDefault)(value);\n      }\n      break;\n    default:\n      throw new TypeError(\"Cell type not supported: \".concat(type));\n  }\n\n  // Convert empty values to `null`.\n  if (value === undefined) {\n    value = null;\n  }\n  return value;\n}\n\n// Decodes numeric error code to a string code.\n// https://github.com/SheetJS/sheetjs/blob/19620da30be2a7d7b9801938a0b9b1fd3c4c4b00/docbits/52_datatype.md\nfunction decodeError(errorCode) {\n  // While the error values are determined by the application,\n  // the following are some example error values that could be used:\n  switch (errorCode) {\n    case 0x00:\n      return '#NULL!';\n    case 0x07:\n      return '#DIV/0!';\n    case 0x0F:\n      return '#VALUE!';\n    case 0x17:\n      return '#REF!';\n    case 0x1D:\n      return '#NAME?';\n    case 0x24:\n      return '#NUM!';\n    case 0x2A:\n      return '#N/A';\n    case 0x2B:\n      return '#GETTING_DATA';\n    default:\n      // Such error code doesn't exist. I made it up.\n      return \"#ERROR_\".concat(errorCode);\n  }\n}\nfunction parseString(value, options) {\n  // In some weird cases, a developer might want to disable\n  // the automatic trimming of all strings.\n  // For example, leading spaces might express a tree-like hierarchy.\n  // https://github.com/catamphetamine/read-excel-file/pull/106#issuecomment-1136062917\n  if (options.trim !== false) {\n    value = value.trim();\n  }\n  if (value === '') {\n    value = undefined;\n  }\n  return value;\n}\n\n// Parses a number from string.\n// Throws an error if the number couldn't be parsed.\n// When parsing floating-point number, is affected by\n// the javascript number encoding precision issues:\n// https://www.youtube.com/watch?v=2gIxbTn7GSc\n// https://www.avioconsulting.com/blog/overcoming-javascript-numeric-precision-issues\nfunction parseNumberDefault(stringifiedNumber) {\n  var parsedNumber = Number(stringifiedNumber);\n  if (isNaN(parsedNumber)) {\n    throw new Error(\"Invalid \\\"numeric\\\" cell value: \".concat(stringifiedNumber));\n  }\n  return parsedNumber;\n}\n//# sourceMappingURL=parseCellValue.js.map","import parseCell from './parseCell.js';\nimport { getCells, getMergedCells } from '../xml/xlsx.js';\nexport default function parseCells(sheet, xml, values, styles, properties, options) {\n  var cells = getCells(sheet);\n  if (cells.length === 0) {\n    return [];\n  }\n\n  // const mergedCells = getMergedCells(sheet)\n  // for (const mergedCell of mergedCells) {\n  //   const [from, to] = mergedCell.split(':').map(parseCellCoordinates)\n  //   console.log('Merged Cell.', 'From:', from, 'To:', to)\n  // }\n\n  return cells.map(function (node) {\n    return parseCell(node, sheet, xml, values, styles, properties, options);\n  });\n}\n//# sourceMappingURL=parseCells.js.map","// Parses an Excel Date (\"serial\") into a corresponding javascript Date in UTC+0 timezone.\n// (with time equal to 00:00)\n//\n// https://www.pcworld.com/article/3063622/software/mastering-excel-date-time-serial-numbers-networkdays-datevalue-and-more.html\n// \"If you need to calculate dates in your spreadsheets,\n//  Excel uses its own unique system, which it calls Serial Numbers\".\n//\nexport default function parseExcelDate(excelSerialDate, options) {\n  // https://support.microsoft.com/en-gb/help/214330/differences-between-the-1900-and-the-1904-date-system-in-excel\n  if (options && options.epoch1904) {\n    excelSerialDate += 1462;\n  }\n\n  // \"Excel serial date\" is just\n  // the count of days since `01/01/1900`\n  // (seems that it may be even fractional).\n  //\n  // The count of days elapsed\n  // since `01/01/1900` (Excel epoch)\n  // till `01/01/1970` (Unix epoch).\n  // Accounts for leap years\n  // (19 of them, yielding 19 extra days).\n  var daysBeforeUnixEpoch = 70 * 365 + 19;\n\n  // An hour, approximately, because a minute\n  // may be longer than 60 seconds, due to \"leap seconds\".\n  //\n  // Still, Javascript `Date` (and UNIX time in general) intentionally\n  // drops the concept of \"leap seconds\" in order to make things simpler.\n  // So it's fine.\n  // https://stackoverflow.com/questions/53019726/where-are-the-leap-seconds-in-javascript\n  //\n  // \"The JavaScript Date object specifically adheres to the concept of Unix Time\n  //  (albeit with higher precision). This is part of the POSIX specification,\n  //  and thus is sometimes called \"POSIX Time\". It does not count leap seconds,\n  //  but rather assumes every day had exactly 86,400 seconds. You can read about\n  //  this in section 20.3.1.1 of the current ECMAScript specification, which states:\n  //\n  //  \"Time is measured in ECMAScript in milliseconds since 01 January, 1970 UTC.\n  //   In time values leap seconds are ignored. It is assumed that there are exactly\n  //   86,400,000 milliseconds per day.\"\n  //\n  //  The fact is, that the unpredictable nature of leap seconds makes them very\n  //  difficult to work with in APIs. One can't generally pass timestamps around\n  //  that need leap seconds tables to be interpreted correctly, and expect that\n  //  one system will interpret them the same as another. For example, while your\n  //  example timestamp 1483228826 is 2017-01-01T00:00:00Z on your system,\n  //  it would be interpreted as 2017-01-01T00:00:26Z on POSIX based systems,\n  //  or systems without leap second tables. So they aren't portable.\n  //  Even on systems that have full updated tables, there's no telling what those\n  //  tables will contain in the future (beyond the 6-month IERS announcement period),\n  //  so I can't produce a future timestamp without risk that it may eventually change.\n  //\n  //  To be clear - to support leap seconds in a programming language, the implementation\n  //  must go out of its way to do so, and must make tradeoffs that are not always acceptable.\n  //  Though there are exceptions, the general position is to not support them - not because\n  //  of any subversion or active countermeasures, but because supporting them properly is much,\n  //  much harder.\"\n  //\n  // https://en.wikipedia.org/wiki/Unix_time#Leap_seconds\n  // https://en.wikipedia.org/wiki/Leap_year\n  // https://en.wikipedia.org/wiki/Leap_second\n  //\n  var hour = 60 * 60 * 1000;\n  return new Date(Math.round((excelSerialDate - daysBeforeUnixEpoch) * 24 * hour));\n}\n//# sourceMappingURL=parseDate.js.map","function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nfunction _iterableToArrayLimit(r, l) { var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t[\"return\"] && (u = t[\"return\"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nimport { parseCellCoordinates } from './coordinates.js';\nimport { getDimensions } from '../xml/xlsx.js';\n\n// `dimensions` defines the spreadsheet area containing all non-empty cells.\n// https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.sheetdimension?view=openxml-2.8.1\nexport default function parseDimensions(sheet) {\n  var dimensions = getDimensions(sheet);\n  if (dimensions) {\n    dimensions = dimensions.split(':').map(parseCellCoordinates).map(function (_ref) {\n      var _ref2 = _slicedToArray(_ref, 2),\n        row = _ref2[0],\n        column = _ref2[1];\n      return {\n        row: row,\n        column: column\n      };\n    });\n    // Sometimes there can be just a single cell as a spreadsheet's \"dimensions\".\n    // For example, the default \"dimensions\" in Apache POI library is \"A1\",\n    // meaning that only the first cell in the spreadsheet is used.\n    //\n    // A quote from Apache POI library:\n    // \"Single cell ranges are formatted like single cell references (e.g. 'A1' instead of 'A1:A1').\"\n    //\n    if (dimensions.length === 1) {\n      dimensions = [dimensions[0], dimensions[0]];\n    }\n    return dimensions;\n  }\n}\n//# sourceMappingURL=parseDimensions.js.map","import { getRelationships } from '../xml/xlsx.js';\n\n/**\r\n * Returns sheet file paths.\r\n * Seems that the correct place to look for the `sheetId` -> `filename` mapping\r\n * is `xl/_rels/workbook.xml.rels` file.\r\n * https://github.com/tidyverse/readxl/issues/104\r\n * @param  {string} content — `xl/_rels/workbook.xml.rels` file contents.\r\n * @param  {object} xml\r\n * @return {object}\r\n */\nexport default function parseFilePaths(content, xml) {\n  // Example:\n  // <Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\n  //   ...\n  //   <Relationship\n  //     Id=\"rId3\"\n  //     Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet\"\n  //     Target=\"worksheets/sheet1.xml\"/>\n  // </Relationships>\n  var document = xml.createDocument(content);\n  var filePaths = {\n    sheets: {},\n    sharedStrings: undefined,\n    styles: undefined\n  };\n  var addFilePathInfo = function addFilePathInfo(relationship) {\n    var filePath = relationship.getAttribute('Target');\n    var fileType = relationship.getAttribute('Type');\n    switch (fileType) {\n      case 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles':\n        filePaths.styles = getFilePath(filePath);\n        break;\n      case 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings':\n        filePaths.sharedStrings = getFilePath(filePath);\n        break;\n      case 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet':\n        filePaths.sheets[relationship.getAttribute('Id')] = getFilePath(filePath);\n        break;\n    }\n  };\n  getRelationships(document).forEach(addFilePathInfo);\n\n  // Seems like \"sharedStrings.xml\" is not required to exist.\n  // For example, when the spreadsheet doesn't contain any strings.\n  // https://github.com/catamphetamine/read-excel-file/issues/85\n  // if (!filePaths.sharedStrings) {\n  //   throw new Error('\"sharedStrings.xml\" file not found in the *.xlsx file')\n  // }\n\n  return filePaths;\n}\nfunction getFilePath(path) {\n  // Normally, `path` is a relative path inside the ZIP archive,\n  // like \"worksheets/sheet1.xml\", or \"sharedStrings.xml\", or \"styles.xml\".\n  // There has been one weird case when file path was an absolute path,\n  // like \"/xl/worksheets/sheet1.xml\" (specifically for sheets):\n  // https://github.com/catamphetamine/read-excel-file/pull/95\n  // Other libraries (like `xlsx`) and software (like Google Docs)\n  // seem to support such absolute file paths, so this library does too.\n  if (path[0] === '/') {\n    return path.slice('/'.length);\n  }\n  // // Seems like a path could also be a URL.\n  // // http://officeopenxml.com/anatomyofOOXML-xlsx.php\n  // if (/^[a-z]+\\:\\/\\//.test(path)) {\n  //   return path\n  // }\n  return 'xl/' + path;\n}\n//# sourceMappingURL=parseFilePaths.js.map","import { getWorkbookProperties, getSheets } from '../xml/xlsx.js';\n\n// I guess `xl/workbook.xml` file should always be present inside the *.xlsx archive.\nexport default function parseProperties(content, xml) {\n  var book = xml.createDocument(content);\n  var properties = {};\n\n  // Read `<workbookPr/>` element to detect whether dates are 1900-based or 1904-based.\n  // https://support.microsoft.com/en-gb/help/214330/differences-between-the-1900-and-the-1904-date-system-in-excel\n  // http://webapp.docx4java.org/OnlineDemo/ecma376/SpreadsheetML/workbookPr.html\n\n  var workbookProperties = getWorkbookProperties(book);\n  if (workbookProperties && workbookProperties.getAttribute('date1904') === '1') {\n    properties.epoch1904 = true;\n  }\n\n  // Get sheets info (indexes, names, if they're available).\n  // Example:\n  // <sheets>\n  //   <sheet\n  //     xmlns:ns=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\"\n  //     name=\"Sheet1\"\n  //     sheetId=\"1\"\n  //     ns:id=\"rId3\"/>\n  // </sheets>\n  // http://www.datypic.com/sc/ooxml/e-ssml_sheet-1.html\n\n  properties.sheets = [];\n  var addSheetInfo = function addSheetInfo(sheet) {\n    if (sheet.getAttribute('name')) {\n      properties.sheets.push({\n        id: sheet.getAttribute('sheetId'),\n        name: sheet.getAttribute('name'),\n        relationId: sheet.getAttribute('r:id')\n      });\n    }\n  };\n  getSheets(book).forEach(addSheetInfo);\n  return properties;\n}\n//# sourceMappingURL=parseProperties.js.map","import { getSharedStrings } from '../xml/xlsx.js';\nexport default function parseSharedStrings(content, xml) {\n  if (!content) {\n    return [];\n  }\n  return getSharedStrings(xml.createDocument(content));\n}\n//# sourceMappingURL=parseSharedStrings.js.map","import parseCells from './parseCells.js';\nimport parseDimensions from './parseDimensions.js';\nimport { calculateDimensions } from './coordinates.js';\nexport default function parseSheet(content, xml, values, styles, properties, options) {\n  var sheet = xml.createDocument(content);\n  var cells = parseCells(sheet, xml, values, styles, properties, options);\n\n  // `dimensions` defines the spreadsheet area containing all non-empty cells.\n  // https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.sheetdimension?view=openxml-2.8.1\n  var dimensions = parseDimensions(sheet) || calculateDimensions(cells);\n  return {\n    cells: cells,\n    dimensions: dimensions\n  };\n}\n//# sourceMappingURL=parseSheet.js.map","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport { getBaseStyles, getCellStyles, getNumberFormats } from '../xml/xlsx.js';\n\n// http://officeopenxml.com/SSstyles.php\n// Returns an array of cell styles.\n// A cell style index is its ID.\nexport default function parseStyles(content, xml) {\n  if (!content) {\n    return {};\n  }\n\n  // https://social.msdn.microsoft.com/Forums/sqlserver/en-US/708978af-b598-45c4-a598-d3518a5a09f0/howwhen-is-cellstylexfs-vs-cellxfs-applied-to-a-cell?forum=os_binaryfile\n  // https://www.office-forums.com/threads/cellxfs-cellstylexfs.2163519/\n  var doc = xml.createDocument(content);\n  var baseStyles = getBaseStyles(doc).map(parseCellStyle);\n  var numberFormats = getNumberFormats(doc).map(parseNumberFormatStyle).reduce(function (formats, format) {\n    // Format ID is a numeric index.\n    // There're some standard \"built-in\" formats (in Excel) up to about `100`.\n    formats[format.id] = format;\n    return formats;\n  }, []);\n  var getCellStyle = function getCellStyle(xf) {\n    if (xf.hasAttribute('xfId')) {\n      return _objectSpread(_objectSpread({}, baseStyles[xf.xfId]), parseCellStyle(xf, numberFormats));\n    }\n    return parseCellStyle(xf, numberFormats);\n  };\n  return getCellStyles(doc).map(getCellStyle);\n}\nfunction parseNumberFormatStyle(numFmt) {\n  return {\n    id: numFmt.getAttribute('numFmtId'),\n    template: numFmt.getAttribute('formatCode')\n  };\n}\n\n// http://www.datypic.com/sc/ooxml/e-ssml_xf-2.html\nfunction parseCellStyle(xf, numFmts) {\n  var style = {};\n  if (xf.hasAttribute('numFmtId')) {\n    var numberFormatId = xf.getAttribute('numFmtId');\n    // Built-in number formats don't have a `<numFmt/>` element in `styles.xml`.\n    // https://hexdocs.pm/xlsxir/number_styles.html\n    if (numFmts[numberFormatId]) {\n      style.numberFormat = numFmts[numberFormatId];\n    } else {\n      style.numberFormat = {\n        id: numberFormatId\n      };\n    }\n  }\n  return style;\n}\n//# sourceMappingURL=parseStyles.js.map","import readXlsxFile from './readXlsxFileBrowser.js';\n\n/**\r\n * Reads the list of sheet names in an XLSX file in a web browser.\r\n * @param  {file} file - A file being uploaded in the browser.\r\n * @return {Promise} Resolves to an array of objects of shape `{ name: string }`.\r\n */\nexport default function readSheetNames(file) {\n  return readXlsxFile(file, {\n    getSheets: true\n  }).then(function (sheets) {\n    return sheets.map(function (sheet) {\n      return sheet.name;\n    });\n  });\n}\n//# sourceMappingURL=readSheetNamesBrowser.js.map","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nfunction _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport parseProperties from './parseProperties.js';\nimport parseFilePaths from './parseFilePaths.js';\nimport parseStyles from './parseStyles.js';\nimport parseSharedStrings from './parseSharedStrings.js';\nimport parseSheet from './parseSheet.js';\nimport getData from './getData.js';\n\n// For an introduction in reading `*.xlsx` files see \"The minimum viable XLSX reader\":\n// https://www.brendanlong.com/the-minimum-viable-xlsx-reader.html\n\n/**\r\n * Reads an (unzipped) XLSX file structure into a 2D array of cells.\r\n * @param  {object} contents - A list of XML files inside XLSX file (which is a zipped directory).\r\n * @param  {number?} options.sheet - Workbook sheet id (`1` by default).\r\n * @param  {string?} options.dateFormat - Date format, e.g. \"mm/dd/yyyy\". Values having this format template set will be parsed as dates.\r\n * @param  {object} contents - A list of XML files inside XLSX file (which is a zipped directory).\r\n * @return {object} An object of shape `{ data, cells, properties }`. `data: string[][]` is an array of rows, each row being an array of cell values. `cells: string[][]` is an array of rows, each row being an array of cells. `properties: object` is the spreadsheet properties (e.g. whether date epoch is 1904 instead of 1900).\r\n */\nexport default function readXlsx(contents, xml) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  if (!options.sheet) {\n    options = _objectSpread({\n      sheet: 1\n    }, options);\n  }\n  var getXmlFileContent = function getXmlFileContent(filePath) {\n    if (!contents[filePath]) {\n      throw new Error(\"\\\"\".concat(filePath, \"\\\" file not found inside the *.xlsx file zip archive\"));\n    }\n    return contents[filePath];\n  };\n\n  // Some Excel editors don't want to use standard naming scheme for sheet files.\n  // https://github.com/tidyverse/readxl/issues/104\n  var filePaths = parseFilePaths(getXmlFileContent('xl/_rels/workbook.xml.rels'), xml);\n\n  // Default file path for \"shared strings\": \"xl/sharedStrings.xml\".\n  var values = filePaths.sharedStrings ? parseSharedStrings(getXmlFileContent(filePaths.sharedStrings), xml) : [];\n\n  // Default file path for \"styles\": \"xl/styles.xml\".\n  var styles = filePaths.styles ? parseStyles(getXmlFileContent(filePaths.styles), xml) : {};\n  var properties = parseProperties(getXmlFileContent('xl/workbook.xml'), xml);\n\n  // A feature for getting the list of sheets in an Excel file.\n  // https://github.com/catamphetamine/read-excel-file/issues/14\n  if (options.getSheets) {\n    return properties.sheets.map(function (_ref) {\n      var name = _ref.name;\n      return {\n        name: name\n      };\n    });\n  }\n\n  // Find the sheet by name, or take the first one.\n  var sheetId = getSheetId(options.sheet, properties.sheets);\n\n  // If the sheet wasn't found then throw an error.\n  // Example: \"xl/worksheets/sheet1.xml\".\n  if (!sheetId || !filePaths.sheets[sheetId]) {\n    throw createSheetNotFoundError(options.sheet, properties.sheets);\n  }\n\n  // Parse sheet data.\n  var sheet = parseSheet(getXmlFileContent(filePaths.sheets[sheetId]), xml, values, styles, properties, options);\n  options = _objectSpread({\n    // Create a `rowIndexMap` for the original dataset, if not passed,\n    // because \"empty\" rows will be dropped from the input data.\n    rowMap: []\n  }, options);\n\n  // Get spreadsheet data.\n  var data = getData(sheet, options);\n\n  // Can return properties, if required.\n  if (options.properties) {\n    return {\n      data: data,\n      properties: properties\n    };\n  }\n\n  // Return spreadsheet data.\n  return data;\n}\nfunction getSheetId(sheet, sheets) {\n  if (typeof sheet === 'number') {\n    var _sheet = sheets[sheet - 1];\n    return _sheet && _sheet.relationId;\n  }\n  for (var _iterator = _createForOfIteratorHelperLoose(sheets), _step; !(_step = _iterator()).done;) {\n    var _sheet2 = _step.value;\n    if (_sheet2.name === sheet) {\n      return _sheet2.relationId;\n    }\n  }\n}\nfunction createSheetNotFoundError(sheet, sheets) {\n  var sheetsList = sheets && sheets.map(function (sheet, i) {\n    return \"\\\"\".concat(sheet.name, \"\\\" (#\").concat(i + 1, \")\");\n  }).join(', ');\n  return new Error(\"Sheet \".concat(typeof sheet === 'number' ? '#' + sheet : '\"' + sheet + '\"', \" not found in the *.xlsx file.\").concat(sheets ? ' Available sheets: ' + sheetsList + '.' : ''));\n}\n//# sourceMappingURL=readXlsx.js.map","import xml from '../xml/xmlBrowser.js';\nimport unpackXlsxFile from './unpackXlsxFileBrowser.js';\nimport readXlsxFileContents from './readXlsxFileContents.js';\n\n/**\r\n * Reads XLSX file into a 2D array of cells in a browser.\r\n * @param  {file} file - A file being uploaded in the browser.\r\n * @param  {object?} options\r\n * @param  {(number|string)?} options.sheet - Excel document sheet to read. Defaults to `1`. Will only read this sheet and skip others.\r\n * @return {Promise} Resolves to a 2D array of cells: an array of rows, each row being an array of cells.\r\n */\nexport default function readXlsxFile(file) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return unpackXlsxFile(file).then(function (entries) {\n    return readXlsxFileContents(entries, xml, options);\n  });\n}\n//# sourceMappingURL=readXlsxFileBrowser.js.map","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nvar _excluded = [\"schema\", \"map\"];\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\nimport readXlsx from './readXlsx.js';\nimport mapToObjectsLegacyBehavior from './schema/mapToObjects.legacy.js';\nimport mapToObjectsSpreadsheetBehavior from './schema/mapToObjects.spreadsheet.js';\nimport convertMapToSchema from './schema/convertMapToSchema.js';\nexport default function readXlsxFileContents(entries, xml, _ref) {\n  var schema = _ref.schema,\n    map = _ref.map,\n    options = _objectWithoutProperties(_ref, _excluded);\n  if (!schema && map) {\n    schema = convertMapToSchema(map);\n  }\n  // `readXlsx()` adds `options.rowMap`, if not passed.\n  var result = readXlsx(entries, xml, _objectSpread(_objectSpread({}, options), {}, {\n    properties: schema || options.properties\n  }));\n  if (schema) {\n    return mapToObjectsSpreadsheetBehavior(mapToObjectsLegacyBehavior, result.data, schema, _objectSpread(_objectSpread({}, options), {}, {\n      properties: result.properties\n    }));\n  }\n  return result;\n}\n//# sourceMappingURL=readXlsxFileContents.js.map","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nexport default function convertMapToSchema(map) {\n  var schema = {};\n  for (var _i = 0, _Object$keys = Object.keys(map); _i < _Object$keys.length; _i++) {\n    var key = _Object$keys[_i];\n    var prop = map[key];\n    var type = void 0;\n    if (_typeof(prop) === 'object') {\n      prop = Object.keys(map[key])[0];\n      type = convertMapToSchema(map[key][prop]);\n    }\n    schema[key] = {\n      prop: prop\n    };\n    if (type) {\n      schema[key].type = type;\n    }\n  }\n  return schema;\n}\n//# sourceMappingURL=convertMapToSchema.js.map","function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _iterableToArrayLimit(r, l) { var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t[\"return\"] && (u = t[\"return\"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nfunction _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nfunction _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport NumberType from '../../types/Number.js';\nimport StringType from '../../types/String.js';\nimport BooleanType from '../../types/Boolean.js';\nimport DateType from '../../types/Date.js';\nvar DEFAULT_OPTIONS = {\n  schemaPropertyValueForMissingColumn: undefined,\n  schemaPropertyValueForUndefinedCellValue: undefined,\n  schemaPropertyValueForNullCellValue: null,\n  schemaPropertyShouldSkipRequiredValidationForMissingColumn: function schemaPropertyShouldSkipRequiredValidationForMissingColumn() {\n    return false;\n  },\n  // `getEmptyObjectValue(object, { path })` applies to both the top-level object\n  // and any of its sub-objects.\n  getEmptyObjectValue: function getEmptyObjectValue() {\n    return null;\n  },\n  getEmptyArrayValue: function getEmptyArrayValue() {\n    return null;\n  },\n  isColumnOriented: false,\n  arrayValueSeparator: ','\n};\n\n/**\r\n * (this function is exported from `read-excel-file/map`)\r\n * Converts spreadsheet-alike data structure into an array of objects.\r\n * The first row should be the list of column headers.\r\n * @param {any[][]} data - An array of rows, each row being an array of cells.\r\n * @param {object} schema\r\n * @param {object} [options]\r\n * @param {null} [options.schemaPropertyValueForMissingColumn] — By default, when some of the `schema` columns are missing in the input `data`, those properties are set to `undefined` in the output objects. Pass `schemaPropertyValueForMissingColumn: null` to set such \"missing column\" properties to `null` in the output objects.\r\n * @param {null} [options.schemaPropertyValueForNullCellValue] — By default, when it encounters a `null` value in a cell in input `data`, it sets it to `undefined` in the output object. Pass `schemaPropertyValueForNullCellValue: null` to make it set such values as `null`s in output objects.\r\n * @param {null} [options.schemaPropertyValueForUndefinedCellValue] — By default, when it encounters an `undefined` value in a cell in input `data`, it it sets it to `undefined` in the output object. Pass `schemaPropertyValueForUndefinedCellValue: null` to make it set such values as `null`s in output objects.\r\n * @param {boolean} [options.schemaPropertyShouldSkipRequiredValidationForMissingColumn(column: string, { object })] — By default, it does apply `required` validation to `schema` properties for which columns are missing in the input `data`. One could pass a custom `schemaPropertyShouldSkipRequiredValidationForMissingColumn(column, { object })` to disable `required` validation for missing columns in some or all cases.\r\n * @param {function} [options.getEmptyObjectValue(object, { path })] — By default, it returns `null` for an \"empty\" resulting object. One could override that value using `getEmptyObjectValue(object, { path })` parameter. The value applies to both top-level object and any nested sub-objects in case of a nested schema, hence the additional `path?: string` parameter.\r\n * @param {function} [getEmptyArrayValue(array, { path })] — By default, it returns `null` for an \"empty\" array value. One could override that value using `getEmptyArrayValue(array, { path })` parameter.\r\n * @param {boolean} [options.isColumnOriented] — By default, the headers are assumed to be the first row in the `data`. Pass `isColumnOriented: true` if the headers are the first column in the `data`. i.e. if `data` is \"transposed\".\r\n * @param {object} [options.rowIndexMap] — Custom row index mapping `data` rows. If present, will overwrite the indexes of `data` rows with the indexes from this `rowIndexMap`.\r\n * @return {object[]}\r\n */\nexport default function mapToObjects(data, schema, options) {\n  if (options) {\n    options = _objectSpread(_objectSpread({}, DEFAULT_OPTIONS), options);\n  } else {\n    options = DEFAULT_OPTIONS;\n  }\n  var _options = options,\n    isColumnOriented = _options.isColumnOriented,\n    rowIndexMap = _options.rowIndexMap;\n  validateSchema(schema);\n  if (isColumnOriented) {\n    data = transpose(data);\n  }\n  var columns = data[0];\n  var results = [];\n  var errors = [];\n  for (var i = 1; i < data.length; i++) {\n    var result = read(schema, data[i], i, undefined, columns, errors, options);\n    results.push(result);\n  }\n\n  // Set the correct `row` number in `errors` if a custom `rowIndexMap` is supplied.\n  if (rowIndexMap) {\n    for (var _iterator = _createForOfIteratorHelperLoose(errors), _step; !(_step = _iterator()).done;) {\n      var error = _step.value;\n      // Convert the `row` index in `data` to the\n      // actual `row` index in the spreadsheet.\n      // `- 1` converts row number to row index.\n      // `+ 1` converts row index to row number.\n      error.row = rowIndexMap[error.row - 1] + 1;\n    }\n  }\n  return {\n    rows: results,\n    errors: errors\n  };\n}\nfunction read(schema, row, rowIndex, path, columns, errors, options) {\n  var object = {};\n  var isEmptyObject = true;\n  var createError = function createError(_ref) {\n    var column = _ref.column,\n      value = _ref.value,\n      errorMessage = _ref.error,\n      reason = _ref.reason;\n    var error = {\n      error: errorMessage,\n      row: rowIndex + 1,\n      column: column,\n      value: value\n    };\n    if (reason) {\n      error.reason = reason;\n    }\n    if (schema[column].type) {\n      error.type = schema[column].type;\n    }\n    return error;\n  };\n  var pendingRequiredChecks = [];\n\n  // For each schema entry.\n  var _loop = function _loop() {\n    var key = _Object$keys[_i];\n    var schemaEntry = schema[key];\n    var isNestedSchema = _typeof(schemaEntry.type) === 'object' && !Array.isArray(schemaEntry.type);\n\n    // The path of this property inside the resulting object.\n    var propertyPath = \"\".concat(path || '', \".\").concat(schemaEntry.prop);\n\n    // Read the cell value for the schema entry.\n    var cellValue;\n    var columnIndex = columns.indexOf(key);\n    var isMissingColumn = columnIndex < 0;\n    if (!isMissingColumn) {\n      cellValue = row[columnIndex];\n    }\n    var value;\n    var error;\n    var reason;\n\n    // Get property `value` from cell value.\n    if (isNestedSchema) {\n      value = read(schemaEntry.type, row, rowIndex, propertyPath, columns, errors, options);\n    } else {\n      if (isMissingColumn) {\n        value = options.schemaPropertyValueForMissingColumn;\n      } else if (cellValue === undefined) {\n        value = options.schemaPropertyValueForUndefinedCellValue;\n      } else if (cellValue === null) {\n        value = options.schemaPropertyValueForNullCellValue;\n      } else if (Array.isArray(schemaEntry.type)) {\n        var array = parseArray(cellValue, options.arrayValueSeparator).map(function (_value) {\n          if (error) {\n            return;\n          }\n          var result = parseValue(_value, schemaEntry, options);\n          if (result.error) {\n            // In case of an error, `value` won't be returned and will just be reported\n            // as part of an `error` object, so it's fine assigning just an element of the array.\n            value = _value;\n            error = result.error;\n            reason = result.reason;\n          }\n          return result.value;\n        });\n        if (!error) {\n          var isEmpty = array.every(isEmptyValue);\n          value = isEmpty ? options.getEmptyArrayValue(array, {\n            path: propertyPath\n          }) : array;\n        }\n      } else {\n        var result = parseValue(cellValue, schemaEntry, options);\n        error = result.error;\n        reason = result.reason;\n        value = error ? cellValue : result.value;\n      }\n    }\n\n    // Apply `required` validation if the value is \"empty\".\n    if (!error && isEmptyValue(value)) {\n      if (schemaEntry.required) {\n        // Will perform this `required()` validation in the end,\n        // when all properties of the mapped object have been mapped.\n        pendingRequiredChecks.push({\n          column: key,\n          value: value,\n          isMissingColumn: isMissingColumn\n        });\n      }\n    }\n    if (error) {\n      // If there was an error then the property value in the `object` will be `undefined`,\n      // i.e it won't add the property value to the mapped object.\n      errors.push(createError({\n        column: key,\n        value: value,\n        error: error,\n        reason: reason\n      }));\n    } else {\n      // Possibly unmark the mapped object as \"empty\".\n      if (isEmptyObject && !isEmptyValue(value)) {\n        isEmptyObject = false;\n      }\n      // Set the value in the mapped object.\n      // Skip setting `undefined` values because they're already `undefined`.\n      if (value !== undefined) {\n        object[schemaEntry.prop] = value;\n      }\n    }\n  };\n  for (var _i = 0, _Object$keys = Object.keys(schema); _i < _Object$keys.length; _i++) {\n    _loop();\n  }\n\n  // Return `null` for an \"empty\" mapped object.\n  if (isEmptyObject) {\n    return options.getEmptyObjectValue(object, {\n      path: path\n    });\n  }\n\n  // Perform any `required` validations.\n  for (var _i2 = 0, _pendingRequiredCheck = pendingRequiredChecks; _i2 < _pendingRequiredCheck.length; _i2++) {\n    var _pendingRequiredCheck2 = _pendingRequiredCheck[_i2],\n      column = _pendingRequiredCheck2.column,\n      value = _pendingRequiredCheck2.value,\n      isMissingColumn = _pendingRequiredCheck2.isMissingColumn;\n    // Can optionally skip `required` validation for missing columns.\n    var skipRequiredValidation = isMissingColumn && options.schemaPropertyShouldSkipRequiredValidationForMissingColumn(column, {\n      object: object\n    });\n    if (!skipRequiredValidation) {\n      var required = schema[column].required;\n      var isRequired = typeof required === 'boolean' ? required : required(object);\n      if (isRequired) {\n        errors.push(createError({\n          column: column,\n          value: value,\n          error: 'required'\n        }));\n      }\n    }\n  }\n\n  // Return the mapped object.\n  return object;\n}\n\n/**\r\n * Converts textual value to a javascript typed value.\r\n * @param  {any} value\r\n * @param  {object} schemaEntry\r\n * @return {{ value: any, error: string }}\r\n */\nexport function parseValue(value, schemaEntry, options) {\n  if (value === null) {\n    return {\n      value: null\n    };\n  }\n  var result;\n  if (schemaEntry.parse) {\n    result = parseCustomValue(value, schemaEntry.parse);\n  } else if (schemaEntry.type) {\n    result = parseValueOfType(value,\n    // Supports parsing array types.\n    // See `parseArray()` function for more details.\n    // Example `type`: String[]\n    // Input: 'Barack Obama, \"String, with, colons\", Donald Trump'\n    // Output: ['Barack Obama', 'String, with, colons', 'Donald Trump']\n    Array.isArray(schemaEntry.type) ? schemaEntry.type[0] : schemaEntry.type, options);\n  } else {\n    result = {\n      value: value\n    };\n    // throw new Error('Invalid schema entry: no .type and no .parse():\\n\\n' + JSON.stringify(schemaEntry, null, 2))\n  }\n  // If errored then return the error.\n  if (result.error) {\n    return result;\n  }\n  if (result.value !== null) {\n    if (schemaEntry.oneOf && schemaEntry.oneOf.indexOf(result.value) < 0) {\n      return {\n        error: 'invalid',\n        reason: 'unknown'\n      };\n    }\n    if (schemaEntry.validate) {\n      try {\n        schemaEntry.validate(result.value);\n      } catch (error) {\n        return {\n          error: error.message\n        };\n      }\n    }\n  }\n  return result;\n}\n\n/**\r\n * Converts textual value to a custom value using supplied `.parse()`.\r\n * @param  {any} value\r\n * @param  {function} parse\r\n * @return {{ value: any, error: string }}\r\n */\nfunction parseCustomValue(value, parse) {\n  try {\n    var parsedValue = parse(value);\n    if (parsedValue === undefined) {\n      return {\n        value: null\n      };\n    }\n    return {\n      value: parsedValue\n    };\n  } catch (error) {\n    var result = {\n      error: error.message\n    };\n    if (error.reason) {\n      result.reason = error.reason;\n    }\n    return result;\n  }\n}\n\n/**\r\n * Converts textual value to a javascript typed value.\r\n * @param  {any} value\r\n * @param  {} type\r\n * @return {{ value: (string|number|Date|boolean), error: string, reason?: string }}\r\n */\nfunction parseValueOfType(value, type, options) {\n  switch (type) {\n    case String:\n      return parseCustomValue(value, StringType);\n    case Number:\n      return parseCustomValue(value, NumberType);\n    case Date:\n      return parseCustomValue(value, function (value) {\n        return DateType(value, {\n          properties: options.properties\n        });\n      });\n    case Boolean:\n      return parseCustomValue(value, BooleanType);\n    default:\n      if (typeof type === 'function') {\n        return parseCustomValue(value, type);\n      }\n      throw new Error(\"Unsupported schema type: \".concat(type && type.name || type));\n  }\n}\nexport function getBlock(string, endCharacter, startIndex) {\n  var i = 0;\n  var substring = '';\n  var character;\n  while (startIndex + i < string.length) {\n    var _character = string[startIndex + i];\n    if (_character === endCharacter) {\n      return [substring, i];\n    } else if (_character === '\"') {\n      var block = getBlock(string, '\"', startIndex + i + 1);\n      substring += block[0];\n      i += '\"'.length + block[1] + '\"'.length;\n    } else {\n      substring += _character;\n      i++;\n    }\n  }\n  return [substring, i];\n}\n\n/**\r\n * Parses a string of comma-separated substrings into an array of substrings.\r\n * (the `export` is just for tests)\r\n * @param  {string} string — A string of comma-separated substrings.\r\n * @return {string[]} An array of substrings.\r\n */\nexport function parseArray(string, arrayValueSeparator) {\n  var blocks = [];\n  var index = 0;\n  while (index < string.length) {\n    var _getBlock = getBlock(string, arrayValueSeparator, index),\n      _getBlock2 = _slicedToArray(_getBlock, 2),\n      substring = _getBlock2[0],\n      length = _getBlock2[1];\n    index += length + arrayValueSeparator.length;\n    blocks.push(substring.trim());\n  }\n  return blocks;\n}\n\n// Transpose a 2D array.\n// https://stackoverflow.com/questions/17428587/transposing-a-2d-array-in-javascript\nvar transpose = function transpose(array) {\n  return array[0].map(function (_, i) {\n    return array.map(function (row) {\n      return row[i];\n    });\n  });\n};\nfunction validateSchema(schema) {\n  for (var _i3 = 0, _Object$keys2 = Object.keys(schema); _i3 < _Object$keys2.length; _i3++) {\n    var key = _Object$keys2[_i3];\n    var entry = schema[key];\n    if (!entry.prop) {\n      throw new Error(\"\\\"prop\\\" not defined for schema entry \\\"\".concat(key, \"\\\".\"));\n    }\n  }\n}\nfunction isEmptyValue(value) {\n  return value === undefined || value === null;\n}\n//# sourceMappingURL=mapToObjects.js.map","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport mapToObjects from './mapToObjects.js';\nexport default function mapToObjectsLegacyBehavior(data, schema) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var includeNullValues = options.includeNullValues,\n    ignoreEmptyRows = options.ignoreEmptyRows,\n    isColumnOriented = options.isColumnOriented,\n    rowMap = options.rowMap;\n  var defaultConversionOptions = {\n    schemaPropertyValueForMissingColumn: undefined,\n    schemaPropertyValueForUndefinedCellValue: undefined,\n    schemaPropertyValueForNullCellValue: undefined,\n    schemaPropertyShouldSkipRequiredValidationForMissingColumn: function schemaPropertyShouldSkipRequiredValidationForMissingColumn(column, _ref) {\n      var path = _ref.path;\n      return false;\n    },\n    getEmptyObjectValue: function getEmptyObjectValue(object, _ref2) {\n      var path = _ref2.path;\n      return path ? undefined : null;\n    },\n    getEmptyArrayValue: function getEmptyArrayValue() {\n      return null;\n    },\n    arrayValueSeparator: ','\n  };\n  if (includeNullValues) {\n    defaultConversionOptions.schemaPropertyValueForMissingColumn = null;\n    defaultConversionOptions.schemaPropertyValueForUndefinedCellValue = null;\n    defaultConversionOptions.schemaPropertyValueForNullCellValue = null;\n    defaultConversionOptions.getEmptyObjectValue = function (object, _ref3) {\n      var path = _ref3.path;\n      return null;\n    };\n  }\n  var result = mapToObjects(data, schema, _objectSpread(_objectSpread({}, defaultConversionOptions), {}, {\n    rowIndexMap: rowMap,\n    isColumnOriented: isColumnOriented\n  }));\n  if (ignoreEmptyRows !== false) {\n    result.rows = result.rows.filter(function (_) {\n      return _ !== defaultConversionOptions.getEmptyObjectValue(_, {\n        path: undefined\n      });\n    });\n  }\n  return result;\n}\n//# sourceMappingURL=mapToObjects.legacy.js.map","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nvar _excluded = [\"schemaPropertyValueForEmptyCell\"];\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\n// Renames some of the `react-excel-file` options to `mapToObjects()` options.\nexport default function mapToObjectsSpreadsheetBehavior(mapToObjects, data, schema) {\n  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n  var schemaPropertyValueForEmptyCell = options.schemaPropertyValueForEmptyCell,\n    restOptions = _objectWithoutProperties(options, _excluded);\n  return mapToObjects(data, schema, _objectSpread(_objectSpread({}, restOptions), {}, {\n    schemaPropertyValueForNullCellValue: schemaPropertyValueForEmptyCell\n  }));\n}\n//# sourceMappingURL=mapToObjects.spreadsheet.js.map","import { unzipSync, strFromU8 } from 'fflate';\n\n/**\r\n * Reads XLSX file in a browser.\r\n * @param  {(File|Blob|ArrayBuffer)} input - A `File` or an `ArrayBuffer`.\r\n * @return {Promise} Resolves to an object holding XLSX file entries.\r\n */\nexport default function unpackXlsxFile(input) {\n  if (input instanceof File) {\n    return input.arrayBuffer().then(unpackXlsxArrayBuffer);\n  }\n  if (input instanceof Blob) {\n    return input.arrayBuffer().then(unpackXlsxArrayBuffer);\n  }\n  return unpackXlsxArrayBuffer(input);\n}\n\n/**\r\n * Reads XLSX file in a browser from an `ArrayBuffer`.\r\n * @param  {ArrayBuffer} input\r\n * @return {Promise} Resolves to an object holding XLSX file entries.\r\n */\nfunction unpackXlsxArrayBuffer(arrayBuffer) {\n  var archive = new Uint8Array(arrayBuffer);\n  var contents = unzipSync(archive);\n  return Promise.resolve(getContents(contents));\n  // return new Promise((resolve, reject) => {\n  // \tunzip(archive, (error, contents) => {\n  // \t\tif (error) {\n  // \t\t\treturn reject(error)\n  // \t\t}\n  // \t\treturn resolve(getContents(contents))\n  // \t})\n  // })\n}\n\nfunction getContents(contents) {\n  var unzippedFiles = [];\n  for (var _i = 0, _Object$keys = Object.keys(contents); _i < _Object$keys.length; _i++) {\n    var key = _Object$keys[_i];\n    unzippedFiles[key] = strFromU8(contents[key]);\n  }\n  return unzippedFiles;\n}\n//# sourceMappingURL=unpackXlsxFileBrowser.js.map","import InvalidError from './InvalidError.js';\nexport default function BooleanType(value) {\n  if (typeof value === 'boolean') {\n    return value;\n  }\n  throw new InvalidError('not_a_boolean');\n}\n//# sourceMappingURL=Boolean.js.map","import parseDate from '../read/parseDate.js';\nimport InvalidError from './InvalidError.js';\nexport default function DateType(value, _ref) {\n  var properties = _ref.properties;\n  // XLSX has no specific format for dates.\n  // Sometimes a date can be heuristically detected.\n  // https://github.com/catamphetamine/read-excel-file/issues/3#issuecomment-395770777\n  if (value instanceof Date) {\n    if (isNaN(value.valueOf())) {\n      throw new InvalidError('out_of_bounds');\n    }\n    return value;\n  }\n  if (typeof value === 'number') {\n    if (isNaN(value)) {\n      throw new InvalidError('invalid_number');\n    }\n    if (!isFinite(value)) {\n      throw new InvalidError('out_of_bounds');\n    }\n    var date = parseDate(value, properties);\n    if (isNaN(date.valueOf())) {\n      throw new InvalidError('out_of_bounds');\n    }\n    return date;\n  }\n  throw new InvalidError('not_a_date');\n}\n//# sourceMappingURL=Date.js.map","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \"function\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \"function\") { throw new TypeError(\"Super expression must either be null or a function\"); } if (typeof _cache !== \"undefined\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\nfunction _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\"[native code]\") !== -1; }\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\nvar InvalidError = /*#__PURE__*/function (_Error) {\n  _inherits(InvalidError, _Error);\n  var _super = _createSuper(InvalidError);\n  function InvalidError(reason) {\n    var _this;\n    _classCallCheck(this, InvalidError);\n    _this = _super.call(this, 'invalid');\n    _this.reason = reason;\n    return _this;\n  }\n  return _createClass(InvalidError);\n}( /*#__PURE__*/_wrapNativeSuper(Error));\nexport { InvalidError as default };\n//# sourceMappingURL=InvalidError.js.map","import InvalidError from './InvalidError.js';\nexport default function NumberType(value) {\n  // An XLSX file editing software might not always correctly\n  // detect numeric values in string-type cells. Users won't bother\n  // manually selecting a cell type, so the editing software has to guess\n  // based on the user's input. One can assume that such auto-detection\n  // might not always work.\n  //\n  // So, if a cell is supposed to be a numeric one, convert a string value to a number.\n  //\n  if (typeof value === 'string') {\n    var stringifiedValue = value;\n    value = Number(value);\n    if (String(value) !== stringifiedValue) {\n      throw new InvalidError('not_a_number');\n    }\n  }\n  if (typeof value !== 'number') {\n    throw new InvalidError('not_a_number');\n  }\n  if (isNaN(value)) {\n    throw new InvalidError('invalid_number');\n  }\n  // At this point, `value` can only be a number.\n  //\n  // The global `isFinite()` function filters out:\n  // * NaN\n  // * -Infinity\n  // * Infinity\n  //\n  // All other values pass (including non-numbers).\n  //\n  if (!isFinite(value)) {\n    throw new InvalidError('out_of_bounds');\n  }\n  return value;\n}\n//# sourceMappingURL=Number.js.map","import InvalidError from './InvalidError.js';\nexport default function StringType(value) {\n  if (typeof value === 'string') {\n    return value;\n  }\n  // Excel tends to perform a forced automatic convertion of string-type values\n  // to number-type ones when the user has input them. Otherwise, users wouldn't\n  // be able to perform formula calculations on those cell values because users\n  // won't bother manually choosing a \"numeric\" cell type for each cell, and\n  // even if they did, choosing a \"numeric\" cell type every time wouldn't be an\n  // acceptable \"user experience\".\n  //\n  // So, if a cell value is supposed to be a string and Excel has automatically\n  // converted it to a number, perform a backwards conversion.\n  //\n  if (typeof value === 'number') {\n    if (isNaN(value)) {\n      throw new InvalidError('invalid_number');\n    }\n    // The global `isFinite()` function filters out:\n    // * NaN\n    // * -Infinity\n    // * Infinity\n    //\n    // All other values pass (including non-numbers).\n    //\n    if (!isFinite(value)) {\n      throw new InvalidError('out_of_bounds');\n    }\n    return String(value);\n  }\n  throw new InvalidError('not_a_string');\n}\n//# sourceMappingURL=String.js.map","export function findChild(node, tagName) {\n  var i = 0;\n  while (i < node.childNodes.length) {\n    var childNode = node.childNodes[i];\n    // `nodeType: 1` means \"Element\".\n    // https://www.w3schools.com/xml/prop_element_nodetype.asp\n    if (childNode.nodeType === 1 && getTagName(childNode) === tagName) {\n      return childNode;\n    }\n    i++;\n  }\n}\nexport function findChildren(node, tagName) {\n  var results = [];\n  var i = 0;\n  while (i < node.childNodes.length) {\n    var childNode = node.childNodes[i];\n    // `nodeType: 1` means \"Element\".\n    // https://www.w3schools.com/xml/prop_element_nodetype.asp\n    if (childNode.nodeType === 1 && getTagName(childNode) === tagName) {\n      results.push(childNode);\n    }\n    i++;\n  }\n  return results;\n}\nexport function forEach(node, tagName, func) {\n  // if (typeof tagName === 'function') {\n  // \tfunc = tagName\n  // \ttagName = undefined\n  // }\n  var i = 0;\n  while (i < node.childNodes.length) {\n    var childNode = node.childNodes[i];\n    if (tagName) {\n      // `nodeType: 1` means \"Element\".\n      // https://www.w3schools.com/xml/prop_element_nodetype.asp\n      if (childNode.nodeType === 1 && getTagName(childNode) === tagName) {\n        func(childNode, i);\n      }\n    } else {\n      func(childNode, i);\n    }\n    i++;\n  }\n}\nexport function map(node, tagName, func) {\n  var results = [];\n  forEach(node, tagName, function (node, i) {\n    results.push(func(node, i));\n  });\n  return results;\n}\nvar NAMESPACE_REG_EXP = /.+\\:/;\nexport function getTagName(element) {\n  // For some weird reason, if an element is declared as,\n  // for example, `<x:sheets/>`, then its `.tagName` will be\n  // \"x:sheets\" instead of just \"sheets\".\n  // https://gitlab.com/catamphetamine/read-excel-file/-/issues/25\n  // Its not clear how to tell it to ignore any namespaces\n  // when getting `.tagName`, so just replacing anything\n  // before a colon, if any.\n  return element.tagName.replace(NAMESPACE_REG_EXP, '');\n}\n\n// This function is only used for occasional debug messages.\nexport function getOuterXml(node) {\n  // `nodeType: 1` means \"Element\".\n  // https://www.w3schools.com/xml/prop_element_nodetype.asp\n  if (node.nodeType !== 1) {\n    return node.textContent;\n  }\n  var xml = '<' + getTagName(node);\n  var j = 0;\n  while (j < node.attributes.length) {\n    xml += ' ' + node.attributes[j].name + '=' + '\"' + node.attributes[j].value + '\"';\n    j++;\n  }\n  xml += '>';\n  var i = 0;\n  while (i < node.childNodes.length) {\n    xml += getOuterXml(node.childNodes[i]);\n    i++;\n  }\n  xml += '</' + getTagName(node) + '>';\n  return xml;\n}\n//# sourceMappingURL=dom.js.map","import { findChild, findChildren, forEach, map, getTagName } from './dom.js';\n\n// Returns an array of cells,\n// each element being an XML DOM element representing a cell.\nexport function getCells(document) {\n  var worksheet = document.documentElement;\n  var sheetData = findChild(worksheet, 'sheetData');\n  var cells = [];\n  forEach(sheetData, 'row', function (row) {\n    forEach(row, 'c', function (cell) {\n      cells.push(cell);\n    });\n  });\n  return cells;\n}\nexport function getMergedCells(document) {\n  var worksheet = document.documentElement;\n  var mergedCells = findChild(worksheet, 'mergeCells');\n  var mergedCellsInfo = [];\n  if (mergedCells) {\n    forEach(mergedCells, 'mergeCell', function (mergedCell) {\n      mergedCellsInfo.push(mergedCell.getAttribute('ref'));\n    });\n  }\n  return mergedCellsInfo;\n}\nexport function getCellValue(document, node) {\n  return findChild(node, 'v');\n}\nexport function getCellInlineStringValue(document, node) {\n  if (node.firstChild && getTagName(node.firstChild) === 'is' && node.firstChild.firstChild && getTagName(node.firstChild.firstChild) === 't') {\n    return node.firstChild.firstChild.textContent;\n  }\n}\nexport function getDimensions(document) {\n  var worksheet = document.documentElement;\n  var dimensions = findChild(worksheet, 'dimension');\n  if (dimensions) {\n    return dimensions.getAttribute('ref');\n  }\n}\nexport function getBaseStyles(document) {\n  var styleSheet = document.documentElement;\n  var cellStyleXfs = findChild(styleSheet, 'cellStyleXfs');\n  if (cellStyleXfs) {\n    return findChildren(cellStyleXfs, 'xf');\n  }\n  return [];\n}\nexport function getCellStyles(document) {\n  var styleSheet = document.documentElement;\n  var cellXfs = findChild(styleSheet, 'cellXfs');\n  if (!cellXfs) {\n    return [];\n  }\n  return findChildren(cellXfs, 'xf');\n}\nexport function getNumberFormats(document) {\n  var styleSheet = document.documentElement;\n  var numberFormats = [];\n  var numFmts = findChild(styleSheet, 'numFmts');\n  if (numFmts) {\n    return findChildren(numFmts, 'numFmt');\n  }\n  return [];\n}\nexport function getSharedStrings(document) {\n  // An `<si/>` element can contain a `<t/>` (simplest case) or a set of `<r/>` (\"rich formatting\") elements having `<t/>`.\n  // https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.sharedstringitem?redirectedfrom=MSDN&view=openxml-2.8.1\n  // http://www.datypic.com/sc/ooxml/e-ssml_si-1.html\n\n  var sst = document.documentElement;\n  return map(sst, 'si', function (string) {\n    var t = findChild(string, 't');\n    if (t) {\n      return t.textContent;\n    }\n    var value = '';\n    forEach(string, 'r', function (r) {\n      value += findChild(r, 't').textContent;\n    });\n    return value;\n  });\n}\nexport function getWorkbookProperties(document) {\n  var workbook = document.documentElement;\n  return findChild(workbook, 'workbookPr');\n}\nexport function getRelationships(document) {\n  var relationships = document.documentElement;\n  return findChildren(relationships, 'Relationship');\n}\nexport function getSheets(document) {\n  var workbook = document.documentElement;\n  var sheets = findChild(workbook, 'sheets');\n  return findChildren(sheets, 'sheet');\n}\n//# sourceMappingURL=xlsx.js.map","export default {\n  createDocument: function createDocument(content) {\n    // if (!content) {\n    // \tthrow new Error('No *.xml content')\n    // }\n    // A weird bug: it won't parse XML unless it's trimmed.\n    // https://github.com/catamphetamine/read-excel-file/issues/21\n    return new DOMParser().parseFromString(content.trim(), 'text/xml');\n  }\n};\n//# sourceMappingURL=xmlBrowser.js.map"],"names":[],"sourceRoot":""}