@tangram.gl/tangram-renderer 0.0.0-stage → 0.0.0

package/src/labels/collision.ts

@@ -0,0 +1,273 @@
+// Tangram
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2013-2016 Brett Camper and Mapzen
+// Copyright (c) 2026 vis.gl contributors
+
+import Label from './label';
+import RepeatGroup from './repeat_group';
+import CollisionGrid from './collision_grid';
+import log from '../utils/log';
+import type {CollisionObject, CollisionTileState, PendingCollisionObject} from './collision-types';
+
+const Collision = {
+
+    /** Started tile batches, removed after completion or abort. */
+    tiles: {} as Partial<Record<string, CollisionTileState>>,
+    /** Optional spatial index; null uses each tile's placed bounds. */
+    grid: null as CollisionGrid | null, // no collision grid by default
+
+    /** Select grid-based or tile-wide collision testing. */
+    initGrid (options?: {anchor: {x: number; y: number}; span: number} | null): void {
+        if (options == null) {
+            this.grid = null;
+        }
+        else {
+            this.grid = new CollisionGrid(options.anchor, options.span);
+        }
+    },
+
+    /** Initialize a batch before registering/submitting its contributing styles. */
+    startTile (tile: string | number, { apply_repeat_groups = true, return_hidden = false }: {
+        apply_repeat_groups?: boolean; return_hidden?: boolean
+    } = {}): void {
+        let state: CollisionTileState = this.tiles[tile] = {
+            bboxes: {           // current set of placed bounding boxes
+                aabb: [],
+                obb: []
+            },
+            objects: {},        // objects to collide, grouped by priority, then by style
+            labels: {},         // objects post-collision, grouped by style, marked as show/hide
+            styles: {},         // styles contributing collision objects
+            repeat: apply_repeat_groups,
+            return_hidden
+        };
+
+        // Promise resolved when all registered styles have added objects
+        if (state.complete == null) {
+            state.complete = new Promise<void | CollisionObject[]>((resolve, reject) => {
+                state.resolve = resolve;
+                state.reject = reject;
+            });
+        }
+    },
+
+    /** Drop all collision state for a completed or abandoned tile. */
+    resetTile (tile: string | number | undefined): void {
+        delete this.tiles[String(tile)];
+    },
+
+    /** Resolve pending consumers before removing an abandoned batch. */
+    abortTile (tile: string | number | undefined): void {
+        const key = String(tile);
+        if (this.tiles[key] && this.tiles[key].resolve) {
+            this.tiles[key].resolve([]);
+        }
+        this.resetTile(tile);
+    },
+
+    // Add a style to the pending set, collision will block on all styles submitting to collision set
+    /** Register a contributor on an already-started tile. */
+    addStyle (style: string, tile: string): void {
+        this.tiles[tile]!.styles[style] = true;
+    },
+
+    // Add collision objects for a style
+    /** Submit one style and return the same containers, retaining their payload types. */
+    collide<T extends CollisionObject> (objects: readonly T[], style: string, tile: string): Promise<T[]> {
+        let state = this.tiles[tile];
+        if (!state) {
+            log('trace', 'Collision.collide() called with null tile', tile, this.tiles, style, objects);
+            return Promise.resolve([]);
+        }
+
+        // Group by priority and style
+        let tile_objects = state.objects;
+        for (let i=0; i < objects.length; i++) {
+            let obj = objects[i];
+            let priority = obj.label.layout.priority;
+            tile_objects[priority] = tile_objects[priority] || {};
+            tile_objects[priority][style] = tile_objects[priority][style] || [];
+            tile_objects[priority][style].push(obj);
+        }
+
+        // Remove from pending style set, if no more styles, do collision & finish tile
+        delete state.styles[style];
+        if (Object.keys(state.styles).length === 0) {
+            this.endTile(tile);
+        }
+
+        // Wait for objects to be added from all styles
+        return state.complete!.then(() => {
+            state.resolve = null;
+            // Each style's result contains only containers submitted by that style.
+            return state.labels[style] as T[] || [];
+        });
+    },
+
+    // Test labels for collisions, higher to lower priority
+    // When two collide, hide the lower-priority label
+    /** Resolve an already-started batch in priority/style submission order. */
+    endTile (tile: string): void {
+        let state = this.tiles[tile]!;
+        let labels = state.labels;
+
+        if (this.grid) {
+            this.addLabelsToGrid(tile);
+        }
+
+        if (state.repeat) {
+            RepeatGroup.clear(tile);
+        }
+
+        // Process labels by priority, then by style
+        let priorities = Object.keys(state.objects).sort((a, b) => Number(a) - Number(b));
+        for (let p=0; p < priorities.length; p++) {
+            let style_objects = state.objects[priorities[p]];
+            if (!style_objects) { // no labels at this priority, skip to next
+                continue;
+            }
+
+            // For each style
+            for (let style in style_objects) {
+                let objects = style_objects[style];
+                labels[style] = labels[style] || [];
+
+                for (let i = 0; i < objects.length; i++) {
+                    let object = objects[i];
+                    if (object.linked && !isPreparedCollisionObject(object.linked)) throw new TypeError('Collision partner has not completed label preparation');
+                    if (this.canBePlaced(object, tile, object.linked, state)) {
+                        // show object if it isn't dependent on a parent object
+                        if (!object.linked) {
+                            object.show = true;
+                            labels[style].push(object);
+                            this.place(object, tile, state);
+                        }
+                        // If object is dependent on a parent, only show if both can be placed
+                        else if (this.canBePlaced(object.linked, tile, object, state)) {
+                            object.show = true;
+
+                            // If a label is breach, its linked label should be considered breach as well
+                            // (this keeps linked labels (in)visible in tandem)
+                            if (object.label.breach || object.linked.label.breach) {
+                                object.label.breach = true;
+                                object.linked.label.breach = true;
+                            }
+
+                            // Similarly for labels that need main thread repeat culling, keep linked labels in sync
+                            if (object.label.may_repeat_across_tiles || object.linked.label.may_repeat_across_tiles) {
+                                object.label.may_repeat_across_tiles = true;
+                                object.linked.label.may_repeat_across_tiles = true;
+                            }
+
+                            labels[style].push(object);
+                            this.place(object, tile, state);
+                            this.place(object.linked, tile, state);
+                        }
+                        else if (state.return_hidden) {
+                            object.show = false;
+                            labels[style].push(object);
+                        }
+                    }
+                    else if (state.return_hidden) {
+                        object.show = false;
+                        labels[style].push(object);
+                    }
+                }
+            }
+        }
+
+        delete this.tiles[tile];
+        state.resolve!();
+    },
+
+    /** Index candidates after grid initialization and before placement starts. */
+    addLabelsToGrid (tile_id: string): void {
+        // Process labels by priority, then by style
+        const tile = this.tiles[tile_id]!;
+        for (const priority in tile.objects) {
+            const style_objects = tile.objects[priority];
+            if (!style_objects) { // no labels at this priority, skip to next
+                continue;
+            }
+
+            // For each style
+            for (const style in style_objects) {
+                const objects = style_objects[style];
+                objects.forEach(object => this.grid!.addLabel(object.label));
+            }
+        }
+    },
+
+    // Run collision and repeat check to see if label can currently be placed
+    /** Check a candidate, preserving previously resolved placement outcomes. */
+    canBePlaced (object: CollisionObject, tile: string, exclude: PendingCollisionObject | null | 0 | '' = null, { repeat = true }: {repeat?: boolean} = {}): boolean | null | undefined {
+        let label = object.label;
+        let layout = object.label.layout;
+
+        // Skip if already processed (e.g. by parent object)
+        if (label.placed != null) {
+            return label.placed;
+        }
+
+        let placeable = !layout.collide;
+        if (!placeable) {
+            // Test the label for intersections with other labels
+            if (this.grid && label.cells) {
+                // test label candidate against labels placed in each grid cell
+                placeable = label.cells.reduce((keep, cell) => {
+                    if (keep && label.discard(cell, (exclude && exclude.label) ?? null)) {
+                        keep = false;
+                    }
+                    return keep;
+                }, true);
+            }
+            else {
+                placeable = !label.discard(this.tiles[tile]!.bboxes, (exclude && exclude.label) ?? null);
+            }
+        }
+
+        if (placeable) {
+            // repeat culling with nearby labels
+            if (repeat && RepeatGroup.check(label, layout, tile)) {
+                label.placed = false;
+            }
+            else {
+                return true;
+            }
+        }
+        else if (layout.collide) {
+            // log('trace', `hide label '${label.text}' due to collision`);
+            label.placed = false;
+        }
+        return label.placed;
+    },
+
+    // Place label
+    /** Register a candidate once, after its dependency and repeat checks succeed. */
+    place ({ label }: CollisionObject, tile: string, { repeat = true }: {repeat?: boolean}): void {
+        // Skip if already processed (e.g. by parent object)
+        if (label.placed != null) {
+            return;
+        }
+
+        // Register as placed for future collision and repeat culling
+        if (repeat) {
+            RepeatGroup.add(label, label.layout, tile);
+        }
+
+        if (this.grid && label.cells) {
+            label.cells.forEach(cell => Label.add(label, cell));
+        }
+        else {
+            Label.add(label, this.tiles[tile]!.bboxes);
+        }
+    }
+
+};
+
+export default Collision;
+
+/** Linked text may queue before measurement, but placement requires its concrete label. */
+function isPreparedCollisionObject(object: PendingCollisionObject): object is CollisionObject {
+    return object.label !== undefined;
+}

