nissl-lab/npoi

This system is a comprehensive .NET library for reading, writing, and manipulating Microsoft Office file formats, including legacy binary formats (HSSF/POIFS) and modern Open XML standards (OOXML). It provides a unified API for processing spreadsheets, Word documents, and PowerPoint presentations, supporting features such as formula evaluation, chart generation, and data extraction. The library also includes infrastructure for handling document encryption, digital signatures, and VBA macro extraction across these various file types.

95 changes.

This period focused on significantly expanding support for legacy OLE2 and HSSF formats, introducing features such as XOR encryption, event-based low-memory reading, and comprehensive handling of charts, pivot tables, and conditional formatting. The work also included a major refactoring of the HPSF metadata module and the initial implementation of the HWPF Word document reader and HSLF PowerPoint model in the scratchpad.

54 changes.

This period focused on significantly expanding NPOI's support for OOXML formats (XSSF and XWPF) by implementing core model components, formula evaluation, charting, and text extraction capabilities. The work also introduced new utility tools for document inspection and code generation, alongside a comprehensive suite of unit tests to validate these new features and existing infrastructure.

64 changes.

This period focused on establishing the foundational OpenXML parsing infrastructure, including the Open Packaging Convention reader, comprehensive schema generation, and robust encryption support for both legacy and modern formats. It also introduced significant new capabilities such as the SXSSF streaming API, VBA macro extraction, and extensive charting and formula enhancements, all underpinned by a modernized Nuke-based build system and expanded test coverage.

The spreadsheet formula evaluator now supports the standard Boolean functions AND, OR, NOT, TRUE, and FALSE. These functions allow users to perform logical operations within cell formulas, with AND and OR handling multiple arguments and ranges, NOT negating a single value, and TRUE/FALSE returning their respective constants.

main/SS/Formula/Functions/Boolean · high confidence

Introduced a new ForkedEvaluator in the formula evaluation subsystem that allows a single master workbook to be shared across multiple independent evaluation contexts. This enables users to evaluate formulas concurrently with significantly reduced memory overhead, as the heavy workbook structures are loaded only once while each evaluator maintains its own isolated, updatable cell values.

main/SS/Formula/Eval/Forked · high confidence

Added new classes to the NPOI HSSF record set to support Excel AutoFilter functionality: AutoFilterInfoRecord, AutoFilterRecord, FilterModeRecord, and the DOPERRecord helper class. These files implement the serialization, deserialization, and cloning logic for the underlying binary records (SIDs 0x9B, 0x9D, 0x9E) required to read and write autofilter settings in .xls files.

main/HSSF/Record/AutoFilter · high confidence

Introduces HtmlDocumentFacade to handle the generation of HTML output from spreadsheets, including support for metadata (charset, author, description, keywords) and styling. Adds SpreadsheetVersion enum to define constraints and properties for Excel formats (Excel97 and Excel2007), such as maximum rows, columns, function arguments, and text length, enabling common code to handle multiple spreadsheet versions correctly.

main/SS · high confidence

A new Windows Forms utility, DocPartViewer, is introduced in the tools directory to inspect the internal XML structure of Microsoft Office documents. The tool allows users to open .docx/.xlsx/.pptx files (which are ZIP archives) and view their contents in a split-pane interface: a tree view on the left displays the document's part hierarchy, while an XML-highlighting text editor on the right shows the source code of the selected part. It supports opening multiple documents simultaneously via separate panes and includes menu options to open files, open another document, and exit.

tools/DocPartViewer · high confidence

A new standalone Windows Forms application, NPOI.StyleViewer, has been added to the tools directory. This utility allows users to inspect WordprocessingML style definitions by loading an XML styles file, displaying the styles in a hierarchical tree view, and showing the corresponding XML source in a rich text box upon selection.

tools/NPOI.StyleViewer · high confidence

The OpenXmlFormats/Drawing area now includes generated C\# classes for several previously missing Open XML DrawingML schema components. This adds support for diagram definitions, data models, color transforms, and layout variables (e.g., CT\_ColorTransform, CT\_DataModel, CT\_OrgChart), as well as audio/video file references (CT\_AudioFile, CT\_VideoFile, CT\_QuickTimeFile) and base types/stylesheet elements (e.g., CT\_ColorScheme, CT\_OfficeArtExtension). These types enable the library to read and write diagram-related content and media references in Office documents, and to handle additional drawing/stylesheet structures required for full compatibility with the Open XML format.

OpenXmlFormats/Drawing · high confidence

The OpenXmlFormats library now includes generated C\# model classes for Office Open XML schemas (such as bibliography, custom properties, and extended properties) alongside new helper utilities. A new StreamWriterExtensions class provides direct, low-allocation methods for writing XML attributes and elements, replacing previous formatted string writes to improve performance and reduce memory pressure when generating documents.

OpenXmlFormats · high confidence

The Styles directory now includes generated C\# classes (CT\_Border, CT\_BorderPr, CT\_Fill, CT\_Fills, CT\_Font, CT\_CellAlignment, etc.) that map to the OpenXML spreadsheet style schema. These classes provide Parse and Write methods for serializing and deserializing style XML, enabling the library to read and write border, fill, font, and alignment settings in Excel files.

OpenXmlFormats/Spreadsheet/Styles · high confidence

Added a new set of exception classes to the NPOI.OpenXml4Net.Exceptions namespace to provide more specific error handling for OpenXML file operations. This includes OpenXml4NetException as the base class, along with InvalidFormatException, NotOfficeXmlFileException, ODFNotOfficeXmlFileException, OLE2NotOfficeXmlFileException, OpenXML4NetRuntimeException, and PartAlreadyExistsException. These exceptions allow applications to catch and handle specific error conditions when working with OOXML files, such as attempting to open non-Office XML files or encountering duplicate parts.

openxml4Net/Exceptions · high confidence

New development tools have been added to the NPOI.POIFS.Dev namespace to help users inspect and visualize the internal structure of POIFS (OLE2) files. This includes the POIFSLister and POIFSViewer classes for printing directory trees and hierarchical views to the console, the POIFSViewEngine for processing viewable objects, and the POIFSViewable interface which defines how objects expose their contents for inspection.

main/POIFS/Dev · high confidence

The library now supports XOR-encrypted OLE2 documents (such as older Excel files) by introducing a new encryption framework in the \NPOI.POIFS.Crypt.XOR\ namespace, including \XORDecryptor\, \XOREncryptor\, and related header/verifier classes. To improve error handling, new exception classes \EmptyFileException\, \EncryptedDocumentException\, and \OldFileFormatException\ have been added to provide specific feedback for empty files, encrypted content, and unsupported legacy formats. Additionally, \POITextExtractor\ and \POIOLE2TextExtractor\ now implement \ICloseable\ to allow users to explicitly release file handles and resources after extraction.

main · high confidence

A new Windows Forms-based utility has been added to the tools directory to generate C\# serialization code for XML structures. The tool provides a graphical interface with a tree view for navigating type hierarchies and buttons to generate parse/write code, generate property code, and copy the output to the clipboard. It is designed to assist in creating serialization logic for OOXML classes, such as pivot table definitions, by recursively analyzing types and generating the corresponding C\# code.

tools/XmlSerializationCodeGenerator · high confidence

Users can now perform linear algebra operations directly within spreadsheet formulas. The new MDETERM function calculates the determinant of a square matrix, MINVERSE returns the inverse of a matrix, TRANSPOSE flips the rows and columns of an array, and MMULT computes the matrix product of two arrays. These functions are implemented using the MathNet.Numerics library and handle array inputs, returning results as array formulas.

main/SS/Formula/Functions/Matrix · high confidence

Added the CT\_RElt, CT\_RPrElt, CT\_Rst, and CT\_Sst classes to the OpenXmlFormats.Spreadsheet namespace, providing the data structures required to parse and write shared strings, rich text runs, and font properties in Excel files.

OpenXmlFormats/Spreadsheet/SharedString · high confidence

The formula engine now supports several new Excel functions. The ADDRESS function generates a text reference from row and column numbers, including optional absolute/relative styling and sheet names. The AGGREGATE function provides a unified interface for statistical aggregations (such as AVERAGE, SUM, MAX, MIN, STDEV, VAR, etc.) while offering options to ignore hidden rows or error values. Additionally, conditional aggregation functions AVERAGEIF, AVERAGEIFS, and the base implementation for SUMIFS/COUNTIFS are now available, allowing users to calculate averages or sums based on one or multiple criteria ranges.

main/SS/Formula/Functions · high confidence

Users can now open and read password-protected HSSF (.xls) files. This change introduces the \Biff8DecryptingStream\, \Biff8EncryptionKey\, \Biff8RC4\, and \RC4\ classes in the \NPOI.HSSF.Record.Crypto\ namespace, which implement the BIFF8 encryption algorithm (including key derivation and RC4 stream handling) to decrypt protected workbook records.

main/HSSF/Record/Crypto · high confidence

The \main/Util/Collections/BidirectionalDictionary\ area now includes a new \BidirectionalDictionary\<TKey, TValue\>\ class, along with \IBidirectionalDictionary\, \IReadOnlyBidirectionalDictionary\, and \ReadOnlyBidirectionalDictionary\ types. This addition provides a dictionary implementation that maintains a unique mapping in both directions, allowing users to look up keys by value via the \Inverse\ property, and includes read-only wrappers for immutable scenarios.

