@jbrowse/cli 4.3.0 → 5.0.0-beta.10

package/dist/commands/validate/displayDefaultKeys.js

@@ -0,0 +1,28 @@
+import { configManifest } from './configManifest.generated.js';
+// `displayDefaults: {color: 'green'}` is a track-level shorthand
+// (expandTrackConfigShorthand.ts) routing each key to whichever of the track's
+// display types declares it, so the keys a track accepts are the union of those
+// displays' slots rather than the track's own.
+export function displayDefaultKeys(trackEntry, manifest) {
+    return (trackEntry.displayTypes ?? []).flatMap(name => manifest.displays[name]?.slots.map(slot => slot.name) ?? []);
+}
+// The same set for a track type named rather than resolved — add-track knows
+// the type it is writing, not a manifest entry. The display types come back
+// alongside, because most tracks offer exactly one and naming it is the whole
+// difference between a message someone can act on and one they cannot: an
+// AlignmentsTrack has only LinearAlignmentsDisplay, so "no AlignmentsTrack
+// display declares color" sends the reader looking for the other displays.
+//
+// Both empty for a type the manifest does not carry (a plugin's), which no
+// check here can speak to.
+export function displayDefaultsForTrackType(trackType, manifest = configManifest) {
+    const entry = lookup(manifest.tracks, trackType);
+    return {
+        displayTypes: entry?.displayTypes ?? [],
+        keys: entry ? displayDefaultKeys(entry, manifest) : [],
+    };
+}
+function lookup(group, typeName) {
+    return (group[typeName] ??
+        Object.values(group).find(entry => entry.aliases?.includes(typeName)));
+}

package/dist/commands/validate/index.js

@@ -0,0 +1,113 @@
+import { parseArgs } from 'node:util';
+import { printHelp, readConfigFile } from '../../utils.js';
+import { validateConfig } from './validateConfig.js';
+const description = 'Check a JBrowse configuration for errors, including the ones JBrowse itself accepts silently';
+const notes = `A config key JBrowse does not recognize is ignored rather than reported, so a
+misspelled slot leaves the track loading normally with the setting doing
+nothing. That is what this command is mainly for.
+
+Two levels are reported:
+
+  error    JBrowse silently does the wrong thing, or refuses to load it — an
+           unknown slot, a key a defaultSession view or display does not
+           declare, a track naming an assembly the config never defines, a
+           defaultSession naming a trackId that does not exist, a duplicate
+           trackId. Exits 1.
+
+  warning  JBrowse will complain by itself on load, or handles it — a type name
+           the core plugins do not register (expected if one of your plugins
+           registers it), or a legacy key a migration rewrites, such as a view
+           nesting its settings under "init". Never fails the run.
+
+A LinearMarkDisplay loads whenever its keys and value types are right and says
+what it cannot draw in a corner notice rather than refusing the track.
+This command runs the display's own rule list over every "marks" list in the
+file: an error where a mark draws nothing, never draws or a step cannot run,
+and a warning where a slot waits unread or the marks draw in an arrangement
+the author may not have meant. With --json each finding carries the stable
+"rule" id of the rule that made it.
+
+Types registered by plugins are not known to this command, so they come through
+as warnings rather than errors.
+
+The same checks are published as a JSON Schema at
+https://jbrowse.org/jb2/schema/v5/config.json: a "$schema" line naming it at
+the top of a config.json gives an editor completion and validation for every
+slot. This command runs that schema first, then the cross-references a schema
+cannot express — a trackId a session names that no track defines, an assembly
+a track names that none defines.`;
+const examples = [
+    '# check the config.json in the current directory',
+    '$ jbrowse validate',
+    '',
+    '# check a specific config or saved session',
+    '$ jbrowse validate /path/to/config.json',
+    '$ jbrowse validate mysession.jbrowse',
+    '',
+    '# machine-readable output',
+    '$ jbrowse validate config.json --json',
+];
+const options = {
+    json: {
+        type: 'boolean',
+        description: 'Output the findings as JSON instead of text',
+    },
+    quiet: {
+        type: 'boolean',
+        short: 'q',
+        description: 'Only print errors, suppressing warnings and notes',
+    },
+    help: { type: 'boolean', short: 'h', description: 'Show help' },
+};
+function format({ level, where, message }) {
+    return where ? `${level}: ${where}: ${message}` : `${level}: ${message}`;
+}
+export async function run(args) {
+    const { values: flags, positionals } = parseArgs({
+        options,
+        args,
+        allowPositionals: true,
+    });
+    if (flags.help) {
+        printHelp({
+            description,
+            examples,
+            notes,
+            usage: 'jbrowse validate [config.json] [options]',
+            options,
+        });
+        return;
+    }
+    const file = positionals[0] ?? 'config.json';
+    // readConfigFile, not readJsonFile: running from the wrong directory is the
+    // most common way this fails, and it says which path it looked at.
+    const config = await readConfigFile(file);
+    const result = validateConfig(config);
+    if (flags.json) {
+        console.log(JSON.stringify({ file, ok: result.errorCount === 0, ...result }, null, 2));
+    }
+    else {
+        const shown = flags.quiet
+            ? result.problems.filter(p => p.level === 'error')
+            : result.problems;
+        if (!flags.quiet) {
+            for (const note of result.notes) {
+                console.log(`note: ${note}`);
+            }
+        }
+        for (const problem of shown) {
+            console.log(format(problem));
+        }
+        if (result.problems.length === 0) {
+            console.log(`${file} looks good`);
+        }
+        else {
+            console.log(`\n${result.errorCount} error(s), ${result.warningCount} warning(s) in ${file}`);
+        }
+    }
+    if (result.errorCount > 0) {
+        // Non-zero so this can gate a deploy. Thrown rather than process.exit so it
+        // goes through the same error path as every other command.
+        throw new Error(`${result.errorCount} error(s) found in ${file}`);
+    }
+}

