@odoo/o-spreadsheet 18.0.55 → 18.0.68

package/dist/types/xlsx/constants.d.ts

@@ -0,0 +1,74 @@
+import { IconSetType } from "../components/icons/icons";
+import { ExcelIconSet } from "../types/xlsx";
+/** In XLSX color format (no #)  */
+export declare const AUTO_COLOR = "000000";
+export declare const XLSX_ICONSET_MAP: Record<IconSetType, ExcelIconSet>;
+export declare const NAMESPACE: {
+    styleSheet: string;
+    sst: string;
+    Relationships: string;
+    Types: string;
+    worksheet: string;
+    workbook: string;
+    drawing: string;
+    table: string;
+    revision: string;
+    revision3: string;
+    markupCompatibility: string;
+};
+export declare const DRAWING_NS_A = "http://schemas.openxmlformats.org/drawingml/2006/main";
+export declare const DRAWING_NS_C = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+export declare const CONTENT_TYPES: {
+    readonly workbook: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml";
+    readonly sheet: "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml";
+    readonly metadata: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml";
+    readonly sharedStrings: "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml";
+    readonly styles: "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml";
+    readonly drawing: "application/vnd.openxmlformats-officedocument.drawing+xml";
+    readonly chart: "application/vnd.openxmlformats-officedocument.drawingml.chart+xml";
+    readonly themes: "application/vnd.openxmlformats-officedocument.theme+xml";
+    readonly table: "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml";
+    readonly pivot: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml";
+    readonly externalLink: "application/vnd.openxmlformats-officedocument.spreadsheetml.externalLink+xml";
+};
+export declare const XLSX_RELATION_TYPE: {
+    readonly document: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+    readonly sheet: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet";
+    readonly metadata: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sheetMetadata";
+    readonly sharedStrings: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings";
+    readonly styles: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles";
+    readonly drawing: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing";
+    readonly chart: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
+    readonly theme: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";
+    readonly table: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/table";
+    readonly hyperlink: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+    readonly image: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+};
+export declare const ARRAY_FORMULA_URI = "bdbb8cdc-fa1e-496e-a857-3c3f30c029c3";
+export declare const RELATIONSHIP_NSR = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+export declare const HEIGHT_FACTOR = 0.75;
+/**
+ * Excel says its default column width is 8.43 characters (64px)
+ * which makes WIDTH_FACTOR = 0.1317, but it doesn't work well
+ * 0.143 is a value from dev's experiments.
+ */
+export declare const WIDTH_FACTOR = 0.143;
+/** unit : maximum number of characters a column can hold at the standard font size. What. */
+export declare const EXCEL_DEFAULT_COL_WIDTH = 8.43;
+/** unit : points */
+export declare const EXCEL_DEFAULT_ROW_HEIGHT = 12.75;
+export declare const EXCEL_IMPORT_DEFAULT_NUMBER_OF_COLS = 30;
+export declare const EXCEL_IMPORT_DEFAULT_NUMBER_OF_ROWS = 100;
+export declare const FIRST_NUMFMT_ID = 164;
+interface functionDefaultArg {
+    type: "NUMBER";
+    value: number;
+}
+export declare const FORCE_DEFAULT_ARGS_FUNCTIONS: Record<string, functionDefaultArg[]>;
+/**
+ * This list contains all "future" functions that are not compatible with older versions of Excel
+ * For more information, see https://docs.microsoft.com/en-us/openspecs/office_standards/ms-xlsx/5d1b6d44-6fc1-4ecd-8fef-0b27406cc2bf
+ */
+export declare const NON_RETROCOMPATIBLE_FUNCTIONS: string[];
+export declare const CONTENT_TYPES_FILE = "[Content_Types].xml";
+export {};

package/dist/types/xlsx/conversion/cf_conversion.d.ts

@@ -0,0 +1,4 @@
+import { ConditionalFormat } from "../../types";
+import { XLSXConditionalFormat, XLSXDxf } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+export declare function convertConditionalFormats(xlsxCfs: XLSXConditionalFormat[], dxfs: XLSXDxf[], warningManager: XLSXImportWarningManager): ConditionalFormat[];

package/dist/types/xlsx/conversion/color_conversion.d.ts