main/Util/Collections/BidirectionalDictionary · high confidence

Users can now encrypt and decrypt POIFS-based files (such as older Excel or Word formats) using the Binary RC4 algorithm. This change introduces a new \BinaryRC4\ namespace containing the \BinaryRC4Encryptor\, \BinaryRC4Decryptor\, and associated header and verifier classes, which implement the specific key generation, password verification, and chunked stream processing required for this legacy encryption standard.

main/POIFS/Crypt · high confidence

Introduced the NPOI.SS.Util.CellWalk namespace, providing a new CellWalk class that allows users to iterate through a specified range of cells in a sheet. This feature includes an ICellHandler interface for custom processing logic, an ICellWalkContext interface exposing row, column, and ordinal indices, and a configurable option to include or exclude empty cells during traversal.

main/SS/Util/Cellwalk · high confidence

New classes have been added to the NPOI.POIFS.Crypt.CryptoAPI namespace to enable encryption and decryption of POIFS streams using the Microsoft CryptoAPI RC4 algorithm. This includes CryptoAPIDecryptor and CryptoAPIEncryptor for handling the cryptographic operations, along with supporting classes for the encryption header, verifier, and info builder. Users can now encrypt and decrypt files that utilize this specific legacy encryption method.

main/POIFS/Crypt/CryptoAPI · high confidence

A new DocumentStylesBuilder class has been added to the XWPF utilities to simplify the creation and management of document styles. It provides methods to set default font properties and create custom heading styles, including a specific static method to generate the style definitions required for rendering a Table of Contents (TOC) in Word documents.

ooxml/XWPF/Util · high confidence

New classes have been added to the NPOI.HWPF.SPRM namespace to handle the compression and decompression of Word document properties. CharacterSprmCompressor and CharacterSprmUncompressor now manage character property (CHP) changes, ParagraphSprmCompressor and ParagraphSprmUncompressor handle paragraph property (PAP) adjustments, and SectionSprmCompressor and SectionSprmUncompressor manage section property (SEP) data. Supporting infrastructure includes SprmBuffer for managing the underlying byte streams and SprmIterator/SprmOperation for parsing individual SPRM operations.

scratchpad/HWPF/SPRM · high confidence

The NPOI.Util.Collections namespace now includes several classes ported from Java to support legacy code patterns: a generic HashSet\<T\> for set operations, a Properties class for loading and managing key-value configuration pairs, a StringTokenizer for parsing strings with custom delimiters, and an EmptyEnumerable (currently commented out) for representing empty enumerables.

main/Util/Collections · high confidence

The main/Util area now includes a suite of foundational utility classes to support binary data manipulation and stream processing. This addition introduces a BigInteger implementation for arbitrary-precision arithmetic, bit-field helpers (BitField, ByteField) for parsing binary protocols, and a ByteBuffer class for efficient memory management. It also adds standard I/O utilities such as BufferedInputStream, BoundedInputStream, and ByteArrayOutputStream, alongside helper classes for CRC32 verification and array operations.

main/Util · high confidence

Introduced the MSOFillType enumeration to define shape and background fill types (such as solid, pattern, texture, picture, and various gradient modes) and added the OfficeArtProperties class containing constants for Office Art fill-related properties (like fill type, color, opacity, and gradient settings) along with a helper to map property IDs to their names.

main/SS/UserModel/Drawing · high confidence

The OpenXmlFormats/Shared module now includes the IOMathContainer interface and the Math.cs file, which provides the underlying data structures and serialization logic for Office MathML (OMath) elements. This adds the capability to parse, construct, and write complex mathematical formulas within Open XML documents, including support for specific elements like fractions, radicals, and limits.

OpenXmlFormats/Shared · high confidence

The OpenXmlFormats/Encryption area now includes generated C\# classes (CT\_Encryption, CT\_KeyData, CT\_KeyEncryptorPassword, CT\_KeyEncryptorCertificate, and EncryptionDocument) that model the Microsoft Office 2006 encryption XML schema. This adds the data structures and XML serialization/deserialization logic required to parse and write encryption metadata for password-based and certificate-based key encryptors, enabling downstream components to handle encrypted Open XML documents.

OpenXmlFormats/Encryption · high confidence

The \main/Util/Optional\ area now includes \Option\<T\>\ for reference types and \ValueOption\<T\>\ for value types, providing a functional-style container to handle potentially absent values. These structs support mapping, filtering, and default-value fallbacks (via \OrElse\ and \Reduce\), along with extension methods to convert nullable objects into these optional wrappers.

main/Util/Optional · high confidence

Introduced the POIFSConstants class to centralize shared constants for POIFS file handling, including definitions for big block sizes (512 and 4096 bytes), mini block sizes, property sizes, and specific byte headers for detecting OOXML and raw XML files. Added the POIFSBigBlockSize class to encapsulate attributes of the big block size, providing methods to retrieve the block size, header value, and counts for properties and BAT entries per block.

main/POIFS/Common · high confidence

The scratchpad directory now includes a Visual Studio 2013 solution file (NPOI.ScratchPad.sln) that organizes the HWPF, HSLF, and TestCases projects. It also adds a local test run configuration (LocalTestRun.testrunconfig) and a test metadata file (NPOI.ScratchPad.vsmdi) to support running unit tests within the Visual Studio environment.

scratchpad · high confidence

New wrapper classes have been added to the Wordprocessing document model to handle parsing and serialization of specific WordprocessingML parts. The diff introduces \CommentsDocument\, \DocumentDocument\, \EndnotesDocument\, \FootnotesDocument\, \FtrDocument\, \HdrDocument\, \NumberingDocument\, \SettingsDocument\, and \StylesDocument\. Each class provides a \Parse\ method to deserialize XML into the corresponding \CT\\\ type and a \Save\ method to serialize the content back to a stream, enabling the library to read and write these distinct document sections.

OpenXmlFormats/Wordprocessing/Document · high confidence

Introduced four new classes in the \NPOI.HSSF.EventUserModel.DummyRecord\ namespace to support the event-user model for reading HSSF (.xls) files. \DummyRecordBase\ serves as an abstract base for records that cannot be serialized, while \LastCellOfRowDummyRecord\, \MissingCellDummyRecord\, and \MissingRowDummyRecord\ provide specific markers to indicate the end of a row, missing cells, and missing rows respectively during sequential parsing.

main/HSSF/EventUserModel/DummyRecord · high confidence

The application now includes \font\_metrics.properties\ and \functionMetadata.txt\ in the main resources. The font metrics file provides character sets, widths, and heights for a wide range of fonts (such as Arial, Times New Roman, and Lucida Sans), enabling accurate text layout and rendering. The function metadata file defines the signatures, parameter counts, and return types for built-in spreadsheet functions (including FIXED, LINEST, and TREND), allowing the application to correctly parse and evaluate formulas.

main/Resources · high confidence

The library now includes implementations for several HSSF PivotTable record types, enabling the parsing and serialization of complex pivot table structures in Excel 97-2003 (.xls) files. New classes added to the \NPOI.HSSF.Record.PivotTable\ namespace include \DataItemRecord\ (SXDI), \ExtendedPivotTableViewFieldsRecord\ (SXVDEX), \PageItemRecord\ (SXPI), \StreamIDRecord\ (SXIDSTM), \ViewDefinitionRecord\ (SXVIEW), \ViewFieldsRecord\ (SXVD), and \ViewSourceRecord\ (SXVS). These changes allow the library to correctly handle pivot table data, view definitions, and field configurations that were previously unsupported.

main/HSSF/Record/PivotTable · high confidence

The HPSF module now includes dedicated mapping classes (PropertyIDMap and SectionIDMap) that define constants and lookup tables for standard Summary Information and Document Summary Information properties (such as title, author, and creation date) and their corresponding section format IDs. This allows applications to resolve numeric property IDs into human-readable strings and identify well-known document summary sections, improving clarity when working with legacy Office file metadata.

main/HPSF/Wellknown · high confidence

The EventFileSystem namespace now provides an event-driven API for reading and writing POIFS (OLE2) documents. Users can register listeners via POIFSReaderListener and POIFSWriterListener to process documents as they are read or written, rather than loading entire structures into memory. This includes the core reader/writer classes, event argument types (POIFSReaderEventArgs, POIFSWriterEventArgs), and the listener registry for managing document paths and names.

main/POIFS/EventFileSystem · high confidence

The ExcelToHtmlConverter class and its supporting utilities have been added to the NPOI.SS.Converter namespace, enabling users to convert Excel workbooks (specifically HSSF/97-2007 formats) into HTML documents. This new feature allows for the generation of HTML output from Excel files via static methods that accept file paths, streams, or workbook instances, while preserving visual styles such as cell borders, colors, and alignment through CSS class mapping.

ooxml/SS/Converter · high confidence

The Analysis ToolPak formula evaluator now supports a wide range of previously missing Excel functions, including IFERROR, IFNA, IFS, SWITCH, TEXTJOIN, RANDBETWEEN, MROUND, NETWORKDAYS, WORKDAY, WORKDAY.INTL, XLOOKUP, XMATCH, DAYS, EDATE, EOMONTH, WEEKNUM, DELTA, various base-conversion functions (BIN2DEC, DEC2BIN, HEX2DEC, etc.), mathematical functions (FACTDOUBLE, QUOTIENT, IMAGINARY, IMREAL), and conditional aggregation functions (AVERAGEIFS, COUNTIFS, MAXIFS, MINIFS, SUMIFS). This significantly improves compatibility with spreadsheets using these formulas.

