ofs-dxf-ts 1.0.0

package/dist/core/hatch-patterns.js

@@ -0,0 +1,214 @@
+/**
+ * Built-in hatch pattern definitions (ISO, millimetre based — as in acadiso.pat).
+ *
+ * Each line is `[angle, [baseX, baseY], [offsetX, offsetY], dashes]` exactly as
+ * stored in a DXF HATCH (group codes 53 / 43,44 / 45,46 / 49): the offset vector
+ * is already in world orientation. Scale/rotation are applied at serialization.
+ *
+ * A curated subset of ezdxf's ISO pattern table (MIT). Pass your own
+ * definition via `addHatch(..., { patternLines })` for anything not listed.
+ *
+ * GENERATED by tools/gen_hatch_patterns.py — do not edit by hand.
+ */
+export const HATCH_PATTERNS = {
+    'ANGLE': [
+        [0, [0, 0], [0, 13.97], [10.16, -3.81]],
+        [90, [0, 0], [-13.97, 0], [10.16, -3.81]],
+    ],
+    'ANSI31': [
+        [45, [0, 0], [-2.2450640303, 2.2450640303], []],
+    ],
+    'ANSI32': [
+        [45, [0, 0], [-6.7351920908, 6.7351920908], []],
+        [45, [4.490128053, 0], [-6.7351920908, 6.7351920908], []],
+    ],
+    'ANSI33': [
+        [45, [0, 0], [-4.4901280605, 4.4901280605], []],
+        [45, [4.490128053, 0], [-4.4901280605, 4.4901280605], [3.175, -1.5875]],
+    ],
+    'ANSI34': [
+        [45, [0, 0], [-13.4703841816, 13.4703841816], []],
+        [45, [4.490128053, 0], [-13.4703841816, 13.4703841816], []],
+        [45, [8.9802561314, 0], [-13.4703841816, 13.4703841816], []],
+        [45, [13.4703841844, 0], [-13.4703841816, 13.4703841816], []],
+    ],
+    'ANSI35': [
+        [45, [0, 0], [-4.4901280605, 4.4901280605], []],
+        [45, [4.490128053, 0], [-4.4901280605, 4.4901280605], [7.9375, -1.5875, 0, -1.5875]],
+    ],
+    'ANSI36': [
+        [45, [0, 0], [1.6837980227, 6.1739260832], [7.9375, -1.5875, 0, -1.5875]],
+    ],
+    'ANSI37': [
+        [45, [0, 0], [-2.2450640303, 2.2450640303], []],
+        [135, [0, 0], [-2.2450640303, -2.2450640303], []],
+    ],
+    'ANSI38': [
+        [45, [0, 0], [-2.2450640303, 2.2450640303], []],
+        [135, [0, 0], [-6.7351920908, 2.2450640303], [7.9375, -4.7625]],
+    ],
+    'AR-CONC': [
+        [50, [0, 0], [182.184668996, -15.9390855389], [19.05, -209.55]],
+        [355, [0, 0], [-35.243421425, 191.056845239], [15.24, -167.64058417]],
+        [100.4514447, [15.182007, -1.3282535], [146.9412470904, 175.1177519122], [16.1900088, -178.0902446]],
+        [46.1842, [0, 50.8], [271.0790408921, -42.0423279327], [28.575, -314.325]],
+        [96.63555761, [22.5899, 47.2965], [237.4041340515, 247.4261245977], [24.28502314, -267.13560816]],
+        [351.18415117, [0, 50.8], [237.404134065, 247.4261245855], [22.85996707, -251.45973192]],
+        [21, [25.4, 38.1], [151.6143912691, -102.2651981871], [19.05, -209.55]],
+        [326, [25.4, 38.1], [61.8020283476, 184.1879661223], [15.24, -167.64]],
+        [71.451445, [38.0345326, 29.5779001], [213.4164192787, 81.9227688859], [16.1900088, -178.0899376]],
+        [37.5, [0, 0], [3.0886032506, 84.5550388732], [0, -165.608, 0, -170.18, 0, -168.275]],
+        [7.5, [0, 0], [66.8196625103, 100.1805748181], [0, -97.028, 0, -161.798, 0, -64.135]],
+        [-32.5, [-56.642, 0], [135.5905951669, -5.7287439927], [0, -63.5, 0, -198.12, 0, -262.89]],
+        [-42.5, [-82.042, 0], [148.129181386, 25.4264910333], [0, -82.55, 0, -131.572, 0, -186.69]],
+    ],
+    'AR-SAND': [
+        [37.5, [0, 0], [-1.600031296, 48.9413237329], [0, -38.608, 0, -43.18, 0, -41.275]],
+        [7.5, [0, 0], [44.9523283138, 71.6825100568], [0, -20.828, 0, -34.798, 0, -13.335]],
+        [-32.5, [-31.242, 0], [79.0992370241, 0.1437184679], [0, -12.7, 0, -45.72, 0, -59.69]],
+        [-42.5, [-31.242, 0], [76.3556452472, 22.2929323257], [0, -6.35, 0, -29.972, 0, -34.29]],
+    ],
+    'BOX': [
+        [90, [0, 0], [-25.4, 0], []],
+        [90, [6.35, 0], [-25.4, 0], []],
+        [0, [0, 0], [0, 25.4], [-6.35, 6.35]],
+        [0, [0, 6.35], [0, 25.4], [-6.35, 6.35]],
+        [0, [0, 12.7], [0, 25.4], [6.35, -6.35]],
+        [0, [0, 19.05], [0, 25.4], [6.35, -6.35]],
+        [90, [12.7, 0], [-25.4, 0], [6.35, -6.35]],
+        [90, [19.05, 0], [-25.4, 0], [6.35, -6.35]],
+    ],
+    'BRICK': [
+        [0, [0, 0], [0, 6.35], []],
+        [90, [0, 0], [-12.7, 0], [6.35, -6.35]],
+        [90, [6.35, 0], [-12.7, 0], [-6.35, 6.35]],
+    ],
+    'CROSS': [
+        [0, [0, 0], [6.35, 6.35], [3.175, -9.525]],
+        [90, [1.5875, -1.5875], [-6.35, 6.35], [3.175, -9.525]],
+    ],
+    'DASH': [
+        [0, [0, 0], [3.175, 3.175], [3.175, -3.175]],
+    ],
+    'DOTS': [
+        [0, [0, 0], [0.79375, 1.5875], [0, -1.5875]],
+    ],
+    'EARTH': [
+        [0, [0, 0], [6.35, 6.35], [6.35, -6.35]],
+        [0, [0, 2.38125], [6.35, 6.35], [6.35, -6.35]],
+        [0, [0, 4.7625], [6.35, 6.35], [6.35, -6.35]],
+        [90, [0.79375, 5.55625], [-6.35, 6.35], [6.35, -6.35]],
+        [90, [3.175, 5.55625], [-6.35, 6.35], [6.35, -6.35]],
+        [90, [5.55625, 5.55625], [-6.35, 6.35], [6.35, -6.35]],
+    ],
+    'GRASS': [
+        [90, [0, 0], [-17.96051224, 17.96051224], [4.7625, -31.15852448]],
+        [45, [0, 0], [-17.9605122421, 17.9605122421], [4.7625, -20.6375]],
+        [135, [0, 0], [-17.9605122421, -17.9605122421], [4.7625, -20.6375]],
+    ],
+    'GRATE': [
+        [0, [0, 0], [0, 0.79375], []],
+        [90, [0, 0], [-3.175, 0], []],
+    ],
+    'GRAVEL': [
+        [228.0127875, [18.288, 25.4], [-203.200000016, -228.5999999858], [3.4172144, -338.3048363956]],
+        [184.969741, [16.002, 22.86], [304.7999998794, 25.400001447], [5.8640472, -580.5404889352]],
+        [132.5104471, [10.16, 22.352], [254.0000001073, -279.3999999025], [4.1348152, -409.347227941]],
+        [267.273689, [0.254, 16.002], [25.4000000532, 507.9999999973], [5.3400452, -528.6643742574]],
+        [292.83365418, [0, 10.668], [-127.0000000106, 304.7999999956], [5.236337, -518.3980774534]],
+        [357.273689, [2.032, 5.842], [-507.9999999973, 25.4000000532], [5.3400452, -528.6643742574]],
+        [37.69424047, [7.366, 5.588], [-330.1999999854, -254.000000019], [7.0619366, -699.1311531425]],
+        [72.25532837, [12.954, 9.906], [177.8000000478, 558.7999999848], [6.6671952, -660.0525660191]],
+        [121.42956562, [14.986, 16.256], [-203.2000000288, 330.1999999823], [5.35813, -530.4554569871]],
+        [175.2363583, [12.192, 20.828], [279.399999996, -25.4000000439], [6.1171328, -299.7393695]],
+        [222.3974378, [6.096, 21.336], [-304.7999999902, -279.4000000106], [7.9107792, -783.1677251218]],
+        [138.81407483, [25.4, 15.748], [-177.7999999893, 152.4000000124], [2.7000454, -267.3056582434]],
+        [171.4692344, [23.368, 17.526], [330.2000000089, -50.7999999424], [5.1368198, -508.5463899704]],
+        [225, [18.288, 18.288], [0, -25.4], [3.5920934, -32.3289310843]],
+        [203.19859051, [16.51, 21.336], [127.0000000035, 50.7999999911], [1.9344132, -191.5062236889]],
+        [291.80140949, [14.732, 20.574], [-25.4000000053, 76.1999999982], [2.7356562, -134.0475299]],
+        [30.96375653, [15.748, 18.034], [76.2000000019, 50.7999999972], [4.4431966, -143.6629815291]],
+        [161.56505118, [19.558, 20.32], [50.8000000013, -25.3999999973], [3.2128714, -77.1089811683]],
+        [16.389540334, [0, 20.574], [254, 76.2], [4.50088, -445.5882667254]],
+        [70.34617594, [4.318, 21.844], [-101.6000000093, -279.3999999967], [3.7759894, -373.822156782]],
+        [293.19859051, [19.558, 25.4], [-50.7999999911, 127.0000000036], [3.868801, -189.5718358889]],
+        [343.61045967, [21.082, 21.844], [-254.0000000053, 76.1999999822], [4.50088, -445.5882667254]],
+        [339.44395478, [0, 4.826], [-127, 50.8], [4.340352, -212.6773431311]],
+        [294.7751406, [4.064, 3.302], [-127.0000001512, 279.3999999313], [3.6367212, -360.0359338072]],
+        [66.80140949, [19.812, 0], [50.799999992, 127.0000000032], [3.868801, -189.5718358889]],
+        [17.35402464, [21.336, 3.556], [-330.1999999934, -101.6000000213], [4.2578274, -421.523759802]],
+        [69.44395478, [7.366, 0], [-50.8000000009, -126.9999999996], [2.170176, -214.8475191311]],
+        [101.309932474, [18.288, 0], [-25.4, 101.6], [1.295146, -128.2199496453]],
+        [165.963756532, [18.034, 1.27], [76.2, -25.4], [5.236337, -99.4905458907]],
+        [186.00900596, [12.954, 2.54], [253.9999999987, 25.4000000133], [4.85267, -480.4136486334]],
+        [303.69006753, [15.748, 15.748], [-25.4000000035, 50.7999999982], [3.6632388, -87.9177635968]],
+        [353.15722659, [17.78, 12.7], [431.8000000027, -50.7999999774], [6.3955676, -633.1600906503]],
+        [60.9453959, [24.13, 11.938], [-101.6000000028, -177.7999999984], [2.6150824, -258.8939231811]],
+        [90, [25.4, 14.224], [-25.4, 25.4], [1.524, -23.876]],
+        [120.25643716, [12.446, 3.302], [101.5999999876, -177.8000000071], [3.5286696, -349.339407732]],
+        [48.0127875, [10.668, 6.35], [203.2000000168, 228.5999999851], [6.8344288, -334.8876219957]],
+        [0, [15.24, 11.43], [25.4, 25.4], [6.604, -18.796]],
+        [325.3048465, [21.844, 11.43], [254.0000000962, -177.7999998625], [4.0160956, -397.5931672414]],
+        [254.0546041, [25.146, 9.144], [-25.3999999982, -101.6000000004], [3.6982908, -181.2165003877]],
+        [207.64597536, [24.13, 5.588], [-482.6000000177, -253.9999999663], [6.021451, -596.1246442294]],
+        [175.42607874, [18.796, 2.794], [-330.2, 25.4], [6.3702946, -630.6584645624]],
+    ],
+    'HEX': [
+        [0, [0, 0], [0, 5.4992613154], [3.175, -6.35]],
+        [120, [0, 0], [-4.7625000012, -2.7496306577], [3.175, -6.35]],
+        [60, [3.175, 0], [-4.7625000012, 2.7496306577], [3.175, -6.35]],
+    ],
+    'HONEY': [
+        [0, [0, 0], [4.7625, 2.749630645], [3.175, -6.35]],
+        [120, [0, 0], [-4.7624999896, 2.749630663], [3.175, -6.35]],
+        [60, [0, 0], [1.04e-08, 5.499261308], [-6.35, 3.175]],
+    ],
+    'INSUL': [
+        [0, [0, 0], [0, 9.525], []],
+        [0, [0, 3.175], [0, 9.525], [3.175, -3.175]],
+        [0, [0, 6.35], [0, 9.525], [3.175, -3.175]],
+    ],
+    'LINE': [
+        [0, [0, 0], [0, 3.175], []],
+    ],
+    'NET': [
+        [0, [0, 0], [0, 3.175], []],
+        [90, [0, 0], [-3.175, 0], []],
+    ],
+    'NET3': [
+        [0, [0, 0], [0, 3.175], []],
+        [60, [0, 0], [-2.749630657, 1.5875], []],
+        [120, [0, 0], [-2.749630657, -1.5875], []],
+    ],
+    'PLAST': [
+        [0, [0, 0], [0, 6.35], []],
+        [0, [0, 0.79375], [0, 6.35], []],
+        [0, [0, 1.5875], [0, 6.35], []],
+    ],
+    'SQUARE': [
+        [0, [0, 0], [0, 3.175], [3.175, -3.175]],
+        [90, [0, 0], [-3.175, 0], [3.175, -3.175]],
+    ],
+    'STARS': [
+        [0, [0, 0], [0, 5.4992613154], [3.175, -3.175]],
+        [60, [0, 0], [-4.7625000012, 2.7496306577], [3.175, -3.175]],
+        [120, [1.5875, 2.7496306704], [-4.7625000012, -2.7496306577], [3.175, -3.175]],
+    ],
+    'SWAMP': [
+        [0, [0, 0], [12.7, 21.9970452362], [3.175, -22.225]],
+        [90, [1.5875, 0], [-12.7, 21.9970452362], [1.5875, -42.4065904724]],
+        [90, [1.984375, 0], [-12.7, 21.9970452362], [1.27, -42.7240904724]],
+        [90, [1.190625, 0], [-12.7, 21.9970452362], [1.27, -42.7240904724]],
+        [60, [2.38125, 0], [-12.6999999827, 21.9970452462], [1.016, -24.384]],
+        [120, [0.79375, 0], [-25.3999999827, 1e-08], [1.016, -24.384]],
+    ],
+    'TRIANG': [
+        [60, [0, 0], [-4.7624999908, 8.2488919657], [4.7625, -4.7625]],
+        [120, [0, 0], [-9.5249999908, 5.3e-09], [4.7625, -4.7625]],
+        [0, [-2.38125, 4.1244459802], [4.7625, 8.2488919604], [4.7625, -4.7625]],
+    ],
+    'ZIGZAG': [
+        [0, [0, 0], [6.35, 6.35], [6.35, -6.35]],
+        [90, [6.35, 0], [-6.35, 6.35], [6.35, -6.35]],
+    ],
+};

