react-native-nitro-xlsx 0.2.5 → 0.2.7

package/thirdparty/OpenXLSX/OpenXLSX/sources/XLContentTypes.cpp

@@ -0,0 +1,329 @@
+/*
+
+   ____                               ____      ___ ____       ____  ____      ___
+  6MMMMb                              `MM(      )M' `MM'      6MMMMb\`MM(      )M'
+ 8P    Y8                              `MM.     d'   MM      6M'    ` `MM.     d'
+6M      Mb __ ____     ____  ___  __    `MM.   d'    MM      MM        `MM.   d'
+MM      MM `M6MMMMb   6MMMMb `MM 6MMb    `MM. d'     MM      YM.        `MM. d'
+MM      MM  MM'  `Mb 6M'  `Mb MMM9 `Mb    `MMd       MM       YMMMMb     `MMd
+MM      MM  MM    MM MM    MM MM'   MM     dMM.      MM           `Mb     dMM.
+MM      MM  MM    MM MMMMMMMM MM    MM    d'`MM.     MM            MM    d'`MM.
+YM      M9  MM    MM MM       MM    MM   d'  `MM.    MM            MM   d'  `MM.
+ 8b    d8   MM.  ,M9 YM    d9 MM    MM  d'    `MM.   MM    / L    ,M9  d'    `MM.
+  YMMMM9    MMYMMM9   YMMMM9 _MM_  _MM_M(_    _)MM_ _MMMMMMM MYMMMM9 _M(_    _)MM_
+            MM
+            MM
+           _MM_
+
+  Copyright (c) 2018, Kenneth Troldal Balslev
+
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+  - Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  - Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+  - Neither the name of the author nor the
+    names of any contributors may be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+
+// ===== External Includes ===== //
+#include <cstring>
+
+// ===== OpenXLSX Includes ===== //
+#include "XLContentTypes.hpp"
+#include "XLDocument.hpp"
+#include "XLException.hpp"
+#include "XLXmlParser.hpp"              // pugixml wrapper
+
+using namespace OpenXLSX;
+
+namespace { // anonymous namespace for local functions
+
+    const std::string applicationOpenXmlOfficeDocument = "application/vnd.openxmlformats-officedocument";
+    const std::string applicationOpenXmlPackage        = "application/vnd.openxmlformats-package";
+    const std::string applicationMicrosoftExcel        = "application/vnd.ms-excel";
+    const std::string applicationMicrosoftOffice       = "application/vnd.ms-office";
+
+    /**
+     * @details
+     * @note 2024-08-31: In line with a change to hardcoded XML relationship domains in XLRelationships.cpp, replaced the repeating
+     *          hardcoded strings here with the above declared constants, preparing a potential need for a similar "dumb" fallback implementation
+     */
+    XLContentType GetContentTypeFromString(const std::string& typeString)
+    {
+        XLContentType type { XLContentType::Unknown };
+
+        if (typeString == applicationMicrosoftExcel + ".sheet.macroEnabled.main+xml")
+            type = XLContentType::WorkbookMacroEnabled;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".spreadsheetml.sheet.main+xml")
+            type = XLContentType::Workbook;
+        else if (typeString == applicationOpenXmlPackage + ".relationships+xml")
+            type = XLContentType::Relationships;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".spreadsheetml.worksheet+xml")
+            type = XLContentType::Worksheet;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".spreadsheetml.chartsheet+xml")
+            type = XLContentType::Chartsheet;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".spreadsheetml.externalLink+xml")
+            type = XLContentType::ExternalLink;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".theme+xml")
+            type = XLContentType::Theme;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".spreadsheetml.styles+xml")
+            type = XLContentType::Styles;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".spreadsheetml.sharedStrings+xml")
+            type = XLContentType::SharedStrings;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".drawing+xml")
+            type = XLContentType::Drawing;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".drawingml.chart+xml")
+            type = XLContentType::Chart;
+        else if (typeString == applicationMicrosoftOffice + ".chartstyle+xml")
+            type = XLContentType::ChartStyle;
+        else if (typeString == applicationMicrosoftOffice + ".chartcolorstyle+xml")
+            type = XLContentType::ChartColorStyle;
+        else if (typeString == applicationMicrosoftExcel + ".controlproperties+xml")
+            type = XLContentType::ControlProperties;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".spreadsheetml.calcChain+xml")
+            type = XLContentType::CalculationChain;
+        else if (typeString == applicationMicrosoftOffice + ".vbaProject")
+            type = XLContentType::VBAProject;
+        else if (typeString == applicationOpenXmlPackage + ".core-properties+xml")
+            type = XLContentType::CoreProperties;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".extended-properties+xml")
+            type = XLContentType::ExtendedProperties;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".custom-properties+xml")
+            type = XLContentType::CustomProperties;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".spreadsheetml.comments+xml")
+            type = XLContentType::Comments;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".spreadsheetml.table+xml")
+            type = XLContentType::Table;
+        else if (typeString == applicationOpenXmlOfficeDocument + ".vmlDrawing")
+            type = XLContentType::VMLDrawing;
+        else
+            type = XLContentType::Unknown;
+
+        return type;
+    }
+
+    /**
+     * @details
+     */
+    std::string GetStringFromType(XLContentType type)
+    {
+        std::string typeString;
+
+        if (type == XLContentType::WorkbookMacroEnabled)
+            typeString = applicationMicrosoftExcel + ".sheet.macroEnabled.main+xml";
+        else if (type == XLContentType::Workbook)
+            typeString = applicationOpenXmlOfficeDocument + ".spreadsheetml.sheet.main+xml";
+        else if (type == XLContentType::Relationships)
+            typeString = applicationOpenXmlPackage + ".relationships+xml";
+        else if (type == XLContentType::Worksheet)
+            typeString = applicationOpenXmlOfficeDocument + ".spreadsheetml.worksheet+xml";
+        else if (type == XLContentType::Chartsheet)
+            typeString = applicationOpenXmlOfficeDocument + ".spreadsheetml.chartsheet+xml";
+        else if (type == XLContentType::ExternalLink)
+            typeString = applicationOpenXmlOfficeDocument + ".spreadsheetml.externalLink+xml";
+        else if (type == XLContentType::Theme)
+            typeString = applicationOpenXmlOfficeDocument + ".theme+xml";
+        else if (type == XLContentType::Styles)
+            typeString = applicationOpenXmlOfficeDocument + ".spreadsheetml.styles+xml";
+        else if (type == XLContentType::SharedStrings)
+            typeString = applicationOpenXmlOfficeDocument + ".spreadsheetml.sharedStrings+xml";
+        else if (type == XLContentType::Drawing)
+            typeString = applicationOpenXmlOfficeDocument + ".drawing+xml";
+        else if (type == XLContentType::Chart)
+            typeString = applicationOpenXmlOfficeDocument + ".drawingml.chart+xml";
+        else if (type == XLContentType::ChartStyle)
+            typeString = applicationMicrosoftOffice + ".chartstyle+xml";
+        else if (type == XLContentType::ChartColorStyle)
+            typeString = applicationMicrosoftOffice + ".chartcolorstyle+xml";
+        else if (type == XLContentType::ControlProperties)
+            typeString = applicationMicrosoftExcel + ".controlproperties+xml";
+        else if (type == XLContentType::CalculationChain)
+            typeString = applicationOpenXmlOfficeDocument + ".spreadsheetml.calcChain+xml";
+        else if (type == XLContentType::VBAProject)
+            typeString = applicationMicrosoftOffice + ".vbaProject";
+        else if (type == XLContentType::CoreProperties)
+            typeString = applicationOpenXmlPackage + ".core-properties+xml";
+        else if (type == XLContentType::ExtendedProperties)
+            typeString = applicationOpenXmlOfficeDocument + ".extended-properties+xml";
+        else if (type == XLContentType::CustomProperties)
+            typeString = applicationOpenXmlOfficeDocument + ".custom-properties+xml";
+        else if (type == XLContentType::Comments)
+            typeString = applicationOpenXmlOfficeDocument + ".spreadsheetml.comments+xml";
+        else if (type == XLContentType::Table)
+            typeString = applicationOpenXmlOfficeDocument + ".spreadsheetml.table+xml";
+        else if (type == XLContentType::VMLDrawing)
+            typeString = applicationOpenXmlOfficeDocument + ".vmlDrawing";
+        else
+            throw XLInternalError("Unknown ContentType");
+
+        return typeString;
+    }
+}    // anonymous namespace
+
+/**
+ * @details
+ */
+XLContentItem::XLContentItem() : m_contentNode(std::make_unique<XMLNode>()) {}
+
+/**
+ * @details
+ */
+XLContentItem::XLContentItem(const XMLNode& node) : m_contentNode(std::make_unique<XMLNode>(node)) {}
+
+/**
+ * @details
+ */
+XLContentItem::XLContentItem(const XLContentItem& other) : m_contentNode(std::make_unique<XMLNode>(*other.m_contentNode)) {}
+
+/**
+ * @details
+ */
+XLContentItem::XLContentItem(XLContentItem&& other) noexcept = default;
+
+/**
+ * @details
+ */
+XLContentItem::~XLContentItem() = default;
+
+/**
+ * @details
+ */
+XLContentItem& XLContentItem::operator=(const XLContentItem& other)
+{
+    if (&other != this) *m_contentNode = *other.m_contentNode;
+    return *this;
+}
+
+XLContentItem& XLContentItem::operator=(XLContentItem&& other) noexcept = default;
+
+/**
+ * @details
+ */
+XLContentType XLContentItem::type() const { return GetContentTypeFromString(m_contentNode->attribute("ContentType").value()); }
+
+/**
+ * @details
+ */
+std::string XLContentItem::path() const { return m_contentNode->attribute("PartName").value(); }
+
+/**
+ * @details
+ */
+XLContentTypes::XLContentTypes() = default;
+
+/**
+ * @details
+ */
+XLContentTypes::XLContentTypes(XLXmlData* xmlData) : XLXmlFile(xmlData) {}
+
+/**
+ * @details explicit default destructor
+ */
+XLContentTypes::~XLContentTypes() = default;
+
+/**
+ * @details explicit default copy constructor - invokes base class copy constructor
+ */
+XLContentTypes::XLContentTypes(const XLContentTypes& other) = default;
+
+/**
+ * @details
+ */
+XLContentTypes::XLContentTypes(XLContentTypes&& other) noexcept = default;
+
+/**
+ * @details explicit default copy assignment operator - invokes base class copy assignment
+ */
+XLContentTypes& XLContentTypes::operator=(const XLContentTypes& other) = default;
+
+/**
+ * @details explicit default move assignment operator - invokes base class move assignment
+ */
+XLContentTypes& XLContentTypes::operator=(XLContentTypes&& other) noexcept = default;
+
+/**
+ * @details
+ * @note 2024-07-22: added more intelligent whitespace support
+ */
+void XLContentTypes::addOverride(const std::string& path, XLContentType type)
+{
+    const std::string typeString = GetStringFromType(type);
+
+    XMLNode lastOverride = xmlDocument().document_element().last_child_of_type(pugi::node_element); // see if there's a last element
+    XMLNode node{};    // scope declaration
+
+    // Create new node in the [Content_Types].xml file
+    if (lastOverride.empty())
+        node = xmlDocument().document_element().prepend_child("Override");
+    else { // if last element found
+        // ===== Insert node after previous override
+        node = xmlDocument().document_element().insert_child_after("Override", lastOverride);
+
+        // ===== Using whitespace nodes prior to lastOverride as a template, insert whitespaces between lastOverride and the new node
+        XMLNode copyWhitespaceFrom = lastOverride;    // start looking for whitespace nodes before previous override
+        XMLNode insertBefore = node;                  // start inserting the same whitespace nodes before new override
+        while (copyWhitespaceFrom.previous_sibling().type() == pugi::node_pcdata) { // empty node returns pugi::node_null
+            // Advance to previous "template" whitespace node, ensured to exist in while-condition
+            copyWhitespaceFrom = copyWhitespaceFrom.previous_sibling();
+            // ===== Insert a whitespace node
+            insertBefore = xmlDocument().document_element().insert_child_before(pugi::node_pcdata, insertBefore);
+            insertBefore.set_value(copyWhitespaceFrom.value());            // copy the a whitespace in sequence node value
+        }
+    }
+    node.append_attribute("PartName").set_value(path.c_str());
+    node.append_attribute("ContentType").set_value(typeString.c_str());
+}
+
+/**
+ * @details
+ */
+void XLContentTypes::deleteOverride(const std::string& path)
+{
+    xmlDocument().document_element().remove_child(xmlDocument().document_element().find_child_by_attribute("PartName", path.c_str()));
+}
+
+/**
+ * @details
+ */
+void XLContentTypes::deleteOverride(const XLContentItem& item) { deleteOverride(item.path()); }
+
+/**
+ * @details
+ */
+XLContentItem XLContentTypes::contentItem(const std::string& path)
+{
+    return XLContentItem(xmlDocument().document_element().find_child_by_attribute("PartName", path.c_str()));
+}
+
+/**
+ * @details
+ */
+std::vector<XLContentItem> XLContentTypes::getContentItems()
+{
+    std::vector<XLContentItem> result;
+    XMLNode                    item = xmlDocument().document_element().first_child_of_type(pugi::node_element);
+    while (not item.empty()) {
+        if (strcmp(item.name(), "Override") == 0) result.emplace_back(item);
+        item = item.next_sibling_of_type(pugi::node_element);
+    }
+
+    return result;
+}

