@mlightcad/libredwg-web 0.7.10 → 0.7.12

package/README.md

@@ -53,7 +53,7 @@ pnpm build
 In order to reduce the size of wasm file, the following functionalities are not included by default when building web assembly.
 
 - write dwg file
-- read/write dxf file
+- write dxf file
 - import/export json file
 
 If you want those functionalities, just modify command `build:prepare` defined in [package.json](./package.json) and remove the following options.

package/dist/libredwg-web.js

@@ -94,8 +94,9 @@ const encodings = [
   "macintosh",
   // 23
   "big5",
-  "utf-8",
-  // Korean (Wansung + Johab)
+  // WHATWG 'euc-kr' decodes windows-949, which covers CP949 (Wansung + UHC).
+  "euc-kr",
+  // Korean (CP949 / Wansung + UHC)
   "utf-8",
   // Johab?
   "ibm866",
@@ -529,6 +530,16 @@ var DwgDictionaryCloningFlags = /* @__PURE__ */ ((DwgDictionaryCloningFlags2) =>
   DwgDictionaryCloningFlags2[DwgDictionaryCloningFlags2["UnmangleName"] = 5] = "UnmangleName";
   return DwgDictionaryCloningFlags2;
 })(DwgDictionaryCloningFlags || {});
+const UNICODE_ESCAPE = /\\U\+([0-9A-Fa-f]{4})/g;
+function decodeUnicodeEscapes(text) {
+  if (!text || !text.includes("\\U+")) {
+    return text;
+  }
+  return text.replace(
+    UNICODE_ESCAPE,
+    (_, hex) => String.fromCharCode(parseInt(hex, 16))
+  );
+}
 const dwgVersions = [
   {
     type: "invalid",
@@ -3341,12 +3352,24 @@ class LibreDwgConverter {
   constructor(instance) {
     __publicField(this, "libredwg");
     __publicField(this, "entityConverter");
+    /**
+     * Entity object indices keyed by owning BLOCK_HEADER object pointer.
+     * Built lazily when an ownership walk returns no entities (LibreDWG
+     * https://github.com/LibreDWG/libredwg/issues/1199).
+     */
+    __publicField(this, "orphanEntitiesByBlock", null);
+    /** Entity indices whose ownerhandle does not resolve to any object. */
+    __publicField(this, "ownerlessOrphanIndices", null);
+    __publicField(this, "orphanIndexDataPtr", null);
     this.libredwg = instance;
     this.entityConverter = new LibreEntityConverter(instance);
   }
   convert(data) {
     var _a;
     this.entityConverter.clear();
+    this.orphanEntitiesByBlock = null;
+    this.ownerlessOrphanIndices = null;
+    this.orphanIndexDataPtr = data;
     const db = {
       tables: {
         APPID: {
@@ -3600,6 +3623,26 @@ class LibreDwgConverter {
         }
       }
     }
+    if (this.orphanIndexDataPtr != null) {
+      const orphans = this.convertOrphanOwnedEntities(
+        this.orphanIndexDataPtr,
+        obj,
+        commonAttrs.handle,
+        isModelSpace(commonAttrs.name) === true
+      );
+      if (orphans.length) {
+        if (entities.length === 0) {
+          entities = orphans;
+        } else {
+          const seen = new Set(entities.map((e) => e.handle));
+          for (const entity of orphans) {
+            if (!seen.has(entity.handle)) {
+              entities.push(entity);
+            }
+          }
+        }
+      }
+    }
     return {
       ...commonAttrs,
       flags,
@@ -3628,6 +3671,89 @@ class LibreDwgConverter {
     }
     return entities;
   }
+  /**
+   * Builds (once) a map of BLOCK_HEADER object pointer → entity object indices
+   * for entities that are not reachable through the ownership chain, then
+   * converts the entities owned by `blockHeaderPtr`.
+   *
+   * @param includeOwnerless - When true (only for *Model_Space), also convert
+   *   entities that still have no resolvable owner after ownerhandle + entmode
+   *   fallback via dwg_entity_owner.
+   */
+  convertOrphanOwnedEntities(data, blockHeaderPtr, ownerHandle, includeOwnerless) {
+    this.ensureOrphanEntityIndex(data);
+    const byBlock = this.orphanEntitiesByBlock ?? /* @__PURE__ */ new Map();
+    const owned = byBlock.get(blockHeaderPtr) ?? [];
+    const ownerless = includeOwnerless && this.ownerlessOrphanIndices ? this.ownerlessOrphanIndices : [];
+    const indices = owned.length && ownerless.length ? owned.concat(ownerless) : owned.length ? owned : ownerless;
+    if (indices.length === 0) {
+      return [];
+    }
+    const libredwg = this.libredwg;
+    const converter = this.entityConverter;
+    const entities = [];
+    for (const index of indices) {
+      const object = libredwg.dwg_get_object(data, index);
+      const entity = converter.convert(object);
+      if (entity) {
+        entity.ownerBlockRecordSoftId = ownerHandle;
+        entities.push(entity);
+      }
+    }
+    return entities;
+  }
+  ensureOrphanEntityIndex(data) {
+    if (this.orphanEntitiesByBlock) {
+      return;
+    }
+    const libredwg = this.libredwg;
+    const numObjects = libredwg.dwg_get_num_objects(data);
+    const indexByEntityPtr = /* @__PURE__ */ new Map();
+    const entityIndices = [];
+    const blockHeaderPtrs = [];
+    const blockObjByTio = /* @__PURE__ */ new Map();
+    for (let i = 0; i < numObjects; i++) {
+      const obj = libredwg.dwg_get_object(data, i);
+      if (!obj) continue;
+      if (libredwg.dwg_object_get_supertype(obj) === Dwg_Object_Supertype.DWG_SUPERTYPE_ENTITY) {
+        entityIndices.push(i);
+        indexByEntityPtr.set(obj, i);
+      } else if (libredwg.dwg_object_get_fixedtype(obj) === Dwg_Object_Type.DWG_TYPE_BLOCK_HEADER) {
+        blockHeaderPtrs.push(obj);
+        const tio = libredwg.dwg_object_to_object_tio(obj);
+        if (tio) blockObjByTio.set(tio, obj);
+      }
+    }
+    const claimed = /* @__PURE__ */ new Set();
+    for (const blockHeader of blockHeaderPtrs) {
+      let current = libredwg.get_first_owned_entity(blockHeader);
+      let steps = 0;
+      while (current && steps++ <= entityIndices.length) {
+        const index = indexByEntityPtr.get(current);
+        if (index === void 0 || claimed.has(index)) break;
+        claimed.add(index);
+        current = libredwg.get_next_owned_entity(blockHeader, current);
+      }
+    }
+    const orphansByBlock = /* @__PURE__ */ new Map();
+    const ownerless = [];
+    for (const index of entityIndices) {
+      if (claimed.has(index)) continue;
+      const obj = libredwg.dwg_get_object(data, index);
+      const etio = obj ? libredwg.dwg_object_to_entity_tio(obj) : 0;
+      const ownerTio = etio ? libredwg.dwg_entity_owner(etio) : 0;
+      const owner = ownerTio ? blockObjByTio.get(ownerTio) ?? 0 : 0;
+      if (owner) {
+        const owned = orphansByBlock.get(owner);
+        if (owned) owned.push(index);
+        else orphansByBlock.set(owner, [index]);
+      } else {
+        ownerless.push(index);
+      }
+    }
+    this.orphanEntitiesByBlock = orphansByBlock;
+    this.ownerlessOrphanIndices = ownerless;
+  }
   convertDimStyle(item, obj) {
     const libredwg = this.libredwg;
     const commonAttrs = this.getCommonTableEntryAttrs(item, obj);
@@ -3867,8 +3993,10 @@ class LibreDwgConverter {
     dashes.forEach((dash) => {
       patterns.push({
         elementLength: dash.length || 0,
-        elementTypeFlag: dash.complex_shapecode,
-        shapeNumber: dash.shape_flag,
+        // DXF 74: 1=absolute rotation, 2=text, 4=shape
+        elementTypeFlag: dash.shape_flag || 0,
+        // DXF 75: shape number (when flag has bit 4)
+        shapeNumber: dash.complex_shapecode,
         // TODO: convert style handle to style object id
         // styleObjectId: dash.style,
         scale: dash.scale,
@@ -6449,6 +6577,9 @@ const _LibreDwg = class _LibreDwg {
     if (value.bin && this.decoder) {
       value.data = this.decoder.decode(value.bin);
     }
+    if (typeof value.data === "string") {
+      value.data = decodeUnicodeEscapes(value.data);
+    }
     return value;
   }
   /**
@@ -6502,7 +6633,18 @@ const _LibreDwg = class _LibreDwg {
    * @returns Returns the sub-field value of one complex field.
    */
   dwg_dynapi_subclass_value(obj, subclass, field) {
-    return this.wasmInstance.dwg_dynapi_subclass_value(obj, subclass, field);
+    const value = this.wasmInstance.dwg_dynapi_subclass_value(
+      obj,
+      subclass,
+      field
+    );
+    if (value.bin && this.decoder) {
+      value.data = this.decoder.decode(value.bin);
+    }
+    if (typeof value.data === "string") {
+      value.data = decodeUnicodeEscapes(value.data);
+    }
+    return value;
   }
   /**
    * Returns the sub-field data of one complex field.
@@ -6938,6 +7080,7 @@ export {
   HEADER_VARIABLES,
   LibreDwg,
   default2 as createModule,
+  decodeUnicodeEscapes,
   dwgCodePageToEncoding,
   dwgVersions
 };

package/dist/libredwg-web.umd.cjs

@@ -96,8 +96,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     "macintosh",
     // 23
     "big5",
-    "utf-8",
-    // Korean (Wansung + Johab)
+    // WHATWG 'euc-kr' decodes windows-949, which covers CP949 (Wansung + UHC).
+    "euc-kr",
+    // Korean (CP949 / Wansung + UHC)
     "utf-8",
     // Johab?
     "ibm866",
@@ -531,6 +532,16 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     DwgDictionaryCloningFlags2[DwgDictionaryCloningFlags2["UnmangleName"] = 5] = "UnmangleName";
     return DwgDictionaryCloningFlags2;
   })(DwgDictionaryCloningFlags || {});
+  const UNICODE_ESCAPE = /\\U\+([0-9A-Fa-f]{4})/g;
+  function decodeUnicodeEscapes(text) {
+    if (!text || !text.includes("\\U+")) {
+      return text;
+    }
+    return text.replace(
+      UNICODE_ESCAPE,
+      (_, hex) => String.fromCharCode(parseInt(hex, 16))
+    );
+  }
   const dwgVersions = [
     {
       type: "invalid",
@@ -3343,12 +3354,24 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     constructor(instance) {
       __publicField(this, "libredwg");
       __publicField(this, "entityConverter");
+      /**
+       * Entity object indices keyed by owning BLOCK_HEADER object pointer.
+       * Built lazily when an ownership walk returns no entities (LibreDWG
+       * https://github.com/LibreDWG/libredwg/issues/1199).
+       */
+      __publicField(this, "orphanEntitiesByBlock", null);
+      /** Entity indices whose ownerhandle does not resolve to any object. */
+      __publicField(this, "ownerlessOrphanIndices", null);
+      __publicField(this, "orphanIndexDataPtr", null);
       this.libredwg = instance;
       this.entityConverter = new LibreEntityConverter(instance);
     }
     convert(data) {
       var _a;
       this.entityConverter.clear();
+      this.orphanEntitiesByBlock = null;
+      this.ownerlessOrphanIndices = null;
+      this.orphanIndexDataPtr = data;
       const db = {
         tables: {
           APPID: {
@@ -3602,6 +3625,26 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           }
         }
       }
+      if (this.orphanIndexDataPtr != null) {
+        const orphans = this.convertOrphanOwnedEntities(
+          this.orphanIndexDataPtr,
+          obj,
+          commonAttrs.handle,
+          isModelSpace(commonAttrs.name) === true
+        );
+        if (orphans.length) {
+          if (entities.length === 0) {
+            entities = orphans;
+          } else {
+            const seen = new Set(entities.map((e) => e.handle));
+            for (const entity of orphans) {
+              if (!seen.has(entity.handle)) {
+                entities.push(entity);
+              }
+            }
+          }
+        }
+      }
       return {
         ...commonAttrs,
         flags,
@@ -3630,6 +3673,89 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       }
       return entities;
     }
+    /**
+     * Builds (once) a map of BLOCK_HEADER object pointer → entity object indices
+     * for entities that are not reachable through the ownership chain, then
+     * converts the entities owned by `blockHeaderPtr`.
+     *
+     * @param includeOwnerless - When true (only for *Model_Space), also convert
+     *   entities that still have no resolvable owner after ownerhandle + entmode
+     *   fallback via dwg_entity_owner.
+     */
+    convertOrphanOwnedEntities(data, blockHeaderPtr, ownerHandle, includeOwnerless) {
+      this.ensureOrphanEntityIndex(data);
+      const byBlock = this.orphanEntitiesByBlock ?? /* @__PURE__ */ new Map();
+      const owned = byBlock.get(blockHeaderPtr) ?? [];
+      const ownerless = includeOwnerless && this.ownerlessOrphanIndices ? this.ownerlessOrphanIndices : [];
+      const indices = owned.length && ownerless.length ? owned.concat(ownerless) : owned.length ? owned : ownerless;
+      if (indices.length === 0) {
+        return [];
+      }
+      const libredwg = this.libredwg;
+      const converter = this.entityConverter;
+      const entities = [];
+      for (const index of indices) {
+        const object = libredwg.dwg_get_object(data, index);
+        const entity = converter.convert(object);
+        if (entity) {
+          entity.ownerBlockRecordSoftId = ownerHandle;
+          entities.push(entity);
+        }
+      }
+      return entities;
+    }
+    ensureOrphanEntityIndex(data) {
+      if (this.orphanEntitiesByBlock) {
+        return;
+      }
+      const libredwg = this.libredwg;
+      const numObjects = libredwg.dwg_get_num_objects(data);
+      const indexByEntityPtr = /* @__PURE__ */ new Map();
+      const entityIndices = [];
+      const blockHeaderPtrs = [];
+      const blockObjByTio = /* @__PURE__ */ new Map();
+      for (let i = 0; i < numObjects; i++) {
+        const obj = libredwg.dwg_get_object(data, i);
+        if (!obj) continue;
+        if (libredwg.dwg_object_get_supertype(obj) === Dwg_Object_Supertype.DWG_SUPERTYPE_ENTITY) {
+          entityIndices.push(i);
+          indexByEntityPtr.set(obj, i);
+        } else if (libredwg.dwg_object_get_fixedtype(obj) === Dwg_Object_Type.DWG_TYPE_BLOCK_HEADER) {
+          blockHeaderPtrs.push(obj);
+          const tio = libredwg.dwg_object_to_object_tio(obj);
+          if (tio) blockObjByTio.set(tio, obj);
+        }
+      }
+      const claimed = /* @__PURE__ */ new Set();
+      for (const blockHeader of blockHeaderPtrs) {
+        let current = libredwg.get_first_owned_entity(blockHeader);
+        let steps = 0;
+        while (current && steps++ <= entityIndices.length) {
+          const index = indexByEntityPtr.get(current);
+          if (index === void 0 || claimed.has(index)) break;
+          claimed.add(index);
+          current = libredwg.get_next_owned_entity(blockHeader, current);
+        }
+      }
+      const orphansByBlock = /* @__PURE__ */ new Map();
+      const ownerless = [];
+      for (const index of entityIndices) {
+        if (claimed.has(index)) continue;
+        const obj = libredwg.dwg_get_object(data, index);
+        const etio = obj ? libredwg.dwg_object_to_entity_tio(obj) : 0;
+        const ownerTio = etio ? libredwg.dwg_entity_owner(etio) : 0;
+        const owner = ownerTio ? blockObjByTio.get(ownerTio) ?? 0 : 0;
+        if (owner) {
+          const owned = orphansByBlock.get(owner);
+          if (owned) owned.push(index);
+          else orphansByBlock.set(owner, [index]);
+        } else {
+          ownerless.push(index);
+        }
+      }
+      this.orphanEntitiesByBlock = orphansByBlock;
+      this.ownerlessOrphanIndices = ownerless;
+    }
     convertDimStyle(item, obj) {
       const libredwg = this.libredwg;
       const commonAttrs = this.getCommonTableEntryAttrs(item, obj);
@@ -3869,8 +3995,10 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       dashes.forEach((dash) => {
         patterns.push({
           elementLength: dash.length || 0,
-          elementTypeFlag: dash.complex_shapecode,
-          shapeNumber: dash.shape_flag,
+          // DXF 74: 1=absolute rotation, 2=text, 4=shape
+          elementTypeFlag: dash.shape_flag || 0,
+          // DXF 75: shape number (when flag has bit 4)
+          shapeNumber: dash.complex_shapecode,
           // TODO: convert style handle to style object id
           // styleObjectId: dash.style,
           scale: dash.scale,
@@ -6451,6 +6579,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       if (value.bin && this.decoder) {
         value.data = this.decoder.decode(value.bin);
       }
+      if (typeof value.data === "string") {
+        value.data = decodeUnicodeEscapes(value.data);
+      }
       return value;
     }
     /**
@@ -6504,7 +6635,18 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
      * @returns Returns the sub-field value of one complex field.
      */
     dwg_dynapi_subclass_value(obj, subclass, field) {
-      return this.wasmInstance.dwg_dynapi_subclass_value(obj, subclass, field);
+      const value = this.wasmInstance.dwg_dynapi_subclass_value(
+        obj,
+        subclass,
+        field
+      );
+      if (value.bin && this.decoder) {
+        value.data = this.decoder.decode(value.bin);
+      }
+      if (typeof value.data === "string") {
+        value.data = decodeUnicodeEscapes(value.data);
+      }
+      return value;
     }
     /**
      * Returns the sub-field data of one complex field.
@@ -6939,6 +7081,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   exports2.Dwg_Object_Type_Inverted = Dwg_Object_Type_Inverted;
   exports2.HEADER_VARIABLES = HEADER_VARIABLES;
   exports2.LibreDwg = LibreDwg;
+  exports2.decodeUnicodeEscapes = decodeUnicodeEscapes;
   exports2.dwgCodePageToEncoding = dwgCodePageToEncoding;
   exports2.dwgVersions = dwgVersions;
   Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });

package/lib/converter/converter.d.ts

@@ -7,6 +7,15 @@ import { Dwg_Data_Ptr } from '../types';
 export declare class LibreDwgConverter {
     private libredwg;
     private entityConverter;
+    /**
+     * Entity object indices keyed by owning BLOCK_HEADER object pointer.
+     * Built lazily when an ownership walk returns no entities (LibreDWG
+     * https://github.com/LibreDWG/libredwg/issues/1199).
+     */
+    private orphanEntitiesByBlock;
+    /** Entity indices whose ownerhandle does not resolve to any object. */
+    private ownerlessOrphanIndices;
+    private orphanIndexDataPtr;
     constructor(instance: LibreDwgEx);
     convert(data: Dwg_Data_Ptr): DwgDatabase;
     getConversionStats(): {
@@ -18,6 +27,17 @@ export declare class LibreDwgConverter {
     private convertAppId;
     private convertBlockRecord;
     private convertEntities;
+    /**
+     * Builds (once) a map of BLOCK_HEADER object pointer → entity object indices
+     * for entities that are not reachable through the ownership chain, then
+     * converts the entities owned by `blockHeaderPtr`.
+     *
+     * @param includeOwnerless - When true (only for *Model_Space), also convert
+     *   entities that still have no resolvable owner after ownerhandle + entmode
+     *   fallback via dwg_entity_owner.
+     */
+    private convertOrphanOwnedEntities;
+    private ensureOrphanEntityIndex;
     private convertDimStyle;
     private convertLayer;
     private convertLineType;

package/lib/converter/converter.js

@@ -9,12 +9,24 @@ import { idToString, isModelSpace, isPaperSpace, uint8ArrayToHexString } from '.
 export class LibreDwgConverter {
     libredwg;
     entityConverter;
+    /**
+     * Entity object indices keyed by owning BLOCK_HEADER object pointer.
+     * Built lazily when an ownership walk returns no entities (LibreDWG
+     * https://github.com/LibreDWG/libredwg/issues/1199).
+     */
+    orphanEntitiesByBlock = null;
+    /** Entity indices whose ownerhandle does not resolve to any object. */
+    ownerlessOrphanIndices = null;
+    orphanIndexDataPtr = null;
     constructor(instance) {
         this.libredwg = instance;
         this.entityConverter = new LibreEntityConverter(instance);
     }
     convert(data) {
         this.entityConverter.clear();
+        this.orphanEntitiesByBlock = null;
+        this.ownerlessOrphanIndices = null;
+        this.orphanIndexDataPtr = data;
         const db = {
             tables: {
                 APPID: {
@@ -287,6 +299,27 @@ export class LibreDwgConverter {
                 }
             }
         }
+        // Some DWG writers (including LibreDWG's own) declare first_entity /
+        // last_entity handles that resolve to no object, or only link a
+        // partial ownership chain. Fall back to entity objects whose owner
+        // (ownerhandle / entmode via dwg_entity_owner) names this block.
+        // For *Model_Space only, also pick up entities with no resolvable owner.
+        if (this.orphanIndexDataPtr != null) {
+            const orphans = this.convertOrphanOwnedEntities(this.orphanIndexDataPtr, obj, commonAttrs.handle, isModelSpace(commonAttrs.name) === true);
+            if (orphans.length) {
+                if (entities.length === 0) {
+                    entities = orphans;
+                }
+                else {
+                    const seen = new Set(entities.map(e => e.handle));
+                    for (const entity of orphans) {
+                        if (!seen.has(entity.handle)) {
+                            entities.push(entity);
+                        }
+                    }
+                }
+            }
+        }
         return {
             ...commonAttrs,
             flags: flags,
@@ -315,6 +348,108 @@ export class LibreDwgConverter {
         }
         return entities;
     }
+    /**
+     * Builds (once) a map of BLOCK_HEADER object pointer → entity object indices
+     * for entities that are not reachable through the ownership chain, then
+     * converts the entities owned by `blockHeaderPtr`.
+     *
+     * @param includeOwnerless - When true (only for *Model_Space), also convert
+     *   entities that still have no resolvable owner after ownerhandle + entmode
+     *   fallback via dwg_entity_owner.
+     */
+    convertOrphanOwnedEntities(data, blockHeaderPtr, ownerHandle, includeOwnerless) {
+        this.ensureOrphanEntityIndex(data);
+        const byBlock = this.orphanEntitiesByBlock ?? new Map();
+        const owned = byBlock.get(blockHeaderPtr) ?? [];
+        const ownerless = includeOwnerless && this.ownerlessOrphanIndices
+            ? this.ownerlessOrphanIndices
+            : [];
+        const indices = owned.length && ownerless.length
+            ? owned.concat(ownerless)
+            : owned.length
+                ? owned
+                : ownerless;
+        if (indices.length === 0) {
+            return [];
+        }
+        const libredwg = this.libredwg;
+        const converter = this.entityConverter;
+        const entities = [];
+        for (const index of indices) {
+            const object = libredwg.dwg_get_object(data, index);
+            const entity = converter.convert(object);
+            if (entity) {
+                entity.ownerBlockRecordSoftId = ownerHandle;
+                entities.push(entity);
+            }
+        }
+        return entities;
+    }
+    ensureOrphanEntityIndex(data) {
+        if (this.orphanEntitiesByBlock) {
+            return;
+        }
+        const libredwg = this.libredwg;
+        const numObjects = libredwg.dwg_get_num_objects(data);
+        const indexByEntityPtr = new Map();
+        const entityIndices = [];
+        const blockHeaderPtrs = [];
+        // dwg_entity_owner returns a BLOCK_HEADER TIO pointer; map it back to the
+        // Dwg_Object* used as the orphan-index key.
+        const blockObjByTio = new Map();
+        for (let i = 0; i < numObjects; i++) {
+            const obj = libredwg.dwg_get_object(data, i);
+            if (!obj)
+                continue;
+            if (libredwg.dwg_object_get_supertype(obj) ===
+                Dwg_Object_Supertype.DWG_SUPERTYPE_ENTITY) {
+                entityIndices.push(i);
+                indexByEntityPtr.set(obj, i);
+            }
+            else if (libredwg.dwg_object_get_fixedtype(obj) ===
+                Dwg_Object_Type.DWG_TYPE_BLOCK_HEADER) {
+                blockHeaderPtrs.push(obj);
+                const tio = libredwg.dwg_object_to_object_tio(obj);
+                if (tio)
+                    blockObjByTio.set(tio, obj);
+            }
+        }
+        const claimed = new Set();
+        for (const blockHeader of blockHeaderPtrs) {
+            let current = libredwg.get_first_owned_entity(blockHeader);
+            let steps = 0;
+            while (current && steps++ <= entityIndices.length) {
+                const index = indexByEntityPtr.get(current);
+                if (index === undefined || claimed.has(index))
+                    break;
+                claimed.add(index);
+                current = libredwg.get_next_owned_entity(blockHeader, current);
+            }
+        }
+        const orphansByBlock = new Map();
+        const ownerless = [];
+        for (const index of entityIndices) {
+            if (claimed.has(index))
+                continue;
+            const obj = libredwg.dwg_get_object(data, index);
+            const etio = obj ? libredwg.dwg_object_to_entity_tio(obj) : 0;
+            // Resolves ownerhandle, then entmode → MSPACE/PSPACE (LibreDWG).
+            const ownerTio = etio ? libredwg.dwg_entity_owner(etio) : 0;
+            const owner = ownerTio ? (blockObjByTio.get(ownerTio) ?? 0) : 0;
+            if (owner) {
+                const owned = orphansByBlock.get(owner);
+                if (owned)
+                    owned.push(index);
+                else
+                    orphansByBlock.set(owner, [index]);
+            }
+            else {
+                ownerless.push(index);
+            }
+        }
+        this.orphanEntitiesByBlock = orphansByBlock;
+        this.ownerlessOrphanIndices = ownerless;
+    }
     convertDimStyle(item, obj) {
         const libredwg = this.libredwg;
         const commonAttrs = this.getCommonTableEntryAttrs(item, obj);
@@ -568,8 +703,10 @@ export class LibreDwgConverter {
         dashes.forEach(dash => {
             patterns.push({
                 elementLength: dash.length || 0,
-                elementTypeFlag: dash.complex_shapecode,
-                shapeNumber: dash.shape_flag,
+                // DXF 74: 1=absolute rotation, 2=text, 4=shape
+                elementTypeFlag: dash.shape_flag || 0,
+                // DXF 75: shape number (when flag has bit 4)
+                shapeNumber: dash.complex_shapecode,
                 // TODO: convert style handle to style object id
                 // styleObjectId: dash.style,
                 scale: dash.scale,

package/lib/database/codepage.js

@@ -73,7 +73,8 @@ const encodings = [
     'shift-jis', // DOS Japanese (shiftjis)
     'macintosh', // 23
     'big5',
-    'utf-8', // Korean (Wansung + Johab)
+    // WHATWG 'euc-kr' decodes windows-949, which covers CP949 (Wansung + UHC).
+    'euc-kr', // Korean (CP949 / Wansung + UHC)
     'utf-8', // Johab?
     'ibm866', // Russian
     'windows-1250', // Central + Eastern European

package/lib/database/index.d.ts

@@ -7,5 +7,6 @@ export * from './header';
 export * from './objects';
 export * from './shared';
 export * from './tables';
+export * from './textEscapes';
 export * from './version';
 //# sourceMappingURL=index.d.ts.map

package/lib/database/index.js

@@ -7,5 +7,6 @@ export * from './header';
 export * from './objects';
 export * from './shared';
 export * from './tables';
+export * from './textEscapes';
 export * from './version';
 //# sourceMappingURL=index.js.map

package/lib/database/tables/ltype.d.ts

@@ -9,13 +9,16 @@ export interface DwgLTypeTableEntry extends DwgCommonTableEntry {
 }
 export interface DwgLineTypeElement {
     elementLength: number;
+    /** DXF 74: 1 = absolute rotation, 2 = embedded text, 4 = shape */
     elementTypeFlag: number;
+    /** DXF 75: shape number when elementTypeFlag has bit 4 */
     shapeNumber?: number;
     styleObjectId?: string;
     scale?: number;
     rotation?: number;
     offsetX?: number;
     offsetY?: number;
+    /** DXF 9: embedded text when elementTypeFlag has bit 2 */
     text?: string;
 }
 //# sourceMappingURL=ltype.d.ts.map

package/lib/database/textEscapes.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Replaces AutoCAD `\U+XXXX` escapes with the corresponding Unicode characters.
+ */
+export declare function decodeUnicodeEscapes(text: string): string;
+//# sourceMappingURL=textEscapes.d.ts.map

package/lib/database/textEscapes.js

@@ -0,0 +1,19 @@
+/**
+ * AutoCAD stores characters outside the drawing's code page as `\U+XXXX`
+ * escape sequences (exactly four hex digits). Decode them so TEXT / MTEXT /
+ * ATTRIB / layer names become real Unicode instead of literal escapes.
+ *
+ * Adjacent high/low surrogate escapes (e.g. `\U+D83D\U+DE00`) expand to
+ * UTF-16 code units that form one supplementary-plane character in JS strings.
+ */
+const UNICODE_ESCAPE = /\\U\+([0-9A-Fa-f]{4})/g;
+/**
+ * Replaces AutoCAD `\U+XXXX` escapes with the corresponding Unicode characters.
+ */
+export function decodeUnicodeEscapes(text) {
+    if (!text || !text.includes('\\U+')) {
+        return text;
+    }
+    return text.replace(UNICODE_ESCAPE, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+}
+//# sourceMappingURL=textEscapes.js.map

package/lib/libredwg.js

@@ -1,6 +1,6 @@
 import createModule from '../wasm/libredwg-web.js';
 import { LibreDwgConverter } from './converter';
-import { dwgCodePageToEncoding, dwgVersions } from './database';
+import { decodeUnicodeEscapes, dwgCodePageToEncoding, dwgVersions } from './database';
 import { SvgConverter } from './svg';
 import { Dwg_Error, Dwg_File_Type, Dwg_Object_Type } from './types';
 export { createModule };
@@ -799,6 +799,9 @@ export class LibreDwg {
         if (value.bin && this.decoder) {
             value.data = this.decoder.decode(value.bin);
         }
+        if (typeof value.data === 'string') {
+            value.data = decodeUnicodeEscapes(value.data);
+        }
         return value;
     }
     /**
@@ -852,7 +855,14 @@ export class LibreDwg {
      * @returns Returns the sub-field value of one complex field.
      */
     dwg_dynapi_subclass_value(obj, subclass, field) {
-        return this.wasmInstance.dwg_dynapi_subclass_value(obj, subclass, field);
+        const value = this.wasmInstance.dwg_dynapi_subclass_value(obj, subclass, field);
+        if (value.bin && this.decoder) {
+            value.data = this.decoder.decode(value.bin);
+        }
+        if (typeof value.data === 'string') {
+            value.data = decodeUnicodeEscapes(value.data);
+        }
+        return value;
     }
     /**
      * Returns the sub-field data of one complex field.

package/package.json

@@ -3,7 +3,7 @@
   "description": "A DWG/DXF JavaScript parser based on libredwg",
   "license": "GPL-3.0",
   "private": false,
-  "version": "0.7.10",
+  "version": "0.7.12",
   "author": "MLight Lee <mlight.lee@outlook.com>",
   "type": "module",
   "engines": {