tsdraft 0.0.0-stage → 0.2.0

package/dist/dxf-r2018.js

@@ -0,0 +1,333 @@
+import { extents } from "./extents.js";
+import { dxfText, fmt } from "./format.js";
+/** `$INSUNITS` codes from the DXF Reference. */
+const INSUNITS = { in: 1, ft: 2, mm: 4, cm: 5, m: 6 };
+/**
+ * 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 function toDXFR2018(drawing) {
+    let seed = 1;
+    const handle = () => (seed++).toString(16).toUpperCase();
+    const body = [];
+    const g = groupWriter(body);
+    const rootDictionary = handle();
+    const groupDictionary = handle();
+    const plotStyleDictionary = handle();
+    const normalPlotStyle = handle();
+    const modelSpace = handle();
+    const paperSpace = handle();
+    const [minX, minY, maxX, maxY] = extents(drawing.entities);
+    g(0, "SECTION");
+    g(2, "CLASSES");
+    g(0, "ENDSEC");
+    g(0, "SECTION");
+    g(2, "TABLES");
+    writeTable(g, handle, "VPORT", [
+        {
+            type: "VPORT",
+            subclass: "AcDbViewportTableRecord",
+            name: "*Active",
+            handle: handle(),
+            fields: (g) => writeActiveViewport(g, minX, minY, maxX, maxY),
+        },
+    ]);
+    writeTable(g, handle, "LTYPE", [
+        ["ByBlock", ""],
+        ["ByLayer", ""],
+        ["Continuous", "Solid line"],
+    ].map(([name = "", description = ""]) => ({
+        type: "LTYPE",
+        subclass: "AcDbLinetypeTableRecord",
+        name,
+        handle: handle(),
+        fields: (g) => {
+            g(3, description);
+            g(72, 65);
+            g(73, 0);
+            g(40, 0);
+        },
+    })));
+    writeTable(g, handle, "LAYER", drawing.layers.map((layer) => ({
+        type: "LAYER",
+        subclass: "AcDbLayerTableRecord",
+        name: layer.name,
+        handle: handle(),
+        fields: (g) => {
+            g(62, layer.color);
+            g(6, "Continuous");
+            g(370, -3); // lineweight: default
+            g(390, normalPlotStyle); // AutoCAD rejects a layer without a plot style
+        },
+    })));
+    writeTable(g, handle, "STYLE", [
+        {
+            type: "STYLE",
+            subclass: "AcDbTextStyleTableRecord",
+            name: "Standard",
+            handle: handle(),
+            fields: (g) => {
+                g(40, 0); // fixed height: none
+                g(41, 1); // width factor
+                g(50, 0); // oblique angle
+                g(71, 0); // generation flags
+                g(42, 0.2); // last height used
+                g(3, "txt");
+                g(4, "");
+            },
+        },
+    ]);
+    writeTable(g, handle, "VIEW", []);
+    writeTable(g, handle, "UCS", []);
+    writeTable(g, handle, "APPID", [
+        { type: "APPID", subclass: "AcDbRegAppTableRecord", name: "ACAD", handle: handle() },
+    ]);
+    writeTable(g, handle, "DIMSTYLE", [
+        { type: "DIMSTYLE", subclass: "AcDbDimStyleTableRecord", name: "Standard", handle: handle() },
+    ]);
+    const blockRecordFields = (g) => {
+        g(280, 1); // explodable
+        g(281, 0); // scale uniformly: no
+    };
+    writeTable(g, handle, "BLOCK_RECORD", [
+        {
+            type: "BLOCK_RECORD",
+            subclass: "AcDbBlockTableRecord",
+            name: "*Model_Space",
+            handle: modelSpace,
+            fields: blockRecordFields,
+        },
+        {
+            type: "BLOCK_RECORD",
+            subclass: "AcDbBlockTableRecord",
+            name: "*Paper_Space",
+            handle: paperSpace,
+            fields: blockRecordFields,
+        },
+    ]);
+    g(0, "ENDSEC");
+    g(0, "SECTION");
+    g(2, "BLOCKS");
+    writeBlock(g, handle, "*Model_Space", modelSpace, false);
+    writeBlock(g, handle, "*Paper_Space", paperSpace, true);
+    g(0, "ENDSEC");
+    g(0, "SECTION");
+    g(2, "ENTITIES");
+    for (const entity of drawing.entities)
+        writeEntity(g, entity, handle(), modelSpace);
+    g(0, "ENDSEC");
+    g(0, "SECTION");
+    g(2, "OBJECTS");
+    g(0, "DICTIONARY");
+    g(5, rootDictionary);
+    g(330, "0");
+    g(100, "AcDbDictionary");
+    g(281, 1); // duplicate records: keep existing
+    g(3, "ACAD_GROUP");
+    g(350, groupDictionary);
+    g(3, "ACAD_PLOTSTYLENAME");
+    g(350, plotStyleDictionary);
+    g(0, "DICTIONARY");
+    ownedBy(g, groupDictionary, rootDictionary);
+    g(100, "AcDbDictionary");
+    g(281, 1);
+    // Plot style names: a dictionary with a default, holding the "Normal" placeholder.
+    g(0, "ACDBDICTIONARYWDFLT");
+    ownedBy(g, plotStyleDictionary, rootDictionary);
+    g(100, "AcDbDictionary");
+    g(281, 1);
+    g(3, "Normal");
+    g(350, normalPlotStyle);
+    g(100, "AcDbDictionaryWithDefault");
+    g(340, normalPlotStyle);
+    g(0, "ACDBPLACEHOLDER");
+    ownedBy(g, normalPlotStyle, plotStyleDictionary);
+    g(0, "ENDSEC");
+    g(0, "EOF");
+    // The header goes first in the file but is written last, once every handle is assigned.
+    const header = [];
+    const h = groupWriter(header);
+    h(0, "SECTION");
+    h(2, "HEADER");
+    h(9, "$ACADVER");
+    h(1, "AC1032");
+    h(9, "$DWGCODEPAGE");
+    h(3, "ANSI_1252");
+    h(9, "$INSBASE");
+    point(h, 10, 0, 0);
+    h(9, "$EXTMIN");
+    point(h, 10, minX, minY);
+    h(9, "$EXTMAX");
+    point(h, 10, maxX, maxY);
+    h(9, "$INSUNITS");
+    h(70, INSUNITS[drawing.units]);
+    h(9, "$MEASUREMENT");
+    h(70, drawing.units === "in" || drawing.units === "ft" ? 0 : 1);
+    h(9, "$CLAYER");
+    h(8, "0");
+    h(9, "$HANDSEED");
+    h(5, handle());
+    h(0, "ENDSEC");
+    return [...header, ...body].join("\r\n") + "\r\n";
+}
+function groupWriter(out) {
+    return (code, value) => {
+        out.push(String(code), typeof value === "number" ? fmt(value) : value);
+    };
+}
+/** Handle, reactor and owner fields for an object owned by a dictionary. */
+function ownedBy(g, handle, owner) {
+    g(5, handle);
+    g(102, "{ACAD_REACTORS");
+    g(330, owner);
+    g(102, "}");
+    g(330, owner);
+}
+function point(g, code, x, y) {
+    g(code, x);
+    g(code + 10, y);
+    g(code + 20, 0);
+}
+function writeTable(g, handle, name, records) {
+    const table = handle();
+    g(0, "TABLE");
+    g(2, name);
+    g(5, table);
+    g(330, "0");
+    g(100, "AcDbSymbolTable");
+    g(70, records.length);
+    if (name === "DIMSTYLE") {
+        g(100, "AcDbDimStyleTable");
+        g(71, records.length);
+        for (const r of records)
+            g(340, r.handle);
+    }
+    for (const r of records) {
+        g(0, r.type);
+        // DIMSTYLE records use 105 for their handle, because 5 is DIMBLK's code there.
+        g(r.type === "DIMSTYLE" ? 105 : 5, r.handle);
+        g(330, table);
+        g(100, "AcDbSymbolTableRecord");
+        g(100, r.subclass);
+        g(2, r.name);
+        g(70, 0);
+        r.fields?.(g);
+    }
+    g(0, "ENDTAB");
+}
+/** 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;
+    g(10, 0); // lower-left corner of the viewport on screen
+    g(20, 0);
+    g(11, 1); // upper-right corner
+    g(21, 1);
+    g(12, (minX + maxX) / 2); // view center
+    g(22, (minY + maxY) / 2);
+    g(13, 0); // snap base
+    g(23, 0);
+    g(14, 0.5); // snap spacing
+    g(24, 0.5);
+    g(15, 0.5); // grid spacing
+    g(25, 0.5);
+    g(16, 0); // view direction
+    g(26, 0);
+    g(36, 1);
+    g(17, 0); // view target
+    g(27, 0);
+    g(37, 0);
+    g(40, height);
+    g(41, aspect);
+    g(42, 50); // lens length
+    g(43, 0); // front clip
+    g(44, 0); // back clip
+    g(50, 0); // snap rotation
+    g(51, 0); // view twist
+    g(71, 0); // view mode
+    g(72, 1000); // circle zoom percent
+    g(73, 1); // fast zoom
+    g(74, 3); // UCS icon
+    g(75, 0); // snap off
+    g(76, 0); // grid off
+    g(77, 0); // snap style
+    g(78, 0); // snap isopair
+}
+function writeBlock(g, handle, name, owner, paper) {
+    g(0, "BLOCK");
+    g(5, handle());
+    g(330, owner);
+    g(100, "AcDbEntity");
+    if (paper)
+        g(67, 1);
+    g(8, "0");
+    g(100, "AcDbBlockBegin");
+    g(2, name);
+    g(70, 0);
+    point(g, 10, 0, 0);
+    g(3, name);
+    g(1, "");
+    g(0, "ENDBLK");
+    g(5, handle());
+    g(330, owner);
+    g(100, "AcDbEntity");
+    if (paper)
+        g(67, 1);
+    g(8, "0");
+    g(100, "AcDbBlockEnd");
+}
+function writeEntity(g, e, handle, owner) {
+    const begin = (type, subclass) => {
+        g(0, type);
+        g(5, handle);
+        g(330, owner);
+        g(100, "AcDbEntity");
+        g(8, e.layer);
+        g(100, subclass);
+    };
+    switch (e.kind) {
+        case "line":
+            begin("LINE", "AcDbLine");
+            point(g, 10, ...e.from);
+            point(g, 11, ...e.to);
+            return;
+        case "polyline":
+            begin("LWPOLYLINE", "AcDbPolyline");
+            g(90, e.points.length);
+            g(70, e.closed ? 1 : 0);
+            g(43, 0); // constant width
+            for (const [x, y] of e.points) {
+                g(10, x);
+                g(20, y);
+            }
+            return;
+        case "circle":
+            begin("CIRCLE", "AcDbCircle");
+            point(g, 10, ...e.center);
+            g(40, e.radius);
+            return;
+        case "arc":
+            begin("ARC", "AcDbCircle");
+            point(g, 10, ...e.center);
+            g(40, e.radius);
+            g(100, "AcDbArc");
+            g(50, e.startAngle);
+            g(51, e.endAngle);
+            return;
+        case "text":
+            begin("TEXT", "AcDbText");
+            point(g, 10, ...e.at);
+            g(40, e.height);
+            g(1, dxfText(e.value));
+            if (e.rotation !== 0)
+                g(50, e.rotation);
+            g(7, "Standard");
+            // TEXT repeats its subclass marker before the vertical alignment fields.
+            g(100, "AcDbText");
+            return;
+    }
+}

package/dist/dxf.d.ts

@@ -0,0 +1,11 @@
+import type { Drawing, DxfVersion } from "./drawing.ts";
+export interface DxfOptions {
+    /** Defaults to the version the drawing was created for, which is `"R12"` unless set. */
+    readonly version?: DxfVersion;
+}
+/**
+ * Writes the drawing as ASCII DXF. Throws a `DrawingError` listing every lint
+ * error when the drawing breaks a rule of the version being written, because
+ * AutoCAD would reject or garble the file.
+ */
+export declare function toDXF(drawing: Drawing, options?: DxfOptions): string;