package/src/labels/collision_grid.ts

@@ -0,0 +1,61 @@
+// Tangram
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2013-2016 Brett Camper and Mapzen
+// Copyright (c) 2026 vis.gl contributors
+
+import type {CollisionBounds} from './collision-types';
+/** Grid origin in Tangram's negative-Y tile coordinate system. */
+type Anchor = {x: number; y: number};
+/** Geometry required to assign a candidate's single or multiple collision boxes. */
+type LabelLike = {aabb?: number[] | null; aabbs?: number[][]; cells?: CollisionBounds[]};
+/** Spatial index sharing placed-label bounds between overlapping candidates. */
+export default class CollisionGrid {
+    /** Coordinate origin used for cell indexing. */
+    anchor: Anchor;
+    /** Cell size in the same units as candidate bounds. */
+    span: number;
+    /** Rows and columns containing placed-label bounds. */
+    cells: Record<number, Record<number, CollisionBounds>>;
+
+    /** Create an empty grid anchored in the current collision coordinate system. */
+    constructor (anchor: Anchor, span: number) {
+        this.anchor = anchor;
+        this.span = span;
+        this.cells = {};
+    }
+
+    /** Assign candidate bounds to grid cells without placing the candidate. */
+    addLabel (label: LabelLike): void {
+        if (label.aabb) {
+            this.addLabelBboxes(label, label.aabb);
+        }
+
+        if (label.aabbs) {
+            label.aabbs.forEach(aabb => this.addLabelBboxes(label, aabb));
+        }
+    }
+
+    /** Index one box, retaining the existing per-box candidate-cell assignment. */
+    addLabelBboxes (label: LabelLike, aabb: number[]): void {
+        // min/max cells that the label falls into
+        // keep grid coordinates at zero or above so any labels that go "below" the anchor are in the lowest grid cell
+        const cell_bounds = [
+            Math.max(Math.floor((aabb[0] - this.anchor.x) / this.span), 0),
+            Math.max(Math.floor(-(aabb[1] - this.anchor.y) / this.span), 0),
+            Math.max(Math.floor((aabb[2] - this.anchor.x) / this.span), 0),
+            Math.max(Math.floor(-(aabb[3] - this.anchor.y) / this.span), 0)
+        ];
+
+        label.cells = []; // label knows which cells it falls in
+
+        // initialize each grid cell as necessary, and add to label's list of cells
+        for (let gy = cell_bounds[1]; gy <= cell_bounds[3]; gy++) {
+            this.cells[gy] = this.cells[gy] || {};
+            for (let gx = cell_bounds[0]; gx <= cell_bounds[2]; gx++) {
+                this.cells[gy][gx] = this.cells[gy][gx] || { aabb: [], obb: [] };
+                label.cells.push(this.cells[gy][gx]);
+            }
+        }
+    }
+
+}

