@orbat-mapper/control-measures 0.12.1 → 0.14.0

package/dist/{renderControlMeasure-DYcehsHK.mjs → renderControlMeasure-BgPfnjvc.mjs}

@@ -280,7 +280,7 @@ const SHAFT_WIDTH_OPTION_HANDLE_ID = "shaft-width";
 /**
 * Creates the definition-owned rear-/shaft-width handle pair shared by every
 * variable-width arrow body. Callers supply only how their own geometry maps
-* onto {@link WidthHandleGeometry}; placement (the two ends of the left edge)
+* onto {@link WidthHandleGeometry}; placement (the two ends of the right edge)
 * and the drag math (perpendicular distance from the dragged point to the
 * matching centerline segment, over the reference half-width) live here once.
 */
@@ -288,15 +288,15 @@ function createWidthOptionHandles(config) {
 	return {
 		get(controlPoints, options) {
 			const geometry = config.geometry(controlPoints, options);
-			const rearLeft = geometry?.leftEdge[0];
-			const neckLeft = geometry?.leftEdge.at(-1);
-			if (!rearLeft || !neckLeft) return [];
+			const rearRight = geometry?.rightEdge[0];
+			const neckRight = geometry?.rightEdge.at(-1);
+			if (!rearRight || !neckRight) return [];
 			return [{
 				id: REAR_WIDTH_OPTION_HANDLE_ID,
-				position: unproject(rearLeft[0], rearLeft[1])
+				position: unproject(rearRight[0], rearRight[1])
 			}, {
 				id: SHAFT_WIDTH_OPTION_HANDLE_ID,
-				position: unproject(neckLeft[0], neckLeft[1])
+				position: unproject(neckRight[0], neckRight[1])
 			}];
 		},
 		drag({ controlPoints, options, handleId, position }) {
@@ -328,7 +328,7 @@ function createVariableWidthAttackOptionHandles(resolveCoordinates = (points) =>
 			if (!geometry || !outerLeft) return null;
 			return {
 				spine: geometry.shaftCenterline,
-				leftEdge: geometry.shaftLeft,
+				rightEdge: geometry.shaftRight,
 				referenceHalfWidth: vecMag(vecSub(outerLeft, geometry.ptBase))
 			};
 		},
@@ -1349,6 +1349,23 @@ const line32DrawRule = {
 	}
 };
 //#endregion
+//#region src/draw-rules/polyline1.ts
+/**
+* Polyline1 anchors for the Infiltration Lane.
+*
+* PT1/PT2 are the two user clicks and define the invisible lane centerline. PT3 is an
+* automatically derived, editable width handle on the perpendicular through
+* its midpoint. It rests on one parallel boundary, so its signed distance
+* from PT1/PT2 is the lane half-width.
+*/
+const polyline1DrawRule = createMidpointPerpendicularDrawRule({
+	id: "polyline1:infiltration-lane",
+	defaultDistanceRatio: .18,
+	minimumUserPoints: 2,
+	minimumPreviewPoints: 2,
+	normal: "left"
+});
+//#endregion
 //#region src/draw-rules/area8.ts
 function derive$3(points) {
 	if (points.length < 2) return clonePositions(points);
@@ -1697,6 +1714,16 @@ const ECHELON_PARAM_OPTIONS = [{
 	label: spec.label,
 	value
 }))];
+/**
+* Effective echelon glyph height in meters. Screen-anchored when a pixel size
+* is supplied with a live resolution; ground-anchored (meters) otherwise.
+* Clamped strictly positive.
+*/
+function resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel) {
+	let h = echelonSize;
+	if (echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) h = echelonSizePixels * metersPerPixel;
+	return Math.max(EPSILON, h);
+}
 function resolveEchelon(echelon) {
 	const key = echelon.trim().toLowerCase();
 	if (key.length === 0) return void 0;
@@ -2677,6 +2704,26 @@ function labelRotationAlong(dir) {
 	const rendered = -Math.atan2(dir[1], dir[0]);
 	return normalizeRadians(Math.PI - keepTextLeftToRight(rendered));
 }
+/** Resolves two echelon-unit rows from a caller-selected set of amplifiers. */
+function unitLabelsFromAmplifiers(amplifiers, fields) {
+	return [{
+		side: 1,
+		designator: amplifiers[fields.unit1.designator] ?? "",
+		country: amplifiers[fields.unit1.country] ?? ""
+	}, {
+		side: -1,
+		designator: amplifiers[fields.unit2.designator] ?? "",
+		country: amplifiers[fields.unit2.country] ?? ""
+	}];
+}
+/** Text size shared by an echelon glyph and its associated unit labels. */
+function echelonUnitLabelSize(echelonHeight, echelonSizePixels, metersPerPixel) {
+	const screenAnchored = echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0;
+	return {
+		properties: screenAnchored ? { textSizePixels: echelonSizePixels } : { textSizeMeters: echelonHeight },
+		screenAnchored
+	};
+}
 /**
 * 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.
@@ -2693,6 +2740,43 @@ function pushUnitLabels(out, frame, units) {
 	}
 }
 /**
+* Default clearance between an echelon glyph and its unit labels, as a ratio of
+* the glyph height — the value Boundary declares as its `labelPadding` default,
+* shared so other echelon-carrying lines land on the same spacing.
+*/
+const ECHELON_UNIT_LABEL_PADDING = .4;
+/**
+* Emits Boundary-style unit labels around echelon groups. Along-line groups
+* straddle the line; standard-orientation groups on north/south segments form
+* one row crossing it, anchored outward from the glyph.
+*/
+function pushEchelonUnitLabels(out, groups, units, echelonHeight, labelPadding, labelSize) {
+	for (const { center, along, perp, rotateGroup, readingAxis, glyphWidth } of groups) {
+		if (rotateGroup) {
+			const sign = vecDot(perp, readingAxis) >= 0 ? 1 : -1;
+			const clearance = glyphWidth / 2 + Math.max(0, labelPadding) * echelonHeight;
+			pushUnitLabels(out, {
+				center,
+				perp: vecScale(readingAxis, sign),
+				offset: clearance,
+				rotation: labelRotationAlong(readingAxis),
+				labelSize
+			}, units.map((unit) => ({
+				...unit,
+				textAnchor: unit.side === sign ? "start" : "end"
+			})));
+			continue;
+		}
+		pushUnitLabels(out, {
+			center,
+			perp,
+			offset: (.45 + Math.max(0, labelPadding)) * echelonHeight,
+			rotation: labelRotationAlong(along),
+			labelSize
+		}, units);
+	}
+}
+/**
 * Walks `verts` (projected meters) into non-degenerate {@link LineSegment}s,
 * skipping coincident vertices (ADR-0014, silent) the same way Boundary's
 * gap-carving does. Empty or fully-degenerate input yields `totalLength: 0`
@@ -2725,6 +2809,15 @@ function clampLinePosition(value, fallback) {
 	return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : fallback;
 }
 /**
+* Resolves a label/group repetition count to a positive whole number. Takes
+* `unknown` because the params panel's `visibleWhen` callbacks receive loosely
+* typed options; non-finite input falls back to a single group.
+*/
+function resolveLabelRepetitions(value) {
+	const numeric = Number(value ?? 1);
+	return Number.isFinite(numeric) ? Math.max(1, Math.round(numeric)) : 1;
+}
+/**
 * Resolves the point at `fraction` (clamped to `[0, 1]`) of `totalLength`
 * along `segments`, walking cumulative arc length exactly like Boundary's
 * label-group placement: the segment containing the target distance absorbs
@@ -3466,14 +3559,14 @@ const DEFAULT_ARROWHEAD_WIDTH_RATIO$1 = 1.15;
 const DEFAULT_BOW_TIE_LENGTH_RATIO = .1;
 const DEFAULT_BOW_TIE_WIDTH_RATIO = .5;
 const DEFAULT_BOW_TIE_POSITION = 1 / 3;
-const DEFAULT_LABEL_POSITION = 2 / 3;
+const DEFAULT_LABEL_POSITION$1 = 2 / 3;
 const DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS = {
 	arrowheadLengthRatio: DEFAULT_ARROWHEAD_LENGTH_RATIO$1,
 	arrowheadWidthRatio: DEFAULT_ARROWHEAD_WIDTH_RATIO$1,
 	bowTieLengthRatio: DEFAULT_BOW_TIE_LENGTH_RATIO,
 	bowTieWidthRatio: DEFAULT_BOW_TIE_WIDTH_RATIO,
 	bowTiePosition: DEFAULT_BOW_TIE_POSITION,
-	labelPosition: DEFAULT_LABEL_POSITION,
+	labelPosition: DEFAULT_LABEL_POSITION$1,
 	labelPadding: 0,
 	smooth: false,
 	smoothResolution: 12
@@ -3620,7 +3713,7 @@ function createDirectionOfAttackAviation(coordinates, options = {}, textAmplifie
 	};
 	const bowTieLength = Math.min(totalLength, totalLength * nonNegative(resolved.bowTieLengthRatio, DEFAULT_BOW_TIE_LENGTH_RATIO));
 	const bowTiePosition = clampLinePosition(resolved.bowTiePosition, DEFAULT_BOW_TIE_POSITION);
-	const labelPosition = clampLinePosition(resolved.labelPosition, DEFAULT_LABEL_POSITION);
+	const labelPosition = clampLinePosition(resolved.labelPosition, DEFAULT_LABEL_POSITION$1);
 	const bowTieCenterDistance = totalLength * bowTiePosition;
 	const bowTieStartDistance = Math.max(0, bowTieCenterDistance - bowTieLength / 2);
 	const bowTieEndDistance = Math.min(totalLength, bowTieCenterDistance + bowTieLength / 2);
@@ -3906,16 +3999,6 @@ function pointOnRing(segs, target) {
 		seg
 	};
 }
-/**
-* Effective echelon glyph height in meters. Screen-anchored when a pixel size
-* is supplied with a live resolution; ground-anchored (meters) otherwise.
-* Clamped strictly positive.
-*/
-function resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel) {
-	let h = echelonSize;
-	if (echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) h = echelonSizePixels * metersPerPixel;
-	return Math.max(EPSILON, h);
-}
 /** Wraps `x` into `[0, 1)`, treating `x` as a fraction (matches the arc-length wrap below). */
 function wrap01(x) {
 	return (x % 1 + 1) % 1;
@@ -4004,7 +4087,7 @@ const BAND_SAMPLE_FRACTIONS = [
 *  rerender); striding holds it to a fixed multiple of one ring scan. Rings
 *  with no more bands than this are still probed exhaustively. */
 const MAX_SAMPLED_BANDS = 48;
-const DEFAULT_SMOOTH_RESOLUTION$9 = 16;
+const DEFAULT_SMOOTH_RESOLUTION$8 = 16;
 /**
 * Composes an area's main label text from a `prefix` (e.g. `"AO"`) and a
 * `designation` (e.g. `"GREEN"`), mirroring Phase Line's "PL" precedent: a
@@ -4404,8 +4487,8 @@ function boundaryFeature(verts, gaps) {
 * common (no `N`) case is unaffected.
 */
 function labeledAreaFeatures(positions, options, texts, amplifierPlacements, context) {
-	const { smooth = false, smoothResolution = DEFAULT_SMOOTH_RESOLUTION$9, ...labelOptions } = options;
-	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$9);
+	const { smooth = false, smoothResolution = DEFAULT_SMOOTH_RESOLUTION$8, ...labelOptions } = options;
+	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$8);
 	const labelFeatures = [];
 	const features = [boundaryFeature(verts, pushAreaLabels(labelFeatures, verts, texts, labelOptions, amplifierPlacements, void 0, context))];
 	features.push(...labelFeatures);
