@rickyzhangca/fpsr 0.0.1

package/dist/profile-DR4i6HDp.js

@@ -0,0 +1,610 @@
+//#region src/types/draw-list.ts
+/**
+* Full Factorio `RenderLayer` enum (lowest → highest).
+* Source: https://lua-api.factorio.com/latest/types/RenderLayer.html
+* (same data as Factorio.app `doc-html/prototype-api.json`, 2.1.11).
+* Values are the enum indices; order is the contract.
+*/
+const FACTORIO_RENDER_LAYERS = {
+	zero: 0,
+	"background-transitions": 1,
+	"under-tiles": 2,
+	decals: 3,
+	"above-tiles": 4,
+	"ground-layer-1": 5,
+	"ground-layer-2": 6,
+	"ground-layer-3": 7,
+	"ground-layer-4": 8,
+	"ground-layer-5": 9,
+	"lower-radius-visualization": 10,
+	"radius-visualization": 11,
+	"transport-belt-integration": 12,
+	resource: 13,
+	"building-smoke": 14,
+	"rail-stone-path-lower": 15,
+	"rail-stone-path": 16,
+	"rail-tie": 17,
+	decorative: 18,
+	"ground-patch": 19,
+	"ground-patch-higher": 20,
+	"ground-patch-higher2": 21,
+	"rail-chain-signal-metal": 22,
+	"rail-screw": 23,
+	"rail-metal": 24,
+	remnants: 25,
+	floor: 26,
+	"transport-belt": 27,
+	"transport-belt-endings": 28,
+	"floor-mechanics-under-corpse": 29,
+	corpse: 30,
+	"floor-mechanics": 31,
+	item: 32,
+	"transport-belt-reader": 33,
+	"lower-object": 34,
+	"transport-belt-circuit-connector": 35,
+	"lower-object-above-shadow": 36,
+	"lower-object-overlay": 37,
+	"object-under": 38,
+	object: 39,
+	"cargo-hatch": 40,
+	"higher-object-under": 41,
+	"higher-object-above": 42,
+	"train-stop-top": 43,
+	"item-in-inserter-hand": 44,
+	"above-inserters": 45,
+	wires: 46,
+	"under-elevated": 47,
+	"elevated-rail-stone-path-lower": 48,
+	"elevated-rail-stone-path": 49,
+	"elevated-rail-tie": 50,
+	"elevated-rail-screw": 51,
+	"elevated-rail-metal": 52,
+	"elevated-lower-object": 53,
+	"elevated-object": 54,
+	"elevated-higher-object": 55,
+	"fluid-visualization": 56,
+	"wires-above": 57,
+	"entity-info-icon": 58,
+	"entity-info-icon-above": 59,
+	explosion: 60,
+	projectile: 61,
+	smoke: 62,
+	"air-object": 63,
+	"air-entity-info-icon": 64,
+	"light-effect": 65,
+	"selection-box": 66,
+	"higher-selection-box": 67,
+	"collision-selection-box": 68,
+	arrow: 69,
+	cursor: 70
+};
+/**
+* fpsr-only names (not in Factorio's enum) and legacy aliases.
+* Aliases share the official index of the Factorio name they stand for.
+*/
+const FPSR_RENDER_LAYERS = {
+	/** ≈ `background-transitions` */
+	"tile-transition": 1,
+	/** ≈ `under-tiles` */
+	"ground-tile": 2,
+	"water-tile": 2,
+	/** alias of `rail-tie` */
+	"rail-ties": 17,
+	/** Dedicated `draw_as_shadow` pass (no Factorio RenderLayer for this) */
+	shadow: 37,
+	/** alias of `elevated-rail-tie` */
+	"elevated-rail-ties": 50,
+	/** alias of `entity-info-icon` */
+	icons: 58
+};
+const RENDER_LAYERS = {
+	...FACTORIO_RENDER_LAYERS,
+	...FPSR_RENDER_LAYERS
+};
+/** Comparator implementing the contract sort order. */
+function compareDrawCmd(a, b) {
+	return a.layer - b.layer || a.sortY - b.sortY || a.sortX - b.sortX || a.entity - b.entity || a.sub - b.sub;
+}
+/**
+* Canonical serialization for Tier-2 snapshots: stable key order, numbers
+* rounded to 4 decimals, one command per line for reviewable diffs.
+*/
+function serializeDrawList(list) {
+	const roundDeep = (v) => {
+		if (typeof v === "number") return Math.round(v * 1e4) / 1e4;
+		if (Array.isArray(v)) return v.map(roundDeep);
+		if (v && typeof v === "object") {
+			const out = {};
+			for (const k of Object.keys(v)) out[k] = roundDeep(v[k]);
+			return out;
+		}
+		return v;
+	};
+	const canon = (obj) => {
+		const out = {};
+		for (const k of Object.keys(obj).sort()) out[k] = roundDeep(obj[k]);
+		return out;
+	};
+	const lines = list.commands.map((c) => JSON.stringify(canon(c)));
+	const bounds = canon(list.bounds);
+	return `{\n"schema": ${list.schema},\n"bounds": ${JSON.stringify(bounds)},\n"commands": [\n${lines.join(",\n")}\n]\n}\n`;
+}
+//#endregion
+//#region src/resolve/trains.ts
+/**
+* Vehicle RotatedAnimation art is already authored in oblique screen angles.
+* Convert the world-space orientation back into that authored ellipse before
+* selecting a pose. This is the inverse axis scaling of rolling-stock
+* projection; vehicles also have no rail/bogie geometry.
+*/
+function projectVehicleOrientation(orientation) {
+	const turn = (orientation % 1 + 1) % 1;
+	let x = Math.sin(turn * Math.PI * 2);
+	const y = -Math.cos(turn * Math.PI * 2);
+	x *= Math.SQRT1_2;
+	let out = Math.atan2(x, -y) / (Math.PI * 2);
+	if (out < 0) out += 1;
+	return out;
+}
+/**
+* Map continuous blueprint `orientation` ∈ [0,1) to a distilled pose index.
+* `round(orientation * N) % N` — orientation 0 → pose 0 (north).
+*
+* With `backEqualsFront` (cargo/fluid wagons): the sheet only authors half a
+* turn; Factorio indexes as `round(o * 2N) % N` so east and west share a pose.
+* @see FBSR FPRotatedSprite.getIndex
+*/
+function trainOrientationIndex(orientation, poseCount, backEqualsFront = false) {
+	if (poseCount <= 0) return 0;
+	const o = (orientation % 1 + 1) % 1;
+	if (backEqualsFront) return Math.round(o * poseCount * 2) % poseCount;
+	return Math.round(o * poseCount) % poseCount;
+}
+/**
+* Factorio's camera is a 45° orthographic tilt: circular orientations project
+* onto an ellipse (Y scaled by 1/√2) before picking rotated sprites.
+* @see https://forums.factorio.com/viewtopic.php?t=109695
+*/
+function projectTrainOrientation(orientation) {
+	const turn = (orientation % 1 + 1) % 1;
+	const x = Math.sin(turn * Math.PI * 2);
+	let y = -Math.cos(turn * Math.PI * 2);
+	y *= Math.SQRT1_2;
+	let out = Math.atan2(x, -y) / (Math.PI * 2);
+	if (out < 0) out += 1;
+	return out;
+}
+/**
+* Rolling-stock "rail shift": FBSR stores this as height and flattens with
+* `y - height`. Equivalent forum form: `-(0.25 * abs(cos(o*TAU + PI/2)))`.
+* @see https://forums.factorio.com/viewtopic.php?t=109695
+*/
+function trainRailShiftY(orientation) {
+	const angle = (orientation % 1 + 1) % 1 * Math.PI * 2;
+	return -.25 * Math.abs(Math.cos(angle + Math.PI / 2));
+}
+/** Factorio oblique Y/Z scale (1/√2). @see FBSR FPUtils.PROJECTION_CONSTANT */
+const TRAIN_PROJECTION = Math.SQRT1_2;
+/**
+* Artillery-wagon cannon mount offset (tile units, before rail-shift Y).
+* Ports FBSR ArtilleryWagonRendering.calculateCannonPosition for slope=0.
+*/
+function artilleryCannonShift(orientation, opts) {
+	const o = (orientation % 1 + 1) % 1;
+	const n = typeof opts.orientationCount === "number" && opts.orientationCount > 0 ? opts.orientationCount : 64;
+	const aligned = trainOrientationIndex(projectTrainOrientation(o), n) / n;
+	const vf = Math.abs(Math.abs(aligned - .5) - .25) * 4;
+	const vert = opts.cannonBaseShiftWhenVertical ?? 0;
+	const horiz = opts.cannonBaseShiftWhenHorizontal ?? 0;
+	const offsetForward = -(vert * vf + horiz * (1 - vf));
+	const offsetHeight = opts.cannonBaseHeight ?? 0;
+	const rotation = o * Math.PI * 2 + Math.PI / 2;
+	return [offsetForward * Math.cos(rotation), offsetForward * Math.sin(rotation) * TRAIN_PROJECTION - offsetHeight * TRAIN_PROJECTION];
+}
+/** Dual bogie shifts for a rolling-stock entity (tile units relative to center). */
+function trainWheelShifts(orientation, jointDistance) {
+	const o = (orientation % 1 + 1) % 1;
+	const projected = projectTrainOrientation(o);
+	const half = jointDistance / 2;
+	const angle = o * Math.PI * 2;
+	const ox = Math.sin(angle) * half;
+	const oy = -Math.cos(angle) * half;
+	const vert = trainRailShiftY(o);
+	const flipped = projectTrainOrientation((o + .5) % 1);
+	return [{
+		shift: [ox, oy + vert],
+		orientation: flipped
+	}, {
+		shift: [-ox, -oy + vert],
+		orientation: projected
+	}];
+}
+/**
+* Map blueprint rail direction (0..15) to a direction8 picture index.
+* Straight / half-diagonal pieces only author 4 of 8 keys; fold 4..7 → 0..3.
+*/
+function railDirectionIndex(direction, foldTo4) {
+	let i = Math.floor((direction % 16 + 16) % 16 / 2) % 8;
+	if (foldTo4) i = i % 4;
+	return i;
+}
+//#endregion
+//#region src/icon-silhouette.ts
+/** Pixel radius for feMorphology-style alpha dilation on entity-info icons. */
+const ENTITY_INFO_SILHOUETTE_RADIUS_PX = 12;
+/** Soft blur applied after dilation to feather the silhouette edge. */
+const ENTITY_INFO_SILHOUETTE_BLUR_PX = 16;
+/** Total source-pixel padding around icon crops for spread + blur. */
+function entityInfoSilhouettePadPx(dilateRadius = 12, blurRadius = 16) {
+	return dilateRadius + blurRadius;
+}
+/** Box dilation on the alpha channel; output RGB is solid black. */
+function dilateAlphaChannel(src, width, height, radius) {
+	if (radius <= 0) {
+		const out = new Uint8Array(width * height);
+		for (let pixel = 0; pixel < out.length; pixel++) out[pixel] = src[pixel * 4 + 3];
+		return out;
+	}
+	const r = Math.floor(radius);
+	if (r <= 0) return dilateAlphaChannel(src, width, height, 0);
+	const horizontal = new Uint8Array(width * height);
+	const deque = new Int32Array(Math.max(width, height));
+	for (let y = 0; y < height; y++) {
+		let head = 0;
+		let tail = 0;
+		let next = 0;
+		const row = y * width;
+		for (let x = 0; x < width; x++) {
+			const addThrough = Math.min(width - 1, x + r);
+			while (next <= addThrough) {
+				const alpha = src[(row + next) * 4 + 3];
+				while (tail > head) {
+					if (src[(row + deque[tail - 1]) * 4 + 3] > alpha) break;
+					tail--;
+				}
+				deque[tail++] = next++;
+			}
+			const removeBefore = x - r;
+			while (tail > head && deque[head] < removeBefore) head++;
+			horizontal[row + x] = src[(row + deque[head]) * 4 + 3];
+		}
+	}
+	const out = new Uint8Array(width * height);
+	for (let x = 0; x < width; x++) {
+		let head = 0;
+		let tail = 0;
+		let next = 0;
+		for (let y = 0; y < height; y++) {
+			const addThrough = Math.min(height - 1, y + r);
+			while (next <= addThrough) {
+				const alpha = horizontal[next * width + x];
+				while (tail > head) {
+					if (horizontal[deque[tail - 1] * width + x] > alpha) break;
+					tail--;
+				}
+				deque[tail++] = next++;
+			}
+			const removeBefore = y - r;
+			while (tail > head && deque[head] < removeBefore) head++;
+			out[y * width + x] = horizontal[deque[head] * width + x];
+		}
+	}
+	return out;
+}
+function writeBlurredBlackRgba(alpha, target, width, height, radius) {
+	const r = Math.floor(radius);
+	if (r <= 0) {
+		for (let pixel = 0; pixel < alpha.length; pixel++) {
+			const i = pixel * 4;
+			target[i] = 0;
+			target[i + 1] = 0;
+			target[i + 2] = 0;
+			target[i + 3] = alpha[pixel];
+		}
+		return;
+	}
+	const stride = width + 1;
+	const integral = new Uint32Array((width + 1) * (height + 1));
+	for (let y = 0; y < height; y++) {
+		let rowSum = 0;
+		const srcRow = y * width;
+		const integralRow = (y + 1) * stride;
+		const previousRow = y * stride;
+		for (let x = 0; x < width; x++) {
+			rowSum += alpha[srcRow + x];
+			integral[integralRow + x + 1] = integral[previousRow + x + 1] + rowSum;
+		}
+	}
+	for (let y = 0; y < height; y++) {
+		const top = Math.max(0, y - r);
+		const bottom = Math.min(height, y + r + 1);
+		for (let x = 0; x < width; x++) {
+			const left = Math.max(0, x - r);
+			const right = Math.min(width, x + r + 1);
+			const sum = integral[bottom * stride + right] - integral[top * stride + right] - integral[bottom * stride + left] + integral[top * stride + left];
+			const i = (y * width + x) * 4;
+			target[i] = 0;
+			target[i + 1] = 0;
+			target[i + 2] = 0;
+			target[i + 3] = Math.round(sum / ((right - left) * (bottom - top)));
+		}
+	}
+}
+/** Bake from an already-cropped icon without reading back a second offscreen canvas. */
+function bakeEntityInfoSilhouetteFromImageData(iconData, createCanvas, dilateRadius = 12, blurRadius = 16) {
+	const iconWidth = iconData.width;
+	const iconHeight = iconData.height;
+	const pad = entityInfoSilhouettePadPx(dilateRadius, blurRadius);
+	const width = iconWidth + 2 * pad;
+	const height = iconHeight + 2 * pad;
+	const canvas = createCanvas(width, height);
+	canvas.width = width;
+	canvas.height = height;
+	const ctx = canvas.getContext("2d");
+	if (!ctx) return void 0;
+	const imageData = ctx.createImageData?.(width, height) ?? ctx.getImageData(0, 0, width, height);
+	for (let y = 0; y < iconHeight; y++) for (let x = 0; x < iconWidth; x++) {
+		const source = (y * iconWidth + x) * 4 + 3;
+		const target = ((y + pad) * width + x + pad) * 4 + 3;
+		imageData.data[target] = iconData.data[source];
+	}
+	writeBlurredBlackRgba(dilateAlphaChannel(imageData.data, width, height, dilateRadius), imageData.data, width, height, blurRadius);
+	ctx.putImageData(imageData, 0, 0);
+	return canvas;
+}
+/**
+* Dilate and blur an isolated icon crop into a padded black silhouette image.
+* Returns undefined when the canvas context cannot read/write ImageData.
+*/
+function bakeEntityInfoSilhouette(iconImage, iconWidth, iconHeight, createCanvas, dilateRadius = 12, blurRadius = 16) {
+	const pad = entityInfoSilhouettePadPx(dilateRadius, blurRadius);
+	const width = iconWidth + 2 * pad;
+	const height = iconHeight + 2 * pad;
+	const canvas = createCanvas(width, height);
+	canvas.width = width;
+	canvas.height = height;
+	const ctx = canvas.getContext("2d");
+	if (!ctx) return void 0;
+	ctx.drawImage(iconImage, pad, pad);
+	const imageData = ctx.getImageData(0, 0, width, height);
+	writeBlurredBlackRgba(dilateAlphaChannel(imageData.data, width, height, dilateRadius), imageData.data, width, height, blurRadius);
+	ctx.putImageData(imageData, 0, 0);
+	return canvas;
+}
+//#endregion
+//#region src/train-chains.ts
+/**
+* Rolling-stock coupling chain overlay: green joint circles + straight segments
+* along connected wagons (Factorio attach/coupling visualization).
+*/
+/** Default Factorio RollingStock connection_distance when not distilled. */
+const DEFAULT_CONNECTION_DISTANCE = 3;
+/** Default Factorio RollingStock joint_distance when not distilled. */
+const DEFAULT_JOINT_DISTANCE = 4;
+/** Hollow joint circle radius in tiles — segments stop at this edge. */
+const TRAIN_CHAIN_JOINT_RADIUS = .3;
+/** Tolerance when inferring couplings from joint proximity (tiles). */
+const COUPLE_TOLERANCE = .25;
+function round4(n) {
+	return Math.round(n * 1e4) / 1e4;
+}
+function jointDistanceOf(def) {
+	const j = def.data?.jointDistance;
+	return typeof j === "number" && j > 0 ? j : 4;
+}
+function connectionDistanceOf(def) {
+	const c = def.data?.connectionDistance;
+	return typeof c === "number" && c > 0 ? c : 3;
+}
+/**
+* World-space front/back joint positions for a rolling-stock entity.
+* Matches bogie placement from `trainWheelShifts` (index 0 = front/+half).
+*/
+function trainJointWorldPoints(entity, jointDistance) {
+	const bogies = trainWheelShifts(entity.orientation ?? 0, jointDistance);
+	const front = bogies[0];
+	const back = bogies[1];
+	return {
+		front: [round4(entity.position.x + front.shift[0]), round4(entity.position.y + front.shift[1])],
+		back: [round4(entity.position.x + back.shift[0]), round4(entity.position.y + back.shift[1])]
+	};
+}
+function dist(a, b) {
+	return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+function jointKey(x, y) {
+	return `${Math.round(x * 1e4) / 1e4},${Math.round(y * 1e4) / 1e4}`;
+}
+function addSegment(segments, seen, a, b, endInset = 0) {
+	const k1 = `${jointKey(a[0], a[1])}|${jointKey(b[0], b[1])}`;
+	const k2 = `${jointKey(b[0], b[1])}|${jointKey(a[0], a[1])}`;
+	if (seen.has(k1) || seen.has(k2)) return;
+	seen.add(k1);
+	let x1 = a[0];
+	let y1 = a[1];
+	let x2 = b[0];
+	let y2 = b[1];
+	if (endInset > 0) {
+		const len = Math.hypot(x2 - x1, y2 - y1);
+		if (len <= endInset * 2) return;
+		const ux = (x2 - x1) / len;
+		const uy = (y2 - y1) / len;
+		x1 = round4(x1 + ux * endInset);
+		y1 = round4(y1 + uy * endInset);
+		x2 = round4(x2 - ux * endInset);
+		y2 = round4(y2 - uy * endInset);
+	}
+	segments.push({
+		x1,
+		y1,
+		x2,
+		y2
+	});
+}
+function addJoint(joints, seen, p) {
+	const k = jointKey(p[0], p[1]);
+	if (seen.has(k)) return;
+	seen.add(k);
+	joints.push({
+		x: p[0],
+		y: p[1]
+	});
+}
+function sideOfNeighbor(links, neighbor, stock, fallback) {
+	const n = links.get(neighbor);
+	if (n?.front === stock) return "front";
+	if (n?.back === stock) return "back";
+	return fallback;
+}
+function parseStockConnections(raw, trainNums) {
+	if (!raw?.length) return [];
+	const links = /* @__PURE__ */ new Map();
+	for (const entry of raw) {
+		if (!entry || typeof entry.stock !== "number") continue;
+		if (!trainNums.has(entry.stock)) continue;
+		const cur = links.get(entry.stock) ?? {};
+		if (typeof entry.front === "number") cur.front = entry.front;
+		if (typeof entry.back === "number") cur.back = entry.back;
+		links.set(entry.stock, cur);
+	}
+	const edges = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const [stock, sides] of links) for (const aSide of ["front", "back"]) {
+		const neighbor = sides[aSide];
+		if (typeof neighbor !== "number" || !trainNums.has(neighbor) || neighbor === stock) continue;
+		const key = `${Math.min(stock, neighbor)}-${Math.max(stock, neighbor)}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		const bSide = sideOfNeighbor(links, neighbor, stock, aSide === "front" ? "back" : "front");
+		edges.push({
+			a: stock,
+			aSide,
+			b: neighbor,
+			bSide
+		});
+	}
+	return edges;
+}
+/**
+* Infer couplings when `stock_connections` is absent: facing joints within
+* connection_distance ± tolerance, orientations aligned or opposite.
+*/
+function inferCouplings(trains, jointsByNum) {
+	const edges = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (let i = 0; i < trains.length; i++) {
+		const a = trains[i];
+		const ja = jointsByNum.get(a.entity.entity_number);
+		if (!ja) continue;
+		const connA = connectionDistanceOf(a.def);
+		for (let j = i + 1; j < trains.length; j++) {
+			const b = trains[j];
+			const jb = jointsByNum.get(b.entity.entity_number);
+			if (!jb) continue;
+			const expected = (connA + connectionDistanceOf(b.def)) / 2;
+			const candidates = [
+				{
+					aSide: "front",
+					bSide: "front",
+					d: dist(ja.front, jb.front)
+				},
+				{
+					aSide: "front",
+					bSide: "back",
+					d: dist(ja.front, jb.back)
+				},
+				{
+					aSide: "back",
+					bSide: "front",
+					d: dist(ja.back, jb.front)
+				},
+				{
+					aSide: "back",
+					bSide: "back",
+					d: dist(ja.back, jb.back)
+				}
+			];
+			let best;
+			for (const c of candidates) {
+				if (Math.abs(c.d - expected) > COUPLE_TOLERANCE) continue;
+				if (!best || c.d < best.d) best = c;
+			}
+			if (!best) continue;
+			const key = `${Math.min(a.entity.entity_number, b.entity.entity_number)}-${Math.max(a.entity.entity_number, b.entity.entity_number)}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			edges.push({
+				a: a.entity.entity_number,
+				aSide: best.aSide,
+				b: b.entity.entity_number,
+				bSide: best.bSide
+			});
+		}
+	}
+	return edges;
+}
+function pointOf(joints, side) {
+	return side === "front" ? joints.front : joints.back;
+}
+/**
+* Build train-chain overlay geometry for all coupled rolling stock in a blueprint.
+*
+* Draws hollow circles only at coupled joints (free ends omitted), and straight
+* segments between those facing joints. Segment endpoints are inset to the
+* circle perimeter so strokes meet the rings instead of crossing through them.
+*
+* Isolated single wagons with no neighbors are omitted.
+*/
+function buildTrainChainGeometry(bp, byNumber) {
+	const trains = [];
+	for (const entry of byNumber.values()) if (entry.def.kind === "train") trains.push(entry);
+	if (trains.length === 0) return null;
+	const trainNums = new Set(trains.map((t) => t.entity.entity_number));
+	const jointsByNum = /* @__PURE__ */ new Map();
+	for (const t of trains) jointsByNum.set(t.entity.entity_number, trainJointWorldPoints(t.entity, jointDistanceOf(t.def)));
+	let edges = parseStockConnections(bp.stock_connections, trainNums);
+	if (edges.length === 0) edges = inferCouplings(trains, jointsByNum);
+	if (edges.length === 0) return null;
+	const segments = [];
+	const joints = [];
+	const segSeen = /* @__PURE__ */ new Set();
+	const jointSeen = /* @__PURE__ */ new Set();
+	for (const e of edges) {
+		const ja = jointsByNum.get(e.a);
+		const jb = jointsByNum.get(e.b);
+		if (!ja || !jb) continue;
+		const aPt = pointOf(ja, e.aSide);
+		const bPt = pointOf(jb, e.bSide);
+		addJoint(joints, jointSeen, aPt);
+		addJoint(joints, jointSeen, bPt);
+		addSegment(segments, segSeen, aPt, bPt, TRAIN_CHAIN_JOINT_RADIUS);
+	}
+	if (segments.length === 0 && joints.length === 0) return null;
+	return {
+		segments,
+		joints
+	};
+}
+//#endregion
+//#region src/profile.ts
+/** High-resolution clock; falls back to Date.now in exotic hosts. */
+function nowMs() {
+	if (typeof performance !== "undefined" && typeof performance.now === "function") return performance.now();
+	return Date.now();
+}
+/** Best-effort Performance API mark (ignored when unavailable). */
+function perfMark(name) {
+	try {
+		performance.mark?.(name);
+	} catch {}
+}
+/** Best-effort Performance API measure between two marks. */
+function perfMeasure(name, startMark, endMark) {
+	try {
+		performance.measure?.(name, startMark, endMark);
+	} catch {}
+}
+//#endregion
+export { compareDrawCmd as C, RENDER_LAYERS as S, railDirectionIndex as _, DEFAULT_JOINT_DISTANCE as a, trainWheelShifts as b, trainJointWorldPoints as c, bakeEntityInfoSilhouette as d, bakeEntityInfoSilhouetteFromImageData as f, projectVehicleOrientation as g, projectTrainOrientation as h, DEFAULT_CONNECTION_DISTANCE as i, ENTITY_INFO_SILHOUETTE_BLUR_PX as l, artilleryCannonShift as m, perfMark as n, TRAIN_CHAIN_JOINT_RADIUS as o, entityInfoSilhouettePadPx as p, perfMeasure as r, buildTrainChainGeometry as s, nowMs as t, ENTITY_INFO_SILHOUETTE_RADIUS_PX as u, trainOrientationIndex as v, serializeDrawList as w, FACTORIO_RENDER_LAYERS as x, trainRailShiftY as y };
+
+//# sourceMappingURL=profile-DR4i6HDp.js.map