package/dist/commands/validate/liftConfig.js

@@ -0,0 +1,34 @@
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function liftSlot(member, slot) {
+    if (slot.subSlots) {
+        const { subSlots, shorthand = {} } = slot;
+        const lift = (item) => {
+            const target = typeof item === 'string'
+                ? shorthand.string
+                : typeof item === 'number'
+                    ? shorthand.number
+                    : undefined;
+            return liftToSnapshot(target === undefined ? item : { [target]: item }, subSlots);
+        };
+        return Array.isArray(member) ? member.map(lift) : lift(member);
+    }
+    const list = slot.liftsString && typeof member === 'string' ? [member] : member;
+    return slot.liftsNumbers && Array.isArray(list) ? list.map(String) : list;
+}
+/**
+ * A config object as its schema holds it once loaded, defaults still left off:
+ * a bare string or number lifted into the sub-schema's `shorthand` slot taking it or a string into a list of
+ * one, and a number in a list of strings carried as a string. Which slot lifts
+ * what is the manifest's record of the live schemas, so a rule list written
+ * against a config snapshot reads a file the way it reads the app's.
+ */
+export function liftToSnapshot(value, slots) {
+    return isRecord(value)
+        ? Object.fromEntries(Object.entries(value).map(([key, member]) => {
+            const slot = slots.find(s => s.name === key);
+            return [key, slot ? liftSlot(member, slot) : member];
+        }))
+        : value;
+}

package/dist/commands/validate/markRules/aggregateFieldName.js

@@ -0,0 +1,9 @@
+// Generated by scripts/generateMarkRules.ts from packages/core/src/util/aggregateFieldName.ts: do not edit, `pnpm autogen` rewrites it.
+/**
+ * The field an aggregate op writes: `as` where named, else `count` for a
+ * count, else `<op>_<field>`. Imports nothing, so the validator's copy of the
+ * mark rule list carries it unchanged.
+ */
+export function aggregateFieldName({ op, field, as, }) {
+    return as || (op === 'count' || !field ? op : `${op}_${field}`);
+}

