tsdraft 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+## 0.2.0
+
+0.1.1 was never published, so its changes ship here too.
+
+Every fix below comes from opening tsdraft's output in AutoCAD 2025.
+
+- `createDrawing({ dxf: "R2018" })` targets AC1032, the DXF version AutoCAD has
+  used since 2018. It writes handles, owner links, the standard tables, model
+  and paper space blocks, plot styles and `$INSUNITS`. R12 stays the default.
+  `toDXF(drawing)` writes the drawing's version, and
+  `toDXF(drawing, { version })` writes another.
+- Layer names, layer colors, radii, text heights and rectangle sizes written as
+  literals are checked by the compiler. The same checks run when the code runs.
+- `lint(drawing, { version })` returns every problem in a drawing. `toDXF`
+  throws a `DrawingError` listing the errors instead of writing a file AutoCAD
+  would reject.
+- Fixed: AutoCAD discarded R12 drawings whose layer names had spaces, dots or
+  other punctuation, or more than 31 characters. Those names are now errors in
+  an R12 drawing and allowed in an R2018 drawing.
+- Fixed: a layer name containing a line break wrote extra records into the
+  file. Commas, carets and leading or trailing spaces are rejected too.
+- Fixed: AutoCAD discarded any drawing with a `^` in its text. A caret is now
+  escaped.
+- Fixed: R12 text outside ASCII came out garbled. It is now written as
+  `\U+XXXX` escapes.
+- Fixed: arc angles outside 0 to 360 failed `AUDIT`. Angles are now stored from
+  0 up to 360.
+- Fixed: `wall` and `WALL` were two layers, and AutoCAD kept only the first.
+  They are now one layer.
+- Text with control characters, or with emoji and other characters above
+  U+FFFF, is rejected, because AutoCAD cannot read it.
+- Unknown units, and rectangle sizes of 0 or less, are rejected.
+- Breaking: a `Drawing` now has a required `dxf` field, and R12 layer names
+  AutoCAD rejects now throw (see above).
+- `pnpm test:cad` runs the output through AutoCAD over ssh.
+- Published from GitHub Actions through npm trusted publishing, with a
+  provenance attestation linking the package to its source commit.
+- `tsdraft/package.json` can be imported or resolved.
+- The package now includes this changelog.
+
+## 0.1.0
+
+First release.
+
+- `createDrawing()` builds a drawing with layers (AutoCAD Color Index colors),
+  lines, polylines, rectangles, circles, arcs and single-line text.
+- `toDXF()` writes ASCII DXF R12 (AC1009) with layer and linetype tables.
+- `toSVG()` writes an SVG preview with model Y pointing up.

package/README.md

@@ -1,14 +1,18 @@
 # tsdraft
 
