@jbrowse/core 5.0.0-beta.1 → 5.0.0-beta.11

package/esm/util/cellsStep.js

@@ -0,0 +1,437 @@
+// The `cells` step: each row's runs against the reference it was fanned out
+// of, and the texts its walk reads, which the fused identity kernel in
+// cellMatches.ts walks too. Imported by relative path only.
+import { DerivedTable, numberReaderOf, readerOf, valueAt, } from './featureTable.js';
+import { FannedTable, boundsThrough } from './stepTables.js';
+export const DEFAULT_CELLS_FIELD = 'seq';
+export const DASH = 45;
+export const SPACE = 32;
+const LOWER_BIT = 0x20;
+const CELL_STATES = ['match', 'mismatch', 'gap', 'insertion'];
+export const MATCH = 0;
+export const MISMATCH = 1;
+const GAP = 2;
+const INSERTION = 3;
+export const NO_STATE = 255;
+export function isGapByte(b) {
+    return b === DASH || b === SPACE;
+}
+// The columns carrying the row's own sequence: a gap run reaching either end
+// of the row measures where the block was cut, not the alignment, so it is no
+// cell either.
+export function firstDrawn(bytes, at, len) {
+    let first = 0;
+    while (first < len && isGapByte(bytes[at + first])) {
+        first++;
+    }
+    return first;
+}
+export function lastDrawn(bytes, at, len, first) {
+    let last = len - 1;
+    while (last > first && isGapByte(bytes[at + last])) {
+        last--;
+    }
+    return last;
+}
+// A reference base's cell: no state outside the drawn columns, else the row's
+// gap, or its base matched or not regardless of case.
+export function cellState(refByte, rowByte, drawn) {
+    return !drawn
+        ? NO_STATE
+        : isGapByte(rowByte)
+            ? GAP
+            : (refByte | LOWER_BIT) === (rowByte | LOWER_BIT)
+                ? MATCH
+                : MISMATCH;
+}
+// The row a cell step reads against: past any table that only reordered or
+// annotated the rows, the one they were fanned out of.
+function containerOf(table) {
+    let at = table;
+    let toBase;
+    while (at instanceof DerivedTable && !at.madeFrom) {
+        toBase = at.parentRow ? compose(toBase, at.parentRow) : toBase;
+        at = at.parent;
+    }
+    if (!(at instanceof DerivedTable)) {
+        return undefined;
+    }
+    return {
+        made: at,
+        toMade: toBase,
+        table: at.parent,
+        row: at.parentRow ? compose(toBase, at.parentRow) : toBase,
+    };
+}
+function compose(outer, inner) {
+    if (!outer) {
+        return inner;
+    }
+    const out = new Uint32Array(outer.length);
+    for (let i = 0; i < outer.length; i++) {
+        out[i] = inner[outer[i]];
+    }
+    return out;
+}
+// Below this length a character loop copies a string faster than
+// `encodeInto`, as the MAF packer measured.
+const ASCII_COPY_MAX_LENGTH = 64;
+const encoder = new TextEncoder();
+// A column's text as bytes, one per character: an adapter's own, or the
+// strings a feature holds copied into one buffer.
+function textOf(column, n) {
+    if (column.kind === 'text') {
+        return column;
+    }
+    const read = readerOf(column);
+    const texts = new Array(n);
+    let total = 0;
+    for (let i = 0; i < n; i++) {
+        const v = read(i);
+        if (typeof v === 'string') {
+            texts[i] = v;
+            total += v.length;
+        }
+    }
+    const bytes = new Uint8Array(total);
+    const offset = new Uint32Array(n);
+    const length = new Uint32Array(n);
+    let pos = 0;
+    for (let i = 0; i < n; i++) {
+        const text = texts[i];
+        if (text === undefined) {
+            continue;
+        }
+        offset[i] = pos;
+        if (text.length <= ASCII_COPY_MAX_LENGTH) {
+            for (let c = 0; c < text.length; c++) {
+                bytes[pos + c] = text.charCodeAt(c);
+            }
+            length[i] = text.length;
+        }
+        else {
+            length[i] = encoder.encodeInto(text, bytes.subarray(pos, pos + text.length)).written;
+        }
+        pos += text.length;
+    }
+    return { kind: 'text', bytes, offset, length, at: undefined };
+}
+/**
+ * The texts a `cells` walk reads, by the row of the table it walked: each
+ * row's own, and the reference it is read against, which a row fanned out of
+ * a container reads off the container.
+ */
+class WalkedTexts {
+    row;
+    reference;
+    refRow;
+    constructor(row, ref, refRow) {
+        this.row = row;
+        this.reference = ref;
+        this.refRow = refRow;
+    }
+    rowOf(r) {
+        const { at } = this.row;
+        return at ? at[r] : r;
+    }
+    refOf(r) {
+        const p = this.refRow ? this.refRow[r] : r;
+        const { at } = this.reference;
+        return at ? at[p] : p;
+    }
+}
+export function walkedTexts(table, field) {
+    const row = textOf(table.column(field), table.length);
+    const container = containerOf(table);
+    const made = container?.made;
+    if (container && !(made instanceof FannedTable && made.hasKept)) {
+        const { table: base } = container;
+        return new WalkedTexts(row, textOf(base.column(field), base.length), container.row);
+    }
+    // A container a flatten kept with nothing to fan out is the row itself, so
+    // its reference is its own container's, as its `parent()` says.
+    const byParent = (r) => table.row(r).parent?.()?.get(field);
+    const readContainer = container
+        ? readerOf(container.table.column(field))
+        : undefined;
+    const read = readContainer && made instanceof FannedTable
+        ? (r) => {
+            const { toMade, row: refRow } = container;
+            return made.isKept(toMade ? toMade[r] : r)
+                ? byParent(r)
+                : readContainer(refRow ? refRow[r] : r);
+        }
+        : byParent;
+    return new WalkedTexts(row, textOf({ kind: 'value', read }, table.length));
+}
+/**
+ * The runs a `cells` step answers, one per stretch of one state against the
+ * reference, typed: each run's span, its state and the text column it starts
+ * at, with `base`, `match` and `length` read back out of the texts when asked
+ * for.
+ */
+class CellTable extends DerivedTable {
+    start;
+    end;
+    state;
+    textAt;
+    texts;
+    firstOfRow;
+    derived = new Map();
+    constructor(parent, parentRow, lanes, texts) {
+        super(parent, parentRow);
+        this.start = lanes.start;
+        this.end = lanes.end;
+        this.state = lanes.state;
+        this.textAt = lanes.textAt;
+        this.texts = texts;
+    }
+    get madeFrom() {
+        return true;
+    }
+    laneOf(name, build) {
+        let column = this.derived.get(name);
+        if (!column) {
+            column = build();
+            this.derived.set(name, column);
+        }
+        return column;
+    }
+    own(name) {
+        switch (name) {
+            case 'start': {
+                return { kind: 'number', values: this.start, at: undefined };
+            }
+            case 'end': {
+                return { kind: 'number', values: this.end, at: undefined };
+            }
+            case 'state': {
+                return {
+                    kind: 'category',
+                    codes: this.state,
+                    labels: CELL_STATES,
+                    at: undefined,
+                };
+            }
+            case 'match': {
+                return this.laneOf(name, () => {
+                    const values = new Float32Array(this.length);
+                    for (let i = 0; i < this.length; i++) {
+                        const s = this.state[i];
+                        values[i] = s === MATCH ? 1 : s === MISMATCH ? 0 : Number.NaN;
+                    }
+                    return { kind: 'number', values, at: undefined, nanIsAbsent: true };
+                });
+            }
+            case 'length': {
+                return this.laneOf(name, () => {
+                    const values = new Float32Array(this.length).fill(Number.NaN);
+                    for (let i = 0; i < this.length; i++) {
+                        if (this.state[i] === INSERTION) {
+                            values[i] = this.inserted(i).length;
+                        }
+                    }
+                    return { kind: 'number', values, at: undefined, nanIsAbsent: true };
+                });
+            }
+            case 'base': {
+                return this.laneOf(name, () => {
+                    const values = new Array(this.length);
+                    for (let i = 0; i < this.length; i++) {
+                        const s = this.state[i];
+                        values[i] =
+                            s === MISMATCH
+                                ? this.mismatched(i)
+                                : s === INSERTION
+                                    ? this.inserted(i)
+                                    : undefined;
+                    }
+                    return { kind: 'value', read: i => values[i] };
+                });
+            }
+            default: {
+                return undefined;
+            }
+        }
+    }
+    mismatched(i) {
+        const { bytes, offset } = this.texts.row;
+        const k = this.texts.rowOf(this.parentOf(i));
+        return String.fromCharCode(bytes[offset[k] + this.textAt[i]]);
+    }
+    // The bases a row holds where the reference has none, from the column the
+    // insertion starts at to the reference's next base.
+    inserted(i) {
+        const { row, reference: ref } = this.texts;
+        const r = this.parentOf(i);
+        const k = this.texts.rowOf(r);
+        const f = this.texts.refOf(r);
+        const rowAt = row.offset[k];
+        const refAt = ref.offset[f];
+        const end = Math.min(row.length[k], ref.length[f]);
+        let out = '';
+        for (let col = this.textAt[i]; col < end && ref.bytes[refAt + col] === DASH; col++) {
+            const b = row.bytes[rowAt + col];
+            if (!isGapByte(b)) {
+                out += String.fromCharCode(b);
+            }
+        }
+        return out;
+    }
+    id(i) {
+        const p = this.parentOf(i);
+        this.firstOfRow ??= firstRowIndex(this.parentRow, this.parent.length);
+        return `${this.parent.row(p).id()}#${i - this.firstOfRow[p]}`;
+    }
+    json(i) {
+        const out = {
+            ...this.parent.row(this.parentOf(i)).toJSON(),
+            start: this.start[i],
+            end: this.end[i],
+            state: CELL_STATES[this.state[i]],
+        };
+        for (const name of ['base', 'match', 'length']) {
+            const v = valueAt(this.column(name), i);
+            if (v !== undefined) {
+                out[name] = v;
+            }
+        }
+        return out;
+    }
+}
+// The lanes a `cells` walk writes, doubled as a row would overrun them.
+class RunLanes {
+    start;
+    end;
+    state;
+    textAt;
+    parentRow;
+    length = 0;
+    constructor(capacity) {
+        this.start = new Uint32Array(capacity);
+        this.end = new Uint32Array(capacity);
+        this.state = new Uint8Array(capacity);
+        this.textAt = new Uint32Array(capacity);
+        this.parentRow = new Uint32Array(capacity);
+    }
+    reserve(more) {
+        const need = this.length + more;
+        if (need <= this.start.length) {
+            return;
+        }
+        const size = Math.max(this.start.length * 2, need);
+        const widen = (a) => {
+            const next = new a.constructor(size);
+            next.set(a);
+            return next;
+        };
+        this.start = widen(this.start);
+        this.end = widen(this.end);
+        this.state = widen(this.state);
+        this.textAt = widen(this.textAt);
+        this.parentRow = widen(this.parentRow);
+    }
+    // One row's runs against its reference: a run per column is the most it
+    // can answer, so the lanes grow once and the walk writes through locals.
+    walk(r, startPos, rowBytes, rowAt, rowLen, refBytes, refAt, refLen) {
+        this.reserve(refLen + 1);
+        const { start, end, state, textAt, parentRow } = this;
+        let n = this.length;
+        let pos = startPos;
+        const first = firstDrawn(rowBytes, rowAt, rowLen);
+        const last = lastDrawn(rowBytes, rowAt, rowLen, first);
+        let runStart = -1;
+        let runState = NO_STATE;
+        let runBase = -1;
+        let runCol = 0;
+        let insertAt = -1;
+        for (let col = 0; col < refLen; col++) {
+            const refByte = refBytes[refAt + col];
+            const rowByte = col < rowLen ? rowBytes[rowAt + col] : SPACE;
+            if (refByte === DASH) {
+                if (insertAt < 0 && col < rowLen && !isGapByte(rowByte)) {
+                    insertAt = col;
+                }
+                continue;
+            }
+            if (insertAt >= 0) {
+                start[n] = pos;
+                end[n] = pos;
+                state[n] = INSERTION;
+                textAt[n] = insertAt;
+                parentRow[n] = r;
+                n++;
+                insertAt = -1;
+            }
+            const st = cellState(refByte, rowByte, col >= first && col <= last && col < rowLen);
+            const base = st === MISMATCH ? rowByte : -1;
+            if (st !== runState || base !== runBase) {
+                if (runStart >= 0) {
+                    start[n] = runStart;
+                    end[n] = pos;
+                    state[n] = runState;
+                    textAt[n] = runCol;
+                    parentRow[n] = r;
+                    n++;
+                }
+                runStart = st === NO_STATE ? -1 : pos;
+                runState = st;
+                runBase = base;
+                runCol = col;
+            }
+            pos++;
+        }
+        if (runStart >= 0) {
+            start[n] = runStart;
+            end[n] = pos;
+            state[n] = runState;
+            textAt[n] = runCol;
+            parentRow[n] = r;
+            n++;
+        }
+        this.length = n;
+    }
+}
+// Where each parent row's children start, for children written parent by
+// parent in order.
+function firstRowIndex(parentRow, parents) {
+    const first = new Uint32Array(parents);
+    for (let i = parentRow.length - 1; i >= 0; i--) {
+        first[parentRow[i]] = i;
+    }
+    return first;
+}
+export function cells({ table, bounds }, step) {
+    const { field = DEFAULT_CELLS_FIELD } = step;
+    const texts = walkedTexts(table, field);
+    const readStart = numberReaderOf(table.column('start'));
+    const { bytes: rowBytes, offset: rowOffset, length: rowLength } = texts.row;
+    const { bytes: refBytes, offset: refOffset, length: refLength, } = texts.reference;
+    // A run per reference base is the most a row can answer and far past what
+    // one does, so the lanes start at an eighth of it.
+    let bound = 0;
+    for (let r = 0; r < table.length; r++) {
+        bound += refLength[texts.refOf(r)] + 1;
+    }
+    const lanes = new RunLanes(Math.max(1024, bound >>> 3));
+    for (let r = 0; r < table.length; r++) {
+        const f = texts.refOf(r);
+        const refLen = refLength[f];
+        const pos = readStart(r);
+        if (refLen > 0 && pos >= 0) {
+            const k = texts.rowOf(r);
+            lanes.walk(r, pos, rowBytes, rowOffset[k], rowLength[k], refBytes, refOffset[f], refLen);
+        }
+    }
+    const n = lanes.length;
+    const rows = lanes.parentRow.subarray(0, n);
+    return {
+        table: new CellTable(table, rows, {
+            start: lanes.start.subarray(0, n),
+            end: lanes.end.subarray(0, n),
+            state: lanes.state.subarray(0, n),
+            textAt: lanes.textAt.subarray(0, n),
+        }, texts),
+        bounds: boundsThrough(bounds, rows),
+    };
+}

