@graphty/graph-io 0.3.48 → 0.3.49

package/src/styles/canon/enums.ts

@@ -1,7 +1,7 @@
 /**
  * Canonical enumeration values: each dialect's spellings matched against an alias table without regard to case,
  * spaces or underscores. An unknown value of an open enumeration (shapes, border and line styles, arrows) is kept as
- * `other:<raw>` and noted; an unknown value of a closed one (weights, positions) gives no value and is noted.
+ * `other:<raw>` and noted; an unknown value of a closed one (weights, positions, label fits) gives no value and is noted.
  */
 
 import { STYLE_ISSUE } from "../codes.js";
@@ -12,7 +12,17 @@ import { type CanonSite, noteAt, scalarText } from "./site.js";
  * The enumerations a style value can belong to.
  * @category Styles
  */
-export type StyleEnumKind = "shape" | "borderStyle" | "lineStyle" | "arrow" | "weight" | "position";
+export type StyleEnumKind =
+    | "shape"
+    | "borderStyle"
+    | "borderPosition"
+    | "lineStyle"
+    | "arrow"
+    | "arrowSide"
+    | "weight"
+    | "position"
+    | "labelFit"
+    | "textAlign";
 
 type Aliases = Readonly<Record<string, readonly string[]>>;
 
@@ -55,16 +65,34 @@ const SHAPES: Aliases = {
         "roundedrectangle",
         "round-rect",
         "mrecord",
-        "cut-rectangle",
         "round-tag",
         "bottom-round-rectangle",
+        "bottomroundrectangle",
     ],
     triangle: ["triangle", "invtriangle", "round-triangle", "tag"],
     diamond: ["diamond", "rhombus", "mdiamond", "round-diamond"],
     pentagon: ["pentagon", "round-pentagon"],
-    hexagon: ["hexagon", "hexagon2", "round-hexagon", "concave-hexagon", "septagon", "heptagon", "round-heptagon"],
-    octagon: ["octagon", "doubleoctagon", "tripleoctagon", "round-octagon", "octagon2"],
-    parallelogram: ["parallelogram", "parallelogram2", "rhomboid", "fat-arrow", "fatarrow"],
+    hexagon: [
+        "hexagon",
+        "hexagon2",
+        "round-hexagon",
+        "concave-hexagon",
+        "concavehexagon",
+        "septagon",
+        "heptagon",
+        "round-heptagon",
+    ],
+    // a cut rectangle is a rectangle with its four corners cut off: eight sides
+    octagon: [
+        "octagon",
+        "doubleoctagon",
+        "tripleoctagon",
+        "round-octagon",
+        "octagon2",
+        "cut-rectangle",
+        "cutrectangle",
+    ],
+    parallelogram: ["parallelogram", "parallelogram2", "rhomboid", "right-rhomboid", "fat-arrow", "fatarrow"],
     trapezoid: ["trapezoid", "trapezoid2", "invtrapezoid", "trapezium", "round-trapezoid"],
     star: ["star", "star5", "star6", "star8", "polygon"],
     vee: ["vee", "v"],
@@ -136,6 +164,35 @@ const POSITIONS: Aliases = {
     "bottom-left": ["bottom-left", "south-west", "southwest"],
     "bottom-right": ["bottom-right", "south-east", "southeast"],
     "inside-top": ["inside-top"],
+    "inside-bottom": ["inside-bottom"],
+    "inside-left": ["inside-left"],
+    "inside-right": ["inside-right"],
+    "inside-top-left": ["inside-top-left"],
+    "inside-top-right": ["inside-top-right"],
+    "inside-bottom-left": ["inside-bottom-left"],
+    "inside-bottom-right": ["inside-bottom-right"],
+};
+
+const BORDER_POSITIONS: Aliases = {
+    inside: ["inside"],
+    center: ["center", "centre", "middle"],
+    outside: ["outside"],
+};
+
+const ARROW_SIDES: Aliases = {
+    left: ["left"],
+    right: ["right"],
+};
+
+const TEXT_ALIGNS: Aliases = {
+    left: ["left", "start"],
+    center: ["center", "centre", "middle"],
+    right: ["right", "end"],
+};
+
+const LABEL_FITS: Aliases = {
+    inside: ["inside"],
+    bounds: ["bounds"],
 };
 
 /** vis-network draws these spellings differently from the common reading. */