@@ -0,0 +1,31 @@
+import { Color } from "../../types";
+import { XLSXColor } from "../../types/xlsx";
+/**
+ * Most of the functions could stay private, but are exported for testing purposes
+ */
+/**
+ *
+ * Extract the color referenced inside of an XML element and return it as an hex string #RRGGBBAA (or #RRGGBB
+ * if alpha = FF)
+ *
+ *  The color is an attribute of the element that can be :
+ *  - rgb : an rgb string
+ *  - theme : a reference to a theme element
+ *  - auto : automatic coloring. Return const AUTO_COLOR in constants.ts.
+ *  - indexed : a legacy indexing scheme for colors. The only value that should be present in a xlsx is
+ *      64 = System Foreground, that we can replace with AUTO_COLOR.
+ */
+export declare function convertColor(xlsxColor: XLSXColor | undefined): Color | undefined;
+/**
+ * Convert a hex + alpha color string to an integer representation. Also remove the alpha.
+ *
+ * eg. #FF0000FF => 4278190335
+ */
+export declare function hexaToInt(hex: Color): number;
+/**
+ * When defining style (fontColor, borderColor for instance)
+ * Excel will specify rgb="FF000000"
+ * In that case, We should not consider this value as user-defined but
+ * rather like an instruction: "Use your system default"
+ */
+export declare const DEFAULT_SYSTEM_COLOR = "FF000000";

package/dist/types/xlsx/conversion/conversion_maps.d.ts