@@ -5122,7 +5205,7 @@ const TARGET_AREA_OF_INTEREST = defineControlMeasure({
 });
 //#endregion
 //#region src/generators/cm12-command-control-areas/airfield-zone.ts
-const DEFAULT_SMOOTH_RESOLUTION$8 = 16;
+const DEFAULT_SMOOTH_RESOLUTION$7 = 16;
 /** Long runway line's tilt off the horizontal, in radians (+15°). */
 const LONG_LINE_ANGLE = 15 * Math.PI / 180;
 /** Short runway line's tilt off the horizontal, in radians (+50°). */
@@ -5137,7 +5220,7 @@ const H_LABEL_OFFSET_RATIO = .75;
 */
 const DEFAULT_AIRFIELD_ZONE_OPTIONS = {
 	smooth: true,
-	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$8,
+	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$7,
 	glyphSizeRatio: .55
 };
 const AIRFIELD_ZONE_METADATA = {
@@ -5195,7 +5278,7 @@ const AIRFIELD_ZONE_METADATA = {
 */
 function createAirfieldZone(positions, options = {}, textAmplifiers = {}, context = {}) {
 	const { smooth = DEFAULT_AIRFIELD_ZONE_OPTIONS.smooth, smoothResolution = DEFAULT_AIRFIELD_ZONE_OPTIONS.smoothResolution, glyphSizeRatio = DEFAULT_AIRFIELD_ZONE_OPTIONS.glyphSizeRatio, ...labelOptions } = options;
-	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$8);
+	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$7);
 	const enyLabels = [];
 	const features = [boundaryFeature(verts, textAmplifiers.N ? pushAreaLabels(enyLabels, verts, { hostile: textAmplifiers.N }, labelOptions, context.amplifierPlacements, void 0, context) : [])];
 	let minX = Infinity;
@@ -5253,7 +5336,7 @@ const AIRFIELD_ZONE = defineControlMeasure({
 });
 //#endregion
 //#region src/generators/cm12-command-control-areas/echelon-labeled-area.ts
-const DEFAULT_SMOOTH_RESOLUTION$7 = 16;
+const DEFAULT_SMOOTH_RESOLUTION$6 = 16;
 /** Default options shared by Base Camp and Guerrilla Base — echelon off, boundary rounded. */
 const DEFAULT_ECHELON_LABELED_AREA_OPTIONS = {
 	echelon: "none",
@@ -5262,7 +5345,7 @@ const DEFAULT_ECHELON_LABELED_AREA_OPTIONS = {
 	echelonPadding: .3,
 	echelonPosition: 0,
 	smooth: true,
-	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$7
+	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$6
 };
 /**
 * Builds the shared Base Camp / Guerrilla Base geometry: a closed area
@@ -5276,7 +5359,7 @@ const DEFAULT_ECHELON_LABELED_AREA_OPTIONS = {
 function echelonLabeledAreaFeatures(positions, options, texts, amplifierPlacements, context) {
 	const { echelon = DEFAULT_ECHELON_LABELED_AREA_OPTIONS.echelon, echelonSize = DEFAULT_ECHELON_LABELED_AREA_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_ECHELON_LABELED_AREA_OPTIONS.echelonPadding, echelonPosition = DEFAULT_ECHELON_LABELED_AREA_OPTIONS.echelonPosition, echelonAnchor, metersPerPixel, smooth = DEFAULT_ECHELON_LABELED_AREA_OPTIONS.smooth, smoothResolution = DEFAULT_ECHELON_LABELED_AREA_OPTIONS.smoothResolution, ...labelOptions } = options;
 	const h = resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel);
-	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$7);
+	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$6);
 	const { strokes, fills, gaps: echelonGaps } = placeEchelon(buildAreaPerimeter(verts), h, echelon, echelonPadding, echelonPosition, echelonAnchor);
 	const labelFeatures = [];
 	const enyGaps = pushAreaLabels(labelFeatures, verts, texts, labelOptions, amplifierPlacements, void 0, context);
@@ -6237,7 +6320,7 @@ const ATTACK_HELICOPTER = defineControlMeasure({
 });
 //#endregion
 //#region src/generators/cm15-maneuver-areas/battlePosition.ts
-const DEFAULT_SMOOTH_RESOLUTION$6 = 16;
+const DEFAULT_SMOOTH_RESOLUTION$5 = 16;
 /** Default options for the Battle Position control measure. */
 const DEFAULT_BATTLE_POSITION_OPTIONS = {
 	echelon: "battalion",
@@ -6246,7 +6329,7 @@ const DEFAULT_BATTLE_POSITION_OPTIONS = {
 	echelonPadding: .3,
 	echelonPosition: 0,
 	smooth: false,
-	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$6
+	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$5
 };
 const BATTLE_POSITION_METADATA = {
 	id: "battle-position",
@@ -6288,7 +6371,7 @@ const BATTLE_POSITION_METADATA = {
 function battlePositionAreaFeatures(positions, options, textAmplifiers, context, variant = {}) {
 	const { echelon = DEFAULT_BATTLE_POSITION_OPTIONS.echelon, echelonSize = DEFAULT_BATTLE_POSITION_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_BATTLE_POSITION_OPTIONS.echelonPadding, echelonPosition = DEFAULT_BATTLE_POSITION_OPTIONS.echelonPosition, echelonAnchor, metersPerPixel, smooth = DEFAULT_BATTLE_POSITION_OPTIONS.smooth, smoothResolution = DEFAULT_BATTLE_POSITION_OPTIONS.smoothResolution } = options;
 	const h = resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel);
-	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$6);
+	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$5);
 	const { strokes, fills, gaps } = placeEchelon(buildAreaPerimeter(verts), h, echelon, echelonPadding, echelonPosition, echelonAnchor);
 	const labelFeatures = [];
 	const enyGaps = pushAreaLabels(labelFeatures, verts, composeAreaLabelTexts(textAmplifiers, variant.namePrefix), options, context.amplifierPlacements, void 0, context);
@@ -6862,7 +6945,7 @@ const BRIDGE_OR_GAP = defineControlMeasure({
 });
 //#endregion
 //#region src/generators/cm99-generic-arrows/blockArrow.ts
-const DEFAULT_SMOOTH_RESOLUTION$5 = 12;
+const DEFAULT_SMOOTH_RESOLUTION$4 = 12;
 const MIN_SMOOTH_RESOLUTION$1 = 2;
 const MAX_SMOOTH_RESOLUTION$1 = 64;
 const DEFAULT_SHAFT_WIDTH_RATIO = .06;
@@ -6875,7 +6958,7 @@ const DEFAULT_BLOCK_ARROW_OPTIONS = {
 	arrowheadWidthRatio: .18,
 	arrowheadLengthRatio: .22,
 	smooth: false,
-	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$5,
+	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$4,
 	filled: true
 };
 const BLOCK_ARROW_METADATA = {
@@ -7110,6 +7193,7 @@ function calculateBlockArrowGeometry(coordinates, options) {
 		ring,
 		spine,
 		leftSide,
+		rightSide,
 		pathLength
 	};
 }
@@ -7134,7 +7218,7 @@ const BLOCK_ARROW = defineControlMeasure({
 			if (!geometry) return null;
 			return {
 				spine: geometry.spine,
-				leftEdge: geometry.leftSide,
+				rightEdge: geometry.rightSide,
 				referenceHalfWidth: geometry.pathLength / 2
 			};
 		},
@@ -7164,74 +7248,26 @@ function axis1Geometry(coordinates) {
 	};
 }
 function normalizeSmoothResolution$1(value) {
-	if (!Number.isFinite(value)) return DEFAULT_SMOOTH_RESOLUTION$5;
+	if (!Number.isFinite(value)) return DEFAULT_SMOOTH_RESOLUTION$4;
 	return Math.min(MAX_SMOOTH_RESOLUTION$1, Math.max(MIN_SMOOTH_RESOLUTION$1, Math.round(value)));
 }
 //#endregion
-//#region src/generators/cm11-command-control-lines/boundary.ts
-const DEFAULT_SMOOTH_RESOLUTION$4 = 12;
-function resolveLabelRepetitions(value) {
-	const numeric = Number(value ?? 1);
-	return Number.isFinite(numeric) ? Math.max(1, Math.round(numeric)) : 1;
-}
-/** Default options for the Boundary control measure. */
-const DEFAULT_BOUNDARY_OPTIONS = {
-	echelon: "battalion",
-	echelonSize: 750,
-	echelonSizePixels: 16,
-	echelonPadding: .3,
-	labelRepetitions: 1,
-	labelSpacing: 1,
-	labelPosition: .5,
-	labelPadding: .4,
-	labelOrientation: "along",
-	smooth: false,
-	smoothResolution: DEFAULT_SMOOTH_RESOLUTION$4
-};
-const BOUNDARY_METADATA = {
-	id: "boundary",
-	name: "Boundary",
-	description: "Delineates the area of responsibility between two adjacent units, labeled with the echelon and the designators of the units it separates.",
-	entity: "Command and Control Lines",
-	entityType: "Boundary",
-	value: "110100",
-	minCoordinates: 2,
-	geometry: "line",
-	geometryTypes: [
-		"MultiLineString",
-		"MultiPolygon",
-		"Point"
-	],
-	paints: {
-		stroke: true,
-		fill: "fixed",
-		text: true
-	},
-	drawRule: "Line1",
-	params: [
-		{
-			key: "smooth",
-			label: "Smooth",
-			description: "Round the boundary's corners by curving it through the control points.",
-			type: "boolean"
-		},
-		{
-			key: "smoothResolution",
-			presentationTier: "advanced",
-			label: "Smooth resolution",
-			description: "Number of samples per segment when smooth mode is enabled.",
-			type: "number",
-			min: 2,
-			max: 64,
-			step: 1,
-			visibleWhen: (opts) => Boolean(opts.smooth)
-		},
+//#region src/internal/line-echelon.ts
+/**
+* The echelon and group-distribution controls shared by the line measures that
+* stamp Field B onto their geometry (Boundary, Generic command and control
+* line). `subject` names the geometry in the user-facing copy ("line",
+* "boundary"). Callers spread these into their own `params` and add whatever
+* else they carry (e.g. Boundary's unit-label padding).
+*/
+function echelonLineParams(subject) {
+	return [
 		{
 			key: "echelon",
 			presentationTier: "primary",
 			semanticRole: "doctrinal",
 			label: "Echelon",
-			description: "Field B unit-size amplifier, drawn on the line",
+			description: `Field B unit-size amplifier, drawn on the ${subject}`,
 			type: "enum",
 			options: ECHELON_PARAM_OPTIONS
 		},
@@ -7269,7 +7305,7 @@ const BOUNDARY_METADATA = {
 			key: "labelRepetitions",
 			presentationTier: "advanced",
 			label: "Label groups",
-			description: "Number of label groups spaced evenly along the whole boundary",
+			description: `Number of label groups spaced evenly along the whole ${subject}`,
 			type: "number",
 			min: 1,
 			max: 5,
@@ -7279,7 +7315,7 @@ const BOUNDARY_METADATA = {
 			key: "labelPosition",
 			presentationTier: "advanced",
 			label: "Label position",
-			description: "Position of the label group along the boundary, from the first point (0) to the last (1)",
+			description: `Position of the label group along the ${subject}, from the first point (0) to the last (1)`,
 			type: "number",
 			min: 0,
 			max: 1,
@@ -7297,30 +7333,160 @@ const BOUNDARY_METADATA = {
 			step: .05,
 			visibleWhen: (opts) => resolveLabelRepetitions(opts.labelRepetitions) > 1
 		},
-		{
-			key: "labelPadding",
-			presentationTier: "advanced",
-			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",
 			presentationTier: "advanced",
 			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.",
+			description: `Orient the label group along the ${subject}, or per MIL-STD-2525E Figure L-10: on mostly north–south segments the group rotates perpendicular to the ${subject} as a single row crossing it.`,
 			type: "enum",
 			options: [{
 				value: "along",
-				label: "Along the line"
+				label: `Along the ${subject}`
 			}, {
 				value: "standard",
 				label: "Standard (MIL-STD-2525E)"
 			}]
 		}
+	];
+}
+/** Along-line position used when a measure leaves `labelPosition` unset. */
+const DEFAULT_LABEL_POSITION = .5;
+/** A placement with nothing in it — the result for a degenerate line. */
+const EMPTY_LINE_ECHELON_PLACEMENT = {
+	strokes: [],
+	fills: [],
+	gaps: [],
+	groups: []
+};
+/**
+* Distributes `labelRepetitions` echelon groups along `verts` and builds the
+* glyph geometry for each. `spec` may be `undefined` — the groups are still
+* placed (so a caller can label them) but no glyph or gap is emitted.
+*/
+function placeEchelonsAlongLine(verts, spec, h, options) {
+	const { labelRepetitions, labelPosition, labelSpacing, labelOrientation, echelonPadding } = options;
+	const { segments, totalLength } = polylineSegments(verts);
+	if (totalLength < 1e-6) return EMPTY_LINE_ECHELON_PLACEMENT;
+	const reps = resolveLabelRepetitions(labelRepetitions);
+	const singleGroupPosition = clampLinePosition(labelPosition, DEFAULT_LABEL_POSITION);
+	const strokes = [];
+	const fills = [];
+	const gaps = [];
+	const groups = [];
+	for (let k = 0; k < reps; k++) {
+		const evenFraction = (k + 1) / (reps + 1);
+		const fraction = Math.min(1, Math.max(0, reps === 1 ? singleGroupPosition : .5 + (evenFraction - .5) * labelSpacing));
+		const target = fraction * totalLength;
+		const { point: center, along, perp } = pointAlongPolyline(segments, totalLength, fraction);
+		const rotateGroup = labelOrientation === "standard" && Math.abs(along[0]) < Math.abs(along[1]);
+		const readingAxis = perp[0] >= 0 ? perp : vecScale(perp, -1);
+		let glyphWidth = 0;
+		if (spec) {
+			const glyph = buildEchelonGlyph(center, rotateGroup ? readingAxis : along, rotateGroup ? [-readingAxis[1], readingAxis[0]] : perp, h, spec);
+			glyphWidth = glyph.width;
+			strokes.push(...glyph.strokes);
+			fills.push(...glyph.fills);
+			const halfGap = (rotateGroup ? h : glyphWidth) / 2 + Math.max(0, echelonPadding) * h;
+			gaps.push({
+				g0: target - halfGap,
+				g1: target + halfGap
+			});
+		}
+		groups.push({
+			center,
+			along,
+			perp,
+			rotateGroup,
+			readingAxis,
+			glyphWidth
+		});
+	}
+	return {
+		strokes,
+		fills,
+		gaps,
+		groups
+	};
+}
+//#endregion
+//#region src/generators/cm11-command-control-lines/boundary.ts
+/**
+* Boundary's Field T/AS mapping: unit 1 (`T`/`AS`) on the left-of-travel side,
+* unit 2 (`T1`/`AS1`) on the right.
+*/
+const BOUNDARY_UNIT_LABEL_FIELDS = {
+	unit1: {
+		designator: "T",
+		country: "AS"
+	},
+	unit2: {
+		designator: "T1",
+		country: "AS1"
+	}
+};
+/** Default options for the Boundary control measure. */
+const DEFAULT_BOUNDARY_OPTIONS = {
+	echelon: "battalion",
+	echelonSize: 750,
+	echelonSizePixels: 16,
+	echelonPadding: .3,
+	labelRepetitions: 1,
+	labelSpacing: 1,
+	labelPosition: .5,
+	labelPadding: ECHELON_UNIT_LABEL_PADDING,
+	labelOrientation: "along",
+	smooth: false,
+	smoothResolution: 12
+};
+const BOUNDARY_METADATA = {
+	id: "boundary",
+	name: "Boundary",
+	description: "Delineates the area of responsibility between two adjacent units, labeled with the echelon and the designators of the units it separates.",
+	entity: "Command and Control Lines",
+	entityType: "Boundary",
+	value: "110100",
+	minCoordinates: 2,
+	geometry: "line",
+	geometryTypes: [
+		"MultiLineString",
+		"MultiPolygon",
+		"Point"
+	],
+	paints: {
+		stroke: true,
+		fill: "fixed",
+		text: true
+	},
+	drawRule: "Line1",
+	params: [
+		{
+			key: "smooth",
+			label: "Smooth",
+			description: "Round the boundary's corners by curving it through the control points.",
+			type: "boolean"
+		},
+		{
+			key: "smoothResolution",
+			presentationTier: "advanced",
+			label: "Smooth resolution",
+			description: "Number of samples per segment when smooth mode is enabled.",
+			type: "number",
+			min: 2,
+			max: 64,
+			step: 1,
+			visibleWhen: (opts) => Boolean(opts.smooth)
+		},
+		...echelonLineParams("boundary"),
+		{
+			key: "labelPadding",
+			presentationTier: "advanced",
+			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
+		}
 	],
 	textAmplifiers: [
 		{
@@ -7362,80 +7528,22 @@ const BOUNDARY_METADATA = {
 */
 function createBoundary(positions, options = {}, textAmplifiers = {}, context = {}) {
 	const { echelon = DEFAULT_BOUNDARY_OPTIONS.echelon, echelonSize = DEFAULT_BOUNDARY_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_BOUNDARY_OPTIONS.echelonPadding, metersPerPixel, labelRepetitions = DEFAULT_BOUNDARY_OPTIONS.labelRepetitions, labelSpacing = DEFAULT_BOUNDARY_OPTIONS.labelSpacing, labelPosition = DEFAULT_BOUNDARY_OPTIONS.labelPosition, 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);
-	const reps = resolveLabelRepetitions(labelRepetitions);
-	const singleGroupPosition = clampLinePosition(labelPosition, DEFAULT_BOUNDARY_OPTIONS.labelPosition);
+	const h = resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel);
 	const spec = resolveEchelon(echelon);
-	const screenAnchored = echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0;
-	const labelSize = screenAnchored ? { textSizePixels: echelonSizePixels } : { textSizeMeters: h };
-	const rawVerts = positions.map((p) => project(p[0], p[1]));
-	const verts = smooth ? catmullRom(rawVerts, normalizeSmoothResolution$2(smoothResolution, DEFAULT_SMOOTH_RESOLUTION$4)) : rawVerts;
-	const glyphStrokes = [];
-	const glyphFills = [];
+	const { properties: labelSize, screenAnchored } = echelonUnitLabelSize(h, echelonSizePixels, metersPerPixel);
+	const verts = smoothLineVerts(positions.map((p) => project(p[0], p[1])), {
+		smooth,
+		smoothResolution
+	}, 12);
 	const labelFeatures = [];
-	const gaps = [];
-	const { segments: segs, totalLength } = polylineSegments(verts);
-	if (totalLength >= 1e-6) for (let k = 0; k < reps; k++) {
-		const evenFraction = (k + 1) / (reps + 1);
-		const fraction = Math.min(1, Math.max(0, reps === 1 ? singleGroupPosition : .5 + (evenFraction - .5) * labelSpacing));
-		const target = fraction * totalLength;
-		const frame = pointAlongPolyline(segs, totalLength, fraction);
-		const center = frame.point;
-		const seg = {
-			along: frame.along,
-			perp: frame.perp
-		};
-		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, glyphAlong, glyphPerp, h, spec);
-			glyphWidth = width;
-			glyphStrokes.push(...strokes);
-			glyphFills.push(...fills);
-			const halfGap = (rotateGroup ? h : width) / 2 + Math.max(0, echelonPadding) * h;
-			gaps.push({
-				g0: target - halfGap,
-				g1: target + halfGap
-			});
-		}
-		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,
-			offset: (.45 + Math.max(0, labelPadding)) * h,
-			rotation: labelRotationAlong(seg.along),
-			labelSize
-		}, units);
-	}
+	const { strokes: glyphStrokes, fills: glyphFills, gaps, groups } = placeEchelonsAlongLine(verts, spec, h, {
+		labelRepetitions,
+		labelPosition,
+		labelSpacing,
+		labelOrientation,
+		echelonPadding
+	});
+	pushEchelonUnitLabels(labelFeatures, groups, unitLabelsFromAmplifiers(textAmplifiers, BOUNDARY_UNIT_LABEL_FIELDS), h, labelPadding, labelSize);
 	const hostileLabelOptions = screenAnchored ? {
 		labelSizePixels: echelonSizePixels,
 		metersPerPixel,
@@ -7722,8 +7830,26 @@ const ENGINEER_WORK_LINE = defineControlMeasure({
 });
 //#endregion
 //#region src/generators/cm11-command-control-lines/generic-c2-line.ts
+const GENERIC_C2_UNIT_LABEL_FIELDS = {
+	unit1: {
+		designator: "T1",
+		country: "AS1"
+	},
+	unit2: {
+		designator: "T2",
+		country: "AS2"
+	}
+};
 /** Default options for the Generic command and control line. */
 const DEFAULT_GENERIC_C2_LINE_OPTIONS = {
+	echelon: "none",
+	echelonSize: 750,
+	echelonSizePixels: 16,
+	echelonPadding: .3,
+	labelRepetitions: 1,
+	labelSpacing: 1,
+	labelPosition: .5,
+	labelOrientation: "along",
 	includePrefix: true,
 	smooth: false,
 	smoothResolution: 12
@@ -7731,22 +7857,28 @@ const DEFAULT_GENERIC_C2_LINE_OPTIONS = {
 const GENERIC_C2_LINE_METADATA = {
 	id: "generic-c2-line",
 	name: "Generic command and control line",
-	description: "Illustrative command-and-control-style line (not part of MIL-STD-2525E) carrying optional additional-information/designation text above it and an effective date-time-group window below it.",
+	description: "Illustrative command-and-control-style line (not part of MIL-STD-2525E) carrying optional echelon glyphs, additional-information/designation text above it, and an effective date-time-group window below it.",
 	entity: "Command and Control Lines",
 	entityType: "Generic",
 	value: "110400",
 	minCoordinates: 2,
 	geometry: "line",
-	geometryTypes: ["LineString", "Point"],
+	geometryTypes: [
+		"LineString",
+		"MultiLineString",
+		"MultiPolygon",
+		"Point"
+	],
 	paints: {
 		stroke: true,
-		fill: "none",
+		fill: "fixed",
 		text: true
 	},
 	drawRule: "Line1",
 	capturesLabelSize: true,
 	params: [
 		...SMOOTH_LINE_PARAMS,
+		...echelonLineParams("line"),
 		{
 			key: "phaseLineName",
 			presentationTier: "primary",
@@ -7765,16 +7897,7 @@ const GENERIC_C2_LINE_METADATA = {
 			type: "boolean",
 			visibleWhen: (opts) => Boolean(String(opts.phaseLineName ?? "").trim())
 		},
-		{
-			key: "labelPadding",
-			presentationTier: "advanced",
-			label: "Label padding",
-			description: "Extra clearance between the line and its labels, as a ratio of the label height",
-			type: "number",
-			min: 0,
-			max: 2,
-			step: .05
-		}
+		LINE_LABEL_PADDING_PARAM
 	],
 	textAmplifiers: [
 		{
@@ -7789,6 +7912,30 @@ const GENERIC_C2_LINE_METADATA = {
 			description: "Field T — unique designation of the line, shown above it near each end.",
 			maxLength: 21
 		},
+		{
+			key: "T1",
+			label: "Unit 1 designation",
+			description: "Field T1 — designation of unit 1 on the left-of-travel side.",
+			maxLength: 32
+		},
+		{
+			key: "AS1",
+			label: "Unit 1 country",
+			description: "Field AS1 — country code of unit 1 on the left-of-travel side.",
+			maxLength: 8
+		},
+		{
+			key: "T2",
+			label: "Unit 2 designation",
+			description: "Field T2 — designation of unit 2 on the right-of-travel side.",
+			maxLength: 32
+		},
+		{
+			key: "AS2",
+			label: "Unit 2 country",
+			description: "Field AS2 — country code of unit 2 on the right-of-travel side.",
+			maxLength: 8
+		},
 		{
 			key: "W",
 			label: "Effective from (DTG)",
@@ -7814,19 +7961,62 @@ const GENERIC_C2_LINE_METADATA = {
 * `base + perp·offset` and the other at `base − perp·offset`.
 */
 function createGenericC2Line(positions, options = {}, textAmplifiers = {}, context = {}) {
-	const { phaseLineName, includePrefix = true, smooth, smoothResolution, ...sizeOptions } = options;
+	const { echelon = DEFAULT_GENERIC_C2_LINE_OPTIONS.echelon, echelonSize = DEFAULT_GENERIC_C2_LINE_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_GENERIC_C2_LINE_OPTIONS.echelonPadding, labelRepetitions = DEFAULT_GENERIC_C2_LINE_OPTIONS.labelRepetitions, labelSpacing = DEFAULT_GENERIC_C2_LINE_OPTIONS.labelSpacing, labelPosition = DEFAULT_GENERIC_C2_LINE_OPTIONS.labelPosition, labelOrientation = DEFAULT_GENERIC_C2_LINE_OPTIONS.labelOrientation, phaseLineName, includePrefix = true, smooth, smoothResolution, ...sizeOptions } = options;
 	const verts = smoothLineVerts(positions.map((p) => project(p[0], p[1])), {
 		smooth,
 		smoothResolution
 	}, 12);
-	const features = [{
+	const features = [];
+	const spec = resolveEchelon(echelon);
+	const h = resolveEchelonHeight(echelonSize, echelonSizePixels, sizeOptions.metersPerPixel);
+	const { strokes: glyphStrokes, fills: glyphFills, gaps, groups } = spec ? placeEchelonsAlongLine(verts, spec, h, {
+		labelRepetitions,
+		labelPosition,
+		labelSpacing,
+		labelOrientation,
+		echelonPadding
+	}) : EMPTY_LINE_ECHELON_PLACEMENT;
+	const gappedCoordinates = gaps.length > 0 ? buildGappedLine(verts, gaps) : [];
+	if (gappedCoordinates.length > 0) features.push({
+		type: "Feature",
+		properties: { part: "generic-c2-line" },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: gappedCoordinates
+		}
+	});
+	else if (gaps.length === 0) features.push({
 		type: "Feature",
 		properties: { part: "generic-c2-line" },
 		geometry: {
 			type: "LineString",
 			coordinates: smooth ? verts.map((v) => unproject(v[0], v[1])) : positions
 		}
-	}];
+	});
+	if (glyphStrokes.length > 0) features.push({
+		type: "Feature",
+		properties: { part: "echelon" },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: glyphStrokes
+		}
+	});
+	if (glyphFills.length > 0) features.push({
+		type: "Feature",
+		properties: {
+			part: "echelon",
+			fill: true,
+			style: SOLID_ACCENT_FILL
+		},
+		geometry: {
+			type: "MultiPolygon",
+			coordinates: glyphFills.map((ring) => [ring])
+		}
+	});
+	const { properties: unitLabelSize } = echelonUnitLabelSize(h, echelonSizePixels, sizeOptions.metersPerPixel);
+	const unitLabels = [];
+	pushEchelonUnitLabels(unitLabels, groups, unitLabelsFromAmplifiers(textAmplifiers, GENERIC_C2_UNIT_LABEL_FIELDS), h, sizeOptions.labelPadding ?? .4, unitLabelSize);
+	features.push(...unitLabels);
 	const above = [textAmplifiers.H, textAmplifiers.T].filter((v) => Boolean(v)).join(" ");
 	const below = [textAmplifiers.W, textAmplifiers.W1].filter((v) => Boolean(v)).join(" - ");
 	const trimmedPhaseLineName = phaseLineName?.trim();
@@ -12442,6 +12632,98 @@ const FINAL_COORDINATION_LINE = defineControlMeasure({
 	}
 });
 //#endregion
+//#region src/generators/cm14-maneuver-lines/infiltration-lane.ts
+const DEFAULT_INFILTRATION_LANE_OPTIONS = {};
+const INFILTRATION_LANE_METADATA = {
+	id: "infiltration-lane",
+	name: "Infiltration Lane",
+	description: "A control measure that coordinates forward and lateral movement of infiltrating units and fixes fire planning responsibilities.",
+	entity: "Maneuver Lines",
+	entityType: "Infiltration Lane",
+	value: "140800",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Polyline1",
+	capturesLabelSize: true,
+	textAmplifiers: [{
+		key: "T",
+		label: "Unique designation",
+		description: "Field T — the infiltration lane's unique designation.",
+		placeholder: "GREEN",
+		maxLength: 21
+	}]
+};
+/** Creates the two parallel boundaries and centered Field T lane designation. */
+function createInfiltrationLane(coordinates, options = {}, textAmplifiers = {}) {
+	const [c1, c2, c3] = coordinates;
+	const p1 = project(c1[0], c1[1]);
+	const p2 = project(c2[0], c2[1]);
+	const frame = createProjectedBaselineFrame(p1, p2, {
+		origin: "midpoint",
+		normal: "left"
+	});
+	if (!frame) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const signedHalfWidth = frame.signedNormalDistance(c3);
+	if (Math.abs(signedHalfWidth) < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const midpoint = frame.origin;
+	const offset = vecScale(frame.normal, signedHalfWidth);
+	const features = [{
+		type: "Feature",
+		properties: { part: "infiltration-lane" },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: [[vecAdd(p1, offset), vecAdd(p2, offset)], [vecSub(p1, offset), vecSub(p2, offset)]].map((line) => line.map((point) => unproject(point[0], point[1])))
+		}
+	}];
+	if (textAmplifiers.T) features.push({
+		type: "Feature",
+		properties: {
+			part: "label",
+			labelPlacement: false,
+			amplifierField: "T",
+			text: textAmplifiers.T,
+			rotation: labelRotationAlong(frame.direction),
+			...labelSizeProps(options)
+		},
+		geometry: {
+			type: "Point",
+			coordinates: unproject(midpoint[0], midpoint[1])
+		}
+	});
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+const INFILTRATION_LANE = defineControlMeasure({
+	metadata: INFILTRATION_LANE_METADATA,
+	generator: createInfiltrationLane,
+	defaultOptions: DEFAULT_INFILTRATION_LANE_OPTIONS,
+	rule: polyline1DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, 0],
+			[1, 0],
+			[0, .36]
+		],
+		textAmplifiers: { T: "GREEN" },
+		options: { labelSize: 100 }
+	}
+});
+//#endregion
 //#region src/generators/cm14-maneuver-lines/airhead-line.ts
 /** Clearance between the boundary's southernmost point and the caption, as a
 *  ratio of the caption's height. */
@@ -16837,6 +17119,7 @@ const DEFINITIONS = {
 	"forward-edge-of-battle-area": FORWARD_EDGE_OF_BATTLE_AREA,
 	"bridgehead-line": BRIDGEHEAD_LINE,
 	"final-coordination-line": FINAL_COORDINATION_LINE,
+	"infiltration-lane": INFILTRATION_LANE,
 	"airhead-line": AIRHEAD_LINE,
 	"holding-line": HOLDING_LINE,
 	"release-line": RELEASE_LINE,
@@ -17292,4 +17575,4 @@ function assertNever(value) {
 	throw new Error(`Unhandled control measure kind: ${String(value)}`);
 }
 //#endregion
-export { DEFAULT_DISRUPT_OPTIONS as $, DEFAULT_STROKE_DASH_CSS_PIXELS as $t, DEFAULT_RETIRE_OPTIONS as A, createBaselineFrame as An, DEFAULT_CONTAIN_OPTIONS as At, DEFAULT_LIMIT_OF_ADVANCE_OPTIONS as B, DEFAULT_AREA_DEFENSE_OPTIONS as Bt, DEFAULT_MAIN_ATTACK_OPTIONS as C, containDrawRule as Cn, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as Ct, DEFAULT_WITHDRAW_OPTIONS as D, getMidpointPerpendicularSignedDistance as Dn, DEFAULT_BOUNDARY_OPTIONS as Dt, DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS as E, createMidpointPerpendicularDrawRule as En, DEFAULT_LIGHT_LINE_OPTIONS as Et, DEFAULT_FORTIFIED_LINE_OPTIONS as F, sphericalBearing as Fn, DEFAULT_ANTITANK_DITCH_OPTIONS as Ft, DEFAULT_HOLDING_LINE_OPTIONS as G, canonicalTextAmplifierKey as Gt, DEFAULT_HANDOVER_LINE_OPTIONS as H, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as Ht, DEFAULT_PROBABLE_LINE_OF_DEPLOYMENT_OPTIONS as I, unproject as In, DEFAULT_ASSEMBLY_AREA_OPTIONS as It, DEFAULT_FLOT_OPTIONS as J, DEFAULT_LABEL_HEIGHT_CSS_PIXELS as Jt, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as K, normalizeTextAmplifiers as Kt, PROBABLE_LINE_OF_DEPLOYMENT_DASH as L, EPSILON as Ln, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as Lt, DEFAULT_PENETRATE_OPTIONS as M, computeInitialWidthPoint as Mn, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Mt, DEFAULT_FRONTAL_ATTACK_OPTIONS as N, haversineDistance as Nn, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Nt, DEFAULT_SEIZE_OPTIONS as O, pointOnMidpointPerpendicularAxis as On, DEFAULT_BLOCK_ARROW_OPTIONS as Ot, DEFAULT_FORTIFIED_AREA_OPTIONS as P, project as Pn, DEFAULT_ANTITANK_WALL_OPTIONS as Pt, DEFAULT_ENCIRCLEMENT_OPTIONS as Q, DEFAULT_PORTRAYAL as Qt, DEFAULT_LINE_OF_DEPARTURE_CONTACT_OPTIONS as R, getMetersPerPixel as Rn, DEFAULT_MOBILE_DEFENSE_OPTIONS as Rt, DEFAULT_MINEFIELD_OPTIONS as S, centerRadiusDrawRule as Sn, DEFAULT_BREACH_OPTIONS as St, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as T, computeDefaultMidpointPerpendicularPoint as Tn, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as Tt, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as U, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as Ut, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as V, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as Vt, DEFAULT_RELEASE_LINE_OPTIONS as W, TEXT_AMPLIFIER_FIELDS as Wt, DEFAULT_FIX_OPTIONS as X, DEFAULT_LINE_CAP as Xt, DEFAULT_FIX_MISSION_TASK_OPTIONS as Y, DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS as Yt, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as Z, DEFAULT_LINE_JOIN as Zt, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as _, staticPointDrawRule as _n, DEFAULT_GENERIC_LINE_OPTIONS as _t, DEFINITIONS as a, axis1DrawRule as an, DEFAULT_TACTICAL_ARROW_OPTIONS as at, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as b, disruptDrawRule as bn, DEFAULT_CANALIZE_OPTIONS as bt, getDefaultOptions as c, line26DrawRule as cn, DEFAULT_SUPPORTING_ATTACK_OPTIONS as ct, DEFAULT_TURN_OPTIONS as d, turnDrawRule as dn, RADAR_SEARCH_DOCTRINE_FILL_COLOR as dt, DEFAULT_STROKE_WIDTH_CSS_PIXELS as en, DEFAULT_GUARD_OPTIONS as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, line1DrawRule as fn, RADAR_SEARCH_DOCTRINE_STROKE_COLOR as ft, SECONDARY_DIRECTION_OF_FIRE_DASH as g, sectorDrawRule as gn, DEFAULT_GENERIC_POLYGON_OPTIONS as gt, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as h, dynamicPointDrawRule as hn, DEFAULT_GENERIC_RECTANGLE_OPTIONS as ht, CONTROL_MEASURE_METADATA as i, rectangleDrawRule as in, DEFAULT_COVER_OPTIONS as it, DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS as j, calculateMetrics as jn, DEFAULT_BATTLE_POSITION_OPTIONS as jt, DEFAULT_SCREEN_OPTIONS as k, snapToMidpointPerpendicular as kn, DEFAULT_BLOCK_OPTIONS as kt, listControlMeasureMetadata as l, line24DrawRule as ln, DEFAULT_CLEAR_OPTIONS as lt, DEFAULT_STRONG_POINT_OPTIONS as m, attackByFireDrawRule as mn, DEFAULT_GENERIC_SECTOR_OPTIONS as mt, resolveStyleHints as n, DEFAULT_AMBUSH_OPTIONS as nn, DEFAULT_DISENGAGE_OPTIONS as nt, getControlMeasureMetadata as o, supportByFireDrawRule as on, DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS as ot, DEFAULT_RETAIN_OPTIONS as p, ambushDrawRule as pn, DEFAULT_GENERIC_TEXT_OPTIONS as pt, DEFAULT_PHASE_LINE_OPTIONS as q, resolveAmplifierPlacement as qt, CONTROL_MEASURE_IDS as r, DEFAULT_AIRBORNE_ATTACK_OPTIONS as rn, DEFAULT_DELAY_OPTIONS as rt, getControlMeasureMetadataByValue as s, line27DrawRule as sn, DEFAULT_COUNTERATTACK_OPTIONS as st, renderControlMeasure as t, DEFAULT_SYMBOL_COLOR as tn, DEFAULT_DISRUPT_MISSION_TASK_OPTIONS as tt, DEFAULT_TURNING_MOVEMENT_OPTIONS as u, line23DrawRule as un, DEFAULT_RADAR_SEARCH_DOCTRINE_OPTIONS as ut, DEFAULT_PICKUP_ZONE_OPTIONS as v, point12DrawRule as vn, DEFAULT_GENERIC_CIRCLE_OPTIONS as vt, DEFAULT_LANDING_ZONE_OPTIONS as w, area27DrawRule as wn, DEFAULT_GENERIC_C2_LINE_OPTIONS as wt, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as x, blockDrawRule as xn, DEFAULT_BYPASS_OPTIONS as xt, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as y, penetrateDrawRule as yn, DEFAULT_CLASSIC_ARROW_OPTIONS as yt, DEFAULT_LINE_OF_DEPARTURE_OPTIONS as z, roundToFixed as zn, DEFAULT_ENGAGEMENT_AREA_OPTIONS as zt };
+export { DEFAULT_ENCIRCLEMENT_OPTIONS as $, DEFAULT_PORTRAYAL as $t, DEFAULT_RETIRE_OPTIONS as A, pointOnMidpointPerpendicularAxis as An, DEFAULT_BLOCK_OPTIONS as At, DEFAULT_LIMIT_OF_ADVANCE_OPTIONS as B, getMetersPerPixel as Bn, DEFAULT_ENGAGEMENT_AREA_OPTIONS as Bt, DEFAULT_MAIN_ATTACK_OPTIONS as C, blockDrawRule as Cn, DEFAULT_BREACH_OPTIONS as Ct, DEFAULT_WITHDRAW_OPTIONS as D, computeDefaultMidpointPerpendicularPoint as Dn, DEFAULT_LIGHT_LINE_OPTIONS as Dt, DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS as E, area27DrawRule as En, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as Et, DEFAULT_FORTIFIED_LINE_OPTIONS as F, haversineDistance as Fn, DEFAULT_ANTITANK_WALL_OPTIONS as Ft, DEFAULT_HOLDING_LINE_OPTIONS as G, TEXT_AMPLIFIER_FIELDS as Gt, DEFAULT_HANDOVER_LINE_OPTIONS as H, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as Ht, DEFAULT_PROBABLE_LINE_OF_DEPLOYMENT_OPTIONS as I, project as In, DEFAULT_ANTITANK_DITCH_OPTIONS as It, DEFAULT_PHASE_LINE_OPTIONS as J, resolveAmplifierPlacement as Jt, DEFAULT_INFILTRATION_LANE_OPTIONS as K, canonicalTextAmplifierKey as Kt, PROBABLE_LINE_OF_DEPLOYMENT_DASH as L, sphericalBearing as Ln, DEFAULT_ASSEMBLY_AREA_OPTIONS as Lt, DEFAULT_PENETRATE_OPTIONS as M, createBaselineFrame as Mn, DEFAULT_BATTLE_POSITION_OPTIONS as Mt, DEFAULT_FRONTAL_ATTACK_OPTIONS as N, calculateMetrics as Nn, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Nt, DEFAULT_SEIZE_OPTIONS as O, createMidpointPerpendicularDrawRule as On, DEFAULT_BOUNDARY_OPTIONS as Ot, DEFAULT_FORTIFIED_AREA_OPTIONS as P, computeInitialWidthPoint as Pn, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Pt, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as Q, DEFAULT_LINE_JOIN as Qt, DEFAULT_LINE_OF_DEPARTURE_CONTACT_OPTIONS as R, unproject as Rn, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as Rt, DEFAULT_MINEFIELD_OPTIONS as S, disruptDrawRule as Sn, DEFAULT_BYPASS_OPTIONS as St, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as T, containDrawRule as Tn, DEFAULT_GENERIC_C2_LINE_OPTIONS as Tt, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as U, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as Ut, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as V, roundToFixed as Vn, DEFAULT_AREA_DEFENSE_OPTIONS as Vt, DEFAULT_RELEASE_LINE_OPTIONS as W, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as Wt, DEFAULT_FIX_MISSION_TASK_OPTIONS as X, DEFAULT_LABEL_SIZE_CLAMP_CSS_PIXELS as Xt, DEFAULT_FLOT_OPTIONS as Y, DEFAULT_LABEL_HEIGHT_CSS_PIXELS as Yt, DEFAULT_FIX_OPTIONS as Z, DEFAULT_LINE_CAP as Zt, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as _, dynamicPointDrawRule as _n, DEFAULT_GENERIC_POLYGON_OPTIONS as _t, DEFINITIONS as a, rectangleDrawRule as an, DEFAULT_COVER_OPTIONS as at, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as b, point12DrawRule as bn, DEFAULT_CLASSIC_ARROW_OPTIONS as bt, getDefaultOptions as c, polyline1DrawRule as cn, DEFAULT_COUNTERATTACK_OPTIONS as ct, DEFAULT_TURN_OPTIONS as d, line24DrawRule as dn, DEFAULT_RADAR_SEARCH_DOCTRINE_OPTIONS as dt, DEFAULT_STROKE_DASH_CSS_PIXELS as en, DEFAULT_DISRUPT_OPTIONS as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, line23DrawRule as fn, RADAR_SEARCH_DOCTRINE_FILL_COLOR as ft, SECONDARY_DIRECTION_OF_FIRE_DASH as g, attackByFireDrawRule as gn, DEFAULT_GENERIC_RECTANGLE_OPTIONS as gt, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as h, ambushDrawRule as hn, DEFAULT_GENERIC_SECTOR_OPTIONS as ht, CONTROL_MEASURE_METADATA as i, DEFAULT_AIRBORNE_ATTACK_OPTIONS as in, DEFAULT_DELAY_OPTIONS as it, DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS as j, snapToMidpointPerpendicular as jn, DEFAULT_CONTAIN_OPTIONS as jt, DEFAULT_SCREEN_OPTIONS as k, getMidpointPerpendicularSignedDistance as kn, DEFAULT_BLOCK_ARROW_OPTIONS as kt, listControlMeasureMetadata as l, line27DrawRule as ln, DEFAULT_SUPPORTING_ATTACK_OPTIONS as lt, DEFAULT_STRONG_POINT_OPTIONS as m, line1DrawRule as mn, DEFAULT_GENERIC_TEXT_OPTIONS as mt, resolveStyleHints as n, DEFAULT_SYMBOL_COLOR as nn, DEFAULT_DISRUPT_MISSION_TASK_OPTIONS as nt, getControlMeasureMetadata as o, axis1DrawRule as on, DEFAULT_TACTICAL_ARROW_OPTIONS as ot, DEFAULT_RETAIN_OPTIONS as p, turnDrawRule as pn, RADAR_SEARCH_DOCTRINE_STROKE_COLOR as pt, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as q, normalizeTextAmplifiers as qt, CONTROL_MEASURE_IDS as r, DEFAULT_AMBUSH_OPTIONS as rn, DEFAULT_DISENGAGE_OPTIONS as rt, getControlMeasureMetadataByValue as s, supportByFireDrawRule as sn, DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS as st, renderControlMeasure as t, DEFAULT_STROKE_WIDTH_CSS_PIXELS as tn, DEFAULT_GUARD_OPTIONS as tt, DEFAULT_TURNING_MOVEMENT_OPTIONS as u, line26DrawRule as un, DEFAULT_CLEAR_OPTIONS as ut, DEFAULT_PICKUP_ZONE_OPTIONS as v, sectorDrawRule as vn, DEFAULT_GENERIC_LINE_OPTIONS as vt, DEFAULT_LANDING_ZONE_OPTIONS as w, centerRadiusDrawRule as wn, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as wt, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as x, penetrateDrawRule as xn, DEFAULT_CANALIZE_OPTIONS as xt, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as y, staticPointDrawRule as yn, DEFAULT_GENERIC_CIRCLE_OPTIONS as yt, DEFAULT_LINE_OF_DEPARTURE_OPTIONS as z, EPSILON as zn, DEFAULT_MOBILE_DEFENSE_OPTIONS as zt };