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

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

@@ -34,6 +34,7 @@ import { StreamingZip, ZipDeflateFile } from "../../archive/zip/stream.js";
 import { ZipParser } from "../../archive/unzip/zip-parser.js";
 import { PassThrough, concatUint8Arrays } from "../../stream/index.browser.js";
 import { commentsPath, commentsRelTargetFromWorksheetName, ctrlPropPath, drawingPath, drawingRelsPath, OOXML_REL_TARGETS, pivotTableRelTargetFromWorksheetName, pivotCacheDefinitionRelTargetFromWorkbook, getCommentsIndexFromPath, getDrawingNameFromPath, getDrawingNameFromRelsPath, getMediaFilenameFromPath, mediaPath, getPivotCacheDefinitionNameFromPath, getPivotCacheDefinitionNameFromRelsPath, getPivotCacheRecordsNameFromPath, getPivotTableNameFromPath, getPivotTableNameFromRelsPath, pivotCacheDefinitionPath, pivotCacheDefinitionRelsPath, pivotCacheDefinitionRelTargetFromPivotTable, pivotCacheRecordsPath, pivotCacheRecordsRelTarget, pivotTablePath, pivotTableRelsPath, getTableNameFromPath, tablePath, tableRelTargetFromWorksheetName, themePath, getThemeNameFromPath, getVmlDrawingNameFromPath, getWorksheetNoFromWorksheetPath, getWorksheetNoFromWorksheetRelsPath, isBinaryEntryPath, normalizeZipPath, OOXML_PATHS, vmlDrawingRelTargetFromWorksheetName, vmlDrawingPath, worksheetPath, worksheetRelsPath } from "../utils/ooxml-paths.js";