@@ -0,0 +1,186 @@
+import { IconSetType } from "../../components/icons/icons";
+import { Align, BorderStyle, ConditionalFormattingOperatorValues, ExcelChartType, ThresholdType, VerticalAlign } from "../../types";
+import { LegendPosition } from "../../types/chart/common_chart";
+import { ExcelIconSet, XLSXBorderStyle, XLSXCellType, XLSXCfOperatorType, XLSXCfType, XLSXCfValueObjectType, XLSXChartType, XLSXHorizontalAlignment } from "../../types/xlsx";
+import { XLSXVerticalAlignment } from "./../../types/xlsx";
+export declare const SUPPORTED_BORDER_STYLES: string[];
+export declare const SUPPORTED_HORIZONTAL_ALIGNMENTS: XLSXHorizontalAlignment[];
+export declare const SUPPORTED_VERTICAL_ALIGNMENTS: XLSXVerticalAlignment[];
+export declare const SUPPORTED_FONTS: string[];
+export declare const SUPPORTED_FILL_PATTERNS: string[];
+export declare const SUPPORTED_CF_TYPES: string[];
+/** Map between cell type in XLSX file and human readable cell type  */
+export declare const CELL_TYPE_CONVERSION_MAP: Record<string, XLSXCellType>;
+/** Conversion map Border Style in XLSX <=> Border style in o_spreadsheet*/
+export declare const BORDER_STYLE_CONVERSION_MAP: Record<XLSXBorderStyle, BorderStyle | undefined>;
+/** Conversion map Horizontal Alignment in XLSX <=> Horizontal Alignment in o_spreadsheet*/
+export declare const H_ALIGNMENT_CONVERSION_MAP: Record<XLSXHorizontalAlignment, Align>;
+/** Conversion map Vertical Alignment in XLSX => Vertical Alignment in o_spreadsheet */
+export declare const V_ALIGNMENT_CONVERSION_MAP: Record<XLSXVerticalAlignment, VerticalAlign>;
+/** Conversion map Vertical Alignment in o-spreadsheet => Vertical Alignment in XLSX */
+export declare const V_ALIGNMENT_EXPORT_CONVERSION_MAP: Record<Exclude<VerticalAlign, undefined>, XLSXVerticalAlignment>;
+/** Convert the "CellIs" cf operator.
+ * We have all the operators that the xlsx have, but ours begin with a uppercase character */
+export declare function convertCFCellIsOperator(xlsxCfOperator: XLSXCfOperatorType): ConditionalFormattingOperatorValues;
+/** Conversion map CF types in XLSX <=> Cf types in o_spreadsheet */
+export declare const CF_TYPE_CONVERSION_MAP: Record<XLSXCfType, ConditionalFormattingOperatorValues | undefined>;
+/** Conversion map CF thresholds types in XLSX <=> Cf thresholds types in o_spreadsheet */
+export declare const CF_THRESHOLD_CONVERSION_MAP: Record<XLSXCfValueObjectType, ThresholdType>;
+/**
+ * Conversion map between Excels IconSets and our own IconSets. The string is the key of the iconset in the ICON_SETS constant.
+ *
+ * NoIcons is undefined instead of an empty string because we don't support it and need to mange it separately.
+ */
+export declare const ICON_SET_CONVERSION_MAP: Record<ExcelIconSet, IconSetType | undefined>;
+/** Map between legend position in XLSX file and human readable position  */
+export declare const DRAWING_LEGEND_POSITION_CONVERSION_MAP: Record<string, LegendPosition>;
+/** Conversion map chart types in XLSX <=> Cf chart types o_spreadsheet (undefined for unsupported chart types)*/
+export declare const CHART_TYPE_CONVERSION_MAP: Record<XLSXChartType, ExcelChartType | undefined>;
+/** Conversion map for the SUBTOTAL(index, formula) function in xlsx, index <=> actual function*/
+export declare const SUBTOTAL_FUNCTION_CONVERSION_MAP: Record<number, string>;
+/** Mapping between Excel format indexes (see XLSX_FORMAT_MAP) and some supported formats  */
+export declare const XLSX_FORMATS_CONVERSION_MAP: Record<number, string | undefined>;
+/**
+ * Mapping format index to format defined by default
+ *
+ * OpenXML $18.8.30
+ * */
+export declare const XLSX_FORMAT_MAP: {
+    "0": number;
+    "0.00": number;
+    "#,#00": number;
+    "#,##0.00": number;
+    "0%": number;
+    "0.00%": number;
+    "0.00E+00": number;
+    "# ?/?": number;
+    "# ??/??": number;
+    "mm-dd-yy": number;
+    "d-mm-yy": number;
+    "mm-yy": number;
+    "mmm-yy": number;
+    "h:mm AM/PM": number;
+    "h:mm:ss AM/PM": number;
+    "h:mm": number;
+    "h:mm:ss": number;
+    "m/d/yy h:mm": number;
+    "#,##0 ;(#,##0)": number;
+    "#,##0 ;[Red](#,##0)": number;
+    "#,##0.00;(#,##0.00)": number;
+    "#,##0.00;[Red](#,##0.00)": number;
+    "mm:ss": number;
+    "[h]:mm:ss": number;
+    "mmss.0": number;
+    "##0.0E+0": number;
+    "@": number;
+    "hh:mm:ss a": number;
+};
+/** OpenXML $18.8.27 */
+export declare const XLSX_INDEXED_COLORS: {
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+    5: string;
+    6: string;
+    7: string;
+    8: string;
+    9: string;
+    10: string;
+    11: string;
+    12: string;
+    13: string;
+    14: string;
+    15: string;
+    16: string;
+    17: string;
+    18: string;
+    19: string;
+    20: string;
+    21: string;
+    22: string;
+    23: string;
+    24: string;
+    25: string;
+    26: string;
+    27: string;
+    28: string;
+    29: string;
+    30: string;
+    31: string;
+    32: string;
+    33: string;
+    34: string;
+    35: string;
+    36: string;
+    37: string;
+    38: string;
+    39: string;
+    40: string;
+    41: string;
+    42: string;
+    43: string;
+    44: string;
+    45: string;
+    46: string;
+    47: string;
+    48: string;
+    49: string;
+    50: string;
+    51: string;
+    52: string;
+    53: string;
+    54: string;
+    55: string;
+    56: string;
+    57: string;
+    58: string;
+    59: string;
+    60: string;
+    61: string;
+    62: string;
+    63: string;
+    64: string;
+    65: string;
+};
+export declare const IMAGE_MIMETYPE_TO_EXTENSION_MAPPING: {
+    "image/avif": string;
+    "image/bmp": string;
+    "image/gif": string;
+    "image/vnd.microsoft.icon": string;
+    "image/jpeg": string;
+    "image/png": string;
+    "image/tiff": string;
+    "image/webp": string;
+};
+export declare const IMAGE_EXTENSION_TO_MIMETYPE_MAPPING: {
+    avif: string;
+    bmp: string;
+    gif: string;
+    ico: string;
+    jpeg: string;
+    png: string;
+    tiff: string;
+    webp: string;
+    jpg: string;
+};
+export declare const XLSX_DV_DECIMAL_OPERATOR_MAPPING: {
+    readonly between: "isBetween";
+    readonly notBetween: "isNotBetween";
+    readonly equal: "isEqual";
+    readonly notEqual: "isNotEqual";
+    readonly greaterThan: "isGreaterThan";
+    readonly greaterThanOrEqual: "isGreaterOrEqualTo";
+    readonly lessThan: "isLessThan";
+    readonly lessThanOrEqual: "isLessOrEqualTo";
+};
+export declare const XLSX_DV_DATE_OPERATOR_TO_DV_TYPE_MAPPING: {
+    readonly between: "dateIsBetween";
+    readonly notBetween: "dateIsNotBetween";
+    readonly equal: "dateIs";
+    readonly greaterThan: "dateIsAfter";
+    readonly greaterThanOrEqual: "dateIsOnOrAfter";
+    readonly lessThan: "dateIsBefore";
+    readonly lessThanOrEqual: "dateIsOnOrBefore";
+};

