tsdraft 0.2.2 → 0.4.0

package/dist/paper.d.ts

@@ -0,0 +1,33 @@
+import type { Units } from "./drawing.ts";
+import { type PaperLength, type Ratio } from "./rules.ts";
+/** A unit paper lengths are given in. */
+export type PaperUnit = "in" | "mm";
+/** The view a paper length is converted for. */
+export interface PaperScale<R extends number = number> {
+    /**
+     * How many times larger the model is than its plot, as a plain number: 96
+     * for 1/8" = 1'-0", 240 for 1" = 20', 50 for 1:50.
+     */
+    readonly ratio: Ratio<R>;
+    /** The drawing's units, as given to `createDrawing`. */
+    readonly units: Units;
+}
+/**
+ * Turns a length on paper into drawing units, for text, symbols and dashes
+ * that are sized by how large they plot. A 3/32 inch note on a sheet at
+ * 1/8" = 1'-0" is 9 inches in the model, which is 0.75 in a drawing in feet:
+ *
+ * ```ts
+ * fromPaper(3 / 32, "in", { ratio: 96, units: "ft" }); // 0.75
+ * ```
+ *
+ * A length or a ratio of 0 or less is a compile error when it is a literal.
+ *
+ * @param length - The length as it plots, greater than 0.
+ * @param unit - The unit of `length`: `"in"` or `"mm"`.
+ * @param view - The ratio the length plots at, and the drawing's units.
+ * @returns The length in drawing units.
+ * @throws When an argument is not one of the above, or when the result would
+ * be written as 0 at the 6 decimals tsdraft writes, or is 1e100 or more.
+ */
+export declare function fromPaper<L extends number, R extends number>(length: PaperLength<L>, unit: PaperUnit, view: PaperScale<R>): number;

package/dist/paper.js

@@ -0,0 +1,58 @@
+import { paperLengthProblem } from "./rules.js";
+/** Inches in one of each imperial unit, and millimetres in one of each metric unit. */
+const SIZES = {
+    in: ["imperial", 1],
+    ft: ["imperial", 12],
+    mm: ["metric", 1],
+    cm: ["metric", 10],
+    m: ["metric", 1000],
+};
+const MM_PER_INCH = 25.4;
+/**
+ * Turns a length on paper into drawing units, for text, symbols and dashes
+ * that are sized by how large they plot. A 3/32 inch note on a sheet at
+ * 1/8" = 1'-0" is 9 inches in the model, which is 0.75 in a drawing in feet:
+ *
+ * ```ts
+ * fromPaper(3 / 32, "in", { ratio: 96, units: "ft" }); // 0.75
+ * ```
+ *
+ * A length or a ratio of 0 or less is a compile error when it is a literal.
+ *
+ * @param length - The length as it plots, greater than 0.
+ * @param unit - The unit of `length`: `"in"` or `"mm"`.
+ * @param view - The ratio the length plots at, and the drawing's units.
+ * @returns The length in drawing units.
+ * @throws When an argument is not one of the above, or when the result would
+ * be written as 0 at the 6 decimals tsdraft writes, or is 1e100 or more.
+ */
+export function fromPaper(length, unit, view) {
+    // The arguments are read as unknown, because a parameter that failed its type is a message.
+    const paper = length;
+    const { ratio, units } = view;
+    const from = unit === "in" || unit === "mm" ? SIZES[unit] : undefined;
+    const to = typeof units === "string" && Object.hasOwn(SIZES, units) ? SIZES[units] : undefined;
+    if (!from)
+        throw new Error(`The paper unit must be "in" or "mm", not ${JSON.stringify(unit)}`);
+    if (!to)
+        throw new Error(`Unknown units: ${JSON.stringify(units)}`);
+    if (typeof paper !== "number" || !Number.isFinite(paper)) {
+        throw new Error("The paper length must be a finite number");
+    }
+    if (typeof ratio !== "number" || !Number.isFinite(ratio)) {
+        throw new Error("The ratio must be a finite number");
+    }
+    // Multiplying before dividing keeps 3/32 in at 96 in feet at exactly 0.75.
+    const model = paper * ratio * from[1];
+    const sameSystem = from[0] === to[0];
+    const converted = sameSystem
+        ? model
+        : from[0] === "imperial"
+            ? model * MM_PER_INCH
+            : model / MM_PER_INCH;
+    const result = converted / to[1];
+    const problem = paperLengthProblem(paper, ratio, result);
+    if (problem)
+        throw new Error(problem);
+    return result;
+}

