tsdraft 0.2.2 → 0.4.0

package/dist/drawing.js

@@ -1,104 +1,242 @@
+import { holdCall, readCall, recordCalls } from "./callsite.js";
 import { fmt, written } from "./format.js";
 import { layerAuditKey, layerKey } from "./layers.js";
-import { arcProblem, layerColorProblem, magnitudeProblem, layerNameProblem, layerTwinProblem, sizeProblem, textProblem, } from "./rules.js";
+import { BUILT_IN_LINETYPES, builtInLinetype } from "./linetypes.js";
+import { DrawingError } from "./lint.js";
+import { arcProblem, duplicateIdProblem, idKey, idProblem, layerColorProblem, layerFlagProblem, layerLinetypeProblem, layerStateProblem, lineweightProblem, linetypeNameProblem, linetypeProblem, linetypeScaleProblem, magnitudeProblem, layerNameProblem, layerTwinProblem, R12_ONLY, sizeProblem, textProblem, undefinedLinetypeProblem, } from "./rules.js";
 const UNITS = ["in", "ft", "mm", "cm", "m"];
 const DXF_VERSIONS = ["R12", "R2018"];
+/** A broken rule, thrown inside a builder method and turned into a `DrawingError` on its way out. */
+class Problem {
+    rule;
+    message;
+    constructor(rule, message) {
+        this.rule = rule;
+        this.message = message;
+    }
+}
+function refuse(rule, message) {
+    throw new Problem(rule, message);
+}
+/**
+ * What a builder method throws for something thrown inside it: for a `Problem`, a `DrawingError`
+ * whose one diagnostic names the caller's call of `method` and what the call was `about`.
+ */
+function located(thrown, method, about) {
+    if (!(thrown instanceof Problem))
+        return thrown;
+    const call = readCall(holdCall(method));
+    const diagnostic = {
+        rule: thrown.rule,
+        severity: "error",
+        message: thrown.message,
+        ...about,
+        ...(call ? { call } : {}),
+    };
+    return new DrawingError([diagnostic], thrown.message);
+}
+/** Whether a tool that runs drawing files has asked every builder to record calls. */
+function recordsCalls() {
+    return globalThis.TSDRAFT_RECORD_CALLS === true;
+}
 /**
  * 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.
+ * when the code runs, for values the compiler cannot see: `layer`, `linetype`
+ * and the entity methods then throw a `DrawingError` whose diagnostic has the
+ * rule, the entity's `id` and the `call` that broke it.
  */
 export class DrawingBuilder {
     units;
     dxf;
+    linetypeScale;
     /** Keyed by `layerKey`, because AutoCAD ignores case in layer names. */
     #layers = new Map([["0", { name: "0", color: 7 }]]);
     /** The first layer name for each `layerAuditKey`, to find names AUDIT would call duplicates. */
     #audited = new Map([["0", "0"]]);
+    /** Keyed by `layerKey`: AutoCAD compares linetype names as it compares layer names. */
+    #linetypes = new Map();
+    /** Seeded with the built-in linetypes, whose twins AUDIT reports as it reports any other. */
+    #linetypesAudited = new Map(BUILT_IN_LINETYPES.map((name) => [layerAuditKey(name), name]));
     #entities = [];
+    /** The first spelling of each entity id, by `idKey`. */
+    #ids = new Map();
+    /** The call that drew each entity, when calls are recorded. */
+    #calls;
     #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";
+        const dxf = options.dxf ?? "R2018";
         if (!DXF_VERSIONS.includes(dxf)) {
             throw new Error(`Unsupported DXF version: ${JSON.stringify(dxf)}`);
         }
+        const scale = options.linetypeScale;
+        if (scale !== undefined) {
+            if (typeof scale !== "number")
+                throw new Error("linetypeScale must be a finite number");
+            if (dxf === "R12" && scale !== 1)
+                throw new Error(`linetypeScale: ${R12_ONLY.linetypes}`);
+            const problem = linetypeScaleProblem(scale);
+            if (problem)
+                throw new Error(`linetypeScale: ${problem}`);
+        }
         this.units = units;
         this.dxf = dxf;
+        this.linetypeScale = scale ?? 1;
+        this.#calls = (options.recordCalls ?? recordsCalls()) ? [] : undefined;
+    }
+    /**
+     * Defines a linetype, or updates the one of the same name. `dashed` and
+     * `DASHED` are the same linetype, as in CAD, and keep the first spelling.
+     * tsdraft exports the linetypes plans use, such as `DASHED` and `HIDDEN`.
+     */
+    linetype(linetype) {
+        const definition = linetype;
+        try {
+            if (this.dxf === "R12")
+                refuse("linetype", R12_ONLY.linetypes);
+            this.#define(definition);
+        }
+        catch (thrown) {
+            const name = definition?.name;
+            const about = typeof name === "string" ? { linetype: name } : {};
+            throw located(thrown, DrawingBuilder.prototype.linetype, about);
+        }
+        return this;
     }
     /**
      * 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.
+     * Options left out keep the values the layer has.
      */
     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;
