tsdraft 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## 0.2.1
+
+Every fix below was found by opening tsdraft's output in AutoCAD 2025.
+
+- Fixed: text holding `\U+XXXX` or `\M+NXXXX` came out in AutoCAD as the
+  character those escapes stand for, so `\U+00B0` became a degree sign and
+  `\U+000A` put a line feed inside a single-line text. Both DXF versions now
+  write such a backslash so that AutoCAD holds the text as the drawing has it
+  when it opens the file. AutoCAD decodes the text after all once it has saved
+  the drawing itself and opened it again: `\M+NXXXX` after a save as DWG, and
+  `\U+XXXX` too after a save as DXF.
+- Fixed: a size too small for the 6 decimals tsdraft writes was written as 0.
+  AutoCAD gave such a text its default height, and held such a circle or arc
+  with radius 0. A radius, text height or rectangle size that would be written
+  as 0 is now an error, in the compiler for a literal and when the code runs.
+  `rect()` also throws when a side is lost because two corners round together.
+- Fixed: AutoCAD reads only two exponent digits from DXF, so it took a number
+  written as `1e+100` for `1e+10`, with no `AUDIT` error. A coordinate, size or
+  text rotation of 1e100 or more is now an error, in the compiler for a size
+  written as a literal and when the code runs. The R2018 writer also caps the
+  extents and the view height it works out, which could pass 1e100 for a
+  drawing whose own numbers are all smaller.
+- Fixed: an arc within 0.000001 degrees of a full turn was written with equal
+  angles, which AutoCAD holds as an arc of no length. It is now an error. An arc
+  angle that rounds up to 360 is written as 0.
+- Fixed: `toDXF` wrote layer `0` wherever the drawing listed it, and `AUDIT`
+  reported "Layer zero name found at incorrect index" when another layer came
+  first. Layer `0` is now written first.
+- Fixed: `lint` matched layer names with JavaScript's `toLowerCase()`, which
+  AutoCAD does not use. It accepted an entity on `οδος` for a layer `ΟΔΟΣ`,
+  where AutoCAD makes a second layer. `lint` and the builder now compare names
+  as AutoCAD does. The README lists the pairs that differ.
+- Fixed: two layers such as `ΟΔΟΣ` and `οδος`, which AutoCAD keeps apart but
+  its `AUDIT` reports as a duplicate name, are now an error.
+- Fixed: AutoCAD discarded a drawing whose layer name had a zero-width space,
+  another invisible formatting character, a letterlike symbol such as the ohm
+  sign U+2126, or a Glagolitic, Coptic, Tifinagh, Georgian Supplement, Latin
+  Extended-C or Ethiopic Extended letter. Those names are now errors, in the
+  compiler for a literal and when the code runs. The README lists them.
+- Fixed: `lint` threw a `RangeError` on a polyline of about 100,000 points or
+  more.
+- Fixed: a layer name that starts or ends with a no-break space, or another
+  space outside ASCII, threw when the code ran, though the compiler accepted
+  the literal and AutoCAD accepts the name. Only an ASCII space is refused now.
+- Fixed: AutoCAD replaced the private-use characters U+E800 to U+E8FF in text
+  and layer names. They are now errors.
+- Fixed: `toSVG` drew nothing for an arc so close to a full turn that its ends
+  rounded to one point, and ignored a layer's color when an entity spelled the
+  layer's name in another case.
+- Changed: a `DrawingError` message starts "The drawing has 3 problems:" and no
+  longer names DXF, because code other than `toDXF` uses it to refuse a drawing.
+- Changed: `lint` messages for a bad radius or height read "radius: This value
+  must be greater than 0", the wording the compiler uses for a literal.
+- `lint` warns about a polyline or an arc with no length, as it does for a line,
+  and about a line, polyline or arc that loses its length to rounding.
+- `lint` warns about text that contains `%%`, which AutoCAD stores as written
+  but draws as a control code: `%%d` is drawn as a degree sign.
+- `pnpm test:cad` covers each fix above, and checks every character `lint`
+  accepts in text and in layer names, and each form of number the writers
+  print, against AutoCAD.
+
 ## 0.2.0
 
 0.1.1 was never published, so its changes ship here too.

package/README.md

@@ -46,6 +46,12 @@ 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.
 
+Numbers are written with 6 decimals, in DXF and in SVG. The checks below judge
+a drawing as it will be written, so a size too small to survive the rounding is
+an error and a line that rounds down to a point is a warning. Every number must
+also be under 1e100 in size. AutoCAD reads only two exponent digits from DXF, so
+it would take `1e+100` for `1e+10` and report nothing.
+
 ## DXF versions
 
 A drawing is written for one DXF version. `createDrawing()` targets R12, the