package/esm/util/clampToContig.d.ts

@@ -24,3 +24,20 @@ export declare function clampToContig(assembly: Assembly, region: {
     start: number;
     end: number;
 }): Region | undefined;
+/**
+ * `clampToContig` for a refName that may not be on the assembly at all, which
+ * is the shape a location nobody requested arrives in — a BAM's `nextRef`, an
+ * SA record's contig (REFNAME_NAMESPACES.md). `clampToContig` alone passes an
+ * unknown name through with nothing to clamp against, so it cannot tell "past
+ * the end of a contig we have" from "a contig we do not have", and both callers
+ * need that apart to say which happened.
+ */
+export declare function clampToListedContig(assembly: Assembly, region: {
+    refName: string;
+    start: number;
+    end: number;
+}): {
+    refName: string;
+    onAssembly: boolean;
+    region: Region | undefined;
+};

package/esm/util/clampToContig.js

@@ -26,3 +26,22 @@ export function clampToContig(assembly, region) {
         ? { ...region, assemblyName: assembly.name, refName, start, end }
         : undefined;
 }
+/**
+ * `clampToContig` for a refName that may not be on the assembly at all, which
+ * is the shape a location nobody requested arrives in — a BAM's `nextRef`, an
+ * SA record's contig (REFNAME_NAMESPACES.md). `clampToContig` alone passes an
+ * unknown name through with nothing to clamp against, so it cannot tell "past
+ * the end of a contig we have" from "a contig we do not have", and both callers
+ * need that apart to say which happened.
+ */
+export function clampToListedContig(assembly, region) {
+    const refName = assembly.getCanonicalRefName2(region.refName);
+    const onAssembly = assembly.getRegionForRefName(refName) !== undefined;
+    return {
+        refName,
+        onAssembly,
+        region: onAssembly
+            ? clampToContig(assembly, { ...region, refName })
+            : undefined,
+    };
+}