package/src/labels/intersect.ts

@@ -0,0 +1,30 @@
+// Tangram
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2013-2016 Brett Camper and Mapzen
+// Copyright (c) 2026 vis.gl contributors
+
+type BoundingBox = [number, number, number, number];
+
+// Do AABB `a` and `b` intersect?
+export function boxIntersectsBox (a: BoundingBox, b: BoundingBox): boolean {
+    if (a[2] < b[0] || // a is left of b
+        a[0] > b[2] || // a is right of b
+        a[3] < b[1] || // a is above b
+        a[1] > b[3]) { // a is below b
+        return false;
+    }
+    return true; // boxes overlap
+}
+
+// Does AABB `a` intersect any of the AABBs in array `boxes`?
+// Invokes `callback` with index of intersecting box
+// Stops intersecting if `callback` returns non-null value (continues otherwise)
+export function boxIntersectsList (a: BoundingBox, boxes: BoundingBox[], callback: (index: number) => unknown): void {
+    for (let i=0; i < boxes.length; i++) {
+        if (boxIntersectsBox(a, boxes[i])) {
+            if (callback(i) != null) {
+                break;
+            }
+        }
+    }
+}

package/src/labels/label-types.ts

@@ -0,0 +1,91 @@
+// tangram-layers
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {CollisionLayout} from './collision-types';
+import type OBB from '../utils/obb';
+
+/** Mutable pixel or tile-coordinate pair. */
+export type LabelPointCoordinate = [number, number];
+
+/** Normalized layout supplied by point/text styles before label construction. */
+export interface LabelLayout extends CollisionLayout {
+    /** Screen-space collision policy deferred until projected cameras are known. */
+    projected_collide?: boolean;
+    /** Source/style/feature identity for buffered copies, absent for anonymous points. */
+    projected_identity?: string;
+    /** Quantized physical anchor height in meters; omitted for nonprojected labels. */
+    projected_height?: number;
+    /** Pixel offset before geographic scaling. */
+    offset: LabelPointCoordinate;
+    /** Collision padding in pixels. */
+    buffer: LabelPointCoordinate;
+    /** Tile units per screen pixel. */
+    units_per_pixel: number;
+    /** Candidate point anchors, tried in order. */
+    anchor?: string | string[];
+    /** Canvas text alignment override. */
+    align?: string;
+    /** Extra collision width for non-normal fonts. */
+    italic?: boolean;
+    /** Point label carrying an attached text label. */
+    parent?: LabelParent;
+    /** Maximum line-placement subdivisions. */
+    subdiv?: number;
+    /** Raster padding excluded from oriented offsets. */
+    vertical_buffer?: number;
+    /** Whether contextual shaping requires straight placement. */
+    no_curving?: boolean;
+    /** Side of a boundary line: left (-1) or right (1). */
+    orientation?: number;
+    /** Point-placement strategy identifier. */
+    placement?: number;
+    /** Minimum segment length relative to label size. */
+    placement_min_length_ratio?: number;
+    /** Requested spacing along a line in pixels. */
+    placement_spacing?: number;
+    /** Whether points may be placed outside tile bounds. */
+    tile_edges?: boolean;
+    /** Fixed point rotation or automatic line rotation. */
+    angle?: number | 'auto';
+    /** Whether this layout uses vertex placement. */
+    vertex?: boolean;
+    /** Optional feature identity retained for debugging. */
+    id?: unknown;
+}
+
+/** Point geometry used to anchor attached text. */
+export interface LabelParent {
+    /** Parent's unscaled dimensions. */
+    size: LabelPointCoordinate;
+    /** Parent's point anchor. */
+    anchor?: string | string[];
+    /** Parent's pixel offset. */
+    offset: LabelPointCoordinate;
+}
+
+/** Geometry serialized across the worker/main-thread collision boundary. */
+export interface SerializedLabel {
+    /** Worker-scoped label identity. */
+    id: number;
+    /** Point, straight, or curved placement kind. */
+    type: string;
+    /** Original tile-local position. */
+    position: LabelPointCoordinate;
+    /** Minimal repeat/collision settings. */
+    layout: Pick<LabelLayout, 'priority' | 'collide' | 'repeat_distance' | 'repeat_group' | 'buffer' | 'italic' | 'projected_collide' | 'projected_identity' | 'projected_height'>;
+    /** Point/straight dimensions, absent for articulated text. */
+    size?: LabelPointCoordinate;
+    /** Rotation for point/straight placement. */
+    angle?: number;
+    /** Pixel offset for point/straight placement. */
+    offset?: LabelPointCoordinate;
+    /** Point-oriented box snapshot. */
+    obb?: ReturnType<OBB['toJSON']>;
+    /** Curved per-segment box snapshots. */
+    obbs?: ReturnType<OBB['toJSON']>[];
+    /** Whether this label crosses the tile boundary. */
+    breach?: boolean;
+    /** Whether repeat culling must run again on the main thread. */
+    may_repeat_across_tiles?: boolean;
+}