package/dist/dxf.js

@@ -0,0 +1,18 @@
+import { toDXFR12 } from "./dxf-r12.js";
+import { toDXFR2018 } from "./dxf-r2018.js";
+import { DrawingError, lint } from "./lint.js";
+/**
+ * Writes the drawing as ASCII DXF. Throws a `DrawingError` listing every lint
+ * error when the drawing breaks a rule of the version being written, because
+ * AutoCAD would reject or garble the file.
+ */
+export function toDXF(drawing, options = {}) {
+    const version = options.version ?? drawing.dxf;
+    if (version !== "R12" && version !== "R2018") {
+        throw new Error(`Unsupported DXF version: ${JSON.stringify(version)}`);
+    }
+    const errors = lint(drawing, { version }).filter((d) => d.severity === "error");
+    if (errors.length > 0)
+        throw new DrawingError(errors);
+    return version === "R12" ? toDXFR12(drawing) : toDXFR2018(drawing);
+}

package/dist/extents.d.ts

@@ -0,0 +1,3 @@
+import type { Entity } from "./drawing.ts";
+/** Approximate extents. Arcs use their full circle; text assumes 0.6 × height per character. */
+export declare function extents(entities: readonly Entity[]): [number, number, number, number];

package/dist/extents.js

@@ -0,0 +1,42 @@
+/** Approximate extents. Arcs use their full circle; text assumes 0.6 × height per character. */
+export function extents(entities) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    const add = (x, y) => {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+    };
+    for (const e of entities) {
+        switch (e.kind) {
+            case "line":
+                add(...e.from);
+                add(...e.to);
+                break;
+            case "polyline":
+                for (const p of e.points)
+                    add(...p);
+                break;
+            case "circle":
+            case "arc":
+                add(e.center[0] - e.radius, e.center[1] - e.radius);
+                add(e.center[0] + e.radius, e.center[1] + e.radius);
+                break;
+            case "text": {
+                const len = e.value.length * e.height * 0.6;
+                const r = rad(e.rotation);
+                add(...e.at);
+                add(e.at[0] + len * Math.cos(r), e.at[1] + len * Math.sin(r));
+                add(e.at[0] - e.height * Math.sin(r), e.at[1] + e.height * Math.cos(r));
+                break;
+            }
+        }
+    }
+    return minX === Infinity ? [0, 0, 1, 1] : [minX, minY, maxX, maxY];
+}
+function rad(degrees) {
+    return (degrees * Math.PI) / 180;
+}

