@mlightcad/libredwg-web 0.7.4 → 0.7.6

package/lib/converter/entityConverter.js

@@ -1,5 +1,6 @@
 import { DwgBoundaryPathEdgeType, DwgHatchAssociativity, DwgHatchGradientColorFlag, DwgHatchGradientFlag, DwgHatchSolidFill } from '../database';
 import { Dwg_Hatch_Edge_Type, Dwg_Object_Type } from '../types';
+import { dwgColorToMLeaderRawColor } from './dwgColorToMLeaderRawColor';
 import { idToString, uint8ArrayToHexString } from './utils';
 export class LibreEntityConverter {
     libredwg;
@@ -101,6 +102,9 @@ export class LibreEntityConverter {
             else if (fixedtype == Dwg_Object_Type.DWG_TYPE_MLINE) {
                 return this.convertMLine(entity_tio, commonAttrs);
             }
+            else if (fixedtype == Dwg_Object_Type.DWG_TYPE_MULTILEADER) {
+                return this.convertMultiLeader(entity_tio, commonAttrs);
+            }
             else if (fixedtype == Dwg_Object_Type.DWG_TYPE_MTEXT) {
                 return this.convertMText(entity_tio, commonAttrs);
             }
@@ -128,6 +132,9 @@ export class LibreEntityConverter {
             else if (fixedtype == Dwg_Object_Type.DWG_TYPE_SECTIONOBJECT) {
                 return this.convertSection(entity_tio, commonAttrs);
             }
+            else if (fixedtype == Dwg_Object_Type.DWG_TYPE_SHAPE) {
+                return this.convertShape(entity_tio, commonAttrs);
+            }
             else if (fixedtype == Dwg_Object_Type.DWG_TYPE_SOLID) {
                 return this.convertSolid(entity_tio, commonAttrs);
             }
@@ -160,16 +167,11 @@ export class LibreEntityConverter {
     }
     convert3dFace(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const corner1 = libredwg.dwg_dynapi_entity_value(entity, 'corner1')
-            .data;
-        const corner2 = libredwg.dwg_dynapi_entity_value(entity, 'corner2')
-            .data;
-        const corner3 = libredwg.dwg_dynapi_entity_value(entity, 'corner3')
-            .data;
-        const corner4 = libredwg.dwg_dynapi_entity_value(entity, 'corner4')
-            .data;
-        const flag = libredwg.dwg_dynapi_entity_value(entity, 'invis_flags')
-            .data;
+        const corner1 = libredwg.dwg_dynapi_entity_data(entity, 'corner1');
+        const corner2 = libredwg.dwg_dynapi_entity_data(entity, 'corner2');
+        const corner3 = libredwg.dwg_dynapi_entity_data(entity, 'corner3');
+        const corner4 = libredwg.dwg_dynapi_entity_data(entity, 'corner4');
+        const flag = libredwg.dwg_dynapi_entity_data(entity, 'invis_flags');
         return {
             type: '3DFACE',
             ...commonAttrs,
@@ -182,17 +184,12 @@ export class LibreEntityConverter {
     }
     convertArc(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const center = libredwg.dwg_dynapi_entity_value(entity, 'center')
-            .data;
-        const radius = libredwg.dwg_dynapi_entity_value(entity, 'radius')
-            .data;
-        const thickness = libredwg.dwg_dynapi_entity_value(entity, 'thickness')
-            .data;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
-        const startAngle = libredwg.dwg_dynapi_entity_value(entity, 'start_angle')
-            .data;
-        const endAngle = libredwg.dwg_dynapi_entity_value(entity, 'end_angle')
-            .data;
+        const center = libredwg.dwg_dynapi_entity_data(entity, 'center');
+        const radius = libredwg.dwg_dynapi_entity_data(entity, 'radius');
+        const thickness = libredwg.dwg_dynapi_entity_data(entity, 'thickness');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
+        const startAngle = libredwg.dwg_dynapi_entity_data(entity, 'start_angle');
+        const endAngle = libredwg.dwg_dynapi_entity_data(entity, 'end_angle');
         return {
             type: 'ARC',
             ...commonAttrs,
@@ -206,13 +203,13 @@ export class LibreEntityConverter {
     }
     convertEmbeddedMText(entity, subclassName) {
         const libredwg = this.libredwg;
-        const attachmentPoint = libredwg.dwg_dynapi_subclass_value(entity, subclassName, 'attachment').data;
-        const insertionPoint = libredwg.dwg_dynapi_subclass_value(entity, subclassName, 'ins_pt').data;
-        const direction = libredwg.dwg_dynapi_subclass_value(entity, subclassName, 'x_axis_dir').data;
-        const rectHeight = libredwg.dwg_dynapi_subclass_value(entity, subclassName, 'rect_height').data;
-        const rectWidth = libredwg.dwg_dynapi_subclass_value(entity, subclassName, 'rect_width').data;
-        const extentsHeight = libredwg.dwg_dynapi_subclass_value(entity, subclassName, 'extents_height').data;
-        const extentsWidth = libredwg.dwg_dynapi_subclass_value(entity, subclassName, 'extents_width').data;
+        const attachmentPoint = libredwg.dwg_dynapi_subclass_data(entity, subclassName, 'attachment');
+        const insertionPoint = libredwg.dwg_dynapi_subclass_data(entity, subclassName, 'ins_pt');
+        const direction = libredwg.dwg_dynapi_subclass_data(entity, subclassName, 'x_axis_dir');
+        const rectHeight = libredwg.dwg_dynapi_subclass_data(entity, subclassName, 'rect_height');
+        const rectWidth = libredwg.dwg_dynapi_subclass_data(entity, subclassName, 'rect_width');
+        const extentsHeight = libredwg.dwg_dynapi_subclass_data(entity, subclassName, 'extents_height');
+        const extentsWidth = libredwg.dwg_dynapi_subclass_data(entity, subclassName, 'extents_width');
         // const columnType = libredwg.dwg_dynapi_subclass_value(entity, subclassName, 'column_type')
         //   .data as number
         // const columnWidth = libredwg.dwg_dynapi_subclass_value(entity, subclassName, 'column_width')
@@ -265,24 +262,19 @@ export class LibreEntityConverter {
         // Because the field name of text string in Dwg_Entity_ATTDEF is 'default_value'
         // instead of 'text_value'. So we need to get its value again using the correct
         // field name.
-        const textValue = libredwg.dwg_dynapi_entity_value(entity, 'default_value')
-            .data;
+        const textValue = libredwg.dwg_dynapi_entity_data(entity, 'default_value');
         const text = this.convertTextBase(entity);
         text.text = textValue;
-        const prompt = libredwg.dwg_dynapi_entity_value(entity, 'prompt')
-            .data;
-        const tag = libredwg.dwg_dynapi_entity_value(entity, 'tag').data;
-        const flags = libredwg.dwg_dynapi_entity_value(entity, 'flags')
-            .data;
-        const fieldLength = libredwg.dwg_dynapi_entity_value(entity, 'field_length')
-            .data;
-        const lockPositionFlag = libredwg.dwg_dynapi_entity_value(entity, 'lock_position_flag').data;
-        const duplicateRecordCloningFlag = libredwg.dwg_dynapi_entity_value(entity, 'keep_duplicate_records').data;
-        const isReallyLocked = libredwg.dwg_dynapi_entity_value(entity, 'is_really_locked').data;
+        const prompt = libredwg.dwg_dynapi_entity_data(entity, 'prompt');
+        const tag = libredwg.dwg_dynapi_entity_data(entity, 'tag');
+        const flags = libredwg.dwg_dynapi_entity_data(entity, 'flags');
+        const fieldLength = libredwg.dwg_dynapi_entity_data(entity, 'field_length');
+        const lockPositionFlag = libredwg.dwg_dynapi_entity_data(entity, 'lock_position_flag');
+        const duplicateRecordCloningFlag = libredwg.dwg_dynapi_entity_data(entity, 'keep_duplicate_records');
+        const isReallyLocked = libredwg.dwg_dynapi_entity_data(entity, 'is_really_locked');
         // TODO: double check whether 'mtext_type' is 'mtextFlag'
-        const mtextFlag = libredwg.dwg_dynapi_entity_value(entity, 'mtext_type')
-            .data;
-        const alignmentPoint = libredwg.dwg_dynapi_entity_value(entity, 'alignment_pt').data;
+        const mtextFlag = libredwg.dwg_dynapi_entity_data(entity, 'mtext_type');
+        const alignmentPoint = libredwg.dwg_dynapi_entity_data(entity, 'alignment_pt');
         return {
             type: 'ATTDEF',
             ...commonAttrs,
@@ -304,18 +296,15 @@ export class LibreEntityConverter {
     convertAttrib(entity, commonAttrs) {
         const libredwg = this.libredwg;
         const text = this.convertTextBase(entity);
-        const tag = libredwg.dwg_dynapi_entity_value(entity, 'tag').data;
-        const flags = libredwg.dwg_dynapi_entity_value(entity, 'flags')
-            .data;
-        const fieldLength = libredwg.dwg_dynapi_entity_value(entity, 'field_length')
-            .data;
-        const lockPositionFlag = libredwg.dwg_dynapi_entity_value(entity, 'lock_position_flag').data;
-        const duplicateRecordCloningFlag = libredwg.dwg_dynapi_entity_value(entity, 'keep_duplicate_records').data;
+        const tag = libredwg.dwg_dynapi_entity_data(entity, 'tag');
+        const flags = libredwg.dwg_dynapi_entity_data(entity, 'flags');
+        const fieldLength = libredwg.dwg_dynapi_entity_data(entity, 'field_length');
+        const lockPositionFlag = libredwg.dwg_dynapi_entity_data(entity, 'lock_position_flag');
+        const duplicateRecordCloningFlag = libredwg.dwg_dynapi_entity_data(entity, 'keep_duplicate_records');
         // TODO: double check whether 'mtext_type' is 'mtextFlag'
-        const mtextFlag = libredwg.dwg_dynapi_entity_value(entity, 'mtext_type')
-            .data;
-        const isReallyLocked = libredwg.dwg_dynapi_entity_value(entity, 'is_really_locked').data;
-        const alignmentPoint = libredwg.dwg_dynapi_entity_value(entity, 'alignment_pt').data;
+        const mtextFlag = libredwg.dwg_dynapi_entity_data(entity, 'mtext_type');
+        const isReallyLocked = libredwg.dwg_dynapi_entity_data(entity, 'is_really_locked');
+        const alignmentPoint = libredwg.dwg_dynapi_entity_data(entity, 'alignment_pt');
         return {
             type: 'ATTRIB',
             ...commonAttrs,
@@ -337,13 +326,10 @@ export class LibreEntityConverter {
     }
     convertCircle(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const center = libredwg.dwg_dynapi_entity_value(entity, 'center')
-            .data;
-        const radius = libredwg.dwg_dynapi_entity_value(entity, 'radius')
-            .data;
-        const thickness = libredwg.dwg_dynapi_entity_value(entity, 'thickness')
-            .data;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
+        const center = libredwg.dwg_dynapi_entity_data(entity, 'center');
+        const radius = libredwg.dwg_dynapi_entity_data(entity, 'radius');
+        const thickness = libredwg.dwg_dynapi_entity_data(entity, 'thickness');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
         return {
             type: 'CIRCLE',
             ...commonAttrs,
@@ -357,11 +343,11 @@ export class LibreEntityConverter {
         const libredwg = this.libredwg;
         const dimensionCommonAttrs = this.getDimensionCommonAttrs(entity);
         // TODO: Not sure whether 'clone_ins_pt' is same as 'insertionPoint'
-        const insertionPoint = libredwg.dwg_dynapi_entity_value(entity, 'clone_ins_pt').data;
-        const subDefinitionPoint1 = libredwg.dwg_dynapi_entity_value(entity, 'xline1_pt').data;
-        const subDefinitionPoint2 = libredwg.dwg_dynapi_entity_value(entity, 'xline2_pt').data;
-        const rotationAngle = libredwg.dwg_dynapi_entity_value(entity, 'ins_rotation').data;
-        const obliqueAngle = libredwg.dwg_dynapi_entity_value(entity, 'oblique_angle').data;
+        const insertionPoint = libredwg.dwg_dynapi_entity_data(entity, 'clone_ins_pt');
+        const subDefinitionPoint1 = libredwg.dwg_dynapi_entity_data(entity, 'xline1_pt');
+        const subDefinitionPoint2 = libredwg.dwg_dynapi_entity_data(entity, 'xline2_pt');
+        const rotationAngle = libredwg.dwg_dynapi_entity_data(entity, 'ins_rotation');
+        const obliqueAngle = libredwg.dwg_dynapi_entity_data(entity, 'oblique_angle');
         return {
             subclassMarker: 'AcDbAlignedDimension',
             ...commonAttrs,
@@ -376,12 +362,10 @@ export class LibreEntityConverter {
     convert3PointAngularDimension(entity, commonAttrs) {
         const libredwg = this.libredwg;
         const dimensionCommonAttrs = this.getDimensionCommonAttrs(entity);
-        const subDefinitionPoint1 = libredwg.dwg_dynapi_entity_value(entity, 'xline1_pt').data;
-        const subDefinitionPoint2 = libredwg.dwg_dynapi_entity_value(entity, 'xline2_pt').data;
-        const centerPoint = libredwg.dwg_dynapi_entity_value(entity, 'center_pt')
-            .data;
-        const arcPoint = libredwg.dwg_dynapi_entity_value(entity, 'xline2end_pt')
-            .data;
+        const subDefinitionPoint1 = libredwg.dwg_dynapi_entity_data(entity, 'xline1_pt');
+        const subDefinitionPoint2 = libredwg.dwg_dynapi_entity_data(entity, 'xline2_pt');
+        const centerPoint = libredwg.dwg_dynapi_entity_data(entity, 'center_pt');
+        const arcPoint = libredwg.dwg_dynapi_entity_data(entity, 'xline2end_pt');
         return {
             subclassMarker: 'AcDb3PointAngularDimension',
             ...commonAttrs,
@@ -396,10 +380,8 @@ export class LibreEntityConverter {
         const libredwg = this.libredwg;
         const dimensionCommonAttrs = this.getDimensionCommonAttrs(entity);
         // TODO: Not sure whether 'first_arc_pt' is same as 'centerPoint'
-        const centerPoint = libredwg.dwg_dynapi_entity_value(entity, 'first_arc_pt')
-            .data;
-        const leaderLength = libredwg.dwg_dynapi_entity_value(entity, 'leader_len')
-            .data;
+        const centerPoint = libredwg.dwg_dynapi_entity_data(entity, 'first_arc_pt');
+        const leaderLength = libredwg.dwg_dynapi_entity_data(entity, 'leader_len');
         return {
             subclassMarker: 'AcDbDiametricDimension',
             ...commonAttrs,
@@ -412,9 +394,9 @@ export class LibreEntityConverter {
         const libredwg = this.libredwg;
         const dimensionCommonAttrs = this.getDimensionCommonAttrs(entity);
         // TODO: Not sure whether 'feature_location_pt' is same as 'subDefinitionPoint1'
-        const subDefinitionPoint1 = libredwg.dwg_dynapi_entity_value(entity, 'feature_location_pt').data;
+        const subDefinitionPoint1 = libredwg.dwg_dynapi_entity_data(entity, 'feature_location_pt');
         // TODO: Not sure whether 'leader_endpt' is same as 'subDefinitionPoint2'
-        const subDefinitionPoint2 = libredwg.dwg_dynapi_entity_value(entity, 'leader_endpt').data;
+        const subDefinitionPoint2 = libredwg.dwg_dynapi_entity_data(entity, 'leader_endpt');
         return {
             subclassMarker: 'AcDbOrdinateDimension',
             ...commonAttrs,
@@ -427,10 +409,8 @@ export class LibreEntityConverter {
         const libredwg = this.libredwg;
         const dimensionCommonAttrs = this.getDimensionCommonAttrs(entity);
         // TODO: Not sure whether 'first_arc_pt' is same as 'centerPoint'
-        const centerPoint = libredwg.dwg_dynapi_entity_value(entity, 'first_arc_pt')
-            .data;
-        const leaderLength = libredwg.dwg_dynapi_entity_value(entity, 'leader_len')
-            .data;
+        const centerPoint = libredwg.dwg_dynapi_entity_data(entity, 'first_arc_pt');
+        const leaderLength = libredwg.dwg_dynapi_entity_data(entity, 'leader_len');
         return {
             subclassMarker: 'AcDbRadialDimension',
             ...commonAttrs,
@@ -441,16 +421,12 @@ export class LibreEntityConverter {
     }
     convertEllise(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const center = libredwg.dwg_dynapi_entity_value(entity, 'center')
-            .data;
-        const majorAxisEndPoint = libredwg.dwg_dynapi_entity_value(entity, 'sm_axis').data;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
-        const axisRatio = libredwg.dwg_dynapi_entity_value(entity, 'axis_ratio')
-            .data;
-        const startAngle = libredwg.dwg_dynapi_entity_value(entity, 'start_angle')
-            .data;
-        const endAngle = libredwg.dwg_dynapi_entity_value(entity, 'end_angle')
-            .data;
+        const center = libredwg.dwg_dynapi_entity_data(entity, 'center');
+        const majorAxisEndPoint = libredwg.dwg_dynapi_entity_data(entity, 'sm_axis');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
+        const axisRatio = libredwg.dwg_dynapi_entity_data(entity, 'axis_ratio');
+        const startAngle = libredwg.dwg_dynapi_entity_data(entity, 'start_angle');
+        const endAngle = libredwg.dwg_dynapi_entity_data(entity, 'end_angle');
         return {
             type: 'ELLIPSE',
             ...commonAttrs,
@@ -464,30 +440,23 @@ export class LibreEntityConverter {
     }
     convertHatch(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
-        const patternName = libredwg.dwg_dynapi_entity_value(entity, 'name')
-            .data;
-        const isSolidFill = libredwg.dwg_dynapi_entity_value(entity, 'is_solid_fill').data;
-        const isAssociative = libredwg.dwg_dynapi_entity_value(entity, 'is_associative').data;
-        const numberOfBoundaryPaths = libredwg.dwg_dynapi_entity_value(entity, 'num_paths').data;
-        const paths_ptr = libredwg.dwg_dynapi_entity_value(entity, 'paths')
-            .data;
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
+        const patternName = libredwg.dwg_dynapi_entity_data(entity, 'name');
+        const isSolidFill = libredwg.dwg_dynapi_entity_data(entity, 'is_solid_fill');
+        const isAssociative = libredwg.dwg_dynapi_entity_data(entity, 'is_associative');
+        const numberOfBoundaryPaths = libredwg.dwg_dynapi_entity_data(entity, 'num_paths');
+        const paths_ptr = libredwg.dwg_dynapi_entity_data(entity, 'paths');
         const boundaryPaths = libredwg.dwg_ptr_to_hatch_path_array(paths_ptr, numberOfBoundaryPaths);
-        const patternStyle = libredwg.dwg_dynapi_entity_value(entity, 'style')
-            .data;
-        const patternType = libredwg.dwg_dynapi_entity_value(entity, 'pattern_type')
-            .data;
-        const patternAngle = libredwg.dwg_dynapi_entity_value(entity, 'angle')
-            .data;
-        const patternScale = libredwg.dwg_dynapi_entity_value(entity, 'scale_spacing').data;
-        const numberOfDefinitionLines = libredwg.dwg_dynapi_entity_value(entity, 'num_deflines').data;
-        const definitionLines_ptr = libredwg.dwg_dynapi_entity_value(entity, 'deflines').data;
+        const patternStyle = libredwg.dwg_dynapi_entity_data(entity, 'style');
+        const patternType = libredwg.dwg_dynapi_entity_data(entity, 'pattern_type');
+        const patternAngle = libredwg.dwg_dynapi_entity_data(entity, 'angle');
+        const patternScale = libredwg.dwg_dynapi_entity_data(entity, 'scale_spacing');
+        const numberOfDefinitionLines = libredwg.dwg_dynapi_entity_data(entity, 'num_deflines');
+        const definitionLines_ptr = libredwg.dwg_dynapi_entity_data(entity, 'deflines');
         const definitionLines = libredwg.dwg_ptr_to_hatch_defline_array(definitionLines_ptr, numberOfDefinitionLines);
-        const pixelSize = libredwg.dwg_dynapi_entity_value(entity, 'pixel_size')
-            .data;
-        const numberOfSeedPoints = libredwg.dwg_dynapi_entity_value(entity, 'num_seeds').data;
-        const seedPoints_ptr = libredwg.dwg_dynapi_entity_value(entity, 'seeds')
-            .data;
+        const pixelSize = libredwg.dwg_dynapi_entity_data(entity, 'pixel_size');
+        const numberOfSeedPoints = libredwg.dwg_dynapi_entity_data(entity, 'num_seeds');
+        const seedPoints_ptr = libredwg.dwg_dynapi_entity_data(entity, 'seeds');
         const seedPoints = libredwg.dwg_ptr_to_point2d_array(seedPoints_ptr, numberOfSeedPoints);
         const result = {
             ...commonAttrs,
@@ -523,23 +492,16 @@ export class LibreEntityConverter {
             seedPoints: seedPoints
             // gradientFlag?: DwgHatchGradientFlag
         };
-        const gradientFlag = libredwg.dwg_dynapi_entity_value(entity, 'is_gradient_fill')
-            .data;
+        const gradientFlag = libredwg.dwg_dynapi_entity_data(entity, 'is_gradient_fill');
         if (gradientFlag > 0) {
-            const gradientName = libredwg.dwg_dynapi_entity_value(entity, 'gradient_name')
-                .data;
-            const gradientRotation = libredwg.dwg_dynapi_entity_value(entity, 'gradient_angle')
-                .data;
-            const gradientDefinition = libredwg.dwg_dynapi_entity_value(entity, 'gradient_shift')
-                .data;
-            const colorTint = libredwg.dwg_dynapi_entity_value(entity, 'gradient_tint')
-                .data;
-            const gradientColorFlag = libredwg.dwg_dynapi_entity_value(entity, 'single_color_gradient')
-                .data;
+            const gradientName = libredwg.dwg_dynapi_entity_data(entity, 'gradient_name');
+            const gradientRotation = libredwg.dwg_dynapi_entity_data(entity, 'gradient_angle');
+            const gradientDefinition = libredwg.dwg_dynapi_entity_data(entity, 'gradient_shift');
+            const colorTint = libredwg.dwg_dynapi_entity_data(entity, 'gradient_tint');
+            const gradientColorFlag = libredwg.dwg_dynapi_entity_data(entity, 'single_color_gradient');
             // const numberOfColors = libredwg.dwg_dynapi_entity_value(entity, 'num_colors')
             //   .data as number
-            const gradientColors_ptr = libredwg.dwg_dynapi_entity_value(entity, 'colors')
-                .data;
+            const gradientColors_ptr = libredwg.dwg_dynapi_entity_data(entity, 'colors');
             const gradientColors = libredwg.dwg_ptr_to_hatch_gradient_color_array(gradientColors_ptr, (gradientColorFlag == 1) ? 1 : 2);
             return {
                 type: 'HATCH',
@@ -641,37 +603,25 @@ export class LibreEntityConverter {
     }
     convertImage(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const version = libredwg.dwg_dynapi_entity_value(entity, 'class_version')
-            .data;
-        const position = libredwg.dwg_dynapi_entity_value(entity, 'pt0')
-            .data;
-        const uPixel = libredwg.dwg_dynapi_entity_value(entity, 'uvec')
-            .data;
-        const vPixel = libredwg.dwg_dynapi_entity_value(entity, 'vvec')
-            .data;
-        const imageSize = libredwg.dwg_dynapi_entity_value(entity, 'image_size')
-            .data;
-        const flags = libredwg.dwg_dynapi_entity_value(entity, 'display_props')
-            .data;
-        const clipping = libredwg.dwg_dynapi_entity_value(entity, 'clipping')
-            .data;
-        const brightness = libredwg.dwg_dynapi_entity_value(entity, 'brightness')
-            .data;
-        const contrast = libredwg.dwg_dynapi_entity_value(entity, 'contrast')
-            .data;
-        const fade = libredwg.dwg_dynapi_entity_value(entity, 'fade').data;
-        const clipMode = libredwg.dwg_dynapi_entity_value(entity, 'clip_mode')
-            .data;
-        const clippingBoundaryType = libredwg.dwg_dynapi_entity_value(entity, 'clip_boundary_type').data;
-        const countBoundaryPoints = libredwg.dwg_dynapi_entity_value(entity, 'num_clip_verts').data;
-        const clip_verts = libredwg.dwg_dynapi_entity_value(entity, 'clip_verts')
-            .data;
+        const version = libredwg.dwg_dynapi_entity_data(entity, 'class_version');
+        const position = libredwg.dwg_dynapi_entity_data(entity, 'pt0');
+        const uPixel = libredwg.dwg_dynapi_entity_data(entity, 'uvec');
+        const vPixel = libredwg.dwg_dynapi_entity_data(entity, 'vvec');
+        const imageSize = libredwg.dwg_dynapi_entity_data(entity, 'image_size');
+        const flags = libredwg.dwg_dynapi_entity_data(entity, 'display_props');
+        const clipping = libredwg.dwg_dynapi_entity_data(entity, 'clipping');
+        const brightness = libredwg.dwg_dynapi_entity_data(entity, 'brightness');
+        const contrast = libredwg.dwg_dynapi_entity_data(entity, 'contrast');
+        const fade = libredwg.dwg_dynapi_entity_data(entity, 'fade');
+        const clipMode = libredwg.dwg_dynapi_entity_data(entity, 'clip_mode');
+        const clippingBoundaryType = libredwg.dwg_dynapi_entity_data(entity, 'clip_boundary_type');
+        const countBoundaryPoints = libredwg.dwg_dynapi_entity_data(entity, 'num_clip_verts');
+        const clip_verts = libredwg.dwg_dynapi_entity_data(entity, 'clip_verts');
         const clippingBoundaryPath = libredwg.dwg_ptr_to_point3d_array(clip_verts, countBoundaryPoints);
-        const imagedef_ref = libredwg.dwg_dynapi_entity_value(entity, 'imagedef')
-            .data;
-        const imageDefHandle = idToString(libredwg.dwg_ref_get_absref(imagedef_ref));
-        const imagedefreactor_ref = libredwg.dwg_dynapi_entity_value(entity, 'imagedefreactor').data;
-        const imageDefReactorHandle = idToString(libredwg.dwg_ref_get_absref(imagedefreactor_ref));
+        const imagedef_ref = libredwg.dwg_dynapi_entity_data(entity, 'imagedef');
+        const imageDefHandle = (libredwg.dwg_ref_get_id(imagedef_ref) ?? '');
+        const imagedefreactor_ref = libredwg.dwg_dynapi_entity_data(entity, 'imagedefreactor');
+        const imageDefReactorHandle = (libredwg.dwg_ref_get_id(imagedefreactor_ref) ?? '');
         return {
             type: 'IMAGE',
             ...commonAttrs,
@@ -697,7 +647,7 @@ export class LibreEntityConverter {
         const libredwg = this.libredwg;
         // Get block name
         let name = '';
-        const block_header_ref = libredwg.dwg_dynapi_entity_value(entity, 'block_header').data;
+        const block_header_ref = libredwg.dwg_dynapi_entity_data(entity, 'block_header');
         if (block_header_ref) {
             const block_header_obj = libredwg.dwg_ref_get_object(block_header_ref);
             if (block_header_obj) {
@@ -710,23 +660,16 @@ export class LibreEntityConverter {
         }
         if (!name) {
             /* pre-R2.0 */
-            name = libredwg.dwg_dynapi_entity_value(entity, 'block_name')
-                .data;
+            name = libredwg.dwg_dynapi_entity_data(entity, 'block_name');
         }
-        const insertionPoint = libredwg.dwg_dynapi_entity_value(entity, 'ins_pt')
-            .data;
-        const scale = libredwg.dwg_dynapi_entity_value(entity, 'scale')
-            .data;
-        const rotation = libredwg.dwg_dynapi_entity_value(entity, 'rotation')
-            .data;
-        const columnCount = libredwg.dwg_dynapi_entity_value(entity, 'num_cols')
-            .data;
-        const rowCount = libredwg.dwg_dynapi_entity_value(entity, 'num_rows')
-            .data;
-        const columnSpacing = libredwg.dwg_dynapi_entity_value(entity, 'col_spacing').data;
-        const rowSpacing = libredwg.dwg_dynapi_entity_value(entity, 'row_spacing')
-            .data;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
+        const insertionPoint = libredwg.dwg_dynapi_entity_data(entity, 'ins_pt');
+        const scale = libredwg.dwg_dynapi_entity_data(entity, 'scale');
+        const rotation = libredwg.dwg_dynapi_entity_data(entity, 'rotation');
+        const columnCount = libredwg.dwg_dynapi_entity_data(entity, 'num_cols');
+        const rowCount = libredwg.dwg_dynapi_entity_data(entity, 'num_rows');
+        const columnSpacing = libredwg.dwg_dynapi_entity_data(entity, 'col_spacing');
+        const rowSpacing = libredwg.dwg_dynapi_entity_data(entity, 'row_spacing');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
         const attrib_ptr_array = libredwg.dwg_entity_insert_get_attribs(entity);
         const attribs = [];
         attrib_ptr_array.forEach(object_ptr => {
@@ -762,28 +705,23 @@ export class LibreEntityConverter {
     convertLeader(entity, commonAttrs) {
         const libredwg = this.libredwg;
         const styleName = libredwg.dwg_entity_mtext_get_style_name(entity);
-        const isArrowheadEnabled = libredwg.dwg_dynapi_entity_value(entity, 'arrowhead_type').data;
-        const isSpline = libredwg.dwg_dynapi_entity_value(entity, 'path_type')
-            .data;
-        const leaderCreationFlag = libredwg.dwg_dynapi_entity_value(entity, 'annot_type').data;
-        const isHooklineSameDirection = libredwg.dwg_dynapi_entity_value(entity, 'hookline_dir').data;
-        const isHooklineExists = libredwg.dwg_dynapi_entity_value(entity, 'hookline_on').data;
-        const textHeight = libredwg.dwg_dynapi_entity_value(entity, 'box_height')
-            .data;
-        const textWidth = libredwg.dwg_dynapi_entity_value(entity, 'box_width')
-            .data;
-        const numberOfVertices = libredwg.dwg_dynapi_entity_value(entity, 'num_points').data;
-        const vertices_ptr = libredwg.dwg_dynapi_entity_value(entity, 'points')
-            .data;
+        const isArrowheadEnabled = libredwg.dwg_dynapi_entity_data(entity, 'arrowhead_type');
+        const isSpline = libredwg.dwg_dynapi_entity_data(entity, 'path_type');
+        const leaderCreationFlag = libredwg.dwg_dynapi_entity_data(entity, 'annot_type');
+        const isHooklineSameDirection = libredwg.dwg_dynapi_entity_data(entity, 'hookline_dir');
+        const isHooklineExists = libredwg.dwg_dynapi_entity_data(entity, 'hookline_on');
+        const textHeight = libredwg.dwg_dynapi_entity_data(entity, 'box_height');
+        const textWidth = libredwg.dwg_dynapi_entity_data(entity, 'box_width');
+        const numberOfVertices = libredwg.dwg_dynapi_entity_data(entity, 'num_points');
+        const vertices_ptr = libredwg.dwg_dynapi_entity_data(entity, 'points');
         const vertices = numberOfVertices > 0
             ? libredwg.dwg_ptr_to_point3d_array(vertices_ptr, numberOfVertices)
             : [];
-        const byBlockColor = libredwg.dwg_dynapi_entity_value(entity, 'byblock_color').data;
-        const normal = libredwg.dwg_dynapi_entity_value(entity, 'extrusion')
-            .data;
-        const horizontalDirection = libredwg.dwg_dynapi_entity_value(entity, 'x_direction').data;
-        const offsetFromBlock = libredwg.dwg_dynapi_entity_value(entity, 'inspt_offset').data;
-        const offsetFromAnnotation = libredwg.dwg_dynapi_entity_value(entity, 'endptproj').data;
+        const byBlockColor = libredwg.dwg_dynapi_entity_data(entity, 'byblock_color');
+        const normal = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
+        const horizontalDirection = libredwg.dwg_dynapi_entity_data(entity, 'x_direction');
+        const offsetFromBlock = libredwg.dwg_dynapi_entity_data(entity, 'inspt_offset');
+        const offsetFromAnnotation = libredwg.dwg_dynapi_entity_data(entity, 'endptproj');
         return {
             type: 'LEADER',
             ...commonAttrs,
@@ -806,13 +744,10 @@ export class LibreEntityConverter {
     }
     convertLine(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const startPoint = libredwg.dwg_dynapi_entity_value(entity, 'start')
-            .data;
-        const endPoint = libredwg.dwg_dynapi_entity_value(entity, 'end')
-            .data;
-        const thickness = libredwg.dwg_dynapi_entity_value(entity, 'thickness')
-            .data;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
+        const startPoint = libredwg.dwg_dynapi_entity_data(entity, 'start');
+        const endPoint = libredwg.dwg_dynapi_entity_data(entity, 'end');
+        const thickness = libredwg.dwg_dynapi_entity_data(entity, 'thickness');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
         return {
             type: 'LINE',
             ...commonAttrs,
@@ -824,24 +759,18 @@ export class LibreEntityConverter {
     }
     convertLWPolyline(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const numberOfVertices = libredwg.dwg_dynapi_entity_value(entity, 'num_points').data;
-        const flag = libredwg.dwg_dynapi_entity_value(entity, 'flag').data;
-        const constantWidth = libredwg.dwg_dynapi_entity_value(entity, 'const_width').data;
-        const elevation = libredwg.dwg_dynapi_entity_value(entity, 'elevation')
-            .data;
-        const thickness = libredwg.dwg_dynapi_entity_value(entity, 'thickness')
-            .data;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
+        const numberOfVertices = libredwg.dwg_dynapi_entity_data(entity, 'num_points');
+        const flag = libredwg.dwg_dynapi_entity_data(entity, 'flag');
+        const constantWidth = libredwg.dwg_dynapi_entity_data(entity, 'const_width');
+        const elevation = libredwg.dwg_dynapi_entity_data(entity, 'elevation');
+        const thickness = libredwg.dwg_dynapi_entity_data(entity, 'thickness');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
         const vertices = [];
-        const num_points = libredwg.dwg_dynapi_entity_value(entity, 'num_points')
-            .data;
-        const points_ptr = libredwg.dwg_dynapi_entity_value(entity, 'points')
-            .data;
+        const num_points = libredwg.dwg_dynapi_entity_data(entity, 'num_points');
+        const points_ptr = libredwg.dwg_dynapi_entity_data(entity, 'points');
         const points = libredwg.dwg_ptr_to_point2d_array(points_ptr, num_points);
-        const num_bulges = libredwg.dwg_dynapi_entity_value(entity, 'num_bulges')
-            .data;
-        const bulges_ptr = libredwg.dwg_dynapi_entity_value(entity, 'bulges')
-            .data;
+        const num_bulges = libredwg.dwg_dynapi_entity_data(entity, 'num_bulges');
+        const bulges_ptr = libredwg.dwg_dynapi_entity_data(entity, 'bulges');
         const bulges = libredwg.dwg_ptr_to_double_array(bulges_ptr, num_bulges);
         points.forEach((point, index) => {
             vertices.push({
@@ -865,19 +794,14 @@ export class LibreEntityConverter {
     }
     convertMLine(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const scale = libredwg.dwg_dynapi_entity_value(entity, 'scale')
-            .data;
-        const flags = libredwg.dwg_dynapi_entity_value(entity, 'flags')
-            .data;
-        const justification = libredwg.dwg_dynapi_entity_value(entity, 'justification').data;
-        const startPoint = libredwg.dwg_dynapi_entity_value(entity, 'base_point')
-            .data;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
-        const numberOfLines = libredwg.dwg_dynapi_entity_value(entity, 'num_lines')
-            .data;
-        const numberOfVertices = libredwg.dwg_dynapi_entity_value(entity, 'num_verts').data;
-        const verts_ptr = libredwg.dwg_dynapi_entity_value(entity, 'verts')
-            .data;
+        const scale = libredwg.dwg_dynapi_entity_data(entity, 'scale');
+        const flags = libredwg.dwg_dynapi_entity_data(entity, 'flags');
+        const justification = libredwg.dwg_dynapi_entity_data(entity, 'justification');
+        const startPoint = libredwg.dwg_dynapi_entity_data(entity, 'base_point');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
+        const numberOfLines = libredwg.dwg_dynapi_entity_data(entity, 'num_lines');
+        const numberOfVertices = libredwg.dwg_dynapi_entity_data(entity, 'num_verts');
+        const verts_ptr = libredwg.dwg_dynapi_entity_data(entity, 'verts');
         const verts = libredwg.dwg_ptr_to_mline_vertex_array(verts_ptr, numberOfVertices);
         const vertices = [];
         verts.forEach(vert => {
@@ -910,26 +834,302 @@ export class LibreEntityConverter {
             mlineStyle: '' // TODO: Set the correct value
         };
     }
+    convertMultiLeader(entity, commonAttrs) {
+        const libredwg = this.libredwg;
+        const entityVal = (field) => libredwg.dwg_dynapi_entity_data(entity, field);
+        const subclassVal = (ptr, subclass, field) => libredwg.dwg_dynapi_subclass_data(ptr, subclass, field);
+        const refToId = (ref) => libredwg.dwg_ref_get_id(ref);
+        const asBool = (value) => value > 0;
+        const mleaderColor = (color) => color != null ? dwgColorToMLeaderRawColor(color) : undefined;
+        const version = entityVal('class_version');
+        const leaderStyleId = refToId(entityVal('mleaderstyle'));
+        const propertyOverrideFlag = entityVal('flags');
+        const leaderLineType = entityVal('type');
+        const leaderLineColor = mleaderColor(entityVal('line_color'));
+        const leaderLineTypeId = refToId(entityVal('line_ltype'));
+        const leaderLineWeight = entityVal('line_linewt');
+        const landingEnabled = asBool(entityVal('has_landing'));
+        const doglegEnabled = asBool(entityVal('has_dogleg'));
+        const doglegLength = entityVal('landing_dist');
+        const arrowheadId = refToId(entityVal('arrow_handle'));
+        const arrowheadSize = entityVal('arrow_size');
+        const contentType = entityVal('style_content');
+        const textStyleId = refToId(entityVal('text_style'));
+        const textLeftAttachmentType = entityVal('text_left');
+        const textRightAttachmentType = entityVal('text_right');
+        const textAngleType = entityVal('text_angletype');
+        const textAlignmentType = entityVal('text_alignment');
+        const textColor = mleaderColor(entityVal('text_color'));
+        const textFrameEnabled = asBool(entityVal('has_text_frame'));
+        const blockContentId = refToId(entityVal('block_style'));
+        const blockContentColor = mleaderColor(entityVal('block_color'));
+        const blockContentScale = entityVal('block_scale');
+        const blockContentRotation = entityVal('block_rotation');
+        const blockContentConnectionType = entityVal('style_attachment');
+        const annotativeScaleEnabled = asBool(entityVal('is_annotative'));
+        const textDirectionNegative = asBool(entityVal('is_neg_textdir'));
+        const textAlignInIPE = entityVal('ipe_alignment');
+        let textAttachmentPoint = entityVal('justification');
+        const textAttachmentDirection = entityVal('attach_dir');
+        const bottomTextAttachmentDirection = entityVal('attach_bottom');
+        const topTextAttachmentDirection = entityVal('attach_top');
+        const contentScale = entityVal('scale_factor');
+        const numArrowheads = entityVal('num_arrowheads');
+        const arrowheadsPtr = entityVal('arrowheads');
+        const arrowHeadSize = libredwg.dwg_dynapi_subclass_size('LEADER_ArrowHead');
+        const arrowheadOverrides = [];
+        for (let i = 0; i < numArrowheads; i++) {
+            const arrowheadPtr = arrowheadsPtr + i * arrowHeadSize;
+            arrowheadOverrides.push({
+                index: subclassVal(arrowheadPtr, 'LEADER_ArrowHead', 'is_default'),
+                handle: refToId(subclassVal(arrowheadPtr, 'LEADER_ArrowHead', 'arrowhead')) ?? ''
+            });
+        }
+        const numBlocklabels = entityVal('num_blocklabels');
+        const blocklabelsPtr = entityVal('blocklabels');
+        const blockLabelSize = libredwg.dwg_dynapi_subclass_size('LEADER_BlockLabel');
+        const blockAttributes = [];
+        for (let i = 0; i < numBlocklabels; i++) {
+            const blocklabelPtr = blocklabelsPtr + i * blockLabelSize;
+            blockAttributes.push({
+                id: refToId(subclassVal(blocklabelPtr, 'LEADER_BlockLabel', 'attdef')),
+                index: subclassVal(blocklabelPtr, 'LEADER_BlockLabel', 'ui_index'),
+                width: subclassVal(blocklabelPtr, 'LEADER_BlockLabel', 'width'),
+                text: subclassVal(blocklabelPtr, 'LEADER_BlockLabel', 'label_text')
+            });
+        }
+        const ctxPtr = entity + libredwg.dwg_dynapi_entity_field_offset(entity, 'ctx');
+        const contentPtr = ctxPtr +
+            libredwg.dwg_dynapi_subclass_field_offset('MLEADER_AnnotContext', 'content');
+        const contentScaleFactor = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'scale_factor');
+        const contentBasePosition = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'content_base');
+        const landingGap = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'landing_gap');
+        const textAttachment = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'attach_dir');
+        const contextTextHeight = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'text_height');
+        const contextArrowSize = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'arrow_size');
+        const contextTextLeft = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'text_left');
+        const contextTextRight = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'text_right');
+        const contextTextAngleType = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'text_angletype');
+        const contextTextAlignment = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'text_alignment');
+        const hasMText = asBool(subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'has_content_txt'));
+        const hasBlock = asBool(subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'has_content_blk'));
+        const planeOrigin = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'base');
+        const planeXAxisDirection = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'base_dir');
+        const planeYAxisDirection = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'base_vert');
+        const planeNormalReversed = asBool(subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'is_normal_reversed'));
+        let textFlowDirection;
+        let normal;
+        let textRotation;
+        let textWidth;
+        let textLineSpacingFactor;
+        let textLineSpacingStyle;
+        let textAnchor;
+        let textDirection;
+        let textBackgroundColor;
+        let textBackgroundScaleFactor;
+        let textBackgroundTransparency;
+        let textBackgroundColorOn;
+        let textFillOn;
+        let textColumnType;
+        let textUseAutoHeight;
+        let textColumnWidth;
+        let textColumnGutterWidth;
+        let textColumnFlowReversed;
+        let textColumnHeight;
+        let textUseWordBreak;
+        let textContent;
+        if (hasMText) {
+            const textAlignment = subclassVal(contentPtr, 'MLEADER_Content_MText', 'alignment');
+            if (textAlignment != null && textAlignment !== 0) {
+                textAttachmentPoint = textAlignment;
+            }
+            normal = subclassVal(contentPtr, 'MLEADER_Content_MText', 'normal');
+            textAnchor = subclassVal(contentPtr, 'MLEADER_Content_MText', 'location');
+            textRotation = subclassVal(contentPtr, 'MLEADER_Content_MText', 'rotation');
+            textDirection = subclassVal(contentPtr, 'MLEADER_Content_MText', 'direction');
+            textWidth = subclassVal(contentPtr, 'MLEADER_Content_MText', 'width');
+            textLineSpacingFactor = subclassVal(contentPtr, 'MLEADER_Content_MText', 'line_spacing_factor');
+            textLineSpacingStyle = subclassVal(contentPtr, 'MLEADER_Content_MText', 'line_spacing_style');
+            textFlowDirection = subclassVal(contentPtr, 'MLEADER_Content_MText', 'flow');
+            textBackgroundColor = mleaderColor(subclassVal(contentPtr, 'MLEADER_Content_MText', 'bg_color'));
+            textBackgroundScaleFactor = subclassVal(contentPtr, 'MLEADER_Content_MText', 'bg_scale');
+            textBackgroundTransparency = subclassVal(contentPtr, 'MLEADER_Content_MText', 'bg_transparency');
+            textFillOn = asBool(subclassVal(contentPtr, 'MLEADER_Content_MText', 'is_bg_fill'));
+            textBackgroundColorOn = asBool(subclassVal(contentPtr, 'MLEADER_Content_MText', 'is_bg_mask_fill'));
+            textColumnType = subclassVal(contentPtr, 'MLEADER_Content_MText', 'col_type');
+            textUseAutoHeight = asBool(subclassVal(contentPtr, 'MLEADER_Content_MText', 'is_height_auto'));
+            textColumnWidth = subclassVal(contentPtr, 'MLEADER_Content_MText', 'col_width');
+            textColumnGutterWidth = subclassVal(contentPtr, 'MLEADER_Content_MText', 'col_gutter');
+            textColumnFlowReversed = asBool(subclassVal(contentPtr, 'MLEADER_Content_MText', 'is_col_flow_reversed'));
+            const numColSizes = subclassVal(contentPtr, 'MLEADER_Content_MText', 'num_col_sizes');
+            const colSizesPtr = subclassVal(contentPtr, 'MLEADER_Content_MText', 'col_sizes');
+            if (numColSizes > 0) {
+                textColumnHeight = libredwg.dwg_ptr_to_double_array(colSizesPtr, numColSizes)[0];
+            }
+            textUseWordBreak = asBool(subclassVal(contentPtr, 'MLEADER_Content_MText', 'word_break'));
+            textContent = subclassVal(contentPtr, 'MLEADER_Content_MText', 'default_text');
+        }
+        let blockContent;
+        if (hasBlock) {
+            const transformPtr = subclassVal(contentPtr, 'MLEADER_Content_Block', 'transform');
+            blockContent = {
+                blockContentId: refToId(subclassVal(contentPtr, 'MLEADER_Content_Block', 'block_table')),
+                normal: subclassVal(contentPtr, 'MLEADER_Content_Block', 'normal'),
+                position: subclassVal(contentPtr, 'MLEADER_Content_Block', 'location'),
+                scale: subclassVal(contentPtr, 'MLEADER_Content_Block', 'scale'),
+                rotation: subclassVal(contentPtr, 'MLEADER_Content_Block', 'rotation'),
+                color: mleaderColor(subclassVal(contentPtr, 'MLEADER_Content_Block', 'color')),
+                transformationMatrix: transformPtr
+                    ? libredwg.dwg_ptr_to_double_array(transformPtr, 16)
+                    : undefined
+            };
+        }
+        const numLeaders = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'num_leaders');
+        const leadersPtr = subclassVal(ctxPtr, 'MLEADER_AnnotContext', 'leaders');
+        const leaderNodeSize = libredwg.dwg_dynapi_subclass_size('LEADER_Node');
+        const leaderLineSize = libredwg.dwg_dynapi_subclass_size('LEADER_Line');
+        const leaderBreakSize = libredwg.dwg_dynapi_subclass_size('LEADER_Break');
+        const leaderSections = [];
+        for (let i = 0; i < numLeaders; i++) {
+            const nodePtr = leadersPtr + i * leaderNodeSize;
+            const lastLeaderLinePointSet = asBool(subclassVal(nodePtr, 'LEADER_Node', 'has_lastleaderlinepoint'));
+            const doglegVectorSet = asBool(subclassVal(nodePtr, 'LEADER_Node', 'has_dogleg'));
+            const numBreaks = subclassVal(nodePtr, 'LEADER_Node', 'num_breaks');
+            const breaksPtr = subclassVal(nodePtr, 'LEADER_Node', 'breaks');
+            const nodeBreaks = [];
+            for (let j = 0; j < numBreaks; j++) {
+                const breakPtr = breaksPtr + j * leaderBreakSize;
+                nodeBreaks.push({
+                    start: subclassVal(breakPtr, 'LEADER_Break', 'start'),
+                    end: subclassVal(breakPtr, 'LEADER_Break', 'end')
+                });
+            }
+            const numLines = subclassVal(nodePtr, 'LEADER_Node', 'num_lines');
+            const linesPtr = subclassVal(nodePtr, 'LEADER_Node', 'lines');
+            const leaderLines = [];
+            for (let j = 0; j < numLines; j++) {
+                const linePtr = linesPtr + j * leaderLineSize;
+                const numPoints = subclassVal(linePtr, 'LEADER_Line', 'num_points');
+                const pointsPtr = subclassVal(linePtr, 'LEADER_Line', 'points');
+                const vertices = numPoints > 0
+                    ? libredwg.dwg_ptr_to_point3d_array(pointsPtr, numPoints)
+                    : [];
+                const lineNumBreaks = subclassVal(linePtr, 'LEADER_Line', 'num_breaks');
+                const lineBreaksPtr = subclassVal(linePtr, 'LEADER_Line', 'breaks');
+                const lineBreaks = [];
+                for (let k = 0; k < lineNumBreaks; k++) {
+                    const breakPtr = lineBreaksPtr + k * leaderBreakSize;
+                    lineBreaks.push({
+                        start: subclassVal(breakPtr, 'LEADER_Break', 'start'),
+                        end: subclassVal(breakPtr, 'LEADER_Break', 'end')
+                    });
+                }
+                leaderLines.push({
+                    vertices,
+                    leaderLineIndex: subclassVal(linePtr, 'LEADER_Line', 'line_index'),
+                    breaks: lineBreaks.length > 0 ? lineBreaks : undefined
+                });
+            }
+            leaderSections.push({
+                lastLeaderLinePoint: lastLeaderLinePointSet
+                    ? subclassVal(nodePtr, 'LEADER_Node', 'lastleaderlinepoint')
+                    : undefined,
+                lastLeaderLinePointSet,
+                doglegVector: doglegVectorSet
+                    ? subclassVal(nodePtr, 'LEADER_Node', 'dogleg_vector')
+                    : undefined,
+                doglegVectorSet,
+                doglegLength: subclassVal(nodePtr, 'LEADER_Node', 'dogleg_length'),
+                breaks: nodeBreaks.length > 0 ? nodeBreaks : undefined,
+                leaderBranchIndex: subclassVal(nodePtr, 'LEADER_Node', 'branch_index'),
+                leaderLines
+            });
+        }
+        return {
+            type: 'MULTILEADER',
+            ...commonAttrs,
+            subclassMarker: 'AcDbMLeader',
+            version,
+            leaderStyleId,
+            propertyOverrideFlag,
+            leaderLineType,
+            leaderLineColor,
+            leaderLineTypeId,
+            leaderLineWeight,
+            landingEnabled,
+            doglegEnabled,
+            doglegLength,
+            arrowheadId,
+            arrowheadSize: arrowheadSize || contextArrowSize,
+            contentType,
+            textStyleId,
+            textLeftAttachmentType: textLeftAttachmentType || contextTextLeft,
+            textRightAttachmentType: textRightAttachmentType || contextTextRight,
+            textAngleType: textAngleType || contextTextAngleType,
+            textAlignmentType: textAlignmentType || contextTextAlignment,
+            textColor,
+            textFrameEnabled,
+            landingGap,
+            textAttachment,
+            textFlowDirection,
+            blockContentId,
+            blockContentColor,
+            blockContentScale,
+            blockContentRotation,
+            blockContentConnectionType,
+            annotativeScaleEnabled,
+            arrowheadOverrides: arrowheadOverrides.length > 0 ? arrowheadOverrides : undefined,
+            blockAttributes: blockAttributes.length > 0 ? blockAttributes : undefined,
+            textDirectionNegative,
+            textAlignInIPE,
+            textAttachmentPoint,
+            textAttachmentDirection,
+            bottomTextAttachmentDirection,
+            topTextAttachmentDirection,
+            contentScale: contentScale || contentScaleFactor,
+            contentBasePosition,
+            normal,
+            textHeight: contextTextHeight,
+            textRotation,
+            textWidth,
+            textLineSpacingFactor,
+            textLineSpacingStyle,
+            textAnchor,
+            textDirection,
+            textBackgroundColor,
+            textBackgroundScaleFactor,
+            textBackgroundTransparency,
+            textBackgroundColorOn,
+            textFillOn,
+            textColumnType,
+            textUseAutoHeight,
+            textColumnWidth,
+            textColumnGutterWidth,
+            textColumnFlowReversed,
+            textColumnHeight,
+            textUseWordBreak,
+            textContent,
+            hasMText,
+            hasBlock,
+            blockContent,
+            planeOrigin,
+            planeXAxisDirection,
+            planeYAxisDirection,
+            planeNormalReversed,
+            leaderSections: leaderSections.length > 0 ? leaderSections : undefined
+        };
+    }
     convertOle2Frame(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const oleVersion = libredwg.dwg_dynapi_entity_value(entity, 'oleversion')
-            .data;
-        const oleClient = libredwg.dwg_dynapi_entity_value(entity, 'oleclient')
-            .data;
-        const dataSize = libredwg.dwg_dynapi_entity_value(entity, 'data_size')
-            .data;
-        const leftUpPoint = libredwg.dwg_dynapi_entity_value(entity, 'pt1')
-            .data;
-        const rightDownPoint = libredwg.dwg_dynapi_entity_value(entity, 'pt2')
-            .data;
-        const lockAspect = libredwg.dwg_dynapi_entity_value(entity, 'lock_aspect')
-            .data;
-        const oleObjectType = libredwg.dwg_dynapi_entity_value(entity, 'type')
-            .data;
-        const tileModeDescriptor = libredwg.dwg_dynapi_entity_value(entity, 'mode')
-            .data;
-        const binaryData = libredwg.dwg_dynapi_entity_value(entity, 'data')
-            .data;
+        const oleVersion = libredwg.dwg_dynapi_entity_data(entity, 'oleversion');
+        const oleClient = libredwg.dwg_dynapi_entity_data(entity, 'oleclient');
+        const dataSize = libredwg.dwg_dynapi_entity_data(entity, 'data_size');
+        const leftUpPoint = libredwg.dwg_dynapi_entity_data(entity, 'pt1');
+        const rightDownPoint = libredwg.dwg_dynapi_entity_data(entity, 'pt2');
+        const lockAspect = libredwg.dwg_dynapi_entity_data(entity, 'lock_aspect');
+        const oleObjectType = libredwg.dwg_dynapi_entity_data(entity, 'type');
+        const tileModeDescriptor = libredwg.dwg_dynapi_entity_data(entity, 'mode');
+        const binaryData = libredwg.dwg_dynapi_entity_data(entity, 'data');
         return {
             type: 'OLE2FRAME',
             ...commonAttrs,
@@ -946,12 +1146,10 @@ export class LibreEntityConverter {
     }
     convertOleFrame(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const flag = libredwg.dwg_dynapi_entity_value(entity, 'flag').data;
-        const mode = libredwg.dwg_dynapi_entity_value(entity, 'mode').data;
-        const dataSize = libredwg.dwg_dynapi_entity_value(entity, 'data_size')
-            .data;
-        const binaryData = libredwg.dwg_dynapi_entity_value(entity, 'data')
-            .data;
+        const flag = libredwg.dwg_dynapi_entity_data(entity, 'flag');
+        const mode = libredwg.dwg_dynapi_entity_data(entity, 'mode');
+        const dataSize = libredwg.dwg_dynapi_entity_data(entity, 'data_size');
+        const binaryData = libredwg.dwg_dynapi_entity_data(entity, 'data');
         return {
             type: 'OLEFRAME',
             ...commonAttrs,
@@ -963,39 +1161,31 @@ export class LibreEntityConverter {
     }
     convertMText(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const insertionPoint = libredwg.dwg_dynapi_entity_value(entity, 'ins_pt')
-            .data;
-        const textHeight = libredwg.dwg_dynapi_entity_value(entity, 'text_height')
-            .data;
-        const rectHeight = libredwg.dwg_dynapi_entity_value(entity, 'rect_height')
-            .data;
-        const rectWidth = libredwg.dwg_dynapi_entity_value(entity, 'rect_width')
-            .data;
-        const extentsWidth = libredwg.dwg_dynapi_entity_value(entity, 'extents_width').data;
-        const extentsHeight = libredwg.dwg_dynapi_entity_value(entity, 'extents_height').data;
-        const attachmentPoint = libredwg.dwg_dynapi_entity_value(entity, 'attachment').data;
-        const drawingDirection = libredwg.dwg_dynapi_entity_value(entity, 'flow_dir').data;
-        const text = libredwg.dwg_dynapi_entity_value(entity, 'text').data;
+        const insertionPoint = libredwg.dwg_dynapi_entity_data(entity, 'ins_pt');
+        const textHeight = libredwg.dwg_dynapi_entity_data(entity, 'text_height');
+        const rectHeight = libredwg.dwg_dynapi_entity_data(entity, 'rect_height');
+        const rectWidth = libredwg.dwg_dynapi_entity_data(entity, 'rect_width');
+        const extentsWidth = libredwg.dwg_dynapi_entity_data(entity, 'extents_width');
+        const extentsHeight = libredwg.dwg_dynapi_entity_data(entity, 'extents_height');
+        const attachmentPoint = libredwg.dwg_dynapi_entity_data(entity, 'attachment');
+        const drawingDirection = libredwg.dwg_dynapi_entity_data(entity, 'flow_dir');
+        const text = libredwg.dwg_dynapi_entity_data(entity, 'text');
         const styleName = libredwg.dwg_entity_mtext_get_style_name(entity);
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
-        const direction = libredwg.dwg_dynapi_entity_value(entity, 'x_axis_dir')
-            .data;
-        const lineSpacingStyle = libredwg.dwg_dynapi_entity_value(entity, 'linespace_style').data;
-        const lineSpacing = libredwg.dwg_dynapi_entity_value(entity, 'linespace_factor').data;
-        const backgroundFill = libredwg.dwg_dynapi_entity_value(entity, 'bg_fill_flag').data;
-        const fillBoxScale = libredwg.dwg_dynapi_entity_value(entity, 'bg_fill_scale').data;
-        const backgroundFillColor = libredwg.dwg_dynapi_entity_value(entity, 'bg_fill_color').data;
-        const backgroundFillTransparency = libredwg.dwg_dynapi_entity_value(entity, 'bg_fill_trans').data;
-        const columnType = libredwg.dwg_dynapi_entity_value(entity, 'column_type')
-            .data;
-        const columnFlowReversed = libredwg.dwg_dynapi_entity_value(entity, 'flow_reversed').data;
-        const columnAutoHeight = libredwg.dwg_dynapi_entity_value(entity, 'auto_height').data;
-        const columnWidth = libredwg.dwg_dynapi_entity_value(entity, 'column_width')
-            .data;
-        const columnGutter = libredwg.dwg_dynapi_entity_value(entity, 'gutter')
-            .data;
-        const columnHeightCount = libredwg.dwg_dynapi_entity_value(entity, 'num_column_heights').data;
-        const columnHeights_ptr = libredwg.dwg_dynapi_entity_value(entity, 'column_heights').data;
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
+        const direction = libredwg.dwg_dynapi_entity_data(entity, 'x_axis_dir');
+        const lineSpacingStyle = libredwg.dwg_dynapi_entity_data(entity, 'linespace_style');
+        const lineSpacing = libredwg.dwg_dynapi_entity_data(entity, 'linespace_factor');
+        const backgroundFill = libredwg.dwg_dynapi_entity_data(entity, 'bg_fill_flag');
+        const fillBoxScale = libredwg.dwg_dynapi_entity_data(entity, 'bg_fill_scale');
+        const backgroundFillColor = libredwg.dwg_dynapi_entity_data(entity, 'bg_fill_color');
+        const backgroundFillTransparency = libredwg.dwg_dynapi_entity_data(entity, 'bg_fill_trans');
+        const columnType = libredwg.dwg_dynapi_entity_data(entity, 'column_type');
+        const columnFlowReversed = libredwg.dwg_dynapi_entity_data(entity, 'flow_reversed');
+        const columnAutoHeight = libredwg.dwg_dynapi_entity_data(entity, 'auto_height');
+        const columnWidth = libredwg.dwg_dynapi_entity_data(entity, 'column_width');
+        const columnGutter = libredwg.dwg_dynapi_entity_data(entity, 'gutter');
+        const columnHeightCount = libredwg.dwg_dynapi_entity_data(entity, 'num_column_heights');
+        const columnHeights_ptr = libredwg.dwg_dynapi_entity_data(entity, 'column_heights');
         const columnHeights = libredwg.dwg_ptr_to_double_array(columnHeights_ptr, columnHeightCount);
         return {
             type: 'MTEXT',
@@ -1032,14 +1222,12 @@ export class LibreEntityConverter {
     }
     convertPoint(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const x = libredwg.dwg_dynapi_entity_value(entity, 'x').data;
-        const y = libredwg.dwg_dynapi_entity_value(entity, 'y').data;
-        const z = libredwg.dwg_dynapi_entity_value(entity, 'z').data;
-        const thickness = libredwg.dwg_dynapi_entity_value(entity, 'thickness')
-            .data;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
-        const angle = libredwg.dwg_dynapi_entity_value(entity, 'x_ang')
-            .data;
+        const x = libredwg.dwg_dynapi_entity_data(entity, 'x');
+        const y = libredwg.dwg_dynapi_entity_data(entity, 'y');
+        const z = libredwg.dwg_dynapi_entity_data(entity, 'z');
+        const thickness = libredwg.dwg_dynapi_entity_data(entity, 'thickness');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
+        const angle = libredwg.dwg_dynapi_entity_data(entity, 'x_ang');
         return {
             type: 'POINT',
             ...commonAttrs,
@@ -1051,18 +1239,13 @@ export class LibreEntityConverter {
     }
     convertPolyline2d(entity, commonAttrs, object) {
         const libredwg = this.libredwg;
-        const flag = libredwg.dwg_dynapi_entity_value(entity, 'flag').data;
-        const smoothType = libredwg.dwg_dynapi_entity_value(entity, 'curve_type')
-            .data;
-        const startWidth = libredwg.dwg_dynapi_entity_value(entity, 'start_width')
-            .data;
-        const endWidth = libredwg.dwg_dynapi_entity_value(entity, 'end_width')
-            .data;
-        const elevation = libredwg.dwg_dynapi_entity_value(entity, 'elevation')
-            .data;
-        const thickness = libredwg.dwg_dynapi_entity_value(entity, 'thickness')
-            .data;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
+        const flag = libredwg.dwg_dynapi_entity_data(entity, 'flag');
+        const smoothType = libredwg.dwg_dynapi_entity_data(entity, 'curve_type');
+        const startWidth = libredwg.dwg_dynapi_entity_data(entity, 'start_width');
+        const endWidth = libredwg.dwg_dynapi_entity_data(entity, 'end_width');
+        const elevation = libredwg.dwg_dynapi_entity_data(entity, 'elevation');
+        const thickness = libredwg.dwg_dynapi_entity_data(entity, 'thickness');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
         const vertices = libredwg.dwg_entity_polyline_2d_get_vertices(object);
         return {
             type: 'POLYLINE2D',
@@ -1094,14 +1277,11 @@ export class LibreEntityConverter {
     }
     convertPolyline3d(entity, commonAttrs, object) {
         const libredwg = this.libredwg;
-        const flag = libredwg.dwg_dynapi_entity_value(entity, 'flag').data;
-        const smoothType = libredwg.dwg_dynapi_entity_value(entity, 'curve_type')
-            .data;
-        const startWidth = libredwg.dwg_dynapi_entity_value(entity, 'start_width')
-            .data;
-        const endWidth = libredwg.dwg_dynapi_entity_value(entity, 'end_width')
-            .data;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
+        const flag = libredwg.dwg_dynapi_entity_data(entity, 'flag');
+        const smoothType = libredwg.dwg_dynapi_entity_data(entity, 'curve_type');
+        const startWidth = libredwg.dwg_dynapi_entity_data(entity, 'start_width');
+        const endWidth = libredwg.dwg_dynapi_entity_data(entity, 'end_width');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
         const vertices = libredwg.dwg_entity_polyline_3d_get_vertices(object);
         return {
             type: 'POLYLINE3D',
@@ -1123,14 +1303,12 @@ export class LibreEntityConverter {
     }
     convertProxyEntity(entity, commonAttrs, objectPtr) {
         const libredwg = this.libredwg;
-        const proxyEntityClassId = libredwg.dwg_dynapi_entity_value(entity, 'proxy_id').data;
-        const applicationEntityClassId = libredwg.dwg_dynapi_entity_value(entity, 'class_id').data;
-        const entityDataSize = libredwg.dwg_dynapi_entity_value(entity, 'data_numbits').data;
-        const objectDrawingFormat = libredwg.dwg_dynapi_entity_value(entity, 'version').data;
-        const fromDxf = libredwg.dwg_dynapi_entity_value(entity, 'from_dxf')
-            .data;
-        const numObjIds = libredwg.dwg_dynapi_entity_value(entity, 'num_objids')
-            .data;
+        const proxyEntityClassId = libredwg.dwg_dynapi_entity_data(entity, 'proxy_id');
+        const applicationEntityClassId = libredwg.dwg_dynapi_entity_data(entity, 'class_id');
+        const entityDataSize = libredwg.dwg_dynapi_entity_data(entity, 'data_numbits');
+        const objectDrawingFormat = libredwg.dwg_dynapi_entity_data(entity, 'version');
+        const fromDxf = libredwg.dwg_dynapi_entity_data(entity, 'from_dxf');
+        const numObjIds = libredwg.dwg_dynapi_entity_data(entity, 'num_objids');
         const graphicsBytes = libredwg.dwg_entity_get_preview(objectPtr);
         const graphicsDataSize = graphicsBytes?.length ?? 0;
         const entityBytes = libredwg.dwg_entity_proxy_entity_get_entity_data(entity);
@@ -1142,8 +1320,7 @@ export class LibreEntityConverter {
             : undefined;
         let linkedObjectIds;
         if (numObjIds > 0) {
-            const objidsPtr = libredwg.dwg_dynapi_entity_value(entity, 'objids')
-                .data;
+            const objidsPtr = libredwg.dwg_dynapi_entity_data(entity, 'objids');
             if (objidsPtr) {
                 const objids = libredwg.dwg_ptr_to_object_ref_array(objidsPtr, numObjIds);
                 linkedObjectIds = objids.map(ref => idToString(ref.absolute_ref));
@@ -1196,10 +1373,8 @@ export class LibreEntityConverter {
     }
     convertRay(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const firstPoint = libredwg.dwg_dynapi_entity_value(entity, 'point')
-            .data;
-        const unitDirection = libredwg.dwg_dynapi_entity_value(entity, 'vector')
-            .data;
+        const firstPoint = libredwg.dwg_dynapi_entity_data(entity, 'point');
+        const unitDirection = libredwg.dwg_dynapi_entity_data(entity, 'vector');
         return {
             type: 'RAY',
             ...commonAttrs,
@@ -1209,30 +1384,26 @@ export class LibreEntityConverter {
     }
     convertSection(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const state = libredwg.dwg_dynapi_entity_value(entity, 'state')
-            .data;
-        const flags = libredwg.dwg_dynapi_entity_value(entity, 'flag')
-            .data;
-        const name = libredwg.dwg_dynapi_entity_value(entity, 'name').data;
-        const verticalDirection = libredwg.dwg_dynapi_entity_value(entity, 'vert_dir').data;
-        const topHeight = libredwg.dwg_dynapi_entity_value(entity, 'top_height')
-            .data;
-        const bottomHeight = libredwg.dwg_dynapi_entity_value(entity, 'bottom_height').data;
-        const indicatorTransparency = libredwg.dwg_dynapi_entity_value(entity, 'indicator_alpha').data;
-        const indicatorColor = libredwg.dwg_dynapi_entity_value(entity, 'indicator_color').data;
-        const numberOfVertices = libredwg.dwg_dynapi_entity_value(entity, 'num_verts').data;
-        const vertices_ptr = libredwg.dwg_dynapi_entity_value(entity, 'verts')
-            .data;
+        const state = libredwg.dwg_dynapi_entity_data(entity, 'state');
+        const flags = libredwg.dwg_dynapi_entity_data(entity, 'flag');
+        const name = libredwg.dwg_dynapi_entity_data(entity, 'name');
+        const verticalDirection = libredwg.dwg_dynapi_entity_data(entity, 'vert_dir');
+        const topHeight = libredwg.dwg_dynapi_entity_data(entity, 'top_height');
+        const bottomHeight = libredwg.dwg_dynapi_entity_data(entity, 'bottom_height');
+        const indicatorTransparency = libredwg.dwg_dynapi_entity_data(entity, 'indicator_alpha');
+        const indicatorColor = libredwg.dwg_dynapi_entity_data(entity, 'indicator_color');
+        const numberOfVertices = libredwg.dwg_dynapi_entity_data(entity, 'num_verts');
+        const vertices_ptr = libredwg.dwg_dynapi_entity_data(entity, 'verts');
         const vertices = numberOfVertices > 0
             ? libredwg.dwg_ptr_to_point3d_array(vertices_ptr, numberOfVertices)
             : [];
-        const numberOfBackLineVertices = libredwg.dwg_dynapi_entity_value(entity, 'num_blverts').data;
-        const backLineVertices_ptr = libredwg.dwg_dynapi_entity_value(entity, 'blverts').data;
+        const numberOfBackLineVertices = libredwg.dwg_dynapi_entity_data(entity, 'num_blverts');
+        const backLineVertices_ptr = libredwg.dwg_dynapi_entity_data(entity, 'blverts');
         const backLineVertices = numberOfBackLineVertices > 0
             ? libredwg.dwg_ptr_to_point3d_array(backLineVertices_ptr, numberOfBackLineVertices)
             : [];
-        const geometrySettingHandle = libredwg.dwg_dynapi_entity_value(entity, 'geometrySettingHardId').data;
-        const geometrySettingHardId = libredwg.dwg_ref_get_handle_absolute_ref(geometrySettingHandle);
+        const geometrySettingHandle = libredwg.dwg_dynapi_entity_data(entity, 'geometrySettingHardId');
+        const geometrySettingHardId = libredwg.dwg_ref_get_handle_absolute_ref(geometrySettingHandle) ?? 0n;
         return {
             type: 'SECTION',
             ...commonAttrs,
@@ -1251,19 +1422,40 @@ export class LibreEntityConverter {
             geometrySettingHardId: geometrySettingHardId
         };
     }
+    convertShape(entity, commonAttrs) {
+        const libredwg = this.libredwg;
+        const insertionPoint = libredwg.dwg_dynapi_entity_data(entity, 'ins_pt');
+        const size = libredwg.dwg_dynapi_entity_data(entity, 'scale');
+        const rotation = libredwg.dwg_dynapi_entity_data(entity, 'rotation');
+        const xScale = libredwg.dwg_dynapi_entity_data(entity, 'width_factor');
+        const obliqueAngle = libredwg.dwg_dynapi_entity_data(entity, 'oblique_angle');
+        const thickness = libredwg.dwg_dynapi_entity_data(entity, 'thickness');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
+        const shapeNumber = libredwg.dwg_dynapi_entity_data(entity, 'style_id');
+        const styleName = libredwg.dwg_entity_text_get_style_name(entity);
+        return {
+            type: 'SHAPE',
+            subclassMarker: 'AcDbShape',
+            ...commonAttrs,
+            thickness: thickness,
+            insertionPoint: insertionPoint,
+            size: size,
+            shapeNumber: shapeNumber,
+            styleName: styleName,
+            rotation: rotation,
+            xScale: xScale,
+            obliqueAngle: obliqueAngle,
+            extrusionDirection: extrusionDirection
+        };
+    }
     convertSolid(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const corner1 = libredwg.dwg_dynapi_entity_value(entity, 'corner1')
-            .data;
-        const corner2 = libredwg.dwg_dynapi_entity_value(entity, 'corner2')
-            .data;
-        const corner3 = libredwg.dwg_dynapi_entity_value(entity, 'corner3')
-            .data;
-        const corner4 = libredwg.dwg_dynapi_entity_value(entity, 'corner4')
-            .data;
-        const thickness = libredwg.dwg_dynapi_entity_value(entity, 'thickness')
-            .data;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
+        const corner1 = libredwg.dwg_dynapi_entity_data(entity, 'corner1');
+        const corner2 = libredwg.dwg_dynapi_entity_data(entity, 'corner2');
+        const corner3 = libredwg.dwg_dynapi_entity_data(entity, 'corner3');
+        const corner4 = libredwg.dwg_dynapi_entity_data(entity, 'corner4');
+        const thickness = libredwg.dwg_dynapi_entity_data(entity, 'thickness');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
         return {
             type: 'SOLID',
             ...commonAttrs,
@@ -1277,37 +1469,26 @@ export class LibreEntityConverter {
     }
     convertSpline(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const flag = libredwg.dwg_dynapi_entity_value(entity, 'splineflags')
-            .data;
-        const degree = libredwg.dwg_dynapi_entity_value(entity, 'degree')
-            .data;
+        const flag = libredwg.dwg_dynapi_entity_data(entity, 'splineflags');
+        const degree = libredwg.dwg_dynapi_entity_data(entity, 'degree');
         // Convert knots
-        const knotTolerance = libredwg.dwg_dynapi_entity_value(entity, 'knot_tol')
-            .data;
-        const numberOfKnots = libredwg.dwg_dynapi_entity_value(entity, 'num_knots')
-            .data;
-        const knots_ptr = libredwg.dwg_dynapi_entity_value(entity, 'knots')
-            .data;
+        const knotTolerance = libredwg.dwg_dynapi_entity_data(entity, 'knot_tol');
+        const numberOfKnots = libredwg.dwg_dynapi_entity_data(entity, 'num_knots');
+        const knots_ptr = libredwg.dwg_dynapi_entity_data(entity, 'knots');
         const knots = libredwg.dwg_ptr_to_double_array(knots_ptr, numberOfKnots);
         // Convert fit points
-        const fitTolerance = libredwg.dwg_dynapi_entity_value(entity, 'fit_tol')
-            .data;
-        const numberOfFitPoints = libredwg.dwg_dynapi_entity_value(entity, 'num_fit_pts').data;
-        const fit_pts_ptr = libredwg.dwg_dynapi_entity_value(entity, 'fit_pts')
-            .data;
+        const fitTolerance = libredwg.dwg_dynapi_entity_data(entity, 'fit_tol');
+        const numberOfFitPoints = libredwg.dwg_dynapi_entity_data(entity, 'num_fit_pts');
+        const fit_pts_ptr = libredwg.dwg_dynapi_entity_data(entity, 'fit_pts');
         const fitPoints = libredwg.dwg_ptr_to_point3d_array(fit_pts_ptr, numberOfFitPoints);
         // Convert control points
-        const weighted = libredwg.dwg_dynapi_entity_value(entity, 'weighted')
-            .data;
-        const controlTolerance = libredwg.dwg_dynapi_entity_value(entity, 'ctrl_tol').data;
-        const numberOfControlPoints = libredwg.dwg_dynapi_entity_value(entity, 'num_ctrl_pts').data;
-        const ctrl_pts_ptr = libredwg.dwg_dynapi_entity_value(entity, 'ctrl_pts')
-            .data;
+        const weighted = libredwg.dwg_dynapi_entity_data(entity, 'weighted');
+        const controlTolerance = libredwg.dwg_dynapi_entity_data(entity, 'ctrl_tol');
+        const numberOfControlPoints = libredwg.dwg_dynapi_entity_data(entity, 'num_ctrl_pts');
+        const ctrl_pts_ptr = libredwg.dwg_dynapi_entity_data(entity, 'ctrl_pts');
         const controlPoints = libredwg.dwg_ptr_to_point4d_array(ctrl_pts_ptr, numberOfControlPoints);
-        const startTangent = libredwg.dwg_dynapi_entity_value(entity, 'beg_tan_vec')
-            .data;
-        const endTangent = libredwg.dwg_dynapi_entity_value(entity, 'end_tan_vec')
-            .data;
+        const startTangent = libredwg.dwg_dynapi_entity_data(entity, 'beg_tan_vec');
+        const endTangent = libredwg.dwg_dynapi_entity_data(entity, 'end_tan_vec');
         return {
             type: 'SPLINE',
             ...commonAttrs,
@@ -1336,32 +1517,26 @@ export class LibreEntityConverter {
     }
     convertTable(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const name = libredwg.dwg_dynapi_subclass_value(entity, 'ldata', 'name')
-            .data;
-        const startPoint = libredwg.dwg_dynapi_entity_value(entity, 'ins_pt')
-            .data;
-        const directionVector = libredwg.dwg_dynapi_entity_value(entity, 'horiz_direction').data;
-        const tableValue = libredwg.dwg_dynapi_entity_value(entity, 'flag_for_table_value').data;
-        const rowCount = libredwg.dwg_dynapi_entity_value(entity, 'num_rows')
-            .data;
-        const columnCount = libredwg.dwg_dynapi_entity_value(entity, 'num_cols')
-            .data;
-        const row_heights_ptr = libredwg.dwg_dynapi_entity_value(entity, 'row_heights').data;
+        const name = libredwg.dwg_dynapi_subclass_data(entity, 'ldata', 'name');
+        const startPoint = libredwg.dwg_dynapi_entity_data(entity, 'ins_pt');
+        const directionVector = libredwg.dwg_dynapi_entity_data(entity, 'horiz_direction');
+        const tableValue = libredwg.dwg_dynapi_entity_data(entity, 'flag_for_table_value');
+        const rowCount = libredwg.dwg_dynapi_entity_data(entity, 'num_rows');
+        const columnCount = libredwg.dwg_dynapi_entity_data(entity, 'num_cols');
+        const row_heights_ptr = libredwg.dwg_dynapi_entity_data(entity, 'row_heights');
         const rowHeightArr = libredwg.dwg_ptr_to_double_array(row_heights_ptr, rowCount);
-        const col_widths_ptr = libredwg.dwg_dynapi_entity_value(entity, 'col_widths').data;
+        const col_widths_ptr = libredwg.dwg_dynapi_entity_data(entity, 'col_widths');
         const columnWidthArr = libredwg.dwg_ptr_to_double_array(col_widths_ptr, columnCount);
-        const table_style_ref = libredwg.dwg_dynapi_entity_value(entity, 'tablestyle').data;
-        const tableStyleId = idToString(libredwg.dwg_ref_get_absref(table_style_ref));
-        const block_header_ref = libredwg.dwg_dynapi_entity_value(entity, 'block_header').data;
-        const blockRecordHandle = idToString(libredwg.dwg_ref_get_absref(block_header_ref));
-        const overrideFlag = libredwg.dwg_dynapi_entity_value(entity, 'table_flag_override').data;
-        const borderColorOverrideFlag = libredwg.dwg_dynapi_entity_value(entity, 'border_color_overrides_flag').data;
-        const borderLineWeightOverrideFlag = libredwg.dwg_dynapi_entity_value(entity, 'border_lineweight_overrides_flag').data;
-        const borderVisibilityOverrideFlag = libredwg.dwg_dynapi_entity_value(entity, 'border_visibility_overrides_flag').data;
-        const num_cells = libredwg.dwg_dynapi_entity_value(entity, 'num_cells')
-            .data;
-        const cells_ptr = libredwg.dwg_dynapi_entity_value(entity, 'cells')
-            .data;
+        const table_style_ref = libredwg.dwg_dynapi_entity_data(entity, 'tablestyle');
+        const tableStyleId = (libredwg.dwg_ref_get_id(table_style_ref) ?? '');
+        const block_header_ref = libredwg.dwg_dynapi_entity_data(entity, 'block_header');
+        const blockRecordHandle = (libredwg.dwg_ref_get_id(block_header_ref) ?? '');
+        const overrideFlag = libredwg.dwg_dynapi_entity_data(entity, 'table_flag_override');
+        const borderColorOverrideFlag = libredwg.dwg_dynapi_entity_data(entity, 'border_color_overrides_flag');
+        const borderLineWeightOverrideFlag = libredwg.dwg_dynapi_entity_data(entity, 'border_lineweight_overrides_flag');
+        const borderVisibilityOverrideFlag = libredwg.dwg_dynapi_entity_data(entity, 'border_visibility_overrides_flag');
+        const num_cells = libredwg.dwg_dynapi_entity_data(entity, 'num_cells');
+        const cells_ptr = libredwg.dwg_dynapi_entity_data(entity, 'cells');
         const cells = libredwg.dwg_ptr_to_table_cell_array(cells_ptr, num_cells);
         return {
             type: 'ACAD_TABLE',
@@ -1386,61 +1561,48 @@ export class LibreEntityConverter {
         };
     }
     convertTableCells(cells) {
-        const converted = [];
-        cells.forEach(cell => {
-            return {
-                text: cell.text_value,
-                attachmentPoint: cell.cell_alignment,
-                textStyle: cell.text_style, // TODO: Set the text style name instead of handle
-                rotation: cell.rotation,
-                cellType: cell.type,
-                flagValue: cell.flags,
-                mergedValue: cell.is_merged_value,
-                autoFit: cell.is_autofit_flag,
-                // borderWidth?: number
-                // borderHeight?: number
-                topBorderVisibility: cell.top_visibility,
-                bottomBorderVisibility: cell.bottom_visibility,
-                leftBorderVisibility: cell.left_visibility,
-                rightBorderVisibility: cell.right_visibility,
-                overrideFlag: cell.cell_flag_override,
-                virtualEdgeFlag: cell.virtual_edge_flag,
-                // fieldObjetId?: string
-                blockTableRecordI: cell.block_handle.absolute_ref,
-                blockScale: cell.block_scale,
-                blockAttrNum: cell.attr_defs.length,
-                attrDefineId: cell.attr_defs.map(value => value.attdef.absolute_ref),
-                // attrText?: string
-                // textHeight: number
-                extendedCellFlags: cell.additional_data_flag
-            };
-        });
-        return converted;
+        return cells.map(cell => ({
+            text: cell.text_value,
+            attachmentPoint: cell.cell_alignment,
+            textStyle: cell.text_style
+                ? String(cell.text_style)
+                : undefined,
+            rotation: cell.rotation,
+            cellType: cell.type,
+            flagValue: cell.flags,
+            mergedValue: cell.is_merged_value,
+            autoFit: cell.is_autofit_flag,
+            topBorderVisibility: !!cell.top_visibility,
+            bottomBorderVisibility: !!cell.bottom_visibility,
+            leftBorderVisibility: !!cell.left_visibility,
+            rightBorderVisibility: !!cell.right_visibility,
+            overrideFlag: cell.cell_flag_override,
+            virtualEdgeFlag: cell.virtual_edge_flag,
+            blockTableRecordId: cell.block_handle
+                ? String(cell.block_handle.absolute_ref ?? '')
+                : undefined,
+            blockScale: cell.block_scale,
+            blockAttrNum: cell.attr_defs?.length ?? 0,
+            attrDefineId: cell.attr_defs?.map(value => String(value.attdef?.absolute_ref ?? '')),
+            textHeight: cell.text_height ?? 0,
+            extendedCellFlags: cell.additional_data_flag
+        }));
     }
     convertTextBase(entity) {
         const libredwg = this.libredwg;
-        const text = libredwg.dwg_dynapi_entity_value(entity, 'text_value')
-            .data;
-        const thickness = libredwg.dwg_dynapi_entity_value(entity, 'thickness')
-            .data;
-        const startPoint = libredwg.dwg_dynapi_entity_value(entity, 'ins_pt')
-            .data;
-        const endPoint = libredwg.dwg_dynapi_entity_value(entity, 'alignment_pt')
-            .data;
-        const rotation = libredwg.dwg_dynapi_entity_value(entity, 'rotation')
-            .data;
-        const textHeight = libredwg.dwg_dynapi_entity_value(entity, 'height')
-            .data;
-        const xScale = libredwg.dwg_dynapi_entity_value(entity, 'width_factor')
-            .data;
-        const obliqueAngle = libredwg.dwg_dynapi_entity_value(entity, 'oblique_angle').data;
+        const text = libredwg.dwg_dynapi_entity_data(entity, 'text_value');
+        const thickness = libredwg.dwg_dynapi_entity_data(entity, 'thickness');
+        const startPoint = libredwg.dwg_dynapi_entity_data(entity, 'ins_pt');
+        const endPoint = libredwg.dwg_dynapi_entity_data(entity, 'alignment_pt');
+        const rotation = libredwg.dwg_dynapi_entity_data(entity, 'rotation');
+        const textHeight = libredwg.dwg_dynapi_entity_data(entity, 'height');
+        const xScale = libredwg.dwg_dynapi_entity_data(entity, 'width_factor');
+        const obliqueAngle = libredwg.dwg_dynapi_entity_data(entity, 'oblique_angle');
         const styleName = libredwg.dwg_entity_text_get_style_name(entity);
-        const generationFlag = libredwg.dwg_dynapi_entity_value(entity, 'generation').data;
-        const halign = libredwg.dwg_dynapi_entity_value(entity, 'horiz_alignment')
-            .data;
-        const valign = libredwg.dwg_dynapi_entity_value(entity, 'vert_alignment')
-            .data;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
+        const generationFlag = libredwg.dwg_dynapi_entity_data(entity, 'generation');
+        const halign = libredwg.dwg_dynapi_entity_data(entity, 'horiz_alignment');
+        const valign = libredwg.dwg_dynapi_entity_data(entity, 'vert_alignment');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
         return {
             text: text,
             thickness: thickness,
@@ -1466,12 +1628,10 @@ export class LibreEntityConverter {
     }
     convertTolerance(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const insertionPoint = libredwg.dwg_dynapi_entity_value(entity, 'ins_pt')
-            .data;
-        const text = libredwg.dwg_dynapi_entity_value(entity, 'text_value')
-            .data;
-        const xAxisDirection = libredwg.dwg_dynapi_entity_value(entity, 'x_direction').data;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
+        const insertionPoint = libredwg.dwg_dynapi_entity_data(entity, 'ins_pt');
+        const text = libredwg.dwg_dynapi_entity_data(entity, 'text_value');
+        const xAxisDirection = libredwg.dwg_dynapi_entity_data(entity, 'x_direction');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
         const dimStyleName = libredwg.dwg_entity_get_dimstyle_name(entity);
         return {
             type: 'TOLERANCE',
@@ -1485,82 +1645,55 @@ export class LibreEntityConverter {
     }
     convertViewport(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const viewportCenter = libredwg.dwg_dynapi_entity_value(entity, 'center')
-            .data;
-        const width = libredwg.dwg_dynapi_entity_value(entity, 'width')
-            .data;
-        const height = libredwg.dwg_dynapi_entity_value(entity, 'height')
-            .data;
-        const status = libredwg.dwg_dynapi_entity_value(entity, 'on_off')
-            .data;
-        const displayCenter = libredwg.dwg_dynapi_entity_value(entity, 'VIEWCTR')
-            .data;
-        const snapBase = libredwg.dwg_dynapi_entity_value(entity, 'SNAPBASE')
-            .data;
-        const snapSpacing = libredwg.dwg_dynapi_entity_value(entity, 'SNAPUNIT')
-            .data;
-        const gridSpacing = libredwg.dwg_dynapi_entity_value(entity, 'GRIDUNIT')
-            .data;
-        const viewDirection = libredwg.dwg_dynapi_entity_value(entity, 'VIEWDIR')
-            .data;
-        const targetPoint = libredwg.dwg_dynapi_entity_value(entity, 'view_target')
-            .data;
-        const perspectiveLensLength = libredwg.dwg_dynapi_entity_value(entity, 'lens_length').data;
-        const frontClipZ = libredwg.dwg_dynapi_entity_value(entity, 'front_clip_z')
-            .data;
-        const backClipZ = libredwg.dwg_dynapi_entity_value(entity, 'back_clip_z')
-            .data;
+        const viewportCenter = libredwg.dwg_dynapi_entity_data(entity, 'center');
+        const width = libredwg.dwg_dynapi_entity_data(entity, 'width');
+        const height = libredwg.dwg_dynapi_entity_data(entity, 'height');
+        const status = libredwg.dwg_dynapi_entity_data(entity, 'on_off');
+        const displayCenter = libredwg.dwg_dynapi_entity_data(entity, 'VIEWCTR');
+        const snapBase = libredwg.dwg_dynapi_entity_data(entity, 'SNAPBASE');
+        const snapSpacing = libredwg.dwg_dynapi_entity_data(entity, 'SNAPUNIT');
+        const gridSpacing = libredwg.dwg_dynapi_entity_data(entity, 'GRIDUNIT');
+        const viewDirection = libredwg.dwg_dynapi_entity_data(entity, 'VIEWDIR');
+        const targetPoint = libredwg.dwg_dynapi_entity_data(entity, 'view_target');
+        const perspectiveLensLength = libredwg.dwg_dynapi_entity_data(entity, 'lens_length');
+        const frontClipZ = libredwg.dwg_dynapi_entity_data(entity, 'front_clip_z');
+        const backClipZ = libredwg.dwg_dynapi_entity_data(entity, 'back_clip_z');
         // TODO: I am not sure whether view size in libredwg represents view height
-        const viewHeight = libredwg.dwg_dynapi_entity_value(entity, 'VIEWSIZE')
-            .data;
-        const snapAngle = libredwg.dwg_dynapi_entity_value(entity, 'SNAPANG')
-            .data;
-        const viewTwistAngle = libredwg.dwg_dynapi_entity_value(entity, 'twist_angle').data;
-        const circleZoomPercent = libredwg.dwg_dynapi_entity_value(entity, 'circle_zoom').data;
+        const viewHeight = libredwg.dwg_dynapi_entity_data(entity, 'VIEWSIZE');
+        const snapAngle = libredwg.dwg_dynapi_entity_data(entity, 'SNAPANG');
+        const viewTwistAngle = libredwg.dwg_dynapi_entity_data(entity, 'twist_angle');
+        const circleZoomPercent = libredwg.dwg_dynapi_entity_data(entity, 'circle_zoom');
         // TODO: convert frozenLayerIds and clippingBoundaryId
-        const statusBitFlags = libredwg.dwg_dynapi_entity_value(entity, 'status_flag').data;
-        const sheetName = libredwg.dwg_dynapi_entity_value(entity, 'style_sheet')
-            .data;
-        const renderMode = libredwg.dwg_dynapi_entity_value(entity, 'render_mode')
-            .data;
+        const statusBitFlags = libredwg.dwg_dynapi_entity_data(entity, 'status_flag');
+        const sheetName = libredwg.dwg_dynapi_entity_data(entity, 'style_sheet');
+        const renderMode = libredwg.dwg_dynapi_entity_data(entity, 'render_mode');
         // TODO: Not sure whether UCSVP in libredwg represents ucsPerViewport
-        const ucsPerViewport = libredwg.dwg_dynapi_entity_value(entity, 'UCSVP')
-            .data;
-        const ucsOrigin = libredwg.dwg_dynapi_entity_value(entity, 'ucsorg')
-            .data;
-        const ucsXAxis = libredwg.dwg_dynapi_entity_value(entity, 'ucsxdir')
-            .data;
-        const ucsYAxis = libredwg.dwg_dynapi_entity_value(entity, 'ucsydir')
-            .data;
-        const named_ucs_ref = libredwg.dwg_dynapi_entity_value(entity, 'named_ucs')
-            .data;
-        const ucsId = libredwg.dwg_ref_get_absref(named_ucs_ref);
-        const base_ucs_ref = libredwg.dwg_dynapi_entity_value(entity, 'base_ucs')
-            .data;
-        const ucsBaseId = libredwg.dwg_ref_get_absref(base_ucs_ref);
+        const ucsPerViewport = libredwg.dwg_dynapi_entity_data(entity, 'UCSVP');
+        const ucsOrigin = libredwg.dwg_dynapi_entity_data(entity, 'ucsorg');
+        const ucsXAxis = libredwg.dwg_dynapi_entity_data(entity, 'ucsxdir');
+        const ucsYAxis = libredwg.dwg_dynapi_entity_data(entity, 'ucsydir');
+        const named_ucs_ref = libredwg.dwg_dynapi_entity_data(entity, 'named_ucs');
+        const ucsId = libredwg.dwg_ref_get_id(named_ucs_ref);
+        const base_ucs_ref = libredwg.dwg_dynapi_entity_data(entity, 'base_ucs');
+        const ucsBaseId = libredwg.dwg_ref_get_id(base_ucs_ref);
         // TODO: Not sure whether UCSORTHOVIEW represents orthographicType
-        const orthographicType = libredwg.dwg_dynapi_entity_value(entity, 'UCSORTHOVIEW').data;
-        const elevation = libredwg.dwg_dynapi_entity_value(entity, 'ucs_elevation')
-            .data;
-        const shadePlotMode = libredwg.dwg_dynapi_entity_value(entity, 'shadeplot_mode').data;
-        const isDefaultLighting = libredwg.dwg_dynapi_entity_value(entity, 'use_default_lights').data;
-        const defaultLightingType = libredwg.dwg_dynapi_entity_value(entity, 'default_lighting_type').data;
-        const brightness = libredwg.dwg_dynapi_entity_value(entity, 'brightness')
-            .data;
-        const contrast = libredwg.dwg_dynapi_entity_value(entity, 'contrast')
-            .data;
-        const majorGridFrequency = libredwg.dwg_dynapi_entity_value(entity, 'grid_major').data;
-        const background_ref = libredwg.dwg_dynapi_entity_value(entity, 'background').data;
-        const backgroundId = libredwg.dwg_ref_get_absref(background_ref);
-        const shadeplot_ref = libredwg.dwg_dynapi_entity_value(entity, 'shadeplot')
-            .data;
-        const shadePlotId = libredwg.dwg_ref_get_absref(shadeplot_ref);
-        const visualstyle_ref = libredwg.dwg_dynapi_entity_value(entity, 'visualstyle').data;
-        const visualStyleId = libredwg.dwg_ref_get_absref(visualstyle_ref);
+        const orthographicType = libredwg.dwg_dynapi_entity_data(entity, 'UCSORTHOVIEW');
+        const elevation = libredwg.dwg_dynapi_entity_data(entity, 'ucs_elevation');
+        const shadePlotMode = libredwg.dwg_dynapi_entity_data(entity, 'shadeplot_mode');
+        const isDefaultLighting = libredwg.dwg_dynapi_entity_data(entity, 'use_default_lights');
+        const defaultLightingType = libredwg.dwg_dynapi_entity_data(entity, 'default_lighting_type');
+        const brightness = libredwg.dwg_dynapi_entity_data(entity, 'brightness');
+        const contrast = libredwg.dwg_dynapi_entity_data(entity, 'contrast');
+        const majorGridFrequency = libredwg.dwg_dynapi_entity_data(entity, 'grid_major');
+        const background_ref = libredwg.dwg_dynapi_entity_data(entity, 'background');
+        const backgroundId = libredwg.dwg_ref_get_id(background_ref);
+        const shadeplot_ref = libredwg.dwg_dynapi_entity_data(entity, 'shadeplot');
+        const shadePlotId = libredwg.dwg_ref_get_id(shadeplot_ref);
+        const visualstyle_ref = libredwg.dwg_dynapi_entity_data(entity, 'visualstyle');
+        const visualStyleId = libredwg.dwg_ref_get_id(visualstyle_ref);
         // TODO: convert ambientLightColor
-        const sun_ref = libredwg.dwg_dynapi_entity_value(entity, 'sun')
-            .data;
-        const sunId = libredwg.dwg_ref_get_absref(sun_ref);
+        const sun_ref = libredwg.dwg_dynapi_entity_data(entity, 'sun');
+        const sunId = libredwg.dwg_ref_get_id(sun_ref);
         return {
             type: 'VIEWPORT',
             ...commonAttrs,
@@ -1589,55 +1722,43 @@ export class LibreEntityConverter {
             ucsOrigin: ucsOrigin,
             ucsXAxis: ucsXAxis,
             ucsYAxis: ucsYAxis,
-            ucsId: idToString(ucsId),
-            ucsBaseId: idToString(ucsBaseId),
+            ucsId: ucsId ?? '',
+            ucsBaseId: ucsBaseId ?? '',
             orthographicType: orthographicType,
             elevation: elevation,
             shadePlotMode: shadePlotMode,
             majorGridFrequency: majorGridFrequency,
-            backgroundId: idToString(backgroundId),
-            shadePlotId: idToString(shadePlotId),
-            visualStyleId: idToString(visualStyleId),
+            backgroundId: backgroundId ?? '',
+            shadePlotId: shadePlotId ?? '',
+            visualStyleId: visualStyleId ?? '',
             isDefaultLighting: !!isDefaultLighting,
             defaultLightingType: defaultLightingType,
             brightness: brightness,
             contrast: contrast,
-            sunId: idToString(sunId)
+            sunId: sunId ?? ''
         };
     }
     convertWipeout(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const version = libredwg.dwg_dynapi_entity_value(entity, 'class_version')
-            .data;
-        const position = libredwg.dwg_dynapi_entity_value(entity, 'pt0')
-            .data;
-        const uPixel = libredwg.dwg_dynapi_entity_value(entity, 'uvec')
-            .data;
-        const vPixel = libredwg.dwg_dynapi_entity_value(entity, 'vvec')
-            .data;
-        const imageSize = libredwg.dwg_dynapi_entity_value(entity, 'image_size')
-            .data;
-        const flags = libredwg.dwg_dynapi_entity_value(entity, 'display_props')
-            .data;
-        const clipping = libredwg.dwg_dynapi_entity_value(entity, 'clipping')
-            .data;
-        const brightness = libredwg.dwg_dynapi_entity_value(entity, 'brightness')
-            .data;
-        const contrast = libredwg.dwg_dynapi_entity_value(entity, 'contrast')
-            .data;
-        const fade = libredwg.dwg_dynapi_entity_value(entity, 'fade').data;
-        const clipMode = libredwg.dwg_dynapi_entity_value(entity, 'clip_mode')
-            .data;
-        const clippingBoundaryType = libredwg.dwg_dynapi_entity_value(entity, 'clip_boundary_type').data;
-        const countBoundaryPoints = libredwg.dwg_dynapi_entity_value(entity, 'num_clip_verts').data;
-        const clip_verts = libredwg.dwg_dynapi_entity_value(entity, 'clip_verts')
-            .data;
+        const version = libredwg.dwg_dynapi_entity_data(entity, 'class_version');
+        const position = libredwg.dwg_dynapi_entity_data(entity, 'pt0');
+        const uPixel = libredwg.dwg_dynapi_entity_data(entity, 'uvec');
+        const vPixel = libredwg.dwg_dynapi_entity_data(entity, 'vvec');
+        const imageSize = libredwg.dwg_dynapi_entity_data(entity, 'image_size');
+        const flags = libredwg.dwg_dynapi_entity_data(entity, 'display_props');
+        const clipping = libredwg.dwg_dynapi_entity_data(entity, 'clipping');
+        const brightness = libredwg.dwg_dynapi_entity_data(entity, 'brightness');
+        const contrast = libredwg.dwg_dynapi_entity_data(entity, 'contrast');
+        const fade = libredwg.dwg_dynapi_entity_data(entity, 'fade');
+        const clipMode = libredwg.dwg_dynapi_entity_data(entity, 'clip_mode');
+        const clippingBoundaryType = libredwg.dwg_dynapi_entity_data(entity, 'clip_boundary_type');
+        const countBoundaryPoints = libredwg.dwg_dynapi_entity_data(entity, 'num_clip_verts');
+        const clip_verts = libredwg.dwg_dynapi_entity_data(entity, 'clip_verts');
         const clippingBoundaryPath = libredwg.dwg_ptr_to_point2d_array(clip_verts, countBoundaryPoints);
-        const imagedef_ref = libredwg.dwg_dynapi_entity_value(entity, 'imagedef')
-            .data;
-        const imageDefHandle = libredwg.dwg_ref_get_absref(imagedef_ref);
-        const imagedefreactor_ref = libredwg.dwg_dynapi_entity_value(entity, 'imagedefreactor').data;
-        const imageDefReactorHandle = libredwg.dwg_ref_get_absref(imagedefreactor_ref);
+        const imagedef_ref = libredwg.dwg_dynapi_entity_data(entity, 'imagedef');
+        const imageDefHandle = libredwg.dwg_ref_get_absref(imagedef_ref) ?? 0;
+        const imagedefreactor_ref = libredwg.dwg_dynapi_entity_data(entity, 'imagedefreactor');
+        const imageDefReactorHandle = libredwg.dwg_ref_get_absref(imagedefreactor_ref) ?? 0;
         return {
             type: 'WIPEOUT',
             ...commonAttrs,
@@ -1661,10 +1782,8 @@ export class LibreEntityConverter {
     }
     convertXline(entity, commonAttrs) {
         const libredwg = this.libredwg;
-        const firstPoint = libredwg.dwg_dynapi_entity_value(entity, 'point')
-            .data;
-        const unitDirection = libredwg.dwg_dynapi_entity_value(entity, 'vector')
-            .data;
+        const firstPoint = libredwg.dwg_dynapi_entity_data(entity, 'point');
+        const unitDirection = libredwg.dwg_dynapi_entity_data(entity, 'vector');
         return {
             type: 'XLINE',
             ...commonAttrs,
@@ -1674,26 +1793,20 @@ export class LibreEntityConverter {
     }
     getDimensionCommonAttrs(entity) {
         const libredwg = this.libredwg;
-        const version = libredwg.dwg_dynapi_entity_value(entity, 'class_version')
-            .data;
+        const version = libredwg.dwg_dynapi_entity_data(entity, 'class_version');
         const name = libredwg.dwg_entity_get_block_name(entity, 'block');
-        const definitionPoint = libredwg.dwg_dynapi_entity_value(entity, 'def_pt')
-            .data;
-        const textPoint = libredwg.dwg_dynapi_entity_value(entity, 'text_midpt')
-            .data;
-        const attachmentPoint = libredwg.dwg_dynapi_entity_value(entity, 'attachmentPoint').data;
-        const dimensionType = libredwg.dwg_dynapi_entity_value(entity, 'flag')
-            .data;
-        const textLineSpacingStyle = libredwg.dwg_dynapi_entity_value(entity, 'lspace_factor').data;
-        const textLineSpacingFactor = libredwg.dwg_dynapi_entity_value(entity, 'lspace_factor').data;
-        const measurement = libredwg.dwg_dynapi_entity_value(entity, 'act_measurement').data;
-        const text = libredwg.dwg_dynapi_entity_value(entity, 'user_text')
-            .data;
-        const textRotation = libredwg.dwg_dynapi_entity_value(entity, 'text_rotation').data;
+        const definitionPoint = libredwg.dwg_dynapi_entity_data(entity, 'def_pt');
+        const textPoint = libredwg.dwg_dynapi_entity_data(entity, 'text_midpt');
+        const attachmentPoint = libredwg.dwg_dynapi_entity_data(entity, 'attachmentPoint');
+        const dimensionType = libredwg.dwg_dynapi_entity_data(entity, 'flag');
+        const textLineSpacingStyle = libredwg.dwg_dynapi_entity_data(entity, 'lspace_factor');
+        const textLineSpacingFactor = libredwg.dwg_dynapi_entity_data(entity, 'lspace_factor');
+        const measurement = libredwg.dwg_dynapi_entity_data(entity, 'act_measurement');
+        const text = libredwg.dwg_dynapi_entity_data(entity, 'user_text');
+        const textRotation = libredwg.dwg_dynapi_entity_data(entity, 'text_rotation');
         // TODO: Not sure whether 'ins_rotation' is 'ocsRotation'.
-        const ocsRotation = libredwg.dwg_dynapi_entity_value(entity, 'ins_rotation')
-            .data;
-        const extrusionDirection = libredwg.dwg_dynapi_entity_value(entity, 'extrusion').data;
+        const ocsRotation = libredwg.dwg_dynapi_entity_data(entity, 'ins_rotation');
+        const extrusionDirection = libredwg.dwg_dynapi_entity_data(entity, 'extrusion');
         const styleName = libredwg.dwg_entity_get_dimstyle_name(entity);
         return {
             type: 'DIMENSION',