@mlightcad/libredwg-web 0.7.6 → 0.7.8

package/lib/converter/converter.js

@@ -42,9 +42,12 @@ export class LibreDwgConverter {
             objects: {
                 DICTIONARY: [],
                 IMAGEDEF: [],
+                LAYER_FILTER: [],
+                LAYER_INDEX: [],
                 LAYOUT: [],
                 MLEADERSTYLE: [],
-                SPATIAL_FILTER: []
+                SPATIAL_FILTER: [],
+                XRECORD: []
             },
             header: {},
             entities: [],
@@ -127,6 +130,12 @@ export class LibreDwgConverter {
                         case Dwg_Object_Type.DWG_TYPE_IMAGEDEF:
                             db.objects.IMAGEDEF.push(this.convertImageDef(tio, obj));
                             break;
+                        case Dwg_Object_Type.DWG_TYPE_LAYERFILTER:
+                            db.objects.LAYER_FILTER.push(this.convertLayerFilter(tio, obj));
+                            break;
+                        case Dwg_Object_Type.DWG_TYPE_LAYER_INDEX:
+                            db.objects.LAYER_INDEX.push(this.convertLayerIndex(tio, obj));
+                            break;
                         case Dwg_Object_Type.DWG_TYPE_LAYOUT:
                             db.objects.LAYOUT.push(this.convertLayout(tio, obj));
                             break;
@@ -136,6 +145,9 @@ export class LibreDwgConverter {
                         case Dwg_Object_Type.DWG_TYPE_SPATIAL_FILTER:
                             db.objects.SPATIAL_FILTER.push(this.convertSpatialFilter(tio, obj));
                             break;
+                        case Dwg_Object_Type.DWG_TYPE_XRECORD:
+                            db.objects.XRECORD.push(this.convertXRecord(tio, obj));
+                            break;
                         default:
                             break;
                     }
@@ -741,6 +753,50 @@ export class LibreDwgConverter {
             resolutionUnits: resolutionUnits
         };
     }
+    convertLayerFilter(item, obj) {
+        const libredwg = this.libredwg;
+        const commonAttrs = this.getCommonObjectAttrs(obj);
+        const numNames = libredwg.dwg_dynapi_entity_data(item, 'num_names') ?? 0;
+        const namesPtr = libredwg.dwg_dynapi_entity_data(item, 'names');
+        const layerNames = namesPtr && numNames > 0
+            ? libredwg
+                .dwg_ptr_to_wchar_string_array(namesPtr, numNames)
+                .filter((name) => name != null && name !== '')
+            : [];
+        return {
+            ...commonAttrs,
+            ...(layerNames.length ? { layerNames } : {})
+        };
+    }
+    convertLayerIndex(item, obj) {
+        const libredwg = this.libredwg;
+        const commonAttrs = this.getCommonObjectAttrs(obj);
+        const timeStamp = libredwg.dwg_dynapi_entity_data(item, 'last_updated');
+        const numEntries = libredwg.dwg_dynapi_entity_data(item, 'num_entries') ?? 0;
+        const entriesPtr = libredwg.dwg_dynapi_entity_data(item, 'entries');
+        const entrySize = libredwg.dwg_dynapi_subclass_size('LAYER_entry');
+        const layerNames = [];
+        const idBufferIds = [];
+        const idBufferEntryCounts = [];
+        if (entriesPtr && entrySize > 0) {
+            for (let i = 0; i < numEntries; i++) {
+                const entryPtr = entriesPtr + i * entrySize;
+                const name = libredwg.dwg_dynapi_subclass_data(entryPtr, 'LAYER_entry', 'name');
+                // Keep parallel arrays aligned with entries even when name is absent.
+                layerNames.push(name ?? '');
+                const handleRef = libredwg.dwg_dynapi_subclass_data(entryPtr, 'LAYER_entry', 'handle');
+                idBufferIds.push(handleRef ? (libredwg.dwg_ref_get_id(handleRef) ?? '') : '');
+                idBufferEntryCounts.push(libredwg.dwg_dynapi_subclass_data(entryPtr, 'LAYER_entry', 'numlayers') ?? 0);
+            }
+        }
+        return {
+            ...commonAttrs,
+            ...(timeStamp != null ? { timeStamp } : {}),
+            ...(layerNames.length ? { layerNames } : {}),
+            ...(idBufferIds.length ? { idBufferIds } : {}),
+            ...(idBufferEntryCounts.length ? { idBufferEntryCounts } : {})
+        };
+    }
     convertLayout(item, obj) {
         const libredwg = this.libredwg;
         const commonAttrs = this.getCommonObjectAttrs(obj);
@@ -879,6 +935,25 @@ export class LibreDwgConverter {
             invertBlockMatrix: invertBlockMatrix
         };
     }
+    convertXRecord(item, obj) {
+        const libredwg = this.libredwg;
+        const commonAttrs = this.getCommonObjectAttrs(obj);
+        const cloning = libredwg.dwg_dynapi_entity_data(item, 'cloning');
+        const data = libredwg.dwg_object_xrecord_get_xdata(item) ?? [];
+        const objectObj = libredwg.dwg_object_get_tio(obj);
+        const xdic = objectObj
+            ? libredwg.dwg_object_object_get_xdicobjhandle_object(objectObj)
+            : null;
+        const extensionDictionary = xdic && xdic.absolute_ref
+            ? idToString(xdic.absolute_ref)
+            : undefined;
+        return {
+            ...commonAttrs,
+            ...(cloning != null ? { cloning } : {}),
+            ...(extensionDictionary ? { extensionDictionary } : {}),
+            data
+        };
+    }
     getCommonObjectAttrs(obj) {
         const libredwg = this.libredwg;
         const object_tio = libredwg.dwg_object_get_tio(obj);

package/lib/converter/entityConverter.d.ts

@@ -13,6 +13,7 @@ export declare class LibreEntityConverter {
     clear(): void;
     convert(object_ptr: Dwg_Object_Ptr): DwgEntity | undefined;
     private convert3dFace;
+    private convert3dSolid;
     private convertArc;
     private convertEmbeddedMText;
     private convertAttdef;
@@ -20,6 +21,7 @@ export declare class LibreEntityConverter {
     private convertCircle;
     private convertAlignedDimension;
     private convert3PointAngularDimension;
+    private convert2LineAngularDimension;
     private convertDiameterDimension;
     private convertOrdinateDimension;
     private convertRadiusDimension;

package/lib/converter/entityConverter.js

@@ -1,7 +1,7 @@
 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';
+import { decodeOle2FrameCornersFromData, idToString, uint8ArrayToHexString } from './utils';
 export class LibreEntityConverter {
     libredwg;
     layers = new Map();
@@ -49,6 +49,9 @@ export class LibreEntityConverter {
             if (fixedtype == Dwg_Object_Type.DWG_TYPE_3DFACE) {
                 return this.convert3dFace(entity_tio, commonAttrs);
             }
+            else if (fixedtype == Dwg_Object_Type.DWG_TYPE_3DSOLID) {
+                return this.convert3dSolid(entity_tio, commonAttrs);
+            }
             else if (fixedtype == Dwg_Object_Type.DWG_TYPE_ARC) {
                 return this.convertArc(entity_tio, commonAttrs);
             }
@@ -69,6 +72,9 @@ export class LibreEntityConverter {
             else if (fixedtype == Dwg_Object_Type.DWG_TYPE_DIMENSION_ANG3PT) {
                 return this.convert3PointAngularDimension(entity_tio, commonAttrs);
             }
+            else if (fixedtype == Dwg_Object_Type.DWG_TYPE_DIMENSION_ANG2LN) {
+                return this.convert2LineAngularDimension(entity_tio, commonAttrs);
+            }
             else if (fixedtype == Dwg_Object_Type.DWG_TYPE_DIMENSION_DIAMETER) {
                 return this.convertDiameterDimension(entity_tio, commonAttrs);
             }
@@ -182,6 +188,40 @@ export class LibreEntityConverter {
             flag: flag
         };
     }
+    convert3dSolid(entity, commonAttrs) {
+        const libredwg = this.libredwg;
+        const version = libredwg.dwg_dynapi_entity_data(entity, 'version');
+        const satCache = libredwg.dwg_dynapi_entity_data(entity, 'acis_empty');
+        const data = libredwg.dwg_dynapi_entity_data(entity, 'acis_data');
+        const hasRevisionGuid = libredwg.dwg_dynapi_entity_data(entity, 'has_revision_guid');
+        const historyRef = libredwg.dwg_dynapi_entity_data(entity, 'history_id');
+        const historyObjectSoftId = libredwg.dwg_ref_get_id(historyRef);
+        const result = {
+            type: '3DSOLID',
+            subclassMarker: 'AcDb3dSolid',
+            ...commonAttrs
+        };
+        if (version) {
+            result.version = version;
+        }
+        result.satCache = satCache;
+        if (data) {
+            result.data = data;
+        }
+        if (hasRevisionGuid) {
+            const guidOffset = libredwg.dwg_dynapi_entity_field_offset(entity, 'revision_guid');
+            if (guidOffset >= 0) {
+                const guid = libredwg.UTF8ToString(entity + guidOffset, 38);
+                if (guid) {
+                    result.guid = guid;
+                }
+            }
+        }
+        if (historyObjectSoftId) {
+            result.historyObjectSoftId = historyObjectSoftId;
+        }
+        return result;
+    }
     convertArc(entity, commonAttrs) {
         const libredwg = this.libredwg;
         const center = libredwg.dwg_dynapi_entity_data(entity, 'center');
@@ -376,6 +416,29 @@ export class LibreEntityConverter {
             arcPoint: arcPoint
         };
     }
+    convert2LineAngularDimension(entity, commonAttrs) {
+        const libredwg = this.libredwg;
+        const dimensionCommonAttrs = this.getDimensionCommonAttrs(entity);
+        const xline1Start = libredwg.dwg_dynapi_entity_data(entity, 'xline1start_pt');
+        const xline1End = libredwg.dwg_dynapi_entity_data(entity, 'xline1end_pt');
+        const xline2Start = libredwg.dwg_dynapi_entity_data(entity, 'xline2start_pt');
+        const xline2End = libredwg.dwg_dynapi_entity_data(entity, 'xline2end_pt');
+        const vertexPoint = libredwg.dwg_dynapi_entity_data(entity, 'def_pt');
+        // For 2-line angular dimensions DXF group 10 is the arc location (xline2end_pt),
+        // not def_pt which stores the dimension line location (DXF group 16).
+        if (xline2End) {
+            dimensionCommonAttrs.definitionPoint = xline2End;
+        }
+        return {
+            subclassMarker: 'AcDb2LineAngularDimension',
+            ...commonAttrs,
+            ...dimensionCommonAttrs,
+            subDefinitionPoint1: xline1Start ?? xline1End ?? vertexPoint ?? xline2End,
+            subDefinitionPoint2: xline2Start ?? xline2End ?? vertexPoint ?? xline1End,
+            centerPoint: vertexPoint ?? xline2Start ?? xline1End ?? xline2End,
+            arcPoint: xline2End ?? dimensionCommonAttrs.definitionPoint
+        };
+    }
     convertDiameterDimension(entity, commonAttrs) {
         const libredwg = this.libredwg;
         const dimensionCommonAttrs = this.getDimensionCommonAttrs(entity);
@@ -1124,12 +1187,22 @@ export class LibreEntityConverter {
         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');
+        let leftUpPoint = libredwg.dwg_dynapi_entity_data(entity, 'pt1');
+        let 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');
+        // Prefer sized TF copy: dynapi TF truncates at the first embedded NUL.
+        const dataBytes = libredwg.dwg_entity_ole2frame_get_data(entity);
+        const binaryData = dataBytes ? uint8ArrayToHexString(dataBytes) : '';
+        // Prefer corners decoded from the OLE header (also fixed in dwg_decode_ole2).
+        if (dataBytes) {
+            const corners = decodeOle2FrameCornersFromData(dataBytes);
+            if (corners) {
+                leftUpPoint = corners.upperLeft;
+                rightDownPoint = corners.lowerRight;
+            }
+        }
         return {
             type: 'OLE2FRAME',
             ...commonAttrs,
@@ -1149,7 +1222,8 @@ export class LibreEntityConverter {
         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');
+        const dataBytes = libredwg.dwg_entity_oleframe_get_data(entity);
+        const binaryData = dataBytes ? uint8ArrayToHexString(dataBytes) : '';
         return {
             type: 'OLEFRAME',
             ...commonAttrs,

package/lib/converter/mleaderColorCodec.d.ts

@@ -0,0 +1,9 @@
+import { Dwg_Color } from '../types';
+/**
+ * Encodes a LibreDWG CMC color as the packed int32 used by MLEADER / MLEADERSTYLE DXF.
+ *
+ * LibreDWG exposes {@link Dwg_Color.index} (0, 1..255, 256). DXF stores the same
+ * semantics in a signed 32-bit raw value whose high byte is the color type flag.
+ */
+export declare function encodeDwgColorAsMLeaderRaw(color: Dwg_Color | undefined | null): number | undefined;
+//# sourceMappingURL=mleaderColorCodec.d.ts.map

package/lib/converter/mleaderColorCodec.js

@@ -0,0 +1,52 @@
+import { Dwg_Color_Method } from '../types';
+/** MLEADERSTYLE DXF raw-color type flag: ByLayer (high byte). */
+const RAW_COLOR_TYPE_BY_LAYER = 0xc0;
+/** MLEADERSTYLE DXF raw-color type flag: ByBlock (high byte). */
+const RAW_COLOR_TYPE_BY_BLOCK = 0xc1;
+/** MLEADERSTYLE DXF raw-color type flag: true color (high byte). */
+const RAW_COLOR_TYPE_RGB = 0xc2;
+/** MLEADERSTYLE DXF raw-color type flag: ACI (high byte). */
+const RAW_COLOR_TYPE_ACI = 0xc3;
+/** MLEADERSTYLE DXF raw-color type flag: none / window background. */
+const RAW_COLOR_TYPE_WINDOW_BG = 0xc8;
+/**
+ * Encodes a LibreDWG CMC color as the packed int32 used by MLEADER / MLEADERSTYLE DXF.
+ *
+ * LibreDWG exposes {@link Dwg_Color.index} (0, 1..255, 256). DXF stores the same
+ * semantics in a signed 32-bit raw value whose high byte is the color type flag.
+ */
+export function encodeDwgColorAsMLeaderRaw(color) {
+    if (color == null)
+        return undefined;
+    const colorMethod = color.method;
+    const method = color.method != null && colorMethod !== 0
+        ? colorMethod
+        : (color.rgb >>> 24) & 0xff;
+    const index = color.index;
+    if (method === Dwg_Color_Method.ByLayer || index === 256) {
+        return (RAW_COLOR_TYPE_BY_LAYER << 24) >> 0;
+    }
+    if (method === Dwg_Color_Method.ByBlock || index === 0) {
+        return (RAW_COLOR_TYPE_BY_BLOCK << 24) >> 0;
+    }
+    if (method === Dwg_Color_Method.None) {
+        return (RAW_COLOR_TYPE_WINDOW_BG << 24) >> 0;
+    }
+    if (method === Dwg_Color_Method.TrueColor) {
+        const rgb = color.rgb != null ? color.rgb & 0xffffff : undefined;
+        if (rgb != null) {
+            return ((RAW_COLOR_TYPE_RGB << 24) | rgb) >> 0;
+        }
+    }
+    if (method === Dwg_Color_Method.ForegroundColor) {
+        return ((RAW_COLOR_TYPE_ACI << 24) | 7) >> 0;
+    }
+    if (method === Dwg_Color_Method.Entities && index > 0 && index < 256) {
+        return ((RAW_COLOR_TYPE_ACI << 24) | (index & 0xff)) >> 0;
+    }
+    if (index > 0 && index < 256) {
+        return ((RAW_COLOR_TYPE_ACI << 24) | (index & 0xff)) >> 0;
+    }
+    return undefined;
+}
+//# sourceMappingURL=mleaderColorCodec.js.map

package/lib/converter/stringConverter.d.ts

@@ -0,0 +1,3 @@
+import { DwgCodePage } from "../database";
+export declare const decodeString: (array: Uint8Array, codepage: DwgCodePage) => string;
+//# sourceMappingURL=stringConverter.d.ts.map

package/lib/converter/stringConverter.js

@@ -0,0 +1,7 @@
+import { dwgCodePageToEncoding } from "../database";
+export const decodeString = (array, codepage) => {
+    const encoding = dwgCodePageToEncoding(codepage);
+    const decoder = new TextDecoder(encoding);
+    return decoder.decode(array);
+};
+//# sourceMappingURL=stringConverter.js.map

package/lib/converter/utils.d.ts

@@ -2,4 +2,25 @@ export declare const isModelSpace: (name: string) => boolean | "";
 export declare const isPaperSpace: (name: string) => boolean | "";
 export declare const idToString: (id: number | bigint) => string;
 export declare const uint8ArrayToHexString: (bytes: Uint8Array) => string;
+/**
+ * OLE2FRAME binary payloads begin with a 0x80-byte Autodesk header, then an
+ * MS-CFB compound document. Corner points for DXF groups 10/11 are stored in
+ * that header (also decoded by `dwg_decode_ole2`).
+ *
+ * Layout after a 2-byte unknown prefix (`0x80 0x55` in common files):
+ * four WCS corners as little-endian 3D doubles (upper-left, upper-right,
+ * lower-right, lower-left). DXF group codes 10/11 store the first and third.
+ */
+export declare const decodeOle2FrameCornersFromData: (data: Uint8Array) => {
+    upperLeft: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    lowerRight: {
+        x: number;
+        y: number;
+        z: number;
+    };
+} | null;
 //# sourceMappingURL=utils.d.ts.map

package/lib/converter/utils.js

@@ -16,4 +16,31 @@ export const uint8ArrayToHexString = (bytes) => {
     }
     return hexChars.join('');
 };
+/**
+ * OLE2FRAME binary payloads begin with a 0x80-byte Autodesk header, then an
+ * MS-CFB compound document. Corner points for DXF groups 10/11 are stored in
+ * that header (also decoded by `dwg_decode_ole2`).
+ *
+ * Layout after a 2-byte unknown prefix (`0x80 0x55` in common files):
+ * four WCS corners as little-endian 3D doubles (upper-left, upper-right,
+ * lower-right, lower-left). DXF group codes 10/11 store the first and third.
+ */
+export const decodeOle2FrameCornersFromData = (data) => {
+    // 2-byte prefix + 4 corners * 3 doubles * 8 bytes = 98 bytes
+    if (!data || data.length < 98) {
+        return null;
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const readPoint = (offset) => ({
+        x: view.getFloat64(offset, true),
+        y: view.getFloat64(offset + 8, true),
+        z: view.getFloat64(offset + 16, true)
+    });
+    const upperLeft = readPoint(2);
+    const lowerRight = readPoint(2 + 48);
+    if (![upperLeft.x, upperLeft.y, upperLeft.z, lowerRight.x, lowerRight.y, lowerRight.z].every(Number.isFinite)) {
+        return null;
+    }
+    return { upperLeft, lowerRight };
+};
 //# sourceMappingURL=utils.js.map

package/lib/database/database.d.ts

@@ -1,7 +1,7 @@
 import { DwgClass } from './classes';
 import { DwgEntity } from './entities';
 import { DwgHeader } from './header';
-import { DwgDictionaryObject, DwgImageDefObject, DwgLayoutObject, DwgMLeaderStyleObject, DwgSpatialFilterObject } from './objects';
+import { DwgDictionaryObject, DwgImageDefObject, DwgLayerFilterObject, DwgLayerIndexObject, DwgLayoutObject, DwgMLeaderStyleObject, DwgSpatialFilterObject, DwgXRecordObject } from './objects';
 import { DwgAppIdEntry, DwgBlockRecordTableEntry, DwgDimStyleTableEntry, DwgLayerTableEntry, DwgLTypeTableEntry, DwgStyleTableEntry, DwgTable, DwgVPortTableEntry } from './tables';
 export interface DwgDatabase {
     tables: {
@@ -16,9 +16,12 @@ export interface DwgDatabase {
     objects: {
         DICTIONARY: DwgDictionaryObject[];
         IMAGEDEF: DwgImageDefObject[];
+        LAYER_FILTER: DwgLayerFilterObject[];
+        LAYER_INDEX: DwgLayerIndexObject[];
         LAYOUT: DwgLayoutObject[];
         MLEADERSTYLE: DwgMLeaderStyleObject[];
         SPATIAL_FILTER: DwgSpatialFilterObject[];
+        XRECORD: DwgXRecordObject[];
     };
     header: DwgHeader;
     /**

package/lib/database/entities/dimension.d.ts

@@ -166,7 +166,7 @@ export interface DwgAngularDimensionEntity extends DwgDimensionEntityCommon {
     /**
      * 	Subclass marker (AcDb3PointAngularDimension)
      */
-    subclassMarker: 'AcDb3PointAngularDimension';
+    subclassMarker: 'AcDb3PointAngularDimension' | 'AcDb2LineAngularDimension';
     /**
      * Definition point for linear and angular dimensions (in WCS)
      */

package/lib/database/entities/index.d.ts

@@ -24,6 +24,7 @@ export * from './ray';
 export * from './section';
 export * from './shape';
 export * from './solid';
+export * from './solid3d';
 export * from './spline';
 export * from './table';
 export * from './text';

package/lib/database/entities/index.js

@@ -24,6 +24,7 @@ export * from './ray';
 export * from './section';
 export * from './shape';
 export * from './solid';
+export * from './solid3d';
 export * from './spline';
 export * from './table';
 export * from './text';

package/lib/database/entities/solid3d.d.ts

@@ -0,0 +1,32 @@
+import { DwgEntity } from './entity';
+export interface DwgSolid3dEntity extends DwgEntity {
+    /**
+     * Entity type
+     */
+    type: '3DSOLID';
+    /**
+     * DXF subclass marker
+     */
+    subclassMarker: 'AcDb3dSolid';
+    /**
+     * Modeler format version number (currently = 1)
+     */
+    version?: number;
+    /**
+     * SAT cache flag (group 290, R2013+)
+     */
+    satCache?: number;
+    /**
+     * GUID string (group 2, R2013+)
+     */
+    guid?: string;
+    /**
+     * Proprietary ACIS/SAT data
+     */
+    data?: string;
+    /**
+     * Soft-owner ID/handle to history object
+     */
+    historyObjectSoftId?: string;
+}
+//# sourceMappingURL=solid3d.d.ts.map

package/lib/database/entities/solid3d.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=solid3d.js.map

package/lib/database/entities/unknown.d.ts

@@ -0,0 +1,7 @@
+export interface DwgUnknownEntity {
+    /**
+     * Entity type
+     */
+    type: 'UNKNOWN_ENTITY';
+}
+//# sourceMappingURL=unknown.d.ts.map

package/lib/database/entities/unknown.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=unknown.js.map

package/lib/database/objects/index.d.ts

@@ -1,8 +1,11 @@
 export * from './common';
 export * from './dictionary';
 export * from './imageDef';
+export * from './layerFilter';
+export * from './layerIndex';
 export * from './layout';
 export * from './mleaderStyle';
 export * from './plotSetting';
 export * from './spatialFilter';
+export * from './xrecord';
 //# sourceMappingURL=index.d.ts.map

package/lib/database/objects/index.js

@@ -1,8 +1,11 @@
 export * from './common';
 export * from './dictionary';
 export * from './imageDef';
+export * from './layerFilter';
+export * from './layerIndex';
 export * from './layout';
 export * from './mleaderStyle';
 export * from './plotSetting';
 export * from './spatialFilter';
+export * from './xrecord';
 //# sourceMappingURL=index.js.map

package/lib/database/objects/layerFilter.d.ts

@@ -0,0 +1,12 @@
+import { DwgCommonObject } from './common';
+/**
+ * DWG LAYER_FILTER / LAYERFILTER object fields.
+ *
+ * @remarks
+ * This shape mirrors the DXF LAYER_FILTER mapping used by ObjectARX / dxf-json.
+ */
+export interface DwgLayerFilterObject extends DwgCommonObject {
+    /** Layer names included in this filter. */
+    layerNames?: string[];
+}
+//# sourceMappingURL=layerFilter.d.ts.map

package/lib/database/objects/layerFilter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=layerFilter.js.map

package/lib/database/objects/layerIndex.d.ts

@@ -0,0 +1,18 @@
+import { DwgCommonObject } from './common';
+/**
+ * DWG LAYER_INDEX object fields.
+ *
+ * @remarks
+ * This shape mirrors the DXF LAYER_INDEX mapping used by ObjectARX / dxf-json.
+ */
+export interface DwgLayerIndexObject extends DwgCommonObject {
+    /** Julian / last-updated timestamp. */
+    timeStamp?: number;
+    /** Layer names included in this layer index. */
+    layerNames?: string[];
+    /** Hard-owner handles to IDBUFFER objects. */
+    idBufferIds?: string[];
+    /** Number of entries in each referenced IDBUFFER. */
+    idBufferEntryCounts?: number[];
+}
+//# sourceMappingURL=layerIndex.d.ts.map

package/lib/database/objects/layerIndex.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=layerIndex.js.map

package/lib/database/objects/unknown.d.ts

@@ -0,0 +1,7 @@
+export interface DwgUnknownObject {
+    /**
+     * Object type
+     */
+    type: 'UNKNOWN_OBJECT';
+}
+//# sourceMappingURL=unknown.d.ts.map

package/lib/database/objects/unknown.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=unknown.js.map

package/lib/database/objects/xrecord.d.ts

@@ -0,0 +1,30 @@
+import { DwgCommonObject } from './common';
+/**
+ * One DXF group-code / value pair stored in an XRECORD.
+ */
+export interface DwgXRecordGroup {
+    /** DXF group code. */
+    code: number;
+    /**
+     * Group value. Strings, numbers, booleans, handle hex strings, binary
+     * byte arrays, or `{ x, y, z }` for 3D points.
+     */
+    value: unknown;
+}
+/**
+ * DWG XRECORD object fields.
+ *
+ * @remarks
+ * Layer Manager filters (`ACAD_LAYERFILTERS` / `ACLYDICTIONARY`) store each
+ * filter node as an XRECORD under those dictionaries. The payload mirrors the
+ * DXF XRECORD `data` group list used by ObjectARX / dxf-json.
+ */
+export interface DwgXRecordObject extends DwgCommonObject {
+    /** Duplicate record cloning flag (DXF group 280). */
+    cloning?: number;
+    /** Extension dictionary handle, when the object has one. */
+    extensionDictionary?: string;
+    /** XRecord payload as DXF group pairs. */
+    data: DwgXRecordGroup[];
+}
+//# sourceMappingURL=xrecord.d.ts.map

package/lib/database/objects/xrecord.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=xrecord.js.map

package/lib/debug.d.ts

@@ -0,0 +1,13 @@
+export interface LibreDwgDebugOptions {
+    /** Master switch for all debug output. */
+    enabled: boolean;
+    /** Log proxy entity graphics/entity data resolution. */
+    proxyEntity: boolean;
+}
+export declare function getLibreDwgDebugOptions(): Readonly<LibreDwgDebugOptions>;
+export declare function setLibreDwgDebugOptions(partial: Partial<LibreDwgDebugOptions>): LibreDwgDebugOptions;
+export declare function resetLibreDwgDebugOptions(): void;
+export declare function isLibreDwgDebugEnabled(scope?: keyof Omit<LibreDwgDebugOptions, 'enabled'>): boolean;
+export declare function libreDwgDebugLog(scope: keyof Omit<LibreDwgDebugOptions, 'enabled'>, message: string, data?: unknown): void;
+export declare function hexPreview(bytes: Uint8Array | number[] | null | undefined, maxBytes?: number): string;
+//# sourceMappingURL=debug.d.ts.map