@@ -146,11 +203,40 @@ const VIS: Partial<Record<StyleEnumKind, Aliases>> = {
         triangle: ["triangledown"],
         none: ["text"],
     },
-    arrow: { inverted: ["inv-triangle"], square: ["box"] },
+    // curve and inv_curve: an arc at the end, bulging toward the node and away from it
+    arrow: { inverted: ["inv-triangle"], square: ["box"], "other:curve": ["curve"], "other:inv-curve": ["inv-curve"] },
+};
+
+/**
+ * Cytoscape.js's compound arrows (https://js.cytoscape.org/#style/edge-arrow): a triangle with a bar behind it, with a
+ * thin bar across the line behind it, a dot with a triangle behind it and its short chevron each keep their own name;
+ * its triangle-backcurve is a triangle whose back is hollowed out, which is how a vee is drawn.
+ */
+const CYJS: Partial<Record<StyleEnumKind, Aliases>> = {
+    arrow: {
+        "other:triangle-tee": ["triangle-tee"],
+        "other:triangle-cross": ["triangle-cross"],
+        "other:circle-triangle": ["circle-triangle"],
+        // a vee two thirds as long as its triangle (0.2 of the arrow width against 0.3)
+        "other:chevron": ["chevron"],
+        vee: ["triangle-backcurve"],
+    },
+};
+
+/**
+ * Graphviz's curve and icurve (lib/common/arrows.c arrow_type_curve): a stem to the tip with an arc across it, bulging
+ * toward the tip and, inverted, away from it -- vis-network's curve and inv_curve.
+ */
+const GRAPHVIZ: Partial<Record<StyleEnumKind, Aliases>> = {
+    arrow: { "other:curve": ["curve"], "other:inv-curve": ["icurve"] },
 };
 
 /** Per-dialect overrides; a dialect not listed reads the common table alone. */
-const OVERRIDES: ReadonlyMap<string, Partial<Record<StyleEnumKind, Aliases>>> = new Map([["vis", VIS]]);
+const OVERRIDES: ReadonlyMap<string, Partial<Record<StyleEnumKind, Aliases>>> = new Map([
+    ["vis", VIS],
+    ["graphviz", GRAPHVIZ],
+    ["cytoscape-js", CYJS],
+]);
 
 const OPEN: ReadonlySet<StyleEnumKind> = new Set<StyleEnumKind>(["shape", "borderStyle", "lineStyle", "arrow"]);
 