package/dist/rules.d.ts

@@ -1,27 +1,75 @@
 import type { DxfVersion } from "./drawing.ts";
+import { BUILT_IN_LINETYPES } from "./linetypes.ts";
 import { type REJECTED_COPTIC, type REJECTED_FORMAT, type REJECTED_GEORGIAN, type REJECTED_GLAGOLITIC, type REJECTED_LETTERLIKE, type REJECTED_PRIVATE } from "./layers.ts";
-declare const NAME_EMPTY = "Layer names cannot be empty";
-declare const NAME_CHARS = "Layer names cannot contain < > / \\ \" : ; ? * | = ` ^ , or line breaks";
-declare const NAME_REJECTED = "Layer names cannot contain a character AutoCAD rejects or replaces in names, such as a zero-width space or the ohm sign U+2126. The README lists them";
-declare const NAME_EDGE = "Layer names cannot start or end with a space";
+declare const LAYER_NAMES: {
+    readonly empty: "Layer names cannot be empty";
+    readonly chars: 'Layer names cannot contain < > / \\ " : ; ? * | = ` ^ , or line breaks';
+    readonly rejected: "Layer names cannot contain a character AutoCAD rejects or replaces in names, such as a zero-width space or the ohm sign U+2126. docs/layer-names.md in the tsdraft repository lists them";
+    readonly edge: "Layer names cannot start or end with a space";
+    readonly length: "Layer names cannot be longer than 255 characters";
+};
+declare const LINETYPE_NAMES: {
+    readonly empty: "Linetype names cannot be empty";
+    readonly chars: 'Linetype names cannot contain < > / \\ " : ; ? * | = ` ^ , or line breaks';
+    readonly rejected: "Linetype names cannot contain a character AutoCAD rejects or replaces in names, such as a zero-width space or the ohm sign U+2126. docs/layer-names.md in the tsdraft repository lists them";
+    readonly edge: "Linetype names cannot start or end with a space";
+    readonly length: "Linetype names cannot be longer than 255 characters";
+};
+type NameMessages = typeof LAYER_NAMES | typeof LINETYPE_NAMES;
 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";
 declare const WRITTEN_AS_ZERO = "This value is written as 0, because tsdraft writes 6 decimals. Use 0.000001 or more";
 declare const TOO_LARGE = "This value must be under 1e100, because AutoCAD reads only two exponent digits from DXF and would take 1e+100 for 1e+10";