+        let layer;
+        try {
+            layer = this.#layer(requested, options);
+        }
+        catch (thrown) {
+            throw located(thrown, DrawingBuilder.prototype.layer, { layer: requested });
+        }
+        if (draw) {
+            const previous = this.#current;
+            this.#current = layer.name;
+            try {
+                draw();
+            }
+            finally {
+                this.#current = previous;
+            }
+        }
+        return this;
+    }
+    /** Checks a layer and stores it. */
+    #layer(requested, o) {
+        const fail = (rule, problem) => refuse(rule, `Layer ${JSON.stringify(requested)}: ${problem}`);
         const nameProblem = layerNameProblem(requested, this.dxf);
         if (nameProblem)
-            throw new Error(`Layer ${JSON.stringify(requested)}: ${nameProblem}`);
+            fail("layer-name", nameProblem);
         const key = layerKey(requested);
         const existing = this.#layers.get(key);
         const auditKey = layerAuditKey(requested);
         const twinProblem = layerTwinProblem(requested, this.#audited.get(auditKey) ?? requested);
         if (twinProblem)
-            throw new Error(`Layer ${JSON.stringify(requested)}: ${twinProblem}`);
-        const color = options.color ?? existing?.color ?? 7;
+            fail("duplicate-layer", twinProblem);
+        const color = o.color ?? existing?.color ?? 7;
         const colorProblem = layerColorProblem(color);
         if (colorProblem)
-            throw new Error(`Layer ${JSON.stringify(requested)}: ${colorProblem}`);
+            fail("layer-color", colorProblem);
         const layer = { name: existing?.name ?? requested, color };
+        const set = (field, value, plain) => {
+            const kept = value === undefined ? existing?.[field] : value;
+            if (kept !== undefined && kept !== plain)
+                layer[field] = kept;
+        };
+        const r12 = this.dxf === "R12";
+        let linetype;
+        if (o.linetype !== undefined) {
+            if (r12 && !isBuiltIn(o.linetype, "Continuous"))
+                fail("linetype", R12_ONLY.linetypes);
+            linetype = this.#linetypeName(o.linetype, fail);
+            const problem = layerLinetypeProblem(linetype);
+            if (problem)
+                fail("linetype", problem);
+        }
+        set("linetype", linetype === undefined ? undefined : (builtInLinetype(linetype) ?? linetype), "Continuous");
+        if (o.lineweight !== undefined) {
+            const problem = lineweightProblem(o.lineweight, "layer");
+            if (problem)
+                fail("lineweight", problem);
+            if (r12 && o.lineweight !== "Default")
+                fail("lineweight", R12_ONLY.lineweights);
+        }
+        set("lineweight", o.lineweight, "Default");
+        for (const state of ["off", "frozen", "locked", "plot"]) {
+            const value = o[state];
+            const flagProblem = layerFlagProblem(state, value);
+            if (flagProblem)
+                fail("layer-state", flagProblem);
+            if (r12 && value !== undefined && value !== (state === "plot")) {
+                fail("layer-state", R12_ONLY.layerStates);
+            }
+            set(state, value, state === "plot");
+        }
+        const stateProblem = layerStateProblem(layer.name, layer.frozen);
+        if (stateProblem)
+            fail("layer-state", stateProblem);
         this.#layers.set(key, layer);
         if (!this.#audited.has(auditKey))
             this.#audited.set(auditKey, layer.name);
-        if (draw) {
-            const previous = this.#current;
-            this.#current = layer.name;
-            try {
-                draw();
-            }
-            finally {
-                this.#current = previous;
-            }
-        }
-        return this;
+        return layer;
     }
-    line(from, to) {
-        return this.#add({ kind: "line", layer: this.#current, from: pt(from), to: pt(to) });
+    line(from, to, options = {}) {
+        return this.#add(DrawingBuilder.prototype.line, options, () => ({
+            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 });
+    polyline(points, closed = false, options = {}) {
+        return this.#add(DrawingBuilder.prototype.polyline, options, () => {
+            if (points.length < 2)
+                refuse("geometry", "A polyline needs at least 2 points");
+            return { 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");
-        // A side can still vanish in the file: a corner and the one across from it may round together.
-        if (written(x + w) === written(x))
-            throw new Error(lostSide("width", "x", x));
-        if (written(y + h) === written(y))
-            throw new Error(lostSide("height", "y", y));
-        return this.polyline([
-            [x, y],
-            [x + w, y],
-            [x + w, y + h],
-            [x, y + h],
-        ], true);
-    }
-    circle(center, radius) {
-        return this.#add({
+    rect(corner, width, height, options = {}) {
+        return this.#add(DrawingBuilder.prototype.rect, options, () => {
+            const [x, y] = pt(corner);
+            const w = positive(width, "width");
+            const h = positive(height, "height");
+            // A side can still vanish in the file: a corner and the one across from it may round together.
+            if (written(x + w) === written(x))
+                refuse("geometry", lostSide("width", "x", x));
+            if (written(y + h) === written(y))
+                refuse("geometry", lostSide("height", "y", y));
+            const corners = [
+                [x, y],
+                [x + w, y],
+                [x + w, y + h],
+                [x, y + h],
+            ];
+            return { kind: "polyline", layer: this.#current, points: corners.map(pt), closed: true };
+        });
+    }
+    circle(center, radius, options = {}) {
+        return this.#add(DrawingBuilder.prototype.circle, options, () => ({
             kind: "circle",
             layer: this.#current,
             center: pt(center),
             radius: positive(radius, "radius"),
-        });
+        }));
     }
     /**
      * Arc from `startAngle` counterclockwise to `endAngle`. Angles are stored
@@ -109,52 +247,178 @@ export class DrawingBuilder {
      * full turn would be written with equal angles, which AutoCAD holds as an
      * arc of no length, so it throws: draw a circle instead.
      */