@@ -98,15 +104,101 @@ 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.
+- Layer names cannot contain the other characters AutoCAD refuses in a name. It
+  discards the drawing over any of them, and they are listed under
+  [Layer name characters](#layer-name-characters).
 - `wall` and `WALL` are the same layer, as in CAD. The first spelling is kept.
+  tsdraft compares names the way AutoCAD does, which is not the way JavaScript
+  does: see [Layer names and case](#layer-names-and-case).
 - Layer colors are whole numbers from 1 to 255.
-- Radii, text heights and rectangle sizes are greater than 0.
+- Radii, text heights and rectangle sizes are greater than 0, and large enough
+  not to be written as 0. Anything from 0.000001 up is safe. AutoCAD gives text
+  of height 0 its default height.
 - 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.
+  U+FFFF, because AutoCAD cannot read them from DXF, or the private-use
+  characters U+E800 to U+E8FF, which AutoCAD replaces.
+- Coordinates, sizes and text rotations are under 1e100 in size, because
+  AutoCAD reads only two exponent digits from DXF.
+- Arc angles are stored from 0 up to 360, so -90 becomes 270. An arc cannot come
+  within 0.000001 degrees of a full turn, because its two angles would be
+  written the same and AutoCAD holds such an arc as having no length. Draw a
+  circle instead.
+
+`lint` also returns warnings. Warnings do not stop an export. They are:
+
+- A line, a polyline or an arc that has no length, or has none once its numbers
+  are rounded.
+- Text that contains `%%`. AutoCAD stores the text as written but reads `%%` as
+  the start of a control code when it draws it: `%%d` is drawn as a degree sign
+  and `%%%` as one percent sign.
+
+`toDXF` throws a `DrawingError` for errors only. Its `diagnostics` property holds
+them, and other code may throw one to refuse a drawing for its own reasons.
+
+### Text
+
+When AutoCAD opens tsdraft's DXF, it holds each text exactly as the drawing has
+it. tsdraft escapes what DXF would otherwise read as something else: a caret,
+and a backslash that starts `\U+XXXX` or `\M+NXXXX`, which AutoCAD decodes into
+a character. A text `\U+00B0` reaches AutoCAD as those seven characters and not
+as a degree sign. Write the character itself, `°`, to get the character.
+
+That lasts until AutoCAD saves the drawing, because AutoCAD does not escape these
+sequences in what it writes. After it saves as DWG and opens the file again, a
+text `\M+18140` holds the character U+3000. After it saves as DXF and opens
+that, `\U+00B0` holds a degree sign as well. tsdraft cannot change this.
+
+### Layer names and case
+
+AutoCAD lower-cases a layer name one character at a time, from a table of its
+own that is older and smaller than Unicode's. An entity on `mixedcase`, `café`,
+`αβγ` or `СЛОЙ` goes on a layer declared as `MixedCase`, `CAFÉ`, `ΑΒΓ` or `Слой`,
+and `lint` accepts it. AutoCAD does not pair these, and `lint` reports the
+entity's layer as undefined:
+
+- `ΟΔΟΣ` and `οδος`, because of the final sigma `ς`. `οδοσ` does match.
+- `STRASSE` and `straße`, and `TITLE` and `tıtle` with a dotless `ı`.
+- `Ÿ` and `ÿ`, `İ` and `i`, and the title-case digraphs such as `Dž`.
+- Georgian, Cherokee and most other letters that gained a case after Unicode
+  5.1.
+
+Declaring both spellings as layers is an error too for some of these pairs,
+among them `ΟΔΟΣ` and `οδος`, `Ÿ` and `ÿ`, and `ß` and `ẞ`. AutoCAD keeps two
+layers, and its `AUDIT` then reports a duplicate name.
+
+`AUDIT` compares names more loosely than `lint` can follow in full. It reports
+each of these pairs as a duplicate name while AutoCAD keeps both layers, and
+`lint` does not catch them:
+
+- A letter and the two letters it stands for: `ß` and `ss`, `æ` and `ae`, `œ`
+  and `oe`, `ij` and `ij`, `fi` and `fi`, `dž` and `dž`, `þ` and `th`.
+- A composed letter such as `é` and its decomposed form.
+- Names that differ only by a soft hyphen.
+
+### Layer name characters
+
+AutoCAD refuses these characters in a layer name, so `lint` does too. Over any
+of them but the last row's, AutoCAD discards the whole drawing. All are outside
+ASCII, so they only concern R2018 drawings.
+
+| Characters                                                                 | What they are                                              |
+| -------------------------------------------------------------------------- | ---------------------------------------------------------- |
+| U+0080 to U+009F                                                           | C1 control characters                                      |
+| U+0600 to U+0603, U+06DD, U+070F, U+17B4, U+17B5                           | Arabic, Syriac and Khmer formatting characters             |
+| U+200B to U+200F, U+202A to U+202E, U+2060 to U+2064, U+206A to U+206F     | Zero-width spaces and joiners, and text direction controls |
+| U+FEFF, U+FFF9 to U+FFFB                                                   | The byte order mark and annotation characters              |
+| U+2071, U+207F, U+2090 to U+2094                                           | Superscript and subscript letters                          |
+| Letters in U+2102 to U+214E, such as `ℓ`, `ℕ`, the ohm sign and the kelvin | Letterlike symbols. Use the Greek `Ω`, U+03A9, for ohms.   |
+| U+2180 to U+2188                                                           | Roman numeral characters                                   |
+| U+2C00 to U+2C5E, except U+2C2F                                            | Glagolitic                                                 |
+| U+2C60 to U+2C7D, except U+2C70                                            | Latin Extended-C                                           |
+| U+2C80 to U+2CE4                                                           | Coptic                                                     |
+| U+2D00 to U+2D25                                                           | Georgian Supplement                                        |
+| U+2D30 to U+2D65, U+2D6F                                                   | Tifinagh                                                   |
+| Letters in U+2D80 to U+2DDE                                                | Ethiopic Extended                                          |
+| U+E800 to U+E8FF                                                           | Private use. AutoCAD replaces these and keeps the drawing. |
+
+`src/layers.ts` has the exact list.
 
 ## Development
 
@@ -124,7 +216,8 @@ pnpm example   # writes a site plan to examples/out/ as DXF and SVG
 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.
+AutoCAD rejects files that DXF parsing libraries accept. Some of its cases write
+a file `toDXF` would refuse, to show that AutoCAD does what the rule says.
 
 `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

package/dist/drawing.d.ts

@@ -105,6 +105,10 @@ export declare class DrawingBuilder<V extends DxfVersion = "R12"> {
      * 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.
+     *
+     * Angles are written with 6 decimals. An arc within 0.000001 degrees of a
+     * 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<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;

package/dist/drawing.js

@@ -1,4 +1,6 @@
-import { layerColorProblem, layerNameProblem, textProblem, } from "./rules.js";
+import { fmt, written } from "./format.js";
+import { layerAuditKey, layerKey } from "./layers.js";
+import { arcProblem, layerColorProblem, magnitudeProblem, layerNameProblem, layerTwinProblem, sizeProblem, textProblem, } from "./rules.js";
 const UNITS = ["in", "ft", "mm", "cm", "m"];
 const DXF_VERSIONS = ["R12", "R2018"];
 /**
@@ -12,8 +14,10 @@ const DXF_VERSIONS = ["R12", "R2018"];
 export class DrawingBuilder {
     units;
     dxf;
-    /** Keyed by lower-cased name, because CAD ignores case in layer names. */
+    /** 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"]]);
     #entities = [];
     #current = "0";
     constructor(options = {}) {
@@ -37,14 +41,20 @@ export class DrawingBuilder {
         const nameProblem = layerNameProblem(requested, this.dxf);
         if (nameProblem)
             throw new Error(`Layer ${JSON.stringify(requested)}: ${nameProblem}`);
-        const key = requested.toLowerCase();
+        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;
         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 (!this.#audited.has(auditKey))
+            this.#audited.set(auditKey, layer.name);
         if (draw) {
             const previous = this.#current;
             this.#current = layer.name;
@@ -70,6 +80,11 @@ export class DrawingBuilder {
         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],
@@ -89,12 +104,19 @@ export class DrawingBuilder {
      * 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.
+     *
+     * Angles are written with 6 decimals. An arc within 0.000001 degrees of a
+     * 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,
@@ -114,7 +136,7 @@ export class DrawingBuilder {
             at: pt(at),
             value,
             height: positive(options.height ?? 0.125, "height"),
-            rotation: num(options.rotation ?? 0, "rotation"),
+            rotation: kept(options.rotation ?? 0, "rotation"),
         });
     }
     build() {
@@ -153,10 +175,21 @@ 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`);
+    const problem = sizeProblem(value);
+    if (problem)
+        throw new Error(`${label}: ${problem}`);
+    return value;
+}
+function lostSide(size, axis, at) {
+    return `${size}: This value is too small at ${axis} = ${at}. Both sides of the rectangle are written as ${axis} = ${fmt(at)}, because tsdraft writes 6 decimals`;
+}
+/** A number the drawing keeps and the writers print, which AutoCAD must be able to read. */
+function kept(value, label) {
+    const problem = magnitudeProblem(num(value, label));
+    if (problem)
+        throw new Error(`${label}: ${problem}`);
     return value;
 }
 function pt(point) {
-    return [num(point[0], "x"), num(point[1], "y")];
+    return [kept(point[0], "x"), kept(point[1], "y")];
 }