package/dist/commands/validate/markRules/autoBin.js

@@ -0,0 +1,27 @@
+// Generated by scripts/generateMarkRules.ts from plugins/marks/src/LinearMarkDisplay/autoBin.ts: do not edit, `pnpm autogen` rewrites it.
+/** The `step` value a `bin` step writes to follow the view's zoom. */
+export const AUTO_BIN = 'auto';
+/**
+ * How wide an automatic bin aims to be on screen. Four pixels is a bar the eye
+ * reads as a bar rather than a hairline, and it keeps a screenful of a
+ * 1000px-wide view at ~250 instances.
+ */
+export const AUTO_BIN_TARGET_PX = 4;
+const LADDER = [1, 2, 5];
+/**
+ * The bin width an `auto` step resolves to at this zoom: the target width in bp
+ * ({@link AUTO_BIN_TARGET_PX} pixels' worth), snapped up to the next 1/2/5
+ * rung — 1, 2, 5, 10, 20, 50, 100 bp and so on, the ladder an axis picks its
+ * ticks from. Snapping stops most zoom steps from refetching: every bp/px
+ * inside a rung resolves to one width, so a zoom step within a rung refetches nothing
+ * and one across it refetches at the width the new zoom asks for.
+ */
+export function autoBinStep(bpPerPx) {
+    const target = Math.max(1, bpPerPx * AUTO_BIN_TARGET_PX);
+    const decade = 10 ** Math.floor(Math.log10(target));
+    return (LADDER.find(m => m * decade >= target) ?? 10) * decade;
+}
+/** A `bin` step's declared width in bp, with `auto` resolved at this zoom. */
+export function binStepWidth(step, bpPerPx) {
+    return step === AUTO_BIN ? autoBinStep(bpPerPx) : Number(step);
+}

package/dist/commands/validate/markRules/colorScale.js