-    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");
-        const problem = arcProblem(start, end);
-        if (problem)
-            throw new Error(problem);
-        return this.#add({
-            kind: "arc",
-            layer: this.#current,
-            center: pt(center),
-            radius: positive(radius, "radius"),
-            startAngle: start,
-            endAngle: end,
+    arc(center, radius, startAngle, endAngle, options = {}) {
+        return this.#add(DrawingBuilder.prototype.arc, options, () => {
+            const start = turn(num(startAngle, "startAngle"));
+            const end = turn(num(endAngle, "endAngle"));
+            if (start === end)
+                refuse("geometry", "An arc's start and end angles must differ");
+            const problem = arcProblem(start, end);
+            if (problem)
+                refuse("geometry", problem);
+            return {
+                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: kept(options.rotation ?? 0, "rotation"),
+        return this.#add(DrawingBuilder.prototype.text, options, () => {
+            const problem = textProblem(value);
+            if (problem)
+                refuse("text", problem);
+            return {
+                kind: "text",
+                layer: this.#current,
+                at: pt(at),
+                value,
+                height: positive(options.height ?? 0.125, "height"),
+                rotation: kept(options.rotation ?? 0, "rotation"),
+            };
         });
     }
     build() {
+        const entities = [...this.#entities];
+        if (this.#calls)
+            recordCalls(entities, [...this.#calls]);
         return {
+            format: 0,
             units: this.units,
             dxf: this.dxf,
             layers: [...this.#layers.values()],
-            entities: [...this.#entities],
+            entities,
+            linetypes: [...this.#linetypes.values()],
+            linetypeScale: this.linetypeScale,
         };
     }
-    #add(entity) {
-        this.#entities.push(entity);
+    /**
+     * Checks the entity that `make` gives and the `EntityOptions` it was drawn with, whose type
+     * parameters differ from method to method, and stores it. `method` is the builder method the
+     * caller called, which a diagnostic names the call of.
+     */
+    #add(method, options, make) {
+        const o = options;
+        const id = o.id;
+        try {
+            const key = id === undefined ? undefined : this.#idKey(id);
+            const named = id === undefined ? {} : { id: id };
+            this.#entities.push({ ...make(), ...named, ...this.#style(o) });
+            if (key !== undefined)
+                this.#ids.set(key, id);
+        }
+        catch (thrown) {
+            throw located(thrown, method, typeof id === "string" ? { id } : {});
+        }
+        this.#calls?.push(holdCall(method));
         return this;
     }
+    /** Checks an id the drawing does not have yet, and returns the key it is kept by. */
+    #idKey(id) {
+        const problem = idProblem(id);
+        if (problem)
+            refuse("id", problem);
+        const key = idKey(id);
+        const first = this.#ids.get(key);
+        if (first !== undefined)
+            refuse("duplicate-id", duplicateIdProblem(id, first));
+        return key;
+    }
+    /** The linetype and lineweight an entity is stored with. */
+    #style(options) {
+        const style = {};
+        if (options.linetype !== undefined) {
+            if (this.dxf === "R12" && !isBuiltIn(options.linetype, "ByLayer")) {
+                refuse("linetype", R12_ONLY.entityStyle);
+            }
+            const name = this.#linetypeName(options.linetype, refuse);
+            const builtIn = builtInLinetype(name);
+            if (builtIn !== "ByLayer")
+                style.linetype = builtIn ?? name;
+        }
+        const weight = options.lineweight;
+        if (weight !== undefined) {
+            const problem = lineweightProblem(weight, "entity");
+            if (problem)
+                refuse("lineweight", problem);
+            if (this.dxf === "R12" && weight !== "ByLayer")
+                refuse("lineweight", R12_ONLY.entityStyle);
+            if (weight !== "ByLayer")
+                style.lineweight = weight;
+        }
+        return style;
+    }
+    /**
+     * The name of the linetype a layer or entity asks for, in the spelling the
+     * drawing has it. A definition is defined first if the drawing does not have it.
+     */
+    #linetypeName(choice, fail) {
+        if (typeof choice === "object" && choice !== null) {
+            return this.#define(choice, true);
+        }
+        if (typeof choice !== "string") {
+            return fail("undefined-linetype", "A linetype is a name or a LinetypeDefinition");
+        }
+        const problem = linetypeNameProblem(choice);
+        if (problem)
+            fail("undefined-linetype", `Linetype ${JSON.stringify(choice)}: ${problem}`);
+        const known = builtInLinetype(choice) ?? this.#linetypes.get(layerKey(choice))?.name;
+        if (known === undefined) {
+            const absent = `${undefinedLinetypeProblem(choice)}. Define it with linetype() first`;
+            fail("undefined-linetype", absent);
+        }
+        return known;
+    }
+    /**
+     * Checks a definition and stores it, and returns the name the drawing has it by. A
+     * definition given to a layer or an entity must match the one the drawing has of its name,
+     * where `linetype()` replaces it.
+     */
+    #define(definition, inline = false) {
+        const label = `Linetype ${JSON.stringify(definition.name)}`;
+        const problem = linetypeProblem(definition.name, definition.description ?? "", definition.pattern);
+        if (problem)
+            refuse("linetype", `${label}: ${problem}`);
+        // linetypeProblem has checked the types.
+        const name = definition.name;
+        const description = (definition.description ?? "");
+        const lengths = definition.pattern;
+        const key = layerKey(name);
+        const auditKey = layerAuditKey(name);
+        const twin = layerTwinProblem(name, this.#linetypesAudited.get(auditKey) ?? name, "linetype");
+        if (twin)
+            refuse("duplicate-linetype", `${label}: ${twin}`);
+        const existing = this.#linetypes.get(key);
+        if (inline && existing) {
+            const same = existing.description === description &&
+                existing.pattern.length === lengths.length &&
+                existing.pattern.every((length, i) => length === lengths[i]);
+            if (!same) {
+                refuse("linetype", `${label}: the drawing has a linetype of this name with another pattern or description. Pass its name, or change it with linetype()`);
+            }
+            return existing.name;
+        }
+        const stored = existing?.name ?? name;
+        this.#linetypes.set(key, {
+            name: stored,
+            description,
+            pattern: [...lengths],
+        });
+        if (!this.#linetypesAudited.has(auditKey))
+            this.#linetypesAudited.set(auditKey, name);
+        return stored;
+    }
 }
 export function createDrawing(options) {
     return new DrawingBuilder(options);
 }
+/** True when `choice` names the built-in linetype `name`, in any case. */
+function isBuiltIn(choice, name) {
+    return typeof choice === "string" && builtInLinetype(choice) === name;
+}
 /** Counterclockwise sweep from start to end, in degrees, within [0, 360). */
 export function sweep(startAngle, endAngle) {
     return turn(endAngle - startAngle);
@@ -167,17 +431,17 @@ function turn(degrees) {
 }
 function num(value, label) {
     if (!Number.isFinite(value))
-        throw new Error(`${label} must be a finite number`);
+        refuse("geometry", `${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`);
+        return refuse("geometry", `${label} must be a finite number`);
     }
     const problem = sizeProblem(value);
     if (problem)
-        throw new Error(`${label}: ${problem}`);
+        refuse("geometry", `${label}: ${problem}`);
     return value;
 }
 function lostSide(size, axis, at) {
@@ -187,7 +451,7 @@ function lostSide(size, axis, at) {
 function kept(value, label) {
     const problem = magnitudeProblem(num(value, label));
     if (problem)
-        throw new Error(`${label}: ${problem}`);
+        refuse("geometry", `${label}: ${problem}`);
     return value;
 }
 function pt(point) {

package/dist/dxf-r2018.js

@@ -1,6 +1,7 @@
 import { extents } from "./extents.js";
-import { dxfText, fmt, readable, writtenAngle } from "./format.js";
+import { dxfOnce, dxfText, fmt, readable, written, writtenAngle } from "./format.js";
 import { layerZeroFirst } from "./layers.js";
+import { entityLinetype, layerLinetype, lineweightCode, patternLength } from "./linetypes.js";
 /** `$INSUNITS` codes from the DXF Reference. */
 const INSUNITS = { in: 1, ft: 2, mm: 4, cm: 5, m: 6 };
 /**
@@ -44,20 +45,26 @@ export function toDXFR2018(drawing) {
             fields: (g) => writeActiveViewport(g, minX, minY, maxX, maxY),
         },
     ]);
-    writeTable(g, handle, "LTYPE", [
-        ["ByBlock", ""],
-        ["ByLayer", ""],
-        ["Continuous", "Solid line"],
-    ].map(([name = "", description = ""]) => ({
+    const linetypes = [
+        { name: "ByBlock", description: "", pattern: [] },
+        { name: "ByLayer", description: "", pattern: [] },
+        { name: "Continuous", description: "Solid line", pattern: [] },
+        ...(drawing.linetypes ?? []),
+    ];
+    writeTable(g, handle, "LTYPE", linetypes.map((linetype) => ({
         type: "LTYPE",
         subclass: "AcDbLinetypeTableRecord",
-        name,
+        name: linetype.name,
         handle: handle(),
         fields: (g) => {
-            g(3, description);
-            g(72, 65);
-            g(73, 0);
-            g(40, 0);
+            g(3, dxfOnce(linetype.description));
+            g(72, 65); // alignment: "A"
+            g(73, linetype.pattern.length);
+            g(40, patternLength(linetype.pattern.map(written)));
+            for (const length of linetype.pattern) {
+                g(49, length);
+                g(74, 0); // a plain dash, gap or dot
+            }
         },
     })));
     writeTable(g, handle, "LAYER", 
@@ -67,10 +74,14 @@ export function toDXFR2018(drawing) {
         subclass: "AcDbLayerTableRecord",
         name: layer.name,
         handle: handle(),
+        flags: (layer.frozen ? 1 : 0) | (layer.locked ? 4 : 0),
         fields: (g) => {
-            g(62, layer.color);
-            g(6, "Continuous");
-            g(370, -3); // lineweight: default
+            // A layer that is off has its color negated.
+            g(62, layer.off ? -layer.color : layer.color);
+            g(6, layerLinetype(layer));
+            if (layer.plot === false)
+                g(290, 0);
+            g(370, lineweightCode(layer.lineweight ?? "Default"));
             g(390, normalPlotStyle); // AutoCAD rejects a layer without a plot style
         },
     })));
@@ -177,6 +188,10 @@ export function toDXFR2018(drawing) {
     h(70, INSUNITS[drawing.units]);
     h(9, "$MEASUREMENT");
     h(70, drawing.units === "in" || drawing.units === "ft" ? 0 : 1);
+    if (drawing.linetypeScale !== undefined && drawing.linetypeScale !== 1) {
+        h(9, "$LTSCALE");
+        h(40, drawing.linetypeScale);
+    }
     h(9, "$CLAYER");
     h(8, "0");
     h(9, "$HANDSEED");
@@ -224,7 +239,7 @@ function writeTable(g, handle, name, records) {
         g(100, "AcDbSymbolTableRecord");
         g(100, r.subclass);
         g(2, r.name);
-        g(70, 0);
+        g(70, r.flags ?? 0);
         r.fields?.(g);
     }
     g(0, "ENDTAB");
@@ -298,6 +313,12 @@ function writeEntity(g, e, handle, owner) {
         g(330, owner);
         g(100, "AcDbEntity");
         g(8, e.layer);
+        const linetype = entityLinetype(e);
+        if (linetype !== undefined)
+            g(6, linetype);
+        if (e.lineweight !== undefined && e.lineweight !== "ByLayer") {
+            g(370, lineweightCode(e.lineweight));
+        }
         g(100, subclass);
     };
     switch (e.kind) {

package/dist/dxf.d.ts

@@ -1,6 +1,6 @@
 import type { Drawing, DxfVersion } from "./drawing.ts";
 export interface DxfOptions {
-    /** Defaults to the version the drawing was created for, which is `"R12"` unless set. */
+    /** Defaults to the version the drawing was created for, which is `"R2018"` unless set. */
     readonly version?: DxfVersion;
 }
 /**

package/dist/format.d.ts

@@ -38,3 +38,10 @@ export declare function fmt(value: number): string;
  * versions before 2007 carry them. Later versions are UTF-8 and need no escape.
  */
 export declare function dxfText(value: string, ascii?: boolean): string;
+/**
+ * Escapes a string that AutoCAD decodes once when it reads DXF, as it does a linetype's
+ * description, so that AutoCAD holds the string as given. `dxfText` explains the escapes; a
+ * text is decoded twice, and a description once, so here a backslash that would start an
+ * escape is written as `\U+005C`.
+ */
+export declare function dxfOnce(value: string): string;

package/dist/format.js

@@ -76,3 +76,12 @@ export function dxfText(value, ascii = false) {
     }
     return out;
 }
+/**
+ * Escapes a string that AutoCAD decodes once when it reads DXF, as it does a linetype's
+ * description, so that AutoCAD holds the string as given. `dxfText` explains the escapes; a
+ * text is decoded twice, and a description once, so here a backslash that would start an
+ * escape is written as `\U+005C`.
+ */
+export function dxfOnce(value) {
+    return value.replace(ESCAPE_START, "\\U+005C").replaceAll("^", "^ ");
+}

package/dist/index.d.ts

@@ -1,5 +1,9 @@
-export { createDrawing, DrawingBuilder, sweep, type Arc, type Circle, type Drawing, type DrawingOptions, type DxfVersion, type Entity, type Layer, type LayerOptions, type Line, type Point, type Polyline, type Text, type TextOptions, type Units, } from "./drawing.ts";
+export type { CallSite } from "./callsite.ts";
+export { createDrawing, DrawingBuilder, sweep, type Arc, type Circle, type Drawing, type DrawingOptions, type DxfVersion, type Entity, type EntityOptions, type Layer, type LayerOptions, type Line, type Linetype, type LinetypeChoice, type LinetypeDefinition, type Lineweight, type Point, type Polyline, type Text, type TextOptions, type Units, } from "./drawing.ts";
 export { toDXF, type DxfOptions } from "./dxf.ts";
+export { fromJSON, toJSON } from "./json.ts";
 export { DrawingError, lint, type Diagnostic, type LintOptions, type LintRule } from "./lint.ts";
-export type { Aci, LayerColor, LayerName, Positive } from "./rules.ts";
+export { CENTER, DASHDOT, DASHED, DOT, HIDDEN, LINEWEIGHTS, PHANTOM } from "./linetypes.ts";
+export { fromPaper, type PaperScale, type PaperUnit } from "./paper.ts";
+export type { Aci, Description, EntityId, LayerColor, LayerLinetypeName, LayerName, LineweightOf, LinetypeName, NewLinetypeName, PaperLength, Pattern, Positive, Ratio, } from "./rules.ts";
 export { toSVG, type SvgOptions } from "./svg.ts";