@cj-tech-master/excelts 4.2.3 → 5.0.0-canary.20260123012457.1fdf506

package/dist/cjs/modules/excel/xlsx/xlsx.browser.js

@@ -37,6 +37,7 @@ const stream_1 = require("../../archive/zip/stream.js");
 const zip_parser_1 = require("../../archive/unzip/zip-parser.js");
 const _stream_1 = require("../../stream/index.js");
 const ooxml_paths_1 = require("../utils/ooxml-paths.js");
+const passthrough_manager_1 = require("../utils/passthrough-manager.js");
 class StreamingZipWriterAdapter {
     constructor(options) {
         this.events = new Map();
@@ -204,6 +205,7 @@ class XLSX {
         this.addDrawings(zip, model);
         this.addTables(zip, model);
         this.addPivotTables(zip, model);
+        this.addPassthrough(zip, model);
         await Promise.all([this.addThemes(zip, model), this.addStyles(zip, model)]);
         await this.addFeaturePropertyBag(zip, model);
         await this.addMedia(zip, model);
@@ -303,8 +305,12 @@ class XLSX {
      * This is the foundation for TRUE streaming reads on platforms that have a
      * streaming ZIP parser (e.g. Node.js `modules/archive` Parse).
      */
-    async loadFromZipEntries(entries, options) {
-        const model = {
+    /**
+     * Create an empty model for parsing XLSX files.
+     * Shared by loadFromZipEntries and loadFromFiles.
+     */
+    createEmptyModel() {
+        return {
             worksheets: [],
             worksheetHash: {},
             worksheetRels: [],
@@ -313,6 +319,8 @@ class XLSX {
             mediaIndex: {},
             drawings: {},
             drawingRels: {},
+            // Raw drawing XML data for passthrough (when drawing contains chart references)
+            rawDrawings: {},
             comments: {},
             tables: {},
             vmlDrawings: {},
@@ -320,8 +328,104 @@ class XLSX {
             pivotTableRels: {},
             pivotCacheDefinitions: {},
             pivotCacheDefinitionRels: {},
-            pivotCacheRecords: {}
+            pivotCacheRecords: {},
+            // Passthrough storage for unknown/unsupported files (charts, etc.)
+            passthrough: {}
         };
+    }
+    /**
+     * Collect all data from a stream into a single Uint8Array.
+     * Reusable helper for passthrough and drawing processing.
+     */
+    async collectStreamData(stream) {
+        const chunks = [];
+        await new Promise((resolve, reject) => {
+            stream.on("data", (chunk) => {
+                if (typeof chunk === "string") {
+                    chunks.push(new TextEncoder().encode(chunk));
+                }
+                else if (chunk instanceof Uint8Array) {
+                    chunks.push(chunk);
+                }
+                else {
+                    chunks.push(new Uint8Array(chunk));
+                }
+            });
+            stream.on("end", () => resolve());
+            stream.on("error", reject);
+        });
+        return (0, _stream_1.concatUint8Arrays)(chunks);
+    }
+    /**
+     * Check if a drawing has chart references in its relationships
+     */
+    drawingHasChartReference(drawing) {
+        return (drawing.rels && drawing.rels.some((rel) => rel.Target && rel.Target.includes("/charts/")));
+    }
+    /**
+     * Check if a drawing rels list references charts.
+     * Used to decide whether we need to keep raw drawing XML for passthrough.
+     */
+    drawingRelsHasChartReference(drawingRels) {
+        return (Array.isArray(drawingRels) &&
+            drawingRels.some(rel => typeof rel?.Target === "string" && rel.Target.includes("/charts/")));
+    }
+    /**
+     * Process a known OOXML entry (workbook, styles, shared strings, etc.)
+     * Returns true if handled, false if should be passed to _processDefaultEntry
+     */
+    async _processKnownEntry(stream, model, entryName, options) {
+        const sheetNo = (0, ooxml_paths_1.getWorksheetNoFromWorksheetPath)(entryName);
+        if (sheetNo !== undefined) {
+            await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
+            return true;
+        }
+        switch (entryName) {
+            case ooxml_paths_1.OOXML_PATHS.rootRels:
+                model.globalRels = await this.parseRels(stream);
+                return true;
+            case ooxml_paths_1.OOXML_PATHS.xlWorkbook: {
+                const workbook = await this.parseWorkbook(stream);
+                model.sheets = workbook.sheets;
+                model.definedNames = workbook.definedNames;
+                model.views = workbook.views;
+                model.properties = workbook.properties;
+                model.calcProperties = workbook.calcProperties;
+                model.pivotCaches = workbook.pivotCaches;
+                return true;
+            }
+            case ooxml_paths_1.OOXML_PATHS.xlSharedStrings:
+                model.sharedStrings = new shared_strings_xform_1.SharedStringsXform();
+                await model.sharedStrings.parseStream(stream);
+                return true;
+            case ooxml_paths_1.OOXML_PATHS.xlWorkbookRels:
+                model.workbookRels = await this.parseRels(stream);
+                return true;
+            case ooxml_paths_1.OOXML_PATHS.docPropsApp: {
+                const appXform = new app_xform_1.AppXform();
+                const appProperties = await appXform.parseStream(stream);
+                if (appProperties) {
+                    model.company = appProperties.company;
+                    model.manager = appProperties.manager;
+                }
+                return true;
+            }
+            case ooxml_paths_1.OOXML_PATHS.docPropsCore: {
+                const coreXform = new core_xform_1.CoreXform();
+                const coreProperties = await coreXform.parseStream(stream);
+                Object.assign(model, coreProperties);
+                return true;
+            }
+            case ooxml_paths_1.OOXML_PATHS.xlStyles:
+                model.styles = new styles_xform_1.StylesXform();
+                await model.styles.parseStream(stream);
+                return true;
+            default:
+                return false;
+        }
+    }
+    async loadFromZipEntries(entries, options) {
+        const model = this.createEmptyModel();
         for await (const entry of entries) {
             let drained = false;
             const drainEntry = async () => {
@@ -338,58 +442,12 @@ class XLSX {
             const entryName = (0, ooxml_paths_1.normalizeZipPath)(entry.name);
             const stream = entry.stream;
             try {
-                const sheetNo = (0, ooxml_paths_1.getWorksheetNoFromWorksheetPath)(entryName);
-                if (sheetNo !== undefined) {
-                    await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
-                    continue;
-                }
-                switch (entryName) {
-                    case ooxml_paths_1.OOXML_PATHS.rootRels:
-                        model.globalRels = await this.parseRels(stream);
-                        break;
-                    case ooxml_paths_1.OOXML_PATHS.xlWorkbook: {
-                        const workbook = await this.parseWorkbook(stream);
-                        model.sheets = workbook.sheets;
-                        model.definedNames = workbook.definedNames;
-                        model.views = workbook.views;
-                        model.properties = workbook.properties;
-                        model.calcProperties = workbook.calcProperties;
-                        model.pivotCaches = workbook.pivotCaches;
-                        break;
-                    }
-                    case ooxml_paths_1.OOXML_PATHS.xlSharedStrings:
-                        model.sharedStrings = new shared_strings_xform_1.SharedStringsXform();
-                        await model.sharedStrings.parseStream(stream);
-                        break;
-                    case ooxml_paths_1.OOXML_PATHS.xlWorkbookRels:
-                        model.workbookRels = await this.parseRels(stream);
-                        break;
-                    case ooxml_paths_1.OOXML_PATHS.docPropsApp: {
-                        const appXform = new app_xform_1.AppXform();
-                        const appProperties = await appXform.parseStream(stream);
-                        if (appProperties) {
-                            model.company = appProperties.company;
-                            model.manager = appProperties.manager;
-                        }
-                        break;
-                    }
-                    case ooxml_paths_1.OOXML_PATHS.docPropsCore: {
-                        const coreXform = new core_xform_1.CoreXform();
-                        const coreProperties = await coreXform.parseStream(stream);
-                        Object.assign(model, coreProperties);
-                        break;
-                    }
-                    case ooxml_paths_1.OOXML_PATHS.xlStyles:
-                        model.styles = new styles_xform_1.StylesXform();
-                        await model.styles.parseStream(stream);
-                        break;
-                    default: {
-                        const handled = await this._processDefaultEntry(stream, model, entryName);
-                        if (!handled) {
-                            // Important for true streaming parsers: always consume unknown entries
-                            await drainEntry();
-                        }
-                        break;
+                const handled = await this._processKnownEntry(stream, model, entryName, options);
+                if (!handled) {
+                    const defaultHandled = await this._processDefaultEntry(stream, model, entryName);
+                    if (!defaultHandled) {
+                        // Important for true streaming parsers: always consume unknown entries
+                        await drainEntry();
                     }
                 }
             }
@@ -503,6 +561,15 @@ class XLSX {
                 drawingXform.reconcile(drawing, drawingOptions);
             }
         });
+        // Trim raw drawings for non-chart drawings to avoid bloating the serialized workbook model.
+        if (model.rawDrawings && model.drawingRels) {
+            for (const name of Object.keys(model.rawDrawings)) {
+                const drawingRel = model.drawingRels[name];
+                if (drawingRel && !this.drawingRelsHasChartReference(drawingRel)) {
+                    delete model.rawDrawings[name];
+                }
+            }
+        }
         // reconcile tables with the default styles
         const tableOptions = {
             styles: model.styles
@@ -519,6 +586,7 @@ class XLSX {
             mediaIndex: model.mediaIndex,
             date1904: model.properties && model.properties.date1904,
             drawings: model.drawings,
+            drawingRels: model.drawingRels,
             comments: model.comments,
             tables: model.tables,
             vmlDrawings: model.vmlDrawings,
@@ -535,6 +603,8 @@ class XLSX {
         delete model.sharedStrings;
         delete model.workbookRels;
         delete model.sheetDefs;
+        // Preserve default font before deleting styles
+        model.defaultFont = model.styles?.defaultFont;
         delete model.styles;
         delete model.mediaIndex;
         delete model.drawings;
@@ -695,9 +765,15 @@ class XLSX {
         }
     }
     async _processDrawingEntry(entry, model, name) {
+        // Collect raw data first so we can preserve drawings that reference charts.
+        const rawData = await this.collectStreamData(entry);
+        // Parse the drawing for normal processing (images, etc.)
         const xform = new drawing_xform_1.DrawingXform();
-        const drawing = await xform.parseStream(entry);
+        const xmlString = this.bufferToString(rawData);
+        const drawing = await xform.parseStream(this.createTextStream(xmlString));
         model.drawings[name] = drawing;
+        // Store raw data; reconcile() may later drop it if charts are not referenced.
+        model.rawDrawings[name] = rawData;
     }
     async _processDrawingRelsEntry(entry, model, name) {
         const xform = new relationships_xform_1.RelationshipsXform();
@@ -772,24 +848,7 @@ class XLSX {
     // loadFromFiles - shared logic for loading from pre-extracted ZIP data
     // ===========================================================================
     async loadFromFiles(zipData, options) {
-        const model = {
-            worksheets: [],
-            worksheetHash: {},
-            worksheetRels: [],
-            themes: {},
-            media: [],
-            mediaIndex: {},
-            drawings: {},
-            drawingRels: {},
-            comments: {},
-            tables: {},
-            vmlDrawings: {},
-            pivotTables: {},
-            pivotTableRels: {},
-            pivotCacheDefinitions: {},
-            pivotCacheDefinitionRels: {},
-            pivotCacheRecords: {}
-        };
+        const model = this.createEmptyModel();
         const entries = Object.keys(zipData).map(name => ({
             name,
             dir: name.endsWith("/"),
@@ -803,54 +862,10 @@ class XLSX {
                 const stream = isBinaryEntry
                     ? this.createBinaryStream(entry.data)
                     : this.createTextStream(this.bufferToString(entry.data));
-                const sheetNo = (0, ooxml_paths_1.getWorksheetNoFromWorksheetPath)(entryName);
-                if (sheetNo !== undefined) {
-                    await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
-                }
-                else {
-                    switch (entryName) {
-                        case ooxml_paths_1.OOXML_PATHS.rootRels:
-                            model.globalRels = await this.parseRels(stream);
-                            break;
-                        case ooxml_paths_1.OOXML_PATHS.xlWorkbook: {
-                            const workbook = await this.parseWorkbook(stream);
-                            model.sheets = workbook.sheets;
-                            model.definedNames = workbook.definedNames;
-                            model.views = workbook.views;
-                            model.properties = workbook.properties;
-                            model.calcProperties = workbook.calcProperties;
-                            model.pivotCaches = workbook.pivotCaches;
-                            break;
-                        }
-                        case ooxml_paths_1.OOXML_PATHS.xlSharedStrings:
-                            model.sharedStrings = new shared_strings_xform_1.SharedStringsXform();
-                            await model.sharedStrings.parseStream(stream);
-                            break;
-                        case ooxml_paths_1.OOXML_PATHS.xlWorkbookRels:
-                            model.workbookRels = await this.parseRels(stream);
-                            break;
-                        case ooxml_paths_1.OOXML_PATHS.docPropsApp: {
-                            const appXform = new app_xform_1.AppXform();
-                            const appProperties = await appXform.parseStream(stream);
-                            if (appProperties) {
-                                model.company = appProperties.company;
-                                model.manager = appProperties.manager;
-                            }
-                            break;
-                        }
-                        case ooxml_paths_1.OOXML_PATHS.docPropsCore: {
-                            const coreXform = new core_xform_1.CoreXform();
-                            const coreProperties = await coreXform.parseStream(stream);
-                            Object.assign(model, coreProperties);
-                            break;
-                        }
-                        case ooxml_paths_1.OOXML_PATHS.xlStyles:
-                            model.styles = new styles_xform_1.StylesXform();
-                            await model.styles.parseStream(stream);
-                            break;
-                        default:
-                            await this._processDefaultEntry(stream, model, entryName);
-                    }
+                const handled = await this._processKnownEntry(stream, model, entryName, options);
+                if (!handled) {
+                    // Pass raw entry data for drawings to enable passthrough
+                    await this._processDefaultEntry(stream, model, entryName, entry.data);
                 }
             }
         }
@@ -860,11 +875,11 @@ class XLSX {
     }
     /**
      * Process default entries (drawings, comments, tables, etc.)
+     * @param rawData Optional raw entry data for passthrough preservation (used by loadFromFiles)
      */
-    async _processDefaultEntry(stream, model, entryName) {
-        const worksheetRelsSheetNo = (0, ooxml_paths_1.getWorksheetNoFromWorksheetRelsPath)(entryName);
-        if (worksheetRelsSheetNo !== undefined) {
-            const sheetNo = worksheetRelsSheetNo;
+    async _processDefaultEntry(stream, model, entryName, rawData) {
+        const sheetNo = (0, ooxml_paths_1.getWorksheetNoFromWorksheetRelsPath)(entryName);
+        if (sheetNo !== undefined) {
             await this._processWorksheetRelsEntry(stream, model, sheetNo);
             return true;
         }
@@ -876,6 +891,10 @@ class XLSX {
         const drawingName = (0, ooxml_paths_1.getDrawingNameFromPath)(entryName);
         if (drawingName) {
             await this._processDrawingEntry(stream, model, drawingName);
+            // For loadFromFiles path, store raw data for passthrough (drawings with charts)
+            if (rawData) {
+                model.rawDrawings[drawingName] = rawData;
+            }
             return true;
         }
         const drawingRelsName = (0, ooxml_paths_1.getDrawingNameFromRelsPath)(entryName);
@@ -930,8 +949,27 @@ class XLSX {
             await this._processPivotCacheRecordsEntry(stream, model, pivotCacheRecordsName);
             return true;
         }
+        // Store passthrough files (charts, etc.) for preservation
+        if (passthrough_manager_1.PassthroughManager.isPassthroughPath(entryName)) {
+            // If raw data is available (loadFromFiles path), use it directly
+            if (rawData) {
+                model.passthrough[entryName] = rawData;
+            }
+            else {
+                await this._processPassthroughEntry(stream, model, entryName);
+            }
+            return true;
+        }
         return false;
     }
+    /**
+     * Store a passthrough file for preservation during read/write cycles.
+     * These files are not parsed but stored as raw bytes to be written back unchanged.
+     */
+    async _processPassthroughEntry(stream, model, entryName) {
+        const data = await this.collectStreamData(stream);
+        model.passthrough[entryName] = data;
+    }
     // ===========================================================================
     // Write methods - shared by all platforms
     // ===========================================================================
@@ -1074,14 +1112,46 @@ class XLSX {
     addDrawings(zip, model) {
         const drawingXform = new drawing_xform_1.DrawingXform();
         const relsXform = new relationships_xform_1.RelationshipsXform();
+        const rawDrawings = model.rawDrawings || {};
         model.worksheets.forEach((worksheet) => {
             const { drawing } = worksheet;
             if (drawing) {
-                drawingXform.prepare(drawing);
-                let xml = drawingXform.toXml(drawing);
-                zip.append(xml, { name: (0, ooxml_paths_1.drawingPath)(drawing.name) });
-                xml = relsXform.toXml(drawing.rels);
-                zip.append(xml, { name: (0, ooxml_paths_1.drawingRelsPath)(drawing.name) });
+                // Check if drawing rels contain chart references using helper
+                const hasChartReference = this.drawingHasChartReference(drawing);
+                if (hasChartReference && rawDrawings[drawing.name]) {
+                    // Use raw data for drawings with chart references (passthrough)
+                    zip.append(rawDrawings[drawing.name], { name: (0, ooxml_paths_1.drawingPath)(drawing.name) });
+                }
+                else {
+                    // Use regenerated XML for normal drawings (images, shapes)
+                    // Filter out invalid anchors (null, undefined, or missing content)
+                    const filteredAnchors = (drawing.anchors || []).filter((a) => {
+                        if (a == null) {
+                            return false;
+                        }
+                        // Form controls have range.br and shape properties
+                        if (a.range?.br && a.shape) {
+                            return true;
+                        }
+                        // One-cell anchors need a valid picture
+                        if (!a.br && !a.picture) {
+                            return false;
+                        }
+                        // Two-cell anchors need either picture or shape
+                        if (a.br && !a.picture && !a.shape) {
+                            return false;
+                        }
+                        return true;
+                    });
+                    const drawingForWrite = drawing.anchors
+                        ? { ...drawing, anchors: filteredAnchors }
+                        : drawing;
+                    drawingXform.prepare(drawingForWrite);
+                    const xml = drawingXform.toXml(drawingForWrite);
+                    zip.append(xml, { name: (0, ooxml_paths_1.drawingPath)(drawing.name) });
+                }
+                const relsXml = relsXform.toXml(drawing.rels);
+                zip.append(relsXml, { name: (0, ooxml_paths_1.drawingRelsPath)(drawing.name) });
             }
         });
     }
@@ -1096,6 +1166,15 @@ class XLSX {
             });
         });
     }
+    /**
+     * Write passthrough files (charts, etc.) that were preserved during read.
+     * These files are written back unchanged to preserve unsupported features.
+     */
+    addPassthrough(zip, model) {
+        const passthroughManager = new passthrough_manager_1.PassthroughManager();
+        passthroughManager.fromRecord(model.passthrough || {});
+        passthroughManager.writeToZip(zip);
+    }
     addPivotTables(zip, model) {
         if (!model.pivotTables.length) {
             return;
@@ -1161,7 +1240,12 @@ class XLSX {
             options.useSharedStrings !== undefined ? options.useSharedStrings : true;
         model.useStyles = options.useStyles !== undefined ? options.useStyles : true;
         model.sharedStrings = new shared_strings_xform_1.SharedStringsXform();
+        // Preserve default font from parsed styles if available
+        const oldDefaultFont = model.defaultFont;
         model.styles = model.useStyles ? new styles_xform_1.StylesXform(true) : new styles_xform_1.StylesXform.Mock();
+        if (oldDefaultFont && model.styles.setDefaultFont) {
+            model.styles.setDefaultFont(oldDefaultFont);
+        }
         const workbookXform = new workbook_xform_1.WorkbookXform();
         const worksheetXform = new worksheet_xform_1.WorkSheetXform();
         workbookXform.prepare(model);
@@ -1188,6 +1272,11 @@ class XLSX {
         });
         // ContentTypesXform expects this flag
         model.hasCheckboxes = model.styles.hasCheckboxes;
+        // Build passthroughContentTypes for ContentTypesXform using PassthroughManager
+        const passthrough = model.passthrough || {};
+        const passthroughManager = new passthrough_manager_1.PassthroughManager();
+        passthroughManager.fromRecord(passthrough);
+        model.passthroughContentTypes = passthroughManager.getContentTypes();
     }
 }
 exports.XLSX = XLSX;

package/dist/cjs/modules/stream/streams.browser.js

@@ -890,9 +890,6 @@ class Readable extends event_emitter_1.EventEmitter {
                     yield chunk;
                 }
             }
-            if (streamError) {
-                throw streamError;
-            }
         }
         finally {
             this.off("data", dataHandler);

package/dist/esm/modules/csv/csv.browser.js

@@ -112,7 +112,7 @@ class CSV {
         const dateFormats = options?.dateFormats ?? DEFAULT_DATE_FORMATS;
         const map = options?.map ||
             createDefaultValueMapper(dateFormats, {
-                decimalSeparator: options?.valueMapperOptions?.decimalSeparator ?? options?.parserOptions?.decimalSeparator
+                decimalSeparator: options?.valueMapperOptions?.decimalSeparator
             });
         const rows = parseCsv(str, options?.parserOptions);
         for (const row of rows) {
@@ -154,7 +154,7 @@ class CSV {
         const dateFormats = options?.dateFormats ?? DEFAULT_DATE_FORMATS;
         const map = options?.map ||
             createDefaultValueMapper(dateFormats, {
-                decimalSeparator: options?.valueMapperOptions?.decimalSeparator ?? options?.parserOptions?.decimalSeparator
+                decimalSeparator: options?.valueMapperOptions?.decimalSeparator
             });
         const parser = new CsvParserStream(options?.parserOptions);
         return new Promise((resolve, reject) => {
@@ -224,7 +224,7 @@ class CSV {
         const dateFormats = options?.dateFormats ?? DEFAULT_DATE_FORMATS;
         const map = options?.map ||
             createDefaultValueMapper(dateFormats, {
-                decimalSeparator: options?.valueMapperOptions?.decimalSeparator ?? options?.parserOptions?.decimalSeparator
+                decimalSeparator: options?.valueMapperOptions?.decimalSeparator
             });
         const parser = new CsvParserStream(options?.parserOptions);
         parser.on("data", (row) => worksheet.addRow(row.map(map)));

package/dist/esm/modules/excel/column.js

@@ -38,7 +38,8 @@ class Column {
             width: this.width,
             style: this.style,
             hidden: this.hidden,
-            outlineLevel: this.outlineLevel
+            outlineLevel: this.outlineLevel,
+            bestFit: this.bestFit
         };
     }
     set defn(value) {
@@ -55,6 +56,7 @@ class Column {
             // headers must be set after style
             this.header = value.header;
             this._hidden = !!value.hidden;
+            this.bestFit = value.bestFit;
         }
         else {
             delete this._header;
@@ -62,6 +64,7 @@ class Column {
             delete this.width;
             this.style = {};
             this.outlineLevel = 0;
+            delete this.bestFit;
         }
     }
     /**
@@ -151,6 +154,7 @@ class Column {
         return (this.width === model.width &&
             this.hidden === model.hidden &&
             this.outlineLevel === model.outlineLevel &&
+            this.bestFit === model.bestFit &&
             isEqual(this.style, model.style));
     }
     get isDefault() {
@@ -163,6 +167,9 @@ class Column {
         if (this.outlineLevel) {
             return false;
         }
+        if (this.bestFit) {
+            return false;
+        }
         const s = this.style;
         if (s && (s.font || s.numFmt || s.alignment || s.border || s.fill || s.protection)) {
             return false;
@@ -313,7 +320,8 @@ class Column {
                         isCustomWidth: column.isCustomWidth,
                         hidden: column.hidden,
                         outlineLevel: column.outlineLevel,
-                        collapsed: column.collapsed
+                        collapsed: column.collapsed,
+                        bestFit: column.bestFit
                     };
                     cols.push(col);
                 }

package/dist/esm/modules/excel/row.js

@@ -388,7 +388,8 @@ class Row {
                 style: this.style,
                 hidden: this.hidden,
                 outlineLevel: this.outlineLevel,
-                collapsed: this.collapsed
+                collapsed: this.collapsed,
+                dyDescent: this.dyDescent
             }
             : null;
     }
@@ -435,6 +436,7 @@ class Row {
         }
         this.hidden = value.hidden;
         this.outlineLevel = value.outlineLevel || 0;
+        this.dyDescent = value.dyDescent;
         this.style = (value.style && JSON.parse(JSON.stringify(value.style))) || {};
     }
 }