package/dist/core/modelspace.d.ts

@@ -0,0 +1,106 @@
+import { DxfEntity, LineEntity, LwPolylineEntity, PolylineEntity, CircleEntity, ArcEntity, EllipseEntity, TextEntity, MTextEntity, InsertEntity, PointEntity, SolidEntity, TraceEntity, SplineEntity, HatchEntity, HatchBoundary, DimensionEntity, LeaderEntity, ViewportEntity, ImageEntity, WipeoutEntity, RegionEntity, MeshEntity, MLeaderEntity, TableDef, DxfAttribs, TextAttribs, BlockRefAttribs, TextEntityAlignment } from './dxf-entities.js';
+import { HatchPatternLine } from './hatch-patterns.js';
+/**
+ * An entity collector — used for model space, paper space layouts and block
+ * definitions alike.
+ */
+export declare class Modelspace {
+    private _entities;
+    get entities(): DxfEntity[];
+    add_line(start: [number, number], end: [number, number], dxfattribs?: DxfAttribs): LineEntity;
+    add_lwpolyline(points: [number, number][], dxfattribs?: DxfAttribs, close?: boolean): LwPolylineEntity;
+    add_polyline(points: [number, number, number][], dxfattribs?: DxfAttribs, close?: boolean): PolylineEntity;
+    add_circle(center: [number, number], radius: number, dxfattribs?: DxfAttribs): CircleEntity;
+    add_arc(center: [number, number], radius: number, startAngle: number, endAngle: number, dxfattribs?: DxfAttribs): ArcEntity;
+    add_ellipse(center: [number, number], majorAxis: [number, number], ratio: number, startParam?: number, endParam?: number, dxfattribs?: DxfAttribs): EllipseEntity;
+    add_point(location: [number, number], dxfattribs?: DxfAttribs): PointEntity;
+    add_solid(points: [[number, number], [number, number], [number, number], [number, number]], dxfattribs?: DxfAttribs): SolidEntity;
+    add_trace(points: [[number, number], [number, number], [number, number], [number, number]], dxfattribs?: DxfAttribs): TraceEntity;
+    add_text(text: string, dxfattribs?: TextAttribs): {
+        set_placement: (pos: [number, number], align?: TextEntityAlignment) => TextEntity;
+    };
+    add_mtext(text: string, dxfattribs?: TextAttribs & {
+        width?: number;
+        attachment_point?: number;
+    }): MTextEntity;
+    add_blockref(blockName: string, insert: [number, number], dxfattribs?: BlockRefAttribs): InsertEntity;
+    add_spline(controlPoints: [number, number][], degree?: number, dxfattribs?: DxfAttribs, opts?: {
+        fitPoints?: [number, number][];
+        knots?: number[];
+        weights?: number[];
+        closed?: boolean;
+    }): SplineEntity;
+    /**
+     * Add a HATCH. Pattern names resolve against the built-in HATCH_PATTERNS
+     * (ISO, mm based) unless `opts.patternLines` supplies a custom definition.
+     */
+    add_hatch(patternName: string | undefined, boundaries: HatchBoundary[], dxfattribs?: DxfAttribs, opts?: {
+        solid?: boolean;
+        scale?: number;
+        angle?: number;
+        patternLines?: HatchPatternLine[];
+    }): HatchEntity;
+    add_dimension(point1: [number, number], point2: [number, number], dimLine: [number, number], dxfattribs?: DxfAttribs & {
+        text?: string;
+        rotation?: number;
+        style?: string;
+        dimensionType?: number;
+    }): DimensionEntity;
+    add_leader(vertices: [number, number][], dxfattribs?: DxfAttribs & {
+        style?: string;
+        has_arrowhead?: boolean;
+        annotation_type?: number;
+        annotation_text?: string;
+    }): LeaderEntity;
+    /**
+     * Add a MULTILEADER entity (modern annotation — AutoCAD 2008+).
+     * Combines leader line with MTEXT content.
+     *
+     * @deprecated The MULTILEADER written for this entity is incomplete and is
+     * not read reliably by AutoCAD. Use `DxfBuilder.addCallout()` instead.
+     */
+    add_mleader(vertices: [number, number][], text: string, textPosition: [number, number], dxfattribs?: DxfAttribs & {
+        text_height?: number;
+        text_width?: number;
+        arrow_size?: number;
+        style?: string;
+        dogleg_length?: number;
+        leader_type?: number;
+        content_type?: number;
+    }): MLeaderEntity;
+    /**
+     * Add a TABLE as composite LINE + TEXT entities.
+     * Note: DXF ACAD_TABLE is extremely complex; this draws a visual table
+     * using primitive entities for maximum compatibility.
+     *
+     * Cells may span columns/rows (`colSpan` / `rowSpan`); grid lines inside a
+     * merged cell are omitted.
+     */
+    add_table(tableDef: TableDef): void;
+    add_viewport(center: [number, number], width: number, height: number, viewCenter: [number, number], viewHeight: number, dxfattribs?: DxfAttribs & {
+        status?: number;
+        id?: number;
+        frozen_layers?: string[];
+        locked?: boolean;
+    }): ViewportEntity;
+    /**
+     * Add a raster IMAGE.
+     * @param insertionPoint lower-left corner (WCS)
+     * @param imagePath      file path as the CAD application should resolve it
+     * @param imageSize      image size in pixels
+     * @param pixelSize      drawing units per pixel — one value, or [x, y]
+     */
+    add_image(insertionPoint: [number, number], imagePath: string, imageSize: [number, number], pixelSize?: number | [number, number], dxfattribs?: DxfAttribs, opts?: {
+        rotation?: number;
+        clip?: [number, number][];
+        brightness?: number;
+        contrast?: number;
+        fade?: number;
+    }): ImageEntity;
+    add_wipeout(boundary: [number, number][], dxfattribs?: DxfAttribs): WipeoutEntity;
+    add_region(acisData: string[], dxfattribs?: DxfAttribs): RegionEntity;
+    add_mesh(vertices: [number, number, number][], faces: number[][], dxfattribs?: DxfAttribs & {
+        subdivision_level?: number;
+    }): MeshEntity;
+    query(entityType: string): DxfEntity[];
+}