package/thirdparty/OpenXLSX/OpenXLSX/sources/XLDateTime.cpp

@@ -0,0 +1,269 @@
+//
+// Created by Kenneth Balslev on 28/08/2021.
+//
+
+#include "XLDateTime.hpp"
+#include "XLException.hpp"
+
+#include <cmath>
+#include <cstdint>    // int32_t
+
+namespace
+{
+
+    /**
+     * @brief
+     * @param year
+     * @return
+     */
+    bool isLeapYear(int year)
+    {
+        if (year == 1900) return true; // historical Excel Date error inherited from older spreadsheet apps
+        if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) return true;
+        return false;
+    }
+
+    /**
+     * @brief
+     * @param month
+     * @param year
+     * @return
+     */
+    int daysInMonth(int month, int year)
+    {
+        switch (month) {
+            case 1:
+                return 31;
+            case 2:
+                return (isLeapYear(year) ? 29 : 28);
+            case 3:
+                return 31;
+            case 4:
+                return 30;
+            case 5:
+                return 31;
+            case 6:
+                return 30;
+            case 7:
+                return 31;
+            case 8:
+                return 31;
+            case 9:
+                return 30;
+            case 10:
+                return 31;
+            case 11:
+                return 30;
+            case 12:
+                return 31;
+            default:
+                return 0;
+        }
+    }
+
+    /**
+     * @brief
+     * @param serial
+     * @return
+     */
+    int dayOfWeek(double serial)
+    {
+        const auto day = static_cast<int32_t>(serial) % 7;
+        return (day == 0 ? 6 : day - 1);
+    }
+
+}    // namespace
+
+namespace OpenXLSX
+{
+    /**
+     * @details Conctructor. Default implementation.
+     */
+    XLDateTime::XLDateTime() = default;
+
+    /**
+     * @details Constructor taking an Excel date/time serial number as an argument.
+     */
+    XLDateTime::XLDateTime(double serial) : m_serial(serial)
+    {
+        if (serial < 1.0) throw XLDateTimeError("Excel date/time serial number is invalid (must be >= 1.0.)"); // don't permit dates before 1900-01-01T00:00:00.000
+    }
+
+    /**
+     * @details Constructor taking a std::tm object as an argument.
+     */
+    XLDateTime::XLDateTime(const std::tm& timepoint)
+    {
+        // ===== Check validity of tm struct.
+        // ===== Only year, month and day of the month are checked. Other variables are ignored.
+        if (timepoint.tm_year < 0) throw XLDateTimeError("Invalid year. Must be >= 0.");
+        if (timepoint.tm_mon < 0 || timepoint.tm_mon > 11) throw XLDateTimeError("Invalid month. Must be >= 0 or <= 11.");
+        if (timepoint.tm_mday <= 0 || timepoint.tm_mday > daysInMonth(timepoint.tm_mon + 1, timepoint.tm_year + 1900))
+            throw XLDateTimeError("Invalid day. Must be >= 1 or <= total days in the month.");
+
+        // ===== Count the number of days for full years past 1900
+        for (int i = 0; i < timepoint.tm_year; ++i) {
+            m_serial += (isLeapYear(1900 + i) ? 366 : 365);
+        }
+
+        // ===== Count the number of days for full months of the last year
+        for (int i = 0; i < timepoint.tm_mon; ++i) {
+            m_serial += daysInMonth(i + 1, timepoint.tm_year + 1900);
+        }
+
+        // ===== Add the number of days of the month, minus one.
+        // ===== (The reason for the 'minus one' is that unlike the other fields in the struct,
+        // ===== tm_day represents the date of a month, whereas the other fields typically
+        // ===== represents the number of whole units since the start).
+        m_serial += timepoint.tm_mday - 1;
+
+        // ===== Convert hour, minute and second to fraction of a full day.
+        const int32_t seconds = timepoint.tm_hour * 3600 + timepoint.tm_min * 60 + timepoint.tm_sec;
+        m_serial += seconds / 86400.0;
+    }
+
+    /**
+     * @details Constructor taking a unixtime format (seconds since 1/1/1970) as an argument.
+     */
+    XLDateTime::XLDateTime(time_t unixtime)
+    {
+        // There are 86400 seconds in a day
+        // There are 25569 days between 1/1/1970 and 30/12/1899 (the epoch used by Excel)
+        m_serial = ( static_cast<double>(unixtime) / 86400 ) + 25569;
+    }
+
+    /**
+     * @details Copy constructor. Default implementation.
+     */
+    XLDateTime::XLDateTime(const XLDateTime& other) = default;
+
+    /**
+     * @details Move constructor. Default implementation.
+     */
+    XLDateTime::XLDateTime(XLDateTime&& other) noexcept = default;
+
+    /**
+     * @details Destructor. Default implementation.
+     */
+    XLDateTime::~XLDateTime() = default;
+
+    /**
+     * @details Copy assignment operator. Default implementation.
+     */
+    XLDateTime& XLDateTime::operator=(const XLDateTime& other) = default;
+
+    /**
+     * @details Move assignment operator. Default implementation.
+     */
+    XLDateTime& XLDateTime::operator=(XLDateTime&& other) noexcept = default;
+
+    /**
+     * @details
+     */
+    XLDateTime& XLDateTime::operator=(double serial)
+    {
+        XLDateTime temp(serial);
+        std::swap(*this, temp);
+        return *this;
+    }
+
+    /**
+     * @details
+     */
+    XLDateTime& XLDateTime::operator=(const std::tm& timepoint)
+    {
+        XLDateTime temp(timepoint);
+        std::swap(*this, temp);
+        return *this;
+    }
+
+    /**
+     * @details
+     */
+    XLDateTime::operator std::tm() const { return tm(); }
+
+    /**
+     * @details Get the time point as an Excel date/time serial number.
+     */
+    double XLDateTime::serial() const { return m_serial; }
+
+    /**
+     * @details Get the time point as a std::tm object.
+     */
+    std::tm XLDateTime::tm() const
+    {
+        // ===== Create and initialize the resulting object.
+        std::tm result {};
+        result.tm_year  = 0;
+        result.tm_mon   = 0;
+        result.tm_mday  = 0;
+        result.tm_wday  = 0;
+        result.tm_yday  = 0;
+        result.tm_hour  = 0;
+        result.tm_min   = 0;
+        result.tm_sec   = 0;
+        result.tm_isdst = -1;
+        double serial   = m_serial;
+
+        // ===== Count the number of whole years since 1900.
+        while (serial > 1) {  // 2025-01-10: safeguard against infinite loop (preemptive)
+            const int days = (isLeapYear(result.tm_year + 1900) ? 366 : 365);
+            if (days + 1 > serial) break; // 2025-01-10: BUGFIX: break on days + 1 > serial (was days >= serial) to account for fractions
+            serial -= days;
+            ++result.tm_year;
+        }
+
+        // ===== Calculate the day of the year, and the day of the week
+        result.tm_yday = static_cast<int>(serial) - 1;
+        result.tm_wday = dayOfWeek(m_serial);
+
+        // ===== Count the number of whole months in the year.
+        while (result.tm_mon < 11) {   // 2025-01-10 BUGFIX: break on December to prevent infinite loop after adjusted bugfix below
+            int days = daysInMonth(result.tm_mon + 1, 1900 + result.tm_year);
+            if (days + 1 > serial) break; // 2025-01-10: BUGFIX: break on days + 1 > serial (was days >= serial) to account for fractions
+            serial -= days;
+            ++result.tm_mon;
+        }
+
+        // ===== Calculate the number of days.
+        result.tm_mday = static_cast<int>(serial);
+        serial -= result.tm_mday;
+
+        // ===== Calculate the number of hours.
+        result.tm_hour = static_cast<int>(serial * 24);
+        serial -= (result.tm_hour / 24.0);
+
+        // ===== Calculate the number of minutes.
+        result.tm_min = static_cast<int>(serial * 24 * 60);
+        serial -= (result.tm_min / (24.0 * 60.0));
+
+        // ===== Calculate the number of seconds.
+        result.tm_sec = static_cast<int>(lround(serial * 24 * 60 * 60));
+
+        // ===== BEGIN: pass rounded overflow back up the date components. BUGFIX 2025-01-10: added this overflow handling to address issue #138
+        if (result.tm_sec >= 60) {
+            result.tm_sec -= 60;
+            ++result.tm_min;
+            if (result.tm_min >= 60) {
+                result.tm_min -= 60;
+                ++result.tm_hour;
+                if (result.tm_hour >= 24) {
+                    result.tm_hour -= 24;
+                    ++result.tm_mday;
+                    int days = daysInMonth(result.tm_mon + 1, 1900 + result.tm_year);
+                    if (result.tm_mday >= days) {
+                        result.tm_mday -= days;
+                        ++result.tm_mon;
+                        if (result.tm_mon >= 12) {
+                            result.tm_mon -= 12;
+                            ++result.tm_year;
+                        }
+                    }
+                }
+            }
+        } // END: pass rounded overflow back up the date components
+
+        return result;
+    }
+
+}    // namespace OpenXLSX