+declare const PAPER_LENGTH = "The paper length must be greater than 0";
+declare const RATIO = "The ratio must be greater than 0";
+declare const TEXT_CONTROL = "Text must be a single line with no control characters";
+declare const TEXT_PRIVATE_USE = "Text cannot contain the private-use characters U+E800 to U+E8FF, because AutoCAD replaces them when it reads DXF";
+declare const R12_LINETYPES = "R12 drawings have no linetypes but Continuous, and no linetype scale. Use DXF version \"R2018\" for linetypes";
+declare const R12_LINEWEIGHTS = "R12 drawings have no lineweights. Use DXF version \"R2018\" for lineweights";
+declare const R12_ENTITY_STYLE = "R12 entities take no linetype or lineweight of their own. Use DXF version \"R2018\" for an entity linetype or lineweight";
+declare const R12_LAYER_STATES = "tsdraft writes no layer states to R12 drawings. Use DXF version \"R2018\" for layers that are off, frozen, locked or not plotted";
+declare const LINEWEIGHT = "A lineweight must be one of AutoCAD's, in millimetres: 0, 0.05, 0.09, 0.13, 0.15, 0.18, 0.2, 0.25, 0.3, 0.35, 0.4, 0.5, 0.53, 0.6, 0.7, 0.8, 0.9, 1, 1.06, 1.2, 1.4, 1.58, 2 or 2.11";
+declare const FROZEN_CURRENT = "Layer \"0\" cannot be frozen: it is the current layer, and AutoCAD does not freeze the current layer";
+declare const LAYER_LINETYPE = "A layer's linetype cannot be ByLayer or ByBlock. AutoCAD's AUDIT reports a layer with either";
+declare const BUILT_IN = "Continuous, ByLayer and ByBlock are in every drawing and cannot be defined. AutoCAD keeps its own and drops the definition";
+declare const PATTERN_COUNT = "A linetype pattern has 2 to 12 lengths, or none for a solid line. AutoCAD's AUDIT reports a pattern of one length, and AutoCAD discards a drawing with a pattern of more than 12";
+declare const PATTERN_WRITTEN_AS_ZERO = "A dash or gap of this length is written as 0, because tsdraft writes 6 decimals, and would draw as a dot. Use 0 for a dot, or a length of 0.000001 or more";
+declare const ID_EMPTY = "An id cannot be empty";
+declare const ID_CHARS = "An id can only use the letters A to Z and a to z, digits, ., - and _";
+declare const ID_LENGTH = "An id cannot be longer than 64 characters";
 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$_-">;
 type RejectedChar = Chars<typeof REJECTED_FORMAT> | Chars<typeof REJECTED_LETTERLIKE> | Chars<typeof REJECTED_GLAGOLITIC> | Chars<typeof REJECTED_COPTIC> | Chars<typeof REJECTED_GEORGIAN> | Chars<typeof REJECTED_PRIVATE>;
 /** 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 `Valid` when `N` passes the rules layer and linetype names share, and to the message otherwise. */
+type NameCheck<N extends string, M extends NameMessages, Valid> = N extends "" ? M["empty"] : N extends `${string}${ForbiddenChar}${string}` ? M["chars"] : N extends `${string}${RejectedChar}${string}` ? M["rejected"] : N extends ` ${string}` | `${string} ` ? M["edge"] : Valid;
 /**
  * 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}${RejectedChar}${string}` ? typeof NAME_REJECTED : N extends ` ${string}` | `${string} ` ? typeof NAME_EDGE : V extends "R12" ? R12Name<N> : N;
+export type LayerName<N extends string, V extends DxfVersion> = string extends N ? N : NameCheck<N, typeof LAYER_NAMES, V extends "R12" ? R12Name<N> : N>;
+/**
+ * Resolves to `N` when it is a valid name for a linetype to be used by, and to
+ * the error message otherwise. AutoCAD holds linetype names to the rules of
+ * layer names, apart from R12's, since R12 drawings have no linetypes.
+ */
+export type LinetypeName<N extends string> = string extends N ? N : NameCheck<N, typeof LINETYPE_NAMES, N>;
+type IdChar = Exclude<R12Char, "$"> | ".";
+/** Walks the id one character at a time, counting, as `R12Name` walks a layer name. */
+type IdCheck<I extends string, Rest extends string = I, Count extends 0[] = []> = Count["length"] extends 65 ? typeof ID_LENGTH : Rest extends `${infer C}${infer Tail}` ? C extends IdChar ? IdCheck<I, Tail, [...Count, 0]> : typeof ID_CHARS : I;
+/**
+ * Resolves to `I` when it is a valid entity id, and to the error message otherwise: 1 to 64
+ * characters, each a letter A to Z or a to z, a digit, `.`, `-` or `_`. An id that is not a
+ * literal, such as `` `door-${n}` ``, passes the compiler: the first branch takes every type
+ * that is not a union of literals. It is checked when the code runs, as is whether the drawing
+ * already has the id.
+ */
+export type EntityId<I extends string> = {} extends Record<I, never> ? I : I extends "" ? typeof ID_EMPTY : IdCheck<I>;
 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>;
