@orbat-mapper/control-measures 0.2.0-alpha.7 → 0.2.0-alpha.9

package/dist/{renderControlMeasure-DGWf44sn.mjs → renderControlMeasure-CFdgTURO.mjs}

@@ -206,8 +206,8 @@ const SHAFT_MAX_RATIO = .9;
 */
 function processAttackGeometry(coordinates, options = {}) {
 	const shaftRatio = clamp(options.shaftWidthRatio ?? .6, SHAFT_MIN_RATIO, SHAFT_MAX_RATIO);
-	const roundedBends = options.roundedBends ?? false;
-	const bendSegments = options.bendSegments ?? 5;
+	const smooth = options.smooth ?? false;
+	const smoothResolution = options.smoothResolution ?? 5;
 	const points = coordinates.map((c) => project(c[0], c[1]));
 	const numPoints = points.length;
 	const ptTip = points[0];
@@ -217,9 +217,9 @@ function processAttackGeometry(coordinates, options = {}) {
 		const p = points[i];
 		if (p) spinePoints.push(p);
 	}
-	return { geometry: calculateSymbolGeometry(ptTip, ptWidth, spinePoints, shaftRatio, roundedBends, bendSegments) };
+	return { geometry: calculateSymbolGeometry(ptTip, ptWidth, spinePoints, shaftRatio, smooth, smoothResolution) };
 }
