@sswroom/sswr 1.6.13 → 1.6.14

package/spreadsheet.js

@@ -0,0 +1,2227 @@
+import * as data from "./data.js";
+import * as text from "./text.js";
+import * as unit from "./unit.js";
+
+export const FontFamily = {
+	NA: 0,
+	Roman: 1,
+	Swiss: 2,
+	Modern: 3,
+	Script: 4,
+	Decorative: 5
+}
+
+export const BorderType = {
+	None: 0,
+	Thin: 1,
+	Medium: 2,
+	Dashed: 3,
+	Dotted: 4,
+	Thick: 5,
+	DOUBLE: 6,
+	Hair: 7,
+	MediumDashed: 8,
+	DashDot: 9,
+	MediumDashDot: 10,
+	DashDotDot: 11,
+	MediumDashDotDot: 12,
+	SlantedDashDot: 13
+}
+
+export const FillPattern = {
+	NoFill: 0,
+	SolidForeground: 1,
+	FineDot: 2,
+	AltBars: 3,
+	SparseDots: 4,
+	ThickHorzBands: 5,
+	ThickVertBands: 6,
+	ThickBackwardDiag: 7,
+	ThickForwardDiag: 8,
+	BigSpots: 9,
+	Bricks: 10,
+	ThinHorzBands: 11,
+	ThinVertBands: 12,
+	ThinBackwardDiag: 13,
+	ThinForwardDiag: 14,
+	Squares: 15,
+	Diamonds: 16,
+	LessDots: 17,
+	LeastDots: 18
+}
+
+export const CellDataType = {
+	String: 0,
+	Number: 1,
+	DateTime: 2,
+	MergedLeft: 3,
+	MergedUp: 4
+}
+
+export const AnchorType = {
+	Absolute: 0,
+	OneCell: 1,
+	TwoCell: 2
+}
+
+export const LegendPos = {
+	Bottom: 0
+}
+
+export const BlankAs = {
+	Default: 0,
+	Gap: 1,
+	Zero: 2
+}
+
+export const ChartType = {
+	Unknown: 0,
+	LineChart: 1
+}
+
+export const AxisType = {
+	Date: 0,
+	Category: 1,
+	Numeric: 2,
+	Series: 3
+}
+
+export const AxisPosition = {
+	Left: 0,
+	Top: 1,
+	Right: 2,
+	Bottom: 3
+}
+
+export const TickLabelPosition = {
+	High: 0,
+	Low: 1,
+	NextTo: 2,
+	None: 3
+}
+
+export const AxisCrosses = {
+	AutoZero: 0,
+	Max: 1,
+	Min: 2
+}
+
+export const ColorType = {
+	Preset: 0,
+	Argb: 1
+}
+
+export const PresetColor = {
+	AliceBlue: 0,
+	AntiqueWhite: 1,
+	Aqua: 2,
+	Aquamarine: 3,
+	Azure: 4,
+	Beige: 5,
+	Bisque: 6,
+	Black: 7,
+	BlanchedAlmond: 8,
+	Blue: 9,
+	BlueViolet: 10,
+	Brown: 11,
+	BurlyWood: 12,
+	CadetBlue: 13,
+	Chartreuse: 14,
+	Chocolate: 15,
+	Coral: 16,
+	CornflowerBlue: 17,
+	Cornsilk: 18,
+	Crimson: 19,
+	Cyan: 20,
+	DeepPink: 21,
+	DeepSkyBlue: 22,
+	DimGray: 23,
+	DarkBlue: 24,
+	DarkCyan: 25,
+	DarkGoldenrod: 26,
+	DarkGray: 27,
+	DarkGreen: 28,
+	DarkKhaki: 29,
+	DarkMagenta: 30,
+	DarkOliveGreen: 31,
+	DarkOrange: 32,
+	DarkOrchid: 33,
+	DarkRed: 34,
+	DarkSalmon: 35,
+	DarkSeaGreen: 36,
+	DarkSlateBlue: 37,
+	DarkSlateGray: 38,
+	DarkTurquoise: 39,
+	DarkViolet: 40,
+	DodgerBlue: 41,
+	Firebrick: 42,
+	FloralWhite: 43,
+	ForestGreen: 44,
+	Fuchsia: 45,
+	Gainsboro: 46,
+	GhostWhite: 47,
+	Gold: 48,
+	Goldenrod: 49,
+	Gray: 50,
+	Green: 51,
+	GreenYellow: 52,
+	Honeydew: 53,
+	HotPink: 54,
+	IndianRed: 55,
+	Indigo: 56,
+	Ivory: 57,
+	Khaki: 58,
+	Lavender: 59,
+	LavenderBlush: 60,
+	LawnGreen: 61,
+	LemonChiffon: 62,
+	Lime: 63,
+	LimeGreen: 64,
+	Linen: 65,
+	LightBlue: 66,
+	LightCoral: 67,
+	LightCyan: 68,
+	LightGoldenrodYellow: 69,
+	LightGray: 70,
+	LightGreen: 71,
+	LightPink: 72,
+	LightSalmon: 73,
+	LightSeaGreen: 74,
+	LightSkyBlue: 75,
+	LightSlateGray: 76,
+	LightSteelBlue: 77,
+	LightYellow: 78,
+	Magenta: 79,
+	Maroon: 80,
+	MediumAquamarine: 81,
+	MediumBlue: 82,
+	MediumOrchid: 83,
+	MediumPurple: 84,
+	MediumSeaGreen: 85,
+	MediumSlateBlue: 86,
+	MediumSpringGreen: 87,
+	MediumTurquoise: 88,
+	MediumVioletRed: 89,
+	MidnightBlue: 90,
+	MintCream: 91,
+	MistyRose: 92,
+	Moccasin: 93,
+	NavajoWhite: 94,
+	Navy: 95,
+	OldLace: 96,
+	Olive: 97,
+	OliveDrab: 98,
+	Orange: 99,
+	OrangeRed: 100,
+	Orchid: 101,
+	PaleGoldenrod: 102,
+	PaleGreen: 103,
+	PaleTurquoise: 104,
+	PaleVioletRed: 105,
+	PapayaWhip: 106,
+	PeachPuff: 107,
+	Peru: 108,
+	Pink: 109,
+	Plum: 110,
+	PowderBlue: 111,
+	Purple: 112,
+	Red: 113,
+	RosyBrown: 114,
+	RoyalBlue: 115,
+	SaddleBrown: 116,
+	Salmon: 117,
+	SandyBrown: 118,
+	SeaGreen: 119,
+	SeaShell: 120,
+	Sienna: 121,
+	Silver: 122,
+	SkyBlue: 123,
+	SlateBlue: 124,
+	SlateGray: 125,
+	Snow: 126,
+	SpringGreen: 127,
+	SteelBlue: 128,
+	Tan: 129,
+	Teal: 130,
+	Thistle: 131,
+	Tomato: 132,
+	Turquoise: 133,
+	Violet: 134,
+	Wheat: 135,
+	White: 136,
+	WhiteSmoke: 137,
+	Yellow: 138,
+	YellowGreen: 139
+}
+
+export class WorkbookFont
+{
+	constructor()
+	{
+		/** @type {string|null} */
+		this.name = null;
+		this.size = 0;
+		this.bold = false;
+		this.italic = false;
+		this.underline = false;
+		this.color = 0;
+		this.family = FontFamily.NA;
+	}
+
+	/**
+	 * @param {string | null} name
+	 */
+	setName(name)
+	{
+		this.name = name;
+		return this;
+	}
+
+	/**
+	 * @param {number} size
+	 */
+	setSize(size)
+	{
+		this.size = size;
+		return this;
+	}
+
+	/**
+	 * @param {boolean} bold
+	 */
+	setBold(bold)
+	{
+		this.bold = bold;
+	}
+
+	/**
+	 * @param {boolean} italic
+	 */
+	setItalic(italic)
+	{
+		this.italic = italic;
+	}
+
+	/**
+	 * @param {boolean} underline
+	 */
+	setUnderline(underline)
+	{
+		this.underline = underline;
+	}
+
+	/**
+	 * @param {number} color
+	 */
+	setColor(color)
+	{
+		this.color = color;
+	}
+
+	/**
+	 * @param {number} family
+	 */
+	setFamily(family)
+	{
+		this.family = family;
+	}
+
+	getName()
+	{
+		return this.name;
+	}
+
+	getSize()
+	{
+		return this.size;
+	}
+
+	isBold()
+	{
+		return this.bold;
+	}
+
+	isItalic()
+	{
+		return this.italic;
+	}
+
+	isUnderline()
+	{
+		return this.underline;
+	}
+
+	getColor()
+	{
+		return this.color;
+	}
+
+	getFamily()
+	{
+		return this.family;
+	}
+
+	clone()
+	{
+		let font = new WorkbookFont();
+		font.name = this.name;
+		font.size = this.size;
+		font.bold = this.bold;
+		font.italic = this.italic;
+		font.underline = this.underline;
+		font.color = this.color;
+		font.family = this.family;
+		return font;
+	}
+
+	/**
+	 * @param {WorkbookFont} font
+	 */
+	equals(font)
+	{
+		return this.name == font.name &&
+			this.size == font.size &&
+			this.bold == font.bold &&
+			this.italic == font.italic &&
+			this.underline == font.underline &&
+			this.color == font.color;
+	}
+}
+
+export class BorderStyle
+{
+	/**
+	 * @param {number} borderColor
+	 * @param {number} borderType
+	 */
+	constructor(borderColor, borderType)
+	{
+		this.borderColor = borderColor;
+		this.borderType = borderType;
+	}
+
+	/**
+	 * @param {BorderStyle} style
+	 */
+	set(style)
+	{
+		this.borderColor = style.borderColor;
+		this.borderType = style.borderType;
+	}
+
+	clone()
+	{
+		return new BorderStyle(this.borderColor, this.borderType);
+	}
+
+	/**
+	 * @param {BorderStyle} style
+	 */
+	equals(style)
+	{
+		if (style.borderType == BorderType.None && this.borderType == BorderType.None)
+			return true;
+		else if (style.borderType != this.borderType)
+			return false;
+		else if (style.borderColor != this.borderColor)
+			return false;
+		else
+			return true;
+	}
+}
+
+export class CellStyle
+{
+	/**
+	 * @param {number} index
+	 */
+	constructor(index)
+	{
+		this.index = index;
+		/** @type {string|null} */
+		this.id = null;
+		this.halign = text.HAlignment.Unknown;
+		this.valign = text.VAlignment.Unknown;
+		this.wordWrap = false;
+		this.borderBottom = new BorderStyle(0, BorderType.None);
+		this.borderLeft = new BorderStyle(0, BorderType.None);
+		this.borderRight = new BorderStyle(0, BorderType.None);
+		this.borderTop = new BorderStyle(0, BorderType.None);
+		/** @type {WorkbookFont|null} */
+		this.font = null;
+		this.fillColor = 0xffffff;
+		this.fillPattern = FillPattern.NoFill;
+		/** @type {string|null} */
+		this.dataFormat = null;
+		this.protection = false;
+	};
+
+	clone()
+	{
+		let style = new CellStyle(this.index);
+		style.id = this.id;
+		style.halign = this.halign;
+		style.valign = this.valign;
+		style.wordWrap = this.wordWrap;
+		style.borderBottom = this.borderBottom.clone();
+		style.borderLeft = this.borderLeft.clone();
+		style.borderRight = this.borderRight.clone();
+		style.borderTop = this.borderTop.clone();
+		style.font = this.font;
+		style.fillColor = this.fillColor;
+		style.fillPattern = this.fillPattern;
+		style.dataFormat = this.dataFormat;
+		style.protection = this.protection;
+		return style;
+	}
+
+	/**
+	 * @param {CellStyle} style
+	 */
+	copyFrom(style)
+	{
+		this.index = style.index;
+		this.id = style.id;
+		this.halign = style.halign;
+		this.valign = style.valign;
+		this.wordWrap = style.wordWrap;
+		this.borderBottom = style.borderBottom.clone();
+		this.borderLeft = style.borderLeft.clone();
+		this.borderRight = style.borderRight.clone();
+		this.borderTop = style.borderTop.clone();
+		this.font = style.font;
+		this.fillColor = style.fillColor;
+		this.fillPattern = style.fillPattern;
+		this.dataFormat = style.dataFormat;
+		this.protection = style.protection;
+	}
+
+	/**
+	 * @param {CellStyle} style
+	 */
+	equals(style)
+	{
+		if (style.halign != this.halign)
+			return false;
+		if (style.valign != this.valign)
+			return false;
+		if (style.wordWrap != this.wordWrap)
+			return false;
+	
+		if (style.borderBottom != this.borderBottom)
+			return false;
+		if (style.borderLeft != this.borderLeft)
+			return false;
+		if (style.borderRight != this.borderRight)
+			return false;
+		if (style.borderTop != this.borderTop)
+			return false;
+	
+		if (this.font == null)
+		{
+			if (style.font != null)
+				return false;
+		}
+		else if (style.font == null)
+		{
+			return false;
+		}
+		else
+		{
+			if (style.font.equals(this.font))
+				return false;
+		}
+		if (style.fillColor != this.fillColor)
+			return false;
+		if (style.fillPattern != this.fillPattern)
+			return false;
+		if (this.dataFormat != style.dataFormat)
+			return false;
+		if (style.protection != this.protection)
+			return false;
+		return true;
+	}
+
+	/**
+	 * @param {number} index
+	 */
+	setIndex(index)
+	{
+		this.index = index;
+	}
+
+	/**
+	 * @param {string | null} id
+	 */
+	setID(id)
+	{
+		if (id == null)
+			return;
+		this.id = id;
+	}
+	
+	/**
+	 * @param {text.HAlignment} halign
+	 */
+	setHAlign(halign)
+	{
+		this.halign = halign;
+	}
+
+	/**
+	 * @param {text.VAlignment} valign
+	 */
+	setVAlign(valign)
+	{
+		this.valign = valign;
+	}
+
+	/**
+	 * @param {boolean} wordWrap
+	 */
+	setWordWrap(wordWrap)
+	{
+		this.wordWrap = wordWrap;
+	}
+
+	/**
+	 * @param {number} color
+	 * @param {number} pattern
+	 */
+	setFillColor(color, pattern)
+	{
+		this.fillColor = color;
+		this.fillPattern = pattern;
+	}
+
+	/**
+	 * @param {WorkbookFont | null} font
+	 */
+	setFont(font)
+	{
+		this.font = font;
+	}
+
+	/**
+	 * @param {BorderStyle} border
+	 */
+	setBorderLeft(border)
+	{
+		this.borderLeft.set(border);
+	}
+
+	/**
+	 * @param {BorderStyle} border
+	 */
+	setBorderRight(border)
+	{
+		this.borderRight.set(border);
+	}
+
+	/**
+	 * @param {BorderStyle} border
+	 */
+	setBorderTop(border)
+	{
+		this.borderTop = border;
+	}
+
+	/**
+	 * @param {BorderStyle} border
+	 */
+	setBorderBottom(border)
+	{
+		this.borderBottom.set(border);
+	}
+
+	/**
+	 * @param {string | null} dataFormat
+	 */
+	setDataFormat(dataFormat)
+	{
+		this.dataFormat = dataFormat;
+	}
+
+	getIndex()
+	{
+		return this.index;
+	}
+
+	getID()
+	{
+		return this.id;
+	}
+
+	getHAlign()
+	{
+		return this.halign;
+	}
+
+	getVAlign()
+	{
+		return this.valign;
+	}
+
+	getWordWrap()
+	{
+		return this.wordWrap;
+	}
+
+	getFillColor()
+	{
+		return this.fillColor;
+	}
+
+	getFillPattern()
+	{
+		return this.fillPattern;
+	}
+
+	getFont()
+	{
+		return this.font;
+	}
+
+	getBorderLeft()
+	{
+		return this.borderLeft;
+	}
+
+	getBorderRight()
+	{
+		return this.borderRight;
+	}
+
+	getBorderTop()
+	{
+		return this.borderTop;
+	}
+
+	getBorderBottom()
+	{
+		return this.borderBottom;
+	}
+
+	getDataFormat()
+	{
+		return this.dataFormat;
+	}
+}
+
+export class Worksheet
+{
+	/**
+	 * @param {number} row
+	 */
+	createRow(row)
+	{
+		if (row >= 1048576)
+			return null;
+		while (row >= this.rows.length)
+		{
+			this.rows.push(null);
+		}
+		let rowData = this.rows[row];
+		if (rowData == null)
+		{
+			rowData = {style: null, height: -1, cells: []};
+			this.rows[row] = rowData;
+		}
+		return rowData;		
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 * @param {boolean} keepMerge
+	 */
+	getCellData(row, col, keepMerge)
+	{
+		let rowData;
+		let cell;
+		if (row >= this.rows.length + 65536)
+			return null;
+		if (col >= 65536)
+			return null;
+		if (col > this.maxCol)
+		{
+			this.maxCol = col;
+		}
+		while (true)
+		{
+			if ((rowData = this.createRow(row)) == null)
+				return null;
+			while (col >= rowData.cells.length)
+			{
+				rowData.cells.push(null);
+			}
+			if ((cell = rowData.cells[col]) == null)
+			{
+				cell = {cdt: CellDataType.String, cellValue: null, style: null, mergeHori: 0, mergeVert: 0, hidden: false, cellURL: null};
+				rowData.cells[col] = cell;
+			}
+	
+			if (keepMerge)
+				break;
+			if (cell.cdt == CellDataType.MergedLeft)
+			{
+				col--;
+			}
+			else if (cell.cdt == CellDataType.MergedUp)
+			{
+				row--;
+			}
+			else
+			{
+				break;
+			}
+		}
+		return cell;
+	}
+
+	/**
+	 * @param {{style: CellStyle|null,cells: ({cdt: number,cellValue: string|null,style: CellStyle|null,mergeHori: number,mergeVert: number,hidden: boolean,cellURL: string|null}|null)[],height: number}} row
+	 * @param {Workbook} srcCtrl
+	 * @param {Workbook} newCtrl
+	 */
+	cloneRow(row, srcCtrl, newCtrl)
+	{
+		let newRow;
+		let cell;
+		let i;
+		let j;
+		let style;
+		if (row.style)
+			style = newCtrl.getStyle(srcCtrl.getStyleIndex(row.style));
+		else
+			style = null;
+		newRow = {style: style, cells: new Array(), height: -1};
+		newRow.height = row.height;
+		i = 0;
+		j = row.cells.length;
+		while (i < j)
+		{
+			if ((cell = row.cells[i]) == null)
+			{
+				newRow.cells.push(null);
+			}
+			else
+			{
+				newRow.cells.push(this.cloneCell(cell, srcCtrl, newCtrl));
+			}
+			i++;
+		}
+		return newRow;
+	}
+
+	/**
+	 * @param {{cdt: number,cellValue: string|null,style: CellStyle|null,mergeHori: number,mergeVert: number,hidden: boolean,cellURL: string|null}} cell
+	 * @param {Workbook} srcCtrl
+	 * @param {Workbook} newCtrl
+	 */
+	cloneCell(cell, srcCtrl, newCtrl)
+	{
+		let newCell = {};
+		newCell.cdt = cell.cdt;
+		newCell.cellValue = cell.cellValue;
+		if (cell.style)
+			newCell.style = newCtrl.getStyle(srcCtrl.getStyleIndex(cell.style));
+		else
+			newCell.style = null;
+		newCell.mergeHori = cell.mergeHori;
+		newCell.mergeVert = cell.mergeVert;
+		newCell.hidden = cell.hidden;
+		newCell.cellURL = cell.cellURL;
+		return newCell;
+	}
+	
+	/**
+	 * @param {string} name
+	 */
+	constructor(name)
+	{
+		this.name = name;
+		/** @type {({style: CellStyle|null,cells: ({cdt: number,cellValue: string|null,style: CellStyle|null,mergeHori: number,mergeVert: number,hidden: boolean,cellURL: string|null}|null)[],height: number}|null)[]} */
+		this.rows = [];
+		/** @type {number[]} */
+		this.colWidthsPt = [];
+		// @type {WorksheetDrawing[]}
+		this.drawings = [];
+		this.freezeHori = 0;
+		this.freezeVert = 0;
+		this.marginLeft = 2.0;
+		this.marginRight = 2.0;
+		this.marginTop = 2.5;
+		this.marginBottom = 2.5;
+		this.marginHeader = 1.3;
+		this.marginFooter = 1.3;
+		this.zoom = 100;
+		this.options = 0x4b6;
+		this.maxCol = 0;
+		this.defColWidthPt = 48.0;
+		this.defRowHeightPt = 13.5;
+	}
+
+	/**
+	 * @param {Workbook} srcCtrl
+	 * @param {Workbook} newCtrl
+	 */
+	clone(srcCtrl, newCtrl)
+	{
+		let i;
+		let j;
+		let row;
+		let newWS = new Worksheet(this.name);
+		newWS.freezeHori = this.freezeHori;
+		newWS.freezeVert = this.freezeVert;
+		newWS.marginLeft = this.marginLeft;
+		newWS.marginRight = this.marginRight;
+		newWS.marginTop = this.marginTop;
+		newWS.marginBottom = this.marginBottom;
+		newWS.marginHeader = this.marginHeader;
+		newWS.marginFooter = this.marginFooter;
+		newWS.options = this.options;
+		newWS.zoom = this.zoom;
+		i = 0;
+		j = this.colWidthsPt.length;
+		while (i < j)
+		{
+			newWS.colWidthsPt.push(this.colWidthsPt[i]);
+			i++;
+		}
+		i = 0;
+		j = this.rows.length;
+		while (i < j)
+		{
+			if ((row = this.rows[i]) == null)
+			{
+				newWS.rows.push(null);
+			}
+			else
+			{
+				newWS.rows.push(this.cloneRow(row, srcCtrl, newCtrl));
+			}
+			i++;
+		}
+		return newWS;
+	}
+
+	/**
+	 * @param {number} options
+	 */
+	setOptions(options)
+	{
+		this.options = options;
+	}
+
+	getOptions()
+	{
+		return this.options;
+	}
+
+	/**
+	 * @param {number} freezeHori
+	 */
+	setFreezeHori(freezeHori)
+	{
+		this.freezeHori = freezeHori;
+		this.options |= 0x108;
+	}
+	
+	getFreezeHori()
+	{
+		return this.freezeHori;
+	}
+
+	/**
+	 * @param {number} freezeVert
+	 */
+	setFreezeVert(freezeVert)
+	{
+		this.freezeVert = freezeVert;
+		this.options |= 0x108;
+	}
+
+	getFreezeVert()
+	{
+		return this.freezeVert;
+	}
+
+	/**
+	 * @param {number} marginLeft
+	 */
+	setMarginLeft(marginLeft)
+	{
+		this.marginLeft = marginLeft;
+	}
+
+	getMarginLeft()
+	{
+		return this.marginLeft;
+	}
+
+	/**
+	 * @param {number} marginRight
+	 */
+	setMarginRight(marginRight)
+	{
+		this.marginRight = marginRight;
+	}
+
+	getMarginRight()
+	{
+		return this.marginRight;
+	}
+
+	/**
+	 * @param {number} marginTop
+	 */
+	setMarginTop(marginTop)
+	{
+		this.marginTop = marginTop;
+	}
+
+	getMarginTop()
+	{
+		return this.marginTop;
+	}
+
+	/**
+	 * @param {number} marginBottom
+	 */
+	setMarginBottom(marginBottom)
+	{
+		this.marginBottom = marginBottom;
+	}
+
+	getMarginBottom()
+	{
+		return this.marginBottom;
+	}
+
+	/**
+	 * @param {number} marginHeader
+	 */
+	setMarginHeader(marginHeader)
+	{
+		this.marginHeader = marginHeader;
+	}
+
+	getMarginHeader()
+	{
+		return this.marginHeader;
+	}
+
+	/**
+	 * @param {number} marginFooter
+	 */
+	setMarginFooter(marginFooter)
+	{
+		this.marginFooter = marginFooter;
+	}
+
+	getMarginFooter()
+	{
+		return this.marginFooter;
+	}
+
+	/**
+	 * @param {number} zoom
+	 */
+	setZoom(zoom)
+	{
+		this.zoom = zoom;
+	}
+
+	getZoom()
+	{
+		return this.zoom;
+	}
+
+	isDefaultPageSetup()
+	{
+		return this.marginHeader == 1.3 && this.marginFooter == 1.3 && this.marginLeft == 2.0 && this.marginRight == 2.0 && this.marginTop == 2.5 && this.marginBottom == 2.5;
+	}
+
+	/**
+	 * @param {number} defColWidthPt
+	 */
+	setDefColWidthPt(defColWidthPt)
+	{
+		this.defColWidthPt = defColWidthPt;
+	}
+
+	getDefColWidthPt()
+	{
+		return this.defColWidthPt;
+	}
+
+	/**
+	 * @param {number} defRowHeightPt
+	 */
+	setDefRowHeightPt(defRowHeightPt)
+	{
+		this.defRowHeightPt = defRowHeightPt;
+	}
+
+	getDefRowHeightPt()
+	{
+		return this.defRowHeightPt;
+	}
+
+	getName()
+	{
+		return this.name;
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 * @param {CellStyle|null} style
+	 */
+	setCellStyle(row, col, style)
+	{
+		let cell;
+		if ((cell = this.getCellData(row, col, false)) == null)
+			return false;
+		cell.style = style;
+		return true;
+	}
+	
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 * @param {Workbook} wb
+	 * @param {text.HAlignment} hAlign
+	 */
+	setCellStyleHAlign(row, col, wb, hAlign)
+	{
+		let cell;
+		if ((cell = this.getCellData(row, col, false)) == null)
+			return false;
+		let tmpStyle;
+		if (cell.style == null)
+		{
+			if (hAlign == text.HAlignment.Unknown)
+				return true;
+			tmpStyle = new CellStyle(0);
+			tmpStyle.setHAlign(hAlign);
+			cell.style = wb.findOrCreateStyle(tmpStyle);
+		}
+		else
+		{
+			if (cell.style.getHAlign() == hAlign)
+				return true;
+			tmpStyle = cell.style.clone();
+			tmpStyle.setHAlign(hAlign);
+			cell.style = wb.findOrCreateStyle(tmpStyle);
+		}
+		return true;
+	}
+	
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 * @param {Workbook} wb
+	 * @param {number} color
+	 * @param {number} borderType
+	 */
+	setCellStyleBorderBottom(row, col, wb, color, borderType)
+	{
+		let cell;
+		if ((cell = this.getCellData(row, col, true)) == null)
+			return false;
+		let tmpStyle;
+		if (cell.style == null)
+		{
+			if (borderType == BorderType.None)
+				return true;
+			tmpStyle = new CellStyle(0);
+			tmpStyle.setBorderBottom(new BorderStyle(color, borderType));
+			cell.style = wb.findOrCreateStyle(tmpStyle);
+		}
+		else
+		{
+			
+			if (cell.style.getBorderBottom().equals(new BorderStyle(color, borderType)))
+				return true;
+			tmpStyle = cell.style.clone();
+			tmpStyle.setBorderBottom(new BorderStyle(color, borderType));
+			cell.style = wb.findOrCreateStyle(tmpStyle);
+		}
+		return true;
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 * @param {string | null} url
+	 */
+	setCellURL(row, col, url)
+	{
+		let cell;
+		if ((cell = this.getCellData(row, col, false)) == null)
+			return false;
+		cell.cellURL = url;
+		return true;
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 * @param {string | null} val
+	 * @param {CellStyle | null} style
+	 */
+	setCellString(row, col, val, style)
+	{
+		let cell;
+		if ((cell = this.getCellData(row, col, false)) == null)
+			return false;
+		cell.cdt = CellDataType.String;
+		cell.cellValue = val;
+		if (style) cell.style = style;
+		return true;
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 * @param {data.Timestamp} val
+	 * @param {CellStyle | null} style
+	 */
+	setCellTS(row, col, val, style)
+	{
+		let cell;
+		if ((cell = this.getCellData(row, col, false)) == null)
+			return false;
+		cell.cdt = CellDataType.DateTime;
+		cell.cellValue = val.toString("yyyy-MM-ddTHH:mm:ss.fffffffff");
+		if (style) cell.style = style;
+		return true;
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 * @param {number} val
+	 * @param {CellStyle | null} style
+	 */
+	setCellDouble(row, col, val, style)
+	{
+		let cell;
+		if ((cell = this.getCellData(row, col, false)) == null)
+			return false;
+		cell.cdt = CellDataType.Number;
+		cell.cellValue = ""+val;
+		if (style) cell.style = style;
+		return true;
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 * @param {number} val
+	 * @param {CellStyle | null} style
+	 */
+	setCellInt32(row, col, val, style)
+	{
+		let cell;
+		if ((cell = this.getCellData(row, col, false)) == null)
+			return false;
+		cell.cdt = CellDataType.Number;
+		cell.cellValue = ""+val;
+		if (style) cell.style = style;
+		return true;
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 * @param {number} val
+	 * @param {CellStyle | null} style
+	 */
+	setCellInt64(row, col, val, style)
+	{
+		let cell;
+		if ((cell = this.getCellData(row, col, false)) == null)
+			return false;
+		cell.cdt = CellDataType.Number;
+		cell.cellValue = ""+val;
+		if (style) cell.style = style;
+		return true;
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 * @param {CellStyle | null} style
+	 */
+	setCellEmpty(row, col, style)
+	{
+		let cell;
+		if ((cell = this.getCellData(row, col, false)) == null)
+			return false;
+		cell.cdt = CellDataType.Number;
+		cell.cellValue = null;
+		if (style) cell.style = style;
+		return true;
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 * @param {number} height
+	 * @param {number} width
+	 */
+	mergeCells(row, col, height, width)
+	{
+		if (width == 0)
+			return false;
+		if (height == 0)
+			return false;
+		if (width == 0 && height == 0)
+			return false;
+	
+		let cell;
+		let i;
+		let j;
+		i = 0;
+		while (i < height)
+		{
+			j = 0;
+			while (j < width)
+			{
+				if ((cell = this.getCellData(row + i, col + j, true)) != null && (cell.cdt == CellDataType.MergedLeft || cell.cdt == CellDataType.MergedUp))
+					return false;
+				j++;
+			}
+			i++;
+		}
+	
+		i = 0;
+		while (i < height)
+		{
+			j = 0;
+			while (j < width)
+			{
+				if ((cell = this.getCellData(row + i, col + j, true)) != null)
+				{
+					if (i == 0)
+					{
+						if (j == 0)
+						{
+							cell.mergeHori = width;
+							cell.mergeVert = height;
+						}
+						else
+						{
+							cell.cdt = CellDataType.MergedLeft;
+						}
+					}
+					else
+					{
+						cell.cdt = CellDataType.MergedUp;
+					}
+				}
+				j++;
+			}
+			i++;
+		}
+		return true;
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 */
+	setCellMergeLeft(row, col)
+	{
+		if (col == 0)
+			return false;
+	
+		let cell;
+		let width = 1;
+		let height = 1;
+		if ((cell = this.getCellData(row, col, true)) != null)
+			cell.cdt = CellDataType.MergedLeft;
+		col--;
+		width++;
+		while (true)
+		{
+			if ((cell = this.getCellData(row, col, true)) == null)
+			{
+				return false;
+			}
+			else if (cell.cdt == CellDataType.MergedUp)
+			{
+				row--;
+				height++;
+			}
+			else if (cell.cdt == CellDataType.MergedLeft)
+			{
+				col--;
+				width++;
+			}
+			else
+			{
+				if (cell.mergeHori < width)
+				{
+					cell.mergeHori = width;
+				}
+				if (cell.mergeVert < height)
+				{
+					cell.mergeVert = height;
+				}
+				break;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 */
+	setCellMergeUp(row, col)
+	{
+		if (row == 0)
+			return false;
+	
+		let cell;
+		let width = 1;
+		let height = 1;
+		if ((cell = this.getCellData(row, col, true)) != null)
+			cell.cdt = CellDataType.MergedUp;
+		row--;
+		height++;
+		while (true)
+		{
+			if ((cell = this.getCellData(row, col, true)) == null)
+			{
+				return false;
+			}
+			else if (cell.cdt == CellDataType.MergedUp)
+			{
+				row--;
+				height++;
+			}
+			else if (cell.cdt == CellDataType.MergedLeft)
+			{
+				col--;
+				width++;
+			}
+			else
+			{
+				if (cell.mergeHori < width)
+				{
+					cell.mergeHori = width;
+				}
+				if (cell.mergeVert < height)
+				{
+					cell.mergeVert = height;
+				}
+				break;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {boolean} hidden
+	 */
+	setRowHidden(row, hidden)
+	{
+		let cell;
+		if (row >= 65536 || (cell = this.getCellData(row, 0, true)) == null)
+			return false;
+		cell.hidden = hidden;
+		return true;
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {number} height
+	 */
+	setRowHeight(row, height)
+	{
+		let rowData;
+		if ((rowData = this.createRow(row)) != null)
+		{
+			rowData.height = height;
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+
+	getCount()
+	{
+		return this.rows.length;
+	}
+
+	/**
+	 * @param {number} row
+	 */
+	getItem(row)
+	{
+		return this.rows[row];
+	}
+
+	/**
+	 * @param {number} col
+	 */
+	removeCol(col)
+	{
+		let i;
+		let row;
+	
+		this.colWidthsPt.splice(col, 1);
+		i = this.rows.length;
+		while (i-- > 0)
+		{
+			if ((row = this.rows[i]) != null)
+			{
+				row.cells.splice(col, 1);
+			}
+		}
+	}
+	
+	/**
+	 * @param {number} col
+	 */
+	insertCol(col)
+	{
+		let i;
+		let row;
+	
+		if (this.colWidthsPt.length > col)
+		{
+			this.colWidthsPt.splice(col, 0, 0);
+		}
+		i = this.rows.length;
+		while (i-- > 0)
+		{
+			if ((row = this.rows[i]) != null)
+			{
+				if (row.cells.length > col)
+				{
+					row.cells.splice(col, 0, null);
+				}
+			}
+		}
+	}
+
+	getMaxCol()
+	{
+		this.maxCol;
+	}
+
+	/**
+	 * @param {number} col
+	 * @param {number} width
+	 * @param {unit.Distance.Unit} du
+	 */
+	setColWidth(col, width, du)
+	{
+		while (col >= this.colWidthsPt.length)
+		{
+			this.colWidthsPt.push(-1);
+		}
+		if (du == unit.Distance.Unit.POINT)
+		{
+			this.colWidthsPt[col] = width;
+		}
+		else
+		{
+			this.colWidthsPt[col] = unit.Distance.convert(du, unit.Distance.Unit.POINT, width);
+		}
+	}
+	
+	getColWidthCount()
+	{
+		return this.colWidthsPt.length;
+	}
+
+	/**
+	 * @param {number} col
+	 */
+	getColWidthPt(col)
+	{
+		if (col >= this.colWidthsPt.length)
+			return -1;
+		return this.colWidthsPt[col];
+	}
+	
+	/**
+	 * @param {number} col
+	 * @param {unit.Distance.Unit} du
+	 */
+	getColWidth(col, du)
+	{
+		if (col >= this.colWidthsPt.length)
+			return -1;
+		if (du == unit.Distance.Unit.POINT)
+			return this.colWidthsPt[col];
+		return unit.Distance.convert(unit.Distance.Unit.POINT, du, this.colWidthsPt[col]);
+	}
+
+	/**
+	 * @param {number} row
+	 * @param {number} col
+	 */
+	getCellDataRead(row, col)
+	{
+		let rowData;
+		let cell;
+		if (row >= this.rows.length + 65536)
+			return null;
+		if (col >= 65536)
+			return null;
+		if (col > this.maxCol)
+		{
+			return null;
+		}
+		while (true)
+		{
+			if ((rowData = this.rows[row]) == null)
+				return null;
+			if ((cell = rowData.cells[col]) == null)
+			{
+				return null;
+			}
+			if (cell.cdt == CellDataType.MergedLeft)
+			{
+				col--;
+			}
+			else if (cell.cdt == CellDataType.MergedUp)
+			{
+				row--;
+			}
+			else
+			{
+				break;
+			}
+		}
+		return cell;		
+	}
+
+	/**
+	 * @param {{cdt: number,cellValue: string|null,style: CellStyle|null,mergeHori: number,mergeVert: number,hidden: boolean,cellURL: string|null} | null} cell
+	 */
+	getCellString(cell)
+	{
+		let cellValue;
+		if (cell == null || (cellValue = cell.cellValue) == null)
+		{
+			return false;
+		}
+		if (cell.cdt == CellDataType.Number)
+		{
+			let v = Number(cellValue);
+			let iv;
+			if (Number.isNaN(v))
+			{
+				return cellValue;
+			}
+			else
+			{
+				return ""+v;
+/*				if (iv == v)
+				{
+					sb.AppendI32(iv);
+				}
+				else
+				{
+					sb.AppendDouble(v);
+				}*/
+	/*			Text::String *fmt;
+				if (cell.style && (fmt = cell.style.GetDataFormat()) != 0)
+				{
+					printf("Style: %s\r\n", fmt.v);
+				}
+				else
+				{
+					printf("Style: null\r\n");
+				}*/
+			}
+		}
+		else
+		{
+			return cellValue;
+		}
+	}
+
+	getDrawingCount()
+	{
+		return this.drawings.length;
+	}
+//	getDrawing(index: number): WorksheetDrawing|null;
+//	getDrawingNoCheck(index: number): WorksheetDrawing;
+//	createDrawing(du: unit.Distance.Unit, x: number, y: number, w: number, h: number): WorksheetDrawing;
+//	createChart(du: unit.Distance.Unit, x: number, y: number, w: number, h: number, title: string|null): OfficeChart;
+}
+
+
+export class Workbook extends data.ParsedObject
+{
+	static defPalette = [
+		0xff000000, 0xffffffff, 0xffff0000, 0xff00ff00, 0xff0000ff, 0xffffff00, 0xffff00ff, 0xff00ffff,
+		0xff800000, 0xff008000, 0xff000080, 0xff808000, 0xff800080, 0xff008080, 0xffc0c0c0, 0xff808080,
+		0xff9999ff, 0xff993366, 0xffffffcc, 0xffccffff, 0xff660066, 0xffff8080, 0xff0066cc, 0xffccccff,
+		0xff000080, 0xffff00ff, 0xffffff00, 0xff00ffff, 0xff800080, 0xff800000, 0xff008080, 0xff0000ff,
+		0xff00ccff, 0xffccffff, 0xffccffcc, 0xffffff99, 0xff99ccff, 0xffff99cc, 0xffcc99ff, 0xffffcc99,
+		0xff3366ff, 0xff33cccc, 0xff99cc00, 0xffffcc00, 0xffff9900, 0xffff6600, 0xff666699, 0xff969696,
+		0xff003366, 0xff339966, 0xff003300, 0xff333300, 0xff993300, 0xff993366, 0xff333399, 0xff333333
+	];
+
+	constructor()
+	{
+		super("Untitled", "Workbook");
+		/**
+		 * @type {string|null}
+		 */
+		this.author = null;
+		/**
+		 * @type {string|null}
+		 */
+		this.lastAuthor = null;
+		/**
+		 * @type {string|null}
+		 */
+		this.company = null;
+		/**
+		 * @type {data.Timestamp|null}
+		 */
+		this.createTime = null;
+		/**
+		 * @type {data.Timestamp|null}
+		 */
+		this.modifyTime = null;
+		this.version = 0;
+		this.windowTopX = 0;
+		this.windowTopY = 0;
+		this.windowWidth = 0;
+		this.windowHeight = 0;
+		this.activeSheet = 0;
+		/** @type {number[]} */
+		this.palette = new Array(56);
+		/** @type {Worksheet[]} */
+		this.sheets = [];
+		/** @type {CellStyle[]} */
+		this.styles = [];
+		/** @type {WorkbookFont[]} */
+		this.fonts = [];
+	
+		let i;
+		for (i in Workbook.defPalette)
+		{
+			this.palette[i] = Workbook.defPalette[i];
+		}
+	
+		this.newCellStyle(null, text.HAlignment.Unknown, text.VAlignment.Bottom, "general");
+		this.newFont("Arial", 10.0, false).setFamily(FontFamily.Swiss);
+		this.newFont("Arial", 10.0, false);
+		this.newFont("Arial", 10.0, false);
+		this.newFont("Arial", 10.0, false);
+	
+	}
+
+	clone()
+	{
+		let i;
+		let j;
+		let newWB = new Workbook();
+		newWB.author = this.author;
+		newWB.lastAuthor = this.lastAuthor;
+		newWB.company = this.company;
+		newWB.createTime = this.createTime;
+		newWB.modifyTime = this.modifyTime;
+		newWB.version = this.version;
+		newWB.windowTopX = this.windowTopX;
+		newWB.windowTopY = this.windowTopY;
+		newWB.windowWidth = this.windowWidth;
+		newWB.windowHeight = this.windowHeight;
+		newWB.activeSheet = this.activeSheet;
+		for (i in this.palette)
+		{
+			newWB.palette[i] = this.palette[i];
+		}
+
+		for (i in this.styles)
+		{
+			newWB.styles.push(this.styles[i].clone());
+		}
+		for (i in this.sheets)
+		{
+			newWB.sheets.push(this.sheets[i].clone(this, newWB));
+		}
+		i = 0;
+		j = this.fonts.length;
+		while (i < j)
+		{
+			newWB.fonts.push(this.fonts[i].clone());
+			i++;
+		}
+		return newWB;
+	}
+
+	addDefaultStyles()
+	{
+		let style;
+		while (this.styles.length < 21)
+		{
+			style = new CellStyle(this.styles.length);
+			this.styles.push(style);
+		}
+	}
+
+	/**
+	 * @param {string | null} author
+	 */
+	setAuthor(author)
+	{
+		this.author = author;
+	}
+
+	/**
+	 * @param {string | null} lastAuthor
+	 */
+	setLastAuthor(lastAuthor)
+	{
+		this.lastAuthor = lastAuthor;	
+	}
+
+	/**
+	 * @param {string | null} company
+	 */
+	setCompany(company)
+	{
+		this.company = company;
+	}
+
+	/**
+	 * @param {data.Timestamp | null} createTime
+	 */
+	setCreateTime(createTime)
+	{
+		this.createTime = createTime;
+	}
+
+	/**
+	 * @param {data.Timestamp | null} modifyTime
+	 */
+	setModifyTime(modifyTime)
+	{
+		this.modifyTime = modifyTime;
+	}
+
+	/**
+	 * @param {number} version
+	 */
+	setVersion(version)
+	{
+		this.version = version;
+	}
+
+	getAuthor()
+	{
+		return this.author;
+	}
+
+	getLastAuthor()
+	{
+		return this.lastAuthor;
+	}
+
+	getCompany()
+	{
+		return this.company;
+	}
+
+	getCreateTime()
+	{
+		return this.createTime;
+	}
+
+	getModifyTime()
+	{
+		return this.modifyTime;
+	}
+
+	getVersion()
+	{
+		return this.version;
+	}
+
+	hasInfo()
+	{
+		if (this.author != null)
+			return true;
+		if (this.lastAuthor != null)
+			return true;
+		if (this.company != null)
+			return true;
+		if (this.createTime != null)
+			return true;
+		if (this.version != 0)
+			return true;
+		return false;
+	}
+
+	/**
+	 * @param {number} windowTopX
+	 */
+	setWindowTopX(windowTopX)
+	{
+		this.windowTopX = windowTopX;
+	}
+
+	/**
+	 * @param {number} windowTopY
+	 */
+	setWindowTopY(windowTopY)
+	{
+		this.windowTopY = windowTopY;
+	}
+
+	/**
+	 * @param {number} windowWidth
+	 */
+	setWindowWidth(windowWidth)
+	{
+		this.windowWidth = windowWidth;
+	}
+
+	/**
+	 * @param {number} windowHeight
+	 */
+	setWindowHeight(windowHeight)
+	{
+		this.windowHeight = windowHeight;
+	}
+
+	/**
+	 * @param {number} index
+	 */
+	setActiveSheet(index)
+	{
+		this.activeSheet = index;
+	}
+
+	getWindowTopX()
+	{
+		return this.windowTopX;
+	}
+
+	getWindowTopY()
+	{
+		return this.windowTopY;
+	}
+
+	getWindowWidth()
+	{
+		return this.windowWidth;
+	}
+
+	getWindowHeight()
+	{
+		return this.windowHeight;
+	}
+
+	getActiveSheet()
+	{
+		return this.activeSheet;
+	}
+
+	hasWindowInfo()
+	{
+		if (this.windowTopX != 0 || this.windowTopY != 0 || this.windowWidth != 0 || this.windowHeight != 0 || this.activeSheet != 0)
+			return true;
+		return false;
+	}
+
+	hasCellStyle()
+	{
+		if (this.styles.length > 0)
+			return true;
+		return false;
+	}
+
+	newCellStyleDef()
+	{
+		let style = new CellStyle(this.styles.length);
+		this.styles.push(style);
+		return style;
+	}
+
+	/**
+	 * @param {WorkbookFont | null} font
+	 * @param {text.HAlignment} halign
+	 * @param {text.VAlignment} valign
+	 * @param {string | null} dataFormat
+	 */
+	newCellStyle(font, halign, valign, dataFormat)
+	{
+		let style = new CellStyle(this.styles.length);
+		style.setFont(font);
+		style.setHAlign(halign);
+		style.setVAlign(valign);
+		style.setDataFormat(dataFormat);
+		this.styles.push(style);
+		return style;
+	}
+
+	getStyleCount()
+	{
+		return this.styles.length;
+	}
+
+	/**
+	 * @param {CellStyle} style
+	 */
+	getStyleIndex(style)
+	{
+		let i = this.styles.length;
+		while (i-- > 0)
+		{
+			if (this.styles[i] == style)
+				return i;
+		}
+		return -1;
+	}
+
+	/**
+	 * @param {number} index
+	 */
+	getStyle(index)
+	{
+		return this.styles[index];
+	}
+
+	/**
+	 * @param {CellStyle} tmpStyle
+	 */
+	findOrCreateStyle(tmpStyle)
+	{
+		let style;
+		let i = this.styles.length;
+		while (i-- > 0)
+		{
+			if ((style = this.styles[i]) != null)
+			{
+				if (style.equals(tmpStyle))
+				{
+					return style;
+				}
+			}
+		}
+		style = tmpStyle.clone();
+		style.setIndex(this.styles.length);
+		this.styles.push(style);
+		return style;
+	}
+
+	getDefaultStyle()
+	{
+		return this.styles[0];
+	}
+
+	getPalette()
+	{
+		return this.palette;
+	}
+
+	/**
+	 * @param {number[]} palette
+	 */
+	setPalette(palette)
+	{
+		let i;
+		for (i in palette)
+		{
+			this.palette[i] = palette[i];
+		}
+	}
+
+	/**
+	 * @param {string | null} name
+	 */
+	addWorksheet(name)
+	{
+		if (name == null)
+			name = "Sheet"+ this.sheets.length;
+		let ws = new Worksheet(name);
+		this.sheets.push(ws);
+		return ws;
+	}
+	
+	/**
+	 * @param {number} index
+	 * @param {string} name
+	 */
+	insertWorksheet(index, name)
+	{
+		let ws = new Worksheet(name);
+		this.sheets.splice(index, 0, ws);
+		return ws;
+	}
+
+	getCount()
+	{
+		return this.sheets.length;
+	}
+
+	/**
+	 * @param {number} index
+	 */
+	getItem(index)
+	{
+		return this.sheets[index];
+	}
+
+	removeAt(index)
+	{
+		return this.sheets.splice(index, 1);
+	}
+
+	/**
+	 * @param {string} name
+	 */
+	getWorksheetByName(name)
+	{
+		let i;
+		for (i in this.sheets)
+		{
+			if (this.sheets[i].getName() == name)
+				return this.sheets[i];
+		}
+		return null;
+	}
+
+	getFontCount()
+	{
+		return this.fonts.length;
+	}
+
+	/**
+	 * @param {number} index
+	 */
+	getFontNoCheck(index)
+	{
+		let fnt = this.fonts[index];
+		if (fnt == null)
+			throw new Error("Font is null");
+		return fnt;
+	}
+
+	/**
+	 * @param {number} index
+	 */
+	getFont(index)
+	{
+		return this.fonts[index];
+	}
+
+	/**
+	 * @param {WorkbookFont} font
+	 */
+	getFontIndex(font)
+	{
+		let i;
+		for (i in this.fonts)
+		{
+			if (this.fonts[i] == font)
+			{
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	newFont(name, size, bold)
+	{
+		let font = new WorkbookFont();
+		this.fonts.push(font);
+		font.setName(name);
+		font.setSize(size);
+		font.setBold(bold);
+		return font;
+	}
+
+	static getDefPalette()
+	{
+		return Workbook.defPalette;
+	}
+
+	/**
+	 * @param {number} col
+	 */
+	static colCode(col)
+	{
+		if (col < 26)
+		{
+			return String.fromCharCode(65 + col);
+		}
+		col -= 26;
+		if (col < 26 * 26)
+		{
+			return String.fromCharCode(65 + (col / 26), 65 + (col % 26));
+		}
+		let sbuff = new Array(3);
+		col -= 26 * 26;
+		sbuff[2] = (65 + (col % 26));
+		col = col / 26;
+		sbuff[1] = (65 + (col % 26));
+		sbuff[0] = (65 + (col / 26));
+		return String.fromCharCode(sbuff[0], sbuff[1], sbuff[2]);		
+	}
+}
+
+export class XLSUtil
+{
+	/**
+	 * @param {data.Timestamp} ts
+	 */
+	static date2Number(ts)
+	{
+		ts = ts.setTimeZoneQHR(0);
+		let secs = ts.inst.sec;
+		let days = Number(secs / 86400n) + 25569;
+		secs -= BigInt(days - 25569) * 86400n;
+		while (secs < 0)
+		{
+			secs += 86400n;
+			days -= 1;
+		}
+		return days + Number(secs) / 86400.0 + (ts.inst.nanosec + 50000) / 86400000000000.0;
+	}
+
+	/**
+	 * @param {number} v
+	 */
+	static number2Timestamp(v)
+	{
+		let days = Math.floor(v);
+		let tz = data.DateTimeUtil.getLocalTzQhr();
+		let ds = (v - days);
+		let s = Math.floor(ds * 86400);
+		return new data.Timestamp(new data.TimeInstant(BigInt(days - 25569) * 86400n + BigInt(s), Math.round((ds * 86400 - s) * 1000000000)), tz);
+	}
+
+	static getCellID(col, row)
+	{
+		let s;
+		if (col >= 26)
+		{
+			s = String.fromCharCode(0x41 + Math.floor(col / 26) - 1, 0x41 + (col % 26));
+		}
+		else
+		{
+			s = String.fromCharCode(0x41 + col);
+		}
+		return s + (row + 1);
+	}
+}