@@ -42,8 +90,66 @@ type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
  * prints a third exponent digit as the writers do.
  */
 export type Positive<N extends number> = number extends N ? N : `${N}` extends `-${string}` | "0" ? typeof POSITIVE : WrittenAsZero<`${N}`> extends true ? typeof WRITTEN_AS_ZERO : `${N}` extends `${string}e+${Digit}${Digit}${Digit}` ? typeof TOO_LARGE : N;
+/**
+ * Resolves to `N` when it is greater than 0, and to `Message` otherwise. For a
+ * number that is worked with before anything is written, where `Positive`
+ * would refuse a small value for the 6 decimals.
+ */
+type AboveZero<N extends number, Message extends string> = number extends N ? N : `${N}` extends `-${string}` | "0" ? Message : N;
+/** Resolves to `N` when it is a length on paper, and to the error message otherwise. */
+export type PaperLength<N extends number> = AboveZero<N, typeof PAPER_LENGTH>;
+/** Resolves to `N` when it is a scale ratio, and to the error message otherwise. */
+export type Ratio<N extends number> = AboveZero<N, typeof RATIO>;
+type BuiltInName = Lowercase<(typeof BUILT_IN_LINETYPES)[number]>;
+/**
+ * Resolves to `N` when it is a valid name for a new linetype, and to the error
+ * message otherwise: a name that is valid to use, and not one of the linetypes
+ * every drawing has.
+ */
+export type NewLinetypeName<N extends string> = string extends N ? N : Lowercase<N> extends BuiltInName ? typeof BUILT_IN : LinetypeName<N>;
+/** Resolves to `N` when it is a valid linetype for a layer, and to the error message otherwise. */
+export type LayerLinetypeName<N extends string> = string extends N ? N : Lowercase<N> extends "bylayer" | "byblock" ? typeof LAYER_LINETYPE : LinetypeName<N>;
+type Unsigned<S extends string> = S extends `-${infer A}` ? A : S;
+/**
+ * The message for each literal pattern length the writers cannot keep: one
+ * written as 0 that is not 0, or one of 1e100 or more in size.
+ */
+type LengthProblem<N extends number> = N extends unknown ? number extends N ? never : Unsigned<`${N}`> extends "0" ? never : WrittenAsZero<Unsigned<`${N}`>> extends true ? typeof PATTERN_WRITTEN_AS_ZERO : Unsigned<`${N}`> extends `${string}e+${Digit}${Digit}${Digit}` ? typeof TOO_LARGE : never : never;
+/** The message for the first length of `P` with a problem, in the order `linetypeProblem` checks them. */
+type FirstLengthProblem<P extends readonly number[]> = P extends readonly [
+    infer N extends number,
+    ...infer Rest extends readonly number[]
+] ? [LengthProblem<N>] extends [never] ? FirstLengthProblem<Rest> : LengthProblem<N> : never;
+/**
+ * Resolves to `P` when it is a pattern AutoCAD accepts, and to the error
+ * message otherwise. A pattern that is not a tuple, and the total of the
+ * lengths, which the compiler cannot add, are checked when the code runs.
+ */
+export type Pattern<P extends readonly number[]> = number extends P["length"] ? P : P["length"] extends 0 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 ? [FirstLengthProblem<P>] extends [never] ? P : FirstLengthProblem<P> : typeof PATTERN_COUNT;
+type ControlChar = Chars<"\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009\u000a\u000b\u000c\u000d\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f\u007f">;
+/**
+ * Resolves to `D` when it is a linetype description AutoCAD keeps, and to the
+ * error message otherwise. Its length, and characters above U+FFFF, are checked
+ * when the code runs.
+ */
+export type Description<D extends string> = string extends D ? D : D extends `${string}${ControlChar}${string}` ? typeof TEXT_CONTROL : D extends `${string}${Chars<typeof REJECTED_PRIVATE>}${string}` ? typeof TEXT_PRIVATE_USE : D;
+/** A lineweight AutoCAD offers, in millimetres. */
+export type LineweightMm = 0 | 0.05 | 0.09 | 0.13 | 0.15 | 0.18 | 0.2 | 0.25 | 0.3 | 0.35 | 0.4 | 0.5 | 0.53 | 0.6 | 0.7 | 0.8 | 0.9 | 1 | 1.06 | 1.2 | 1.4 | 1.58 | 2 | 2.11;
+/** Resolves to `W` when it is one of AutoCAD's lineweights, and to the error message otherwise. */
+export type LineweightOf<W extends number> = number extends W ? W : W extends LineweightMm ? W : typeof LINEWEIGHT;
+/** The message for each feature an R12 drawing cannot have, as a type. */
+export type R12Linetypes = typeof R12_LINETYPES;
+export type R12Lineweights = typeof R12_LINEWEIGHTS;
+export type R12EntityStyle = typeof R12_ENTITY_STYLE;
+export type R12LayerStates = typeof R12_LAYER_STATES;
+export type FrozenCurrent = typeof FROZEN_CURRENT;
 /** 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 linetype name, or undefined when it is valid.
+ * The name may be one of the linetypes every drawing has.
+ */
+export declare function linetypeNameProblem(name: string): string | undefined;
 /**
  * Returns what is wrong with a drawing that has both names as layers, or
  * undefined when the two can stand together. AutoCAD looks layers up one way
@@ -51,15 +157,60 @@ export declare function layerNameProblem(name: string, version: DxfVersion): str
  * layers to AutoCAD and one duplicate name to AUDIT: `ΟΔΟΣ` and `οδος`,
  * `straße` and `strasse`, a composed é and a decomposed one, and a name with
  * and without a soft hyphen. `layerAuditKey` lists the kinds this covers,
- * which are those measured in AutoCAD and not all that AUDIT reports. Names
- * that are one layer to AutoCAD are not this function's concern. The rule
- * compares two names, so it has no type.
+ * which are not all that AUDIT reports. Names that are one layer to AutoCAD
+ * are not this function's concern. The rule compares two names, so it has no
+ * type.
  *
  * @param name - The name of the layer being checked.
  * @param other - The name of another layer in the drawing.
+ * @param kind - Whether the names are of layers or of linetypes, which AutoCAD compares alike.
  * @returns The problem, or undefined.
  */
