tsdraft 0.0.0-stage → 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/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stephen Frederick
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,151 @@
-# Temporary Holding Version
+# tsdraft
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+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.
+
+## 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
+
+```sh
+npm install tsdraft
+```
+
+tsdraft is an ES module and needs Node 22 or later.
+
+## Example
+
+```ts
+import { createDrawing, toDXF, toSVG } from "tsdraft";
+
+const d = createDrawing({ units: "ft" });
+
+d.layer("C-PROP", { color: 3 }, () => {
+  d.rect([0, 0], 75, 120);
+});
+d.layer("A-BLDG", { color: 1 }, () => {
+  d.rect([17.5, 30], 40, 50);
+  d.text([19.5, 55], "PROPOSED RESIDENCE", { height: 2 });
+});
+
+const drawing = d.build();
+const dxf = toDXF(drawing);
+const svg = toSVG(drawing);
+```
+
+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.
+
+## 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
+
+Contributors need Node 24 or later and pnpm. Node runs the TypeScript source
+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 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.
+
+The official TypeScript 7 compiler checks and builds the package.
+[tsrs](https://github.com/oxc-project/tsrs), the Rust port of TypeScript, runs
+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

@@ -0,0 +1,116 @@
+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];
+/**
+ * The unit one drawing unit stands for. It is kept on the drawing for callers;
+ * 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. */
+    readonly color: number;
+}
+interface EntityBase {
+    readonly layer: string;
+}
+export interface Line extends EntityBase {
+    readonly kind: "line";
+    readonly from: Point;
+    readonly to: Point;
+}
+export interface Polyline extends EntityBase {
+    readonly kind: "polyline";
+    readonly points: readonly Point[];
+    readonly closed: boolean;
+}
+export interface Circle extends EntityBase {
+    readonly kind: "circle";
+    readonly center: Point;
+    readonly radius: number;
+}
+/** 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;
+    readonly radius: number;
+    readonly startAngle: number;
+    readonly endAngle: number;
+}
+export interface Text extends EntityBase {
+    readonly kind: "text";
+    /** Left end of the text baseline. */
+    readonly at: Point;
+    readonly height: number;
+    readonly value: string;
+    /** Degrees counterclockwise. */
+    readonly rotation: number;
+}
+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<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<C extends number = number> {
+    /** AutoCAD Color Index, 1 to 255. */
+    readonly color?: LayerColor<C>;
+}
+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<V extends DxfVersion = "R12"> {
+    #private;
+    readonly units: Units;
+    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<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<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

@@ -0,0 +1,162 @@
+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 = {}) {
+        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.
+     * `wall` and `WALL` are the same layer, as in CAD, and keep the first spelling.
+     */
+    layer(name, options = {}, draw) {
+        // 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 = layer.name;
+            try {
+                draw();
+            }
+            finally {
+                this.#current = previous;
+            }
+        }
+        return this;
+    }
+    line(from, to) {
+        return this.#add({ kind: "line", layer: this.#current, from: pt(from), to: pt(to) });
+    }
+    polyline(points, closed = false) {
+        if (points.length < 2)
+            throw new Error("A polyline needs at least 2 points");
+        return this.#add({ kind: "polyline", layer: this.#current, points: points.map(pt), closed });
+    }
+    /** Closed rectangle from its lower-left corner. */
+    rect(corner, width, height) {
+        const [x, y] = pt(corner);
+        const w = positive(width, "width");
+        const h = positive(height, "height");
+        return this.polyline([
+            [x, y],
+            [x + w, y],
+            [x + w, y + h],
+            [x, y + h],
+        ], true);
+    }
+    circle(center, radius) {
+        return this.#add({
+            kind: "circle",
+            layer: this.#current,
+            center: pt(center),
+            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) {
+        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: start,
+            endAngle: end,
+        });
+    }
+    text(at, value, options = {}) {
+        const problem = textProblem(value);
+        if (problem)
+            throw new Error(problem);
+        return this.#add({
+            kind: "text",
+            layer: this.#current,
+            at: pt(at),
+            value,
+            height: positive(options.height ?? 0.125, "height"),
+            rotation: num(options.rotation ?? 0, "rotation"),
+        });
+    }
+    build() {
+        return {
+            units: this.units,
+            dxf: this.dxf,
+            layers: [...this.#layers.values()],
+            entities: [...this.#entities],
+        };
+    }
+    #add(entity) {
+        this.#entities.push(entity);
+        return this;
+    }
+}
+export function createDrawing(options) {
+    return new DrawingBuilder(options);
+}
+/** Counterclockwise sweep from start to end, in degrees, within [0, 360). */
+export function sweep(startAngle, endAngle) {
+    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 (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;
+}
+function pt(point) {
+    return [num(point[0], "x"), num(point[1], "y")];
+}

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;