package/dist/format.d.ts

@@ -0,0 +1,11 @@
+/** 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.
+ *
+ * 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 declare function dxfText(value: string, ascii?: boolean): string;

package/dist/format.js

@@ -0,0 +1,24 @@
+/** 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);
+}
+/**
+ * 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.
+ *
+ * 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("^", "^ ");
+    if (!ascii)
+        return escaped;
+    let out = "";
+    for (let i = 0; i < escaped.length; i++) {
+        const code = escaped.charCodeAt(i);
+        out += code < 0x80 ? escaped[i] : `\\U+${code.toString(16).toUpperCase().padStart(4, "0")}`;
+    }
+    return out;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+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 { toDXF, type DxfOptions } from "./dxf.ts";
+export { DrawingError, lint, type Diagnostic, type LintOptions, type LintRule } from "./lint.ts";
+export type { Aci, LayerColor, LayerName, Positive } from "./rules.ts";
+export { toSVG, type SvgOptions } from "./svg.ts";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { createDrawing, DrawingBuilder, sweep, } from "./drawing.js";
+export { toDXF } from "./dxf.js";
+export { DrawingError, lint } from "./lint.js";
+export { toSVG } from "./svg.js";

package/dist/lint.d.ts

@@ -0,0 +1,30 @@
+import type { Drawing, DxfVersion } from "./drawing.ts";
+export type LintRule = "units" | "layer-name" | "duplicate-layer" | "layer-color" | "undefined-layer" | "geometry" | "text" | "zero-length";
+export interface Diagnostic {
+    readonly rule: LintRule;
+    /** An error means AutoCAD rejects, repairs or garbles the output. `toDXF` refuses to write it. */
+    readonly severity: "error" | "warning";
+    readonly message: string;
+    /** The layer the problem is in, when it is a layer problem. */
+    readonly layer?: string;
+    /** Index into `drawing.entities`, when it is an entity problem. */
+    readonly entity?: number;
+}
+export interface LintOptions {
+    /** The DXF version to check against. Defaults to the drawing's own. */
+    readonly version?: DxfVersion;
+}
+/**
+ * Checks a drawing against the rules AutoCAD enforces when it opens DXF.
+ *
+ * A drawing made with `createDrawing()` already passes the error rules for its
+ * own DXF version, because the builder throws at the offending call. `lint`
+ * matters when a `Drawing` was built by hand or by other code, when it is
+ * exported as a different version than it was built for, and for warnings.
+ */
+export declare function lint(drawing: Drawing, options?: LintOptions): Diagnostic[];
+/** Thrown by `toDXF` when a drawing has lint errors for the version being written. */
+export declare class DrawingError extends Error {
+    readonly diagnostics: readonly Diagnostic[];
+    constructor(diagnostics: readonly Diagnostic[]);
+}