main/SS/Formula/Atp · high confidence

Added a comprehensive set of new HSSF chart record classes (including AlRunsRecord, AreaFormatRecord, AreaRecord, AttachedLabelRecord, AxcExtRecord, AxesUsedRecord, AxisLineFormatRecord, AxisOptionsRecord, AxisParentRecord, and AxisRecord) to the NPOI.HSSF.Record.Chart namespace. These additions enable the library to parse and generate specific binary structures for chart titles, area charts, axis options, and formatting, thereby improving the fidelity of chart data when reading and writing .xls files.

main/HSSF/Record/Chart · high confidence

The OpenXmlFormats/Spreadsheet library has been significantly expanded with new auto-generated model classes to support a broader range of Excel features. This update adds full serialization and parsing support for AutoFilter (including custom filters and sort states), PivotTable areas, Conditional Formatting elements (gradient fills, stops, and types), and Data Validation. It also introduces models for external data connections, query tables, shared workbook revisions and user tracking, and custom XML mappings, enabling the library to read and write these previously unsupported document structures.

OpenXmlFormats/Spreadsheet · high confidence

The VML (Vector Markup Language) parsing and serialization capabilities have been extended to better support complex Office document structures. New model classes have been added to handle VML Alternative Content (CT\_AlternateContent), Spreadsheet client data (CT\_ClientData), Presentation relationships (CT\_Rel), and Wordprocessing borders (CT\_Border). These additions allow the library to correctly parse and write VML drawings embedded in Excel, PowerPoint, and Word documents, improving compatibility with files containing shapes, comments, and other graphical elements.

OpenXmlFormats/Vml · high confidence

Introduces the core OOXML document hierarchy in the \ooxml\ module, including \POIXMLDocument\ for managing the underlying OPC package and resource lifecycle (via \Close()\), \POIXMLDocumentPart\ for handling package parts and relationships, and \POIXMLFactory\ for instantiating document parts. Adds \POIXMLProperties\ to expose and modify core, extended, and custom document metadata (such as title, author, and custom properties), along with \POIXMLPropertiesTextExtractor\ to retrieve these properties as text.

ooxml · high confidence

This change introduces the foundational classes and interfaces for the XWPF Usermodel, enabling the library to interact with WordprocessingML structures. It adds core abstractions such as IBody and IRunBody to manage document parts (documents, headers, footers, cells), and defines enumerations for document elements (BodyType, BodyElementType), paragraph formatting (ParagraphAlignment, LineSpacingRule, BreakType, BreakClear), and table properties (TableWidthType, TableRowAlign, Borders). Additionally, it provides initial support for structured document tags (SDTs) via AbstractXWPFSDT and ISDTContent, and includes a helper class (TOC) to programmatically generate Table of Contents fields.

ooxml/XWPF/Usermodel · high confidence

This change introduces the foundational model layer for the HSLF PowerPoint module, adding new classes to represent core presentation elements and handle specific error conditions. Users can now interact with a broader range of slide components, including AutoShapes, Freeforms, ActiveX controls, and Backgrounds, as well as manage fill effects, hyperlinks, comments, and header/footer settings. Additionally, dedicated exception classes (such as CorruptPowerPointFileException and EncryptedPowerPointFileException) are now available to provide more granular error reporting when encountering invalid or protected files.

scratchpad/HSLF · high confidence

The HWPF Model layer has been introduced to handle the internal structure of Word 97-2003 (.doc) files. This change adds the core data structures and parsing logic required to read and write document components, including character and paragraph formatting properties (CHP/PAP), bookmarks, and complex file tables. It also introduces support for Escher records (used for embedded images and shapes) and provides a base cloning mechanism for model objects, enabling the library to correctly interpret and manipulate legacy Word document internals.

scratchpad/HWPF/Model · high confidence

This change introduces the core infrastructure for converting Word documents (HWPF) into other formats, specifically HTML and XSL-FO. It adds the \AbstractWordConverter\ base class to handle common conversion logic, along with format-specific implementations (\WordToHtmlConverter\, \WordToFoConverter\) and their corresponding document facades (\HtmlDocumentFacade\, \FoDocumentFacade\, \TextDocumentFacade\). The update also includes utility classes for handling font replacement, number formatting, and image management, enabling the library to parse Word files and generate structured output.

scratchpad/HWPF/Converter · high confidence

This change introduces the core property hierarchy and table management classes for the NPOIFS (NPOI OLE2) implementation. It adds the \Property\ base class and its specific types (\DirectoryProperty\, \DocumentProperty\, \RootProperty\) to represent the OLE2 storage structure, along with \Child\ and \Parent\ interfaces to manage the tree relationships. It also includes \PropertyTable\ and \NPropertyTable\ to handle reading, writing, and indexing these properties, and \PropertyFactory\ to convert raw byte data into the property objects.

main/POIFS/property · high confidence

Added the core OpenXML schema classes for PivotTable support, including CT\_PivotCacheDefinition, CT\_PivotCacheRecords, and CT\_PivotTableDefinition. These new files provide the parsing and serialization logic required to read and write PivotTable structures in spreadsheets, addressing previous gaps in PivotTable handling.

OpenXmlFormats/Spreadsheet/PivotTable · high confidence

This change introduces the core SXSSF (Streaming User Model) classes, enabling the creation of large Excel workbooks with a low memory footprint. The implementation includes the primary entry point SXSSFWorkbook, along with SXSSFSheet, SXSSFRow, and SXSSFCell for streaming data. It also provides SXSSFFormulaEvaluator for formula calculation within the streaming window, SXSSFDrawing and SXSSFPicture for handling images, and GZIPSheetDataWriter for compressed temporary file storage.

ooxml/XSSF/Streaming · high confidence

This change introduces the foundational classes for reading and writing Microsoft Word (.docx) documents within the OpenXmlFormats/Wordprocessing module. It adds core data structures for document bodies, headers, footers, and custom XML, along with base types for handling on/off flags and hexadecimal values. This provides the underlying serialization and parsing infrastructure required for Word document processing.

OpenXmlFormats/Wordprocessing · high confidence

This change introduces the core \openxml4Net/OPC\ library, providing the foundational classes required to read and manipulate Open Packaging Convention files (such as .docx, .xlsx, and .pptx). The new codebase includes \OPCPackage\ and \ZipPackage\ for handling the underlying ZIP container, \PackagePart\ for managing individual document components, and \PackageRelationship\ for navigating connections between parts. It also adds supporting infrastructure such as \ContentTypes\ and \PackageNamespaces\ for standard MIME type and URI handling, \PackagePartName\ for strict URI validation, and \PackageProperties\ for accessing document metadata. This implementation establishes the base capability for the library to parse OOXML structures.

openxml4Net/OPC · high confidence

The spreadsheet formula engine now includes the complete set of Parsed Token (PTG) classes required to parse, represent, and serialize Excel formulas. This change introduces the foundational components for formula handling, including base classes for functions (AbstractFunctionPtg), operators (AddPtg, ConcatPtg), and various reference types (AreaPtg, Area3DPtg, Area3DPxg). It also adds support for array constants (ArrayPtg), boolean and error values (BoolPtg, AreaErrPtg), and formula attributes (AttrPtg). This library enables the system to correctly interpret and reconstruct complex spreadsheet formulas across different Excel file formats.

main/SS/Formula/PTG · high confidence

This change introduces the initial implementation of the HWPF module for reading and extracting text from Microsoft Word documents. It adds core document classes (HWPFDocument, HWPFOldDocument) to handle both modern and legacy (Word 6/95) file formats, along with extractors (WordExtractor, Word6Extractor) that allow users to retrieve plain text, paragraph text, footnotes, headers, and other document content.

scratchpad/HWPF · high confidence

Adds the XWPFWordExtractor class, enabling users to extract text content from .docx files. The extractor processes document body elements including paragraphs, tables (with recursive cell content), and structured document tags (SDTs). It supports optional configuration to include hyperlink URLs and to control the concatenation of phonetic runs. The extraction logic also incorporates headers, footers, comments, and footnotes found within the document structure.

ooxml/XWPF/Extractor · high confidence

The repository is initialized with the core NPOI library structure, including the main source projects (NPOI.Core, NPOI.OOXML, etc.) and a new NUKE-based build infrastructure (build.sh, build.ps1). A centralized Directory.Build.props file establishes the project version as 2.8.1, enables SourceLink for debugging, and enforces strict code analysis rules. The project also introduces an Open Source Maintenance Fee (OSMF) policy, documented in OSMFEULA.txt and enforced via a new MSBuild target, alongside a comprehensive .editorconfig for consistent code formatting.

(repo-wide) · high confidence

Added the HSSFChart class and associated assembly metadata to the scratchpad area, providing experimental capabilities to retrieve existing charts from HSSF workbooks and construct new bar charts by inserting low-level binary records.

scratchpad/HSSF · high confidence