-function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, roundedBends, bendSegments) {
+function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, smooth, smoothResolution) {
 	const initialNeck = spine[spine.length - 1];
 	if (!initialNeck) return null;
 	const initialTipDir = vecNorm(vecSub(ptTip, initialNeck));
@@ -273,8 +273,8 @@ function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, roundedBends
 	];
 	const fullSpine = [...remainingSpine, shaftEndCenter];
 	return {
-		shaftLeft: offsetPolyline(fullSpine, shaftHalfWidth, roundedBends, bendSegments),
-		shaftRight: offsetPolyline(fullSpine, -shaftHalfWidth, roundedBends, bendSegments),
+		shaftLeft: offsetPolyline(fullSpine, shaftHalfWidth, smooth, smoothResolution),
+		shaftRight: offsetPolyline(fullSpine, -shaftHalfWidth, smooth, smoothResolution),
 		headRing,
 		ptTip,
 		ptNeck,
@@ -975,20 +975,20 @@ const ATTACK_SHAFT_PARAMS = [
 		step: .05
 	},
 	{
-		key: "roundedBends",
-		label: "Rounded bends",
+		key: "smooth",
+		label: "Smooth",
 		description: "Round the corners where the shaft changes direction.",
 		type: "boolean"
 	},
 	{
-		key: "bendSegments",
-		label: "Bend segments",
-		description: "Number of segments approximating each rounded bend",
+		key: "smoothResolution",
+		label: "Smooth resolution",
+		description: "Number of segments approximating each rounded bend when smooth mode is enabled.",
 		type: "number",
 		min: 1,
 		max: 20,
 		step: 1,
-		visibleWhen: (opts) => opts.roundedBends === true
+		visibleWhen: (opts) => opts.smooth === true
 	}
 ];
 const FIRE_ARROW_PARAMS = [
@@ -1002,8 +1002,8 @@ const FIRE_ARROW_PARAMS = [
 		step: .01
 	},
 	{
-		key: "backLineLengthRatio",
-		label: "Back line length",
+		key: "rearLineLengthRatio",
+		label: "Rear line length",
 		description: "Length of the rear flare lines as a ratio of the head",
 		type: "number",
 		min: .05,
@@ -1011,8 +1011,8 @@ const FIRE_ARROW_PARAMS = [
 		step: .01
 	},
 	{
-		key: "backLineAngle",
-		label: "Back line angle",
+		key: "rearLineAngle",
+		label: "Rear line angle",
 		description: "Angle of the rear flare lines, in degrees",
 		type: "number",
 		min: 0,
@@ -1021,8 +1021,8 @@ const FIRE_ARROW_PARAMS = [
 	}
 ];
 const FORTIFIED_AREA_SIZE_PARAMS = [{
-	key: "sizePixels",
-	label: "Size",
+	key: "toothSizePixels",
+	label: "Tooth size",
 	description: "Size of the fortified-area teeth, in pixels",
 	type: "number",
 	min: 5,
@@ -1030,8 +1030,8 @@ const FORTIFIED_AREA_SIZE_PARAMS = [{
 	step: 1,
 	unit: "px"
 }, {
-	key: "size",
-	label: "Size",
+	key: "toothSize",
+	label: "Tooth size",
 	description: "Size of the fortified-area teeth, in meters",
 	type: "number",
 	min: 1,
@@ -1098,8 +1098,8 @@ const FORTIFIED_AREA_PARAMS = [
 //#region src/generators/cm15-maneuver-areas/airborneAttack.ts
 const DEFAULT_AIRBORNE_ATTACK_OPTIONS = {
 	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
-	roundedBends: false,
-	bendSegments: 5
+	smooth: false,
+	smoothResolution: 5
 };
 const AIRBORNE_ATTACK_METADATA = {
 	id: "airborne-attack",
@@ -1194,7 +1194,7 @@ const DEFAULT_AMBUSH_OPTIONS = {
 	hatchLengthRatio: .15,
 	hatchCount: 5,
 	curveDepthRatio: .25,
-	resolution: 30
+	arcSegments: 30
 };
 const AMBUSH_METADATA = {
 	id: "ambush",
@@ -1255,8 +1255,8 @@ const AMBUSH_METADATA = {
 			step: .01
 		},
 		{
-			key: "resolution",
-			label: "Resolution",
+			key: "arcSegments",
+			label: "Arc segments",
 			description: "Number of segments used to render the curve",
 			type: "number",
 			min: 4,
@@ -1278,11 +1278,11 @@ const quadBezier = (t, a, b, c) => {
 * @returns GeoJSON FeatureCollection containing LineString components
 */
 function createAmbushSymbol(coordinates, options = {}) {
-	const { arrowheadLengthRatio, arrowheadWidthRatio, hatchLengthRatio, hatchCount, curveDepthRatio, resolution } = {
+	const { arrowheadLengthRatio, arrowheadWidthRatio, hatchLengthRatio, hatchCount, curveDepthRatio, arcSegments } = {
 		...DEFAULT_AMBUSH_OPTIONS,
 		...options
 	};
-	const safeResolution = Math.max(1, Math.floor(resolution));
+	const safeArcSegments = Math.max(1, Math.floor(arcSegments));
 	const safeHatchCount = Math.max(0, Math.floor(hatchCount));
 	const safeArrowheadLengthRatio = Math.max(0, arrowheadLengthRatio);
 	const safeArrowheadWidthRatio = Math.max(0, arrowheadWidthRatio);
@@ -1315,8 +1315,8 @@ function createAmbushSymbol(coordinates, options = {}) {
 		vecSub(hBase, vecScale(perp, hw))
 	]);
 	const curve = [];
-	for (let i = 0; i <= safeResolution; i++) {
-		const t = i / safeResolution;
+	for (let i = 0; i <= safeArcSegments; i++) {
+		const t = i / safeArcSegments;
 		curve.push(quadBezier(t, p2, ctrl, p3));
 	}
 	lines.push(curve);
@@ -1363,8 +1363,8 @@ const FORTIFIED_PARAMS = [
 		visibleWhen: (opts) => Boolean(opts.smooth)
 	},
 	{
-		key: "sizePixels",
-		label: "Size",
+		key: "toothSizePixels",
+		label: "Tooth size",
 		description: "Side length of the square crenellations",
 		type: "number",
 		min: 5,
@@ -1373,8 +1373,8 @@ const FORTIFIED_PARAMS = [
 		unit: "px"
 	},
 	{
-		key: "size",
-		label: "Size",
+		key: "toothSize",
+		label: "Tooth size",
 		description: "Side length of the square crenellations",
 		type: "number",
 		min: 1,
@@ -1623,8 +1623,8 @@ const ANTITANK_WALL = defineControlMeasure({
 //#region src/generators/cm15-maneuver-areas/attackByFire.ts
 const DEFAULT_ATTACK_BY_FIRE_OPTIONS = {
 	arrowheadWidthRatio: .3,
-	backLineLengthRatio: .3,
-	backLineAngle: 45
+	rearLineLengthRatio: .3,
+	rearLineAngle: 45
 };
 const ATTACK_BY_FIRE_METADATA = {
 	id: "attack-by-fire",
@@ -1655,8 +1655,8 @@ const ATTACK_BY_FIRE_METADATA = {
 function createAttackByFire(coordinates, options = {}) {
 	const featureProps = {};
 	const arrowheadWidthRatio = options.arrowheadWidthRatio ?? DEFAULT_ATTACK_BY_FIRE_OPTIONS.arrowheadWidthRatio;
-	const backLineLengthRatio = options.backLineLengthRatio ?? DEFAULT_ATTACK_BY_FIRE_OPTIONS.backLineLengthRatio;
-	const backLineAngle = options.backLineAngle ?? DEFAULT_ATTACK_BY_FIRE_OPTIONS.backLineAngle;
+	const rearLineLengthRatio = options.rearLineLengthRatio ?? DEFAULT_ATTACK_BY_FIRE_OPTIONS.rearLineLengthRatio;
+	const rearLineAngle = options.rearLineAngle ?? DEFAULT_ATTACK_BY_FIRE_OPTIONS.rearLineAngle;
 	const c1 = coordinates[0];
 	const c2 = coordinates[1];
 	const c3 = coordinates[2];
@@ -1682,13 +1682,13 @@ function createAttackByFire(coordinates, options = {}) {
 	const lenShaft = Math.abs(signedTipDistance);
 	const lenBase = frame.length;
 	const dirBase = frame.direction;
-	const angleRad = backLineAngle * Math.PI / 180;
+	const angleRad = rearLineAngle * Math.PI / 180;
 	const baseAngle = -Math.PI / 2;
 	const angleLeft = baseAngle - angleRad;
 	const dirBackLeft = [dirBase[0] * Math.cos(angleLeft) - dirBase[1] * Math.sin(angleLeft), dirBase[0] * Math.sin(angleLeft) + dirBase[1] * Math.cos(angleLeft)];
 	const angleRight = baseAngle + angleRad;
 	const dirBackRight = [dirBase[0] * Math.cos(angleRight) - dirBase[1] * Math.sin(angleRight), dirBase[0] * Math.sin(angleRight) + dirBase[1] * Math.cos(angleRight)];
-	const backLen = lenBase * backLineLengthRatio;
+	const backLen = lenBase * rearLineLengthRatio;
 	const p2Back = vecAdd(p2, vecScale(dirBackLeft, backLen));
 	const p3Back = vecAdd(p3, vecScale(dirBackRight, backLen));
 	const headWidth = lenShaft * arrowheadWidthRatio;
@@ -1763,8 +1763,8 @@ const ATTACK_BY_FIRE = defineControlMeasure({
 //#region src/generators/cm15-maneuver-areas/attackHelicopter.ts
 const DEFAULT_ATTACK_HELICOPTER_OPTIONS = {
 	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
-	roundedBends: false,
-	bendSegments: 5,
+	smooth: false,
+	smoothResolution: 5,
 	symbolHeightRatio: .45,
 	triangleSizeRatio: .25,
 	bottomBarWidthRatio: 1.5,
@@ -2729,7 +2729,7 @@ const DEFAULT_SMOOTH_RESOLUTION$5 = 12;
 const MIN_SMOOTH_RESOLUTION$1 = 2;
 const MAX_SMOOTH_RESOLUTION$1 = 64;
 const DEFAULT_BLOCK_ARROW_OPTIONS = {
-	shaftWidth: .06,
+	shaftWidthRatio: .06,
 	arrowheadStyle: "triangle",
 	arrowheadWidthRatio: .18,
 	arrowheadLengthRatio: .22,
@@ -2751,7 +2751,7 @@ const BLOCK_ARROW_METADATA = {
 	drawRule: "Axis1",
 	params: [
 		{
-			key: "shaftWidth",
+			key: "shaftWidthRatio",
 			label: "Shaft width",
 			description: "Shaft band width as a fraction of the total path length",
 			type: "number",
@@ -2844,7 +2844,7 @@ const BLOCK_ARROW_METADATA = {
 * right side of the shaft.
 */
 function createBlockArrow(coordinates, options = {}) {
-	const { shaftWidth, arrowheadStyle, arrowheadWidthRatio, arrowheadLengthRatio, smooth, smoothResolution, filled } = {
+	const { shaftWidthRatio, arrowheadStyle, arrowheadWidthRatio, arrowheadLengthRatio, smooth, smoothResolution, filled } = {
 		...DEFAULT_BLOCK_ARROW_OPTIONS,
 		...options
 	};
@@ -2857,7 +2857,7 @@ function createBlockArrow(coordinates, options = {}) {
 	const { pts, pathLength, tip, dir, perp, segLength } = axis;
 	const requestedHeadLen = axis1.headLength ?? pathLength * arrowheadLengthRatio;
 	const headLen = Math.min(requestedHeadLen, segLength * .95);
-	const halfShaft = pathLength * shaftWidth / 2;
+	const halfShaft = pathLength * shaftWidthRatio / 2;
 	const halfHead = axis1.headHalfWidth ?? pathLength * arrowheadWidthRatio / 2;
 	const onAxis = (d, side = 0) => [tip[0] - dir[0] * d + perp[0] * side, tip[1] - dir[1] * d + perp[1] * side];
 	let shaftEndDist;
@@ -2956,7 +2956,7 @@ const BLOCK_ARROW = defineControlMeasure({
 			[-1.5, 0],
 			[.95, .4]
 		],
-		options: { shaftWidth: .2 }
+		options: { shaftWidthRatio: .2 }
 	}
 });
 function axis1Geometry(coordinates) {
@@ -3006,10 +3006,8 @@ const DEFAULT_BOUNDARY_OPTIONS = {
 	echelonPadding: .3,
 	labelRepetitions: 1,
 	labelSpacing: 1,
-	unit1Designator: "",
-	unit1Country: "",
-	unit2Designator: "",
-	unit2Country: "",
+	labelPadding: .4,
+	labelOrientation: "along",
 	smooth: false,
 	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$4
 };
@@ -3100,6 +3098,54 @@ const BOUNDARY_METADATA = {
 			max: 2,
 			step: .05,
 			visibleWhen: (opts) => Number(opts.labelRepetitions ?? 1) > 1
+		},
+		{
+			key: "labelPadding",
+			label: "Label padding",
+			description: "Gap between the line/echelon and the unit labels, as a ratio of the echelon height",
+			type: "number",
+			min: 0,
+			max: 2,
+			step: .05
+		},
+		{
+			key: "labelOrientation",
+			label: "Label orientation",
+			description: "Unit labels along the line, or per MIL-STD-2525E Figure L-10: on mostly north–south segments the label group rotates perpendicular to the line as a single row crossing it.",
+			type: "enum",
+			options: [{
+				value: "along",
+				label: "Along the line"
+			}, {
+				value: "standard",
+				label: "Standard (MIL-STD-2525E)"
+			}]
+		}
+	],
+	textAmplifiers: [
+		{
+			key: "T",
+			label: "Unit designation",
+			description: "Field T — unique designation of the unit on the left-of-travel side.",
+			maxLength: 32
+		},
+		{
+			key: "AS",
+			label: "Country",
+			description: "Field AS — country code of the unit on the left-of-travel side.",
+			maxLength: 8
+		},
+		{
+			key: "T1",
+			label: "Unit designation (other side)",
+			description: "Field T1 — unique designation of the unit on the right-of-travel side.",
+			maxLength: 32
+		},
+		{
+			key: "AS1",
+			label: "Country (other side)",
+			description: "Field AS1 — country code of the unit on the right-of-travel side.",
+			maxLength: 8
 		}
 	]
 };
@@ -3114,30 +3160,33 @@ function labelRotationAlong(dir) {
 	const rendered = -Math.atan2(dir[1], dir[0]);
 	return normalizeRadians(Math.PI - keepTextLeftToRight(rendered));
 }
-/** Emits the T (designator) and AS (country) labels for both unit sides. */
+/**
+* Emits a single combined `T (AS)` label per unit side (APP-6/MIL-STD-2525):
+* designator and country code share one text row rather than stacking.
+*/
 function pushUnitLabels(out, frame, units) {
-	const { center, perp, h, rotation, labelSize } = frame;
-	const designatorOffset = h * .85;
-	const countryOffset = designatorOffset + h * 1.1;
-	const label = (side, offset, text) => {
+	const { center, perp, offset, rotation, labelSize } = frame;
+	for (const { side, designator, country, textAnchor } of units) {
+		let text;
+		if (designator.length > 0 && country.length > 0) text = `${designator} (${country})`;
+		else if (designator.length > 0) text = designator;
+		else if (country.length > 0) text = `(${country})`;
+		else continue;
 		const q = vecAdd(center, vecScale(perp, side * offset));
-		return {
+		out.push({
 			type: "Feature",
 			properties: {
 				part: "label",
 				text,
 				rotation,
+				...textAnchor ? { textAnchor } : {},
 				...labelSize
 			},
 			geometry: {
 				type: "Point",
 				coordinates: unproject(q[0], q[1])
 			}
-		};
-	};
-	for (const { side, designator, country } of units) {
-		if (designator.length > 0) out.push(label(side, designatorOffset, designator));
-		if (country.length > 0) out.push(label(side, countryOffset, country));
+		});
 	}
 }
 /**
@@ -3147,9 +3196,15 @@ function pushUnitLabels(out, frame, units) {
 * @param positions - Boundary anchor points (≥2); the input contract is
 *   enforced at the render seam (ADR-0014).
 * @param options - {@link BoundaryOptions}.
+* @param textAmplifiers - Normalized text amplifiers (ADR-0027): `T`/`AS` label
+*   unit 1 (left-of-travel side), `T1`/`AS1` label unit 2 (right-of-travel side).
 */
-function createBoundary(positions, options = {}) {
-	const { echelon = DEFAULT_BOUNDARY_OPTIONS.echelon, echelonSize = DEFAULT_BOUNDARY_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_BOUNDARY_OPTIONS.echelonPadding, metersPerPixel, labelSizeZoom, labelSizeResolution, labelRepetitions = DEFAULT_BOUNDARY_OPTIONS.labelRepetitions, labelSpacing = DEFAULT_BOUNDARY_OPTIONS.labelSpacing, unit1Designator = "", unit1Country = "", unit2Designator = "", unit2Country = "", smooth = DEFAULT_BOUNDARY_OPTIONS.smooth, smoothResolution = DEFAULT_BOUNDARY_OPTIONS.smoothResolution } = options;
+function createBoundary(positions, options = {}, textAmplifiers = {}) {
+	const { echelon = DEFAULT_BOUNDARY_OPTIONS.echelon, echelonSize = DEFAULT_BOUNDARY_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_BOUNDARY_OPTIONS.echelonPadding, metersPerPixel, labelSizeZoom, labelSizeResolution, labelRepetitions = DEFAULT_BOUNDARY_OPTIONS.labelRepetitions, labelSpacing = DEFAULT_BOUNDARY_OPTIONS.labelSpacing, labelPadding = DEFAULT_BOUNDARY_OPTIONS.labelPadding, labelOrientation = DEFAULT_BOUNDARY_OPTIONS.labelOrientation, smooth = DEFAULT_BOUNDARY_OPTIONS.smooth, smoothResolution = DEFAULT_BOUNDARY_OPTIONS.smoothResolution } = options;
+	const unit1Designator = textAmplifiers.T ?? "";
+	const unit1Country = textAmplifiers.AS ?? "";
+	const unit2Designator = textAmplifiers.T1 ?? "";
+	const unit2Country = textAmplifiers.AS1 ?? "";
 	let h = echelonSize;
 	if (echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) h = echelonSizePixels * metersPerPixel;
 	h = Math.max(EPSILON, h);
@@ -3199,32 +3254,50 @@ function createBoundary(positions, options = {}) {
 		}
 		const d = Math.max(0, Math.min(seg.length, target - acc));
 		const center = vecAdd(seg.start, vecScale(seg.along, d));
-		const rotation = labelRotationAlong(seg.along);
+		const units = [{
+			side: 1,
+			designator: unit1Designator,
+			country: unit1Country
+		}, {
+			side: -1,
+			designator: unit2Designator,
+			country: unit2Country
+		}];
+		const rotateGroup = labelOrientation === "standard" && Math.abs(seg.along[0]) < Math.abs(seg.along[1]);
+		const readingAxis = seg.perp[0] >= 0 ? seg.perp : vecScale(seg.perp, -1);
+		const glyphAlong = rotateGroup ? readingAxis : seg.along;
+		const glyphPerp = rotateGroup ? [-readingAxis[1], readingAxis[0]] : seg.perp;
+		let glyphWidth = 0;
 		if (spec) {
-			const { strokes, fills, width } = buildEchelonGlyph(center, seg.along, seg.perp, h, spec);
+			const { strokes, fills, width } = buildEchelonGlyph(center, glyphAlong, glyphPerp, h, spec);
+			glyphWidth = width;
 			glyphStrokes.push(...strokes);
 			glyphFills.push(...fills);
-			const halfGap = width / 2 + Math.max(0, echelonPadding) * h;
+			const halfGap = (rotateGroup ? h : width) / 2 + Math.max(0, echelonPadding) * h;
 			gaps.push({
 				g0: target - halfGap,
 				g1: target + halfGap
 			});
 		}
-		pushUnitLabels(labelFeatures, {
+		if (rotateGroup) {
+			const sign = vecDot(seg.perp, readingAxis) >= 0 ? 1 : -1;
+			const clearance = glyphWidth / 2 + Math.max(0, labelPadding) * h;
+			units[0].textAnchor = sign > 0 ? "start" : "end";
+			units[1].textAnchor = sign > 0 ? "end" : "start";
+			pushUnitLabels(labelFeatures, {
+				center,
+				perp: vecScale(readingAxis, sign),
+				offset: clearance,
+				rotation: labelRotationAlong(readingAxis),
+				labelSize
+			}, units);
+		} else pushUnitLabels(labelFeatures, {
 			center,
 			perp: seg.perp,
-			h,
-			rotation,
+			offset: (.45 + Math.max(0, labelPadding)) * h,
+			rotation: labelRotationAlong(seg.along),
 			labelSize
-		}, [{
-			side: 1,
-			designator: unit1Designator,
-			country: unit1Country
-		}, {
-			side: -1,
-			designator: unit2Designator,
-			country: unit2Country
-		}]);
+		}, units);
 	}
 	const boundaryCoords = buildGappedLine(verts, gaps);
 	const features = [];
@@ -4990,7 +5063,7 @@ const BLADE_LENGTH_FRACTION = .8;
 const DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS = {
 	arrowheadLengthRatio: .07,
 	arrowheadWidthRatio: .67,
-	bladeHeight: .03
+	bladeHeightRatio: .03
 };
 const FPF_SHARED = {
 	entity: "Maneuver Lines",
@@ -5020,7 +5093,7 @@ const FPF_SHARED = {
 			step: .01
 		},
 		{
-			key: "bladeHeight",
+			key: "bladeHeightRatio",
 			label: "Blade height",
 			description: "Blade's perpendicular reach into the V, as a fraction of its arm's length",
 			type: "number",
@@ -5050,7 +5123,7 @@ const FINAL_PROTECTIVE_FIRE_RIGHT_METADATA = {
 * Builds the filled "blade": a uniform-width rectangle hugging the inside of
 * one arm. One long edge lies on the central 80% of the arm line (connected to
 * the line); the strip bulges perpendicularly into the inside of the V by
-* `bladeHeight * armLength`.
+* `bladeHeightRatio * armLength`.
 *
 * @param vertex - PT 1, the shared vertex of the V (projected)
 * @param tip - the outward tip of the bladed arm (projected)
@@ -5058,7 +5131,7 @@ const FINAL_PROTECTIVE_FIRE_RIGHT_METADATA = {
 *   be undefined during live single-arm feedback, in which case a default side
 *   is chosen
 */
-function bladeRectangle(vertex, tip, otherTip, bladeHeight) {
+function bladeRectangle(vertex, tip, otherTip, bladeHeightRatio) {
 	const v = vecSub(tip, vertex);
 	const armLength = vecMag(v);
 	if (armLength < 1e-6) return null;
@@ -5071,7 +5144,7 @@ function bladeRectangle(vertex, tip, otherTip, bladeHeight) {
 	const gap = (1 - BLADE_LENGTH_FRACTION) / 2;
 	const onLineNear = vecAdd(vertex, vecScale(dir, armLength * gap));
 	const onLineFar = vecAdd(vertex, vecScale(dir, armLength * (1 - gap)));
-	const height = vecScale(perp, armLength * bladeHeight);
+	const height = vecScale(perp, armLength * bladeHeightRatio);
 	return [
 		onLineNear,
 		onLineFar,
@@ -5093,7 +5166,7 @@ function bladeRectangle(vertex, tip, otherTip, bladeHeight) {
 * @param options - Arrowhead and blade sizing parameters
 */
 function createFinalProtectiveFire(coordinates, bladedArm, options = {}) {
-	const { arrowheadLengthRatio, arrowheadWidthRatio, bladeHeight } = {
+	const { arrowheadLengthRatio, arrowheadWidthRatio, bladeHeightRatio } = {
 		...DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS,
 		...options
 	};
@@ -5113,7 +5186,7 @@ function createFinalProtectiveFire(coordinates, bladedArm, options = {}) {
 	const bladeTip = v.tips[bladedArm];
 	if (bladeTip) {
 		const otherTip = v.tips[bladedArm === 0 ? 1 : 0];
-		const blade = bladeRectangle(v.vertex, bladeTip, otherTip, Math.max(0, bladeHeight));
+		const blade = bladeRectangle(v.vertex, bladeTip, otherTip, Math.max(0, bladeHeightRatio));
 		if (blade) {
 			const ring = [...blade, blade[0]].map((c) => unproject(c[0], c[1]));
 			features.push({
@@ -5299,14 +5372,14 @@ const FIX = defineControlMeasure({
 //#region src/generators/cm14-maneuver-lines/flot.ts
 const DEFAULT_RADIUS = 50;
 const DEFAULT_RADIUS_PIXELS = 10;
-const DEFAULT_RESOLUTION = 16;
+const DEFAULT_ARC_SEGMENTS = 16;
 /**
 * Default options for the FLOT graphic.
 */
 const DEFAULT_FLOT_OPTIONS = {
 	radius: DEFAULT_RADIUS,
 	radiusPixels: DEFAULT_RADIUS_PIXELS,
-	resolution: DEFAULT_RESOLUTION
+	arcSegments: DEFAULT_ARC_SEGMENTS
 };
 const FLOT_METADATA = {
 	id: "flot",
@@ -5341,8 +5414,8 @@ const FLOT_METADATA = {
 			unit: "m"
 		},
 		{
-			key: "resolution",
-			label: "Resolution",
+			key: "arcSegments",
+			label: "Arc segments",
 			description: "Number of points used to render each semicircle",
 			type: "number",
 			min: 4,
@@ -5362,16 +5435,16 @@ const FLOT_METADATA = {
 * @param segmentDir - Direction vector of the segment (normalized)
 * @param perpDir - Perpendicular direction vector (normalized)
 * @param radius - Radius of the semicircle
-* @param resolution - Number of points in the arc
+* @param arcSegments - Number of points in the arc
 * @param includeStart - Whether to include the start point
 * @returns Array of arc points forming a true semicircle
 */
-function generateArcPoints(startPoint, segmentDir, perpDir, radius, resolution, includeStart) {
+function generateArcPoints(startPoint, segmentDir, perpDir, radius, arcSegments, includeStart) {
 	const points = [];
 	const startIndex = includeStart ? 0 : 1;
 	const center = vecAdd(startPoint, vecScale(segmentDir, radius));
-	for (let i = startIndex; i <= resolution; i++) {
-		const t = i / resolution;
+	for (let i = startIndex; i <= arcSegments; i++) {
+		const t = i / arcSegments;
 		const angle = Math.PI * (1 - t);
 		const alongSegment = Math.cos(angle) * radius;
 		const perpOffset = Math.sin(angle) * radius;
@@ -5386,11 +5459,11 @@ function generateArcPoints(startPoint, segmentDir, perpDir, radius, resolution,
 * @param p1 - Start position (projected)
 * @param p2 - End position (projected)
 * @param radius - Radius of each semicircle
-* @param resolution - Points per arc
+* @param arcSegments - Points per arc
 * @param isFirstSegment - Whether this is the first segment (include start point)
 * @returns Array of points forming the scalloped line for this segment
 */
-function processSegment(p1, p2, radius, resolution, isFirstSegment) {
+function processSegment(p1, p2, radius, arcSegments, isFirstSegment) {
 	const segmentVec = vecSub(p2, p1);
 	const segmentLength = vecMag(segmentVec);
 	if (segmentLength < 1e-6) return isFirstSegment ? [p1] : [];
@@ -5402,14 +5475,14 @@ function processSegment(p1, p2, radius, resolution, isFirstSegment) {
 	const remainingLength = segmentLength - numFullArcs * diameter;
 	let currentPos = p1;
 	for (let arcIndex = 0; arcIndex < numFullArcs; arcIndex++) {
-		const arcPoints = generateArcPoints(currentPos, segmentDir, perpDir, radius, resolution, arcIndex === 0 && isFirstSegment);
+		const arcPoints = generateArcPoints(currentPos, segmentDir, perpDir, radius, arcSegments, arcIndex === 0 && isFirstSegment);
 		points.push(...arcPoints);
 		currentPos = vecAdd(currentPos, vecScale(segmentDir, diameter));
 	}
 	if (remainingLength > diameter * .1) {
 		const partialRadius = remainingLength / 2;
-		const partialResolution = Math.max(3, Math.round(resolution * (partialRadius / radius)));
-		const arcPoints = generateArcPoints(currentPos, segmentDir, perpDir, partialRadius, partialResolution, numFullArcs === 0 && isFirstSegment);
+		const partialArcSegments = Math.max(3, Math.round(arcSegments * (partialRadius / radius)));
+		const arcPoints = generateArcPoints(currentPos, segmentDir, perpDir, partialRadius, partialArcSegments, numFullArcs === 0 && isFirstSegment);
 		points.push(...arcPoints);
 	}
 	return points;
@@ -5429,22 +5502,22 @@ function processSegment(p1, p2, radius, resolution, isFirstSegment) {
 * ```typescript
 * const flot = createFLOT(
 *   [[-122.4194, 37.7749], [-122.4100, 37.7800], [-122.4000, 37.7750]],
-*   { radius: 100, resolution: 20 }
+*   { radius: 100, arcSegments: 20 }
 * );
 * ```
 */
 function createFLOT(positions, options = {}) {
-	const { radius = DEFAULT_RADIUS, radiusPixels, metersPerPixel, resolution = DEFAULT_RESOLUTION } = options;
+	const { radius = DEFAULT_RADIUS, radiusPixels, metersPerPixel, arcSegments = DEFAULT_ARC_SEGMENTS } = options;
 	let effectiveRadius = radius;
 	if (radiusPixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) effectiveRadius = radiusPixels * metersPerPixel;
 	const safeRadius = Math.max(EPSILON, effectiveRadius);
-	const safeResolution = Math.max(3, Math.round(resolution));
+	const safeArcSegments = Math.max(3, Math.round(arcSegments));
 	const projectedPoints = positions.map((p) => project(p[0], p[1]));
 	const allPoints = [];
 	for (let i = 0; i < projectedPoints.length - 1; i++) {
 		const p1 = projectedPoints[i];
 		const p2 = projectedPoints[i + 1];
-		const segmentPoints = processSegment(p1, p2, safeRadius, safeResolution, i === 0);
+		const segmentPoints = processSegment(p1, p2, safeRadius, safeArcSegments, i === 0);
 		allPoints.push(...segmentPoints);
 	}
 	if (allPoints.length > 0 && projectedPoints.length > 1) {
@@ -5473,15 +5546,15 @@ const FLOT = defineControlMeasure({
 });
 //#endregion
 //#region src/generators/cm29-protection-lines/fortifiedLine.ts
-const DEFAULT_SIZE = 50;
-const DEFAULT_SIZE_PIXELS = 10;
+const DEFAULT_TOOTH_SIZE = 50;
+const DEFAULT_TOOTH_SIZE_PIXELS = 10;
 const DEFAULT_SMOOTH_RESOLUTION$1 = 16;
 /**
 * Default options for the Fortified Line graphic.
 */
 const DEFAULT_FORTIFIED_LINE_OPTIONS = {
-	size: DEFAULT_SIZE,
-	sizePixels: DEFAULT_SIZE_PIXELS,
+	toothSize: DEFAULT_TOOTH_SIZE,
+	toothSizePixels: DEFAULT_TOOTH_SIZE_PIXELS,
 	smooth: false,
 	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$1
 };
@@ -5571,9 +5644,9 @@ function processFortifiedSegment(p1, p2, size, isFirstSegment) {
 * Calculates the effective size based on options and projection.
 */
 function calculateEffectiveSize(options) {
-	const { size = DEFAULT_SIZE, sizePixels, metersPerPixel } = options;
-	let effectiveSize = size;
-	if (sizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) effectiveSize = sizePixels * metersPerPixel;
+	const { toothSize = DEFAULT_TOOTH_SIZE, toothSizePixels, metersPerPixel } = options;
+	let effectiveSize = toothSize;
+	if (toothSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) effectiveSize = toothSizePixels * metersPerPixel;
 	return Math.max(EPSILON, effectiveSize);
 }
 /**
@@ -5825,8 +5898,8 @@ const ISOLATE = defineControlMeasure({
 //#region src/generators/cm15-maneuver-areas/mainAttack.ts
 const DEFAULT_MAIN_ATTACK_OPTIONS = {
 	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
-	roundedBends: false,
-	bendSegments: 5
+	smooth: false,
+	smoothResolution: 5
 };
 const MAIN_ATTACK_METADATA = {
 	id: "main-attack",
@@ -6731,8 +6804,8 @@ const STRONG_POINT = defineControlMeasure({
 //#region src/generators/cm15-maneuver-areas/supportByFire.ts
 const DEFAULT_SUPPORT_BY_FIRE_OPTIONS = {
 	arrowheadWidthRatio: .3,
-	backLineLengthRatio: .3,
-	backLineAngle: 45
+	rearLineLengthRatio: .3,
+	rearLineAngle: 45
 };
 const SUPPORT_BY_FIRE_METADATA = {
 	id: "support-by-fire",
@@ -6759,8 +6832,8 @@ const SUPPORT_BY_FIRE_METADATA = {
 function createSupportByFire(coordinates, options = {}) {
 	const featureProps = {};
 	const arrowheadWidthRatio = options.arrowheadWidthRatio ?? DEFAULT_SUPPORT_BY_FIRE_OPTIONS.arrowheadWidthRatio;
-	const backLineLengthRatio = options.backLineLengthRatio ?? DEFAULT_SUPPORT_BY_FIRE_OPTIONS.backLineLengthRatio;
-	const backLineAngle = options.backLineAngle ?? DEFAULT_SUPPORT_BY_FIRE_OPTIONS.backLineAngle;
+	const rearLineLengthRatio = options.rearLineLengthRatio ?? DEFAULT_SUPPORT_BY_FIRE_OPTIONS.rearLineLengthRatio;
+	const rearLineAngle = options.rearLineAngle ?? DEFAULT_SUPPORT_BY_FIRE_OPTIONS.rearLineAngle;
 	const c1 = coordinates[0];
 	const c2 = coordinates[1];
 	const c3 = coordinates[2];
@@ -6776,13 +6849,13 @@ function createSupportByFire(coordinates, options = {}) {
 		type: "FeatureCollection",
 		features: []
 	};
-	const angleRad = backLineAngle * Math.PI / 180;
+	const angleRad = rearLineAngle * Math.PI / 180;
 	const baseAngle = -Math.PI / 2;
 	const angleLeft = baseAngle - angleRad;
 	const dirBackLeft = [dirBase[0] * Math.cos(angleLeft) - dirBase[1] * Math.sin(angleLeft), dirBase[0] * Math.sin(angleLeft) + dirBase[1] * Math.cos(angleLeft)];
 	const angleRight = baseAngle + angleRad;
 	const dirBackRight = [dirBase[0] * Math.cos(angleRight) - dirBase[1] * Math.sin(angleRight), dirBase[0] * Math.sin(angleRight) + dirBase[1] * Math.cos(angleRight)];
-	const backLen = lenBase * backLineLengthRatio;
+	const backLen = lenBase * rearLineLengthRatio;
 	const p1Back = vecAdd(p1, vecScale(dirBackLeft, backLen));
 	const p2Back = vecAdd(p2, vecScale(dirBackRight, backLen));
 	const vLeft = vecSub(p3, p1);
@@ -6877,8 +6950,8 @@ const SUPPORT_BY_FIRE = defineControlMeasure({
 //#region src/generators/cm15-maneuver-areas/supportingAttack.ts
 const DEFAULT_SUPPORTING_ATTACK_OPTIONS = {
 	shaftWidthRatio: DEFAULT_SHAFT_WIDTH_RATIO,
-	roundedBends: false,
-	bendSegments: 5
+	smooth: false,
+	smoothResolution: 5
 };
 const SUPPORTING_ATTACK_METADATA = {
 	id: "supporting-attack",
@@ -7208,6 +7281,127 @@ function applyLayer(target, layer) {
 	}
 }
 //#endregion
+//#region src/text-amplifiers.ts
+/**
+* The vocabulary of text amplifier fields: doctrinal code, milsymbol-style
+* friendly alias, and a human-readable label. The single source of truth for
+* both the runtime catalog and the derived alias→code lookup used by
+* {@link normalizeTextAmplifiers}.
+*/
+const TEXT_AMPLIFIER_FIELDS = {
+	C: {
+		alias: "quantity",
+		label: "Quantity"
+	},
+	H: {
+		alias: "additionalInformation",
+		label: "Additional information"
+	},
+	N: {
+		alias: "hostile",
+		label: "Hostile (ENY) marker"
+	},
+	T: {
+		alias: "uniqueDesignation",
+		label: "Unique designation"
+	},
+	V: {
+		alias: "type",
+		label: "Equipment/type"
+	},
+	W: {
+		alias: "dtg",
+		label: "Date-time group / O/O"
+	},
+	X: {
+		alias: "altitudeDepth",
+		label: "Altitude/depth"
+	},
+	Y: {
+		alias: "location",
+		label: "Location"
+	},
+	AM: {
+		alias: "distance",
+		label: "Distance/range/radius"
+	},
+	AN: {
+		alias: "azimuth",
+		label: "Azimuth"
+	},
+	AP: {
+		alias: "targetNumber",
+		label: "Target number"
+	},
+	AS: {
+		alias: "country",
+		label: "Country code"
+	}
+};
+/** Derived alias→code lookup, so the vocabulary table stays the single source of truth. */
+const CODE_BY_ALIAS = Object.fromEntries(Object.entries(TEXT_AMPLIFIER_FIELDS).map(([code, { alias }]) => [alias, code]));
+const CANONICAL_KEYS = new Set(Object.keys(TEXT_AMPLIFIER_FIELDS).flatMap((code) => [
+	code,
+	`${code}1`,
+	`${code}2`
+]));
+const EMPTY_TEXT_AMPLIFIERS = Object.freeze({});
+/** Splits a key like `"country1"` into its base (`"country"`) and suffix (`"1"`). */
+function splitSuffix(key) {
+	const last = key.charAt(key.length - 1);
+	if (last === "1" || last === "2") return {
+		base: key.slice(0, -1),
+		suffix: last
+	};
+	return {
+		base: key,
+		suffix: ""
+	};
+}
+/**
+* Resolves any accepted key (canonical or friendly alias, with an optional
+* `1`/`2` suffix) to its canonical key, or `undefined` if unknown — e.g.
+* `"T"` → `"T"`, `"uniqueDesignation1"` → `"T1"`, `"bogus"` → `undefined`.
+*/
+function canonicalTextAmplifierKey(key) {
+	if (CANONICAL_KEYS.has(key)) return key;
+	const { base, suffix } = splitSuffix(key);
+	const code = CODE_BY_ALIAS[base];
+	return code ? `${code}${suffix}` : void 0;
+}
+/**
+* Resolves a `TextAmplifiers` record (canonical keys, friendly aliases, or a
+* mix) to `CanonicalTextAmplifiers` keyed purely by doctrinal field code.
+*
+* - Friendly aliases (with an optional `1`/`2` suffix) map to their canonical
+*   code (e.g. `country1` → `AS1`).
+* - Values are trimmed; entries that are empty/whitespace-only after
+*   trimming, or not strings, are dropped.
+* - When both a canonical key and its friendly alias are present for the same
+*   field + suffix, the **canonical key wins** regardless of insertion order.
+*   This holds even for an empty/whitespace canonical value: it suppresses
+*   (clears) the alias entry rather than letting the alias survive.
+* - Unknown keys are ignored.
+*
+* `undefined` or an empty input returns a shared frozen empty object.
+*/
+function normalizeTextAmplifiers(input) {
+	if (!input) return EMPTY_TEXT_AMPLIFIERS;
+	const canonicalPresent = /* @__PURE__ */ new Set();
+	for (const [key, rawValue] of Object.entries(input)) if (typeof rawValue === "string" && CANONICAL_KEYS.has(key)) canonicalPresent.add(key);
+	const result = {};
+	for (const [key, rawValue] of Object.entries(input)) {
+		if (typeof rawValue !== "string") continue;
+		const value = rawValue.trim();
+		if (value.length === 0) continue;
+		const canonicalKey = canonicalTextAmplifierKey(key);
+		if (!canonicalKey) continue;
+		if (!CANONICAL_KEYS.has(key) && canonicalPresent.has(canonicalKey)) continue;
+		result[canonicalKey] = value;
+	}
+	return Object.keys(result).length > 0 ? Object.freeze(result) : EMPTY_TEXT_AMPLIFIERS;
+}
+//#endregion
 //#region src/renderControlMeasure.ts
 /**
 * Pure render: `ControlMeasure` → `ControlMeasureRender` (a
@@ -7233,7 +7427,8 @@ function dispatchControlMeasure(cm, opts) {
 	const definition = DEFINITIONS[cm.kind];
 	if (!validateInputContract(cm.controlPoints, definition.metadata, opts?.validationMode)) return EMPTY_COLLECTION;
 	const generator = definition.generator;
-	return generator(cm.controlPoints, cm.options ?? {});
+	const textAmplifiers = normalizeTextAmplifiers(cm.textAmplifiers);
+	return generator(cm.controlPoints, cm.options ?? {}, textAmplifiers);
 }
 /**
 * The control-point *input contract*: at least `metadata.minCoordinates` points,
@@ -7259,6 +7454,7 @@ function normalizeFeature(id, feature, index, measureStyle, graphicsStyle) {
 	const textSizePixels = typeof sourceProps.textSizePixels === "number" ? sourceProps.textSizePixels : void 0;
 	const textSizeZoom = typeof sourceProps.textSizeZoom === "number" ? sourceProps.textSizeZoom : void 0;
 	const textSizeResolution = typeof sourceProps.textSizeResolution === "number" ? sourceProps.textSizeResolution : void 0;
+	const textAnchor = sourceProps.textAnchor === "start" || sourceProps.textAnchor === "end" ? sourceProps.textAnchor : void 0;
 	return {
 		type: "Feature",
 		id: `${id}:${part}:${index}`,
@@ -7268,6 +7464,7 @@ function normalizeFeature(id, feature, index, measureStyle, graphicsStyle) {
 			style,
 			...text !== void 0 ? { text } : {},
 			...rotation !== void 0 ? { rotation } : {},
+			...textAnchor !== void 0 ? { textAnchor } : {},
 			...textSizePixels !== void 0 ? { textSizePixels } : {},
 			...textSizeZoom !== void 0 ? { textSizeZoom } : {},
 			...textSizeResolution !== void 0 ? { textSizeResolution } : {}
@@ -7321,4 +7518,4 @@ function assertNever(value) {
 	throw new Error(`Unhandled control measure kind: ${String(value)}`);
 }
 //#endregion
-export { point12DrawRule as $, DEFAULT_GENERIC_POLYGON_OPTIONS as A, DEFAULT_ANTITANK_WALL_OPTIONS as B, DEFAULT_FIX_OPTIONS as C, DEFAULT_DELAY_OPTIONS as D, DEFAULT_DISRUPT_OPTIONS as E, DEFAULT_BREACH_OPTIONS as F, axis1DrawRule as G, DEFAULT_AMBUSH_OPTIONS as H, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as I, line23DrawRule as J, supportByFireDrawRule as K, DEFAULT_BLOCK_OPTIONS as L, DEFAULT_GENERIC_CIRCLE_OPTIONS as M, DEFAULT_CANALIZE_OPTIONS as N, DEFAULT_CLEAR_OPTIONS as O, DEFAULT_BYPASS_OPTIONS as P, attackByFireDrawRule as Q, DEFAULT_ATTACK_HELICOPTER_OPTIONS as R, DEFAULT_FLOT_OPTIONS as S, DEFAULT_ENCIRCLEMENT_OPTIONS as T, DEFAULT_AIRBORNE_ATTACK_OPTIONS as U, DEFAULT_ANTITANK_DITCH_OPTIONS as V, rectangleDrawRule as W, line1DrawRule as X, turnDrawRule as Y, ambushDrawRule as Z, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as _, DEFINITIONS as a, getMidpointPerpendicularSignedDistance as at, DEFAULT_FORTIFIED_AREA_OPTIONS as b, getDefaultOptions as c, createBaselineFrame as ct, DEFAULT_SUPPORTING_ATTACK_OPTIONS as d, project as dt, centerRadiusDrawRule as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, unproject as ft, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as g, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as h, roundToFixed as ht, CONTROL_MEASURE_METADATA as i, createMidpointPerpendicularDrawRule as it, DEFAULT_GENERIC_LINE_OPTIONS as j, DEFAULT_GENERIC_RECTANGLE_OPTIONS as k, listControlMeasureMetadata as l, calculateMetrics as lt, DEFAULT_TACTICAL_ARROW_OPTIONS as m, getMetersPerPixel as mt, resolveStyleHints as n, blockDrawRule as nt, getControlMeasureMetadata as o, pointOnMidpointPerpendicularAxis as ot, DEFAULT_STRONG_POINT_OPTIONS as p, EPSILON as pt, line24DrawRule as q, CONTROL_MEASURE_IDS as r, computeDefaultMidpointPerpendicularPoint as rt, getControlMeasureMetadataByValue as s, snapToMidpointPerpendicular as st, renderControlMeasure as t, disruptDrawRule as tt, DEFAULT_TURN_OPTIONS as u, computeInitialWidthPoint as ut, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as v, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as w, DEFAULT_FORTIFIED_LINE_OPTIONS as x, DEFAULT_MAIN_ATTACK_OPTIONS as y, DEFAULT_ATTACK_BY_FIRE_OPTIONS as z };
+export { supportByFireDrawRule as $, DEFAULT_DELAY_OPTIONS as A, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as B, DEFAULT_FORTIFIED_AREA_OPTIONS as C, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as D, DEFAULT_FIX_OPTIONS as E, DEFAULT_GENERIC_CIRCLE_OPTIONS as F, DEFAULT_ATTACK_HELICOPTER_OPTIONS as G, DEFAULT_BLOCK_ARROW_OPTIONS as H, DEFAULT_CLASSIC_ARROW_OPTIONS as I, DEFAULT_ANTITANK_DITCH_OPTIONS as J, DEFAULT_ATTACK_BY_FIRE_OPTIONS as K, DEFAULT_CANALIZE_OPTIONS as L, DEFAULT_GENERIC_RECTANGLE_OPTIONS as M, DEFAULT_GENERIC_POLYGON_OPTIONS as N, DEFAULT_ENCIRCLEMENT_OPTIONS as O, DEFAULT_GENERIC_LINE_OPTIONS as P, axis1DrawRule as Q, DEFAULT_BYPASS_OPTIONS as R, DEFAULT_MAIN_ATTACK_OPTIONS as S, roundToFixed as St, DEFAULT_FLOT_OPTIONS as T, DEFAULT_BLOCK_OPTIONS as U, DEFAULT_BOUNDARY_OPTIONS as V, DEFAULT_BATTLE_POSITION_OPTIONS as W, DEFAULT_AIRBORNE_ATTACK_OPTIONS as X, DEFAULT_AMBUSH_OPTIONS as Y, rectangleDrawRule as Z, DEFAULT_TACTICAL_ARROW_OPTIONS as _, computeInitialWidthPoint as _t, resolveStyleHints as a, attackByFireDrawRule as at, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as b, EPSILON as bt, DEFINITIONS as c, disruptDrawRule as ct, getDefaultOptions as d, createMidpointPerpendicularDrawRule as dt, line24DrawRule as et, listControlMeasureMetadata as f, getMidpointPerpendicularSignedDistance as ft, DEFAULT_STRONG_POINT_OPTIONS as g, calculateMetrics as gt, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as h, createBaselineFrame as ht, normalizeTextAmplifiers as i, ambushDrawRule as it, DEFAULT_CLEAR_OPTIONS as j, DEFAULT_DISRUPT_OPTIONS as k, getControlMeasureMetadata as l, blockDrawRule as lt, DEFAULT_SUPPORTING_ATTACK_OPTIONS as m, snapToMidpointPerpendicular as mt, TEXT_AMPLIFIER_FIELDS as n, turnDrawRule as nt, CONTROL_MEASURE_IDS as o, point12DrawRule as ot, DEFAULT_TURN_OPTIONS as p, pointOnMidpointPerpendicularAxis as pt, DEFAULT_ANTITANK_WALL_OPTIONS as q, canonicalTextAmplifierKey as r, line1DrawRule as rt, CONTROL_MEASURE_METADATA as s, centerRadiusDrawRule as st, renderControlMeasure as t, line23DrawRule as tt, getControlMeasureMetadataByValue as u, computeDefaultMidpointPerpendicularPoint as ut, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as v, project as vt, DEFAULT_FORTIFIED_LINE_OPTIONS as w, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as x, getMetersPerPixel as xt, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as y, unproject as yt, DEFAULT_BREACH_OPTIONS as z };