package/dist/lint.js

@@ -0,0 +1,109 @@
+import { layerColorProblem, layerNameProblem, textProblem } from "./rules.js";
+/**
+ * Checks a drawing against the rules AutoCAD enforces when it opens DXF.
+ *
+ * A drawing made with `createDrawing()` already passes the error rules for its
+ * own DXF version, because the builder throws at the offending call. `lint`
+ * matters when a `Drawing` was built by hand or by other code, when it is
+ * exported as a different version than it was built for, and for warnings.
+ */
+export function lint(drawing, options = {}) {
+    const version = options.version ?? drawing.dxf;
+    const out = [];
+    if (!["in", "ft", "mm", "cm", "m"].includes(drawing.units)) {
+        out.push({
+            rule: "units",
+            severity: "error",
+            message: `Unknown units: ${JSON.stringify(drawing.units)}`,
+        });
+    }
+    const seen = new Set();
+    for (const layer of drawing.layers) {
+        const error = (rule, message) => out.push({ rule, severity: "error", message, layer: layer.name });
+        const nameProblem = layerNameProblem(layer.name, version);
+        if (nameProblem)
+            error("layer-name", `Layer ${JSON.stringify(layer.name)}: ${nameProblem}`);
+        const colorProblem = layerColorProblem(layer.color);
+        if (colorProblem)
+            error("layer-color", `Layer ${JSON.stringify(layer.name)}: ${colorProblem}`);
+        const key = layer.name.toLowerCase();
+        if (seen.has(key)) {
+            error("duplicate-layer", `Layer ${JSON.stringify(layer.name)} is defined twice. CAD ignores case in layer names`);
+        }
+        seen.add(key);
+    }
+    if (!seen.has("0")) {
+        out.push({ rule: "undefined-layer", severity: "error", message: 'Layer "0" is missing' });
+    }
+    drawing.entities.forEach((entity, index) => {
+        const add = (rule, severity, problem) => out.push({ rule, severity, message: `${entity.kind} #${index}: ${problem}`, entity: index });
+        if (!seen.has(entity.layer.toLowerCase())) {
+            add("undefined-layer", "error", `layer ${JSON.stringify(entity.layer)} is not defined`);
+        }
+        for (const problem of geometryProblems(entity))
+            add("geometry", "error", problem);
+        if (entity.kind === "text") {
+            const problem = textProblem(entity.value);
+            if (problem)
+                add("text", "error", problem);
+        }
+        if (entity.kind === "line" && same(entity.from, entity.to)) {
+            add("zero-length", "warning", "the line has no length");
+        }
+    });
+    return out;
+}
+/** Thrown by `toDXF` when a drawing has lint errors for the version being written. */
+export class DrawingError extends Error {
+    diagnostics;
+    constructor(diagnostics) {
+        const shown = diagnostics.slice(0, 10).map((d) => `- ${d.message}`);
+        const more = diagnostics.length > 10 ? [`- and ${diagnostics.length - 10} more`] : [];
+        super(["The drawing cannot be written as DXF:", ...shown, ...more].join("\n"));
+        this.name = "DrawingError";
+        this.diagnostics = diagnostics;
+    }
+}
+function geometryProblems(e) {
+    const out = [];
+    const finite = (label, ...values) => {
+        if (!values.every(Number.isFinite))
+            out.push(`${label} must be finite numbers`);
+    };
+    const positive = (label, value) => {
+        if (!(Number.isFinite(value) && value > 0))
+            out.push(`${label} must be greater than 0`);
+    };
+    switch (e.kind) {
+        case "line":
+            finite("its points", ...e.from, ...e.to);
+            break;
+        case "polyline":
+            if (e.points.length < 2)
+                out.push("a polyline needs at least 2 points");
+            finite("its points", ...e.points.flat());
+            break;
+        case "circle":
+            finite("its center", ...e.center);
+            positive("its radius", e.radius);
+            break;
+        case "arc":
+            finite("its center", ...e.center);
+            positive("its radius", e.radius);
+            if (![e.startAngle, e.endAngle].every((a) => Number.isFinite(a) && a >= 0 && a < 360)) {
+                out.push("its angles must be from 0 up to 360");
+            }
+            else if (e.startAngle === e.endAngle) {
+                out.push("its start and end angles must differ");
+            }
+            break;
+        case "text":
+            finite("its position and rotation", ...e.at, e.rotation);
+            positive("its height", e.height);
+            break;
+    }
+    return out;
+}
+function same(a, b) {
+    return a[0] === b[0] && a[1] === b[1];
+}