Added new model classes in the XSSF package to handle core OOXML parts, including CalculationChain, CommentsTable, ExternalLinksTable, MapInfo, SharedStringsTable, SingleXmlCells, StylesTable, and ThemesTable. These additions enable reading, writing, and managing workbook calculation chains, cell comments, external links, XML mappings, shared strings, and styles/themes within XSSF workbooks.

ooxml/XSSF/Model · high confidence

The EventUserModel package now includes new classes (XSSFBReader, ReadOnlySharedStringsTable, XSSFReader, XSSFSheetXMLHandler) that enable low-memory, event-based streaming of XLSB (Excel Binary Workbook) files. This allows users to read large XLSB workbooks without loading the entire file into memory, mirroring the existing streaming capabilities for XLSX files.

ooxml/XSSF/EventUserModel · high confidence

Adds the foundational classes for the \NPOI.XSSF.Binary\ namespace to enable streaming parsing of Microsoft Excel Binary Workbook (XLSB) files. This change introduces a new binary parser (\XSSFBParser\) and specific handlers for reading shared strings, styles, comments, hyperlinks, and cell data from the XLSB format, allowing users to process large XLSB workbooks with lower memory overhead compared to traditional DOM-based approaches.

ooxml/XSSF/Binary · high confidence

Added new classes in the NPOI.POIFS.NIO namespace, including the abstract DataSource interface and its implementations ByteArrayBackedDataSource and FileBackedDataSource. This provides a unified API for reading and writing byte buffers backed by either in-memory arrays or file streams, enabling more efficient and flexible data access patterns for POIFS file systems.

main/POIFS/NIO · high confidence

Added several new utility classes to the HSSF namespace to support Excel file operations: HSSFCellRangeAddress and RangeAddress for managing cell range addresses, HSSFColor for handling color palettes and indices, HSSFCellUtil for copying cell styles and values, HSSFRegionUtil for applying borders to cell regions, RKUtil for decoding RK numbers, LazilyConcatenatedByteArray for efficient byte array handling, and GUID for parsing and formatting GUIDs.

main/HSSF/Util · high confidence

A new IExcelExtractor interface has been added to the NPOI.SS.Extractor namespace to provide a common contract for Excel text extractors, covering both HSSF and XSSF formats. This interface defines properties to control extraction details, such as including cell comments, sheet names, headers/footers, and whether to display formulas or their results, along with an option to add tab delimiters for empty cells. Users can now implement or utilize this interface to standardize how Excel file content is extracted as text.

main/SS/Extractor · high confidence

The POIFS file system now supports the new NPOIFS implementation alongside the existing OPOIFS. This change introduces a new block storage abstraction (BlockStore) and a unified DocumentInputStream that automatically delegates to either ODocumentInputStream or NDocumentInputStream based on the underlying file system, allowing users to work with NPOIFS files transparently.

main/POIFS/FileSystem · high confidence

The \main/SS/UserModel\ area now includes foundational interfaces and enumerations for the spreadsheet API, specifically adding \IAutoFilter\ for worksheet filtering, \BorderDiagonal\ and \BorderExtent\ enums for border configuration, \IBorderFormatting\ for conditional formatting borders, and the \BorderStyle\ enum with its helper class for cell border styles. Additionally, \BuiltinFormats\ provides access to standard Excel number formats, \CellCopyPolicy\ enables granular control over cell copying behavior, \ICellRange\<T\>\ defines a typed range interface, and \ICellStyle\ exposes comprehensive cell styling properties including alignment, borders, and fills.

main/SS/UserModel · high confidence

Added HPSFPropertiesExtractor, a new component that extracts document summary and custom properties from HPSF (Home Page Settings File) structures. This allows users to retrieve metadata such as author, title, and custom document properties in textual form, enhancing the library's ability to inspect and extract metadata from legacy Office formats.

main/HPSF/Extractor · high confidence

The HSSF.UserModel namespace now includes several new classes to support advanced spreadsheet features. DVConstraint provides the implementation for data validation constraints, allowing users to define rules for cell input. EscherGraphics enables drawing operations on HSSF shapes using SkiaSharp for font and color handling. EvaluationCycleDetector and EvaluationCycleDetectorManager are added to detect circular references during formula evaluation, ensuring robust calculation of dependent cells. Additionally, HSSFAutoFilter implements the IAutoFilter interface to support Excel auto-filtering on HSSF sheets.

main/HSSF/UserModel · high confidence

Added several new record classes in the HSSF Common folder to support modern Excel features: ExtendedColor for XSSF-style color definitions (indexed, RGB, and theme-based), FeatFormulaErr2 for formula evaluation and error-checking flags, FeatProtection for sheet protection data including password verifiers, FeatSmartTag for smart tag data, FtrHeader and the IFutureRecord interface for Excel 2007+ future records with cell-range associations, and SharedFeature as a common interface for shared feature records. Also moved UnicodeString to this folder and implemented hashCode for its ExtRst component.

main/HSSF/Record/Common · high confidence

Users can now use the ISERR, ISBLANK, and ISNA functions in spreadsheet formulas. ISERR returns TRUE for any error value except \#N/A, ISBLANK returns TRUE for blank cells, and ISNA returns TRUE specifically for \#N/A errors. These functions are implemented in the SS.Formula.Functions.Logical namespace and registered alongside existing type-checking functions like ISERROR, ISTEXT, and ISNUMBER.

main/SS/Formula/Functions/Logical · high confidence

Added the Standard encryption implementation for POIFS files, enabling users to encrypt and decrypt documents using AES-128/192/256 with SHA-1 hashing and ECB chaining mode. This change introduces the \StandardEncryptor\, \StandardDecryptor\, and related header/verifier classes, which rely on BouncyCastle for cryptographic operations. Users can now open password-protected POIFS files that use the legacy Standard encryption scheme and create new files with this encryption method.

main/POIFS/Crypt/Standard · high confidence

Users can now extract VBA macro source code from macro-enabled Office files (both OLE2/POIFS formats like DOC and OOXML formats like XLSM) using the new VBAMacroReader and VBAMacroExtractor classes. The VBAMacroReader automatically detects the file format and locates the VBA project data, while VBAMacroExtractor provides a command-line tool or programmatic API to output the extracted modules to standard output or a specified directory.

main/POIFS/Macros · high confidence

The XDDF/UserModel folder now contains a comprehensive set of new classes supporting the XDDF charting API. This includes enums and extension methods for chart styling (such as PresetColor, PresetGeometry, PresetLineDash, PresetPattern, SchemeColor, and SystemColor), line properties (LineCap, LineEndType, LineEndLength, LineEndWidth, CompoundLine, PenAlignment, BlackWhiteMode), and layout helpers (Angles, RectangleAlignment, PathShadeType). An interface for shape properties (IHasShapeProperties) is also added, providing the foundational types needed to configure chart elements.

ooxml/XDDF/UserModel · high confidence

The XDDF charting subsystem now exposes a comprehensive set of configuration options for building and customizing charts. Users can control axis behavior through new enums for cross-between positioning, crossing points, label alignment, orientation, tick mark placement, and tick label positioning. Chart appearance and layout are configurable via enums for legend position, marker styles, radar and scatter plot styles, bar direction and grouping, display of blank cells, and layout modes. The API also introduces support for 3D chart types (Area3D, Bar3D, Line3D, Pie3D, Surface, Surface3D) and provides data model classes (XDDFAreaChartData, XDDFArea3DChartData) that allow users to add series, set grouping, vary colors, and define shape properties for chart elements.

ooxml/XDDF/UserModel/Chart · high confidence

The XDDF (XSLF Drawing Format) text handling has been expanded with a new user-model layer in the \NPOI.XDDF.UserModel.Text\ namespace. This adds support for detailed text paragraph and character properties, including text alignment, anchoring, auto-fit behavior, and font styling (such as caps, strike, and underline types). It also introduces comprehensive bullet and numbering support, allowing users to configure auto-numbered lists, custom character bullets, and bullet sizes. These changes provide a richer API for manipulating text content in PowerPoint presentations.

ooxml/XDDF/UserModel/Text · high confidence

This change introduces a new set of extension classes in the NPOI XSSF user model to expose detailed cell styling and header/footer capabilities. XSSFCellAlignment now provides properties for vertical and horizontal alignment, reading order, text indentation, rotation, wrapping, and shrink-to-fit. XSSFCellBorder and XSSFCellFill allow users to configure border styles, colors, fill patterns, and foreground/background colors for cells. Additionally, XSSFHeaderFooter exposes the left, center, and right sections of headers and footers, including support for stripping field codes. These additions enable finer control over document appearance and layout in OOXML spreadsheets.

ooxml/XSSF/UserModel/Extensions · high confidence

This change introduces the core evaluation framework for XSSF and SXSSF workbooks by adding the abstract base classes BaseXSSFEvaluationWorkbook and BaseXSSFFormulaEvaluator, which consolidate formula evaluation logic and replace previous implementations. It also adds XSSFNumberCache to pre-calculate and cache numeric values for chart data series, ensuring that formula-based chart data is correctly rendered. Additionally, it introduces CustomIndexedColorMap and DefaultIndexedColorMap to handle custom and legacy color palette lookups for XSSF styles.

ooxml/XSSF/UserModel · high confidence