package/src/labels/label.ts

@@ -0,0 +1,207 @@
+// Tangram
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2013-2016 Brett Camper and Mapzen
+// Copyright (c) 2026 vis.gl contributors
+
+import type {CollisionBounds, CollisionLabel} from './collision-types';
+import type {LabelLayout, LabelPointCoordinate, SerializedLabel} from './label-types';
+import PointAnchor from './point_anchor';
+import {boxIntersectsList} from './intersect';
+import OBB from '../utils/obb';
+import Geo from '../utils/geo';
+// import log from '../utils/log';
+
+export default class Label {
+
+    static epsilon: number;
+    static nextLabelId: () => number;
+    static add: (label: CollisionLabel, bboxes: CollisionBounds) => void;
+    static id: number;
+    static id_prefix: number;
+    static id_multiplier: number;
+    id: number;
+    type: string;
+    /** Unscaled width and height in pixels. */
+    size: LabelPointCoordinate;
+    /** Normalized collision and positioning rules supplied by a style. */
+    layout: LabelLayout;
+    /** Tile-local position, installed by a concrete label after base construction. */
+    position: LabelPointCoordinate | null;
+    /** Rotation in radians. */
+    angle: number;
+    /** Current candidate anchor, possibly changed by point collision retries. */
+    anchor: string | undefined;
+    /** Collision outcome; null means not processed. */
+    placed: boolean | null;
+    /** Pixel offset before scaling into tile coordinates. */
+    offset: LabelPointCoordinate;
+    /** Tile units per pixel. */
+    unit_scale: number;
+    /** Broad-phase extent, absent until bounds are constructed. */
+    aabb: number[] | null;
+    /** Corresponding oriented collision box. */
+    obb: OBB | null;
+    /** Optional broad-phase extents for segmented geometry. */
+    aabbs: number[][] | undefined;
+    /** Oriented boxes corresponding to segmented extents. */
+    obbs: OBB[] | undefined;
+    /** Canvas text alignment derived from the anchor or explicit layout. */
+    align: string;
+    /** Whether geometry fitting rejected the label. */
+    throw_away: boolean;
+    /** Whether bounds cross a tile edge. */
+    breach?: boolean;
+    /** Whether a second repeat-distance pass is needed across tiles. */
+    may_repeat_across_tiles?: boolean;
+
+    /** Concrete labels supply normalized layouts; the legacy empty base default remains supported. */
+    constructor (size: LabelPointCoordinate, layout: LabelLayout = {} as LabelLayout) {
+        this.id = Label.nextLabelId();
+        this.type = ''; // set by subclass
+        this.size = size;
+        this.layout = layout;
+        this.position = null;
+        this.angle = 0;
+        this.anchor = Array.isArray(this.layout.anchor) ? this.layout.anchor[0] : this.layout.anchor; // initial anchor
+        this.placed = null;
+        this.offset = layout.offset;
+        this.unit_scale = this.layout.units_per_pixel;
+        this.aabb = null;
+        this.obb = null;
+        this.align = 'center';
+        this.throw_away = false;    // if label does not fit (exceeds tile boundary, etc) this boolean will be true
+    }
+
+    // Minimal representation of label
+    toJSON (): SerializedLabel {
+        return {
+            id: this.id,
+            type: this.type,
+            obb: this.obb!.toJSON(),
+            position: this.position!,
+            angle: this.angle,
+            size: this.size,
+            offset: this.offset,
+            breach: this.breach,
+            may_repeat_across_tiles: this.may_repeat_across_tiles,
+            layout: textLayoutToJSON(this.layout)
+        };
+    }
+
+    update () {
+        this.align = this.layout.align || PointAnchor.alignForAnchor(this.anchor);
+    }
+
+    // check for overlaps with other labels in the tile
+    occluded (this: {aabb: number[] | null; obb: OBB | null}, bboxes: CollisionBounds, exclude: CollisionLabel | null | 0 | '' = null): boolean {
+        let intersect = false;
+        let aabbs = bboxes.aabb;
+        let obbs = bboxes.obb;
+
+        // Broad phase
+        if (aabbs.length > 0) {
+            boxIntersectsList(this.aabb! as [number, number, number, number], aabbs as [number, number, number, number][], (j) => {
+                // log('trace', 'collision: broad phase collide', this.layout.id, this, this.aabb, aabbs[j]);
+
+                // Skip if colliding with excluded label
+                if (exclude && aabbs[j] === exclude.aabb) {
+                    // log('trace', 'collision: skipping due to explicit exclusion', this, exclude);
+                    return;
+                }
+
+                // Skip narrow phase collision if no rotation
+                if (this.obb!.angle === 0 && obbs[j].angle === 0) {
+                    // log('trace', 'collision: skip narrow phase collide because neither is rotated', this.layout.id, this, this.obb, obbs[j]);
+                    intersect = true;
+                    return true;
+                }
+
+                // Narrow phase
+                if (OBB.intersect(this.obb!, obbs[j])) {
+                    // log('trace', 'collision: narrow phase collide', this.layout.id, this, this.obb, obbs[j]);
+                    intersect = true;
+                    return true;
+                }
+            });
+        }
+        return intersect;
+    }
+
+    // checks whether the label is within the tile boundaries
+    inTileBounds (this: {aabb: number[] | null}): boolean {
+        if ((this.aabb![0] >= 0 && this.aabb![1] > -Geo.tile_scale && this.aabb![0] < Geo.tile_scale && this.aabb![1] <= 0) ||
+            (this.aabb![2] >= 0 && this.aabb![3] > -Geo.tile_scale && this.aabb![2] < Geo.tile_scale && this.aabb![3] <= 0)) {
+            return true;
+        }
+        return false;
+    }
+
+    // some labels need further repeat culling checks on the main thread
+    // checks whether the label is within its repeat distance of the tile boundaries
+    mayRepeatAcrossTiles () {
+        if (this.layout.collide) {
+            return true; // additional collision pass will already apply, so skip further distance checks
+        }
+
+        const dist = this.layout.repeat_distance!;
+        if (dist === 0) {
+            return false;
+        }
+
+        return (Math.abs(this.position![0]) < dist ||  Math.abs(this.position![0] - Geo.tile_scale) < dist) ||
+               (Math.abs(this.position![1]) < dist ||  Math.abs(-(this.position![1] - Geo.tile_scale)) < dist);
+    }
+
+    // Whether the label should be discarded
+    // Depends on whether label must fit in the tile bounds, and if so, can it be moved to fit there
+    discard(bboxes: CollisionBounds, exclude: CollisionLabel | null | 0 | '' = null): boolean {
+        if (this.throw_away) {
+            return true;
+        }
+        return this.occluded(bboxes, exclude);
+    }
+}
+
+// Generic label placement function, adds a label's bounding boxes to the currently placed set
+//  Supports single or multiple collision boxes
+Label.add = function (label, bboxes) {
+    label.placed = true;
+
+    if (label.aabb) {
+        bboxes.aabb.push(label.aabb);
+        bboxes.obb.push(label.obb!);
+    }
+
+    if (label.aabbs) {
+        for (let i = 0; i < label.aabbs.length; i++) {
+            bboxes.aabb.push(label.aabbs[i]);
+            bboxes.obb.push(label.obbs![i]);
+        }
+    }
+};
+
+Label.id = 0;
+Label.id_prefix = 0; // id prefix scoped to worker thread
+Label.id_multiplier = 0; // multiplier to keep label ids distinct across threads
+
+Label.nextLabelId = function () {
+    return Label.id_prefix + ((Label.id++) * Label.id_multiplier);
+};
+
+Label.epsilon = 0.9999; // tolerance around collision boxes, prevent perfectly adjacent objects from colliding
+
+// Minimal representation of text layout, sent to main thread for label collisions
+export function textLayoutToJSON (layout: LabelLayout): SerializedLabel['layout'] {
+    return {
+        priority: layout.priority,
+        ...(layout.projected_collide === undefined ? {} : {projected_collide: layout.projected_collide}),
+        ...(layout.projected_identity === undefined ? {} : {projected_identity: layout.projected_identity}),
+        ...(layout.projected_height === undefined ? {} : {projected_height: layout.projected_height}),
+        collide: layout.collide,
+        repeat_distance: layout.projected_collide === undefined ? layout.repeat_distance :
+            (layout.repeat_distance ?? 0) / layout.units_per_pixel,
+        repeat_group: layout.repeat_group,
+        buffer: layout.buffer,
+        italic: layout.italic // affects bounding box size
+    };
+}