@cj-tech-master/excelts 4.2.2 → 4.2.3-canary.20260122073152.a9bb6b0

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

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

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

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

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

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

package/dist/esm/modules/excel/utils/parse-sax.js

@@ -142,6 +142,12 @@ const XML_ENTITIES = {
     quot: '"',
     apos: "'"
 };
+// HAN CELL namespace prefix normalization
+// HAN CELL uses non-standard namespace prefixes (ep:, cp:, dc:, etc.)
+// The x: prefix for spreadsheetml is detected dynamically from xmlns declarations
+// See: https://github.com/exceljs/exceljs/issues/3014
+const HAN_CELL_PREFIXES = /^(ep|cp|dc|dcterms|dcmitype|vt):/;
+const SPREADSHEETML_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
 // ============================================================================
 // Parser States
 // ============================================================================
@@ -202,6 +208,8 @@ export class SaxesParser {
         this.chunkPosition = 0;
         // Entity storage
         this.ENTITIES = { ...XML_ENTITIES };
+        // HAN CELL compatibility: spreadsheetml namespace prefix (e.g., "x")
+        this.nsPrefix = null;
         this.trackPosition = opt?.position !== false;
         this.fileName = opt?.fileName;
         this.fragment = opt?.fragment ?? false;
@@ -236,6 +244,14 @@ export class SaxesParser {
         this.chunk = "";
         this.i = 0;
         this.prevI = 0;
+        this.nsPrefix = null;
+    }
+    // Strip HAN CELL namespace prefixes from element names
+    stripNsPrefix(name) {
+        const n = name.replace(HAN_CELL_PREFIXES, "");
+        return this.nsPrefix && n.startsWith(this.nsPrefix + ":")
+            ? n.slice(this.nsPrefix.length + 1)
+            : n;
     }
     on(name, handler) {
         switch (name) {
@@ -651,9 +667,8 @@ export class SaxesParser {
             this.name += charFromCode(c);
             return;
         }
-        // Tag name complete
         this.tag = {
-            name: this.name,
+            name: this.stripNsPrefix(this.name),
             attributes: Object.create(null),
             isSelfClosing: false
         };
@@ -1092,11 +1107,7 @@ export class SaxesParser {
     openTag() {
         const tag = this.tag;
         tag.isSelfClosing = false;
-        // Copy attributes from list to object
-        for (const { name, value } of this.attribList) {
-            tag.attributes[name] = value;
-        }
-        this.attribList = [];
+        this.processAttributes(tag);
         this.openTagHandler?.(tag);
         this.tags.push(tag);
         this.name = "";
@@ -1105,11 +1116,7 @@ export class SaxesParser {
     openSelfClosingTag() {
         const tag = this.tag;
         tag.isSelfClosing = true;
-        // Copy attributes from list to object
-        for (const { name, value } of this.attribList) {
-            tag.attributes[name] = value;
-        }
-        this.attribList = [];
+        this.processAttributes(tag);
         this.openTagHandler?.(tag);
         this.closeTagHandler?.(tag);
         if (this.tags.length === 0) {
@@ -1118,8 +1125,20 @@ export class SaxesParser {
         this.name = "";
         this.state = S_TEXT;
     }
+    // Process attributes and detect spreadsheetml namespace prefix
+    processAttributes(tag) {
+        for (const { name, value } of this.attribList) {
+            tag.attributes[name] = value;
+            if (name.startsWith("xmlns:") && value === SPREADSHEETML_NS) {
+                this.nsPrefix = name.slice(6);
+                tag.name = this.stripNsPrefix(tag.name);
+            }
+        }
+        this.attribList = [];
+    }
     closeTag() {
-        const { tags, name } = this;
+        const { tags } = this;
+        const name = this.stripNsPrefix(this.name);
         this.state = S_TEXT;
         this.name = "";
         if (name === "") {