deukpack 1.0.0

package/dist/protocols/ExcelProtocol.js

@@ -0,0 +1,639 @@
+"use strict";
+/**
+ * DeukPack Excel Protocol for TypeScript
+ * DpProtocol implementation that reads Excel data using numeric field-ID hierarchy headers.
+ *
+ * Excel layout (same as C# DpExcelProtocol):
+ *   Row 0: schema info
+ *   Row 1: HIERARCHY_ID (numeric field IDs, dot-separated: "1", "20", "20.1", "40.22.1")
+ *   Row 2: DATATYPE 득팩 표준 (int32, int64, list, list<T>, record, enum<T>, ...). 레거시 i64/rec/lst 도 수용.
+ *   Row 3: COLUMN_NAME (human-readable)
+ *   Row 4: COMMENT
+ *   Row 5+: DATA
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DpExcelProtocol = exports.FIRST_DATA_ROW = exports.COLUMN_NAME_ROW = exports.DATATYPE_ROW = exports.HIERARCHY_ID_ROW = void 0;
+exports.fromExcelRow = fromExcelRow;
+exports.fromExcelSheet = fromExcelSheet;
+const WireProtocol_1 = require("./WireProtocol");
+exports.HIERARCHY_ID_ROW = 1;
+exports.DATATYPE_ROW = 2;
+exports.COLUMN_NAME_ROW = 3;
+exports.FIRST_DATA_ROW = 5;
+class DpExcelProtocol {
+    constructor(sheet, dataRow = exports.FIRST_DATA_ROW, enumResolver) {
+        this._fieldIdToCol = new Map();
+        this._colDataType = new Map();
+        this._pathStack = [];
+        this._currentPath = '';
+        this._structStack = [];
+        this._pendingFields = [];
+        this._pendingIdx = 0;
+        this._listStack = [];
+        this._lastField = { id: 0, type: WireProtocol_1.DpWireType.Stop, col: -1, path: '' };
+        this._sheet = sheet;
+        this._dataRow = dataRow;
+        this._enumResolver = enumResolver ?? null;
+        this.buildColumnMap();
+    }
+    getDataRow() { return this._dataRow; }
+    setDataRow(row) { this._dataRow = row; }
+    // ─── Column Map ───
+    buildColumnMap() {
+        this._fieldIdToCol.clear();
+        this._colDataType.clear();
+        for (let col = 1; col <= this._sheet.lastColumn; col++) {
+            const hier = this._sheet.cellValue(exports.HIERARCHY_ID_ROW, col)?.trim();
+            if (!hier)
+                break;
+            const dt = this._sheet.cellValue(exports.DATATYPE_ROW, col)?.trim() ?? '';
+            this._fieldIdToCol.set(hier, col);
+            this._colDataType.set(col, dt);
+        }
+    }
+    collectChildFields(parentPath) {
+        const entries = new Map();
+        const prefix = parentPath ? parentPath + '.' : '';
+        for (const [path, col] of this._fieldIdToCol) {
+            let remainder;
+            if (prefix) {
+                if (!path.startsWith(prefix))
+                    continue;
+                remainder = path.substring(prefix.length);
+            }
+            else {
+                remainder = path;
+            }
+            const dotPos = remainder.indexOf('.');
+            const firstSeg = dotPos >= 0 ? remainder.substring(0, dotPos) : remainder;
+            const fieldId = parseInt(firstSeg, 10);
+            if (isNaN(fieldId))
+                continue;
+            const childPath = prefix ? prefix + firstSeg : firstSeg;
+            const isExactColumn = (path === childPath);
+            if (isExactColumn) {
+                const dt = this._colDataType.get(col) ?? '';
+                entries.set(fieldId, { id: fieldId, type: dataTypeToDpWireType(dt), col, path: childPath });
+            }
+            else if (!entries.has(fieldId)) {
+                const explicitCol = this._fieldIdToCol.get(childPath);
+                if (explicitCol !== undefined) {
+                    const dt = this._colDataType.get(explicitCol) ?? '';
+                    entries.set(fieldId, { id: fieldId, type: dataTypeToDpWireType(dt), col: explicitCol, path: childPath });
+                }
+                else {
+                    entries.set(fieldId, { id: fieldId, type: WireProtocol_1.DpWireType.Struct, col: -1, path: childPath });
+                }
+            }
+        }
+        const result = Array.from(entries.values());
+        result.sort((a, b) => a.id - b.id);
+        return result;
+    }
+    // ─── Read - Struct ───
+    readStructBegin() {
+        if (this._listStack.length > 0) {
+            const ls = this._listStack[this._listStack.length - 1];
+            if (ls.structDepth === 0) {
+                this._pathStack.push(this._currentPath);
+                this._dataRow = ls.startRow + ls.currentElement;
+                ls.currentElement++;
+            }
+            ls.structDepth++;
+        }
+        if (this._pendingFields.length > 0 || this._pendingIdx > 0) {
+            this._structStack.push({ fields: this._pendingFields, index: this._pendingIdx });
+        }
+        this._pendingFields = this.collectChildFields(this._currentPath);
+        this._pendingIdx = 0;
+        return { name: 'record' };
+    }
+    readStructEnd() {
+        if (this._listStack.length > 0) {
+            const ls = this._listStack[this._listStack.length - 1];
+            ls.structDepth--;
+        }
+        if (this._pathStack.length > 0) {
+            this._currentPath = this._pathStack.pop();
+        }
+        if (this._structStack.length > 0) {
+            const s = this._structStack.pop();
+            this._pendingFields = s.fields;
+            this._pendingIdx = s.index;
+        }
+    }
+    readFieldBegin() {
+        while (this._pendingIdx < this._pendingFields.length) {
+            const entry = this._pendingFields[this._pendingIdx];
+            this._pendingIdx++;
+            if (entry.type !== WireProtocol_1.DpWireType.Struct && entry.type !== WireProtocol_1.DpWireType.List &&
+                entry.type !== WireProtocol_1.DpWireType.Map && entry.type !== WireProtocol_1.DpWireType.Set) {
+                if (entry.col <= 0 || this._sheet.isCellEmpty(this._dataRow, entry.col))
+                    continue;
+            }
+            if (entry.type === WireProtocol_1.DpWireType.Struct && !this.hasAnyChildData(entry.path))
+                continue;
+            if (entry.type === WireProtocol_1.DpWireType.List && this.countListElements(entry) === 0)
+                continue;
+            this._lastField = entry;
+            if (entry.type === WireProtocol_1.DpWireType.Struct) {
+                this._pathStack.push(this._currentPath);
+                this._currentPath = entry.path;
+            }
+            return { name: entry.path, type: entry.type, id: entry.id };
+        }
+        return { name: '', type: WireProtocol_1.DpWireType.Stop, id: 0 };
+    }
+    readFieldEnd() { }
+    hasAnyChildData(parentPath) {
+        const prefix = parentPath + '.';
+        for (const [path, col] of this._fieldIdToCol) {
+            if (!path.startsWith(prefix))
+                continue;
+            const dt = this._colDataType.get(col);
+            if (dt) {
+                const lower = dt.toLowerCase();
+                if (lower === 'rec' || lower === 'record' || lower.startsWith('lst') || lower.startsWith('list') ||
+                    lower.startsWith('set') || lower.startsWith('map'))
+                    continue;
+            }
+            if (!this._sheet.isCellEmpty(this._dataRow, col))
+                return true;
+        }
+        return false;
+    }
+    // ─── Read - List ───
+    countListElements(listField) {
+        const rootCol = listField.col;
+        const prefix = listField.path + '.';
+        let count = 0;
+        const metaId = this._sheet.cellValue(this._dataRow, 1) ?? '';
+        for (let r = this._dataRow; r <= this._sheet.lastRow; r++) {
+            if (r > this._dataRow) {
+                const rid = this._sheet.cellValue(r, 1) ?? '';
+                if (rid && rid !== metaId)
+                    break;
+            }
+            let hasData = false;
+            if (rootCol > 0 && !this._sheet.isCellEmpty(r, rootCol))
+                hasData = true;
+            if (!hasData) {
+                for (const [p, c] of this._fieldIdToCol) {
+                    if (p.startsWith(prefix) && !this._sheet.isCellEmpty(r, c)) {
+                        hasData = true;
+                        break;
+                    }
+                }
+            }
+            if (hasData)
+                count++;
+            else if (count > 0)
+                break;
+        }
+        return count;
+    }
+    inferListElementType(listEntry) {
+        const dt = (listEntry.col > 0 ? this._colDataType.get(listEntry.col) : undefined) ?? 'list';
+        const lt = dt.indexOf('<');
+        if (lt >= 0) {
+            return dataTypeToDpWireType(extractContainerElemType(dt));
+        }
+        const prefix = listEntry.path + '.';
+        const childIds = new Map();
+        for (const [path, col] of this._fieldIdToCol) {
+            if (!path.startsWith(prefix))
+                continue;
+            const remainder = path.substring(prefix.length);
+            const dotPos = remainder.indexOf('.');
+            const firstSeg = dotPos >= 0 ? remainder.substring(0, dotPos) : remainder;
+            const fid = parseInt(firstSeg, 10);
+            if (isNaN(fid))
+                continue;
+            const childPath = listEntry.path + '.' + firstSeg;
+            const isExactChild = (path === childPath);
+            if (isExactChild) {
+                const childDt = this._colDataType.get(col) ?? '';
+                childIds.set(fid, { dt: childDt, col, path: childPath });
+            }
+            else if (!childIds.has(fid)) {
+                const explicitCol = this._fieldIdToCol.get(childPath);
+                if (explicitCol !== undefined) {
+                    const childDt = this._colDataType.get(explicitCol) ?? '';
+                    childIds.set(fid, { dt: childDt, col: explicitCol, path: childPath });
+                }
+                else {
+                    childIds.set(fid, { dt: 'record', col: -1, path: childPath });
+                }
+            }
+        }
+        if (childIds.size === 0)
+            return WireProtocol_1.DpWireType.Struct;
+        if (childIds.size === 1) {
+            for (const c of childIds.values()) {
+                const childDpWireType = dataTypeToDpWireType(c.dt);
+                if (childDpWireType !== WireProtocol_1.DpWireType.Struct && childDpWireType !== WireProtocol_1.DpWireType.List &&
+                    childDpWireType !== WireProtocol_1.DpWireType.Map && childDpWireType !== WireProtocol_1.DpWireType.Set) {
+                    return childDpWireType;
+                }
+            }
+        }
+        return WireProtocol_1.DpWireType.Struct;
+    }
+    readListBegin() {
+        const entry = this._lastField;
+        const elemDpWireType = this.inferListElementType(entry);
+        const count = this.countListElements(entry);
+        let primitiveElemCol = -1;
+        if (elemDpWireType !== WireProtocol_1.DpWireType.Struct) {
+            const prefix = entry.path + '.';
+            for (const [p, c] of this._fieldIdToCol) {
+                if (p.startsWith(prefix)) {
+                    primitiveElemCol = c;
+                    break;
+                }
+            }
+        }
+        const state = {
+            startRow: this._dataRow,
+            currentElement: 0,
+            count,
+            elementType: elemDpWireType,
+            rootCol: entry.col,
+            listPath: entry.path,
+            savedDataRow: this._dataRow,
+            structDepth: 0,
+            primitiveElemCol
+        };
+        this._listStack.push(state);
+        if (primitiveElemCol > 0) {
+            this._lastField = { id: 0, type: elemDpWireType, col: primitiveElemCol, path: entry.path };
+        }
+        this._pathStack.push(this._currentPath);
+        this._currentPath = entry.path;
+        return { elementType: elemDpWireType, count };
+    }
+    readListEnd() {
+        if (this._listStack.length > 0) {
+            const state = this._listStack.pop();
+            this._dataRow = state.savedDataRow;
+        }
+        if (this._pathStack.length > 0) {
+            this._currentPath = this._pathStack.pop();
+        }
+    }
+    advanceListElementIfPrimitive() {
+        if (this._listStack.length === 0)
+            return;
+        const state = this._listStack[this._listStack.length - 1];
+        if (state.structDepth > 0)
+            return;
+        this._dataRow = state.startRow + state.currentElement;
+        state.currentElement++;
+    }
+    // ─── Read - Primitives ───
+    readBool() {
+        this.advanceListElementIfPrimitive();
+        const val = this.readCurrentCellValue();
+        if (!val)
+            return false;
+        if (val === '1')
+            return true;
+        if (val === '0')
+            return false;
+        return val.toLowerCase() === 'true';
+    }
+    readByte() {
+        this.advanceListElementIfPrimitive();
+        const val = this.readCurrentCellValue();
+        if (!val)
+            return 0;
+        return parseInt(val.split(':')[0].trim(), 10) || 0;
+    }
+    readI16() {
+        this.advanceListElementIfPrimitive();
+        const val = this.readCurrentCellValue();
+        if (!val)
+            return 0;
+        return parseInt(val.split(':')[0].trim(), 10) || 0;
+    }
+    readI32() {
+        this.advanceListElementIfPrimitive();
+        const val = this.readCurrentCellValue();
+        if (!val)
+            return 0;
+        const token = val.split(':')[0].trim();
+        const num = parseInt(token, 10);
+        if (!isNaN(num))
+            return num;
+        return this.resolveEnumName(token);
+    }
+    readI64() {
+        this.advanceListElementIfPrimitive();
+        const val = this.readCurrentCellValue();
+        if (!val)
+            return 0n;
+        const token = val.split(':')[0].trim();
+        try {
+            return BigInt(token);
+        }
+        catch {
+            return 0n;
+        }
+    }
+    readDouble() {
+        this.advanceListElementIfPrimitive();
+        const val = this.readCurrentCellValue();
+        return parseFloat(val) || 0;
+    }
+    readString() {
+        this.advanceListElementIfPrimitive();
+        return (this.readCurrentCellValue() ?? '').trim();
+    }
+    readBinary() {
+        this.advanceListElementIfPrimitive();
+        const val = this.readCurrentCellValue();
+        if (!val)
+            return new Uint8Array(0);
+        const encoder = new TextEncoder();
+        return encoder.encode(val);
+    }
+    readSetBegin() {
+        const lb = this.readListBegin();
+        return { elementType: lb.elementType, count: lb.count };
+    }
+    readSetEnd() { this.readListEnd(); }
+    readMapBegin() {
+        return { keyType: WireProtocol_1.DpWireType.I64, valueType: WireProtocol_1.DpWireType.Struct, count: 0 };
+    }
+    readMapEnd() { }
+    readCurrentCellValue() {
+        if (this._lastField.col <= 0)
+            return '';
+        return this._sheet.cellValue(this._dataRow, this._lastField.col) ?? '';
+    }
+    resolveEnumName(name) {
+        if (!this._enumResolver)
+            return 0;
+        if (this._lastField.col <= 0)
+            return 0;
+        const dt = this._colDataType.get(this._lastField.col);
+        if (!dt)
+            return 0;
+        const enumTypeName = extractContainerElemType(dt);
+        if (!enumTypeName || enumTypeName === 'rec' || enumTypeName === 'record')
+            return 0;
+        return this._enumResolver(enumTypeName, name) ?? 0;
+    }
+    // ─── Write (placeholder) ───
+    writeStructBegin(_s) { }
+    writeStructEnd() { }
+    writeFieldBegin(_f) { }
+    writeFieldEnd() { }
+    writeFieldStop() { }
+    writeBool(_b) { }
+    writeByte(_b) { }
+    writeI16(_i16) { }
+    writeI32(_i32) { }
+    writeI64(_i64) { }
+    writeDouble(_d) { }
+    writeString(_s) { }
+    writeBinary(_b) { }
+    writeListBegin(_list) { }
+    writeListEnd() { }
+    writeSetBegin(_set) { }
+    writeSetEnd() { }
+    writeMapBegin(_map) { }
+    writeMapEnd() { }
+}
+exports.DpExcelProtocol = DpExcelProtocol;
+// ─── Helpers ───
+function dataTypeToDpWireType(dt) {
+    if (!dt)
+        return WireProtocol_1.DpWireType.String;
+    const lower = dt.toLowerCase();
+    if (lower === 'int64' || lower === 'i64')
+        return WireProtocol_1.DpWireType.I64;
+    if (lower === 'int32' || lower === 'i32')
+        return WireProtocol_1.DpWireType.I32;
+    if (lower === 'int16' || lower === 'i16')
+        return WireProtocol_1.DpWireType.I16;
+    if (lower === 'int8' || lower === 'i8')
+        return WireProtocol_1.DpWireType.Byte;
+    if (lower === 'float')
+        return WireProtocol_1.DpWireType.Double;
+    if (lower === 'str')
+        return WireProtocol_1.DpWireType.String;
+    if (lower === 'dbl')
+        return WireProtocol_1.DpWireType.Double;
+    if (lower === 'tf')
+        return WireProtocol_1.DpWireType.Bool;
+    if (lower === 'rec' || lower === 'record')
+        return WireProtocol_1.DpWireType.Struct;
+    if (lower.startsWith('lst') || lower.startsWith('list'))
+        return WireProtocol_1.DpWireType.List;
+    if (lower.startsWith('set'))
+        return WireProtocol_1.DpWireType.Set;
+    if (lower.startsWith('map'))
+        return WireProtocol_1.DpWireType.Map;
+    if (lower.startsWith('enum'))
+        return WireProtocol_1.DpWireType.I32;
+    return WireProtocol_1.DpWireType.String;
+}
+function extractContainerElemType(dt) {
+    const lt = dt.indexOf('<');
+    const gt = dt.lastIndexOf('>');
+    if (lt >= 0 && gt > lt)
+        return dt.substring(lt + 1, gt).trim();
+    return 'record';
+}
+/**
+ * Schema-driven Excel reader for plain JS objects (no DpProtocol / generated Read()).
+ * Used by meta editor JS runtime to create objects from Excel sheets.
+ */
+function fromExcelRow(schema, sheet, row, schemas, enumMap) {
+    if (!schema || schema.type !== 'Struct' || !schema.fields)
+        return {};
+    const colMap = buildColMap(sheet);
+    const result = {};
+    const fields = schema.fields;
+    for (const fid of Object.keys(fields)) {
+        const field = fields[fid];
+        const val = readFieldValue(field, fid, colMap, sheet, row, schemas, enumMap, '');
+        if (val !== undefined && val !== null) {
+            result[field['name']] = val;
+        }
+    }
+    return result;
+}
+/**
+ * Read all records from an Excel sheet.
+ * Returns a map of metaId → object (matching the container.Infos structure).
+ */
+function fromExcelSheet(schema, sheet, schemas, enumMap, firstDataRow = exports.FIRST_DATA_ROW) {
+    const result = new Map();
+    for (let row = firstDataRow; row <= sheet.lastRow; row++) {
+        const metaIdStr = sheet.cellValue(row, 1);
+        if (!metaIdStr)
+            continue;
+        const metaId = parseInt(metaIdStr.split(':')[0].trim(), 10);
+        if (isNaN(metaId))
+            continue;
+        const obj = fromExcelRow(schema, sheet, row, schemas, enumMap);
+        result.set(metaId, obj);
+    }
+    return result;
+}
+function buildColMap(sheet) {
+    const map = new Map();
+    for (let col = 1; col <= sheet.lastColumn; col++) {
+        const hier = sheet.cellValue(exports.HIERARCHY_ID_ROW, col)?.trim();
+        if (!hier)
+            break;
+        const dt = sheet.cellValue(exports.DATATYPE_ROW, col)?.trim() ?? '';
+        map.set(hier, { col, datatype: dt });
+    }
+    return map;
+}
+function readFieldValue(field, fieldId, colMap, sheet, row, schemas, enumMap, parentPath) {
+    const fieldPath = parentPath ? parentPath + '.' + fieldId : fieldId;
+    const type = field['type'];
+    const typeName = field['typeName'];
+    if (type === 'Struct') {
+        const childSchema = schemas[typeName];
+        if (!childSchema?.['fields'])
+            return undefined;
+        const obj = {};
+        let hasData = false;
+        const childFields = childSchema['fields'];
+        for (const cid of Object.keys(childFields)) {
+            const cf = childFields[cid];
+            const val = readFieldValue(cf, cid, colMap, sheet, row, schemas, enumMap, fieldPath);
+            if (val !== undefined && val !== null) {
+                obj[cf['name']] = val;
+                hasData = true;
+            }
+        }
+        return hasData ? obj : undefined;
+    }
+    if (type === 'List' || type === 'Set') {
+        return readListValue(fieldPath, typeName, colMap, sheet, row, schemas, enumMap);
+    }
+    const entry = colMap.get(fieldPath);
+    if (!entry)
+        return undefined;
+    if (sheet.isCellEmpty(row, entry.col))
+        return undefined;
+    const raw = sheet.cellValue(row, entry.col) ?? '';
+    return parsePrimitiveValue(type, raw, entry.datatype, enumMap);
+}
+function readListValue(listPath, typeName, colMap, sheet, row, schemas, enumMap) {
+    const prefix = listPath + '.';
+    const metaId = sheet.cellValue(row, 1) ?? '';
+    let count = 0;
+    for (let r = row; r <= sheet.lastRow; r++) {
+        if (r > row) {
+            const rid = sheet.cellValue(r, 1) ?? '';
+            if (rid && rid !== metaId)
+                break;
+        }
+        let hasData = false;
+        for (const [p, e] of colMap) {
+            if ((p === listPath || p.startsWith(prefix)) && !sheet.isCellEmpty(r, e.col)) {
+                hasData = true;
+                break;
+            }
+        }
+        if (hasData)
+            count++;
+        else if (count > 0)
+            break;
+    }
+    if (count === 0)
+        return undefined;
+    const elemMatch = typeName.match(/^(?:list|set)<(.+)>$/i);
+    const elemTypeName = elemMatch ? elemMatch[1] : (typeName && typeName.trim()) || 'record';
+    const primitiveTypes = ['int32', 'int64', 'int16', 'int8', 'float', 'double', 'string', 'bool', 'byte'];
+    const elemIsPrimitive = primitiveTypes.includes(elemTypeName);
+    const result = [];
+    for (let i = 0; i < count; i++) {
+        const elemRow = row + i;
+        if (elemIsPrimitive) {
+            for (const [p, e] of colMap) {
+                if (p.startsWith(prefix)) {
+                    const raw = sheet.cellValue(elemRow, e.col) ?? '';
+                    result.push(parsePrimitiveValue(mapSchemaTypeToWire(elemTypeName), raw, e.datatype, enumMap));
+                    break;
+                }
+            }
+        }
+        else {
+            const elemSchema = schemas[elemTypeName];
+            if (elemSchema?.['fields']) {
+                const obj = {};
+                const childFields = elemSchema['fields'];
+                for (const cid of Object.keys(childFields)) {
+                    const cf = childFields[cid];
+                    const val = readFieldValue(cf, cid, colMap, sheet, elemRow, schemas, enumMap, listPath);
+                    if (val !== undefined && val !== null)
+                        obj[cf['name']] = val;
+                }
+                result.push(obj);
+            }
+            else {
+                const obj = {};
+                for (const [p, e] of colMap) {
+                    if (!p.startsWith(prefix))
+                        continue;
+                    const remainder = p.substring(prefix.length);
+                    if (remainder.includes('.'))
+                        continue;
+                    if (!sheet.isCellEmpty(elemRow, e.col)) {
+                        obj[remainder] = sheet.cellValue(elemRow, e.col);
+                    }
+                }
+                result.push(obj);
+            }
+        }
+    }
+    return result.length > 0 ? result : undefined;
+}
+function parsePrimitiveValue(type, raw, datatype, enumMap) {
+    if (!raw && raw !== '0')
+        return type === 'String' ? '' : undefined;
+    const token = raw.split(':')[0].trim();
+    switch (type) {
+        case 'Bool': return token === '1' || token.toLowerCase() === 'true';
+        case 'Byte':
+        case 'I16':
+        case 'I32': {
+            const n = parseInt(token, 10);
+            if (!isNaN(n))
+                return n;
+            if (enumMap && datatype.startsWith('enum')) {
+                const enumTypeName = extractContainerElemType(datatype);
+                const enumDef = enumMap[enumTypeName];
+                const values = enumDef?.['values'];
+                if (values) {
+                    const v = values[token];
+                    if (v !== undefined)
+                        return v;
+                }
+            }
+            return 0;
+        }
+        case 'I64': return parseInt(token, 10) || 0;
+        case 'Double': return parseFloat(raw) || 0;
+        case 'String': return raw.trim();
+        default: return raw.trim();
+    }
+}
+function mapSchemaTypeToWire(tn) {
+    const m = {
+        'int32': 'I32', 'int64': 'I64', 'int16': 'I16', 'int8': 'Byte',
+        'byte': 'Byte', 'float': 'Double',
+        'double': 'Double', 'dbl': 'Double', 'string': 'String', 'str': 'String',
+        'bool': 'Bool', 'tf': 'Bool'
+    };
+    return m[tn] ?? 'Struct';
+}
+//# sourceMappingURL=ExcelProtocol.js.map