package/dist/types/xlsx/conversion/data_validation_conversion.d.ts

@@ -0,0 +1,4 @@
+import { DataValidationRuleData } from "../../types";
+import { XLSXDataValidation } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+export declare function convertDataValidationRules(xlsxDataValidations: XLSXDataValidation[], warningManager: XLSXImportWarningManager): DataValidationRuleData[];

package/dist/types/xlsx/conversion/figure_conversion.d.ts

@@ -0,0 +1,3 @@
+import { FigureData } from "../../types";
+import { XLSXWorksheet } from "../../types/xlsx";
+export declare function convertFigures(sheetData: XLSXWorksheet): FigureData<any>[];

package/dist/types/xlsx/conversion/format_conversion.d.ts

@@ -0,0 +1,8 @@
+import { XLSXNumFormat } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+/**
+ * Convert excel format to o_spreadsheet format
+ *
+ * Excel format are defined in openXML §18.8.31
+ */
+export declare function convertXlsxFormat(numFmtId: number, formats: XLSXNumFormat[], warningManager: XLSXImportWarningManager): string | undefined;

package/dist/types/xlsx/conversion/formula_conversion.d.ts

@@ -0,0 +1,9 @@
+import { XLSXImportData, XLSXSharedFormula, XLSXWorksheet } from "../../types/xlsx";
+export declare function convertFormulasContent(sheet: XLSXWorksheet, data: XLSXImportData): void;
+/**
+ * Transform a shared formula for the given target.
+ *
+ * This will compute the offset between the original cell of the shared formula and the target cell,
+ * then apply this offset to all the ranges in the formula (taking fixed references into account)
+ */
+export declare function adaptFormula(targetCell: string, sf: XLSXSharedFormula): string;

package/dist/types/xlsx/conversion/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./cf_conversion";
+export * from "./color_conversion";
+export * from "./conversion_maps";
+export * from "./figure_conversion";
+export * from "./sheet_conversion";
+export * from "./style_conversion";
+export * from "./table_conversion";

package/dist/types/xlsx/conversion/sheet_conversion.d.ts

@@ -0,0 +1,4 @@
+import { SheetData } from "../../types";
+import { XLSXImportData } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+export declare function convertSheets(data: XLSXImportData, warningManager: XLSXImportWarningManager): SheetData[];

package/dist/types/xlsx/conversion/style_conversion.d.ts

@@ -0,0 +1,19 @@
+import { Border, Style } from "../../types";
+import { XLSXCellAlignment, XLSXFill, XLSXFont, XLSXImportData } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+interface StyleStruct {
+    fontStyle?: XLSXFont;
+    fillStyle?: XLSXFill;
+    alignment?: XLSXCellAlignment;
+}
+export declare function convertBorders(data: XLSXImportData, warningManager: XLSXImportWarningManager): {
+    [key: number]: Border;
+};
+export declare function convertStyles(data: XLSXImportData, warningManager: XLSXImportWarningManager): {
+    [key: number]: Style;
+};
+export declare function convertStyle(styleStruct: StyleStruct, warningManager: XLSXImportWarningManager): Style;
+export declare function convertFormats(data: XLSXImportData, warningManager: XLSXImportWarningManager): {
+    [key: number]: string;
+};
+export {};