@@ -0,0 +1,244 @@
+// Generated by scripts/generateMarkRules.ts from packages/core/src/util/colorScale.ts: do not edit, `pnpm autogen` rewrites it.
+/**
+ * The scales a colour object paints through, in a module that imports
+ * nothing: `jbrowse validate` carries a copy of it, so the validator and the
+ * displays read one statement.
+ */
+/** How a colour object maps its `field`; `none` paints `value`. */
+export const COLOR_SCALES = [
+    'none',
+    'categorical',
+    'linear',
+    'log',
+    'threshold',
+];
+/**
+ * The scale that maps no field: each feature paints the colour it carries, and
+ * the key names the colours `domain` lists. Only a display whose features
+ * carry colours of their own declares it.
+ */
+export const IDENTITY_SCALE = 'identity';
+const CATEGORICAL_PRESET = { scale: 'categorical' };
+/**
+ * The fields whose values have names, an order and colours of their own on
+ * every display, beneath each display's own presets. Red forward and blue
+ * reverse is what the synteny ribbons paint too. The SV classes are
+ * `svClassOf`'s, deletion red and duplication blue as dbVar and gnomAD-SV
+ * paint them, insertion the pileup's purple, and the rest kept apart under
+ * deuteranopia and protanopia. A record with no class files under `''`, so
+ * each display keeps its own no-value colour for it.
+ */
+export const UNIVERSAL_FIELD_PRESETS = {
+    strand: {
+        scale: 'categorical',
+        missing: '0',
+        domain: ['1', '-1', '0'],
+        range: ['tomato', 'cornflowerblue', 'goldenrod'],
+        labels: ['Forward strand', 'Reverse strand', 'No strand'],
+    },
+    svType: {
+        scale: 'categorical',
+        domain: ['DEL', 'DUP', 'INS', 'INV', 'CNV', 'TR', 'BND', 'CPX', 'OTHER'],
+        range: [
+            '#e41a1c',
+            '#377eb8',
+            '#800080',
+            '#ff7f00',
+            '#7e6148',
+            '#e7298a',
+            '#17becf',
+            '#66a61e',
+            '#000000',
+        ],
+        labels: [
+            'Deletion',
+            'Duplication',
+            'Insertion',
+            'Inversion',
+            'Copy-number variable',
+            'Tandem repeat',
+            'Breakend / translocation',
+            'Complex',
+            'Other / mixed',
+        ],
+        title: 'SV type',
+    },
+};
+/** The universal preset of `field`, if it has one. */
+export function universalPresetOf(field) {
+    return Object.hasOwn(UNIVERSAL_FIELD_PRESETS, field)
+        ? UNIVERSAL_FIELD_PRESETS[field]
+        : undefined;
+}
+/** Every field categorical while `scale` is unset, with nothing preset. */
+export const CATEGORICAL_FIELD_PRESETS = {
+    '*': CATEGORICAL_PRESET,
+};
+/**
+ * What a feature's field paints through while `scale` is unset: `score` a
+ * ramp, any other field categories.
+ */
+export const FEATURE_FIELD_PRESETS = {
+    score: { scale: 'linear' },
+    '*': CATEGORICAL_PRESET,
+};
+/**
+ * A field's preset under `presets`: its own, else a universal one, else
+ * `*`'s, else categorical.
+ */
+export function presetOf(presets, field) {
+    return ((Object.hasOwn(presets, field)
+        ? presets[field]
+        : (universalPresetOf(field) ?? presets['*'])) ?? CATEGORICAL_PRESET);
+}
+/** What a field paints through under `presets` while `scale` is unset. */
+export function fieldScaleOf(presets, field) {
+    return presetOf(presets, field).scale;
+}
+function unwritten(value) {
+    return value === undefined || (Array.isArray(value) && value.length === 0);
+}
+/**
+ * A colour object with its field's preset under it: each member the preset
+ * names and the config leaves unwritten, an empty list counting as unwritten.
+ * Only while the colour paints through the preset's own scale, so the cuts of
+ * a threshold preset never reach a field read through a ramp. A categorical
+ * preset's `range` and `labels` name its `domain`'s values in order, so they
+ * fill only while `domain` does too: a written order keeps each value's own
+ * colour and name.
+ */
+export function withPreset(color, presets) {
+    const field = color.field ?? '';
+    const preset = presetOf(presets, field);
+    if (!field || (color.scale ?? preset.scale) !== preset.scale) {
+        return color;
+    }
+    const written = new Map(Object.entries(color));
+    const ordered = preset.scale !== 'categorical' ||
+        !preset.domain ||
+        unwritten(written.get('domain'));
+    const filled = Object.entries(preset).filter(([key]) => key !== 'scale' &&
+        key !== 'missing' &&
+        (ordered || (key !== 'range' && key !== 'labels')) &&
+        unwritten(written.get(key)));
+    return filled.length > 0 ? { ...color, ...Object.fromEntries(filled) } : color;
+}
+/**
+ * The scale a colour object paints through: `none` while no `field` is
+ * named, else its own `scale`, or `fieldScale` where that is unset.
+ */
+export function paintedScale({ scale, field }, fieldScale) {
+    return field ? (scale ?? fieldScale) : 'none';
+}
+/**
+ * What a quantitative scale's ends say together that neither can refuse
+ * alone: a `domainMax` below its `domainMin`, which every such scale draws in
+ * order either way, and a `domainQuantile` outside 0.5 to 1, where the quantile
+ * an open end follows is clamped. `reverse` is whether the scale turns round by
+ * a member of its own, which is then the spelling to point at.
+ */
+export function scaleEndProblems({ domainMin, domainMax, domainQuantile }, { reverse = false } = {}) {
+    return [
+        ...(domainMin !== undefined &&
+            domainMax !== undefined &&
+            domainMin > domainMax
+            ? [
+                {
+                    rule: 'domain-ends',
+                    slot: 'domainMax',
+                    message: `domainMax is below domainMin: the scale spans the two in order either way${reverse ? ', and reverse is what turns it round' : ''}`,
+                },
+            ]
+            : []),
+        ...(domainQuantile !== undefined &&
+            !(domainQuantile >= 0.5 && domainQuantile <= 1)
+            ? [
+                {
+                    rule: 'domain-quantile',
+                    slot: 'domainQuantile',
+                    message: 'domainQuantile is a fraction from 0.5 to 1, not a percent: 1 follows the extremes and 0.99 clips the outermost 1% at each end; above 1 reads as 1 and below 0.5 as 0.5',
+                },
+            ]
+            : []),
+    ];
+}
+/** Problems as the lines a display's corner notice lists, under the setting that holds the scale. */
+export function noticeLines(setting, problems) {
+    return problems.map(({ slot, message }) => `${setting}.${slot}: ${message}`);
+}
+function pinned(entry) {
+    return entry !== '' && Number.isFinite(Number(entry));
+}
+/**
+ * What a colour object's slots say together that no single slot can refuse,
+ * since the config editor writes one slot at a time (ADR-133), read with its
+ * field's preset under it. A display shows these as a notice and draws what
+ * it can. A threshold naming no cuts leaves its intervals to the display —
+ * the alignments insert-size band samples its cuts, the wiggle plot cuts at
+ * its origin — so its `labels` go uncounted.
+ */
+export function colorProblems(written, presets) {
+    const color = withPreset(written, presets);
+    const { domain = [] } = color;
+    const { range = [] } = written;
+    const scale = color.scale === IDENTITY_SCALE
+        ? IDENTITY_SCALE
+        : paintedScale({ scale: color.scale, field: color.field ?? '' }, fieldScaleOf(presets, color.field ?? ''));
+    const problems = [];
+    if (scale === 'threshold') {
+        if (domain.some((cut, i) => !pinned(cut) || Number(cut) <= Number(domain[i - 1]))) {
+            problems.push({
+                rule: 'threshold-cuts',
+                slot: 'domain',
+                message: 'threshold cuts are distinct numbers, read in ascending order, with the range running from the lowest interval; a repeated cut leaves an interval no value falls in',
+            });
+        }
+        if (domain.length > 0 &&
+            range.length > 0 &&
+            range.length !== domain.length + 1) {
+            problems.push({
+                rule: 'threshold-range',
+                slot: 'range',
+                message: `${domain.length} threshold ${domain.length === 1 ? 'cut makes' : 'cuts make'} ${domain.length + 1} intervals, one colour each, and range lists ${range.length}: a missing colour comes from the default palette and an extra one is never read`,
+            });
+        }
+    }
+    if (scale === 'linear' || scale === 'log') {
+        if (domain.length > 0) {
+            problems.push({
+                rule: 'ramp-domain',
+                slot: 'domain',
+                message: "a linear or log scale reads no domain, which is a categorical scale's order and a threshold scale's cuts; a ramp's ends are domainMin and domainMax where the colour has them",
+            });
+        }
+        problems.push(...scaleEndProblems(color, { reverse: true }));
+    }
+    const { labels = [] } = color;
+    const named = scale === 'categorical' || scale === IDENTITY_SCALE
+        ? domain.length
+        : scale === 'threshold'
+            ? domain.length + 1
+            : undefined;
+    const cutsFromData = scale === 'threshold' && domain.length === 0;
+    if (labels.length > 0 &&
+        !cutsFromData &&
+        (named === undefined || labels.length > named)) {
+        const what = scale === 'categorical'
+            ? 'value'
+            : scale === IDENTITY_SCALE
+                ? 'colour'
+                : 'interval';
+        problems.push({
+            rule: 'labels-domain',
+            slot: 'labels',
+            message: named === undefined
+                ? "labels names a categorical scale's values, a threshold scale's intervals or an identity scale's colours, and this colour paints none of them"
+                : `labels names one ${what} each, and ${labels.length} ${labels.length === 1 ? 'label names' : 'labels name'} ${named} ${named === 1 ? what : `${what}s`}: a label past them names nothing`,
+        });
+    }
+    return problems;
+}
+/** `colorProblems` as the lines a display's corner notice lists, under `color`. */
+export function colorNotices(color, presets) {
+    return noticeLines('color', colorProblems(color, presets));
+}