package/dist/core/modelspace.js

@@ -0,0 +1,351 @@
+import { TextEntityAlignment } from './dxf-entities.js';
+import { HATCH_PATTERNS } from './hatch-patterns.js';
+/** Common entity attributes from ezdxf-style dxfattribs. */
+function base(dxfattribs) {
+    return {
+        layer: dxfattribs.layer || '0',
+        color: dxfattribs.color,
+        linetype: dxfattribs.linetype,
+        lineweight: dxfattribs.lineweight,
+    };
+}
+/**
+ * An entity collector — used for model space, paper space layouts and block
+ * definitions alike.
+ */
+export class Modelspace {
+    _entities = [];
+    get entities() { return this._entities; }
+    // ─── Basic Geometry ───
+    add_line(start, end, dxfattribs = {}) {
+        const e = { type: 'LINE', ...base(dxfattribs), start, end };
+        this._entities.push(e);
+        return e;
+    }
+    add_lwpolyline(points, dxfattribs = {}, close = false) {
+        const e = { type: 'LWPOLYLINE', ...base(dxfattribs), points: [...points], closed: close };
+        this._entities.push(e);
+        return e;
+    }
+    add_polyline(points, dxfattribs = {}, close = false) {
+        const e = { type: 'POLYLINE', ...base(dxfattribs), points: [...points], closed: close };
+        this._entities.push(e);
+        return e;
+    }
+    add_circle(center, radius, dxfattribs = {}) {
+        const e = { type: 'CIRCLE', ...base(dxfattribs), center, radius };
+        this._entities.push(e);
+        return e;
+    }
+    add_arc(center, radius, startAngle, endAngle, dxfattribs = {}) {
+        const e = { type: 'ARC', ...base(dxfattribs), center, radius, startAngle, endAngle };
+        this._entities.push(e);
+        return e;
+    }
+    add_ellipse(center, majorAxis, ratio, startParam = 0, endParam = Math.PI * 2, dxfattribs = {}) {
+        const e = { type: 'ELLIPSE', ...base(dxfattribs), center, majorAxis, ratioMinorToMajor: ratio, startParam, endParam };
+        this._entities.push(e);
+        return e;
+    }
+    add_point(location, dxfattribs = {}) {
+        const e = { type: 'POINT', ...base(dxfattribs), position: location };
+        this._entities.push(e);
+        return e;
+    }
+    add_solid(points, dxfattribs = {}) {
+        const e = { type: 'SOLID', ...base(dxfattribs), points };
+        this._entities.push(e);
+        return e;
+    }
+    add_trace(points, dxfattribs = {}) {
+        const e = { type: 'TRACE', ...base(dxfattribs), points };
+        this._entities.push(e);
+        return e;
+    }
+    // ─── Text Entities ───
+    add_text(text, dxfattribs = {}) {
+        const e = {
+            type: 'TEXT', ...base(dxfattribs),
+            text, position: [0, 0], height: dxfattribs.height || 2.5, rotation: dxfattribs.rotation || 0,
+            style: dxfattribs.style || 'Standard', halign: dxfattribs.halign || 0, valign: dxfattribs.valign || 0,
+        };
+        this._entities.push(e);
+        return {
+            set_placement: (pos, align) => {
+                if (align !== undefined) {
+                    if (align >= 30) {
+                        e.valign = 1;
+                        e.halign = align - 30;
+                    }
+                    else if (align >= 20) {
+                        e.valign = 3;
+                        e.halign = align - 20;
+                    }
+                    else if (align >= 10) {
+                        e.valign = 2;
+                        e.halign = align - 10;
+                    }
+                    else if (align === TextEntityAlignment.MIDDLE) {
+                        e.halign = 4;
+                        e.valign = 0;
+                    }
+                    else {
+                        e.halign = align;
+                        e.valign = 0;
+                    }
+                }
+                if (e.halign === 0 && e.valign === 0) {
+                    e.position = pos;
+                }
+                else {
+                    e.position = pos;
+                    e.alignmentPoint = pos;
+                }
+                return e;
+            }
+        };
+    }
+    add_mtext(text, dxfattribs = {}) {
+        const e = {
+            type: 'MTEXT', ...base(dxfattribs),
+            text, position: [0, 0], height: dxfattribs.height || 2.5, rotation: dxfattribs.rotation || 0,
+            width: dxfattribs.width || 100, style: dxfattribs.style || 'Standard', attachmentPoint: dxfattribs.attachment_point || 1,
+        };
+        this._entities.push(e);
+        return e;
+    }
+    // ─── Block Reference ───
+    add_blockref(blockName, insert, dxfattribs = {}) {
+        const e = {
+            type: 'INSERT', ...base(dxfattribs),
+            blockName, position: insert, xScale: dxfattribs.xscale || 1, yScale: dxfattribs.yscale || 1,
+            zScale: dxfattribs.zscale || 1, rotation: dxfattribs.rotation || 0,
+        };
+        this._entities.push(e);
+        return e;
+    }
+    // ─── Complex Entities ───
+    add_spline(controlPoints, degree = 3, dxfattribs = {}, opts = {}) {
+        const n = controlPoints.length;
+        const order = degree + 1;
+        const knots = opts.knots || Array.from({ length: n + order }, (_, i) => i);
+        const e = {
+            type: 'SPLINE', ...base(dxfattribs),
+            degree, closed: opts.closed || false, controlPoints: [...controlPoints],
+            fitPoints: opts.fitPoints ? [...opts.fitPoints] : [], knots, weights: opts.weights,
+        };
+        this._entities.push(e);
+        return e;
+    }
+    /**
+     * Add a HATCH. Pattern names resolve against the built-in HATCH_PATTERNS
+     * (ISO, mm based) unless `opts.patternLines` supplies a custom definition.
+     */
+    add_hatch(patternName = 'SOLID', boundaries, dxfattribs = {}, opts = {}) {
+        const solid = opts.solid !== undefined ? opts.solid : patternName.toUpperCase() === 'SOLID';
+        if (!solid && !opts.patternLines && !HATCH_PATTERNS[patternName.toUpperCase()]) {
+            throw new Error(`Unknown hatch pattern "${patternName}". Use one of ${Object.keys(HATCH_PATTERNS).join(', ')}, ` +
+                `or pass opts.patternLines.`);
+        }
+        const e = {
+            type: 'HATCH', ...base(dxfattribs),
+            patternName, solid, scale: opts.scale || 1, angle: opts.angle || 0, boundaries,
+            patternLines: opts.patternLines,
+        };
+        this._entities.push(e);
+        return e;
+    }
+    add_dimension(point1, point2, dimLine, dxfattribs = {}) {
+        const textMid = [(point1[0] + point2[0]) / 2, dimLine[1]];
+        const e = {
+            type: 'DIMENSION', ...base(dxfattribs),
+            dimensionType: dxfattribs.dimensionType || 0, definitionPoint: dimLine, textMidpoint: textMid,
+            insertionPoint: dimLine, text: dxfattribs.text || '', rotation: dxfattribs.rotation || 0,
+            style: dxfattribs.style || 'Standard', point1, point2,
+        };
+        this._entities.push(e);
+        return e;
+    }
+    add_leader(vertices, dxfattribs = {}) {
+        const e = {
+            type: 'LEADER', ...base(dxfattribs),
+            vertices: [...vertices], hasArrowhead: dxfattribs.has_arrowhead !== false,
+            annotationType: dxfattribs.annotation_type || 3, style: dxfattribs.style || 'Standard',
+            annotationText: dxfattribs.annotation_text,
+        };
+        this._entities.push(e);
+        return e;
+    }
+    /**
+     * Add a MULTILEADER entity (modern annotation — AutoCAD 2008+).
+     * Combines leader line with MTEXT content.
+     *
+     * @deprecated The MULTILEADER written for this entity is incomplete and is
+     * not read reliably by AutoCAD. Use `DxfBuilder.addCallout()` instead.
+     */
+    add_mleader(vertices, text, textPosition, dxfattribs = {}) {
+        const e = {
+            type: 'MLEADER', ...base(dxfattribs),
+            vertices: [...vertices], text, textPosition,
+            textHeight: dxfattribs.text_height || 2.5,
+            textWidth: dxfattribs.text_width || 50,
+            arrowSize: dxfattribs.arrow_size || 2.5,
+            style: dxfattribs.style || 'Standard',
+            doglegLength: dxfattribs.dogleg_length || 8,
+            leaderType: dxfattribs.leader_type || 1,
+            contentType: dxfattribs.content_type || 2,
+        };
+        this._entities.push(e);
+        return e;
+    }
+    /**
+     * Add a TABLE as composite LINE + TEXT entities.
+     * Note: DXF ACAD_TABLE is extremely complex; this draws a visual table
+     * using primitive entities for maximum compatibility.
+     *
+     * Cells may span columns/rows (`colSpan` / `rowSpan`); grid lines inside a
+     * merged cell are omitted.
+     */
+    add_table(tableDef) {
+        const { position, columnWidths, rows, layer, textHeight } = tableDef;
+        const gridColor = tableDef.gridColor || 7;
+        const textColor = tableDef.textColor || 7;
+        const numCols = columnWidths.length;
+        const numRows = rows.length;
+        const xs = [position[0]];
+        for (const w of columnWidths)
+            xs.push(xs[xs.length - 1] + w);
+        const ys = [position[1]];
+        for (let r = 0; r < numRows; r++)
+            ys.push(ys[r] - (tableDef.rowHeights?.[r] ?? tableDef.rowHeight));
+        // Place cells on the grid (HTML table semantics); owner[r][c] = placed cell index.
+        const owner = Array.from({ length: numRows }, () => new Array(numCols).fill(-1));
+        const placed = [];
+        for (let r = 0; r < numRows; r++) {
+            let c = 0;
+            for (let i = 0; i < rows[r].length; i++) {
+                while (c < numCols && owner[r][c] !== -1)
+                    c++;
+                if (c >= numCols)
+                    break;
+                const cell = rows[r][i];
+                const cs = Math.max(1, Math.min(cell.colSpan ?? 1, numCols - c));
+                const rs = Math.max(1, Math.min(cell.rowSpan ?? 1, numRows - r));
+                for (let rr = r; rr < r + rs; rr++) {
+                    for (let cc = c; cc < c + cs; cc++)
+                        owner[rr][cc] = placed.length;
+                }
+                placed.push({ r, c, rs, cs, row: r, col: i });
+                c += cs;
+            }
+        }
+        // Positions not covered by any cell still get their own grid box.
+        let next = placed.length;
+        for (let r = 0; r < numRows; r++) {
+            for (let c = 0; c < numCols; c++)
+                if (owner[r][c] === -1)
+                    owner[r][c] = next++;
+        }
+        const gridAttr = { layer, color: gridColor };
+        // Horizontal borders: between rows k-1 and k, wherever the owning cell changes.
+        for (let k = 0; k <= numRows; k++) {
+            let start = -1;
+            for (let c = 0; c <= numCols; c++) {
+                const draw = c < numCols && (k === 0 || k === numRows || owner[k - 1][c] !== owner[k][c]);
+                if (draw && start === -1)
+                    start = c;
+                if (!draw && start !== -1) {
+                    this.add_line([xs[start], ys[k]], [xs[c], ys[k]], gridAttr);
+                    start = -1;
+                }
+            }
+        }
+        // Vertical borders: between columns k-1 and k.
+        for (let k = 0; k <= numCols; k++) {
+            let start = -1;
+            for (let r = 0; r <= numRows; r++) {
+                const draw = r < numRows && (k === 0 || k === numCols || owner[r][k - 1] !== owner[r][k]);
+                if (draw && start === -1)
+                    start = r;
+                if (!draw && start !== -1) {
+                    this.add_line([xs[k], ys[start]], [xs[k], ys[r]], gridAttr);
+                    start = -1;
+                }
+            }
+        }
+        // Cell text, centered in the (possibly merged) cell box.
+        for (const p of placed) {
+            const cell = rows[p.row][p.col];
+            if (!cell.text)
+                continue;
+            const cx = (xs[p.c] + xs[p.c + p.cs]) / 2;
+            const cy = (ys[p.r] + ys[p.r + p.rs]) / 2;
+            const isHeader = p.r === 0 && tableDef.headerColor !== undefined;
+            const color = cell.color || (isHeader ? tableDef.headerColor : textColor) || textColor;
+            this.add_text(cell.text, {
+                height: textHeight, layer,
+                color, style: cell.style,
+            }).set_placement([cx, cy], cell.alignment || TextEntityAlignment.MIDDLE_CENTER);
+        }
+    }
+    add_viewport(center, width, height, viewCenter, viewHeight, dxfattribs = {}) {
+        const e = {
+            type: 'VIEWPORT', ...base(dxfattribs),
+            center, width, height, viewCenter, viewHeight, status: dxfattribs.status || 1,
+            id: dxfattribs.id, frozenLayers: dxfattribs.frozen_layers, locked: dxfattribs.locked,
+        };
+        this._entities.push(e);
+        return e;
+    }
+    /**
+     * Add a raster IMAGE.
+     * @param insertionPoint lower-left corner (WCS)
+     * @param imagePath      file path as the CAD application should resolve it
+     * @param imageSize      image size in pixels
+     * @param pixelSize      drawing units per pixel — one value, or [x, y]
+     */
+    add_image(insertionPoint, imagePath, imageSize, pixelSize = 1, dxfattribs = {}, opts = {}) {
+        const [sx, sy] = typeof pixelSize === 'number' ? [pixelSize, pixelSize] : pixelSize;
+        const a = (opts.rotation || 0) * Math.PI / 180;
+        const e = {
+            type: 'IMAGE', ...base(dxfattribs),
+            insertionPoint, imagePath, imageSize,
+            uVector: [Math.cos(a) * sx, Math.sin(a) * sx],
+            vVector: [-Math.sin(a) * sy, Math.cos(a) * sy],
+            clipBoundary: opts.clip, brightness: opts.brightness, contrast: opts.contrast, fade: opts.fade,
+        };
+        this._entities.push(e);
+        return e;
+    }
+    add_wipeout(boundary, dxfattribs = {}) {
+        const xs = boundary.map(p => p[0]);
+        const ys = boundary.map(p => p[1]);
+        const minX = Math.min(...xs), minY = Math.min(...ys);
+        const maxX = Math.max(...xs), maxY = Math.max(...ys);
+        const w = maxX - minX || 1, h = maxY - minY || 1;
+        const normalized = boundary.map(p => [(p[0] - minX) / w, (p[1] - minY) / h]);
+        const e = {
+            type: 'WIPEOUT', ...base(dxfattribs),
+            insertionPoint: [minX, minY], uVector: [w, 0], vVector: [0, h], imageSize: [1, 1], clipBoundary: normalized,
+        };
+        this._entities.push(e);
+        return e;
+    }
+    add_region(acisData, dxfattribs = {}) {
+        const e = { type: 'REGION', ...base(dxfattribs), acisData };
+        this._entities.push(e);
+        return e;
+    }
+    add_mesh(vertices, faces, dxfattribs = {}) {
+        const e = {
+            type: 'MESH', ...base(dxfattribs),
+            subdivisionLevel: dxfattribs.subdivision_level || 0, vertices: [...vertices], faces: faces.map(f => [...f]),
+        };
+        this._entities.push(e);
+        return e;
+    }
+    // ─── Query ───
+    query(entityType) {
+        return this._entities.filter(e => e.type === entityType);
+    }
+}

package/dist/geometry/math.utils.d.ts

@@ -0,0 +1,8 @@
+import { Coordinate, Coordinate3D } from '../types/index.js';
+export declare function formatDistance(distance: number): string;
+export declare function calculateDistance(p1: Coordinate, p2: Coordinate): number;
+export declare function calculateAzimuth(x1: number, y1: number, x2: number, y2: number): number;
+export declare function rotatePoint(x: number, y: number, angleDeg: number, shiftX: number, shiftY: number): Coordinate3D;
+export declare function rotatePointAzimuth(x: number, y: number, azimuthDeg: number, shiftX: number, shiftY: number): Coordinate3D;
+export declare function isPointInBounds(x: number, y: number, xmin: number, ymin: number, xmax: number, ymax: number): boolean;
+export declare function snapBound(value: number, step: number, direction?: 'up' | 'down'): number;