package/dist/types/xlsx/conversion/table_conversion.d.ts

@@ -0,0 +1,8 @@
+import { WorkbookData } from "../../types";
+import { XLSXImportData } from "../../types/xlsx";
+/**
+ * Convert the imported XLSX tables and pivots convert the table-specific formula references into standard references.
+ *
+ * Change the converted data in-place.
+ */
+export declare function convertTables(convertedData: WorkbookData, xlsxData: XLSXImportData): void;

package/dist/types/xlsx/extraction/base_extractor.d.ts

@@ -0,0 +1,142 @@
+import { XLSXColor, XLSXFileStructure, XLSXImportFile, XLSXRel, XLSXTheme, XMLFile } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+import { XLSXImageFile } from "./../../types/xlsx";
+interface MapOnElementArgs {
+    query: string;
+    parent: Element | XMLDocument;
+    children?: boolean;
+}
+interface ExtractArg {
+    required?: boolean;
+    default?: string | boolean | number;
+}
+declare class AttributeValue {
+    private readonly value;
+    constructor(value: string | boolean | number);
+    asString(): string;
+    asBool(): boolean;
+    asNum(): number;
+}
+type ExtractAttrType<T> = T extends {
+    required: true;
+} | {
+    default: string | number | boolean;
+} ? AttributeValue : AttributeValue | undefined;
+type ExtractTextType<T> = T extends {
+    required: true;
+} | {
+    default: string | number | boolean;
+} ? string : string | undefined;
+export declare class XlsxBaseExtractor {
+    protected rootFile: XLSXImportFile;
+    protected xlsxFileStructure: XLSXFileStructure;
+    protected warningManager: XLSXImportWarningManager;
+    protected relationships: Record<string, XLSXRel>;
+    protected currentFile: string | undefined;
+    /**
+     * /!\ Important : There should be no namespaces in the tags of the XML files.
+     *
+     * This class use native querySelector and querySelectorAll, that's used for HTML (not XML). These aren't supposed to
+     * handled namespaces, as they are not supported by the HTML specification. Some implementations (most browsers) do
+     * actually support namespaces, but some don't (e.g. jsdom).
+     *
+     * The namespace should be escaped as with NAMESPACE string (eg. <t:foo> => <NAMESPACEtNAMESPACEfoo>).
+     */
+    constructor(rootFile: XLSXImportFile, xlsxStructure: XLSXFileStructure, warningManager: XLSXImportWarningManager);
+    /**
+     * Extract all the relationships inside a .xml.rels file
+     */
+    protected extractRelationships(relFile: XMLFile): XLSXRel[];
+    /**
+     * Get the list of all the XLSX files in the XLSX file structure
+     */
+    protected getListOfXMLFiles(): XLSXImportFile[];
+    /**
+     * Return an array containing the return value of the given function applied to all the XML elements
+     * found using the MapOnElementArgs.
+     *
+     * The arguments contains :
+     *  - query : a QuerySelector string to find the elements to apply the function to
+     *  - parent : an XML element or XML document in which to find the queried elements
+     *  - children : if true, the function is applied on the direct children of the queried element
+     *
+     * This method will also handle the errors thrown in the argument function.
+     */
+    protected mapOnElements<T>(args: MapOnElementArgs, fct: (e: Element) => T): T[];
+    /**
+     * Log an error caught when parsing an element in the warningManager.
+     */
+    protected catchErrorOnElement(error: Error, onElement?: Element): void;
+    /**
+     * Extract an attribute from an Element.
+     *
+     * If the attribute is required but was not found, will add a warning in the warningManager if it was given a default
+     * value, and throw an error if no default value was given.
+     *
+     * Can only return undefined value for non-required attributes without default value.
+     */
+    protected extractAttr<T extends ExtractArg>(e: Element, attName: string, optionalArgs?: T): ExtractAttrType<T>;
+    /**
+     * Extract the text content of an Element.
+     *
+     * If the text content is required but was not found, will add a warning in the warningManager if it was given a default
+     * value, and throw an error if no default value was given.
+     *
+     * Can only return undefined value for non-required text content without default value.
+     */
+    protected extractTextContent<T extends ExtractArg>(element: Element, optionalArgs?: T): ExtractTextType<T>;
+    /**
+     * Extract an attribute of a child of the given element.
+     *
+     * The reference of a child can be a string (tag of the child) or an number (index in the list of children of the element)
+     *
+     * If the attribute is required but either the attribute or the referenced child element was not found, it will
+     * will add a warning in the warningManager if it was given a default value, and throw an error if no default value was given.
+     *
+     * Can only return undefined value for non-required attributes without default value.
+     */
+    protected extractChildAttr<T extends ExtractArg>(e: Element, childRef: string | number, attName: string, optionalArgs?: T): ExtractAttrType<T>;
+    /**
+     * Extract the text content of a child of the given element.
+     *
+     * If the text content is required but either the text content or the referenced child element was not found, it will
+     * will add a warning in the warningManager if it was given a default value, and throw an error if no default value was given.
+     *
+     * Can only return undefined value for non-required text content without default value.
+     */
+    protected extractChildTextContent<T extends ExtractArg>(e: Element, childRef: string, optionalArgs?: T): ExtractTextType<T>;
+    /**
+     * Should be called if a extractAttr/extractTextContent doesn't find the element it needs to extract.
+     *
+     * If the extractable was required, this function will add a warning in the warningManager if there was a default value,
+     * and throw an error if no default value was given.
+     */
+    private handleMissingValue;
+    /**
+     * Extract a color, extracting it from the theme if needed.
+     *
+     * Will throw an error if the element references a theme, but no theme was provided or the theme it doesn't contain the color.
+     */
+    protected extractColor<T extends string | undefined>(colorElement: Element | null, theme: XLSXTheme | undefined, defaultColor?: T): T extends string ? XLSXColor : XLSXColor | undefined;
+    /**
+     * Returns the xml file targeted by a relationship.
+     */
+    protected getTargetXmlFile(relationship: XLSXRel): XLSXImportFile;
+    /**
+     * Returns the image parameters targeted by a relationship.
+     */
+    protected getTargetImageFile(relationship: XLSXRel): XLSXImageFile;
+    protected querySelector(element: Element | Document, query: string): Element | null;
+    protected querySelectorAll(element: Element | Document, query: string): NodeListOf<Element>;
+    /**
+     * Get a color from its id in the Theme's colorScheme.
+     *
+     * Note that Excel don't use the colors from the theme but from its own internal theme, so the displayed
+     * colors will be different in the import than in excel.
+     * .
+     */
+    private getThemeColor;
+    /** Remove signs of relative path. */
+    private processRelationshipTargetName;
+}
+export {};