package/dist/commands/validate/markRules/cssColorsLevel4.js

@@ -0,0 +1,162 @@
+// Generated by scripts/generateMarkRules.ts from packages/core/src/util/color/cssColorsLevel4.ts: do not edit, `pnpm autogen` rewrites it.
+// from https://www.w3.org/TR/css-color-4/#named-colors
+const colors = {
+    aliceblue: '#F0F8FF',
+    antiquewhite: '#FAEBD7',
+    aqua: '#00FFFF',
+    aquamarine: '#7FFFD4',
+    azure: '#F0FFFF',
+    beige: '#F5F5DC',
+    bisque: '#FFE4C4',
+    black: '#000000',
+    blanchedalmond: '#FFEBCD',
+    blue: '#0000FF',
+    blueviolet: '#8A2BE2',
+    brown: '#A52A2A',
+    burlywood: '#DEB887',
+    cadetblue: '#5F9EA0',
+    chartreuse: '#7FFF00',
+    chocolate: '#D2691E',
+    coral: '#FF7F50',
+    cornflowerblue: '#6495ED',
+    cornsilk: '#FFF8DC',
+    crimson: '#DC143C',
+    cyan: '#00FFFF',
+    darkblue: '#00008B',
+    darkcyan: '#008B8B',
+    darkgoldenrod: '#B8860B',
+    darkgray: '#A9A9A9',
+    darkgreen: '#006400',
+    darkgrey: '#A9A9A9',
+    darkkhaki: '#BDB76B',
+    darkmagenta: '#8B008B',
+    darkolivegreen: '#556B2F',
+    darkorange: '#FF8C00',
+    darkorchid: '#9932CC',
+    darkred: '#8B0000',
+    darksalmon: '#E9967A',
+    darkseagreen: '#8FBC8F',
+    darkslateblue: '#483D8B',
+    darkslategray: '#2F4F4F',
+    darkslategrey: '#2F4F4F',
+    darkturquoise: '#00CED1',
+    darkviolet: '#9400D3',
+    deeppink: '#FF1493',
+    deepskyblue: '#00BFFF',
+    dimgray: '#696969',
+    dimgrey: '#696969',
+    dodgerblue: '#1E90FF',
+    firebrick: '#B22222',
+    floralwhite: '#FFFAF0',
+    forestgreen: '#228B22',
+    fuchsia: '#FF00FF',
+    gainsboro: '#DCDCDC',
+    ghostwhite: '#F8F8FF',
+    gold: '#FFD700',
+    goldenrod: '#DAA520',
+    gray: '#808080',
+    green: '#008000',
+    greenyellow: '#ADFF2F',
+    grey: '#808080',
+    honeydew: '#F0FFF0',
+    hotpink: '#FF69B4',
+    indianred: '#CD5C5C',
+    indigo: '#4B0082',
+    ivory: '#FFFFF0',
+    khaki: '#F0E68C',
+    lavender: '#E6E6FA',
+    lavenderblush: '#FFF0F5',
+    lawngreen: '#7CFC00',
+    lemonchiffon: '#FFFACD',
+    lightblue: '#ADD8E6',
+    lightcoral: '#F08080',
+    lightcyan: '#E0FFFF',
+    lightgoldenrodyellow: '#FAFAD2',
+    lightgray: '#D3D3D3',
+    lightgreen: '#90EE90',
+    lightgrey: '#D3D3D3',
+    lightpink: '#FFB6C1',
+    lightsalmon: '#FFA07A',
+    lightseagreen: '#20B2AA',
+    lightskyblue: '#87CEFA',
+    lightslategray: '#778899',
+    lightslategrey: '#778899',
+    lightsteelblue: '#B0C4DE',
+    lightyellow: '#FFFFE0',
+    lime: '#00FF00',
+    limegreen: '#32CD32',
+    linen: '#FAF0E6',
+    magenta: '#FF00FF',
+    maroon: '#800000',
+    mediumaquamarine: '#66CDAA',
+    mediumblue: '#0000CD',
+    mediumorchid: '#BA55D3',
+    mediumpurple: '#9370DB',
+    mediumseagreen: '#3CB371',
+    mediumslateblue: '#7B68EE',
+    mediumspringgreen: '#00FA9A',
+    mediumturquoise: '#48D1CC',
+    mediumvioletred: '#C71585',
+    midnightblue: '#191970',
+    mintcream: '#F5FFFA',
+    mistyrose: '#FFE4E1',
+    moccasin: '#FFE4B5',
+    navajowhite: '#FFDEAD',
+    navy: '#000080',
+    oldlace: '#FDF5E6',
+    olive: '#808000',
+    olivedrab: '#6B8E23',
+    orange: '#FFA500',
+    orangered: '#FF4500',
+    orchid: '#DA70D6',
+    palegoldenrod: '#EEE8AA',
+    palegreen: '#98FB98',
+    paleturquoise: '#AFEEEE',
+    palevioletred: '#DB7093',
+    papayawhip: '#FFEFD5',
+    peachpuff: '#FFDAB9',
+    peru: '#CD853F',
+    pink: '#FFC0CB',
+    plum: '#DDA0DD',
+    powderblue: '#B0E0E6',
+    purple: '#800080',
+    rebeccapurple: '#663399',
+    red: '#FF0000',
+    rosybrown: '#BC8F8F',
+    royalblue: '#4169E1',
+    saddlebrown: '#8B4513',
+    salmon: '#FA8072',
+    sandybrown: '#F4A460',
+    seagreen: '#2E8B57',
+    seashell: '#FFF5EE',
+    sienna: '#A0522D',
+    silver: '#C0C0C0',
+    skyblue: '#87CEEB',
+    slateblue: '#6A5ACD',
+    slategray: '#708090',
+    slategrey: '#708090',
+    snow: '#FFFAFA',
+    springgreen: '#00FF7F',
+    steelblue: '#4682B4',
+    tan: '#D2B48C',
+    teal: '#008080',
+    thistle: '#D8BFD8',
+    tomato: '#FF6347',
+    turquoise: '#40E0D0',
+    violet: '#EE82EE',
+    wheat: '#F5DEB3',
+    white: '#FFFFFF',
+    whitesmoke: '#F5F5F5',
+    yellow: '#FFFF00',
+    yellowgreen: '#9ACD32',
+};
+// Object.hasOwn rather than a bare index: the table is a plain object, so
+// `colors.constructor` and `colors.toString` come back as functions typed
+// `string`, and isNamedColor('toString') was true.
+export function namedColorToHex(name) {
+    return Object.hasOwn(colors, name) ? colors[name] : undefined;
+}
+export function isNamedColor(name) {
+    return Object.hasOwn(colors, name);
+}
+export const CSS_COLOR_NAMES = Object.keys(colors);

package/dist/commands/validate/markRules/jexlStrings.js

@@ -0,0 +1,23 @@
+/** The `jexl:` prefix marks a config value as a deferred callback expression. */
+export const JEXL_PREFIX = 'jexl:';
+export function isJexl(str) {
+    return typeof str === 'string' && str.startsWith(JEXL_PREFIX);
+}
+/** Add the `jexl:` prefix unless the string already carries it. */
+export function ensureJexlPrefix(code) {
+    return isJexl(code) ? code : `${JEXL_PREFIX}${code}`;
+}
+/**
+ * Compile a `jexl:...` string to an Expression. The jexl instance caches
+ * compilation, so this only strips the prefix.
+ *
+ * @param str - string of code like `jexl:...`
+ * @param jexl - the instance whose registered functions the expression may call
+ *   (`pluginManager.jexl` on eval paths)
+ */
+export function stringToJexlExpression(str, jexl) {
+    if (!isJexl(str)) {
+        throw new Error('string does not appear to be in jexl format');
+    }
+    return jexl.compile(str.slice(JEXL_PREFIX.length));
+}