ofs-dxf-ts 1.0.0

package/dist/core/dxf-serializer.js

@@ -0,0 +1,595 @@
+/**
+ * DXF Format Serializer.
+ * Converts internal entity representations and table records to DXF tag text.
+ * Section assembly (tables, blocks, objects, handle seeding) lives in
+ * template/template-injector, which serves both template and blank documents.
+ */
+import { HATCH_PATTERNS } from './hatch-patterns.js';
+let handleCounter = 1000;
+export function nextHandle() {
+    return (handleCounter++).toString(16).toUpperCase();
+}
+export function resetHandleCounter(start = 1000) {
+    handleCounter = start;
+}
+/** The handle `nextHandle()` will return next — the value to store in $HANDSEED. */
+export function peekHandle() {
+    return handleCounter.toString(16).toUpperCase();
+}
+/** Format a computed number for DXF: no exponent notation, no negative zero. */
+export function fmt(n) {
+    if (!Number.isFinite(n) || Math.abs(n) < 1e-12)
+        return '0';
+    const s = String(n);
+    return s.includes('e') ? n.toFixed(12).replace(/\.?0+$/, '') : s;
+}
+// ─── Entity Serializer ───
+function serializeEntity(entity, ctx = {}) {
+    switch (entity.type) {
+        case 'LINE': return serializeLine(entity, ctx);
+        case 'LWPOLYLINE': return serializeLwPolyline(entity, ctx);
+        case 'POLYLINE': return serializePolyline(entity, ctx);
+        case 'CIRCLE': return serializeCircle(entity, ctx);
+        case 'ARC': return serializeArc(entity, ctx);
+        case 'ELLIPSE': return serializeEllipse(entity, ctx);
+        case 'TEXT': return serializeText(entity, ctx);
+        case 'MTEXT': return serializeMText(entity, ctx);
+        case 'INSERT': return serializeInsert(entity, ctx);
+        case 'POINT': return serializePoint(entity, ctx);
+        case 'SOLID': return serializeSolid(entity, ctx);
+        case 'TRACE': return serializeTrace(entity, ctx);
+        case 'SPLINE': return serializeSpline(entity, ctx);
+        case 'HATCH': return serializeHatch(entity, ctx);
+        case 'DIMENSION': return serializeDimension(entity, ctx);
+        case 'LEADER': return serializeLeader(entity, ctx);
+        case 'VIEWPORT': return serializeViewport(entity, ctx);
+        case 'IMAGE': return serializeImage(entity, ctx);
+        case 'WIPEOUT': return serializeWipeout(entity, ctx);
+        case 'REGION': return serializeRegion(entity, ctx);
+        case 'MESH': return serializeMesh(entity, ctx);
+        case 'MLEADER': return serializeMLeader(entity, ctx);
+        default: return '';
+    }
+}
+function entityCommon(entity, ctx, handle = entity.handle ?? nextHandle()) {
+    const lines = ['5', handle];
+    if (ctx.owner)
+        lines.push('330', ctx.owner);
+    lines.push('100', 'AcDbEntity');
+    if (ctx.paperSpace)
+        lines.push('67', '1');
+    lines.push('8', entity.layer);
+    if (entity.linetype && entity.linetype.toUpperCase() !== 'BYLAYER') {
+        lines.push('6', entity.linetype);
+    }
+    if (entity.color !== undefined && entity.color !== 256) {
+        lines.push('62', String(entity.color));
+    }
+    if (entity.lineweight !== undefined) {
+        lines.push('370', String(entity.lineweight));
+    }
+    return lines;
+}
+/** Single-line DXF values cannot contain line breaks. */
+function oneLine(text) {
+    return text.replace(/\r?\n/g, ' ');
+}
+function serializeLine(e, ctx) {
+    const lines = ['0', 'LINE', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbLine');
+    lines.push('10', String(e.start[0]));
+    lines.push('20', String(e.start[1]));
+    lines.push('30', '0');
+    lines.push('11', String(e.end[0]));
+    lines.push('21', String(e.end[1]));
+    lines.push('31', '0');
+    return lines.join('\n');
+}
+function serializeLwPolyline(e, ctx) {
+    const lines = ['0', 'LWPOLYLINE', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbPolyline');
+    lines.push('90', String(e.points.length));
+    lines.push('70', e.closed ? '1' : '0');
+    for (const pt of e.points) {
+        lines.push('10', String(pt[0]));
+        lines.push('20', String(pt[1]));
+    }
+    return lines.join('\n');
+}
+function serializeCircle(e, ctx) {
+    const lines = ['0', 'CIRCLE', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbCircle');
+    lines.push('10', String(e.center[0]));
+    lines.push('20', String(e.center[1]));
+    lines.push('30', '0');
+    lines.push('40', String(e.radius));
+    return lines.join('\n');
+}
+function serializeArc(e, ctx) {
+    const lines = ['0', 'ARC', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbCircle');
+    lines.push('10', String(e.center[0]));
+    lines.push('20', String(e.center[1]));
+    lines.push('30', '0');
+    lines.push('40', String(e.radius));
+    lines.push('100', 'AcDbArc');
+    lines.push('50', String(e.startAngle));
+    lines.push('51', String(e.endAngle));
+    return lines.join('\n');
+}
+function serializeText(e, ctx) {
+    const lines = ['0', 'TEXT', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbText');
+    lines.push('10', String(e.position[0]));
+    lines.push('20', String(e.position[1]));
+    lines.push('30', '0');
+    lines.push('40', String(e.height));
+    lines.push('1', oneLine(e.text));
+    if (e.rotation)
+        lines.push('50', String(e.rotation));
+    if (e.style && e.style !== 'Standard')
+        lines.push('7', e.style);
+    const aligned = e.halign !== 0 || e.valign !== 0;
+    if (aligned) {
+        const ap = e.alignmentPoint ?? e.position;
+        lines.push('72', String(e.halign));
+        lines.push('11', String(ap[0]), '21', String(ap[1]), '31', '0');
+    }
+    lines.push('100', 'AcDbText');
+    if (aligned)
+        lines.push('73', String(e.valign));
+    return lines.join('\n');
+}
+function serializeMText(e, ctx) {
+    const lines = ['0', 'MTEXT', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbMText');
+    lines.push('10', String(e.position[0]));
+    lines.push('20', String(e.position[1]));
+    lines.push('30', '0');
+    lines.push('40', String(e.height));
+    lines.push('41', String(e.width));
+    lines.push('71', String(e.attachmentPoint));
+    // MTEXT line breaks are "\P"; content longer than 250 chars goes in code-3 chunks.
+    const content = e.text.replace(/\r?\n/g, '\\P');
+    const chunks = content.match(/[\s\S]{1,250}/g) ?? [''];
+    for (let i = 0; i < chunks.length - 1; i++)
+        lines.push('3', chunks[i]);
+    lines.push('1', chunks[chunks.length - 1]);
+    if (e.style && e.style !== 'Standard')
+        lines.push('7', e.style);
+    if (e.rotation)
+        lines.push('50', String(e.rotation));
+    return lines.join('\n');
+}
+function serializeInsert(e, ctx) {
+    const lines = ['0', 'INSERT', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbBlockReference');
+    lines.push('2', e.blockName);
+    lines.push('10', String(e.position[0]));
+    lines.push('20', String(e.position[1]));
+    lines.push('30', '0');
+    if (e.xScale !== 1)
+        lines.push('41', String(e.xScale));
+    if (e.yScale !== 1)
+        lines.push('42', String(e.yScale));
+    if (e.zScale !== 1)
+        lines.push('43', String(e.zScale));
+    if (e.rotation)
+        lines.push('50', String(e.rotation));
+    return lines.join('\n');
+}
+function serializePoint(e, ctx) {
+    const lines = ['0', 'POINT', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbPoint');
+    lines.push('10', String(e.position[0]));
+    lines.push('20', String(e.position[1]));
+    lines.push('30', '0');
+    return lines.join('\n');
+}
+function serializePolyline(e, ctx) {
+    const handle = nextHandle();
+    const lines = ['0', 'POLYLINE', ...entityCommon(e, ctx, handle)];
+    lines.push('100', 'AcDb3dPolyline');
+    lines.push('66', '1');
+    lines.push('10', '0', '20', '0', '30', '0');
+    lines.push('70', String(8 | (e.closed ? 1 : 0))); // 8 = 3D polyline
+    const parts = [lines.join('\n')];
+    const sub = (type) => {
+        const l = ['0', type, '5', nextHandle(), '330', handle, '100', 'AcDbEntity'];
+        if (ctx.paperSpace)
+            l.push('67', '1');
+        l.push('8', e.layer);
+        return l;
+    };
+    for (const pt of e.points) {
+        const vl = sub('VERTEX');
+        vl.push('100', 'AcDbVertex', '100', 'AcDb3dPolylineVertex');
+        vl.push('10', String(pt[0]), '20', String(pt[1]), '30', String(pt[2] || 0), '70', '32');
+        parts.push(vl.join('\n'));
+    }
+    parts.push(sub('SEQEND').join('\n'));
+    return parts.join('\n');
+}
+function serializeEllipse(e, ctx) {
+    const lines = ['0', 'ELLIPSE', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbEllipse');
+    lines.push('10', String(e.center[0]), '20', String(e.center[1]), '30', '0');
+    lines.push('11', String(e.majorAxis[0]), '21', String(e.majorAxis[1]), '31', '0');
+    lines.push('40', String(e.ratioMinorToMajor));
+    lines.push('41', String(e.startParam));
+    lines.push('42', String(e.endParam));
+    return lines.join('\n');
+}
+function serializeSolid(e, ctx) {
+    const lines = ['0', 'SOLID', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbTrace');
+    lines.push('10', String(e.points[0][0]), '20', String(e.points[0][1]), '30', '0');
+    lines.push('11', String(e.points[1][0]), '21', String(e.points[1][1]), '31', '0');
+    lines.push('12', String(e.points[2][0]), '22', String(e.points[2][1]), '32', '0');
+    lines.push('13', String(e.points[3][0]), '23', String(e.points[3][1]), '33', '0');
+    return lines.join('\n');
+}
+function serializeTrace(e, ctx) {
+    const lines = ['0', 'TRACE', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbTrace');
+    lines.push('10', String(e.points[0][0]), '20', String(e.points[0][1]), '30', '0');
+    lines.push('11', String(e.points[1][0]), '21', String(e.points[1][1]), '31', '0');
+    lines.push('12', String(e.points[2][0]), '22', String(e.points[2][1]), '32', '0');
+    lines.push('13', String(e.points[3][0]), '23', String(e.points[3][1]), '33', '0');
+    return lines.join('\n');
+}
+function serializeSpline(e, ctx) {
+    const lines = ['0', 'SPLINE', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbSpline');
+    lines.push('70', e.closed ? '11' : '8');
+    lines.push('71', String(e.degree));
+    lines.push('72', String(e.knots.length));
+    lines.push('73', String(e.controlPoints.length));
+    lines.push('74', String(e.fitPoints.length));
+    for (const k of e.knots)
+        lines.push('40', String(k));
+    if (e.weights) {
+        for (const w of e.weights)
+            lines.push('41', String(w));
+    }
+    for (const cp of e.controlPoints)
+        lines.push('10', String(cp[0]), '20', String(cp[1]), '30', '0');
+    for (const fp of e.fitPoints)
+        lines.push('11', String(fp[0]), '21', String(fp[1]), '31', '0');
+    return lines.join('\n');
+}
+// ─── HATCH ───
+function rotateScale(p, scale, angleDeg) {
+    const a = angleDeg * Math.PI / 180;
+    const x = p[0] * scale, y = p[1] * scale;
+    return [x * Math.cos(a) - y * Math.sin(a), x * Math.sin(a) + y * Math.cos(a)];
+}
+/** Resolve a hatch's pattern lines (custom or built-in), scaled and rotated for output. */
+export function hatchPatternLines(e) {
+    const base = e.patternLines ?? HATCH_PATTERNS[e.patternName.toUpperCase()];
+    if (!base) {
+        throw new Error(`Unknown hatch pattern "${e.patternName}". Use one of ${Object.keys(HATCH_PATTERNS).join(', ')}, ` +
+            `or pass patternLines.`);
+    }
+    return base.map(([angle, basePoint, offset, dashes]) => [
+        angle + e.angle,
+        rotateScale(basePoint, e.scale, e.angle),
+        rotateScale(offset, e.scale, e.angle),
+        dashes.map(d => d * e.scale),
+    ]);
+}
+function serializeHatch(e, ctx) {
+    const lines = ['0', 'HATCH', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbHatch');
+    lines.push('10', '0', '20', '0', '30', '0');
+    lines.push('210', '0', '220', '0', '230', '1');
+    lines.push('2', e.solid ? 'SOLID' : e.patternName.toUpperCase());
+    lines.push('70', e.solid ? '1' : '0');
+    lines.push('71', '0'); // not associative
+    lines.push('91', String(e.boundaries.length));
+    e.boundaries.forEach((b, i) => {
+        lines.push('92', i === 0 ? '3' : '2'); // 2 = polyline path, 1 = external
+        lines.push('72', '0'); // no bulges
+        lines.push('73', '1'); // closed
+        lines.push('93', String(b.points.length));
+        for (const pt of b.points)
+            lines.push('10', String(pt[0]), '20', String(pt[1]));
+        lines.push('97', '0'); // no source boundary objects
+    });
+    lines.push('75', '0'); // odd parity (holes work)
+    lines.push('76', e.patternLines ? '2' : '1'); // 1 = predefined, 2 = custom
+    if (!e.solid) {
+        const patternLines = hatchPatternLines(e);
+        lines.push('52', fmt(e.angle));
+        lines.push('41', fmt(e.scale));
+        lines.push('77', '0');
+        lines.push('78', String(patternLines.length));
+        for (const [angle, base, offset, dashes] of patternLines) {
+            lines.push('53', fmt(angle));
+            lines.push('43', fmt(base[0]), '44', fmt(base[1]));
+            lines.push('45', fmt(offset[0]), '46', fmt(offset[1]));
+            lines.push('79', String(dashes.length));
+            for (const d of dashes)
+                lines.push('49', fmt(d));
+        }
+    }
+    lines.push('98', '0');
+    return lines.join('\n');
+}
+function serializeDimension(e, ctx) {
+    const lines = ['0', 'DIMENSION', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbDimension');
+    lines.push('2', '*D0'); // block name auto-generated
+    lines.push('10', String(e.definitionPoint[0]), '20', String(e.definitionPoint[1]), '30', '0');
+    lines.push('11', String(e.textMidpoint[0]), '21', String(e.textMidpoint[1]), '31', '0');
+    lines.push('70', String(e.dimensionType));
+    if (e.text)
+        lines.push('1', e.text);
+    if (e.style)
+        lines.push('3', e.style);
+    if (e.dimensionType <= 1) {
+        lines.push('100', 'AcDbAlignedDimension');
+        if (e.point1)
+            lines.push('13', String(e.point1[0]), '23', String(e.point1[1]), '33', '0');
+        if (e.point2)
+            lines.push('14', String(e.point2[0]), '24', String(e.point2[1]), '34', '0');
+        if (e.rotation)
+            lines.push('50', String(e.rotation));
+        if (e.dimensionType === 0)
+            lines.push('100', 'AcDbRotatedDimension');
+    }
+    return lines.join('\n');
+}
+function serializeLeader(e, ctx) {
+    const lines = ['0', 'LEADER', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbLeader');
+    if (e.style)
+        lines.push('3', e.style);
+    lines.push('71', e.hasArrowhead ? '1' : '0');
+    lines.push('72', '0'); // leader path type (0=straight)
+    lines.push('73', String(e.annotationType));
+    lines.push('76', String(e.vertices.length));
+    for (const v of e.vertices)
+        lines.push('10', String(v[0]), '20', String(v[1]), '30', '0');
+    return lines.join('\n');
+}
+// ─── VIEWPORT ───
+function serializeViewport(e, ctx) {
+    const lines = ['0', 'VIEWPORT', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbViewport');
+    lines.push('10', fmt(e.center[0]), '20', fmt(e.center[1]), '30', '0');
+    lines.push('40', fmt(e.width));
+    lines.push('41', fmt(e.height));
+    lines.push('68', String(e.status));
+    lines.push('69', String(e.id ?? e.status));
+    lines.push('12', fmt(e.viewCenter[0]), '22', fmt(e.viewCenter[1]));
+    lines.push('13', '0', '23', '0'); // snap base
+    lines.push('14', '10', '24', '10'); // snap spacing
+    lines.push('15', '10', '25', '10'); // grid spacing
+    lines.push('16', '0', '26', '0', '36', '1'); // view direction
+    lines.push('17', '0', '27', '0', '37', '0'); // view target
+    lines.push('42', '50'); // lens length
+    lines.push('43', '0', '44', '0'); // front/back clip
+    lines.push('45', fmt(e.viewHeight));
+    lines.push('50', '0', '51', '0'); // snap angle, twist
+    lines.push('72', '1000'); // circle zoom
+    for (const name of e.frozenLayers ?? []) {
+        const h = ctx.layerHandles?.get(name.toUpperCase());
+        if (h)
+            lines.push('331', h);
+    }
+    // 32768 = always set by AutoCAD; 16384 = display locked
+    lines.push('90', String(32768 | (e.locked ? 16384 : 0)));
+    lines.push('1', '');
+    lines.push('281', '0'); // render mode
+    lines.push('71', '1'); // UCS per viewport
+    lines.push('74', '0'); // UCS icon
+    lines.push('110', '0', '120', '0', '130', '0');
+    lines.push('111', '1', '121', '0', '131', '0');
+    lines.push('112', '0', '122', '1', '132', '0');
+    lines.push('79', '0');
+    lines.push('146', '0');
+    lines.push('170', '0'); // shade plot mode
+    lines.push('61', '5'); // grid frequency
+    lines.push('292', '1', '282', '1'); // default lighting
+    lines.push('141', '0', '142', '0'); // brightness, contrast
+    lines.push('63', '250', '421', '3355443'); // ambient light color
+    return lines.join('\n');
+}
+// ─── IMAGE ───
+/** Convert a WCS point to IMAGE clip-boundary pixel coordinates (origin top-left). */
+function wcsToImagePixel(e, p) {
+    const [ux, uy] = e.uVector, [vx, vy] = e.vVector;
+    // origin of pixel (0, height) grid, see DXF IMAGE clip boundary convention
+    const ox = e.insertionPoint[0] + ux * 0.5 - vx * 0.5;
+    const oy = e.insertionPoint[1] + uy * 0.5 - vy * 0.5;
+    const dx = p[0] - ox, dy = p[1] - oy;
+    const det = ux * vy - uy * vx;
+    const px = (dx * vy - dy * vx) / det;
+    const qy = (ux * dy - uy * dx) / det;
+    return [px, e.imageSize[1] - qy];
+}
+function serializeImage(e, ctx) {
+    const refs = ctx.images?.get(e);
+    if (!refs) {
+        throw new Error('IMAGE entities must be serialized through DxfDocument (image definition missing).');
+    }
+    const clip = e.clipBoundary && e.clipBoundary.length >= 3 ? [...e.clipBoundary] : undefined;
+    if (clip) {
+        const [f, l] = [clip[0], clip[clip.length - 1]];
+        if (f[0] !== l[0] || f[1] !== l[1])
+            clip.push(f); // AutoCAD requires a closed clip polygon
+    }
+    const lines = ['0', 'IMAGE', ...entityCommon(e, ctx, refs.handle)];
+    lines.push('100', 'AcDbRasterImage');
+    lines.push('90', '0');
+    lines.push('10', fmt(e.insertionPoint[0]), '20', fmt(e.insertionPoint[1]), '30', '0');
+    lines.push('11', fmt(e.uVector[0]), '21', fmt(e.uVector[1]), '31', '0');
+    lines.push('12', fmt(e.vVector[0]), '22', fmt(e.vVector[1]), '32', '0');
+    lines.push('13', String(e.imageSize[0]), '23', String(e.imageSize[1]));
+    lines.push('340', refs.defHandle);
+    lines.push('70', String(1 | 2 | (clip ? 4 : 0))); // show, show unaligned, use clip
+    lines.push('280', clip ? '1' : '0');
+    lines.push('281', String(e.brightness ?? 50));
+    lines.push('282', String(e.contrast ?? 50));
+    lines.push('283', String(e.fade ?? 0));
+    lines.push('360', refs.reactorHandle);
+    if (clip) {
+        lines.push('71', '2', '91', String(clip.length));
+        for (const p of clip) {
+            const [px, py] = wcsToImagePixel(e, p);
+            lines.push('14', fmt(px), '24', fmt(py));
+        }
+    }
+    else {
+        lines.push('71', '1', '91', '2');
+        lines.push('14', '-0.5', '24', '-0.5');
+        lines.push('14', fmt(e.imageSize[0] - 0.5), '24', fmt(e.imageSize[1] - 0.5));
+    }
+    lines.push('290', '0');
+    return lines.join('\n');
+}
+function serializeWipeout(e, ctx) {
+    const lines = ['0', 'WIPEOUT', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbWipeout');
+    lines.push('90', '0');
+    lines.push('10', String(e.insertionPoint[0]), '20', String(e.insertionPoint[1]), '30', '0');
+    lines.push('11', String(e.uVector[0]), '21', String(e.uVector[1]), '31', '0');
+    lines.push('12', String(e.vVector[0]), '22', String(e.vVector[1]), '32', '0');
+    lines.push('13', String(e.imageSize[0]), '23', String(e.imageSize[1]));
+    lines.push('70', '7');
+    lines.push('280', '1'); // clipping on
+    lines.push('71', '2'); // clip boundary type (2=polygon)
+    lines.push('91', String(e.clipBoundary.length));
+    for (const pt of e.clipBoundary)
+        lines.push('14', String(pt[0]), '24', String(pt[1]));
+    return lines.join('\n');
+}
+function serializeRegion(e, ctx) {
+    const lines = ['0', 'REGION', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbModelerGeometry');
+    lines.push('70', '1');
+    for (const line of e.acisData)
+        lines.push('1', line);
+    return lines.join('\n');
+}
+function serializeMesh(e, ctx) {
+    const lines = ['0', 'MESH', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbSubDMesh');
+    lines.push('71', '2'); // version
+    lines.push('72', String(e.subdivisionLevel));
+    lines.push('93', String(e.vertices.length));
+    for (const v of e.vertices)
+        lines.push('10', String(v[0]), '20', String(v[1]), '30', String(v[2]));
+    const faceData = [];
+    for (const f of e.faces) {
+        faceData.push(f.length, ...f);
+    }
+    lines.push('94', String(faceData.length));
+    for (const d of faceData)
+        lines.push('90', String(d));
+    lines.push('95', '0'); // edge count
+    lines.push('90', '0'); // edge crease count
+    return lines.join('\n');
+}
+function serializeMLeader(e, ctx) {
+    const lines = ['0', 'MULTILEADER', ...entityCommon(e, ctx)];
+    lines.push('100', 'AcDbMLeader');
+    lines.push('270', '2'); // version
+    lines.push('300', 'CONTEXT_DATA{');
+    lines.push('40', String(e.textHeight)); // text height
+    lines.push('10', String(e.textPosition[0]), '20', String(e.textPosition[1]), '30', '0');
+    lines.push('41', String(e.textWidth));
+    lines.push('304', e.text);
+    lines.push('301', '}');
+    // Leader line data
+    lines.push('302', 'LEADER{');
+    lines.push('290', '1'); // has set last leader line point
+    lines.push('291', '1'); // has set dogleg vector
+    lines.push('10', String(e.vertices[0]?.[0] || 0), '20', String(e.vertices[0]?.[1] || 0), '30', '0');
+    for (const v of e.vertices) {
+        lines.push('10', String(v[0]), '20', String(v[1]), '30', '0');
+    }
+    lines.push('303', '}');
+    // Style
+    lines.push('170', String(e.leaderType)); // leader type
+    lines.push('171', String(e.contentType)); // content type
+    lines.push('41', String(e.doglegLength)); // dogleg length
+    lines.push('40', String(e.arrowSize)); // arrow size
+    return lines.join('\n');
+}
+// ─── Table Records ───
+function recordHead(type, handle, owner, subclass) {
+    return ['0', type, '5', handle, '330', owner, '100', 'AcDbSymbolTableRecord', '100', subclass];
+}
+/** LAYER table record. `plotStyle` / `material` are the document's default object handles. */
+export function layerRecord(l, handle, owner, refs = {}) {
+    const color = Math.abs(l.color || 7);
+    const lines = recordHead('LAYER', handle, owner, 'AcDbLayerTableRecord');
+    lines.push('2', l.name);
+    lines.push('70', String((l.frozen ? 1 : 0) | (l.locked ? 4 : 0)));
+    lines.push('62', String(l.off ? -color : color));
+    lines.push('6', l.linetype || 'Continuous');
+    lines.push('370', '-3');
+    if (refs.plotStyle)
+        lines.push('390', refs.plotStyle);
+    if (refs.material)
+        lines.push('347', refs.material);
+    return lines.join('\n');
+}
+export function linetypeRecord(lt, handle, owner) {
+    const lines = recordHead('LTYPE', handle, owner, 'AcDbLinetypeTableRecord');
+    lines.push('2', lt.name);
+    lines.push('70', '0');
+    lines.push('3', lt.description);
+    lines.push('72', '65');
+    lines.push('73', String(lt.pattern.length));
+    lines.push('40', fmt(lt.pattern.reduce((sum, v) => sum + Math.abs(v), 0)));
+    for (const p of lt.pattern)
+        lines.push('49', fmt(p), '74', '0');
+    return lines.join('\n');
+}
+export function textStyleRecord(s, handle, owner) {
+    const lines = recordHead('STYLE', handle, owner, 'AcDbTextStyleTableRecord');
+    lines.push('2', s.name);
+    lines.push('70', '0');
+    lines.push('40', String(s.height || 0));
+    lines.push('41', '1');
+    lines.push('50', '0');
+    lines.push('71', '0');
+    lines.push('42', '2.5');
+    lines.push('3', s.font);
+    lines.push('4', '');
+    return lines.join('\n');
+}
+export function blockRecord(name, handle, owner, layoutHandle = '0') {
+    const lines = recordHead('BLOCK_RECORD', handle, owner, 'AcDbBlockTableRecord');
+    lines.push('2', name);
+    lines.push('340', layoutHandle);
+    lines.push('70', '0'); // insert units
+    lines.push('280', '1'); // explodable
+    lines.push('281', '0'); // scale uniformly: no
+    return lines.join('\n');
+}
+/**
+ * BLOCK … ENDBLK definition. `blockRecordHandle` owns the block and its content.
+ * Paper space layout blocks pass `paperSpace` so their content is flagged 67=1.
+ */
+export function blockDefinition(name, blockRecordHandle, basePoint, entities, ctx = {}) {
+    const paper = ctx.paperSpace ? ['67', '1'] : [];
+    const parts = [];
+    parts.push([
+        '0', 'BLOCK', '5', nextHandle(), '330', blockRecordHandle, '100', 'AcDbEntity', ...paper,
+        '8', '0', '100', 'AcDbBlockBegin', '2', name, '70', '0',
+        '10', String(basePoint[0]), '20', String(basePoint[1]), '30', '0', '3', name, '1', '',
+    ].join('\n'));
+    const entCtx = { ...ctx, owner: blockRecordHandle };
+    for (const e of entities)
+        parts.push(serializeEntity(e, entCtx));
+    parts.push([
+        '0', 'ENDBLK', '5', nextHandle(), '330', blockRecordHandle, '100', 'AcDbEntity', ...paper,
+        '8', '0', '100', 'AcDbBlockEnd',
+    ].join('\n'));
+    return parts.join('\n');
+}
+export { serializeEntity };

package/dist/core/hatch-patterns.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ */
+/** One hatch pattern line: angle (deg), base point, offset vector, dash lengths. */
+export type HatchPatternLine = [number, [number, number], [number, number], number[]];
+export declare const HATCH_PATTERNS: Record<string, HatchPatternLine[]>;