@@ -174,8 +260,12 @@ const COMMON: ReadonlyMap<StyleEnumKind, ReadonlyMap<string, string>> = new Map(
     ["borderStyle", lookup(BORDER_STYLES)],
     ["lineStyle", lookup(LINE_STYLES)],
     ["arrow", lookup(ARROWS)],
+    ["arrowSide", lookup(ARROW_SIDES)],
     ["weight", lookup(WEIGHTS)],
     ["position", lookup(POSITIONS)],
+    ["labelFit", lookup(LABEL_FITS)],
+    ["borderPosition", lookup(BORDER_POSITIONS)],
+    ["textAlign", lookup(TEXT_ALIGNS)],
 ]);
 
 const DIALECT: ReadonlyMap<string, ReadonlyMap<StyleEnumKind, ReadonlyMap<string, string>>> = new Map(

package/src/styles/canon/graphviz.ts

@@ -12,6 +12,13 @@
  *   scheme knows no names at all.
  * - `transparent`, `none` and `invis` are `#fffffe` with alpha 0, whatever the scheme.
  * - An unknown color is drawn BLACK.
+ * - A bare name SVG knows (`gray`, `purple`, `green`, `maroon`, `crimson` ...), not in a `/scheme/` and with no
+ *   leading blanks, is drawn as the SVG color, whatever the scheme: Graphviz's SVG output writes such a name as it is
+ *   (`fill="gray"`, gvrender_resolve_color) and every SVG reader draws it as CSS does, so `gray` is #808080 there,
+ *   not X11's #c0c0c0. The SVG drawing is the one we read Graphviz by.
+ * - An outline or font color list whose first entry is such a name is written whole (`stroke="red:blue"`: Graphviz
+ *   resolves the first entry in place and puts the `:` back), which no SVG reader can draw: an outline is not drawn
+ *   and a text is black, SVG's own default.
  * - A color list (`red:blue`, `red;0.3:blue`): an outline or a font color draws the text before the first `:` as one
  *   color, so `red:blue` is red and `red;0.3:blue` is black (`red;0.3` is not a color). A fill draws a gradient and
  *   an edge draws one line per color; both start with the first entry's color, its `;fraction` dropped. A value
@@ -24,7 +31,7 @@ import { BREWER_SCHEMES, CSS_COLORS, X11_COLORS } from "./color-tables.js";
  * How Graphviz draws a color value, which decides how a color list is read.
  * @category Styles
  */
-export type GraphvizColorUse = "line" | "fill" | "edge";
+export type GraphvizColorUse = "line" | "text" | "fill" | "edge";
 
 /**
  * A resolved Graphviz color, with how it was read.
@@ -159,30 +166,84 @@ function schemeColor(name: string, scheme: string): string | undefined {
     return colors !== undefined && index >= 1 ? colors[index - 1] : undefined;
 }
 
+/**
+ * A color list whose first color is a bare SVG name, as Graphviz's SVG output draws it for a pen: no outline, black
+ * text.
+ * @param use - `line` or `text`
+ * @returns the color
+ */
+function svgPenList(use: GraphvizColorUse): GraphvizColor {
+    return use === "line"
+        ? { hex: "#fffffe", alpha: 0, unknown: false, list: null }
+        : { hex: "#000000", alpha: 1, unknown: false, list: null };
+}
+
+/**
+ * A color list entry without its `;fraction`.
+ * @param text - the entry
+ * @returns the color part
+ */
+function beforeSemicolon(text: string): string {
+    const semi = text.indexOf(";");
+    return semi >= 0 ? text.slice(0, semi) : text;
+}
+
+/**
+ * One Graphviz color, read from its scheme (X11 when none), a bare SVG name first when `svgNames` says so.
+ * @param raw - the whole value
+ * @param text - the color, without the list after it
+ * @param scheme - the object's `colorscheme`, or null
+ * @param svgNames - whether a bare SVG name is drawn as SVG's color
+ * @returns the color, or null when it is unknown
+ */
+function resolveColorText(
+    raw: string,
+    text: string,
+    scheme: string | null,
+    svgNames: boolean,
+): { hex: string; alpha: number } | null {
+    const svgName = svgNames && raw.startsWith(text) ? CSS_COLORS.get(text.toLowerCase()) : undefined;
+    if (svgName !== undefined) {
+        return { hex: svgName, alpha: 1 };
+    }
+    if (text === "") {
+        return null;
+    }
+    const sc = scheme === null || scheme.trim() === "" ? "x11" : scheme.toLowerCase();
+    return resolveOne(text, sc);
+}
+
 /**
  * Resolves a Graphviz color value the way Graphviz draws it for a use; an unknown color is black.
  * @param raw - the value, at most 256 characters
  * @param scheme - the object's `colorscheme`, or null
- * @param use - an outline or font color (`line`), a fill, or an edge's line color
+ * @param use - an outline color (`line`), a font color (`text`), a fill, or an edge's line color
+ * @param svgNames - whether a bare SVG name is drawn as SVG's color, as Graphviz's SVG output draws it (false: as
+ * every other Graphviz output draws it)
  * @returns the color and how it was read
  * @category Styles
  */
-export function graphvizColor(raw: string, scheme: string | null, use: GraphvizColorUse): GraphvizColor {
+export function graphvizColor(
+    raw: string,
+    scheme: string | null,
+    use: GraphvizColorUse,
+    svgNames = true,
+): GraphvizColor {
     let text = raw.replace(/^[ \t\r\n]+/, "");
     let list: GraphvizColor["list"] = null;
     const colon = text.indexOf(":");
+    const pen = use === "line" || use === "text";
     if (colon >= 0) {
         text = text.slice(0, colon);
-        if (use !== "line") {
-            const semi = text.indexOf(";");
-            if (semi >= 0) {
-                text = text.slice(0, semi);
-            }
+        if (svgNames && pen && raw.startsWith(text) && CSS_COLORS.has(text.toLowerCase())) {
+            return svgPenList(use);
+        }
+        if (!pen) {
+            text = beforeSemicolon(text);
             list = use === "fill" ? "gradient" : "lines";
         }
     }
-    const sc = scheme === null || scheme.trim() === "" ? "x11" : scheme.toLowerCase();
-    const resolved = text === "" ? null : resolveOne(text, sc);
+    const resolved = resolveColorText(raw, text, scheme, svgNames);
     return resolved === null
         ? { hex: "#000000", alpha: 1, unknown: true, list }
         : { hex: resolved.hex, alpha: resolved.alpha, unknown: false, list };

package/src/styles/canon/number.ts

@@ -82,6 +82,25 @@ export function canonNumber(raw: unknown, site: CanonSite, factor = 1): number |
     return num6(scaled);
 }
 
+/**
+ * A signed number (an offset): any finite value within the largest a style number may be, either way.
+ * @param raw - the file's value
+ * @param site - where it was read
+ * @returns the canonical number, or null (noted)
+ * @category Styles
+ */
+export function canonSigned(raw: unknown, site: CanonSite): number | null {
+    const value = finite(raw, site);
+    if (value === null) {
+        return null;
+    }
+    if (Math.abs(value) > MAX_STYLE_NUMBER) {
+        noteAt(site, STYLE_ISSUE.BAD_VALUE, typeof raw === "string" ? raw : String(raw));
+        return null;
+    }
+    return num6(value);
+}
+
 /**
  * An opacity from 0 to 1. Cytoscape desktop states opacities from 0 to 255 and is divided by 255; every other
  * dialect states 0 to 1. A value outside the dialect's range is null with a `W_STYLE_BAD_VALUE` note.

package/src/styles/canon/text.ts

@@ -51,7 +51,8 @@ export interface DotEscapeNames {
 /**
  * The text a DOT label draws, in Graphviz's two passes: first `\N`, `\G`, `\E`, `\T` and `\H` are replaced by the
  * names and every other backslash pair is kept; then `\n`, `\l` and `\r` end a line (a final one adds no empty line)
- * and any other escaped character stands for itself. So a node name holding `\n` breaks the line.
+ * and any other escaped character stands for itself. So a node name holding `\n` breaks the line. Between the
+ * two, HTML entities (`&`, `β`) are decoded, as Graphviz's `htmlEntityUTF8` does for a plain label.
  * @param text - the label as the file gives it
  * @param names - the names to substitute
  * @param site - where it was read, for the budget
@@ -62,6 +63,20 @@ export function dotLabelText(text: string, names: DotEscapeNames, site?: CanonSi
     if (site !== undefined) {
         spendAt(site, text.length);
     }
+    const out = replaceEscapes(decodeEntities(substituteNames(text, names)), (e) =>
+        e === "n" || e === "l" || e === "r" ? "\n" : e,
+    );
+    return out.endsWith("\n") ? out.slice(0, -1) : out;
+}
+
+/**
+ * Graphviz's first pass over a label: `\N`, `\G`, `\E`, `\T` and `\H` replaced by the names, every other
+ * backslash pair kept.
+ * @param text - the label as the file gives it
+ * @param names - the names to substitute
+ * @returns the text
+ */
+function substituteNames(text: string, names: DotEscapeNames): string {
     const subs: Readonly<Record<string, string | undefined>> = {
         N: names.node,
         G: names.graph,
@@ -69,9 +84,34 @@ export function dotLabelText(text: string, names: DotEscapeNames, site?: CanonSi
         T: names.tail,
         H: names.head,
     };
-    const first = replaceEscapes(text, (e) => (Object.hasOwn(subs, e) ? subs[e] : undefined) ?? `\\${e}`);
-    const out = replaceEscapes(first, (e) => (e === "n" || e === "l" || e === "r" ? "\n" : e));
-    return out.endsWith("\n") ? out.slice(0, -1) : out;
+    return replaceEscapes(text, (e) => (Object.hasOwn(subs, e) ? subs[e] : undefined) ?? `\\${e}`);
+}
+
+/**
+ * How a DOT label's lines line up: each line ended by `\l` is drawn against the left, by `\r` against the right, and
+ * any other line centered (Graphviz's second pass, after `\N` and the other names are substituted). graphty lines
+ * up a label's lines one way, so the way most of its lines take wins, the first line's on a tie.
+ * @param text - the label as the file gives it
+ * @param names - the names to substitute
+ * @returns `left` or `right`, or null for a centered label
+ * @category Styles
+ */
+export function dotLabelAlign(text: string, names: DotEscapeNames): "left" | "right" | null {
+    // each line's end, in order: "n" centered, "l" left, "r" right; text after the last end is a centered line
+    const parts = replaceEscapes(substituteNames(text, names), (e) =>
+        e === "n" || e === "l" || e === "r" ? `\u0000${e}\u0000` : "x",
+    ).split("\u0000");
+    const ends = parts.filter((_, i) => i % 2 === 1);
+    if (parts.at(-1) !== "") {
+        ends.push("n");
+    }
+    const count = (end: string): number => ends.filter((e) => e === end).length;
+    const best = ["l", "r", "n"].filter((end) => count(end) === Math.max(count("l"), count("r"), count("n")));
+    const winner = best.length > 1 ? (ends.find((e) => best.includes(e)) ?? "n") : best[0];
+    if (winner === "l") {
+        return "left";
+    }
+    return winner === "r" ? "right" : null;
 }
 
 /**
@@ -126,7 +166,8 @@ function entity(body: string): string | undefined {
 
 /**
  * The text an HTML-like label shows: tags dropped, `<br/>` as a line break, entities decoded, outer blanks trimmed.
- * Notes `W_STYLE_HTML_LABEL` at the site, since the markup is lost.
+ * A table's rows are lines and the cells of a row are parted by a space, as Graphviz lays them out; text in a table
+ * outside its cells is not drawn. Notes `W_STYLE_HTML_LABEL` at the site, since the markup is lost.
  * @param html - the label, with or without its outer `<` and `>`
  * @param site - where it was read
  * @returns the label's text
@@ -135,8 +176,33 @@ function entity(body: string): string | undefined {
 export function htmlLabelText(html: string, site: CanonSite): string {
     spendAt(site, html.length);
     noteAt(site, STYLE_ISSUE.HTML_LABEL, html);
+    return htmlLabelSpans(html)
+        .map((s) => s.text)
+        .join("")
+        .trim();
+}
+
+/** A piece of an HTML-like label's text with the font tags open around it, outermost first. */
+export interface HtmlLabelSpan {
+    /** The text, entities decoded. */
+    readonly text: string;
+    /** The open font tags (`<B>`, `<FONT COLOR="red">`, ...) as written, outermost first. */
+    readonly tags: readonly string[];
+}
+
+/** The tags that change the font of the text inside them. */
+const FONT_TAGS = /^<(\/?)(b|i|u|o|s|sub|sup|font)\b/i;
+
+/**
+ * The pieces of text an HTML-like label shows, untrimmed, each with the font tags around it (the text
+ * {@link htmlLabelText} joins and trims).
+ * @param html - the label, with or without its outer `<` and `>`
+ * @returns the pieces in order
+ * @category Styles
+ */
+export function htmlLabelSpans(html: string): HtmlLabelSpan[] {
     const body = html.startsWith("<") && html.endsWith(">") ? html.slice(1, -1) : html;
-    let out = "";
+    const s: SpanState = { spans: [], tags: [], out: "", open: [] };
     let i = 0;
     while (i < body.length) {
         const c = body[i];
@@ -145,20 +211,125 @@ export function htmlLabelText(html: string, site: CanonSite): string {
             if (close < 0) {
                 break;
             }
-            if (/^<br\b/i.test(body.slice(i, i + 4))) {
-                out += "\n";
-            }
+            readTag(s, body, i, close);
             i = close + 1;
-        } else if (c === "&") {
-            const [text, next] = entityAt(body, i);
-            out += text;
-            i = next;
         } else {
-            out += c;
-            i++;
+            const [text, next]: [string, number] = c === "&" ? entityAt(body, i) : [c, i + 1];
+            emitSpan(s, s.open.at(-1) === "table" ? "" : text);
+            i = next;
         }
     }
-    return out.trim();
+    return s.spans;
+}
+
+/** What {@link htmlLabelSpans} has read so far. */
+interface SpanState {
+    /** the pieces so far */
+    spans: HtmlLabelSpan[];
+    /** the font tags open now; a new array whenever they change, so a piece's tags are compared by identity */
+    tags: string[];
+    /** the text so far */
+    out: string;
+    /** the open tables and cells, innermost last: text is drawn outside every table or inside a cell */
+    open: ("table" | "td")[];
+}
+
+/**
+ * Adds text to the last piece when its tags are the ones open, else as a new piece.
+ * @param s - the reading so far, changed in place
+ * @param text - the text
+ */
+function emitSpan(s: SpanState, text: string): void {
+    s.out += text;
+    const last = s.spans.at(-1);
+    if (last?.tags === s.tags) {
+        s.spans[s.spans.length - 1] = { text: last.text + text, tags: s.tags };
+    } else if (text !== "") {
+        s.spans.push({ text, tags: s.tags });
+    }
+}
+
+/**
+ * Whether the line being read has text on it.
+ * @param s - the reading so far
+ * @returns whether it has
+ */
+function lineHasText(s: SpanState): boolean {
+    return s.out.slice(s.out.lastIndexOf("\n") + 1).trim() !== "";
+}
+
+/**
+ * One tag of an HTML-like label: a line break, a table, row or cell, or a font tag.
+ * @param s - the reading so far, changed in place
+ * @param body - the label
+ * @param i - the offset of the tag's `<`
+ * @param close - the offset of its `>`
+ */
+function readTag(s: SpanState, body: string, i: number, close: number): void {
+    const tag = /^<(\/?)(br|table|tr|td)\b/i.exec(body.slice(i, i + 7));
+    if (tag !== null) {
+        layoutTag(s, tag[2].toLowerCase(), tag[1] === "/");
+        return;
+    }
+    const font = FONT_TAGS.exec(body.slice(i, i + 6));
+    if (font !== null && font[1] === "/") {
+        s.tags = withoutLastTag(s.tags, font[2]);
+    } else if (font !== null && body[close - 1] !== "/") {
+        s.tags = [...s.tags, body.slice(i, close + 1)];
+    }
+}
+
+/**
+ * A line break, table, row or cell tag: a break and a row with text before it start a line, a cell with text before
+ * it on its line a space.
+ * @param s - the reading so far, changed in place
+ * @param name - `br`, `table`, `tr` or `td`, in lower case
+ * @param closing - whether it is a closing tag
+ */
+function layoutTag(s: SpanState, name: string, closing: boolean): void {
+    if (name === "br" || name === "tr") {
+        if (name === "br" || (!closing && lineHasText(s))) {
+            emitSpan(s, "\n");
+        }
+    } else if (closing) {
+        s.open.pop();
+    } else {
+        if (name === "td" && lineHasText(s)) {
+            emitSpan(s, " ");
+        }
+        s.open.push(name === "td" ? "td" : "table");
+    }
+}
+
+/**
+ * The open font tags without the innermost one a closing tag closes.
+ * @param tags - the open tags
+ * @param name - the closing tag's name
+ * @returns the tags left open (the same array when none matched)
+ */
+function withoutLastTag(tags: string[], name: string): string[] {
+    const lower = name.toLowerCase();
+    let at = tags.length - 1;
+    while (at >= 0 && /^<(\w+)/.exec(tags[at])?.[1].toLowerCase() !== lower) {
+        at--;
+    }
+    return at < 0 ? tags : [...tags.slice(0, at), ...tags.slice(at + 1)];
+}
+
+/**
+ * Every entity of a text decoded; an `&` that starts none is itself.
+ * @param text - the text
+ * @returns the decoded text
+ */
+function decodeEntities(text: string): string {
+    let out = "";
+    let i = 0;
+    for (let amp = text.indexOf("&"); amp >= 0; amp = text.indexOf("&", i)) {
+        const [decoded, next] = entityAt(text, amp);
+        out += text.slice(i, amp) + decoded;
+        i = next;
+    }
+    return out + text.slice(i);
 }
 
 /**

package/src/styles/codes.ts

@@ -42,6 +42,8 @@ export const STYLE_ISSUE = Object.freeze({
     INHERIT_COLOR: "W_STYLE_INHERIT_COLOR",
     /** A style property the vocabulary has no counterpart for was not carried. */
     NOT_CARRIED: "W_STYLE_NOT_CARRIED",
+    /** An annotation of a kind graph-io does not read (a group of annotations); its kinds are the samples. */
+    ANNOTATION_SKIPPED: "W_STYLE_ANNOTATION_SKIPPED",
     // ------------------------------------------------ reading declared styles
     /** A declared mapping that cannot be read. */
     BAD_MAPPING: "W_STYLE_BAD_MAPPING",