This change introduces new classes in the ooxml/XSSF/Extractor directory to enhance text extraction from OOXML Excel files. It adds XSSFExcelExtractor and XSSFEventBasedExcelExtractor for standard and streaming-based text extraction, respectively, including support for including sheet names, cell comments, headers/footers, and textboxes. Additionally, it introduces EmbeddedExtractor and EmbeddedData classes to identify and extract embedded objects (such as PDFs, Word documents, or other binary data) from Excel sheets, providing a unified interface for accessing embedded content.

ooxml/XSSF/Extractor · high confidence

The \ooxml/XWPF/Model\ directory now includes new classes to support advanced document structure and text processing. \XWPFHeaderFooterPolicy\ provides logic to manage and create headers and footers (including first-page and even-page variants) within a Word document. \XWPFParagraphDecorator\ and \XWPFCommentsDecorator\ introduce a decorator pattern for paragraphs, allowing comment text to be appended to paragraph content. Additionally, the deprecated \XMLParagraph\ base class is present, marked for removal in version 3.18.

ooxml/XWPF/Model · high confidence

The SS/Format area now contains a complete, newly implemented cell formatting engine. This includes dedicated formatters for dates (CellDateFormatter), elapsed times (CellElapsedFormatter), numbers (CellNumberFormatter), and text (CellTextFormatter), along with the core CellFormat and CellFormatPart classes that parse Excel-style format strings (supporting conditions, colors, and locale-specific currency). The implementation introduces SkiaSharp for color handling and Cysharp.Text for string operations, replacing previous dependencies and providing a robust foundation for cell value display.

main/SS/Format · high confidence