package/dist/types/xlsx/extraction/cf_extractor.d.ts

@@ -0,0 +1,14 @@
+import { XLSXConditionalFormat, XLSXFileStructure, XLSXImportFile, XLSXTheme } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+import { XlsxBaseExtractor } from "./base_extractor";
+export declare class XlsxCfExtractor extends XlsxBaseExtractor {
+    theme?: XLSXTheme;
+    constructor(sheetFile: XLSXImportFile, xlsxStructure: XLSXFileStructure, warningManager: XLSXImportWarningManager, theme: XLSXTheme | undefined);
+    extractConditionalFormattings(): XLSXConditionalFormat[];
+    private extractCFRules;
+    private extractCfFormula;
+    private extractCfColorScale;
+    private extractCfIconSet;
+    private extractCfIcons;
+    private extractCFVos;
+}

package/dist/types/xlsx/extraction/chart_extractor.d.ts

@@ -0,0 +1,14 @@
+import { ExcelChartDefinition } from "../../types";
+import { XlsxBaseExtractor } from "./base_extractor";
+export declare class XlsxChartExtractor extends XlsxBaseExtractor {
+    extractChart(): ExcelChartDefinition | undefined;
+    private extractLabelRange;
+    private extractComboChart;
+    private extractChartDatasets;
+    private extractScatterChartDatasets;
+    /**
+     * The chart type in the XML isn't explicitly defined, but there is an XML element that define the
+     * chart, and this element tag name tells us which type of chart it is. We just need to find this XML element.
+     */
+    private getChartType;
+}

package/dist/types/xlsx/extraction/data_validation_extractor.d.ts