package/dist/dxf-r12.d.ts

@@ -6,5 +6,6 @@ import type { Drawing } from "./drawing.ts";
  * 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`.
+ * Layer `0` is written first, wherever it is in `drawing.layers`.
  */
 export declare function toDXFR12(drawing: Drawing): string;

package/dist/dxf-r12.js

@@ -1,4 +1,5 @@
-import { dxfText, fmt } from "./format.js";
+import { dxfText, fmt, writtenAngle } from "./format.js";
+import { layerZeroFirst } from "./layers.js";
 /**
  * Writes an ASCII DXF (AC1009, R12). R12 is the most widely readable DXF:
  * AutoCAD, BricsCAD, LibreCAD, QCAD and most converters open it.
@@ -6,6 +7,7 @@ import { dxfText, fmt } from "./format.js";
  * 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`.
+ * Layer `0` is written first, wherever it is in `drawing.layers`.
  */
 export function toDXFR12(drawing) {
     const out = [];
@@ -33,7 +35,7 @@ export function toDXFR12(drawing) {
     g(0, "TABLE");
     g(2, "LAYER");
     g(70, String(drawing.layers.length));
-    for (const layer of drawing.layers) {
+    for (const layer of layerZeroFirst(drawing.layers)) {
         g(0, "LAYER");
         g(2, layer.name);
         g(70, "0");
@@ -95,8 +97,8 @@ function writeEntity(e, g) {
             g(20, e.center[1]);
             g(30, 0);
             g(40, e.radius);
-            g(50, e.startAngle);
-            g(51, e.endAngle);
+            g(50, writtenAngle(e.startAngle));
+            g(51, writtenAngle(e.endAngle));
             return;
         case "text":
             g(0, "TEXT");

package/dist/dxf-r2018.js

@@ -1,5 +1,6 @@
 import { extents } from "./extents.js";
-import { dxfText, fmt } from "./format.js";
+import { dxfText, fmt, readable, writtenAngle } from "./format.js";
+import { layerZeroFirst } from "./layers.js";
 /** `$INSUNITS` codes from the DXF Reference. */
 const INSUNITS = { in: 1, ft: 2, mm: 4, cm: 5, m: 6 };
 /**
@@ -21,7 +22,14 @@ export function toDXFR2018(drawing) {
     const normalPlotStyle = handle();
     const modelSpace = handle();
     const paperSpace = handle();
-    const [minX, minY, maxX, maxY] = extents(drawing.entities);
+    // The extents are worked out here, so they are brought into the range AutoCAD reads.
+    const [left, bottom, right, top] = extents(drawing.entities);
+    const [minX, minY, maxX, maxY] = [
+        readable(left),
+        readable(bottom),
+        readable(right),
+        readable(top),
+    ];
     g(0, "SECTION");
     g(2, "CLASSES");
     g(0, "ENDSEC");
@@ -52,7 +60,9 @@ export function toDXFR2018(drawing) {
             g(40, 0);
         },
     })));
-    writeTable(g, handle, "LAYER", drawing.layers.map((layer) => ({
+    writeTable(g, handle, "LAYER", 
+    // AUDIT reports "Layer zero name found at incorrect index" unless layer 0 comes first.
+    layerZeroFirst(drawing.layers).map((layer) => ({
         type: "LAYER",
         subclass: "AcDbLayerTableRecord",
         name: layer.name,
@@ -222,7 +232,8 @@ function writeTable(g, handle, name, records) {
 /** The *Active viewport, zoomed to the drawing's extents so the file opens on the drawing. */
 function writeActiveViewport(g, minX, minY, maxX, maxY) {
     const aspect = 1.6;
-    const height = Math.max(maxY - minY, (maxX - minX) / aspect, 1) * 1.1;
+    // A drawing can span more than AutoCAD can read as one number, so the height is capped.
+    const height = readable(Math.max(maxY - minY, (maxX - minX) / aspect, 1) * 1.1);
     g(10, 0); // lower-left corner of the viewport on screen
     g(20, 0);
     g(11, 1); // upper-right corner
@@ -315,8 +326,8 @@ function writeEntity(g, e, handle, owner) {
             point(g, 10, ...e.center);
             g(40, e.radius);
             g(100, "AcDbArc");
-            g(50, e.startAngle);
-            g(51, e.endAngle);
+            g(50, writtenAngle(e.startAngle));
+            g(51, writtenAngle(e.endAngle));
             return;
         case "text":
             begin("TEXT", "AcDbText");

package/dist/format.d.ts

@@ -1,9 +1,38 @@
+/**
+ * A number as the writers print it: rounded to 6 decimals. Two values that are
+ * equal here are the same number in the file, whatever they were in the drawing.
+ */
+export declare function written(value: number): number;
+/**
+ * An arc angle in degrees as the DXF writers print it: rounded to 6 decimals,
+ * with 0 in place of an angle that rounds up to 360.
+ */
+export declare function writtenAngle(degrees: number): number;
+/**
+ * True for a number AutoCAD would misread from DXF, because it is 1e100 or
+ * more in size. `lint` refuses these wherever a drawing holds one.
+ */
+export declare function isTooLarge(value: number): boolean;
+/**
+ * Brings a number a writer works out for itself, such as an extent or the
+ * height of the view, into the range AutoCAD reads. `lint` cannot vouch for
+ * those: two coordinates under 1e100 can be more than 1e100 apart.
+ */
+export declare function readable(value: number): number;
 /** Formats a coordinate with at most 6 decimals, no float noise, and no "-0". */
 export declare function fmt(value: number): string;
 /**
- * Escapes a string value for DXF. A caret starts a control-character escape in
- * DXF, and AutoCAD discards the drawing when it meets a bare one, so a literal
- * caret is written as a caret and a space.
+ * Escapes a string value for DXF, so that AutoCAD holds the string as given.
+ *
+ * A caret starts a control-character escape in DXF, and AutoCAD discards the
+ * drawing when it meets a bare one, so a literal caret is written as a caret
+ * and a space.
+ *
+ * AutoCAD decodes `\U+XXXX` and `\M+NXXXX` in a string, and it does so twice.
+ * A backslash that would start one is written as `\U+005CU+005C`: the first
+ * pass leaves `\U+005C` and the second leaves the backslash, with nothing left
+ * to decode what follows it. This lasts until AutoCAD saves the drawing:
+ * AutoCAD writes the text unescaped, so it decodes it on a later open.
  *
  * With `ascii`, characters outside ASCII become `\U+XXXX`, which is how DXF
  * versions before 2007 carry them. Later versions are UTF-8 and need no escape.

package/dist/format.js

@@ -1,18 +1,72 @@
+/** The number of decimals the writers keep. */
+const DECIMALS = 6;
+/**
+ * A number as the writers print it: rounded to 6 decimals. Two values that are
+ * equal here are the same number in the file, whatever they were in the drawing.
+ */
+export function written(value) {
+    const rounded = Number(value.toFixed(DECIMALS));
+    return Object.is(rounded, -0) ? 0 : rounded;
+}
+/**
+ * An arc angle in degrees as the DXF writers print it: rounded to 6 decimals,
+ * with 0 in place of an angle that rounds up to 360.
+ */
+export function writtenAngle(degrees) {
+    const rounded = written(degrees);
+    return rounded >= 360 ? rounded - 360 : rounded;
+}
+/**
+ * The size from which a number prints with three exponent digits, as `1e+100`.
+ * AutoCAD reads only two from DXF: it takes `1e+100` for `1e+10` and
+ * `1e+308` for `1e+30`, with no AUDIT error. Writing the digits out does not
+ * help, because AutoCAD takes a number of 101 digits for 0.
+ */
+const TOO_LARGE = 1e100;
+/** The largest number under `TOO_LARGE`. */
+const LARGEST = 9.999999999999998e99;
+/**
+ * True for a number AutoCAD would misread from DXF, because it is 1e100 or
+ * more in size. `lint` refuses these wherever a drawing holds one.
+ */
+export function isTooLarge(value) {
+    return Math.abs(value) >= TOO_LARGE;
+}
+/**
+ * Brings a number a writer works out for itself, such as an extent or the
+ * height of the view, into the range AutoCAD reads. `lint` cannot vouch for
+ * those: two coordinates under 1e100 can be more than 1e100 apart.
+ */
+export function readable(value) {
+    return Math.max(-LARGEST, Math.min(LARGEST, value));
+}
 /** Formats a coordinate with at most 6 decimals, no float noise, and no "-0". */
 export function fmt(value) {
-    const rounded = Number(value.toFixed(6));
-    return Object.is(rounded, -0) ? "0" : String(rounded);
+    return String(written(value));
 }
 /**
- * Escapes a string value for DXF. A caret starts a control-character escape in
- * DXF, and AutoCAD discards the drawing when it meets a bare one, so a literal
- * caret is written as a caret and a space.
+ * A backslash that starts a `\U+XXXX` or `\M+NXXXX` sequence. AutoCAD decodes
+ * both forms in a DXF string, in either letter case.
+ */
+const ESCAPE_START = /\\(?=[Uu]\+[0-9A-Fa-f]{4}|[Mm]\+[1-5][0-9A-Fa-f]{4})/g;
+/**
+ * Escapes a string value for DXF, so that AutoCAD holds the string as given.
+ *
+ * A caret starts a control-character escape in DXF, and AutoCAD discards the
+ * drawing when it meets a bare one, so a literal caret is written as a caret
+ * and a space.
+ *
+ * AutoCAD decodes `\U+XXXX` and `\M+NXXXX` in a string, and it does so twice.
+ * A backslash that would start one is written as `\U+005CU+005C`: the first
+ * pass leaves `\U+005C` and the second leaves the backslash, with nothing left
+ * to decode what follows it. This lasts until AutoCAD saves the drawing:
+ * AutoCAD writes the text unescaped, so it decodes it on a later open.
  *
  * With `ascii`, characters outside ASCII become `\U+XXXX`, which is how DXF
  * versions before 2007 carry them. Later versions are UTF-8 and need no escape.
  */
 export function dxfText(value, ascii = false) {
-    const escaped = value.replaceAll("^", "^ ");
+    const escaped = value.replace(ESCAPE_START, "\\U+005CU+005C").replaceAll("^", "^ ");
     if (!ascii)
         return escaped;
     let out = "";

package/dist/layers.d.ts

@@ -0,0 +1,55 @@
+import type { Layer } from "./drawing.ts";
+/** C1 controls and invisible formatting characters, such as the zero-width space. */
+export declare const REJECTED_FORMAT = "\u0080\u0081\u0082\u0083\u0084\u0085\u0086\u0087\u0088\u0089\u008A\u008B\u008C\u008D\u008E\u008F\u0090\u0091\u0092\u0093\u0094\u0095\u0096\u0097\u0098\u0099\u009A\u009B\u009C\u009D\u009E\u009F\u0600\u0601\u0602\u0603\u06DD\u070F\u17B4\u17B5\u200B\u200C\u200D\u200E\u200F\u202A\u202B\u202C\u202D\u202E\u2060\u2061\u2062\u2063\u2064\u206A\u206B\u206C\u206D\u206E\u206F\uFEFF\uFFF9\uFFFA\uFFFB";
+/** Superscript and subscript letters, Roman numeral characters and letterlike symbols such as the ohm sign. */
+export declare const REJECTED_LETTERLIKE = "\u2071\u207F\u2090\u2091\u2092\u2093\u2094\u2102\u2107\u210A\u210B\u210C\u210D\u210E\u210F\u2110\u2111\u2112\u2113\u2115\u2119\u211A\u211B\u211C\u211D\u2124\u2126\u2128\u212A\u212B\u212C\u212D\u212F\u2130\u2131\u2132\u2133\u2134\u2135\u2136\u2137\u2138\u2139\u213C\u213D\u213E\u213F\u2145\u2146\u2147\u2148\u2149\u214E\u2180\u2181\u2182\u2183\u2184\u2185\u2186\u2187\u2188";
+/** Glagolitic letters and the Latin Extended-C block. */
+export declare const REJECTED_GLAGOLITIC = "\u2C00\u2C01\u2C02\u2C03\u2C04\u2C05\u2C06\u2C07\u2C08\u2C09\u2C0A\u2C0B\u2C0C\u2C0D\u2C0E\u2C0F\u2C10\u2C11\u2C12\u2C13\u2C14\u2C15\u2C16\u2C17\u2C18\u2C19\u2C1A\u2C1B\u2C1C\u2C1D\u2C1E\u2C1F\u2C20\u2C21\u2C22\u2C23\u2C24\u2C25\u2C26\u2C27\u2C28\u2C29\u2C2A\u2C2B\u2C2C\u2C2D\u2C2E\u2C30\u2C31\u2C32\u2C33\u2C34\u2C35\u2C36\u2C37\u2C38\u2C39\u2C3A\u2C3B\u2C3C\u2C3D\u2C3E\u2C3F\u2C40\u2C41\u2C42\u2C43\u2C44\u2C45\u2C46\u2C47\u2C48\u2C49\u2C4A\u2C4B\u2C4C\u2C4D\u2C4E\u2C4F\u2C50\u2C51\u2C52\u2C53\u2C54\u2C55\u2C56\u2C57\u2C58\u2C59\u2C5A\u2C5B\u2C5C\u2C5D\u2C5E\u2C60\u2C61\u2C62\u2C63\u2C64\u2C65\u2C66\u2C67\u2C68\u2C69\u2C6A\u2C6B\u2C6C\u2C6D\u2C6E\u2C6F\u2C71\u2C72\u2C73\u2C74\u2C75\u2C76\u2C77\u2C78\u2C79\u2C7A\u2C7B\u2C7C\u2C7D";
+/** Coptic letters. */
+export declare const REJECTED_COPTIC = "\u2C80\u2C81\u2C82\u2C83\u2C84\u2C85\u2C86\u2C87\u2C88\u2C89\u2C8A\u2C8B\u2C8C\u2C8D\u2C8E\u2C8F\u2C90\u2C91\u2C92\u2C93\u2C94\u2C95\u2C96\u2C97\u2C98\u2C99\u2C9A\u2C9B\u2C9C\u2C9D\u2C9E\u2C9F\u2CA0\u2CA1\u2CA2\u2CA3\u2CA4\u2CA5\u2CA6\u2CA7\u2CA8\u2CA9\u2CAA\u2CAB\u2CAC\u2CAD\u2CAE\u2CAF\u2CB0\u2CB1\u2CB2\u2CB3\u2CB4\u2CB5\u2CB6\u2CB7\u2CB8\u2CB9\u2CBA\u2CBB\u2CBC\u2CBD\u2CBE\u2CBF\u2CC0\u2CC1\u2CC2\u2CC3\u2CC4\u2CC5\u2CC6\u2CC7\u2CC8\u2CC9\u2CCA\u2CCB\u2CCC\u2CCD\u2CCE\u2CCF\u2CD0\u2CD1\u2CD2\u2CD3\u2CD4\u2CD5\u2CD6\u2CD7\u2CD8\u2CD9\u2CDA\u2CDB\u2CDC\u2CDD\u2CDE\u2CDF\u2CE0\u2CE1\u2CE2\u2CE3\u2CE4";
+/** Georgian Supplement, Tifinagh and Ethiopic Extended letters. */
+export declare const REJECTED_GEORGIAN = "\u2D00\u2D01\u2D02\u2D03\u2D04\u2D05\u2D06\u2D07\u2D08\u2D09\u2D0A\u2D0B\u2D0C\u2D0D\u2D0E\u2D0F\u2D10\u2D11\u2D12\u2D13\u2D14\u2D15\u2D16\u2D17\u2D18\u2D19\u2D1A\u2D1B\u2D1C\u2D1D\u2D1E\u2D1F\u2D20\u2D21\u2D22\u2D23\u2D24\u2D25\u2D30\u2D31\u2D32\u2D33\u2D34\u2D35\u2D36\u2D37\u2D38\u2D39\u2D3A\u2D3B\u2D3C\u2D3D\u2D3E\u2D3F\u2D40\u2D41\u2D42\u2D43\u2D44\u2D45\u2D46\u2D47\u2D48\u2D49\u2D4A\u2D4B\u2D4C\u2D4D\u2D4E\u2D4F\u2D50\u2D51\u2D52\u2D53\u2D54\u2D55\u2D56\u2D57\u2D58\u2D59\u2D5A\u2D5B\u2D5C\u2D5D\u2D5E\u2D5F\u2D60\u2D61\u2D62\u2D63\u2D64\u2D65\u2D6F\u2D80\u2D81\u2D82\u2D83\u2D84\u2D85\u2D86\u2D87\u2D88\u2D89\u2D8A\u2D8B\u2D8C\u2D8D\u2D8E\u2D8F\u2D90\u2D91\u2D92\u2D93\u2D94\u2D95\u2D96\u2DA0\u2DA1\u2DA2\u2DA3\u2DA4\u2DA5\u2DA6\u2DA8\u2DA9\u2DAA\u2DAB\u2DAC\u2DAD\u2DAE\u2DB0\u2DB1\u2DB2\u2DB3\u2DB4\u2DB5\u2DB6\u2DB8\u2DB9\u2DBA\u2DBB\u2DBC\u2DBD\u2DBE\u2DC0\u2DC1\u2DC2\u2DC3\u2DC4\u2DC5\u2DC6\u2DC8\u2DC9\u2DCA\u2DCB\u2DCC\u2DCD\u2DCE\u2DD0\u2DD1\u2DD2\u2DD3\u2DD4\u2DD5\u2DD6\u2DD8\u2DD9\u2DDA\u2DDB\u2DDC\u2DDD\u2DDE";
+/** The private-use characters U+E800 to U+E8FF. */
+export declare const REJECTED_PRIVATE = "\uE800\uE801\uE802\uE803\uE804\uE805\uE806\uE807\uE808\uE809\uE80A\uE80B\uE80C\uE80D\uE80E\uE80F\uE810\uE811\uE812\uE813\uE814\uE815\uE816\uE817\uE818\uE819\uE81A\uE81B\uE81C\uE81D\uE81E\uE81F\uE820\uE821\uE822\uE823\uE824\uE825\uE826\uE827\uE828\uE829\uE82A\uE82B\uE82C\uE82D\uE82E\uE82F\uE830\uE831\uE832\uE833\uE834\uE835\uE836\uE837\uE838\uE839\uE83A\uE83B\uE83C\uE83D\uE83E\uE83F\uE840\uE841\uE842\uE843\uE844\uE845\uE846\uE847\uE848\uE849\uE84A\uE84B\uE84C\uE84D\uE84E\uE84F\uE850\uE851\uE852\uE853\uE854\uE855\uE856\uE857\uE858\uE859\uE85A\uE85B\uE85C\uE85D\uE85E\uE85F\uE860\uE861\uE862\uE863\uE864\uE865\uE866\uE867\uE868\uE869\uE86A\uE86B\uE86C\uE86D\uE86E\uE86F\uE870\uE871\uE872\uE873\uE874\uE875\uE876\uE877\uE878\uE879\uE87A\uE87B\uE87C\uE87D\uE87E\uE87F\uE880\uE881\uE882\uE883\uE884\uE885\uE886\uE887\uE888\uE889\uE88A\uE88B\uE88C\uE88D\uE88E\uE88F\uE890\uE891\uE892\uE893\uE894\uE895\uE896\uE897\uE898\uE899\uE89A\uE89B\uE89C\uE89D\uE89E\uE89F\uE8A0\uE8A1\uE8A2\uE8A3\uE8A4\uE8A5\uE8A6\uE8A7\uE8A8\uE8A9\uE8AA\uE8AB\uE8AC\uE8AD\uE8AE\uE8AF\uE8B0\uE8B1\uE8B2\uE8B3\uE8B4\uE8B5\uE8B6\uE8B7\uE8B8\uE8B9\uE8BA\uE8BB\uE8BC\uE8BD\uE8BE\uE8BF\uE8C0\uE8C1\uE8C2\uE8C3\uE8C4\uE8C5\uE8C6\uE8C7\uE8C8\uE8C9\uE8CA\uE8CB\uE8CC\uE8CD\uE8CE\uE8CF\uE8D0\uE8D1\uE8D2\uE8D3\uE8D4\uE8D5\uE8D6\uE8D7\uE8D8\uE8D9\uE8DA\uE8DB\uE8DC\uE8DD\uE8DE\uE8DF\uE8E0\uE8E1\uE8E2\uE8E3\uE8E4\uE8E5\uE8E6\uE8E7\uE8E8\uE8E9\uE8EA\uE8EB\uE8EC\uE8ED\uE8EE\uE8EF\uE8F0\uE8F1\uE8F2\uE8F3\uE8F4\uE8F5\uE8F6\uE8F7\uE8F8\uE8F9\uE8FA\uE8FB\uE8FC\uE8FD\uE8FE\uE8FF";
+/**
+ * Finds the first character of a layer name that AutoCAD rejects, beyond the
+ * ASCII punctuation and control characters that `layerNameProblem` checks.
+ *
+ * @param name - The layer name.
+ * @returns The character, or undefined when the name has none.
+ */
+export declare function rejectedNameCharacter(name: string): string | undefined;
+/**
+ * The form of a layer name that AutoCAD looks layers up by. Two names with the
+ * same key are one layer to AutoCAD: an entity on `wall` goes on a layer
+ * declared as `WALL`, and AutoCAD keeps only the first of two such layers.
+ *
+ * AutoCAD lower-cases one character at a time from its own table, so this is
+ * not `toLowerCase()`: a final sigma ς, a dotless ı and ß stay as they are.
+ *
+ * @param name - The layer name.
+ * @returns The key to compare layer names by.
+ */
+export declare function layerKey(name: string): string;
+/**
+ * The form of a layer name that AutoCAD's AUDIT compares when it looks for
+ * duplicate names. AUDIT takes a few more letters for the same than the layer
+ * table does, so two layers can have different `layerKey`s and still be an
+ * AUDIT error.
+ *
+ * This covers the single letters AUDIT adds, and not everything it reports:
+ * it also calls `straße` and `strasse`, `æ` and `ae`, and a composed é and its
+ * decomposed form duplicates, which this key keeps apart.
+ *
+ * @param name - The layer name.
+ * @returns The key to find AUDIT's duplicate names by.
+ */
+export declare function layerAuditKey(name: string): string;
+/**
+ * Orders layers for a DXF layer table. AutoCAD's AUDIT reports "Layer zero name
+ * found at incorrect index" when layer `0` is not the first record.
+ *
+ * @param layers - The drawing's layers, in any order.
+ * @returns The layers with `0` first and the others in their given order.
+ */
+export declare function layerZeroFirst(layers: readonly Layer[]): readonly Layer[];