Added new utility classes to the NPOI.SS.Util namespace to improve cell reference handling and range management. The new CellAddress class provides a simple container for row and column coordinates without sheet or absolute/relative context, useful for locations like comment anchors. AreaReference now supports structured table references (e.g., Table1\[\#Headers\]) when a workbook is provided, automatically resolving them to standard cell ranges. CellRangeAddress and its base class CellRangeAddressBase have been enhanced with validation against specific spreadsheet versions, improved intersection detection, and iteration support. CellRangeUtil now includes methods to merge adjacent or overlapping cell ranges, and CellReferenceParser offers optimized parsing of cell reference strings using span-based operations.

main/SS/Util · high confidence

Added new interfaces ICharacterRun and IParagraph to the WP.UserModel namespace, providing a shared API for text run properties (such as bold, italic, font size, and highlighting) and paragraph formatting (such as indentation and alignment). Also added the HeaderFooterType enum to define header and footer scopes (Default, Even, First). These changes establish a common abstraction layer for Word Processing document models.

main/WP · high confidence

This change introduces the \NPOI.HSSF.EventUserModel\ namespace, providing a low-level, event-driven API for reading \.xls\ files. This allows users to process Excel workbooks record-by-record, significantly reducing memory consumption compared to the standard DOM-based approach. The new API includes \HSSFEventFactory\ to drive the processing, \HSSFRequest\ to register listeners for specific record types, and \IHSSFListener\ as the base interface for handling events. It also provides specialized listeners such as \FormatTrackingHSSFListener\ to resolve cell formatting strings, \MissingRecordAwareHSSFListener\ to simulate a complete grid by filling in blank rows and cells, and \EventWorkbookBuilder\ to construct stub workbooks for formula parsing during event processing.

main/HSSF/EventUserModel · high confidence

Added EventBasedExcelExtractor for low-memory, streaming extraction of HSSF files, and OldExcelExtractor to support pre-OLE2 formats (Excel 4, 5, and 95) that were previously unsupported. These new extractors provide an alternative to the existing ExcelExtractor, enabling text extraction for older file versions and large files where memory usage is a concern.

main/HSSF/Extractor · high confidence

Added a new set of classes in the \NPOI.Common.UserModel.Fonts\ namespace to represent font metadata, including \FontCharset\, \FontFamily\, \FontPitch\, and \FontGroup\. These additions provide the underlying data structures and mapping logic required to handle complex character sets, font families, and text run grouping, supporting more accurate font handling in spreadsheet documents.

main/Common · high confidence

Added ConstantValueParser and ErrorConstant classes in the SS.Formula.Constant namespace to support parsing and encoding of constant values (including numbers, strings, booleans, and errors) as required by CRN records, and to provide a type-safe wrapper for 16-bit error codes used in constant value arrays.

main/SS/Formula/Constant · high confidence

The formula evaluation engine in the SS.Formula.Eval namespace has been restructured with the introduction of a new evaluation type hierarchy and supporting utilities. This includes new interfaces and base classes for evaluating cell areas (AreaEval, AreaEvalBase) and a dedicated type for blank cells (BlankEval). Core value evaluation types such as BoolEval, NumberEval, and ErrorEval have been added to handle boolean, numeric, and error states respectively, alongside a new EvaluationException class to standardize error handling during formula processing. Additionally, utility classes like OperandResolver and FunctionEval have been introduced to manage argument resolution and function mapping, providing the foundational components for the formula evaluator.

main/SS/Formula/Eval · high confidence

Added a suite of helper classes in the XSSF UserModel to manage row and column shifting operations, including XSSFRowShifter, XSSFColumnShifter, and the shared XSSFRowColShifter. These components ensure that when rows or columns are inserted, deleted, or moved, dependent elements such as formulas, named ranges, hyperlinks, conditional formatting, and merged regions are correctly updated or removed. The addition of ColumnHelper and HeaderFooterHelper supports column definition management and header/footer text parsing, while XSSFFormulaUtils handles sheet name updates across formulas. XSSFIgnoredErrorHelper and XSSFPasswordHelper provide utilities for managing cell error states and sheet protection, respectively. These changes improve the reliability of spreadsheet manipulation by keeping internal references consistent during structural changes.

ooxml/XSSF/UserModel/Helpers · high confidence

This change introduces a new user-friendly API layer in the HWPF scratchpad module for interacting with Microsoft Word documents. Users can now access and manipulate document bookmarks via the new \Bookmark\ and \Bookmarks\ interfaces and their implementations, allowing for retrieval by index or position range. Additionally, a new \Field\ and \Fields\ API is provided to inspect and navigate document fields (such as page numbers or cross-references) by their start offsets. The update also exposes detailed character formatting capabilities through \CharacterProperties\ and \CharacterRun\, enabling programmatic control over styles like bold, italic, and font attributes, alongside supporting structures for list formatting (\HWPFList\) and border codes.

scratchpad/HWPF/UserModel · high confidence

Added new C\# classes (CT\_Authors, CT\_Cell, CT\_Col, CT\_Cols, CT\_Comment, CT\_CommentList, CT\_Comments, CT\_Hyperlink, CT\_MergeCell, CT\_MergeCells, CT\_Row, CT\_Sheet, CT\_SheetData, CT\_SheetPr) to the OpenXmlFormats.Spreadsheet.Sheet namespace. These classes provide the underlying data structures and XML serialization/deserialization logic for sheet-level elements, enabling the library to correctly parse and write complex spreadsheet features such as comments, hyperlinks, merged cells, and column/row properties.

OpenXmlFormats/Spreadsheet/Sheet · high confidence

The HSSF conditional formatting subsystem now supports reading and writing complex rule types previously unavailable. New classes have been added to handle Color Gradient (Color Scale) formatting, Data Bars, and Icon Sets (Multi-State), including their specific threshold and color definitions. Additionally, the existing Font, Border, and Pattern formatting blocks have been refactored to use strongly-typed enums (BorderStyle, FillPattern) and implement ICloneable, ensuring consistent serialization and deserialization of these visual styles.

main/HSSF/Record/CF · high confidence

The spreadsheet formula evaluator now supports a broad set of new numeric and trigonometric functions, including ABS, ACOS, ACOSH, ASIN, ASINH, ATAN, ATAN2, ATANH, COS, COSH, LN, LOG, LOG10, POISSON, RADIANS, ROUND, ROUNDDOWN, ROUNDUP, SIN, SINH, SQRT, TAN, TANH, and TRUNC. These additions expand the range of mathematical and statistical calculations available to users within spreadsheets.

main/SS/Formula/Functions/Numeric · high confidence

The HSSF low-level record layer now introduces a suite of new aggregate classes in the \NPOI.HSSF.Record.Aggregates\ namespace to group related BIFF records. These include \CFRecordsAggregate\ and \ConditionalFormattingTable\ for managing conditional formatting rules (including CF12 support), \FormulaRecordAggregate\ for handling shared formulas and cached results, \DataValidityTable\ for sheet data validation, \MergedCellsTable\ for cell merge regions, \ColumnInfoRecordsAggregate\ for column width settings, \PageSettingsBlock\ for print and page layout records, \ChartSubstreamRecordAggregate\ for chart sub-streams, \CustomViewSettingsRecordAggregate\ for custom views, and \PLSAggregate\ for PLS records. This restructuring provides a more organized and maintainable way to read, write, and update these specific sheet components.

main/HSSF/Record/Aggregates · high confidence

The formula engine now supports several additional text functions, including CONCAT, PROPER, CHAR, and CLEAN, alongside implementations for EXACT, LEFT, RIGHT, LEN, LOWER, MID, REPLACE, SEARCH, SUBSTITUTE, TRIM, and UPPER. These additions expand the library's capability to process and manipulate text data within spreadsheets, aligning with common Excel formula behaviors.

main/SS/Formula/Functions/Text · high confidence

Added three new utility classes to the OOXML utilities namespace: EnumConverter for mapping between WordprocessingML paragraph alignment enums and their OpenXML schema equivalents; IdentifierManager for managing and reserving unique long-integer identifiers within a specified range; and PackageHelper for simplifying the opening, cloning, and temporary file creation of OOXML packages.

ooxml/Util · high confidence

This change introduces several new helper classes in the NPOI XSSF Util namespace to support spreadsheet processing. CTColComparator provides comparators for sorting column definitions by their minimum and maximum values, which aids in correctly handling column grouping. NumericRanges adds logic to detect and classify overlaps between numeric ranges, a capability relevant to managing cell ranges. Additionally, XmlEnumParser is added to safely parse XML enum attributes into strongly-typed values, and EvilUnclosedBRFixingInputStream is introduced (though marked obsolete) to handle malformed HTML-like tags in XML streams.

ooxml/XSSF/Util · high confidence

Added a new set of aggregate classes in the \NPOI.HSSF.Record.Aggregates.Chart\ namespace to parse and serialize the HSSF chart sub-stream according to its ABNF rules. This includes \ChartRecordAggregate\ as the base class, along with specific aggregates for chart sheets (\ChartSheetAggregate\), chart formats (\ChartFormatsAggregate\), data (\DatAggregate\), axes (\AxesAggregate\, \DVAxisAggregate\, \IVAxisAggregate\), and various chart types and visual elements (\CRTAggregate\, \AXSAggregate\, \AttachedLabelAggregate\, etc.). These classes handle the hierarchical structure of chart records, enabling the library to read and write complex chart data within Excel files.

main/HSSF/Record/Aggregates/Chart · high confidence

Added new C\# classes in the \NPOI.POIFS.Crypt.Dsig.Facets\ namespace to support OOXML document signing. These files (\SignatureFacet\, \OOXMLSignatureFacet\, \XAdESSignatureFacet\, \XAdESXLSignatureFacet\, \EnvelopedSignatureFacet\, \KeyInfoSignatureFacet\, and \Office2010SignatureFacet\) port the signature facet logic from the eID Applet project. Currently, these implementations serve as structural placeholders; the core signing methods throw \NotImplementedException\, indicating that the signature creation workflow is not yet functional in this location.

ooxml/POIFS/Crypt/Dsig/Facets · high confidence

This change introduces the foundational classes for OOXML digital signatures in the NPOI POIFS Crypt Dsig namespace, ported from the eID Applet project. It adds the core configuration container (SignatureConfig), certificate security exceptions, and key signature services including URI dereferencing, relationship transforms, revocation data handling, and time-stamping (TSP). These components provide the necessary plumbing for signing and validating Office Open XML documents, though many service implementations currently throw NotImplementedException as the port is in progress.

ooxml/POIFS/Crypt/Dsig · high confidence

The Drawing Drawing Format (DDF) module has been repopulated with core Escher record implementations, including AbstractEscherOptRecord, DefaultEscherRecordFactory, EscherArrayProperty, EscherBSERecord, EscherBitmapBlip, EscherBlipRecord, EscherBlipWMFRecord, EscherBoolProperty, and EscherChildAnchorRecord. These additions restore the library's ability to parse, manipulate, and serialize complex binary drawing objects (such as images, metafiles, and shape properties) within Excel files, addressing previous gaps in DDF support.

main/DDF · high confidence

Users can now open and save OOXML files (such as .docx, .xlsx, and .pptx) that use the Agile encryption standard. This change introduces the \AgileDecryptor\, \AgileEncryptor\, and related header and verifier classes within the \NPOI.POIFS.Crypt.Agile\ namespace, enabling the library to handle documents encrypted with modern algorithms like AES, which were previously unsupported.

ooxml/POIFS/Crypt/Agile · high confidence

Added support for the Excel 2007+ conditional formatting record types (CFHeader12, CFRule12, and their base classes) in the HSSF (.xls) binary format. This enables the library to correctly parse, modify, and save workbooks containing conditional formatting rules introduced in Excel 2007 and later, ensuring that these formatting rules are preserved during save-and-load operations.

main/HSSF/Record · high confidence

The library now supports generating Area, Bar, Bubble, Line, Pie, Radar, Scatter, and Surface charts in addition to existing types. This change adds the necessary Open XML schema classes (such as CT\_Area3DChart, CT\_BarChart, and CT\_BubbleSer) and their serialization logic, enabling users to create these specific visualizations when exporting spreadsheets.

OpenXmlFormats/Drawing/Chart · high confidence

Added new classes in the HSSF record serialization layer to handle data that exceeds the size limit of a single BIFF record. ContinuableRecordInput allows reading primitive data types that are split across CONTINUE record boundaries, fixing potential read errors on files with fragmented data. ContinuableRecordOutput and UnknownLengthRecordOutput enable the serialization of records with unknown final sizes by automatically generating CONTINUE records when space runs out, ensuring correct BIFF structure for large strings and other variable-length data.

main/HSSF/Record/Cont · high confidence

The WorkbookFactory in the SS/UserModel area has been updated to allow opening Excel files in read-only mode via a new readOnly parameter, which prevents file locks and reduces memory usage for read-heavy scenarios. Additionally, a new ImportOption enum has been introduced, enabling users to import only specific parts of an XSSF file (such as SheetContentOnly or TextOnly) to further optimize performance and resource consumption.

ooxml/SS/UserModel · high confidence

The library now guards against zip-bomb denial-of-service attacks when opening OOXML documents. New utility classes in the \openxml4Net/Util\ directory (\ZipSecureFile\, \ZipEntrySizeGuardStream\, \CountingStream\) enforce configurable limits on the maximum uncompressed size of individual entries and the minimum compression ratio. These checks are applied during the reading of ZIP entries, ensuring that maliciously crafted files designed to inflate memory usage are rejected with an \IOException\ rather than causing resource exhaustion.

openxml4Net/Util · high confidence

A change to existing behaviour in testcases/test-data/xmldsign — 1 commit, 17 files.

testcases/test-data/hsmf, testcases/test-data/xmldsign · low confidence · unverified

A change to existing behaviour in testcases/test-data/functions — 3 commits (1 fix), 2 files.

testcases/test-data/functions · medium confidence · unverified

A change to existing behaviour in testcases/test-data/hpsf — 8 commits (4 fixs), 23 files.

testcases/test-data/hpsf · medium confidence · unverified

The AssemblyInfo.cs file in the openxml4Net/Properties directory has been updated to include conditional compilation attributes for .NET Standard 2.0/2.1, .NET 6.0+, and .NET Framework 4.0/4.5. Specifically, it now applies the AllowPartiallyTrustedCallers attribute and sets SecurityRuleSet.Level1 for these platforms, ensuring compatibility with security requirements in these environments.

openxml4Net/Properties · high confidence

The HPSF (Horrible Property Set Format) module has been significantly refactored to improve robustness and modernize the codebase. The change introduces dedicated, strongly-typed classes for all property value types (such as Array, Blob, ClassID, CodePageString, Currency, Date, Decimal, Filetime, and GUID), replacing previous ad-hoc handling. This new structure includes strict bounds checking for array dimensions and record lengths to prevent out-of-memory errors and crashes when processing malformed or fuzzed files. Additionally, string encoding now leverages the centralized CodePageUtil for consistent code page support, and the CustomProperties API has been updated to use a BidirectionalDictionary for more reliable name-to-ID mapping.

main/HPSF · high confidence

The arithmetic operators (+, -, \*, /) in spreadsheet formulas now use decimal arithmetic internally to avoid precision loss and overflow issues common with double-precision floating-point calculations. This change ensures that results for addition, subtraction, multiplication, and division match Excel's behavior more closely, particularly for large numbers or operations that previously resulted in unexpected rounding errors. The implementation includes specific handling for edge cases such as negative zero in subtraction and overflow fallback in multiplication.

main/SS/Formula/Eval/TwoOperandNumeric · high confidence

The HSSF Model layer has been significantly restructured with the introduction of several new low-level classes to improve binary record handling and formula parsing. A new \ConvertAnchor\ class now standardizes the creation of Escher anchor records for drawing objects, while \DrawingManager2\ provides a modernized, generic-based utility for managing drawing groups and shape IDs, deprecating the legacy \DrawingManager\. Formula support is enhanced by the new \HSSFFormulaParser\ wrapper and \ParseNode\ tree structure, which enable more robust parsing and token collection for cell formulas. Additionally, new internal models \InternalChart\ and \InternalSheet\ offer dedicated, low-level access to chart and sheet binary records respectively, and \RecordOrderer\ ensures correct insertion positions for various sheet records according to the BIFF8 specification.

main/HSSF/Model · high confidence

The NPOI test case assembly has been updated to version 1.2.5, aligning with the preparation for a potential release. This change includes the addition of new project property files: AssemblyInfo.cs, which sets the assembly version and file version to 1.2.5.0, and new application settings files (Settings.settings and Settings.Designer.cs) that define a user-scoped configuration property named TEST\_PROPERTY, defaulting to the path "../../test-data".

testcases/main/Properties · high confidence

The project has replaced its previous build process with a new Nuke-based infrastructure. This change introduces a standardized build pipeline that compiles the solution using the .NET 10 SDK, runs tests, and packages the library. It also configures GitHub Actions for continuous integration, including specific steps to install required fonts on Linux runners and logic to handle versioning and artifact publishing.

build · high confidence

The POIFS storage subsystem has been replaced with a new implementation in NPOI.POIFS.Storage. This change introduces dedicated classes for managing the OLE2 Compound File structure, including BATBlock, BlockAllocationTableReader, and BlockAllocationTableWriter for handling block allocation tables, as well as HeaderBlock, DocumentBlock, and BigBlock for managing file headers and data streams. The new code also adds DataInputBlock for efficient little-endian binary reading and BlockList/BlockListImpl for managing block references, fundamentally changing how the library reads and writes OLE2-based documents like older Excel formats.

main/POIFS/Storage · high confidence

Added new document wrapper classes (CalcChainDocument, ChartsheetDocument, CommentsDocument, ExternalLinkDocument, MapInfoDocument, SingleXmlCellsDocument, SstDocument, StyleSheetDocument, TableDocument, ThemeDocument, WorkbookDocument, and WorksheetDocument) to handle parsing and saving of specific Open XML spreadsheet components. Additionally, the WorksheetDocument.Save method now accepts a leaveOpen boolean argument, allowing control over whether the underlying stream is closed after saving.

OpenXmlFormats/Spreadsheet/Document · high confidence

The spreadsheet formula engine now uses a new \FunctionMetadataRegistry\ to manage built-in Excel functions. This registry is populated by parsing a new \functionMetadata.txt\ resource file via \FunctionMetadataReader\, with metadata stored in \FunctionMetadata\ objects and built using \FunctionDataBuilder\. This change provides a centralized, data-driven way to look up function indices and parameter definitions by name or index, replacing previous hard-coded or less structured approaches.

main/SS/Formula/Function · high confidence

This change introduces several new internal classes for the Open Packaging Conventions (OPC) layer, including ContentType, ContentTypeManager, ZipContentTypeManager, FileHelper, MemoryPackagePart, and their associated output streams and marshallers, to manage package content types and in-memory part storage. It also updates PackagePropertiesPart to support a wider range of timezone-aware date formats (including those with colons) and fixes DateTime formatting issues by using TimeZoneInfo. Additionally, ZipHelper now pins zip entry timestamps to 1980-01-01 to match Excel's behavior, ensuring deterministic output.

openxml4Net/OPC/Internal · high confidence

The formula evaluation engine for relational operators (equal, not equal, greater than, less than, etc.) has been restructured. The core comparison logic is now implemented in the abstract base class \RelationalOperationEval\, which handles operand resolution, type-specific comparisons (including special handling for blanks, booleans, strings, and numbers), and array-based evaluations. Specific operators are now implemented in their own classes (\EqualEval\, \NotEqualEval\, \GreaterThanEval\, etc.) that inherit from this base and define the specific comparison result conversion. This change improves code modularity and maintainability of the formula evaluation system.

main/SS/Formula/Eval/RelationalOperationEval · high confidence

The solution files have been updated to include previously separate projects: the test suite (NPOI.Core.Test), the NUKE build infrastructure (\_build), the benchmarks project (NPOI.Benchmarks), and the NPOI.Pack project. The main solution (NPOI.Core.sln) now targets Visual Studio 16, while the test solution (NPOI.Core.Test.sln) targets Visual Studio 17 and includes configuration for runsettings and nested test case projects.

solution · high confidence

User-defined functions are now registered per workbook instance rather than globally, preventing conflicts when multiple workbooks define functions with the same name. This change introduces a new UDF finder architecture (AggregatingUDFFinder, DefaultUDFFinder, IndexedUDFFinder) to manage function lookups within the context of each workbook instance.

main/SS/Formula/Udf · high confidence

The formula evaluation engine has been refactored to introduce a shared \BaseFormulaEvaluator\ class that consolidates common logic previously duplicated across HSSF and XSSF implementations. This change introduces a robust caching system via \EvaluationCache\, \CellCacheEntry\, and \CacheAreaEval\ to optimize performance by avoiding unnecessary re-calculation of referenced cells. Additionally, the new \CollaboratingWorkbooksEnvironment\ class enables the evaluation of formulas that contain external references across multiple workbooks, and dedicated evaluators for conditional formatting and data validation are now integrated into this unified evaluation context.

main/SS/Formula · high confidence

The AssemblyInfo.cs file has been updated to include conditional compilation directives for .NET 6 and .NET Standard 2.1, ensuring compatibility with these newer frameworks. The file now explicitly applies the AllowPartiallyTrustedCallers attribute and sets SecurityRuleSet.Level1 for these targets, while also maintaining InternalsVisibleTo access for the NPOI.OOXML.TestCases assembly.

OpenXmlFormats/Properties · high confidence

The OOXML assembly metadata has been updated to version 2.0.1.0, with the company name set to Neuzilla. New conditional compilation attributes have been added to support modern .NET targets (.NET Standard 2.0, .NET Standard 2.1, .NET 6.0+, and .NET 4.0+): the assembly is now marked with AllowPartiallyTrustedCallers and SecurityRules(Level1) for these frameworks, and internal types are exposed to NPOI.Benchmarks and NPOI.OOXML.TestCases via InternalsVisibleTo. The legacy AssemblyInfoDotnet2.cs file retains the 2.0.1.0 version and basic metadata but does not include the new conditional security attributes.

ooxml/Properties · high confidence

The AssemblyInfo.cs file has been updated to configure assembly-level attributes for compatibility with .NET Standard 2.0/2.1, .NET 4.0/4.5, and .NET 6+. Specifically, it enables \AllowPartiallyTrustedCallers\ and sets \SecurityRuleSet.Level1\ for these frameworks, while also defining \InternalsVisibleTo\ for the NPOI test cases assembly.

main/Properties · high confidence

A fix in testcases/test-data/poifs — 4 commits (3 fixs), 17 files.

testcases/test-data/poifs · medium confidence · unverified

Introduces the \PackagePropertiesUnmarshaller\ class to correctly parse and extract core document metadata (such as title, creator, description, and keywords) from Open XML package core properties parts. This implementation resolves Bug 56479 by dynamically handling XML namespace aliases (e.g., for \dcterms\) rather than hardcoding them, ensuring compatibility with various XML namespace declarations. The change also includes the \UnmarshallContext\ class to manage the state required during the unmarshalling process.

openxml4Net/OPC/Internal/Unmarshallers · high confidence

Attempting to open a .xlsb (Excel Binary Workbook) file now throws a specific XLSBUnsupportedException with a clear message, instead of a generic or confusing error. This helps users quickly identify that the binary workbook format is not supported by the library.

ooxml/XSSF · high confidence

The workbook XML output now strictly adheres to the Open XML schema by placing the fileRecoveryPr element before the extLst element, ensuring compatibility with spreadsheet applications that enforce this sequence. Additionally, the generated workbook XML now includes the correct compatible xmlns declarations for sheet, styles, and workbook parts, preventing validation errors or display issues in consumers that require strict namespace compliance.

OpenXmlFormats/Spreadsheet/Workbook · high confidence

Resolves an issue where FileMagicContainer.ValueOf incorrectly returned UNKNOWN when detecting file types from a stream with a position greater than zero. This ensures that streams, such as those from XSSFWorkbook, are correctly identified as OOXML regardless of their current read position.

testcases/ooxml/POIFS/FileSystem · high confidence

The marshaller layer in the OPC package handling now correctly skips writing empty shared-string tables to avoid errors, ensures that the original cause of exceptions in ZipPackagePropertiesMarshaller is preserved rather than swallowed, and pins ZIP entry timestamps to 1980-01-01 to match Excel's behavior.

openxml4Net/OPC/Internal/Marshallers · high confidence

The row-shifting implementation has been consolidated from scattered methods in HSSFSheet into new helper classes (BaseRowColShifter and RowShifter). This change fixes bugs related to merged region handling during row shifts, ensuring that regions are correctly shifted, grown, shrunk, or removed based on whether they are overlaid by the shift operation. Users will see more accurate behavior when shifting rows in spreadsheets containing merged cells, preventing data loss or incorrect region persistence.

main/SS/UserModel/Helpers · high confidence

Add HPSF Basic test suite; Add HSSF test data provider and sample utilities; Add OOXML test project configuration and settings; Add XWPF test suite for document protection, extended properties, and bug fixes; Add comprehensive unit tests for spreadsheet formula functions; Add formula evaluator unit tests for HSSF and XSSF; Add unit tests for XSSF circular reference handling; Added ComparisonFailure exception class; Added HSSF UserModel test utilities and test cases; Added HWPF test suite and scratchpad test infrastructure; Added NIO FileBackedDataSource tests; Added Open Packaging Convention (OPC) compliance test suite; Added POIFS FileSystem test suite; Added XSSF user model test coverage for pivot tables, formula evaluation, and sheet cloning; Added event-model unit tests for HSSF workbooks; Added font metrics test data; Added formula evaluation unit tests for caching, shifting, and external references; Added test coverage for Analysis Toolpak (ATP) functions; Added test coverage for Excel to HTML conversion; Added test coverage for POIFS Cryptography CipherAlgorithm; Added test coverage for WorkbookFactory creation modes; Added test coverage for XSSF extractors and XML export; Added test data files for OpenXML4J and Publisher formats; Added test data files for spreadsheet parsing edge cases; Added test data for macro extraction; Added test data for macro extraction and slideshow parsing; Added test data for text extraction, metadata, and macro content; Added test for chart sub-stream record aggregation; Added test suite for OOXML and POIFS encryption and signing; Added tests for ForkedEvaluator concurrency and error handling; Added tests for HPSF variant and property support; Added tests for POIFS EventFileSystem listener and registry; Added tests for VBA macro extraction in POIFS; Added tests for XLSB shared strings and hyperlink parsing; Added tests for XSSF event-based reading and shared strings handling; Added tests for XWPF hyperlink, footer, and header/footer policy handling; Added tests for embedded object extraction in Excel files; Added tests for spreadsheet formula function parsing and metadata; Added tests for structured references, cell utility, and border templates; Added unit tests for CellRange utility operations; Added unit tests for Escher DDF records; Added unit tests for Excel 4, 5, and 95 text extraction; Added unit tests for HPSF properties extractor; Added unit tests for HSSF EventModel abort and record factory logic; Added unit tests for HSSF UnicodeString record serialization; Added unit tests for HSSF cell and area reference utilities; Added unit tests for HSSF chart record serialization; Added unit tests for HSSF crypto and pivot table record handling; Added unit tests for HSSF drawing, formula parsing, and anchor handling; Added unit tests for HSSF formula PTG parsing and evaluation; Added unit tests for HSSF record aggregates; Added unit tests for OOXML cell format parsing; Added unit tests for OOXML spreadsheet document serialization and deserialization; Added unit tests for SS Util components; Added unit tests for SS/Format cell formatting logic; Added unit tests for SXSSF streaming components; Added unit tests for UDFFinder classes; Added unit tests for XDDF chart components; Added unit tests for XDDF chart data sources, culture handling, and text properties; Added unit tests for XSSF border, fill, and header/footer extensions; Added unit tests for XSSF column and header/footer helpers; Added unit tests for XSSF utility classes; Added unit tests for XSSF workbook loading and saving; Added unit tests for the ConstantValueParser; Added unit tests for the OOXML IdentifierManager utility; Expanded and corrected formula function test coverage; Expanded unit test coverage for HSSF record serialization and cloning; Expanded unit test coverage for NPOI utility classes; Expanded unit test coverage for XWPF document components; Initial OOXML test suite and configuration; Initial OpenXML4Net test suite for OPC package validation; Initial test coverage for XWPFWordExtractor; Migrate test suite to NUnit and introduce SS test provider interface; New NPOI.Benchmarks project for performance regression testing; New XSSF test infrastructure and coverage for sheet protection, cloning, and formulas; New test infrastructure and utilities for NPOI; New test suite for OOXML spreadsheet components; Port CellWalk tests to NUnit with legacy assertion support; Structured reference handling and parsing improvements; Test for PackageRelationship.GetHashCode with null source.

The project now uses Central Package Management via Directory.Packages.props to unify dependency versions across all projects. Key library upgrades include SkiaSharp to 3.119.4 (replacing SixLabors.ImageSharp and SixLabors.Fonts), BouncyCastle.Cryptography to 2.6.2, SharpZipLib to 1.4.2, and NUnit to 4.5.1. The build infrastructure has been upgraded to NUKE 10, and the solution now targets .NET 10.0 alongside .NET 4.7.2 and .NET Standard 2.0/2.1.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 51 → 52 (+1.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 54 → 50 (-3.6)
• Architecture 94 → 94 (+0.0)
• Maturity 55 → 56 (+0.3)
• Readiness 61 → 56 (-5.4)
• Security 41 → 46 (+5.5)
• Performance 81 → 81 (+0.0)

• Bounded contexts not declared
• CommentedOutCode (main/DDF/EscherContainerRecord.cs)
• CommentedOutCode (main/DDF/EscherDgRecord.cs)
• CommentedOutCode (main/DDF/EscherDggRecord.cs)
• CommentedOutCode (main/DDF/EscherSpgrRecord.cs)
• CommentedOutCode (main/DDF/EscherSplitMenuColorsRecord.cs)
• CommentedOutCode (main/HSSF/Record/ExternalNameRecord.cs)
• CommentedOutCode (main/HSSF/Record/WindowProtectRecord.cs)
• CommentedOutCode (main/POIFS/FileSystem/NPOIFSDocument.cs)
• CommentedOutCode (main/POIFS/FileSystem/OPOIFSDocument.cs)
• CommentedOutCode (main/SS/Formula/Eval/OperandResolver.cs)
• CommentedOutCode (main/SS/Formula/Functions/Index.cs)
• CommentedOutCode (main/SS/Formula/Functions/Index.cs)
• CommentedOutCode (main/SS/UserModel/DateUtil.cs)
• CommentedOutCode (main/SS/UserModel/DateUtil.cs)
• CommentedOutCode (main/Util/IOUtils.cs)
• CommentedOutCode (ooxml/POIFS/Crypt/Dsig/Facets/OOXMLSignatureFacet.cs)
• CommentedOutCode (ooxml/POIFS/Crypt/Dsig/Facets/OOXMLSignatureFacet.cs)
• CommentedOutCode (ooxml/POIFS/Crypt/Dsig/Facets/Office2010SignatureFacet.cs)
• CommentedOutCode (ooxml/XSSF/UserModel/XSSFObjectData.cs)
• …and 350 more

• Assertions commented out: DeserializeVmlDrawingDocumentTest (testcases/ooxml/OpenXmlFormats/Spreadsheet/VmlDrawingDocumentTest.cs)
• Assertions commented out: Test58616 (testcases/ooxml/POIFS/Crypt/TestDecryptor.cs)
• Assertions commented out: TestApplyObjectDate (testcases/main/SS/Format/TestCellFormat.cs)
• Assertions commented out: TestConstruct (testcases/main/Util/TestHexDump.cs)
• CT_Rst.XmlText.get (cognitive 67) (OpenXmlFormats/Spreadsheet/SharedString/CT_Rst.cs)
• CT_Rst.XmlText.get (cyclomatic 26) (OpenXmlFormats/Spreadsheet/SharedString/CT_Rst.cs)
• CommentedOutCode (OpenXmlFormats/Wordprocessing/Picture.cs)
• CommentedOutCode (OpenXmlFormats/Wordprocessing/Picture.cs)
• CommentedOutCode (benchmarks/NPOI.Benchmarks/LargeExcelFileBenchmark.cs)
• CommentedOutCode (main/DDF/EscherBoolProperty.cs)
• CommentedOutCode (main/HPSF/Array.cs)
• CommentedOutCode (main/HPSF/ClipboardData.cs)
• CommentedOutCode (main/HPSF/Section.cs)
• CommentedOutCode (main/HSSF/Model/InternalSheet.cs)
• CommentedOutCode (main/HSSF/Model/InternalSheet.cs)
• CommentedOutCode (main/HSSF/Model/InternalSheet.cs)
• CommentedOutCode (main/HSSF/Model/InternalWorkbook.cs)
• CommentedOutCode (main/HSSF/Model/InternalWorkbook.cs)
• CommentedOutCode (main/HSSF/Model/InternalWorkbook.cs)
• CommentedOutCode (main/HSSF/Model/InternalWorkbook.cs)
• …and 986 more

• 65 commits — 49 feature/other, 16 fixes

• (repo) — 25 commits
• (root) — 21 commits
• main/SS — 4 commits
• ooxml/XSSF — 2 commits
• testcases/main — 2 commits
• testcases/openxml4net — 2 commits
• OpenXmlFormats/Drawing — 1 commit
• OpenXmlFormats/NPOI.OpenXmlFormats.Core.csproj — 1 commit
• OpenXmlFormats/Wordprocessing — 1 commit
• build/_build.csproj — 1 commit
• main/NPOI.Core.csproj — 1 commit
• main/POIFS — 1 commit
• ooxml/XWPF — 1 commit
• openxml4Net/Util — 1 commit
• testcases/ooxml — 1 commit

• fix: Add zip-bomb regression tests for [GHSA redacted]
• fix: Fix MIRR rate order and cashflow discounting logic
• fix: Fix decompression-bomb DoS in OOXML package reader ([GHSA redacted])
• fix: Fix flaky TestNPOI1469 timestamp rounding
• fix: Fix sponsor name casing and add PWC Germany
• fix: Fixed CT_Double to serialize zero val attributes.
• fix: Merge branch 'nissl-lab:master' into fix/ks/20260323_area-reference-structured-table-refs
• fix: Merge pull request #1750 from swyfft-insurance/fix/ks/20260323_area-reference-structured-table-refs
• fix: Merge pull request #1846 from EmilienDup/fix/column-open-range-perf-improvement
• fix: Merge pull request #1850 from nissl-lab/revert-1808-copilot/integrate-excelfinancialfunctions-npoi
• fix: Merge pull request #1853 from nissl-lab/copilot/migrate-mirr-function-fixes
• fix: Merge pull request #1872 from nissl-lab/copilot/fix-randomness-issue-1862
• fix: Potential fix for pull request finding
• fix: Revert "Integrate ExcelFinancialFunctions as backing engine for NPOI financial formula evaluation"
• fix: Strengthen RNG regression test
• fix: fix #1860
• change: Add GitHub links for individual sponsors
• change: Add Sponsors.md to outline sponsorship model
• change: Add XWPFTable.WidthType property
• change: Add sponsors section to README
• …and 45 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

nissl-lab/npoi was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.