@@ -0,0 +1,9 @@
+import { XLSXDataValidation, XLSXFileStructure, XLSXImportFile, XLSXTheme } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+import { XlsxBaseExtractor } from "./base_extractor";
+export declare class XlsxDataValidationExtractor extends XlsxBaseExtractor {
+    theme?: XLSXTheme;
+    constructor(sheetFile: XLSXImportFile, xlsxStructure: XLSXFileStructure, warningManager: XLSXImportWarningManager, theme: XLSXTheme | undefined);
+    extractDataValidations(): XLSXDataValidation[];
+    private extractDataValidationFormula;
+}

package/dist/types/xlsx/extraction/external_book_extractor.d.ts

@@ -0,0 +1,6 @@
+import { XLSXExternalBook } from "../../types/xlsx";
+import { XlsxBaseExtractor } from "./base_extractor";
+export declare class XlsxExternalBookExtractor extends XlsxBaseExtractor {
+    getExternalBook(): XLSXExternalBook;
+    private extractExternalSheetData;
+}

package/dist/types/xlsx/extraction/figure_extractor.d.ts

@@ -0,0 +1,10 @@
+import { XLSXFigure } from "../../types/xlsx";
+import { XlsxBaseExtractor } from "./base_extractor";
+export declare class XlsxFigureExtractor extends XlsxBaseExtractor {
+    extractFigures(): XLSXFigure[];
+    private extractFigureAnchorsByType;
+    private extractFigureSizeFromSizeTag;
+    private extractFigureAnchor;
+    private extractChart;
+    private extractImage;
+}

package/dist/types/xlsx/extraction/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./misc_extractor";
+export * from "./sheet_extractor";
+export * from "./style_extractor";

package/dist/types/xlsx/extraction/misc_extractor.d.ts

@@ -0,0 +1,18 @@
+import { XLSXTheme } from "../../types/xlsx";
+import { XlsxBaseExtractor } from "./base_extractor";
+/**
+ * XLSX Extractor class that can be used for either sharedString XML files or theme XML files.
+ *
+ * Since they both are quite simple, it make sense to make a single class to manage them all, to avoid unnecessary file
+ * cluttering.
+ */
+export declare class XlsxMiscExtractor extends XlsxBaseExtractor {
+    getTheme(): XLSXTheme;
+    /**
+     * Get the array of shared strings of the XLSX.
+     *
+     * Worth noting that running a prettier on the xml can mess up some strings, since there is an option in the
+     * xmls to keep the spacing and not trim the string.
+     */
+    getSharedStrings(): string[];
+}

package/dist/types/xlsx/extraction/pivot_extractor.d.ts

@@ -0,0 +1,10 @@
+import { XLSXPivotTable } from "../../types/xlsx";
+import { XlsxBaseExtractor } from "./base_extractor";
+/**
+ * We don't really support pivot tables, we'll just extract them as Tables.
+ */
+export declare class XlsxPivotExtractor extends XlsxBaseExtractor {
+    getPivotTable(): XLSXPivotTable;
+    private extractPivotLocation;
+    private extractPivotStyleInfo;
+}

package/dist/types/xlsx/extraction/sheet_extractor.d.ts

@@ -0,0 +1,26 @@
+import { XLSXFileStructure, XLSXImportFile, XLSXTheme, XLSXWorksheet } from "../../types/xlsx";
+import { XLSXImportWarningManager } from "../helpers/xlsx_parser_error_manager";
+import { XlsxBaseExtractor } from "./base_extractor";
+export declare class XlsxSheetExtractor extends XlsxBaseExtractor {
+    theme?: XLSXTheme;
+    constructor(sheetFile: XLSXImportFile, xlsxStructure: XLSXFileStructure, warningManager: XLSXImportWarningManager, theme: XLSXTheme | undefined);
+    getSheet(): XLSXWorksheet;
+    private extractSheetViews;
+    private extractSheetName;
+    private getSheetWorkbookInfo;
+    private extractConditionalFormats;
+    private extractDataValidations;
+    private extractFigures;
+    private extractTables;
+    private extractPivotTables;
+    private extractMerges;
+    private extractSheetFormat;
+    private extractSheetProperties;
+    private extractSheetOutlineProperties;
+    private extractCols;
+    private extractRows;
+    private extractCells;
+    private extractCellFormula;
+    private extractHyperLinks;
+    private extractSharedFormulas;
+}