package/dist/rules.d.ts

@@ -0,0 +1,33 @@
+import type { DxfVersion } from "./drawing.ts";
+declare const NAME_EMPTY = "Layer names cannot be empty";
+declare const NAME_CHARS = "Layer names cannot contain < > / \\ \" : ; ? * | = ` ^ , or line breaks";
+declare const NAME_EDGE = "Layer names cannot start or end with a space";
+declare const NAME_R12_CHARS = "R12 layer names can only use letters, digits, $, - and _. Use DXF version \"R2018\" for other characters";
+declare const NAME_R12_LENGTH = "R12 layer names cannot be longer than 31 characters. Use DXF version \"R2018\" for longer names";
+declare const COLOR = "A layer color must be an AutoCAD Color Index integer from 1 to 255";
+declare const POSITIVE = "This value must be greater than 0";
+type ForbiddenChar = "<" | ">" | "/" | "\\" | '"' | ":" | ";" | "?" | "*" | "|" | "=" | "`" | "^" | "," | "\n" | "\r" | "\t";
+type Chars<S extends string, Found = never> = S extends `${infer C}${infer Rest}` ? Chars<Rest, Found | C> : Found;
+type R12Char = Chars<"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789$_-">;
+/** Walks the name one character at a time, counting, so it can check both the characters and the length. */
+type R12Name<N extends string, Rest extends string = N, Count extends 0[] = []> = Count["length"] extends 32 ? typeof NAME_R12_LENGTH : Rest extends `${infer C}${infer Tail}` ? C extends R12Char ? R12Name<N, Tail, [...Count, 0]> : typeof NAME_R12_CHARS : N;
+/**
+ * Resolves to `N` when it is a valid layer name for DXF version `V`, and to the
+ * error message otherwise, so the compiler reports the reason. Names that are
+ * not literals pass the compiler and are checked when the code runs.
+ */
+export type LayerName<N extends string, V extends DxfVersion> = string extends N ? N : N extends "" ? typeof NAME_EMPTY : N extends `${string}${ForbiddenChar}${string}` ? typeof NAME_CHARS : N extends ` ${string}` | `${string} ` ? typeof NAME_EDGE : V extends "R12" ? R12Name<N> : N;
+type Enumerate<N extends number, A extends number[] = []> = A["length"] extends N ? A[number] : Enumerate<N, [...A, A["length"]]>;
+/** AutoCAD Color Index: an integer from 1 to 255. */
+export type Aci = Exclude<Enumerate<256>, 0>;
+/** Resolves to `C` when it is a valid layer color, and to the error message otherwise. */
+export type LayerColor<C extends number> = number extends C ? C : C extends Aci ? C : typeof COLOR;
+/** Resolves to `N` when it is greater than 0, and to the error message otherwise. */
+export type Positive<N extends number> = number extends N ? N : `${N}` extends `-${string}` | "0" ? typeof POSITIVE : N;
+/** Returns what is wrong with a layer name for a DXF version, or undefined when it is valid. */
+export declare function layerNameProblem(name: string, version: DxfVersion): string | undefined;
+/** Returns what is wrong with a layer color, or undefined when it is valid. */
+export declare function layerColorProblem(color: number): string | undefined;
+/** Returns what is wrong with a single-line text value, or undefined when it is valid. */
+export declare function textProblem(value: string): string | undefined;
+export {};