@bilig/xlsx 0.164.0

package/dist/simple-workbook-writer.js

@@ -0,0 +1,621 @@
+import { encodeCellRange } from './address.js';
+import { zipSourcePreservingEntries } from './source-preserving-zip.js';
+import { escapeXmlAttribute, escapeXmlText } from './xml.js';
+const spreadsheetNs = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
+const relationshipNs = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+const packageRelationshipNs = 'http://schemas.openxmlformats.org/package/2006/relationships';
+const contentTypesNs = 'http://schemas.openxmlformats.org/package/2006/content-types';
+const customNumberFormatStartId = 164;
+const defaultFontXml = '<font><sz val="11"/><color theme="1"/><name val="Aptos"/><family val="2"/></font>';
+const simpleWorkbookZipDosTimeParts = { time: 0, date: (1 << 5) | 1 };
+const themeContentType = 'application/vnd.openxmlformats-officedocument.theme+xml';
+function normalizeRgbColor(value) {
+    if (!value) {
+        return null;
+    }
+    const normalized = value.trim().replace(/^#/u, '');
+    if (/^[0-9a-fA-F]{6}$/u.test(normalized)) {
+        return `FF${normalized.toUpperCase()}`;
+    }
+    if (/^[0-9a-fA-F]{8}$/u.test(normalized)) {
+        return normalized.toUpperCase();
+    }
+    return null;
+}
+function xmlDeclaration() {
+    return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+}
+function textElement(name, value) {
+    const preserveSpace = /^\s|\s$/u.test(value) || value.includes('\n') || value.includes('\t');
+    const attributes = preserveSpace ? ' xml:space="preserve"' : '';
+    return `<${name}${attributes}>${escapeXmlText(value)}</${name}>`;
+}
+function formulaText(value) {
+    return escapeXmlText(value).replace(/"/gu, '&quot;');
+}
+function fontXml(font) {
+    if (!font) {
+        return defaultFontXml;
+    }
+    const children = [];
+    if (font.size !== undefined && Number.isFinite(font.size) && font.size > 0) {
+        children.push(`<sz val="${escapeXmlAttribute(String(font.size))}"/>`);
+    }
+    else {
+        children.push('<sz val="11"/>');
+    }
+    const color = normalizeRgbColor(font.color);
+    if (color) {
+        children.push(`<color rgb="${color}"/>`);
+    }
+    else {
+        children.push('<color theme="1"/>');
+    }
+    children.push(`<name val="${escapeXmlAttribute(font.family?.trim() || 'Aptos')}"/>`);
+    children.push('<family val="2"/>');
+    if (font.bold === true) {
+        children.push('<b/>');
+    }
+    if (font.italic === true) {
+        children.push('<i/>');
+    }
+    if (font.underline === true) {
+        children.push('<u/>');
+    }
+    return `<font>${children.join('')}</font>`;
+}
+function fillXml(fill) {
+    const color = normalizeRgbColor(fill?.backgroundColor);
+    return color ? `<fill><patternFill patternType="solid"><fgColor rgb="${color}"/><bgColor indexed="64"/></patternFill></fill>` : null;
+}
+function alignmentXml(alignment) {
+    if (!alignment) {
+        return '';
+    }
+    const attributes = [
+        alignment.horizontal ? `horizontal="${escapeXmlAttribute(alignment.horizontal)}"` : null,
+        alignment.vertical ? `vertical="${escapeXmlAttribute(alignment.vertical === 'middle' ? 'center' : alignment.vertical)}"` : null,
+        alignment.wrap === true ? 'wrapText="1"' : null,
+        alignment.indent !== undefined && alignment.indent >= 0 ? `indent="${String(alignment.indent)}"` : null,
+        alignment.shrinkToFit === true ? 'shrinkToFit="1"' : null,
+        alignment.readingOrder !== undefined ? `readingOrder="${String(alignment.readingOrder)}"` : null,
+        alignment.textRotation !== undefined ? `textRotation="${String(alignment.textRotation)}"` : null,
+        alignment.justifyLastLine === true ? 'justifyLastLine="1"' : null,
+    ].filter((entry) => Boolean(entry));
+    return attributes.length > 0 ? `<alignment ${attributes.join(' ')}/>` : '';
+}
+function protectionXml(protection) {
+    if (!protection) {
+        return '';
+    }
+    const attributes = [
+        protection.locked !== undefined ? `locked="${protection.locked ? '1' : '0'}"` : null,
+        protection.hidden !== undefined ? `hidden="${protection.hidden ? '1' : '0'}"` : null,
+    ].filter((entry) => Boolean(entry));
+    return attributes.length > 0 ? `<protection ${attributes.join(' ')}/>` : '<protection/>';
+}
+function borderStyle(side) {
+    if (!side) {
+        return null;
+    }
+    if (side.style === 'dashed') {
+        return side.weight === 'thin' ? 'dashed' : 'mediumDashed';
+    }
+    if (side.style === 'dotted') {
+        return 'dotted';
+    }
+    if (side.style === 'double') {
+        return 'double';
+    }
+    return side.weight;
+}
+function borderSideXml(name, side) {
+    const style = borderStyle(side);
+    if (!style) {
+        return `<${name}/>`;
+    }
+    const color = normalizeRgbColor(side?.color) ?? 'FF000000';
+    return `<${name} style="${style}"><color rgb="${color}"/></${name}>`;
+}
+function borderXml(borders) {
+    if (!borders) {
+        return null;
+    }
+    const hasBorder = Boolean(borders.top || borders.right || borders.bottom || borders.left);
+    return hasBorder
+        ? `<border>${borderSideXml('left', borders.left)}${borderSideXml('right', borders.right)}${borderSideXml('top', borders.top)}${borderSideXml('bottom', borders.bottom)}<diagonal/></border>`
+        : null;
+}
+function styleKey(style) {
+    return `${style.styleId ?? ''}\u0000${style.numberFormat ?? ''}`;
+}
+function createRegisteredStyle(styleId, numberFormat) {
+    return {
+        ...(styleId !== undefined ? { styleId } : {}),
+        ...(numberFormat !== undefined ? { numberFormat } : {}),
+    };
+}
+function collectRegisteredStyles(workbook) {
+    const keys = new Set();
+    const output = [];
+    const add = (style) => {
+        const key = styleKey(style);
+        if (keys.has(key)) {
+            return;
+        }
+        keys.add(key);
+        output.push(style);
+    };
+    add({});
+    for (const sheet of workbook.sheets) {
+        for (const cell of sheet.cells) {
+            if (cell.styleId || cell.numberFormat) {
+                add(createRegisteredStyle(cell.styleId, cell.numberFormat));
+            }
+        }
+    }
+    return output;
+}
+function buildStyleRegistry(workbook) {
+    if (workbook.stylesXml !== undefined) {
+        return {
+            styleIndexByKey: new Map(),
+            acceptsDirectStyleIndexes: true,
+            stylesXml: workbook.stylesXml,
+        };
+    }
+    const styleById = new Map((workbook.styles ?? []).map((style) => [style.id, style]));
+    const registeredStyles = collectRegisteredStyles(workbook);
+    const customFormats = [
+        ...new Set(registeredStyles.map((style) => style.numberFormat).filter((format) => Boolean(format))),
+    ];
+    const numberFormatIdByCode = new Map(customFormats.map((format, index) => [format, customNumberFormatStartId + index]));
+    const fontXmls = [defaultFontXml];
+    const fillXmls = ['<fill><patternFill patternType="none"/></fill>', '<fill><patternFill patternType="gray125"/></fill>'];
+    const borderXmls = ['<border><left/><right/><top/><bottom/><diagonal/></border>'];
+    const styleIndexByKey = new Map();
+    const xfs = registeredStyles.map((registeredStyle, index) => {
+        styleIndexByKey.set(styleKey(registeredStyle), index);
+        const style = registeredStyle.styleId ? styleById.get(registeredStyle.styleId) : undefined;
+        const styleFontXml = fontXml(style?.font);
+        const fontId = style?.font ? fontXmls.push(styleFontXml) - 1 : 0;
+        const styleFillXml = fillXml(style?.fill);
+        const fillId = styleFillXml ? fillXmls.push(styleFillXml) - 1 : 0;
+        const styleBorderXml = borderXml(style?.borders);
+        const borderId = styleBorderXml ? borderXmls.push(styleBorderXml) - 1 : 0;
+        const numberFormatId = registeredStyle.numberFormat ? (numberFormatIdByCode.get(registeredStyle.numberFormat) ?? 0) : 0;
+        const alignment = alignmentXml(style?.alignment);
+        const protection = protectionXml(style?.protection);
+        const children = `${alignment}${protection}`;
+        const attributes = [
+            `numFmtId="${String(numberFormatId)}"`,
+            `fontId="${String(fontId)}"`,
+            `fillId="${String(fillId)}"`,
+            `borderId="${String(borderId)}"`,
+            'xfId="0"',
+            fontId > 0 ? 'applyFont="1"' : null,
+            fillId > 0 ? 'applyFill="1"' : null,
+            borderId > 0 ? 'applyBorder="1"' : null,
+            numberFormatId > 0 ? 'applyNumberFormat="1"' : null,
+            alignment ? 'applyAlignment="1"' : null,
+            protection ? 'applyProtection="1"' : null,
+        ].filter((entry) => Boolean(entry));
+        return children ? `<xf ${attributes.join(' ')}>${children}</xf>` : `<xf ${attributes.join(' ')}/>`;
+    });
+    const numFmtsXml = customFormats.length === 0
+        ? ''
+        : `<numFmts count="${String(customFormats.length)}">${customFormats
+            .map((format) => `<numFmt numFmtId="${String(numberFormatIdByCode.get(format) ?? 0)}" formatCode="${escapeXmlAttribute(format)}"/>`)
+            .join('')}</numFmts>`;
+    const stylesXml = [
+        xmlDeclaration(),
+        `<styleSheet xmlns="${spreadsheetNs}">`,
+        numFmtsXml,
+        `<fonts count="${String(fontXmls.length)}">${fontXmls.join('')}</fonts>`,
+        `<fills count="${String(fillXmls.length)}">${fillXmls.join('')}</fills>`,
+        `<borders count="${String(borderXmls.length)}">${borderXmls.join('')}</borders>`,
+        '<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>',
+        `<cellXfs count="${String(xfs.length)}">${xfs.join('')}</cellXfs>`,
+        '<cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles>',
+        '</styleSheet>',
+    ].join('');
+    return { styleIndexByKey, acceptsDirectStyleIndexes: false, stylesXml };
+}
+function styleIndexForCell(cell, registry) {
+    if (registry.acceptsDirectStyleIndexes &&
+        cell.styleIndex !== undefined &&
+        Number.isSafeInteger(cell.styleIndex) &&
+        cell.styleIndex >= 0) {
+        return cell.styleIndex;
+    }
+    const index = registry.styleIndexByKey.get(styleKey(createRegisteredStyle(cell.styleId, cell.numberFormat)));
+    return index && index > 0 ? index : undefined;
+}
+function cellValueXml(cell, formula) {
+    if (!formula && cell.sharedStringIndex !== undefined && Number.isSafeInteger(cell.sharedStringIndex) && cell.sharedStringIndex >= 0) {
+        return { type: 's', valueXml: `<v>${String(cell.sharedStringIndex)}</v>` };
+    }
+    if (!formula && cell.inlineStringXml !== undefined) {
+        return { type: 'inlineStr', valueXml: cell.inlineStringXml };
+    }
+    if (cell.error !== undefined) {
+        return { type: 'e', valueXml: `<v>${escapeXmlText(cell.error)}</v>` };
+    }
+    const value = cell.value;
+    if (value === undefined || value === null) {
+        return { type: '', valueXml: '' };
+    }
+    if (typeof value === 'number') {
+        return { type: '', valueXml: `<v>${escapeXmlText(String(value))}</v>` };
+    }
+    if (typeof value === 'boolean') {
+        return { type: 'b', valueXml: `<v>${value ? '1' : '0'}</v>` };
+    }
+    if (formula) {
+        return { type: 'str', valueXml: `<v>${escapeXmlText(value)}</v>` };
+    }
+    return { type: 'inlineStr', valueXml: `<is>${textElement('t', value)}</is>` };
+}
+function cellXml(cell, registry) {
+    const styleIndex = styleIndexForCell(cell, registry);
+    const formula = cell.formula?.replace(/^=/u, '');
+    const { type, valueXml } = cellValueXml(cell, formula);
+    const attributes = [
+        `r="${escapeXmlAttribute(cell.address)}"`,
+        styleIndex !== undefined ? `s="${String(styleIndex)}"` : null,
+        type ? `t="${type}"` : null,
+    ].filter((entry) => Boolean(entry));
+    const formulaXml = formula ? `<f>${formulaText(formula)}</f>` : '';
+    const body = `${formulaXml}${valueXml}`;
+    return body ? `<c ${attributes.join(' ')}>${body}</c>` : `<c ${attributes.join(' ')}/>`;
+}
+function rowXml(rowIndex, cells, rowMetadata, registry) {
+    const attributes = [`r="${String(rowIndex + 1)}"`];
+    if (rowMetadata?.size !== undefined && Number.isFinite(rowMetadata.size) && rowMetadata.size > 0) {
+        attributes.push(`ht="${String(rowMetadata.size)}"`, 'customHeight="1"');
+    }
+    if (rowMetadata?.hidden === true) {
+        attributes.push('hidden="1"');
+    }
+    const body = cells.map((cell) => cellXml(cell, registry)).join('');
+    return body ? `<row ${attributes.join(' ')}>${body}</row>` : `<row ${attributes.join(' ')}/>`;
+}
+function worksheetDimension(sheet) {
+    if (sheet.dimension) {
+        return encodeCellRange(sheet.dimension);
+    }
+    let startRow = Number.POSITIVE_INFINITY;
+    let startCol = Number.POSITIVE_INFINITY;
+    let endRow = 0;
+    let endCol = 0;
+    const visit = (address) => {
+        startRow = Math.min(startRow, address.row);
+        startCol = Math.min(startCol, address.col);
+        endRow = Math.max(endRow, address.row);
+        endCol = Math.max(endCol, address.col);
+    };
+    for (const cell of sheet.cells) {
+        visit(cell);
+    }
+    for (const merge of sheet.merges ?? []) {
+        const range = encodeCellRangeAddress(merge.startAddress, merge.endAddress);
+        visit({ row: range.s.r, col: range.s.c });
+        visit({ row: range.e.r, col: range.e.c });
+    }
+    if (!Number.isFinite(startRow) || !Number.isFinite(startCol)) {
+        return 'A1';
+    }
+    return encodeCellRange({ s: { r: startRow, c: startCol }, e: { r: endRow, c: endCol } });
+}
+function encodeCellRangeAddress(startAddress, endAddress) {
+    const start = parseCellAddressFromA1(startAddress);
+    const end = parseCellAddressFromA1(endAddress);
+    return {
+        s: { r: Math.min(start.row, end.row), c: Math.min(start.col, end.col) },
+        e: { r: Math.max(start.row, end.row), c: Math.max(start.col, end.col) },
+    };
+}
+function parseCellAddressFromA1(address) {
+    const match = /^([A-Z]+)([1-9][0-9]*)$/iu.exec(address.replaceAll('$', ''));
+    if (!match) {
+        throw new Error(`Invalid XLSX cell address: ${address}`);
+    }
+    let col = 0;
+    for (const character of match[1].toUpperCase()) {
+        col = col * 26 + character.charCodeAt(0) - 64;
+    }
+    return { row: Number(match[2]) - 1, col: col - 1 };
+}
+function columnsXml(columns) {
+    if (!columns || columns.length === 0) {
+        return '';
+    }
+    const sorted = [...columns]
+        .filter((column) => Number.isSafeInteger(column.index) && column.index >= 0)
+        .toSorted((left, right) => left.index - right.index);
+    const groups = [];
+    let index = 0;
+    while (index < sorted.length) {
+        const first = sorted[index];
+        let last = first;
+        index += 1;
+        while (index < sorted.length &&
+            sorted[index].index === last.index + 1 &&
+            sorted[index].size === first.size &&
+            sorted[index].hidden === first.hidden) {
+            last = sorted[index];
+            index += 1;
+        }
+        const attributes = [`min="${String(first.index + 1)}"`, `max="${String(last.index + 1)}"`];
+        if (first.size !== undefined && Number.isFinite(first.size) && first.size > 0) {
+            attributes.push(`width="${String(Math.max(0.1, first.size / 6))}"`, 'customWidth="1"');
+        }
+        if (first.hidden === true) {
+            attributes.push('hidden="1"');
+        }
+        groups.push(`<col ${attributes.join(' ')}/>`);
+    }
+    return groups.length > 0 ? `<cols>${groups.join('')}</cols>` : '';
+}
+function sheetDataXml(sheet, registry) {
+    const cellsByRow = new Map();
+    for (const cell of sheet.cells) {
+        let row = cellsByRow.get(cell.row);
+        if (!row) {
+            row = [];
+            cellsByRow.set(cell.row, row);
+        }
+        row.push(cell);
+    }
+    for (const row of cellsByRow.values()) {
+        row.sort((left, right) => left.col - right.col);
+    }
+    const rowMetadataByIndex = new Map((sheet.rows ?? []).map((row) => [row.index, row]));
+    const rowIndexes = [...new Set([...cellsByRow.keys(), ...rowMetadataByIndex.keys()])].toSorted((left, right) => left - right);
+    return `<sheetData>${rowIndexes
+        .map((rowIndex) => rowXml(rowIndex, cellsByRow.get(rowIndex) ?? [], rowMetadataByIndex.get(rowIndex), registry))
+        .join('')}</sheetData>`;
+}
+function mergeCellsXml(merges) {
+    if (!merges || merges.length === 0) {
+        return '';
+    }
+    const entries = merges.map((merge) => `<mergeCell ref="${escapeXmlAttribute(`${merge.startAddress}:${merge.endAddress}`)}"/>`);
+    return `<mergeCells count="${String(entries.length)}">${entries.join('')}</mergeCells>`;
+}
+function autoFilterXml(autoFilters) {
+    const filter = autoFilters?.[0];
+    return filter ? `<autoFilter ref="${escapeXmlAttribute(`${filter.startAddress}:${filter.endAddress}`)}"/>` : '';
+}
+function validSimpleHyperlinks(hyperlinks) {
+    return (hyperlinks ?? []).filter((hyperlink) => hyperlink.address.trim().length > 0 && hyperlink.target.trim().length > 0);
+}
+function externalHyperlinkRelationshipId(index) {
+    return `rIdHyperlink${String(index + 1)}`;
+}
+function worksheetHyperlinksXml(hyperlinks) {
+    let externalIndex = 0;
+    const entries = validSimpleHyperlinks(hyperlinks).map((hyperlink) => {
+        const target = hyperlink.target.trim();
+        let targetAttribute;
+        if (target.startsWith('#')) {
+            targetAttribute = `location="${escapeXmlAttribute(target.slice(1))}"`;
+        }
+        else {
+            targetAttribute = `r:id="${externalHyperlinkRelationshipId(externalIndex)}"`;
+            externalIndex += 1;
+        }
+        const attributes = [
+            `ref="${escapeXmlAttribute(hyperlink.address)}"`,
+            targetAttribute,
+            hyperlink.tooltip && hyperlink.tooltip.trim().length > 0 ? `tooltip="${escapeXmlAttribute(hyperlink.tooltip)}"` : null,
+            hyperlink.display && hyperlink.display.trim().length > 0 ? `display="${escapeXmlAttribute(hyperlink.display)}"` : null,
+        ].filter((entry) => Boolean(entry));
+        return `<hyperlink ${attributes.join(' ')}/>`;
+    });
+    return entries.length > 0 ? `<hyperlinks>${entries.join('')}</hyperlinks>` : '';
+}
+function normalizedMacroCodeName(value) {
+    const trimmed = value?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : null;
+}
+function macroSheetCodeNameByName(macro) {
+    const output = new Map();
+    for (const entry of macro?.sheetCodeNames ?? []) {
+        const sheetName = entry.sheetName.trim();
+        const codeName = normalizedMacroCodeName(entry.codeName);
+        if (sheetName.length > 0 && codeName) {
+            output.set(sheetName, codeName);
+        }
+    }
+    return output;
+}
+function sheetPropertiesXml(sheetCodeName) {
+    const codeName = normalizedMacroCodeName(sheetCodeName);
+    return codeName ? `<sheetPr codeName="${escapeXmlAttribute(codeName)}"/>` : '';
+}
+function worksheetXml(sheet, registry, sheetCodeName) {
+    return [
+        xmlDeclaration(),
+        `<worksheet xmlns="${spreadsheetNs}" xmlns:r="${relationshipNs}">`,
+        sheetPropertiesXml(sheetCodeName),
+        `<dimension ref="${escapeXmlAttribute(worksheetDimension(sheet))}"/>`,
+        '<sheetViews><sheetView workbookViewId="0"/></sheetViews>',
+        '<sheetFormatPr defaultRowHeight="15"/>',
+        columnsXml(sheet.columns),
+        sheetDataXml(sheet, registry),
+        mergeCellsXml(sheet.merges),
+        autoFilterXml(sheet.autoFilters),
+        worksheetHyperlinksXml(sheet.hyperlinks),
+        '</worksheet>',
+    ].join('');
+}
+function workbookXml(workbook) {
+    const sheetsXml = workbook.sheets
+        .map((sheet, index) => `<sheet name="${escapeXmlAttribute(sheet.name)}" sheetId="${String(index + 1)}" r:id="rId${String(index + 1)}"/>`)
+        .join('');
+    const definedNamesXml = definedNamesXmlForWorkbook(workbook.definedNames);
+    return [
+        xmlDeclaration(),
+        `<workbook xmlns="${spreadsheetNs}" xmlns:r="${relationshipNs}">`,
+        workbookPropertiesXml(workbook.macro),
+        `<sheets>${sheetsXml}</sheets>`,
+        definedNamesXml,
+        '</workbook>',
+    ].join('');
+}
+function workbookPropertiesXml(macro) {
+    const codeName = normalizedMacroCodeName(macro?.workbookCodeName);
+    return codeName ? `<workbookPr codeName="${escapeXmlAttribute(codeName)}"/>` : '<workbookPr/>';
+}
+function definedNamesXmlForWorkbook(definedNames) {
+    if (!definedNames || definedNames.length === 0) {
+        return '';
+    }
+    return `<definedNames>${definedNames
+        .map((entry) => {
+        const localSheetId = entry.localSheetIndex !== undefined && Number.isSafeInteger(entry.localSheetIndex) && entry.localSheetIndex >= 0
+            ? ` localSheetId="${String(entry.localSheetIndex)}"`
+            : '';
+        return `<definedName name="${escapeXmlAttribute(entry.name)}"${localSheetId}>${escapeXmlText(entry.formula.replace(/^=/u, ''))}</definedName>`;
+    })
+        .join('')}</definedNames>`;
+}
+function workbookRelationshipsXml(sheetCount, hasSharedStrings, hasMacro) {
+    const sheetRelationships = Array.from({ length: sheetCount }, (_entry, index) => `<Relationship Id="rId${String(index + 1)}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet${String(index + 1)}.xml"/>`).join('');
+    return [
+        xmlDeclaration(),
+        `<Relationships xmlns="${packageRelationshipNs}">`,
+        sheetRelationships,
+        `<Relationship Id="rId${String(sheetCount + 1)}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>`,
+        `<Relationship Id="rId${String(sheetCount + 2)}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme" Target="theme/theme1.xml"/>`,
+        hasSharedStrings
+            ? `<Relationship Id="rId${String(sheetCount + 3)}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>`
+            : '',
+        hasMacro
+            ? `<Relationship Id="rId${String(sheetCount + (hasSharedStrings ? 4 : 3))}" Type="http://schemas.microsoft.com/office/2006/relationships/vbaProject" Target="vbaProject.bin"/>`
+            : '',
+        '</Relationships>',
+    ].join('');
+}
+function rootRelationshipsXml() {
+    return [
+        xmlDeclaration(),
+        `<Relationships xmlns="${packageRelationshipNs}">`,
+        '<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>',
+        '<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/>',
+        '<Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/>',
+        '</Relationships>',
+    ].join('');
+}
+function worksheetRelationshipsXml(hyperlinks) {
+    const relationships = validSimpleHyperlinks(hyperlinks)
+        .filter((hyperlink) => !hyperlink.target.trim().startsWith('#'))
+        .map((hyperlink, index) => `<Relationship Id="${externalHyperlinkRelationshipId(index)}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="${escapeXmlAttribute(hyperlink.target.trim())}" TargetMode="External"/>`);
+    return relationships.length > 0
+        ? [xmlDeclaration(), `<Relationships xmlns="${packageRelationshipNs}">`, ...relationships, '</Relationships>'].join('')
+        : '';
+}
+function contentTypesXml(sheetCount, hasSharedStrings, hasMacro) {
+    const worksheets = Array.from({ length: sheetCount }, (_entry, index) => `<Override PartName="/xl/worksheets/sheet${String(index + 1)}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`).join('');
+    const sharedStrings = hasSharedStrings
+        ? '<Override PartName="/xl/sharedStrings.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"/>'
+        : '';
+    return [
+        xmlDeclaration(),
+        `<Types xmlns="${contentTypesNs}">`,
+        '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>',
+        '<Default Extension="xml" ContentType="application/xml"/>',
+        hasMacro ? '<Default Extension="bin" ContentType="application/vnd.ms-office.vbaProject"/>' : '',
+        `<Override PartName="/xl/workbook.xml" ContentType="${hasMacro
+            ? 'application/vnd.ms-excel.sheet.macroEnabled.main+xml'
+            : 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml'}"/>`,
+        '<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>',
+        `<Override PartName="/xl/theme/theme1.xml" ContentType="${themeContentType}"/>`,
+        sharedStrings,
+        '<Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>',
+        '<Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/>',
+        worksheets,
+        '</Types>',
+    ].join('');
+}
+function corePropertiesXml() {
+    return [
+        xmlDeclaration(),
+        '<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:dcmitype="http://purl.org/dc/dcmitype/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">',
+        '<dc:creator>Bilig</dc:creator>',
+        '<cp:lastModifiedBy>Bilig</cp:lastModifiedBy>',
+        '</cp:coreProperties>',
+    ].join('');
+}
+function appPropertiesXml(sheetCount) {
+    return [
+        xmlDeclaration(),
+        '<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes">',
+        '<Application>Bilig</Application>',
+        `<HeadingPairs><vt:vector size="2" baseType="variant"><vt:variant><vt:lpstr>Worksheets</vt:lpstr></vt:variant><vt:variant><vt:i4>${String(sheetCount)}</vt:i4></vt:variant></vt:vector></HeadingPairs>`,
+        '</Properties>',
+    ].join('');
+}
+function themeXml() {
+    return [
+        xmlDeclaration(),
+        '<a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" name="Bilig Theme">',
+        '<a:themeElements>',
+        '<a:clrScheme name="Bilig">',
+        '<a:dk1><a:sysClr val="windowText" lastClr="000000"/></a:dk1>',
+        '<a:lt1><a:sysClr val="window" lastClr="FFFFFF"/></a:lt1>',
+        '<a:dk2><a:srgbClr val="44546A"/></a:dk2>',
+        '<a:lt2><a:srgbClr val="E7E6E6"/></a:lt2>',
+        '<a:accent1><a:srgbClr val="4472C4"/></a:accent1>',
+        '<a:accent2><a:srgbClr val="ED7D31"/></a:accent2>',
+        '<a:accent3><a:srgbClr val="A5A5A5"/></a:accent3>',
+        '<a:accent4><a:srgbClr val="FFC000"/></a:accent4>',
+        '<a:accent5><a:srgbClr val="5B9BD5"/></a:accent5>',
+        '<a:accent6><a:srgbClr val="70AD47"/></a:accent6>',
+        '<a:hlink><a:srgbClr val="0563C1"/></a:hlink>',
+        '<a:folHlink><a:srgbClr val="954F72"/></a:folHlink>',
+        '</a:clrScheme>',
+        '<a:fontScheme name="Aptos">',
+        '<a:majorFont><a:latin typeface="Aptos Display"/><a:ea typeface=""/><a:cs typeface=""/></a:majorFont>',
+        '<a:minorFont><a:latin typeface="Aptos"/><a:ea typeface=""/><a:cs typeface=""/></a:minorFont>',
+        '</a:fontScheme>',
+        '<a:fmtScheme name="Bilig"><a:fillStyleLst><a:solidFill><a:schemeClr val="phClr"/></a:solidFill></a:fillStyleLst><a:lnStyleLst><a:ln w="9525"><a:solidFill><a:schemeClr val="phClr"/></a:solidFill></a:ln></a:lnStyleLst><a:effectStyleLst><a:effectStyle/></a:effectStyleLst><a:bgFillStyleLst><a:solidFill><a:schemeClr val="phClr"/></a:solidFill></a:bgFillStyleLst></a:fmtScheme>',
+        '</a:themeElements>',
+        '</a:theme>',
+    ].join('');
+}
+export function writeSimpleXlsxWorkbook(workbook) {
+    if (workbook.sheets.length === 0) {
+        throw new Error('Cannot write an XLSX workbook without worksheets');
+    }
+    const registry = buildStyleRegistry(workbook);
+    const hasSharedStrings = workbook.sharedStringsXml !== undefined;
+    const hasMacro = workbook.macro !== undefined;
+    const sheetCodeNameByName = macroSheetCodeNameByName(workbook.macro);
+    const zip = {
+        '[Content_Types].xml': new TextEncoder().encode(contentTypesXml(workbook.sheets.length, hasSharedStrings, hasMacro)),
+        '_rels/.rels': new TextEncoder().encode(rootRelationshipsXml()),
+        'docProps/app.xml': new TextEncoder().encode(appPropertiesXml(workbook.sheets.length)),
+        'docProps/core.xml': new TextEncoder().encode(corePropertiesXml()),
+        'xl/workbook.xml': new TextEncoder().encode(workbookXml(workbook)),
+        'xl/_rels/workbook.xml.rels': new TextEncoder().encode(workbookRelationshipsXml(workbook.sheets.length, hasSharedStrings, hasMacro)),
+        'xl/styles.xml': new TextEncoder().encode(registry.stylesXml),
+        'xl/theme/theme1.xml': new TextEncoder().encode(themeXml()),
+    };
+    if (workbook.macro !== undefined) {
+        zip['xl/vbaProject.bin'] = new Uint8Array(workbook.macro.vbaProject);
+    }
+    if (workbook.sharedStringsXml !== undefined) {
+        zip['xl/sharedStrings.xml'] = new TextEncoder().encode(workbook.sharedStringsXml);
+    }
+    workbook.sheets.forEach((sheet, index) => {
+        zip[`xl/worksheets/sheet${String(index + 1)}.xml`] = new TextEncoder().encode(worksheetXml(sheet, registry, sheetCodeNameByName.get(sheet.name)));
+        const relationshipsXml = worksheetRelationshipsXml(sheet.hyperlinks);
+        if (relationshipsXml.length > 0) {
+            zip[`xl/worksheets/_rels/sheet${String(index + 1)}.xml.rels`] = new TextEncoder().encode(relationshipsXml);
+        }
+    });
+    return zipSourcePreservingEntries(zip, new Map(), { dosTime: simpleWorkbookZipDosTimeParts });
+}
+//# sourceMappingURL=simple-workbook-writer.js.map