hwpkit-dev 0.0.1 → 0.0.3

package/src/model/doc-tree.ts

@@ -44,7 +44,7 @@ export interface LinkNode {
 export interface ParaNode {
   tag: 'para';
   props: ParaProps;
-  kids: (SpanNode | ImgNode | LinkNode)[];
+  kids: (SpanNode | ImgNode | LinkNode | GridNode)[];
 }
 
 // ─── 표(Grid) 노드 ─────────────────────────────────────────
@@ -53,10 +53,10 @@ export interface CellNode {
   cs: number;
   rs: number;
   props: CellProps;
-  kids: ParaNode[];
+  kids: (ParaNode | GridNode)[];
 }
 
-export interface RowNode  { tag: 'row'; kids: CellNode[] }
+export interface RowNode  { tag: 'row'; kids: CellNode[]; heightPt?: number }
 
 export interface GridNode {
   tag: 'grid';
@@ -71,8 +71,16 @@ export interface SheetNode {
   tag: 'sheet';
   dims: PageDims;
   kids: ContentNode[];
-  header?: ParaNode[];
-  footer?: ParaNode[];
+  headers?: {
+    default?: ParaNode[];
+    first?: ParaNode[];
+    even?: ParaNode[];
+  };
+  footers?: {
+    default?: ParaNode[];
+    first?: ParaNode[];
+    even?: ParaNode[];
+  };
 }
 
 // ─── 루트 노드 ─────────────────────────────────────────────

package/src/pipeline/Pipeline.ts

@@ -1,6 +1,7 @@
 import type { DocRoot } from '../model/doc-tree';
 import type { Outcome } from '../contract/result';
-import { fail } from '../contract/result';
+import type { EncoderOptions } from '../contract/encoder';
+import { succeed, fail } from '../contract/result';
 import { registry } from './registry';
 
 // Side-effect imports: auto-register all decoders and encoders
@@ -8,9 +9,12 @@ import '../decoders/hwpx/HwpxDecoder';
 import '../decoders/hwp/HwpScanner';
 import '../decoders/docx/DocxDecoder';
 import '../decoders/md/MdDecoder';
+import '../decoders/html/HtmlDecoder';
 import '../encoders/hwpx/HwpxEncoder';
 import '../encoders/docx/DocxEncoder';
 import '../encoders/md/MdEncoder';
+import '../encoders/html/HtmlEncoder';
+import '../encoders/hwp/HwpEncoder';
 
 export class Pipeline {
   private constructor(private raw: Uint8Array, private srcFmt: string) {}
@@ -35,7 +39,7 @@ export class Pipeline {
   }
 
   /** 목표 포맷으로 변환 */
-  async to(targetFmt: string): Promise<Outcome<Uint8Array>> {
+  async to(targetFmt: string, options?: EncoderOptions): Promise<Outcome<Uint8Array>> {
     const decoder = registry.getDecoder(this.srcFmt);
     const encoder = registry.getEncoder(targetFmt);
 
@@ -45,7 +49,7 @@ export class Pipeline {
     const docResult = await decoder.decode(this.raw);
     if (!docResult.ok) return docResult;
 
-    const encResult = await encoder.encode(docResult.data);
+    const encResult = await encoder.encode(docResult.data, options);
     if (!encResult.ok) return { ...encResult, warns: [...docResult.warns, ...encResult.warns] };
 
     return { ...encResult, warns: [...docResult.warns, ...encResult.warns] };
@@ -60,8 +64,21 @@ export class Pipeline {
 }
 
 function detectFormat(data: Uint8Array): string {
-  if (data[0] === 0x50 && data[1] === 0x4B) return 'zip';
+  // HWP 파일 (OLE Compound Document)
   if (data[0] === 0xD0 && data[1] === 0xCF && data[2] === 0x11 && data[3] === 0xE0) return 'hwp';
+
+  // ZIP 기반 파일 (DOCX, HWPX)
+  if (data[0] === 0x50 && data[1] === 0x4B) {
+    // DOCX 는 [Content_Types].xml 에 application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml 이 있음
+    // HWPX 는 application/ha-xml-core-document
+    const str = new TextDecoder('utf-8', { fatal: false }).decode(data.slice(0, 4096));
+    if (str.includes('wordprocessingml')) return 'docx';
+    if (str.includes('ha-xml')) return 'hwpx';
+    if (str.includes('hwpml/')) return 'hwpx';
+    if (str.includes('word/')) return 'docx';
+    return 'hwpx'; // 기본값
+  }
+
   return 'md';
 }
 

package/src/pipeline/registry.ts

@@ -5,8 +5,19 @@ class FormatRegistry {
   private decoders = new Map<string, Decoder>();
   private encoders = new Map<string, Encoder>();
 
-  registerDecoder(d: Decoder): void { this.decoders.set(d.format, d); }
-  registerEncoder(e: Encoder): void { this.encoders.set(e.format, e); }
+  registerDecoder(d: Decoder): void {
+    this.decoders.set(d.format, d);
+    if (d.aliases) {
+      for (const alias of d.aliases) this.decoders.set(alias, d);
+    }
+  }
+
+  registerEncoder(e: Encoder): void {
+    this.encoders.set(e.format, e);
+    if (e.aliases) {
+      for (const alias of e.aliases) this.encoders.set(alias, e);
+    }
+  }
 
   getDecoder(fmt: string): Decoder | undefined { return this.decoders.get(fmt); }
   getEncoder(fmt: string): Encoder | undefined { return this.encoders.get(fmt); }

package/src/safety/StyleBridge.ts

@@ -50,17 +50,39 @@ const ALIGN_MAP: Record<string, Align> = {
   start: 'left', end: 'right',
 };
 export function safeAlign(raw?: string): Align {
-  return ALIGN_MAP[raw ?? ''] ?? 'justify';
+  return ALIGN_MAP[raw ?? ''] ?? 'left';
 }
 
 // ─── 테두리 정규화 ─────────────────────────────────────────
 const HWPX_STROKE: Record<string, StrokeKind> = {
-  SOLID: 'solid', NONE: 'none', DASH: 'dash', DOT: 'dot',
-  DOUBLE: 'double', LONG_DASH: 'dash', DASH_DOT: 'dash',
+  SOLID: "solid",
+  NONE: "none",
+  DASH: "dash",
+  DOT: "dot",
+  DOUBLE: "double",
+  LONG_DASH: "dash",
+  DASH_DOT: "dashDot",
+  DASH_DOT_DOT: "dashDotDot",
+  THICK_THIN: "double",
+  THIN_THICK: "double",
+  TRIPLE: "double",
 };
 const DOCX_STROKE: Record<string, StrokeKind> = {
-  single: 'solid', none: 'none', nil: 'none', dashed: 'dash',
-  dotted: 'dot', double: 'double', wave: 'solid',
+  single: "solid",
+  none: "none",
+  nil: "none",
+  dashed: "dash",
+  dotted: "dot",
+  double: "double",
+  dotDash: "dashDot",
+  dotDotDash: "dashDotDot",
+  thickThin: "double",
+  thinThick: "double",
+  triple: "double",
+  wave: "wave",
+  dashDotStroked: "dashDot",
+  threeDEmboss: "solid",
+  threeDEngrave: "solid",
 };
 
 export function safeStrokeHwpx(type?: string, w?: number, c?: string): Stroke {
@@ -81,14 +103,37 @@ export function safeStrokeDocx(val?: string, sz?: number, c?: string): Stroke {
 
 // ─── 폰트 정규화 ───────────────────────────────────────────
 const FONT_MAP: Record<string, string> = {
+  // 맑은 고딕 계열
   '맑은 고딕': 'Malgun Gothic',
+  '맑은고딕': 'Malgun Gothic',
+  // 바탕 계열 (serif)
   '바탕': 'Batang',
+  '바탕체': 'BatangChe',
+  '한컴바탕': 'Batang',
+  '함초롬바탕': 'Batang',
+  'HY신명조': 'Batang',
+  'HY견명조': 'Batang',
+  'HY그래픽': 'Batang',
+  '궁서': 'Gungsuh',
+  '궁서체': 'GungsuhChe',
+  // 고딕 계열 (sans-serif)
   '돋움': 'Dotum',
+  '돋움체': 'DotumChe',
   '굴림': 'Gulim',
-  '한컴바탕': 'Batang',
+  '굴림체': 'GulimChe',
   '한컴돋움': 'Malgun Gothic',
-  '함초롬바탕': 'Batang',
   '함초롬돋움': 'Malgun Gothic',
+  'HY견고딕': 'Malgun Gothic',
+  'HY중고딕': 'Malgun Gothic',
+  'HY헤드라인M': 'Malgun Gothic',
+  'HY강B': 'Malgun Gothic',
+  'HY나무M': 'Malgun Gothic',
+  'HY목각파임B': 'Malgun Gothic',
+  'HY엽서M': 'Malgun Gothic',
+  'HY엽서L': 'Malgun Gothic',
+  // 나눔 계열
+  '나눔고딕': 'Malgun Gothic',
+  '나눔명조': 'Batang',
 };
 export function safeFont(raw?: string): string {
   return FONT_MAP[raw ?? ''] ?? raw ?? 'Malgun Gothic';

package/src/toolkit/ArchiveKit.ts

@@ -18,6 +18,62 @@ export const ArchiveKit = {
     const files = new Map<string, Uint8Array>();
     const view = new DataView(zipData.buffer, zipData.byteOffset, zipData.byteLength);
 
+    // Find EOCD by scanning backward from end (supports ZIP comment up to 64KB)
+    let eocdOffset = -1;
+    const searchStart = Math.max(0, zipData.length - 65558);
+    for (let i = zipData.length - 22; i >= searchStart; i--) {
+      if (view.getUint32(i, true) === 0x06054b50) {
+        eocdOffset = i;
+        break;
+      }
+    }
+
+    if (eocdOffset !== -1) {
+      // Parse central directory — always has correct sizes even with data descriptors
+      const entryCount      = view.getUint16(eocdOffset + 10, true);
+      const centralDirOffset = view.getUint32(eocdOffset + 16, true);
+
+      let cdOffset = centralDirOffset;
+      for (let i = 0; i < entryCount; i++) {
+        if (cdOffset + 46 > zipData.length) break;
+        if (view.getUint32(cdOffset, true) !== 0x02014b50) break;
+
+        const compressionMethod  = view.getUint16(cdOffset + 10, true);
+        const compressedSize     = view.getUint32(cdOffset + 20, true);
+        const uncompressedSize   = view.getUint32(cdOffset + 24, true);
+        const fileNameLength     = view.getUint16(cdOffset + 28, true);
+        const extraLength        = view.getUint16(cdOffset + 30, true);
+        const commentLength      = view.getUint16(cdOffset + 32, true);
+        const localHeaderOffset  = view.getUint32(cdOffset + 42, true);
+
+        const nameBytes = zipData.subarray(cdOffset + 46, cdOffset + 46 + fileNameLength);
+        const name = new TextDecoder('utf-8').decode(nameBytes);
+        cdOffset += 46 + fileNameLength + extraLength + commentLength;
+
+        if (name.endsWith('/')) continue; // directory entry
+
+        // Read actual data using the local header offset from central directory
+        const localFnLen    = view.getUint16(localHeaderOffset + 26, true);
+        const localExtraLen = view.getUint16(localHeaderOffset + 28, true);
+        const dataOffset    = localHeaderOffset + 30 + localFnLen + localExtraLen;
+
+        let fileData: Uint8Array;
+        if (compressionMethod === 0) {
+          fileData = zipData.subarray(dataOffset, dataOffset + uncompressedSize);
+        } else if (compressionMethod === 8) {
+          const compressed = zipData.subarray(dataOffset, dataOffset + compressedSize);
+          fileData = pako.inflateRaw(compressed);
+        } else {
+          throw new Error(`Unsupported ZIP compression method: ${compressionMethod}`);
+        }
+
+        files.set(name, new Uint8Array(fileData));
+      }
+
+      return files;
+    }
+
+    // Fallback: scan local headers sequentially (no EOCD found — truncated ZIP)
     let offset = 0;
     while (offset < zipData.length - 4) {
       const sig = view.getUint32(offset, true);

package/src/toolkit/StyleMapper.ts

@@ -0,0 +1,221 @@
+/**
+ * 스타일 매핑 유틸리티
+ *
+ * 다양한 문서 포맷 간의 스타일 (폰트, 색상, 정렬, 테두리 등) 을 매핑합니다.
+ */
+
+import type { Align, StrokeKind, Stroke, TextProps, ParaProps } from '../model/doc-props';
+
+// ─── 폰트 매핑 ───────────────────────────────────────────
+
+/** 한글 폰트 ↔ 영문 폰트 매핑 */
+export const FONT_MAP: Record<string, string> = {
+  // 한글 → 영문
+  '맑은 고딕': 'Malgun Gothic',
+  '바탕': 'Batang',
+  '돋움': 'Dotum',
+  '굴림': 'Gulim',
+  '한컴바탕': 'Batang',
+  '한컴돋움': 'Malgun Gothic',
+  '함초롬바탕': 'Batang',
+  '함초롬돋움': 'Malgun Gothic',
+
+  // 영문 → 한글 (역매핑)
+  'Malgun Gothic': '맑은 고딕',
+  'Batang': '바탕',
+  'Dotum': '돋움',
+  'Gulim': '굴림',
+};
+
+/** 폰트를 한글로 변환 (한컴 호환성) */
+export function fontToKorean(font?: string): string {
+  if (!font) return '맑은 고딕';
+  return FONT_MAP[font] ?? font;
+}
+
+/** 폰트를 영문으로 변환 (DOCX 호환성) */
+export function fontToEnglish(font?: string): string {
+  if (!font) return 'Malgun Gothic';
+
+  // 이미 영문 폰트라면 그대로 반환
+  if (/^[a-zA-Z\s]+$/.test(font)) {
+    return FONT_MAP[font] ?? font;
+  }
+  // 한글 폰트라면 영문으로 변환
+  return FONT_MAP[font] ?? 'Malgun Gothic';
+}
+
+// ─── 색상 매핑 ───────────────────────────────────────────
+
+/** 색상을 안전한 6 자리 hex 문자열로 변환 */
+export function safeHex(raw: string | number | null | undefined): string | undefined {
+  if (raw == null) return undefined;
+
+  if (typeof raw === 'number') {
+    if (raw <= 0) return '000000';
+    if (raw >= 0xFFFFFF) return undefined;
+    return raw.toString(16).padStart(6, '0').toUpperCase();
+  }
+
+  let s = String(raw).replace(/^#/, '').toUpperCase();
+
+  // 3 자리 hex → 6 자리 확장
+  if (/^[0-9A-F]{3}$/.test(s)) {
+    s = s[0] + s[0] + s[1] + s[1] + s[2] + s[2];
+  }
+
+  // 6 자리 hex 검증
+  if (/^[0-9A-F]{6}$/.test(s)) {
+    return s;
+  }
+
+  // 특수값 처리
+  if (s === 'AUTO' || s === 'NONE' || s === 'TRANSPARENT') {
+    return undefined;
+  }
+
+  return undefined;
+}
+
+// ─── 정렬 매핑 ───────────────────────────────────────────
+
+/** 정렬 값 정규화 */
+const ALIGN_MAP: Record<string, Align> = {
+  // 대문자
+  LEFT: 'left',
+  CENTER: 'center',
+  RIGHT: 'right',
+  JUSTIFY: 'justify',
+  BOTH: 'justify',
+  DISTRIBUTE: 'justify',
+
+  // 소문자
+  left: 'left',
+  center: 'center',
+  right: 'right',
+  both: 'justify',
+
+  // CSS 스타일
+  start: 'left',
+  end: 'right',
+};
+
+export function safeAlign(raw?: string): Align {
+  return ALIGN_MAP[raw ?? ''] ?? 'left';
+}
+
+// ─── 테두리 매핑 ────────────────────────────────────────
+
+/** HWPX stroke kind 매핑 */
+const HWPX_STROKE: Record<string, StrokeKind> = {
+  SOLID: 'solid',
+  NONE: 'none',
+  DASH: 'dash',
+  DOT: 'dot',
+  DOUBLE: 'double',
+  LONG_DASH: 'dash',
+  DASH_DOT: 'dashDot',
+  DASH_DOT_DOT: 'dashDotDot',
+  THICK_THIN: 'double',
+  THIN_THICK: 'double',
+  TRIPLE: 'double',
+};
+
+/** DOCX stroke kind 매핑 */
+const DOCX_STROKE: Record<string, StrokeKind> = {
+  single: 'solid',
+  none: 'none',
+  nil: 'none',
+  dashed: 'dash',
+  dotted: 'dot',
+  double: 'double',
+  dotDash: 'dashDot',
+  dotDotDash: 'dashDotDot',
+  thickThin: 'double',
+  thinThick: 'double',
+  triple: 'double',
+  wave: 'wave',
+  dashDotStroked: 'dashDot',
+  threeDEmboss: 'solid',
+  threeDEngrave: 'solid',
+};
+
+/** HWPX stroke 값을 Stroke 객체로 변환 */
+export function strokeFromHwpx(type?: string, width?: number, color?: string): Stroke {
+  return {
+    kind: HWPX_STROKE[type ?? ''] ?? 'solid',
+    pt: width != null ? width / 100 : 0.5, // hwpunit → pt
+    color: safeHex(color) ?? '000000',
+  };
+}
+
+/** DOCX stroke 값을 Stroke 객체로 변환 */
+export function strokeFromDocx(type?: string, size?: number, color?: string): Stroke {
+  return {
+    kind: DOCX_STROKE[type ?? ''] ?? 'solid',
+    pt: size != null ? size / 8 : 0.5, // 1/8 pt 단위로 변환
+    color: safeHex(color) ?? '000000',
+  };
+}
+
+// ─── 스타일 객체 매핑 ───────────────────────────────────
+
+/**
+ * DOCX 스타일 → HWPX 스타일 매핑
+ */
+export function styleDocxToHwpx(docxStyle: Partial<TextProps>): Partial<TextProps> {
+  return {
+    font: fontToKorean(docxStyle.font),
+    pt: docxStyle.pt,
+    b: docxStyle.b,
+    i: docxStyle.i,
+    u: docxStyle.u,
+    s: docxStyle.s,
+    color: docxStyle.color,
+  };
+}
+
+/**
+ * HWPX 스타일 → DOCX 스타일 매핑
+ */
+export function styleHwpxToDocx(hwpxStyle: Partial<TextProps>): Partial<TextProps> {
+  return {
+    font: fontToEnglish(hwpxStyle.font),
+    pt: hwpxStyle.pt,
+    b: hwpxStyle.b,
+    i: hwpxStyle.i,
+    u: hwpxStyle.u,
+    s: hwpxStyle.s,
+    color: hwpxStyle.color,
+  };
+}
+
+/**
+ * DOCX 스타일 → HWP 스타일 매핑
+ */
+export function styleDocxToHwp(docxStyle: Partial<TextProps>): Partial<TextProps> {
+  return {
+    font: fontToKorean(docxStyle.font),
+    pt: docxStyle.pt,
+    b: docxStyle.b,
+    i: docxStyle.i,
+    u: docxStyle.u,
+    s: docxStyle.s,
+    color: docxStyle.color,
+  };
+}
+
+/**
+ * HWP 스타일 → DOCX 스타일 매핑
+ */
+export function styleHwpToDocx(hwpStyle: Partial<TextProps>): Partial<TextProps> {
+  return {
+    font: fontToEnglish(hwpStyle.font),
+    pt: hwpStyle.pt,
+    b: hwpStyle.b,
+    i: hwpStyle.i,
+    u: hwpStyle.u,
+    s: hwpStyle.s,
+    color: hwpStyle.color,
+  };
+}

package/src/toolkit/UnitConverter.ts

@@ -0,0 +1,138 @@
+/**
+ * 단위 변환 유틸리티
+ *
+ * 다양한 문서 포맷 간의 단위 변환을 제공합니다.
+ *
+ * 단위 시스템:
+ * - HWP: 1 inch = 7200 hwpunit (1 pt = 100 hwpunit)
+ * - DOCX: 1 inch = 1440 dxa = 914400 emu (1 pt = 20 dxa = 12700 emu)
+ * - HWPX: charPr height 는 1000 = 10pt
+ */
+
+// ─── 기본 단위 변환 (pt 기준) ─────────────────────────────
+
+/** pt 를 다양한 단위로 변환 */
+export const ptTo = {
+  /** pt → HWP unit (1 pt = 100 hwpunit) */
+  hwpunit: (pt: number): number => Math.round(pt * 100),
+
+  /** pt → EMU (English Metric Units, 1 pt = 12700 emu) */
+  emu: (pt: number): number => Math.round(pt * 12700),
+
+  /** pt → DXA (Twips, 1 pt = 20 dxa) */
+  dxa: (pt: number): number => Math.round(pt * 20),
+
+  /** pt → HWPX charPr height (1 pt = 100 hHeight) */
+  hHeight: (pt: number): number => Math.round(pt * 100),
+
+  /** pt → DOCX half-point (1 pt = 2 half-pt) */
+  halfPt: (pt: number): number => Math.round(pt * 2),
+
+  /** pt → pixel (96 DPI 기준) */
+  pixel: (pt: number): number => Math.round(pt * 1.333),
+};
+
+export const mmTo = {
+  /** mm → HWP unit (오버플로 방지 및 한컴 엔진 내림 처리 반영) */
+  hwpunit: (mm: number): number => Math.floor((mm * 283465) / 1000),
+};
+
+/** 다양한 단위를 pt 로 변환 */
+export const toPt = {
+  /** HWP unit → pt */
+  hwpunit: (val: number): number => val / 100,
+
+  /** EMU → pt */
+  emu: (val: number): number => val / 12700,
+
+  /** DXA → pt */
+  dxa: (val: number): number => val / 20,
+
+  /** HWPX charPr height → pt */
+  hHeight: (val: number): number => val / 100,
+
+  /** DOCX half-point → pt */
+  halfPt: (val: number): number => val / 2,
+
+  /** pixel → pt (96 DPI 기준) */
+  pixel: (val: number): number => val * 0.75,
+};
+
+// ─── 직접 변환 (pt 를 거치지 않음) ───────────────────────
+
+/** HWP ↔ DOCX 단위 직접 변환 */
+export const directConvert = {
+  /** hwpunit → dxa (1 hwpunit = 0.2 dxa) */
+  hwpunitToDxa: (val: number): number => Math.round(val / 5),
+
+  /** dxa → hwpunit (1 dxa = 5 hwpunit) */
+  dxaToHwpunit: (val: number): number => Math.round(val * 5),
+
+  /** hwpunit → emu (1 hwpunit = 127 emu) */
+  hwpunitToEmu: (val: number): number => Math.round(val * 127),
+
+  /** emu → hwpunit (1 emu = 1/127 hwpunit) */
+  emuToHwpunit: (val: number): number => Math.round(val / 127),
+
+  /** dxa → emu (1 dxa = 635 emu) */
+  dxaToEmu: (val: number): number => Math.round(val * 635),
+
+  /** emu → dxa (1 emu = 1/635 dxa) */
+  emuToDxa: (val: number): number => Math.round(val / 635),
+};
+
+// ─── 페이지 차원 변환 ────────────────────────────────────
+
+/** A4 크기 (pt) */
+export const A4_DIMENSIONS = {
+  widthPt: 595.28,
+  heightPt: 841.89,
+};
+
+/** A4 크기 (hwpunit) */
+export const A4_HWPUNIT = {
+  width: 5952,
+  height: 8418,
+};
+
+/** A4 크기 (emu) */
+export const A4_EMU = {
+  width: 7512960,
+  height: 10689180,
+};
+
+/** A4 크기 (dxa) */
+export const A4_DXA = {
+  width: 11905,
+  height: 16837,
+};
+
+// ─── 편의 함수 ───────────────────────────────────────────
+
+/** pt 를 지정된 포맷의 단위로 변환 */
+export function ptToFormat(pt: number, format: 'hwp' | 'docx' | 'hwpx'): number {
+  switch (format) {
+    case 'hwp':
+      return ptTo.hwpunit(pt);
+    case 'docx':
+      return ptTo.emu(pt);
+    case 'hwpx':
+      return ptTo.hHeight(pt);
+    default:
+      return pt;
+  }
+}
+
+/** 지정된 포맷의 단위를 pt 로 변환 */
+export function formatToPt(value: number, format: 'hwp' | 'docx' | 'hwpx'): number {
+  switch (format) {
+    case 'hwp':
+      return toPt.hwpunit(value);
+    case 'docx':
+      return toPt.emu(value);
+    case 'hwpx':
+      return toPt.hHeight(value);
+    default:
+      return value;
+  }
+}

package/src/toolkit/XmlKit.ts

@@ -37,11 +37,6 @@ function parseXmlStrict(xml: string): Promise<unknown> {
       if (!frame) return;
       const { tag, obj } = frame;
 
-      // Drop whitespace-only _text
-      if (typeof obj['_text'] === 'string' && !(obj['_text'] as string).trim()) {
-        delete obj['_text'];
-      }
-
       if (stack.length === 0) {
         result = { [tag]: [obj] };
       } else {