package/esm/util/coarseStripHTML.js

@@ -1,5 +1,4 @@
-// not a sanitizer, this just removes html tags for use in measureText-based
-// element width calculations
+// not a sanitizer, this just removes html tags where only the text is shown
 export function coarseStripHTML(s) {
     return s.replaceAll(/<[^<>]*>/g, '');
 }

package/esm/util/color/cssColorsLevel4.d.ts

@@ -1,2 +1,3 @@
 export declare function namedColorToHex(name: string): string | undefined;
 export declare function isNamedColor(name: string): boolean;
+export declare const CSS_COLOR_NAMES: readonly string[];

package/esm/util/color/cssColorsLevel4.js

@@ -158,3 +158,4 @@ export function namedColorToHex(name) {
 export function isNamedColor(name) {
     return Object.hasOwn(colors, name);
 }
+export const CSS_COLOR_NAMES = Object.keys(colors);

package/esm/util/color/index.d.ts

@@ -20,7 +20,9 @@ export declare function emphasize(color: string, coefficient?: number): string;
  * default refName colors.
  */
 export declare function makeContrasting(foreground: string, background?: string, minContrastRatio?: number): string;
-export { isNamedColor, namedColorToHex } from './cssColorsLevel4.ts';
+export { CSS_COLOR_NAMES, isNamedColor, namedColorToHex, } from './cssColorsLevel4.ts';
+export declare const NO_CATEGORY_COLOR = "#afafaf";
+export declare const MISCONFIGURED_COLOR = "#808080";
 /**
  * #api
  * Move a color's OKLCH lightness by `lightnessShift` and scale its chroma,
@@ -69,8 +71,8 @@ export declare function relight(color: string, lightnessShift: number, chromaSca
  *
  * A value that is absent gets NO_CATEGORY_COLOR rather than a hue, and that is
  * the difference between this being usable on real data and not. The everyday
- * caller is the Color-by-attribute dialog, which writes
- * `jexl:randomColor(get(feature,'<attr>'))` over a whole track — and most files
+ * caller is a `jexl:randomColor(get(feature,'<attr>'))` color slot over a
+ * whole track — and most files
  * have the attribute on some features and not others, so most of the time this
  * is handed `undefined`. It used to throw on that (`str.length` of undefined),
  * once per feature, and what a reader saw was every unlabelled feature in one

package/esm/util/color/index.js

@@ -72,7 +72,7 @@ export function makeContrasting(foreground, background = 'white', minContrastRat
     }
     return best;
 }
-export { isNamedColor, namedColorToHex } from './cssColorsLevel4.js';
+export { CSS_COLOR_NAMES, isNamedColor, namedColorToHex, } from './cssColorsLevel4.js';
 // The (lightness, chroma) tiers randomColor picks between, in OKLCH. Values are
 // in the band a hand-built categorical palette occupies — bright enough to tell
 // apart, dark enough that black text over one still reads, and never near
@@ -81,7 +81,10 @@ export { isNamedColor, namedColorToHex } from './cssColorsLevel4.js';
 // What a value-less feature is painted. Neutral and unsaturated on purpose: it
 // has to read as "not in a category" beside a palette whose every member is
 // equally light and equally colorful, so it cannot be one more hue.
-const NO_CATEGORY_COLOR = '#afafaf';
+export const NO_CATEGORY_COLOR = '#afafaf';
+// What a colour declaration paints where it reads nothing it can colour, so a
+// misconfiguration surfaces rather than passing for the no-category grey.
+export const MISCONFIGURED_COLOR = '#808080';
 const RANDOM_COLOR_TIERS = [
     { lightness: 0.66, chroma: 0.15 },
     { lightness: 0.56, chroma: 0.14 },
@@ -175,8 +178,8 @@ export function relight(color, lightnessShift, chromaScale = 1) {
  *
  * A value that is absent gets NO_CATEGORY_COLOR rather than a hue, and that is
  * the difference between this being usable on real data and not. The everyday
- * caller is the Color-by-attribute dialog, which writes
- * `jexl:randomColor(get(feature,'<attr>'))` over a whole track — and most files
+ * caller is a `jexl:randomColor(get(feature,'<attr>'))` color slot over a
+ * whole track — and most files
  * have the attribute on some features and not others, so most of the time this
  * is handed `undefined`. It used to throw on that (`str.length` of undefined),
  * once per feature, and what a reader saw was every unlabelled feature in one

package/esm/util/colorBits.d.ts

@@ -1,5 +1,7 @@
-import type { Color } from './color-bits/index.ts';
+import { abgrToCssRgba } from '@jbrowse/render-core/marks/colorFill';
 import type { Feature } from './simpleFeature.ts';
+export { abgrToCssRgba };
+export { isCssColor, parseCssColorOr } from './cssColorParse.ts';
 export { alpha, blend, darken, formatHEX, formatHEXA, formatRGBA, getAlpha, getBlue, getGreen, getLuminance, getRed, lighten, newColor, parse, toHSLA, toRGBA, } from './color-bits/index.ts';
 export type { Color } from './color-bits/index.ts';
 /**
@@ -17,7 +19,6 @@ export declare function featureItemRgb(raw: unknown): string | undefined;
  * undefined if it declares none.
  */
 export declare function featureBedColor(feature: Feature): string | undefined;
-export declare function parseCssColorOr(color: string, fallback: Color): Color;
 export declare function parseCssColor(color: string | undefined | null): number;
 export declare function cssColorToNormalizedRgb(color: string): [number, number, number];
 export declare function cssColorToRgb(color: string): [number, number, number];
@@ -35,5 +36,4 @@ export declare function abgrRed(c: number): number;
 export declare function abgrGreen(c: number): number;
 export declare function abgrBlue(c: number): number;
 export declare function abgrAlpha(c: number): number;
-export declare function abgrToCssRgba(c: number): string;
 export declare function cssColorToNormalizedRgba(color: string): [number, number, number, number];

package/esm/util/colorBits.js

@@ -1,5 +1,8 @@
-import { getAlpha, getBlue, getGreen, getRed, newColor, parse, } from './color-bits/index.js';
-import { namedColorToHex } from './color/cssColorsLevel4.js';
+import { abgrToCssRgba } from '@jbrowse/render-core/marks/colorFill';
+import { getAlpha, getBlue, getGreen, getRed, newColor, } from './color-bits/index.js';
+import { bedTriple, parseCssColorOr } from './cssColorParse.js';
+export { abgrToCssRgba };
+export { isCssColor, parseCssColorOr } from './cssColorParse.js';
 export { alpha, blend, darken, formatHEX, formatHEXA, formatRGBA, getAlpha, getBlue, getGreen, getLuminance, getRed, lighten, newColor, parse, toHSLA, toRGBA, } from './color-bits/index.js';
 // Magenta sentinel for invalid input. User-written jexl color callbacks can
 // legitimately return undefined (e.g. when a feature lacks the field they
@@ -7,10 +10,6 @@ export { alpha, blend, darken, formatHEX, formatHEXA, formatRGBA, getAlpha, getB
 // Returning magenta makes the bad slot visually obvious without breaking the
 // rest of the render.
 const INVALID_COLOR = newColor(255, 0, 255, 255);
-// A bare BED color triple ("255,0,0"), which is not a CSS color but is what
-// BED-family adapters put on the feature verbatim. The spec has no spaces, but
-// tolerate them rather than silently ignoring an otherwise-usable color.
-const BED_TRIPLE = /^(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})$/;
 // UCSC's convention is that a color of "0" means "no color specified", and plain
 // BED12 files fill the column with that placeholder (often spelled as the
 // all-zero triple) rather than omitting it — every itemRgb in our own
@@ -18,17 +17,6 @@ const BED_TRIPLE = /^(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})$/;
 // ordinary BED12 track solid black, so read them as absent. A file that really
 // wants black can say so with an explicit `color` slot.
 const BED_TRIPLE_UNSET = /^0(,0,0)?$/;