-Write 2D CAD drawings in TypeScript and export them as DXF for AutoCAD or
-BricsCAD, or as SVG for a quick preview. A drawing is a program, so dimensions
-can come from variables, sheets can share code, and changes show up as diffs.
-[tscircuit](https://github.com/tscircuit/tscircuit) takes the same approach to
-circuit boards.
+Write 2D CAD drawings in TypeScript and export them as DXF, the exchange format
+that AutoCAD, BricsCAD and most other CAD programs open, or as SVG for a quick
+preview. A drawing is a program, so dimensions can come from variables, drawings
+can share code, and changes show up as diffs.
 
-This is an early release. It has layers, lines, polylines, rectangles, circles,
-arcs and single-line text. It does not yet have dimensions, hatches, blocks,
-paper space or a JSX syntax.
+## Status
+
+tsdraft is at an early stage. It draws layers, lines, polylines, rectangles,
+circles, arcs and single-line text. It does not yet have dimensions, hatches,
+blocks, linetypes, lineweights or paper space layouts. It writes DXF, not DWG.
+
+The DXF output is tested by opening it in AutoCAD 2025 and running `AUDIT`. It
+has not been tested in BricsCAD or any other CAD program yet.
 
 ## Install
 
@@ -42,10 +46,67 @@ Coordinates are in drawing units with Y pointing up, as in CAD. Angles are in
 degrees, counterclockwise from +X. Layer colors are AutoCAD Color Index numbers.
 Entities go on layer `0` unless they are drawn inside a `layer()` callback.
 
-`toDXF` writes ASCII DXF R12, because nearly every CAD program can open that
-version. R12 has no field for drawing units, so the file holds plain numbers.
-Set the units in CAD after opening it, for example with `UNITS` in AutoCAD or
-BricsCAD.
+## DXF versions
+
+A drawing is written for one DXF version. `createDrawing()` targets R12, the
+oldest version still in common use, which nearly every CAD program can open.
+`createDrawing({ dxf: "R2018" })` targets the version AutoCAD has used since
+2018, which is the newest one Autodesk has published. `toDXF(drawing)` writes
+the drawing's version, and `toDXF(drawing, { version })` writes another one.
+
+|               | `"R12"`, the default                               | `"R2018"`                                              |
+| ------------- | -------------------------------------------------- | ------------------------------------------------------ |
+| Format code   | AC1009                                             | AC1032                                                 |
+| Drawing units | Not stored. Set them in CAD with `UNITS`.          | Stored in `$INSUNITS`.                                 |
+| Polylines     | `POLYLINE` with `VERTEX` records                   | `LWPOLYLINE`                                           |
+| Text          | ASCII, with `\U+XXXX` escapes for other characters | UTF-8                                                  |
+| Layer names   | Up to 31 letters, digits, `$`, `-` and `_`         | Up to 255 characters, with the exceptions listed below |
+
+Choose R2018 when the drawing will be inserted into another drawing, because CAD
+needs the stored units to scale it correctly. AutoCAD shows layer names from an
+R12 file in upper case.
+
+## Checks
+
+AutoCAD discards a whole drawing over one bad layer name, and it reports no
+line of your code when it does. tsdraft checks the rules AutoCAD enforces at
+three points, so the mistake shows up where you made it.
+
+1. **In the editor.** Layer names, colors and sizes written as literals are
+   checked by the TypeScript compiler, and the error message says what is wrong.
+2. **When the code runs.** The builder throws at the call that breaks a rule.
+   This covers values the compiler cannot see, such as a name read from a file.
+3. **Before export.** `lint(drawing)` returns every problem in a drawing, and
+   `toDXF` throws a `DrawingError` that lists them instead of writing a file
+   AutoCAD would reject.
+
+```ts
+const d = createDrawing({ units: "ft" });
+
+d.layer("A WALL");
+// error TS2345: Argument of type '"A WALL"' is not assignable to parameter of
+// type '"R12 layer names can only use letters, digits, $, - and _. Use DXF
+// version \"R2018\" for other characters"'.
+
+createDrawing({ dxf: "R2018" }).layer("A WALL"); // fine
+
+lint(drawing, { version: "R12" }); // check a drawing against another version
+```
+
+The rules:
+
+- Layer names cannot be empty, start or end with a space, or contain a line
+  break or any of ``< > / \ " : ; ? * | = ` ^ ,``. R12 names have the tighter
+  limits in the table above.
+- `wall` and `WALL` are the same layer, as in CAD. The first spelling is kept.
+- Layer colors are whole numbers from 1 to 255.
+- Radii, text heights and rectangle sizes are greater than 0.
+- Text is a single line. It cannot contain emoji or other characters above
+  U+FFFF, because AutoCAD cannot read them from DXF.
+- Arc angles are stored from 0 up to 360, so -90 becomes 270.
+
+`lint` also returns warnings, such as a line with no length. Warnings do not
+stop an export.
 
 ## Development
 
@@ -55,9 +116,16 @@ directly, so tests and examples need no build step.
 ```sh
 pnpm install
 pnpm verify    # format check, lint, type check, tests, package smoke test
-pnpm example   # writes examples/out/site-plan.dxf and .svg
+pnpm example   # writes a site plan to examples/out/ as DXF and SVG
 ```
 
+`pnpm test:cad` opens the output in AutoCAD. It needs
+`TSDRAFT_CAD_SSH=user@host`, an ssh login to a WSL shell on a Windows machine
+that has AutoCAD. Each test drawing runs in AutoCAD's headless console, which
+runs `AUDIT` and saves the drawing back as DXF. The script then compares that
+file with what was drawn. Run it after any change to a DXF writer, because
+AutoCAD rejects files that DXF parsing libraries accept.
+
 `pnpm test:package` packs the package, installs the tarball into a throwaway
 project and checks that it type-checks and runs there. `pnpm build` compiles
 `src/` to `dist/`, and `npm pack` and `npm publish` run it automatically.
@@ -68,6 +136,16 @@ as `pnpm check:tsrs` and as an informational CI step. It tracks TypeScript 7.1
 beta, so it does not gate releases yet. Its WebAssembly build is the planned
 route for type-checking drawings in a browser playground.
 
+## Releasing
+
+Bump `version` in `package.json` and add a CHANGELOG entry in a pull request.
+After it merges, publish a GitHub release tagged `v<version>` on the merge
+commit. The Release workflow checks that the tag matches the version, runs
+`pnpm verify` and publishes to npm through
+[trusted publishing](https://docs.npmjs.com/trusted-publishers), so no npm token
+is stored anywhere. npm adds a provenance attestation that links each version to
+the commit it was built from.
+
 ## License
 
 [MIT](LICENSE)

package/dist/drawing.d.ts

@@ -1,3 +1,4 @@
+import { type LayerColor, type LayerName, type Positive } from "./rules.ts";
 /** A model-space point, in drawing units. Y points up, as in CAD. */
 export type Point = readonly [x: number, y: number];
 /**
@@ -5,6 +6,15 @@ export type Point = readonly [x: number, y: number];
  * the DXF R12 writer has no field for it, so set units in CAD after opening.
  */
 export type Units = "in" | "ft" | "mm" | "cm" | "m";
+/**
+ * DXF versions tsdraft writes.
+ *
+ * - `"R12"` (AC1009) opens in nearly every CAD program, but stores no units and
+ *   limits layer names to 31 letters, digits, `$`, `-` and `_`.
+ * - `"R2018"` (AC1032) is the newest published version and the one AutoCAD has
+ *   used since 2018. It records the drawing's units.
+ */
+export type DxfVersion = "R12" | "R2018";
 export interface Layer {
     readonly name: string;
     /** AutoCAD Color Index, 1 to 255. 7 is white on dark backgrounds, black on light. */
@@ -28,7 +38,7 @@ export interface Circle extends EntityBase {
     readonly center: Point;
     readonly radius: number;
 }
-/** Angles are in degrees, counterclockwise from +X, as in DXF. */
+/** Angles are in degrees from 0 up to 360, counterclockwise from +X, as in DXF. */
 export interface Arc extends EntityBase {
     readonly kind: "arc";
     readonly center: Point;
@@ -48,39 +58,59 @@ export interface Text extends EntityBase {
 export type Entity = Line | Polyline | Circle | Arc | Text;
 export interface Drawing {
     readonly units: Units;
+    /** The DXF version the drawing is written for. `toDXF` uses it unless told otherwise. */
+    readonly dxf: DxfVersion;
     readonly layers: readonly Layer[];
     readonly entities: readonly Entity[];
 }
-export interface DrawingOptions {
+export interface DrawingOptions<V extends DxfVersion = DxfVersion> {
+    /** Defaults to `"in"`. */
     readonly units?: Units;
+    /** The DXF version to check the drawing against and export. Defaults to `"R12"`. */
+    readonly dxf?: V;
 }
-export interface LayerOptions {
-    readonly color?: number;
+export interface LayerOptions<C extends number = number> {
+    /** AutoCAD Color Index, 1 to 255. */
+    readonly color?: LayerColor<C>;
 }
-export interface TextOptions {
-    readonly height?: number;
+export interface TextOptions<H extends number = number> {
+    readonly height?: Positive<H>;
+    /** Degrees counterclockwise. */
     readonly rotation?: number;
 }
 /**
  * Builds a drawing. Entities go on the current layer, which starts as "0".
  * `layer(name, opts, draw)` scopes everything drawn inside `draw` to that layer.
+ *
+ * Mistakes written as literals, such as a layer name the DXF version does not
+ * allow or a negative radius, are compile errors. The same checks run again
+ * when the code runs, for values the compiler cannot see.
  */
-export declare class DrawingBuilder {
+export declare class DrawingBuilder<V extends DxfVersion = "R12"> {
     #private;
     readonly units: Units;
-    constructor(options?: DrawingOptions);
-    /** Defines or updates a layer. With `draw`, entities drawn inside it go on this layer. */
-    layer(name: string, options?: LayerOptions, draw?: () => void): this;
+    readonly dxf: V;
+    constructor(options?: DrawingOptions<V>);
+    /**
+     * Defines or updates a layer. With `draw`, entities drawn inside it go on this layer.
+     * `wall` and `WALL` are the same layer, as in CAD, and keep the first spelling.
+     */
+    layer<N extends string, C extends number = number>(name: LayerName<N, V>, options?: LayerOptions<C>, draw?: () => void): this;
     line(from: Point, to: Point): this;
     polyline(points: readonly Point[], closed?: boolean): this;
     /** Closed rectangle from its lower-left corner. */
-    rect(corner: Point, width: number, height: number): this;
-    circle(center: Point, radius: number): this;
-    arc(center: Point, radius: number, startAngle: number, endAngle: number): this;
-    text(at: Point, value: string, options?: TextOptions): this;
+    rect<W extends number, H extends number>(corner: Point, width: Positive<W>, height: Positive<H>): this;
+    circle<R extends number>(center: Point, radius: Positive<R>): this;
+    /**
+     * Arc from `startAngle` counterclockwise to `endAngle`. Angles are stored
+     * from 0 up to 360, so -90 becomes 270, because AutoCAD's AUDIT rejects
+     * angles outside that range.
+     */
+    arc<R extends number>(center: Point, radius: Positive<R>, startAngle: number, endAngle: number): this;
+    text<H extends number = number>(at: Point, value: string, options?: TextOptions<H>): this;
     build(): Drawing;
 }
-export declare function createDrawing(options?: DrawingOptions): DrawingBuilder;
+export declare function createDrawing<V extends DxfVersion = "R12">(options?: DrawingOptions<V>): DrawingBuilder<V>;
 /** Counterclockwise sweep from start to end, in degrees, within [0, 360). */
 export declare function sweep(startAngle: number, endAngle: number): number;
 export {};

package/dist/drawing.js

@@ -1,28 +1,53 @@
+import { layerColorProblem, layerNameProblem, textProblem, } from "./rules.js";
+const UNITS = ["in", "ft", "mm", "cm", "m"];
+const DXF_VERSIONS = ["R12", "R2018"];
 /**
  * Builds a drawing. Entities go on the current layer, which starts as "0".
  * `layer(name, opts, draw)` scopes everything drawn inside `draw` to that layer.
+ *
+ * Mistakes written as literals, such as a layer name the DXF version does not
+ * allow or a negative radius, are compile errors. The same checks run again
+ * when the code runs, for values the compiler cannot see.
  */
 export class DrawingBuilder {
     units;
+    dxf;
+    /** Keyed by lower-cased name, because CAD ignores case in layer names. */
     #layers = new Map([["0", { name: "0", color: 7 }]]);
     #entities = [];
     #current = "0";
     constructor(options = {}) {
-        this.units = options.units ?? "in";
+        const units = options.units ?? "in";
+        if (!UNITS.includes(units))
+            throw new Error(`Unknown units: ${JSON.stringify(units)}`);
+        const dxf = options.dxf ?? "R12";
+        if (!DXF_VERSIONS.includes(dxf)) {
+            throw new Error(`Unsupported DXF version: ${JSON.stringify(dxf)}`);
+        }
+        this.units = units;
+        this.dxf = dxf;
     }
-    /** Defines or updates a layer. With `draw`, entities drawn inside it go on this layer. */
+    /**
+     * Defines or updates a layer. With `draw`, entities drawn inside it go on this layer.
+     * `wall` and `WALL` are the same layer, as in CAD, and keep the first spelling.
+     */
     layer(name, options = {}, draw) {
-        if (!/^[^<>/\\":;?*|=`]{1,255}$/.test(name)) {
-            throw new Error(`Invalid layer name: ${JSON.stringify(name)}`);
-        }
-        const color = options.color ?? this.#layers.get(name)?.color ?? 7;
-        if (!Number.isInteger(color) || color < 1 || color > 255) {
-            throw new Error(`Layer ${name}: color must be an ACI integer from 1 to 255`);
-        }
-        this.#layers.set(name, { name, color });
+        // The parameter type is the error message when a literal name is wrong, so read it as a string.
+        const requested = name;
+        const nameProblem = layerNameProblem(requested, this.dxf);
+        if (nameProblem)
+            throw new Error(`Layer ${JSON.stringify(requested)}: ${nameProblem}`);
+        const key = requested.toLowerCase();
+        const existing = this.#layers.get(key);
+        const color = options.color ?? existing?.color ?? 7;
+        const colorProblem = layerColorProblem(color);
+        if (colorProblem)
+            throw new Error(`Layer ${JSON.stringify(requested)}: ${colorProblem}`);
+        const layer = { name: existing?.name ?? requested, color };
+        this.#layers.set(key, layer);
         if (draw) {
             const previous = this.#current;
-            this.#current = name;
+            this.#current = layer.name;
             try {
                 draw();
             }
@@ -43,13 +68,13 @@ export class DrawingBuilder {
     /** Closed rectangle from its lower-left corner. */
     rect(corner, width, height) {
         const [x, y] = pt(corner);
-        num(width, "width");
-        num(height, "height");
+        const w = positive(width, "width");
+        const h = positive(height, "height");
         return this.polyline([
             [x, y],
-            [x + width, y],
-            [x + width, y + height],
-            [x, y + height],
+            [x + w, y],
+            [x + w, y + h],
+            [x, y + h],
         ], true);
     }
     circle(center, radius) {
@@ -60,23 +85,29 @@ export class DrawingBuilder {
             radius: positive(radius, "radius"),
         });
     }
+    /**
+     * Arc from `startAngle` counterclockwise to `endAngle`. Angles are stored
+     * from 0 up to 360, so -90 becomes 270, because AutoCAD's AUDIT rejects
+     * angles outside that range.
+     */
     arc(center, radius, startAngle, endAngle) {
-        num(startAngle, "startAngle");
-        num(endAngle, "endAngle");
-        if (sweep(startAngle, endAngle) === 0)
+        const start = turn(num(startAngle, "startAngle"));
+        const end = turn(num(endAngle, "endAngle"));
+        if (start === end)
             throw new Error("An arc's start and end angles must differ");
         return this.#add({
             kind: "arc",
             layer: this.#current,
             center: pt(center),
             radius: positive(radius, "radius"),
-            startAngle,
-            endAngle,
+            startAngle: start,
+            endAngle: end,
         });
     }
     text(at, value, options = {}) {
-        if (/[\r\n]/.test(value))
-            throw new Error("Text must be a single line");
+        const problem = textProblem(value);
+        if (problem)
+            throw new Error(problem);
         return this.#add({
             kind: "text",
             layer: this.#current,
@@ -87,7 +118,12 @@ export class DrawingBuilder {
         });
     }
     build() {
-        return { units: this.units, layers: [...this.#layers.values()], entities: [...this.#entities] };
+        return {
+            units: this.units,
+            dxf: this.dxf,
+            layers: [...this.#layers.values()],
+            entities: [...this.#entities],
+        };
     }
     #add(entity) {
         this.#entities.push(entity);
@@ -99,15 +135,25 @@ export function createDrawing(options) {
 }
 /** Counterclockwise sweep from start to end, in degrees, within [0, 360). */
 export function sweep(startAngle, endAngle) {
-    return (((endAngle - startAngle) % 360) + 360) % 360;
+    return turn(endAngle - startAngle);
+}
+/** Brings an angle in degrees into [0, 360). */
+function turn(degrees) {
+    const wrapped = ((degrees % 360) + 360) % 360;
+    // A tiny negative angle rounds up to exactly 360.
+    return wrapped === 360 ? 0 : wrapped;
 }
 function num(value, label) {
     if (!Number.isFinite(value))
         throw new Error(`${label} must be a finite number`);
     return value;
 }
+/** Takes `unknown` because a `Positive<N>` parameter is a message string when the literal is wrong. */
 function positive(value, label) {
-    if (num(value, label) <= 0)
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`${label} must be a finite number`);
+    }
+    if (value <= 0)
         throw new Error(`${label} must be greater than 0`);
     return value;
 }

package/dist/dxf-r12.d.ts

@@ -0,0 +1,10 @@
+import type { Drawing } from "./drawing.ts";
+/**
+ * Writes an ASCII DXF (AC1009, R12). R12 is the most widely readable DXF:
+ * AutoCAD, BricsCAD, LibreCAD, QCAD and most converters open it.
+ *
+ * R12 has no header variable for drawing units, so coordinates are written as
+ * plain numbers in the drawing's units and `drawing.units` is not written.
+ * R12 predates Unicode DXF, so text outside ASCII is written as `\U+XXXX`.
+ */
+export declare function toDXFR12(drawing: Drawing): string;

package/dist/dxf-r12.js

@@ -0,0 +1,113 @@
+import { dxfText, fmt } from "./format.js";
+/**
+ * Writes an ASCII DXF (AC1009, R12). R12 is the most widely readable DXF:
+ * AutoCAD, BricsCAD, LibreCAD, QCAD and most converters open it.
+ *
+ * R12 has no header variable for drawing units, so coordinates are written as
+ * plain numbers in the drawing's units and `drawing.units` is not written.
+ * R12 predates Unicode DXF, so text outside ASCII is written as `\U+XXXX`.
+ */
+export function toDXFR12(drawing) {
+    const out = [];
+    const g = (code, value) => {
+        out.push(String(code), typeof value === "number" ? fmt(value) : value);
+    };
+    g(0, "SECTION");
+    g(2, "HEADER");
+    g(9, "$ACADVER");
+    g(1, "AC1009");
+    g(0, "ENDSEC");
+    g(0, "SECTION");
+    g(2, "TABLES");
+    g(0, "TABLE");
+    g(2, "LTYPE");
+    g(70, "1");
+    g(0, "LTYPE");
+    g(2, "CONTINUOUS");
+    g(70, "0");
+    g(3, "Solid line");
+    g(72, "65");
+    g(73, "0");
+    g(40, "0.0");
+    g(0, "ENDTAB");
+    g(0, "TABLE");
+    g(2, "LAYER");
+    g(70, String(drawing.layers.length));
+    for (const layer of drawing.layers) {
+        g(0, "LAYER");
+        g(2, layer.name);
+        g(70, "0");
+        g(62, String(layer.color));
+        g(6, "CONTINUOUS");
+    }
+    g(0, "ENDTAB");
+    g(0, "ENDSEC");
+    g(0, "SECTION");
+    g(2, "ENTITIES");
+    for (const entity of drawing.entities)
+        writeEntity(entity, g);
+    g(0, "ENDSEC");
+    g(0, "EOF");
+    return out.join("\r\n") + "\r\n";
+}
+function writeEntity(e, g) {
+    switch (e.kind) {
+        case "line":
+            g(0, "LINE");
+            g(8, e.layer);
+            g(10, e.from[0]);
+            g(20, e.from[1]);
+            g(30, 0);
+            g(11, e.to[0]);
+            g(21, e.to[1]);
+            g(31, 0);
+            return;
+        case "polyline":
+            g(0, "POLYLINE");
+            g(8, e.layer);
+            g(66, "1");
+            g(10, 0);
+            g(20, 0);
+            g(30, 0);
+            g(70, e.closed ? "1" : "0");
+            for (const [x, y] of e.points) {
+                g(0, "VERTEX");
+                g(8, e.layer);
+                g(10, x);
+                g(20, y);
+                g(30, 0);
+            }
+            g(0, "SEQEND");
+            g(8, e.layer);
+            return;
+        case "circle":
+            g(0, "CIRCLE");
+            g(8, e.layer);
+            g(10, e.center[0]);
+            g(20, e.center[1]);
+            g(30, 0);
+            g(40, e.radius);
+            return;
+        case "arc":
+            g(0, "ARC");
+            g(8, e.layer);
+            g(10, e.center[0]);
+            g(20, e.center[1]);
+            g(30, 0);
+            g(40, e.radius);
+            g(50, e.startAngle);
+            g(51, e.endAngle);
+            return;
+        case "text":
+            g(0, "TEXT");
+            g(8, e.layer);
+            g(10, e.at[0]);
+            g(20, e.at[1]);
+            g(30, 0);
+            g(40, e.height);
+            g(1, dxfText(e.value, true));
+            if (e.rotation !== 0)
+                g(50, e.rotation);
+            return;
+    }
+}

package/dist/dxf-r2018.d.ts

@@ -0,0 +1,10 @@
+import type { Drawing } from "./drawing.ts";
+/**
+ * Writes an ASCII DXF for AutoCAD 2018 and later (AC1032), the newest DXF
+ * version Autodesk has published. AutoCAD 2027 still reads and writes AC1032.
+ *
+ * Unlike R12, this version has handles, owner links, an OBJECTS section and the
+ * `$INSUNITS` header, so the drawing's units reach CAD and xref and block
+ * insertion scale correctly. Text is UTF-8.
+ */
+export declare function toDXFR2018(drawing: Drawing): string;