-export declare function layerTwinProblem(name: string, other: string): string | undefined;
+export declare function layerTwinProblem(name: string, other: string, kind?: "layer" | "linetype"): string | undefined;
+/**
+ * Returns what is wrong with a linetype definition, or undefined when it is
+ * valid. It takes `unknown`s so that `lint` can report a drawing built by hand
+ * with a field of the wrong type.
+ */
+export declare function linetypeProblem(name: unknown, description: unknown, pattern: unknown): string | undefined;
+/**
+ * Returns what is wrong with a layer or an entity that names a linetype the
+ * drawing does not have. The rule depends on the drawing, so it has no type.
+ */
+export declare function undefinedLinetypeProblem(name: string): string;
+/** Returns what is wrong with the linetype a layer names, or undefined when it can be a layer's. */
+export declare function layerLinetypeProblem(name: string): string | undefined;
+/**
+ * Returns what is wrong with a lineweight, or undefined when it is valid. A
+ * layer's lineweight may also be "Default", and an entity's "ByLayer",
+ * "ByBlock" or "Default". AutoCAD discards a drawing with an entity of any
+ * other lineweight, and gives a layer of another lineweight the default.
+ *
+ * @param value - The lineweight, in millimetres or by name.
+ * @param of - Whose lineweight it is.
+ * @returns The problem, or undefined.
+ */
+export declare function lineweightProblem(value: unknown, of: "layer" | "entity"): string | undefined;
+/**
+ * Returns what is wrong with a layer's states, or undefined when AutoCAD takes
+ * them. tsdraft writes layer "0" as the current layer, and AutoCAD's AUDIT
+ * reports a drawing whose current layer is frozen.
+ */
+export declare function layerStateProblem(name: string, frozen: boolean | undefined): string | undefined;
+/** Returns what is wrong with the value of a layer's `off`, `frozen`, `locked` or `plot`. */
+export declare function layerFlagProblem(state: string, value: unknown): string | undefined;
+/**
+ * Returns what is wrong with the global linetype scale, or undefined when it is
+ * valid. AutoCAD reads a scale of 0 or less, or one written as 0, as 1.
+ */
+export declare function linetypeScaleProblem(value: number): string | undefined;
+/** The R12 message for a feature, for `lint` and the builder. */
+export declare const R12_ONLY: {
+    readonly linetypes: "R12 drawings have no linetypes but Continuous, and no linetype scale. Use DXF version \"R2018\" for linetypes";
+    readonly lineweights: "R12 drawings have no lineweights. Use DXF version \"R2018\" for lineweights";
+    readonly layerStates: "tsdraft writes no layer states to R12 drawings. Use DXF version \"R2018\" for layers that are off, frozen, locked or not plotted";
+    readonly entityStyle: "R12 entities take no linetype or lineweight of their own. Use DXF version \"R2018\" for an entity linetype or lineweight";
+};
 /** Returns what is wrong with a layer color, or undefined when it is valid. */
 export declare function layerColorProblem(color: number): string | undefined;
 /**
@@ -73,6 +224,17 @@ export declare function layerColorProblem(color: number): string | undefined;
  * @returns The problem, or undefined.
  */
 export declare function sizeProblem(value: number): string | undefined;
