@a3s-lab/office 0.2.2 → 0.4.0

package/dist/0~7048.js

@@ -2,7 +2,8 @@ import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useId, useRef, useState } from "react";
 import { Check, ChevronDown, ChevronUp } from "lucide-react";
 import { Dialog } from "./0~4595.js";
-import { button_Button, office_text_field_OfficeTextField, office_text_field_OfficeTextArea } from "./0~9512.js";
+import { button_Button, office_text_field_OfficeTextField, office_text_field_OfficeTextArea } from "./0~6090.js";
+import { OFFICE_KERNEL_SPREADSHEET_MAX_ROWS as office_kernel_spreadsheet_protocol_OFFICE_KERNEL_SPREADSHEET_MAX_ROWS, isOfficeKernelSpreadsheetError } from "./5184.js";
 function CollectionState({ children, icon, actions, tone = 'neutral', role, className = '' }) {
     return /*#__PURE__*/ jsxs("div", {
         className: `ds-collection-state ${tone}${className ? ` ${className}` : ''}`,
@@ -667,29 +668,36 @@ function normalizeOfficeFontFamily(value) {
     return officeFontFamilyLabel(value).toLocaleLowerCase();
 }
 const MAX_LAYOUT_BLOCKS = 10000;
+const MAX_LAYOUT_PAGE_STYLES = MAX_LAYOUT_BLOCKS;
 const MAX_LAYOUT_EXTENT = 1000000;
 const MAX_LAYOUT_PAGE_INDEX = 1000000;
 function layoutOfficeDocumentInJavaScript(request) {
     validateLayoutRequest(request);
-    const availableHeight = Math.max(1, request.page.height - request.page.marginTop - request.page.marginBottom);
+    const pageStyles = new Map((request.pageStyles ?? []).map(({ id, page })=>[
+            id,
+            page
+        ]));
+    const firstPage = pageMetricsForBlock(request.blocks[0], request.page, pageStyles);
     const pages = [
-        emptyPage(request.startPageIndex, availableHeight)
+        emptyPage(request.startPageIndex, firstPage)
     ];
     let index = 0;
     while(index < request.blocks.length){
         const block = request.blocks[index];
+        const page = pageMetricsForBlock(block, request.page, pageStyles);
+        ensurePageMetrics(pages, page);
         if (void 0 !== block.flowCount) {
             const end = index + block.flowCount;
-            layoutFlow(request.blocks.slice(index, end), request.blocks.slice(end), pages, availableHeight, end < request.blocks.length);
+            layoutFlow(request.blocks.slice(index, end), request.blocks.slice(end), pages, page, request.page, pageStyles, end < request.blocks.length);
             index = end;
         } else {
-            layoutSingleBlock(block, request.blocks.slice(index + 1), pages, availableHeight, index + 1 < request.blocks.length);
+            layoutSingleBlock(block, request.blocks.slice(index + 1), pages, page, request.page, pageStyles, index + 1 < request.blocks.length);
             index += 1;
         }
     }
     if (pages.length > 1 && pages.at(-1)?.placements.length === 0) pages.pop();
     return {
-        protocol: 15,
+        protocol: 16,
         kind: 'layoutResult',
         requestId: request.requestId,
         revision: request.revision,
@@ -697,66 +705,76 @@ function layoutOfficeDocumentInJavaScript(request) {
         startPageIndex: request.startPageIndex,
         engine: "javascript",
         pages,
-        breaks: layoutBreaks(pages, request)
+        breaks: layoutBreaks(pages)
     };
 }
 function validateLayoutRequest(request) {
-    if (15 !== request.protocol) throw kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
+    if (16 !== request.protocol) throw kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
     if ('layout' !== request.kind) throw kernelError('office.kernel.request_kind_invalid', 'The Office kernel only accepts layout requests at this boundary.');
     if (!Number.isSafeInteger(request.requestId) || request.requestId < 0 || !Number.isSafeInteger(request.revision) || request.revision < 0 || !Number.isSafeInteger(request.documentRevision) || request.documentRevision < 0 || !Number.isSafeInteger(request.startPageIndex) || request.startPageIndex < 0) throw kernelError('office.kernel.revision_invalid', 'Request, layout, and document revisions must be non-negative safe integers.');
     if (request.startPageIndex > MAX_LAYOUT_PAGE_INDEX) throw kernelError('office.kernel.page_index_invalid', `startPageIndex may not exceed ${MAX_LAYOUT_PAGE_INDEX}.`);
     if (request.blocks.length > MAX_LAYOUT_BLOCKS) throw kernelError('office.kernel.block_limit_exceeded', `A layout request may contain at most ${MAX_LAYOUT_BLOCKS} blocks.`);
-    for (const [name, value] of Object.entries(request.page))validateExtent(`page.${name}`, value);
-    if (request.page.width <= request.page.marginLeft + request.page.marginRight) throw kernelError('office.kernel.page_width_invalid', 'Page width must be greater than its horizontal margins.');
-    if (request.page.height <= request.page.marginTop + request.page.marginBottom) throw kernelError('office.kernel.page_height_invalid', 'Page height must leave a positive body area.');
+    validatePageMetrics('page', request.page);
+    const pageStyles = request.pageStyles ?? [];
+    if (pageStyles.length > MAX_LAYOUT_PAGE_STYLES) throw kernelError('office.kernel.page_style_limit_exceeded', `A layout request may contain at most ${MAX_LAYOUT_PAGE_STYLES} page styles.`);
+    const pageStyleIds = new Set();
+    for (const style of pageStyles){
+        if (!style.id.trim() || style.id.length > 256) throw kernelError('office.kernel.page_style_id_invalid', 'Every page style requires a non-empty ID of at most 256 bytes.');
+        if (pageStyleIds.has(style.id)) throw kernelError('office.kernel.page_style_id_duplicate', `Page style ID '${style.id}' is duplicated.`);
+        pageStyleIds.add(style.id);
+        validatePageMetrics(`pageStyles.${style.id}.page`, style.page);
+    }
     const blockIds = new Set();
     for (const block of request.blocks){
         if (!block.id.trim() || block.id.length > 256) throw kernelError('office.kernel.block_id_invalid', 'Every layout block requires a non-empty ID of at most 256 bytes.');
         if (blockIds.has(block.id)) throw kernelError('office.kernel.block_id_duplicate', `Layout block ID '${block.id}' is duplicated.`);
         blockIds.add(block.id);
+        if (void 0 !== block.pageStyleId && (!block.pageStyleId.trim() || block.pageStyleId.length > 256 || !pageStyleIds.has(block.pageStyleId))) throw kernelError('office.kernel.page_style_reference_invalid', `Layout block '${block.id}' references an unknown page style.`);
         validateExtent('block.height', block.height);
         validateFlowMetadata(block);
     }
     validateFlowSequences(request.blocks);
 }
-function layoutSingleBlock(block, next, pages, availableHeight, hasMoreBlocks) {
+function layoutSingleBlock(block, next, pages, page, defaultPage, pageStyles, hasMoreBlocks) {
+    const availableHeight = pageBodyHeight(page);
     let current = pages.at(-1);
     let currentHasContent = current.placements.length > 0;
     if (block.breakBefore && currentHasContent) {
-        current = emptyPage(nextPageIndex(pages), availableHeight);
+        current = emptyPage(nextPageIndex(pages), page);
         pages.push(current);
         currentHasContent = false;
     }
     const remaining = Math.max(0, availableHeight - current.usedHeight);
-    const nextHeight = nextBlockPreviewHeight(next);
+    const nextHeight = nextBlockPreviewHeight(next, page, defaultPage, pageStyles);
     const groupedHeight = block.height + (block.keepWithNext ? nextHeight : 0);
     const shouldAdvance = currentHasContent && (block.height > remaining || (block.keepTogether || block.keepWithNext) && groupedHeight <= availableHeight && groupedHeight > remaining);
     if (shouldAdvance) {
-        current = emptyPage(nextPageIndex(pages), availableHeight);
+        current = emptyPage(nextPageIndex(pages), page);
         pages.push(current);
     }
     placeFragment(block, current, availableHeight);
-    if (block.breakAfter && hasMoreBlocks) pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+    if (block.breakAfter && hasMoreBlocks) pages.push(emptyPage(nextPageIndex(pages), page));
 }
-function layoutFlow(blocks, next, pages, availableHeight, hasMoreBlocks) {
+function layoutFlow(blocks, next, pages, page, defaultPage, pageStyles, hasMoreBlocks) {
+    const availableHeight = pageBodyHeight(page);
     const first = blocks[0];
     const last = blocks.at(-1);
-    if (first.breakBefore && pages.at(-1)?.placements.length) pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+    if (first.breakBefore && pages.at(-1)?.placements.length) pages.push(emptyPage(nextPageIndex(pages), page));
     const totalHeight = fragmentHeight(blocks, 0, blocks.length);
-    const nextHeight = last.keepWithNext ? nextBlockPreviewHeight(next) : 0;
+    const nextHeight = last.keepWithNext ? nextBlockPreviewHeight(next, page, defaultPage, pageStyles) : 0;
     let current = pages.at(-1);
     const repeatHeaderCount = first.repeatHeaderCount ?? 0;
     const repeatHeaderHeight = first.repeatHeaderHeight ?? 0;
     const groupedHeight = totalHeight + nextHeight;
     if (first.keepTogether && current.placements.length && groupedHeight <= availableHeight && groupedHeight > Math.max(0, availableHeight - current.usedHeight)) {
-        current = emptyPage(nextPageIndex(pages), availableHeight);
+        current = emptyPage(nextPageIndex(pages), page);
         pages.push(current);
     }
     if (repeatHeaderCount > 0 && repeatHeaderCount < blocks.length) {
         const leadingHeight = fragmentHeight(blocks, 0, repeatHeaderCount + 1);
         const remainingHeight = Math.max(0, availableHeight - current.usedHeight);
         if (current.placements.length > 0 && leadingHeight <= availableHeight && leadingHeight > remainingHeight) {
-            current = emptyPage(nextPageIndex(pages), availableHeight);
+            current = emptyPage(nextPageIndex(pages), page);
             pages.push(current);
         }
     }
@@ -770,7 +788,7 @@ function layoutFlow(blocks, next, pages, availableHeight, hasMoreBlocks) {
         const remainingFragments = blocks.length - cursor;
         const remainingFlowHeight = fragmentHeight(blocks, cursor, blocks.length);
         if (nextHeight > 0 && currentHasContent && remainingFlowHeight <= remainingHeight && remainingFlowHeight + nextHeight > remainingHeight && remainingFlowHeight + nextHeight <= availableHeight) {
-            pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+            pages.push(emptyPage(nextPageIndex(pages), page));
             continue;
         }
         let fitting = fragmentsFitting(blocks, cursor, blocks.length, remainingHeight);
@@ -781,7 +799,7 @@ function layoutFlow(blocks, next, pages, availableHeight, hasMoreBlocks) {
         }
         if (0 === fitting) {
             if (currentHasContent) {
-                pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+                pages.push(emptyPage(nextPageIndex(pages), page));
                 continue;
             }
             fitting = 1;
@@ -789,19 +807,20 @@ function layoutFlow(blocks, next, pages, availableHeight, hasMoreBlocks) {
         if (remainingFragments > minimum) fitting = Math.min(fitting, remainingFragments - minimum);
         const minimumHere = Math.min(minimum, remainingFragments);
         if (fitting < minimumHere && currentHasContent) {
-            pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+            pages.push(emptyPage(nextPageIndex(pages), page));
             continue;
         }
         fitting = Math.max(1, fitting);
         placeFragments(blocks, cursor, cursor + fitting, current, availableHeight);
         cursor += fitting;
-        if (cursor < blocks.length) pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+        if (cursor < blocks.length) pages.push(emptyPage(nextPageIndex(pages), page));
     }
-    if (last.breakAfter && hasMoreBlocks) pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+    if (last.breakAfter && hasMoreBlocks) pages.push(emptyPage(nextPageIndex(pages), page));
 }
-function nextBlockPreviewHeight(blocks) {
+function nextBlockPreviewHeight(blocks, currentPage, defaultPage, pageStyles) {
     const first = blocks[0];
     if (!first || first.breakBefore) return 0;
+    if (!pageMetricsEqual(currentPage, pageMetricsForBlock(first, defaultPage, pageStyles))) return 0;
     const count = Math.min(2, first.flowCount ?? 1);
     return fragmentHeight(blocks, 0, count);
 }
@@ -874,25 +893,28 @@ function validateFlowSequences(blocks) {
         const flow = blocks.slice(index, index + count);
         if (flow.length !== count) throw kernelError('office.kernel.flow_sequence_invalid', 'A layout flow must contain its declared number of fragments.');
         flow.forEach((fragment, flowIndex)=>{
-            if (fragment.flowId !== block.flowId || fragment.flowIndex !== flowIndex || fragment.flowCount !== count || fragment.minimumFragmentsPerPage !== block.minimumFragmentsPerPage || fragment.repeatHeaderCount !== repeatHeaderCount || fragment.repeatHeaderHeight !== repeatHeaderHeight) throw kernelError('office.kernel.flow_sequence_invalid', 'Layout flow fragments must be consecutive and consistently indexed.');
+            if (fragment.flowId !== block.flowId || fragment.flowIndex !== flowIndex || fragment.flowCount !== count || fragment.minimumFragmentsPerPage !== block.minimumFragmentsPerPage || fragment.repeatHeaderCount !== repeatHeaderCount || fragment.repeatHeaderHeight !== repeatHeaderHeight || fragment.pageStyleId !== block.pageStyleId) throw kernelError('office.kernel.flow_sequence_invalid', 'Layout flow fragments must be consecutive and consistently indexed.');
             if (flowIndex > 0 && fragment.breakBefore) throw kernelError('office.kernel.flow_break_invalid', 'Only the first flow fragment may request breakBefore.');
             if (flowIndex + 1 < count && fragment.breakAfter) throw kernelError('office.kernel.flow_break_invalid', 'Only the last flow fragment may request breakAfter.');
         });
         index += count;
     }
 }
-function emptyPage(index, availableHeight) {
+function emptyPage(index, page) {
     return {
         index,
+        page: {
+            ...page
+        },
         usedHeight: 0,
-        availableHeight,
+        availableHeight: pageBodyHeight(page),
         placements: []
     };
 }
 function nextPageIndex(pages) {
     return (pages.at(-1)?.index ?? -1) + 1;
 }
-function layoutBreaks(pages, request) {
+function layoutBreaks(pages) {
     return pages.slice(1).flatMap((page, localIndex)=>{
         const beforeBlockId = page.placements[0]?.blockId;
         const previous = pages[localIndex];
@@ -903,11 +925,37 @@ function layoutBreaks(pages, request) {
                 beforeBlockId,
                 pageIndex: page.index,
                 remainingBodyHeight,
-                spacerHeight: remainingBodyHeight + request.page.marginBottom + request.page.pageGap + request.page.marginTop
+                spacerHeight: remainingBodyHeight + previous.page.marginBottom + previous.page.pageGap + page.page.marginTop
             }
         ];
     });
 }
+function ensurePageMetrics(pages, page) {
+    const current = pages.at(-1);
+    if (pageMetricsEqual(current.page, page)) return;
+    if (0 === current.placements.length && 0 === current.usedHeight) {
+        current.page = {
+            ...page
+        };
+        current.availableHeight = pageBodyHeight(page);
+        return;
+    }
+    pages.push(emptyPage(nextPageIndex(pages), page));
+}
+function pageMetricsForBlock(block, defaultPage, pageStyles) {
+    return block?.pageStyleId ? pageStyles.get(block.pageStyleId) ?? defaultPage : defaultPage;
+}
+function pageBodyHeight(page) {
+    return Math.max(1, page.height - page.marginTop - page.marginBottom);
+}
+function pageMetricsEqual(left, right) {
+    return left.width === right.width && left.height === right.height && left.marginTop === right.marginTop && left.marginRight === right.marginRight && left.marginBottom === right.marginBottom && left.marginLeft === right.marginLeft && left.headerHeight === right.headerHeight && left.footerHeight === right.footerHeight && left.pageGap === right.pageGap;
+}
+function validatePageMetrics(name, page) {
+    for (const [property, value] of Object.entries(page))validateExtent(`${name}.${property}`, value);
+    if (page.width <= page.marginLeft + page.marginRight) throw kernelError('office.kernel.page_width_invalid', 'Page width must be greater than its horizontal margins.');
+    if (page.height <= page.marginTop + page.marginBottom) throw kernelError('office.kernel.page_height_invalid', 'Page height must leave a positive body area.');
+}
 function validateExtent(name, value) {
     if (!Number.isFinite(value) || value < 0 || value > MAX_LAYOUT_EXTENT) throw kernelError('office.kernel.extent_invalid', `${name} must be a finite non-negative number.`);
 }
@@ -929,7 +977,7 @@ function resolveOfficePresentationGeometryInJavaScript(request) {
         guides: []
     } : snapPresentationElement(request.elements, operation.movingElementId, operation.mode, operation.thresholdX, operation.thresholdY);
     return {
-        protocol: 15,
+        protocol: 16,
         kind: 'presentationGeometryResult',
         requestId: request.requestId,
         revision: request.revision,
@@ -1077,7 +1125,7 @@ function clampPresentationExtent(value, maximum) {
     return Math.min(Math.max(value, 0), Math.max(0, maximum));
 }
 function validatePresentationGeometryRequest(request) {
-    if (15 !== request.protocol) throw office_kernel_presentation_fallback_kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
+    if (16 !== request.protocol) throw office_kernel_presentation_fallback_kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
     if ('presentationGeometry' !== request.kind) throw office_kernel_presentation_fallback_kernelError('office.kernel.request_kind_invalid', 'The presentation geometry kernel received an invalid request kind.');
     for (const [name, value] of [
         [
@@ -1383,36 +1431,13 @@ function isAsciiFormulaNameStart(value) {
 function isAsciiFormulaNameContinue(value) {
     return /[A-Za-z0-9_.]/u.test(value);
 }
-const office_kernel_spreadsheet_protocol_OFFICE_KERNEL_SPREADSHEET_MAX_ROWS = 1048576;
-const spreadsheetErrors = new Set([
-    '#BLOCKED!',
-    '#BUSY!',
-    '#CALC!',
-    '#CONNECT!',
-    '#DIV/0!',
-    '#FIELD!',
-    '#GETTING_DATA',
-    '#N/A',
-    '#NAME?',
-    '#NULL!',
-    '#NUM!',
-    '#PYTHON!',
-    '#REF!',
-    '#SPILL!',
-    '#UNKNOWN!',
-    '#VALUE!'
-]);
-new TextEncoder();
-function isOfficeKernelSpreadsheetError(value) {
-    return 'string' == typeof value && spreadsheetErrors.has(value);
-}
 const MAX_SPREADSHEET_INPUT_CELLS = 100000;
 const MAX_SPREADSHEET_FORMULA_CHARACTERS = 8192;
 const MAX_SPREADSHEET_SHEETS = 1024;
 const MAX_SPREADSHEET_IDENTIFIER_BYTES = 256;
 const MAX_UNSIGNED_32_BIT_INTEGER = 4294967295;
 function validateSpreadsheetCalculationRequest(request) {
-    if (15 !== request.protocol) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
+    if (16 !== request.protocol) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
     if ('spreadsheetCalculation' !== request.kind) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.request_kind_invalid', 'The Spreadsheet kernel only accepts calculation requests.');
     if (!unsigned32BitInteger(request.requestId) || !unsigned32BitInteger(request.revision) || !nonNegativeSafeInteger(request.documentRevision)) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.revision_invalid', 'Request, calculation, and document revisions must be non-negative safe integers.');
     if (request.sheets.length > MAX_SPREADSHEET_SHEETS) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.sheet_limit_exceeded', `A Spreadsheet calculation request may contain at most ${MAX_SPREADSHEET_SHEETS} sheets.`);
@@ -1575,7 +1600,7 @@ class JavaScriptSpreadsheetEvaluator {
             ] : [];
         });
         return {
-            protocol: 15,
+            protocol: 16,
             kind: 'spreadsheetCalculationResult',
             requestId: this.request.requestId,
             revision: this.request.revision,
@@ -1804,7 +1829,7 @@ async function calculateSpreadsheetSessionInJavaScript(request, sheets) {
 }
 function layoutOfficeTextInJavaScript(request) {
     return {
-        protocol: 15,
+        protocol: 16,
         kind: 'textLayoutResult',
         requestId: request.requestId,
         revision: request.revision,
@@ -1847,13 +1872,14 @@ class BrowserOfficeKernelClient {
     layout(input, signal) {
         if (this.disposed) return Promise.reject(disposedError());
         const request = {
-            protocol: 15,
+            protocol: 16,
             kind: 'layout',
             requestId: this.nextRequestId++,
             revision: input.revision,
             documentRevision: input.documentRevision,
             startPageIndex: input.startPageIndex ?? 0,
             page: input.page,
+            pageStyles: input.pageStyles,
             blocks: input.blocks
         };
         if (signal?.aborted) return Promise.reject(abortError());
@@ -1874,7 +1900,7 @@ class BrowserOfficeKernelClient {
     presentationGeometry(input, signal) {
         if (this.disposed) return Promise.reject(disposedError());
         const request = {
-            protocol: 15,
+            protocol: 16,
             kind: 'presentationGeometry',
             requestId: this.nextRequestId++,
             revision: input.revision,
@@ -1900,7 +1926,7 @@ class BrowserOfficeKernelClient {
     textLayout(input, signal) {
         if (this.disposed) return Promise.reject(disposedError());
         const request = {
-            protocol: 15,
+            protocol: 16,
             kind: 'textLayout',
             requestId: this.nextRequestId++,
             revision: input.revision,
@@ -1925,7 +1951,7 @@ class BrowserOfficeKernelClient {
     spreadsheetCalculation(input, signal) {
         if (this.disposed) return Promise.reject(disposedError());
         const request = {
-            protocol: 15,
+            protocol: 16,
             kind: 'spreadsheetCalculation',
             requestId: this.nextRequestId++,
             revision: input.revision,
@@ -1951,7 +1977,7 @@ class BrowserOfficeKernelClient {
     spreadsheetSessionCalculation(input, signal) {
         if (this.disposed) return Promise.reject(disposedError());
         const request = {
-            protocol: 15,
+            protocol: 16,
             kind: 'spreadsheetSessionCalculation',
             requestId: this.nextRequestId++,
             revision: input.revision,
@@ -2109,4 +2135,4 @@ function abortError() {
 function disposedError() {
     return new Error('Office kernel client is disposed.');
 }
-export { CollectionState, CommittedOfficeNumberField, OfficeCheckbox, OfficeNumberField, createOfficeKernelClient, handleOfficeTaskPaneKeyDown, isOfficeKernelSpreadsheetError, normalizeOfficeFontFamily, officeFontFamilies, officeFontFamilyLabel, office_kernel_spreadsheet_protocol_OFFICE_KERNEL_SPREADSHEET_MAX_ROWS, useOfficeDialog, useOfficeTaskPaneEscape, useOfficeTaskPaneModal };
+export { CollectionState, CommittedOfficeNumberField, OfficeCheckbox, OfficeNumberField, createOfficeKernelClient, handleOfficeTaskPaneKeyDown, normalizeOfficeFontFamily, officeFontFamilies, officeFontFamilyLabel, useOfficeDialog, useOfficeTaskPaneEscape, useOfficeTaskPaneModal };

package/dist/0~7614.js

@@ -1,7 +1,8 @@
 import jszip from "jszip";
-import { workSpreadsheetChartSupportsErrorBars, workSpreadsheetChartSupportsGrouping, parseXml, firstDescendant, normalizeWorkSpreadsheetChartSmoothLines, workSpreadsheetChartSupportsSeriesAnalysis, descendants, normalizeWorkSpreadsheetChartSeriesStyle, attribute, directChildren, xmlNamespacePrefix, normalizeWorkSpreadsheetChartOverlap, normalizeWorkSpreadsheetErrorBars, normalizeWorkSpreadsheetChartLegendOverlay, normalizeWorkSpreadsheetChartGapWidth, workSpreadsheetChartSupportsBarSpacing, directChild, normalizeWorkSpreadsheetChartGrouping, workSpreadsheetChartSupportsSmoothLines, normalizeWorkSpreadsheetTrendline, workSpreadsheetChartUsesNumericXAxis, workSpreadsheetChartSupportsTrendlines } from "./8715.js";
+import { descendants, directChildren, directChild, xmlNamespacePrefix, attribute, firstDescendant, parseXml } from "./5184.js";
 import { normalizePresentationChartDataLabelPosition, normalizePresentationChartDataLabels, normalizePresentationChartSeriesStyle } from "./0~work-presentation-charts.js";
 import { parseXlsxChartSeriesStyle, xlsxChartSeriesMarkerXml, parseXlsxTrendline, isSupportedXlsxChartLegend, isSupportedXlsxChartPlotLayout, isSupportedXlsxChartSeriesFormatting, parseXlsxChartPlotLayout, parseXlsxChartLegend, xlsxChartSeriesShapePropertiesXml, parseXlsxErrorBars } from "./4104.js";
+import { workSpreadsheetChartSupportsErrorBars, workSpreadsheetChartSupportsGrouping, normalizeWorkSpreadsheetChartSmoothLines, workSpreadsheetChartSupportsSeriesAnalysis, normalizeWorkSpreadsheetChartSeriesStyle, normalizeWorkSpreadsheetErrorBars, normalizeWorkSpreadsheetChartOverlap, workSpreadsheetChartUsesNumericXAxis, workSpreadsheetChartSupportsBarSpacing, normalizeWorkSpreadsheetChartLegendOverlay, normalizeWorkSpreadsheetChartGapWidth, normalizeWorkSpreadsheetChartGrouping, workSpreadsheetChartSupportsTrendlines, workSpreadsheetChartSupportsSmoothLines, normalizeWorkSpreadsheetTrendline } from "./8715.js";
 import { createWorkSlideTransition } from "./0~work-presentation-transition.js";
 const PRESENTATION_NAMESPACE = 'http://schemas.openxmlformats.org/presentationml/2006/main';
 const DRAWING_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/main';