+import { PassthroughManager } from "../utils/passthrough-manager.js";
 class StreamingZipWriterAdapter {
     constructor(options) {
         this.events = new Map();
@@ -201,6 +202,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);
@@ -300,8 +302,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: [],
@@ -310,6 +316,8 @@ class XLSX {
             mediaIndex: {},
             drawings: {},
             drawingRels: {},
+            // Raw drawing XML data for passthrough (when drawing contains chart references)
+            rawDrawings: {},
             comments: {},
             tables: {},
             vmlDrawings: {},
@@ -317,8 +325,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 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 = getWorksheetNoFromWorksheetPath(entryName);
+        if (sheetNo !== undefined) {
+            await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
+            return true;
+        }
+        switch (entryName) {
+            case OOXML_PATHS.rootRels:
+                model.globalRels = await this.parseRels(stream);
+                return true;
+            case 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.xlSharedStrings:
+                model.sharedStrings = new SharedStringsXform();
+                await model.sharedStrings.parseStream(stream);
+                return true;
+            case OOXML_PATHS.xlWorkbookRels:
+                model.workbookRels = await this.parseRels(stream);
+                return true;
+            case OOXML_PATHS.docPropsApp: {
+                const appXform = new AppXform();
+                const appProperties = await appXform.parseStream(stream);
+                if (appProperties) {
+                    model.company = appProperties.company;
+                    model.manager = appProperties.manager;
+                }
+                return true;
+            }
+            case OOXML_PATHS.docPropsCore: {
+                const coreXform = new CoreXform();
+                const coreProperties = await coreXform.parseStream(stream);
+                Object.assign(model, coreProperties);
+                return true;
+            }
+            case OOXML_PATHS.xlStyles:
+                model.styles = new 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 () => {
@@ -335,56 +439,12 @@ class XLSX {
             const entryName = normalizeZipPath(entry.name);
             const stream = entry.stream;
             try {
-                const sheetNo = getWorksheetNoFromWorksheetPath(entryName);
-                if (sheetNo !== undefined) {
-                    await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
-                    continue;
-                }
-                switch (entryName) {
-                    case OOXML_PATHS.rootRels:
-                        model.globalRels = await this.parseRels(stream);
-                        break;
-                    case 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.xlSharedStrings:
-                        model.sharedStrings = new SharedStringsXform();
-                        await model.sharedStrings.parseStream(stream);
-                        break;
-                    case OOXML_PATHS.xlWorkbookRels:
-                        model.workbookRels = await this.parseRels(stream);
-                        break;
-                    case OOXML_PATHS.docPropsApp: {
-                        const appXform = new AppXform();
-                        const appProperties = await appXform.parseStream(stream);
-                        model.company = appProperties.company;
-                        model.manager = appProperties.manager;
-                        break;
-                    }
-                    case OOXML_PATHS.docPropsCore: {
-                        const coreXform = new CoreXform();
-                        const coreProperties = await coreXform.parseStream(stream);
-                        Object.assign(model, coreProperties);
-                        break;
-                    }
-                    case OOXML_PATHS.xlStyles:
-                        model.styles = new 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();
                     }
                 }
             }
@@ -498,6 +558,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
@@ -514,6 +583,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,
@@ -690,9 +760,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 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 RelationshipsXform();
@@ -767,24 +843,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("/"),
@@ -798,52 +857,10 @@ class XLSX {
                 const stream = isBinaryEntry
                     ? this.createBinaryStream(entry.data)
                     : this.createTextStream(this.bufferToString(entry.data));
-                const sheetNo = getWorksheetNoFromWorksheetPath(entryName);
-                if (sheetNo !== undefined) {
-                    await this._processWorksheetEntry(stream, model, sheetNo, options, entryName);
-                }
-                else {
-                    switch (entryName) {
-                        case OOXML_PATHS.rootRels:
-                            model.globalRels = await this.parseRels(stream);
-                            break;
-                        case 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.xlSharedStrings:
-                            model.sharedStrings = new SharedStringsXform();
-                            await model.sharedStrings.parseStream(stream);
-                            break;
-                        case OOXML_PATHS.xlWorkbookRels:
-                            model.workbookRels = await this.parseRels(stream);
-                            break;
-                        case OOXML_PATHS.docPropsApp: {
-                            const appXform = new AppXform();
-                            const appProperties = await appXform.parseStream(stream);
-                            model.company = appProperties.company;
-                            model.manager = appProperties.manager;
-                            break;
-                        }
-                        case OOXML_PATHS.docPropsCore: {
-                            const coreXform = new CoreXform();
-                            const coreProperties = await coreXform.parseStream(stream);
-                            Object.assign(model, coreProperties);
-                            break;
-                        }
-                        case OOXML_PATHS.xlStyles:
-                            model.styles = new 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);
                 }
             }
         }
@@ -853,11 +870,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 = getWorksheetNoFromWorksheetRelsPath(entryName);
-        if (worksheetRelsSheetNo !== undefined) {
-            const sheetNo = worksheetRelsSheetNo;
+    async _processDefaultEntry(stream, model, entryName, rawData) {
+        const sheetNo = getWorksheetNoFromWorksheetRelsPath(entryName);
+        if (sheetNo !== undefined) {
             await this._processWorksheetRelsEntry(stream, model, sheetNo);
             return true;
         }
@@ -869,6 +886,10 @@ class XLSX {
         const drawingName = 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 = getDrawingNameFromRelsPath(entryName);
@@ -923,8 +944,27 @@ class XLSX {
             await this._processPivotCacheRecordsEntry(stream, model, pivotCacheRecordsName);
             return true;
         }
+        // Store passthrough files (charts, etc.) for preservation
+        if (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
     // ===========================================================================
@@ -1067,14 +1107,46 @@ class XLSX {
     addDrawings(zip, model) {
         const drawingXform = new DrawingXform();
         const relsXform = new 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: drawingPath(drawing.name) });
-                xml = relsXform.toXml(drawing.rels);
-                zip.append(xml, { name: 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: 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: drawingPath(drawing.name) });
+                }
+                const relsXml = relsXform.toXml(drawing.rels);
+                zip.append(relsXml, { name: drawingRelsPath(drawing.name) });
             }
         });
     }
@@ -1089,6 +1161,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 PassthroughManager();
+        passthroughManager.fromRecord(model.passthrough || {});
+        passthroughManager.writeToZip(zip);
+    }
     addPivotTables(zip, model) {
         if (!model.pivotTables.length) {
             return;
@@ -1181,6 +1262,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 PassthroughManager();
+        passthroughManager.fromRecord(passthrough);
+        model.passthroughContentTypes = passthroughManager.getContentTypes();
     }
 }
 XLSX.RelType = RelType;

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

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

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

@@ -119,7 +119,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 = (0, csv_core_1.parseCsv)(str, options?.parserOptions);
         for (const row of rows) {
@@ -161,7 +161,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 csv_stream_1.CsvParserStream(options?.parserOptions);
         return new Promise((resolve, reject) => {
@@ -231,7 +231,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 csv_stream_1.CsvParserStream(options?.parserOptions);
         parser.on("data", (row) => worksheet.addRow(row.map(map)));

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

@@ -146,6 +146,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
 // ============================================================================
@@ -206,6 +212,8 @@ 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;
@@ -240,6 +248,14 @@ 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) {
@@ -655,9 +671,8 @@ 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
         };
@@ -1096,11 +1111,7 @@ 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 = "";
@@ -1109,11 +1120,7 @@ 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) {
@@ -1122,8 +1129,20 @@ 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 === "") {