+/**
+ * Returns what is wrong with a paper length, the ratio it plots at, or the
+ * length in drawing units they give, or undefined when the result can be
+ * written. The result is a size, so it is held to the limits of `sizeProblem`.
+ *
+ * @param length - The length on paper, which must be a finite number.
+ * @param ratio - The scale ratio, which must be a finite number.
+ * @param result - The length in drawing units.
+ * @returns The problem, or undefined.
+ */
+export declare function paperLengthProblem(length: number, ratio: number, result: number): string | undefined;
 /**
  * Returns what is wrong with the size of a number a drawing holds, or
  * undefined when AutoCAD can read it. This goes for every number that is
@@ -106,6 +268,25 @@ export declare function arcProblem(startAngle: number, endAngle: number): string
  * @returns Whether the arc is written with no length.
  */
 export declare function arcIsWrittenAsPoint(startAngle: number, endAngle: number): boolean;
+/**
+ * Returns what is wrong with an entity id, or undefined when it is valid. It takes `unknown` so
+ * that `lint` can report a drawing built by hand with an id of the wrong type.
+ */
+export declare function idProblem(id: unknown): string | undefined;
+/** The form two ids are compared in: `Door-1` and `door-1` are one id. */
+export declare function idKey(id: string): string;
+/**
+ * Returns what is wrong with a second entity that has an id the drawing already has. The rule
+ * depends on the drawing, so it has no type.
+ *
+ * @param id - The id of the second entity.
+ * @param first - The id as the first entity spells it.
+ */
+export declare function duplicateIdProblem(id: string, first: string): string;
+/** Returns what is wrong with a drawing's format version, or undefined when tsdraft reads it. */
+export declare function formatProblem(format: unknown): string | undefined;
+/** A value of any type for a message: a string quoted, a number as it is, anything else by kind. */
+export declare function shown(value: unknown): string;
 /** Returns what is wrong with a single-line text value, or undefined when it is valid. */
 export declare function textProblem(value: string): string | undefined;
 /**