-/**
- * Normalize a bare BED color triple to canonical "r,g,b", or undefined if the
- * string isn't one. Each component must be in range: the underlying parser
- * masks to 8 bits, so a bogus "999,0,0" would otherwise *wrap* to 231 and paint
- * a plausible-looking but wrong color rather than being caught.
- */
-function bedTriple(str) {
-    const m = BED_TRIPLE.exec(str.trim());
-    const rgb = m?.slice(1, 4).map(Number);
-    return rgb?.every(n => n <= 255) ? rgb.join(',') : undefined;
-}
 /**
  * One raw attribute value as a usable BED color, or undefined when it isn't
  * one. Deliberately strict: this feeds an *automatic* coloring path, so a value
@@ -73,27 +61,6 @@ export function featureBedColor(feature) {
     }
     return found;
 }
-// Resolve a CSS color string to a Color: honors named colors, `transparent`,
-// and bare BED color triples, and returns `fallback` on malformed-but-nonempty
-// input. `parse` throws on e.g. an empty "rgb()"; callers pass a fallback so one
-// bad per-feature color can't crash a whole render/RPC. An out-of-range triple
-// is left to throw into `fallback` (magenta) rather than wrapping to a wrong
-// color — the same rule featureItemRgb applies, so a jexl callback reading an
-// itemRgb column and the automatic path agree on what counts as a color.
-export function parseCssColorOr(color, fallback) {
-    const str = color.trim().toLowerCase();
-    if (str === 'transparent') {
-        return newColor(0, 0, 0, 0);
-    }
-    try {
-        const hex = namedColorToHex(str);
-        const triple = bedTriple(str);
-        return parse(hex ? hex : triple ? `rgb(${triple})` : str);
-    }
-    catch {
-        return fallback;
-    }
-}
 export function parseCssColor(color) {
     if (typeof color !== 'string' || color.length === 0) {
         return INVALID_COLOR;
@@ -118,9 +85,22 @@ export function cssColorToRgba(color) {
 export function packAbgr(r, g, b, a) {
     return ((a << 24) | (b << 16) | (g << 8) | r) >>> 0;
 }
+// A packer resolves the same few strings once per primitive, so the parse is
+// cached by string. Capped, because BED itemRgb triples are unbounded.
+const ABGR_CACHE_LIMIT = 4096;
+const abgrByCss = new Map();
 export function cssColorToABGR(color) {
+    const cached = abgrByCss.get(color);
+    if (cached !== undefined) {
+        return cached;
+    }
     const c = parseCssColor(color);
-    return packAbgr(getRed(c), getGreen(c), getBlue(c), getAlpha(c));
+    const packed = packAbgr(getRed(c), getGreen(c), getBlue(c), getAlpha(c));
+    if (abgrByCss.size >= ABGR_CACHE_LIMIT) {
+        abgrByCss.clear();
+    }
+    abgrByCss.set(color, packed);
+    return packed;
 }
 // Replace the alpha byte of an ABGR-packed u32, keeping its RGB. RGB already
 // occupies the low 24 bits (b<<16 | g<<8 | r), so this is a mask + or — no
@@ -143,7 +123,6 @@ export function normalizedRgbToCss(c) {
 export function normalizedRgbToCssRgba(c, alpha) {
     return `rgba(${Math.round(c[0] * 255)},${Math.round(c[1] * 255)},${Math.round(c[2] * 255)},${alpha})`;
 }
-// Set fillStyle from an ABGR-packed u32.
 export function setAbgrFill(ctx, c) {
     ctx.fillStyle = abgrToCssRgba(c);
 }
@@ -165,10 +144,6 @@ export function abgrBlue(c) {
 export function abgrAlpha(c) {
     return (c >>> 24) & 0xff;
 }
-// Format an ABGR-packed u32 as a CSS rgba() string.
-export function abgrToCssRgba(c) {
-    return `rgba(${abgrRed(c)},${abgrGreen(c)},${abgrBlue(c)},${abgrAlpha(c) / 255})`;
-}
 export function cssColorToNormalizedRgba(color) {
     const c = parseCssColor(color);
     return [