@orbat-mapper/control-measures 0.2.0 → 0.3.1

package/dist/{renderControlMeasure-CAfC2nEw.mjs → renderControlMeasure-awInmGJN.mjs}

@@ -558,7 +558,7 @@ function samePosition(a, b) {
 }
 //#endregion
 //#region src/draw-rules/area1.ts
-function derive$10(points) {
+function derive$11(points) {
 	return clonePositions(points);
 }
 /**
@@ -578,9 +578,9 @@ const area1DrawRule = {
 	id: "area1",
 	minimumUserPoints: 3,
 	closedRing: true,
-	derive: derive$10,
+	derive: derive$11,
 	transform(event) {
-		return derive$10(event.next);
+		return derive$11(event.next);
 	}
 };
 //#endregion
@@ -606,14 +606,14 @@ const disruptDrawRule = createMidpointPerpendicularDrawRule({
 * that fixes both the radius and the bearing of the symbol's opening. Both
 * points are user-clicked, so the canonical array is just the (clamped) input.
 */
-function derive$9(points) {
+function derive$10(points) {
 	return clonePositions(points.slice(0, 2));
 }
 const centerRadiusDrawRule = {
 	id: "area15:center-radius",
 	minimumUserPoints: 2,
 	canonicalPointCount: 2,
-	derive: derive$9,
+	derive: derive$10,
 	transform(event) {
 		const { previous, next, activePointIndex } = event;
 		if (activePointIndex === 0 && previous.length >= 2 && next.length >= 2) {
@@ -622,12 +622,25 @@ const centerRadiusDrawRule = {
 			const origin = previous[1];
 			return [clonePosition(next[0]), [origin[0] + dx, origin[1] + dy]];
 		}
-		return derive$9(next);
+		return derive$10(next);
 	}
 };
 /** Backward-compatible doctrinal name for Area15's shared center-radius rule. */
 const isolateDrawRule = centerRadiusDrawRule;
 //#endregion
+//#region src/draw-rules/area17.ts
+/**
+* Area17 anchor draw rule for Penetrate.
+*
+* PT.1/PT.2 are the free barrier endpoints. PT.3 is the arrow tail,
+* constrained to the perpendicular axis through the barrier midpoint.
+*/
+const penetrateDrawRule = createMidpointPerpendicularDrawRule({
+	id: "area17:penetrate",
+	minimumUserPoints: 3,
+	minimumPreviewPoints: 2
+});
+//#endregion
 //#region src/draw-rules/point12.ts
 /**
 * Point12 anchor draw rule for the obstacle-bypass family.
@@ -645,16 +658,16 @@ const point12DrawRule = createMidpointPerpendicularDrawRule({ id: "point12:obsta
 * Point1 — a single anchor point (e.g. Text's center). One user click commits
 * the measure; dragging the point simply translates it.
 */
-function derive$8(points) {
+function derive$9(points) {
 	return clonePositions(points.slice(0, 1));
 }
 const pointDrawRule = {
 	id: "point1:anchor",
 	minimumUserPoints: 1,
 	canonicalPointCount: 1,
-	derive: derive$8,
+	derive: derive$9,
 	transform(event) {
-		return derive$8(event.next);
+		return derive$9(event.next);
 	}
 };
 //#endregion
@@ -685,20 +698,20 @@ const ambushDrawRule = createMidpointPerpendicularDrawRule({
 });
 //#endregion
 //#region src/draw-rules/line1.ts
-function derive$7(points) {
+function derive$8(points) {
 	return clonePositions(points);
 }
 const line1DrawRule = {
 	id: "line1",
 	minimumUserPoints: 2,
-	derive: derive$7,
+	derive: derive$8,
 	transform(event) {
-		return derive$7(event.next);
+		return derive$8(event.next);
 	}
 };
 //#endregion
 //#region src/draw-rules/line3.ts
-function derive$6(points) {
+function derive$7(points) {
 	return clonePositions(points);
 }
 /**
@@ -713,23 +726,23 @@ const line3DrawRule = {
 	id: "line3",
 	minimumUserPoints: 3,
 	canonicalPointCount: 3,
-	derive: derive$6,
+	derive: derive$7,
 	transform(event) {
-		return derive$6(event.next);
+		return derive$7(event.next);
 	}
 };
 //#endregion
 //#region src/draw-rules/line9.ts
-function derive$5(points) {
+function derive$6(points) {
 	return clonePositions(points);
 }
 const line9DrawRule = {
 	id: "line9",
 	minimumUserPoints: 2,
 	canonicalPointCount: 2,
-	derive: derive$5,
+	derive: derive$6,
 	transform(event) {
-		return derive$5(event.next);
+		return derive$6(event.next);
 	}
 };
 //#endregion
@@ -836,7 +849,7 @@ const line24DrawRule = createMidpointPerpendicularDrawRule({
 });
 //#endregion
 //#region src/draw-rules/line26.ts
-function derive$4(points) {
+function derive$5(points) {
 	if (points.length === 2) {
 		const [p1, p2] = points;
 		const dx = p2[0] - p1[0];
@@ -875,9 +888,89 @@ const line26DrawRule = {
 	minimumUserPoints: 4,
 	minimumPreviewPoints: 2,
 	canonicalPointCount: 4,
+	derive: derive$5,
+	transform(event) {
+		return derive$5(event.next);
+	}
+};
+//#endregion
+//#region src/draw-rules/line27.ts
+function deriveArcPoint(p1, p2, p4) {
+	const center = project(p1[0], p1[1]);
+	const start = project(p2[0], p2[1]);
+	const tip = project(p4[0], p4[1]);
+	const arc = createQuarterArc(start, tip, quarterArcSide(start, tip, center) === 1 ? -1 : 1);
+	if (!arc) return [(p2[0] + p4[0]) / 2, (p2[1] + p4[1]) / 2];
+	return unproject(arc.midpoint[0], arc.midpoint[1]);
+}
+function derive$4(points) {
+	if (points.length < 2) return clonePositions(points);
+	const [p1, p2] = points;
+	if (points.length === 2) {
+		const dx = p2[0] - p1[0];
+		const dy = p2[1] - p1[1];
+		const p4 = [p2[0] + dx * 2.5, p2[1] + dy * 2.5];
+		return clonePositions([
+			p1,
+			p2,
+			deriveArcPoint(p1, p2, p4),
+			p4
+		]);
+	}
+	if (points.length === 3) {
+		const p4 = points[2];
+		return clonePositions([
+			p1,
+			p2,
+			deriveArcPoint(p1, p2, p4),
+			p4
+		]);
+	}
+	return clonePositions(points.slice(0, 4));
+}
+/**
+* Line27 anchor draw rule for the Seize mission task.
+*
+* PT. 1 is the circle center, PT. 2 fixes its radius and the curved arrow's
+* start, derived PT. 3 lies on and selects the circular arc, and the user's
+* third click becomes PT. 4 (the arrow tip). PT. 3 remains directly editable
+* after commit. Dragging PT. 1 carries PT. 2 with it so the assigned-unit
+* circle keeps its radius.
+*/
+const line27DrawRule = {
+	id: "line27:seize",
+	minimumUserPoints: 3,
+	minimumPreviewPoints: 2,
+	canonicalPointCount: 4,
 	derive: derive$4,
 	transform(event) {
-		return derive$4(event.next);
+		const { previous, next, activePointIndex } = event;
+		if (activePointIndex === 0 && previous.length >= 4 && next.length >= 4) {
+			const dx = next[0][0] - previous[0][0];
+			const dy = next[0][1] - previous[0][1];
+			const oldRadiusPoint = previous[1];
+			const p1 = clonePosition(next[0]);
+			const p2 = [oldRadiusPoint[0] + dx, oldRadiusPoint[1] + dy];
+			const p4 = clonePosition(next[3]);
+			return [
+				p1,
+				p2,
+				deriveArcPoint(p1, p2, p4),
+				p4
+			];
+		}
+		if ((activePointIndex === 1 || activePointIndex === 3) && next.length >= 4) {
+			const p1 = clonePosition(next[0]);
+			const p2 = clonePosition(next[1]);
+			const p4 = clonePosition(next[3]);
+			return [
+				p1,
+				p2,
+				deriveArcPoint(p1, p2, p4),
+				p4
+			];
+		}
+		return clonePositions(next.slice(0, 4));
 	}
 };
 //#endregion
@@ -965,6 +1058,48 @@ const axis1DrawRule = {
 		return packWithWidth(next, projected);
 	}
 };
+/**
+* Recesses the CATK body from P1. The original P1 remains the tip of the fire
+* arrow, while P2 and the remaining Axis1 points continue to shape the body.
+*/
+function counterattackByFireBodyCoordinates(points) {
+	const fireTipCoordinate = points[0];
+	const neckCoordinate = points[1];
+	if (!fireTipCoordinate || !neckCoordinate) return null;
+	const fireTip = project(fireTipCoordinate[0], fireTipCoordinate[1]);
+	const terminal = vecSub(fireTip, project(neckCoordinate[0], neckCoordinate[1]));
+	if (vecMag(terminal) < 1e-6) return null;
+	const bodyTip = vecAdd(fireTip, vecScale(terminal, -.3));
+	return [unproject(bodyTip[0], bodyTip[1]), ...points.slice(1)];
+}
+function restoreFireTip(points, fireTip) {
+	if (points.length > 0 && fireTip) points[0] = clonePosition(fireTip);
+	return points;
+}
+/**
+* Axis1 interaction for Counterattack by Fire, with its width frame anchored
+* to the recessed CATK body tip rather than P1, which belongs to the separate
+* fire arrow.
+*/
+const counterattackByFireDrawRule = {
+	...axis1DrawRule,
+	id: "axis1:counterattack-by-fire",
+	derive(points) {
+		const bodyPoints = counterattackByFireBodyCoordinates(points);
+		if (!bodyPoints) return axis1DrawRule.derive(points);
+		return restoreFireTip(axis1DrawRule.derive(bodyPoints), points[0]);
+	},
+	transform(event) {
+		const previousBody = counterattackByFireBodyCoordinates(event.previous);
+		const nextBody = counterattackByFireBodyCoordinates(event.next);
+		if (!previousBody || !nextBody) return axis1DrawRule.transform(event);
+		return restoreFireTip(axis1DrawRule.transform({
+			...event,
+			previous: previousBody,
+			next: nextBody
+		}), event.next[0]);
+	}
+};
 //#endregion
 //#region src/draw-rules/area21.ts
 function derive$1(points) {
@@ -4779,28 +4914,29 @@ function generateAntitankDitchTriangles(projectedPoints, toothHeight, toothWidth
 	return triangles;
 }
 /**
-* Projects `positions` and, when `options.smooth` is set, curves the result
-* through the control points (centripetal Catmull-Rom) before the teeth are
-* traced — matching Fortified Line's base-path smoothing. Returns the input
-* unchanged (no project/unproject round trip) when smoothing is off.
+* When `options.smooth` is set, curves the projected control points
+* (centripetal Catmull-Rom) before the teeth are traced — matching Fortified
+* Line's base-path smoothing.
 */
-function smoothedDitchBasePath(positions, options) {
-	const projectedPoints = positions.map((position) => project(position[0], position[1]));
+function ditchPaths(projectedPoints, options) {
 	const smoothedPath = smoothLineVerts(projectedPoints, options, 16);
 	const toothHeight = calculateAntitankDitchHeight(options);
 	const toothWidthRatio = Math.max(EPSILON, options.toothWidthRatio ?? DEFAULT_TOOTH_WIDTH_RATIO$1);
-	return options.smooth && projectedPoints.length >= 3 ? evenlySpacePath(smoothedPath, toothWidthRatio * toothHeight) : smoothedPath;
+	return {
+		smoothedPath,
+		basePath: options.smooth && projectedPoints.length >= 3 ? evenlySpacePath(smoothedPath, toothWidthRatio * toothHeight) : smoothedPath
+	};
 }
 function buildAntitankDitchTriangles(basePath, options) {
 	return generateAntitankDitchTriangles(basePath, calculateAntitankDitchHeight(options), options.toothWidthRatio ?? DEFAULT_TOOTH_WIDTH_RATIO$1);
 }
 function createAntitankDitchUnderConstruction(positions, options = {}, textAmplifiers = {}) {
-	const basePath = smoothedDitchBasePath(positions, options);
+	const { smoothedPath, basePath } = ditchPaths(positions.map((position) => project(position[0], position[1])), options);
 	const triangles = buildAntitankDitchTriangles(basePath, options);
 	const baseLine = options.smooth ? basePath.map((point) => unproject(point[0], point[1])) : positions.map((position) => [position[0], position[1]]);
 	const triangleLines = triangles.map((triangle) => triangle.map((point) => unproject(point[0], point[1])));
 	const labels = [];
-	pushHostileEndLabels(labels, basePath, textAmplifiers.N, options);
+	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options);
 	return {
 		type: "FeatureCollection",
 		features: [{
@@ -4814,12 +4950,12 @@ function createAntitankDitchUnderConstruction(positions, options = {}, textAmpli
 	};
 }
 function createAntitankDitchCompleted(positions, options = {}, textAmplifiers = {}) {
-	const basePath = smoothedDitchBasePath(positions, options);
+	const { smoothedPath, basePath } = ditchPaths(positions.map((position) => project(position[0], position[1])), options);
 	const polygons = buildAntitankDitchTriangles(basePath, options).map((triangle) => {
 		return [[...triangle, triangle[0]].map((point) => unproject(point[0], point[1]))];
 	});
 	const labels = [];
-	pushHostileEndLabels(labels, basePath, textAmplifiers.N, options);
+	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options);
 	return {
 		type: "FeatureCollection",
 		features: [{
@@ -4915,10 +5051,9 @@ function createAntitankWall(positions, options = {}, textAmplifiers = {}) {
 	const toothSpacingRatio = options.toothSpacingRatio ?? DEFAULT_TOOTH_SPACING_RATIO;
 	const projectedPoints = positions.map((position) => project(position[0], position[1]));
 	const smoothedPath = smoothLineVerts(projectedPoints, options, 16);
-	const basePath = options.smooth && projectedPoints.length >= 3 ? evenlySpacePath(smoothedPath, Math.max(EPSILON, toothWidthRatio) * toothHeight) : smoothedPath;
-	const wallLine = generateAntitankWallPoints(basePath, toothHeight, toothWidthRatio, toothSpacingRatio).map((point) => unproject(point[0], point[1]));
+	const wallLine = generateAntitankWallPoints(options.smooth && projectedPoints.length >= 3 ? evenlySpacePath(smoothedPath, Math.max(EPSILON, toothWidthRatio) * toothHeight) : smoothedPath, toothHeight, toothWidthRatio, toothSpacingRatio).map((point) => unproject(point[0], point[1]));
 	const labels = [];
-	pushHostileEndLabels(labels, basePath, textAmplifiers.N, options);
+	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options);
 	return {
 		type: "FeatureCollection",
 		features: [{
@@ -6448,6 +6583,10 @@ const GENERIC_C2_LINE = defineControlMeasure({
 });
 //#endregion
 //#region src/generators/cm34-mission-tasks/shared.ts
+/** Unprojects a point in Web Mercator meters back to a GeoJSON position. */
+function toPosition(point) {
+	return unproject(point[0], point[1]);
+}
 /**
 * Builds an open chevron arrowhead (left → tip → right) as unprojected
 * coordinates. The tip sits at `tip`, pointing along `dir`, with the base set
@@ -7966,17 +8105,28 @@ function createSupportingAttack(coordinates, options = {}) {
 			properties: {},
 			geometry: {
 				type: "LineString",
-				coordinates: [
-					...geometry.shaftLeft,
-					geometry.headRing[0],
-					geometry.headRing[1],
-					geometry.headRing[2],
-					...[...geometry.shaftRight].reverse()
-				].map((p) => unproject(p[0], p[1]))
+				coordinates: supportingAttackOutline(geometry)
 			}
 		}]
 	};
 }
+/**
+* Traces the single-LineString supporting-attack outline from already-computed
+* attack geometry, as unprojected coordinates. Exposed so measures that build
+* on the supporting-attack body (Counterattack by Fire) can reuse the trace
+* without running {@link processAttackGeometry} a second time.
+*
+* Path: [ShaftLeft...] -> OuterLeft -> Tip -> OuterRight -> [ShaftRight...(reversed)]
+*/
+function supportingAttackOutline(geometry) {
+	return [
+		...geometry.shaftLeft,
+		geometry.headRing[0],
+		geometry.headRing[1],
+		geometry.headRing[2],
+		...[...geometry.shaftRight].reverse()
+	].map((p) => unproject(p[0], p[1]));
+}
 const SUPPORTING_ATTACK = defineControlMeasure({
 	metadata: SUPPORTING_ATTACK_METADATA,
 	generator: createSupportingAttack,
@@ -8082,6 +8232,185 @@ const COUNTERATTACK = defineControlMeasure({
 	}
 });
 //#endregion
+//#region src/internal/arrowhead.ts
+/**
+* Builds a closed, filled arrowhead triangle ring in unprojected coordinates.
+*
+* `tip` is the point of the arrow, `dir` the unit direction the arrow points,
+* `length` the distance from tip back to the base, and `width` the base width.
+* The returned ring is `[left, tip, right, left]`.
+*/
+function createArrowHeadRing(tip, dir, length, width) {
+	const perp = [-dir[1], dir[0]];
+	const base = vecSub(tip, vecScale(dir, length));
+	const left = vecAdd(base, vecScale(perp, width / 2));
+	const right = vecSub(base, vecScale(perp, width / 2));
+	return [
+		unproject(left[0], left[1]),
+		unproject(tip[0], tip[1]),
+		unproject(right[0], right[1]),
+		unproject(left[0], left[1])
+	];
+}
+//#endregion
+//#region src/generators/cm34-mission-tasks/counterattack-by-fire.ts
+const DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS = { ...DEFAULT_COUNTERATTACK_OPTIONS };
+/** Length of the solid fire arrowhead relative to the recessed P1 extension. */
+const COUNTERATTACK_BY_FIRE_HEAD_RATIO = .18;
+const COUNTERATTACK_BY_FIRE_METADATA = {
+	id: "counterattack-by-fire",
+	name: "Counterattack by Fire",
+	description: "An attack against an enemy attacking force using fires",
+	entity: "Mission Tasks",
+	entityType: "Counterattack by Fire",
+	value: "340700",
+	minCoordinates: 3,
+	geometry: "line",
+	geometryTypes: [
+		"LineString",
+		"MultiLineString",
+		"Polygon",
+		"Point"
+	],
+	paints: {
+		stroke: true,
+		fill: "fixed",
+		text: true
+	},
+	drawRule: "Axis1",
+	capturesLabelSize: true,
+	params: [...ATTACK_SHAFT_PARAMS, {
+		key: "labelPosition",
+		label: "Label position",
+		description: "Position of the CATK label along the shaft, from tail (0) to head (1)",
+		type: "number",
+		min: 0,
+		max: 1,
+		step: .01
+	}],
+	textAmplifiers: [{
+		key: "T",
+		label: "Unique designation",
+		description: "Field T — the counterattack's unique designation.",
+		placeholder: "1",
+		maxLength: 21
+	}]
+};
+/** Generates the Counterattack by Fire mission task (340700). */
+function createCounterattackByFire(coordinates, options = {}, textAmplifiers = {}) {
+	const bodyCoordinates = counterattackByFireBodyCoordinates(coordinates);
+	if (!bodyCoordinates) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const { geometry } = processAttackGeometry(bodyCoordinates, options);
+	const fireTipCoordinate = coordinates[0];
+	if (!geometry || !fireTipCoordinate) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const fireTip = project(fireTipCoordinate[0], fireTipCoordinate[1]);
+	const bodyTip = geometry.ptTip;
+	const fireExtension = vecSub(fireTip, bodyTip);
+	const extensionLength = vecMag(fireExtension);
+	if (extensionLength < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const along = vecNorm(fireExtension);
+	const perpendicular = [-along[1], along[0]];
+	const headHalfWidth = vecMag(vecSub(geometry.headRing[0], geometry.ptBase));
+	const headLength = vecMag(vecSub(geometry.ptTip, geometry.ptBase));
+	const bracketCenter = vecAdd(bodyTip, vecScale(fireExtension, .5));
+	const bracketUpper = vecAdd(bracketCenter, vecScale(perpendicular, headHalfWidth));
+	const bracketLower = vecAdd(bracketCenter, vecScale(perpendicular, -headHalfWidth));
+	const flare = headHalfWidth * .55;
+	const bracketOuterUpper = vecAdd(vecAdd(bracketUpper, vecScale(along, -headLength)), vecScale(perpendicular, flare));
+	const bracketOuterLower = vecAdd(vecAdd(bracketLower, vecScale(along, -headLength)), vecScale(perpendicular, -flare));
+	const fireHeadLength = extensionLength * COUNTERATTACK_BY_FIRE_HEAD_RATIO;
+	const fireHeadBase = vecAdd(fireTip, vecScale(along, -fireHeadLength));
+	const features = [
+		{
+			type: "Feature",
+			properties: {
+				part: "counterattack-body",
+				style: { strokeDash: [...COUNTERATTACK_DASH] }
+			},
+			geometry: {
+				type: "LineString",
+				coordinates: supportingAttackOutline(geometry)
+			}
+		},
+		{
+			type: "Feature",
+			properties: {
+				part: "fire-attachment",
+				style: { strokeDash: [...COUNTERATTACK_DASH] }
+			},
+			geometry: {
+				type: "MultiLineString",
+				coordinates: [[
+					toPosition(bracketOuterUpper),
+					toPosition(bracketUpper),
+					toPosition(bracketLower),
+					toPosition(bracketOuterLower)
+				], [toPosition(bracketCenter), toPosition(fireHeadBase)]]
+			}
+		},
+		{
+			type: "Feature",
+			properties: {
+				part: "fire-arrowhead",
+				fill: true,
+				style: SOLID_ACCENT_FILL
+			},
+			geometry: {
+				type: "Polygon",
+				coordinates: [createArrowHeadRing(fireTip, along, fireHeadLength, fireHeadLength * 1.15)]
+			}
+		}
+	];
+	const { segments, totalLength } = polylineSegments(geometry.shaftCenterline);
+	const frame = pointAlongPolyline(segments, totalLength, options.labelPosition ?? DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS.labelPosition);
+	if (frame) {
+		const designation = textAmplifiers.T?.trim();
+		features.push({
+			type: "Feature",
+			properties: {
+				part: "label",
+				labelPlacement: false,
+				amplifierField: "T",
+				text: designation ? `CATK ${designation}` : "CATK",
+				rotation: labelRotationAlong(frame.along),
+				...labelSizeProps(options)
+			},
+			geometry: {
+				type: "Point",
+				coordinates: toPosition(frame.point)
+			}
+		});
+	}
+	return {
+		type: "FeatureCollection",
+		features
+	};
+}
+const COUNTERATTACK_BY_FIRE = defineControlMeasure({
+	metadata: COUNTERATTACK_BY_FIRE_METADATA,
+	generator: createCounterattackByFire,
+	defaultOptions: DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS,
+	rule: counterattackByFireDrawRule,
+	previewSample: {
+		controlPoints: [
+			[1.35, 0],
+			[-.2, -.1],
+			[-1, -.75],
+			[.45, .7]
+		],
+		options: { labelSize: 120 }
+	}
+});
+//#endregion
 //#region src/internal/field-of-fire.ts
 /**
 * Builds the open (stroked) arrowhead at the outward tip of one arm. The two
@@ -8492,6 +8821,44 @@ const DEFAULT_DELAY_OPTIONS = {
 	labelGapRatio: .18,
 	arcSegments: 32
 };
+const DELAY_PARAMS = [
+	{
+		key: "arrowheadLengthRatio",
+		label: "Arrowhead length",
+		description: "Arrowhead length as a ratio of the straight-line length",
+		type: "number",
+		min: .01,
+		max: 1,
+		step: .01
+	},
+	{
+		key: "arrowheadWidthRatio",
+		label: "Arrowhead width",
+		description: "Arrowhead base width as a ratio of the straight-line length",
+		type: "number",
+		min: .01,
+		max: 1,
+		step: .01
+	},
+	{
+		key: "labelGapRatio",
+		label: "Label gap",
+		description: "Size of the shaft gap holding the task label, as a ratio of the shaft length",
+		type: "number",
+		min: 0,
+		max: 1,
+		step: .01
+	},
+	{
+		key: "arcSegments",
+		label: "Arc segments",
+		description: "Number of straight segments used to approximate the semicircular arc",
+		type: "number",
+		min: 4,
+		max: 96,
+		step: 1
+	}
+];
 const DELAY_METADATA = {
 	id: "delay",
 	name: "Delay",
@@ -8510,44 +8877,7 @@ const DELAY_METADATA = {
 	},
 	drawRule: "Line24",
 	capturesLabelSize: true,
-	params: [
-		{
-			key: "arrowheadLengthRatio",
-			label: "Arrowhead length",
-			description: "Arrowhead length as a ratio of the straight-line length",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "arrowheadWidthRatio",
-			label: "Arrowhead width",
-			description: "Arrowhead base width as a ratio of the straight-line length",
-			type: "number",
-			min: .01,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "labelGapRatio",
-			label: "Label gap",
-			description: "Size of the shaft gap holding the 'D' label, as a ratio of the shaft length",
-			type: "number",
-			min: 0,
-			max: 1,
-			step: .01
-		},
-		{
-			key: "arcSegments",
-			label: "Arc segments",
-			description: "Number of straight segments used to approximate the semicircular arc",
-			type: "number",
-			min: 4,
-			max: 96,
-			step: 1
-		}
-	]
+	params: DELAY_PARAMS
 };
 function createDelaySymbol(coordinates, options = {}) {
 	const [c1, c2, c3] = coordinates;
@@ -8608,6 +8938,26 @@ function createSemicircleArc(start, end, bulgeDir, requestedSegments) {
 	}
 	return points;
 }
+/**
+* Line24 mission tasks that share Delay's geometry and differ only in the
+* glyph shown in the shaft gap and the `part` tag on the line feature.
+*/
+function createDelayVariantSymbol(coordinates, config, options = {}) {
+	return {
+		type: "FeatureCollection",
+		features: createDelaySymbol(coordinates, options).features.map((feature) => ({
+			...feature,
+			properties: feature.geometry.type === "Point" ? {
+				...feature.properties,
+				part: "label",
+				text: config.glyph
+			} : {
+				...feature.properties,
+				part: config.part
+			}
+		}))
+	};
+}
 const DELAY = defineControlMeasure({
 	metadata: DELAY_METADATA,
 	generator: createDelaySymbol,
@@ -8615,6 +8965,204 @@ const DELAY = defineControlMeasure({
 	rule: line24DrawRule
 });
 //#endregion
+//#region src/generators/cm34-mission-tasks/disengage.ts
+const DEFAULT_DISENGAGE_OPTIONS = DEFAULT_DELAY_OPTIONS;
+const DISENGAGE_METADATA = {
+	id: "disengage",
+	name: "Disengage",
+	description: "Breaks contact with the enemy to enable another mission or avoid decisive engagement.",
+	entity: "Mission Tasks",
+	entityType: "Disengage",
+	value: "344400",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line24",
+	capturesLabelSize: true,
+	params: DELAY_PARAMS
+};
+function createDisengageSymbol(coordinates, options = {}) {
+	return createDelayVariantSymbol(coordinates, {
+		glyph: "DIS",
+		part: "disengage"
+	}, options);
+}
+const DISENGAGE = defineControlMeasure({
+	metadata: DISENGAGE_METADATA,
+	generator: createDisengageSymbol,
+	defaultOptions: DEFAULT_DISENGAGE_OPTIONS,
+	rule: line24DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.4],
+			[1, -.4],
+			[0, .6]
+		],
+		options: { labelGapRatio: .36 }
+	}
+});
+//#endregion
+//#region src/generators/cm34-mission-tasks/disrupt.ts
+const DEFAULT_DISRUPT_MISSION_TASK_OPTIONS = {
+	middleArrowLengthRatio: .65,
+	bottomArrowLengthRatio: .45,
+	shaftLengthRatio: .25,
+	arrowheadLengthRatio: .15,
+	arrowheadWidthRatio: .2,
+	labelGapRatio: .2
+};
+const DISRUPT_MISSION_TASK_METADATA = {
+	id: "disrupt-mission-task",
+	name: "Disrupt",
+	description: "Upsets an enemy's formation or tempo and causes the enemy force to attack prematurely or in a piecemeal fashion.",
+	entity: "Mission Tasks",
+	entityType: "Disrupt",
+	value: "341000",
+	minCoordinates: 2,
+	maxCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Area12",
+	capturesLabelSize: true,
+	params: [
+		{
+			key: "middleArrowLengthRatio",
+			label: "Middle arrow length",
+			description: "Middle arrow length as a ratio of the PT.3-controlled top arrow",
+			type: "number",
+			min: .01,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "bottomArrowLengthRatio",
+			label: "Bottom arrow length",
+			description: "Bottom arrow length as a ratio of the PT.3-controlled top arrow",
+			type: "number",
+			min: .01,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "shaftLengthRatio",
+			label: "Rear shaft length",
+			description: "Middle shaft extension behind the spine, as a ratio of the top arrow",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "arrowheadLengthRatio",
+			label: "Arrowhead length",
+			description: "Arrowhead length as a ratio of the spine length",
+			type: "number",
+			min: .01,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "arrowheadWidthRatio",
+			label: "Arrowhead width",
+			description: "Arrowhead base width as a ratio of the spine length",
+			type: "number",
+			min: .01,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "labelGapRatio",
+			label: "Label gap",
+			description: "Size of the middle-shaft gap holding the 'D' label",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		}
+	]
+};
+/** Generates the DISRUPT mission task symbol (341000). */
+function createDisruptMissionTaskSymbol(coordinates, options = {}) {
+	const p1 = project(coordinates[0][0], coordinates[0][1]);
+	const p2 = project(coordinates[1][0], coordinates[1][1]);
+	const frame = createProjectedBaselineFrame(p1, p2, {
+		origin: "p1",
+		normal: "left"
+	});
+	if (!frame) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const c3 = coordinates[2];
+	const signedTopLength = c3 ? frame.signedNormalDistance(c3) : frame.length * 1.5;
+	const topLength = Math.abs(signedTopLength);
+	if (topLength < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const arrowDirection = vecScale(frame.normal, signedTopLength < 0 ? -1 : 1);
+	const middle = vecScale(vecAdd(p1, p2), .5);
+	/** Scales `base` by the named ratio option, falling back to its default and clamping negatives. */
+	const scaled = (base, key) => base * Math.max(0, options[key] ?? DEFAULT_DISRUPT_MISSION_TASK_OPTIONS[key]);
+	const middleLength = scaled(topLength, "middleArrowLengthRatio");
+	const bottomLength = scaled(topLength, "bottomArrowLengthRatio");
+	const rearLength = scaled(topLength, "shaftLengthRatio");
+	const headLength = scaled(frame.length, "arrowheadLengthRatio");
+	const headWidth = scaled(frame.length, "arrowheadWidthRatio");
+	const topTip = vecAdd(p1, vecScale(arrowDirection, topLength));
+	const middleTip = vecAdd(middle, vecScale(arrowDirection, middleLength));
+	const bottomTip = vecAdd(p2, vecScale(arrowDirection, bottomLength));
+	const rearEnd = vecAdd(middle, vecScale(arrowDirection, -rearLength));
+	const labelPoint = vecScale(vecAdd(middle, middleTip), .5);
+	const labelGapRatio = clamp01(options.labelGapRatio ?? DEFAULT_DISRUPT_MISSION_TASK_OPTIONS.labelGapRatio);
+	const gapHalf = Math.min(topLength * labelGapRatio / 2, middleLength / 2);
+	const gapStart = vecAdd(labelPoint, vecScale(arrowDirection, -gapHalf));
+	const gapEnd = vecAdd(labelPoint, vecScale(arrowDirection, gapHalf));
+	const p1LonLat = unproject(p1[0], p1[1]);
+	const p2LonLat = unproject(p2[0], p2[1]);
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: { part: "disrupt" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: [
+					[p1LonLat, p2LonLat],
+					[[...p1LonLat], unproject(topTip[0], topTip[1])],
+					createArrowHead$1(topTip, arrowDirection, headLength, headWidth),
+					[unproject(rearEnd[0], rearEnd[1]), unproject(gapStart[0], gapStart[1])],
+					[unproject(gapEnd[0], gapEnd[1]), unproject(middleTip[0], middleTip[1])],
+					createArrowHead$1(middleTip, arrowDirection, headLength, headWidth),
+					[[...p2LonLat], unproject(bottomTip[0], bottomTip[1])],
+					createArrowHead$1(bottomTip, arrowDirection, headLength, headWidth)
+				]
+			}
+		}, createLabelFeature(labelPoint, "D", labelRotationAlong(arrowDirection), {
+			labelSize: options.labelSize,
+			labelSizePixels: options.labelSizePixels
+		})]
+	};
+}
+const DISRUPT_MISSION_TASK = defineControlMeasure({
+	metadata: DISRUPT_MISSION_TASK_METADATA,
+	generator: createDisruptMissionTaskSymbol,
+	defaultOptions: DEFAULT_DISRUPT_MISSION_TASK_OPTIONS,
+	rule: disruptDrawRule,
+	previewSample: { controlPoints: [[0, .4], [0, -.4]] }
+});
+//#endregion
 //#region src/generators/cm34-mission-tasks/guard.ts
 const DEFAULT_GUARD_OPTIONS = DEFAULT_SECURITY_TASK_OPTIONS;
 const GUARD_METADATA = {
@@ -8660,27 +9208,6 @@ const GUARD = defineControlMeasure({
 	}
 });
 //#endregion
-//#region src/internal/arrowhead.ts
-/**
-* Builds a closed, filled arrowhead triangle ring in unprojected coordinates.
-*
-* `tip` is the point of the arrow, `dir` the unit direction the arrow points,
-* `length` the distance from tip back to the base, and `width` the base width.
-* The returned ring is `[left, tip, right, left]`.
-*/
-function createArrowHeadRing(tip, dir, length, width) {
-	const perp = [-dir[1], dir[0]];
-	const base = vecSub(tip, vecScale(dir, length));
-	const left = vecAdd(base, vecScale(perp, width / 2));
-	const right = vecSub(base, vecScale(perp, width / 2));
-	return [
-		unproject(left[0], left[1]),
-		unproject(tip[0], tip[1]),
-		unproject(right[0], right[1]),
-		unproject(left[0], left[1])
-	];
-}
-//#endregion
 //#region src/generators/cm27-protection-areas/disrupt.ts
 const DEFAULT_DISRUPT_OPTIONS = {
 	middleArrowLengthRatio: .65,
@@ -9467,6 +9994,175 @@ const FIX = defineControlMeasure({
 	previewSample: { controlPoints: [[1, 0], [-1, 0]] }
 });
 //#endregion
+//#region src/generators/cm34-mission-tasks/fix.ts
+const DEFAULT_FIX_MISSION_TASK_OPTIONS = {
+	arrowheadLengthRatio: .11,
+	arrowheadWidthRatio: .18,
+	zigzagStartRatio: .18,
+	zigzagEndRatio: .8,
+	zigzagPeakCount: 5,
+	labelPositionRatio: .09,
+	labelGapRatio: .1
+};
+const FIX_MISSION_TASK_METADATA = {
+	id: "fix-mission-task",
+	name: "Fix",
+	description: "Prevents an enemy force from moving from a specific location for a specified period of time.",
+	entity: "Mission Tasks",
+	entityType: "Fix",
+	value: "341100",
+	minCoordinates: 2,
+	maxCoordinates: 2,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line9",
+	capturesLabelSize: true,
+	params: [
+		{
+			key: "arrowheadLengthRatio",
+			label: "Arrowhead length",
+			description: "Arrowhead length as a ratio of the axis length",
+			type: "number",
+			min: .01,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "arrowheadWidthRatio",
+			label: "Arrowhead width",
+			description: "Arrowhead base width as a ratio of the axis length",
+			type: "number",
+			min: .01,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "zigzagStartRatio",
+			label: "Zigzag start",
+			description: "Position where the zigzag begins, measured from PT2",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "zigzagEndRatio",
+			label: "Zigzag end",
+			description: "Position where the zigzag ends, measured from PT2",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "zigzagPeakCount",
+			label: "Zigzag peaks",
+			description: "Number of upward peaks in the zigzag body",
+			type: "number",
+			min: 1,
+			max: 12,
+			step: 1
+		},
+		{
+			key: "labelPositionRatio",
+			label: "Label position",
+			description: "Position of the F label along the axis, measured from PT2",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "labelGapRatio",
+			label: "Label gap",
+			description: "Size of the shaft gap holding the F label",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		}
+	]
+};
+/** Generates the Fix mission task symbol (341100). */
+function createFixMissionTaskSymbol(coordinates, options = {}) {
+	const c1 = coordinates[0];
+	const c2 = coordinates[1];
+	const tip = project(c1[0], c1[1]);
+	const tail = project(c2[0], c2[1]);
+	const axis = vecSub(tip, tail);
+	const axisLength = vecMag(axis);
+	if (axisLength < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const along = vecNorm(axis);
+	const perpendicular = [-along[1], along[0]];
+	const arrowheadLength = axisLength * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_FIX_MISSION_TASK_OPTIONS.arrowheadLengthRatio);
+	const arrowheadWidth = axisLength * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_FIX_MISSION_TASK_OPTIONS.arrowheadWidthRatio);
+	const requestedStart = clamp01(options.zigzagStartRatio ?? DEFAULT_FIX_MISSION_TASK_OPTIONS.zigzagStartRatio);
+	const requestedEnd = clamp01(options.zigzagEndRatio ?? DEFAULT_FIX_MISSION_TASK_OPTIONS.zigzagEndRatio);
+	const zigzagStart = Math.min(requestedStart, requestedEnd);
+	const zigzagEnd = Math.max(requestedStart, requestedEnd);
+	const extremumCount = Math.round(clamp(options.zigzagPeakCount ?? DEFAULT_FIX_MISSION_TASK_OPTIONS.zigzagPeakCount, 1, 12)) * 2 + 1;
+	const amplitude = arrowheadWidth / 2;
+	const zigzag = [];
+	for (let index = 0; index < extremumCount; index += 1) {
+		const progress = extremumCount === 1 ? 0 : index / (extremumCount - 1);
+		const distance = axisLength * (zigzagStart + (zigzagEnd - zigzagStart) * progress);
+		const side = index % 2 === 0 ? -1 : 1;
+		zigzag.push(vecAdd(vecAdd(tail, vecScale(along, distance)), vecScale(perpendicular, amplitude * side)));
+	}
+	const toothStep = extremumCount > 1 ? (zigzagEnd - zigzagStart) / (extremumCount - 1) : 0;
+	const entryRatio = Math.max(0, zigzagStart - toothStep / 2);
+	const exitRatio = Math.min(1, zigzagEnd + toothStep / 2);
+	const zigzagEntry = vecAdd(tail, vecScale(along, axisLength * entryRatio));
+	const zigzagExit = vecAdd(tail, vecScale(along, axisLength * exitRatio));
+	const labelPosition = clamp01(options.labelPositionRatio ?? DEFAULT_FIX_MISSION_TASK_OPTIONS.labelPositionRatio);
+	const labelGap = axisLength * clamp01(options.labelGapRatio ?? DEFAULT_FIX_MISSION_TASK_OPTIONS.labelGapRatio);
+	const labelDistance = axisLength * labelPosition;
+	const labelCenter = vecAdd(tail, vecScale(along, labelDistance));
+	const gapStartDistance = Math.max(0, labelDistance - labelGap / 2);
+	const gapEndDistance = Math.min(axisLength, labelDistance + labelGap / 2);
+	const gapStart = vecAdd(tail, vecScale(along, gapStartDistance));
+	const gapEnd = vecAdd(tail, vecScale(along, gapEndDistance));
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: { part: "fix-mission-task" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: [
+					[toPosition(tail), toPosition(gapStart)],
+					[
+						toPosition(gapEnd),
+						toPosition(zigzagEntry),
+						...zigzag.map(toPosition),
+						toPosition(zigzagExit),
+						toPosition(tip)
+					],
+					createArrowHead$1(tip, along, arrowheadLength, arrowheadWidth)
+				]
+			}
+		}, createLabelFeature(labelCenter, "F", labelRotationAlong(along), options)]
+	};
+}
+const FIX_MISSION_TASK = defineControlMeasure({
+	metadata: FIX_MISSION_TASK_METADATA,
+	generator: createFixMissionTaskSymbol,
+	defaultOptions: DEFAULT_FIX_MISSION_TASK_OPTIONS,
+	rule: line9DrawRule,
+	previewSample: {
+		controlPoints: [[1, 0], [-1, 0]],
+		options: { labelSize: 110 }
+	}
+});
+//#endregion
 //#region src/generators/cm14-maneuver-lines/flot.ts
 const DEFAULT_RADIUS = 50;
 const DEFAULT_RADIUS_PIXELS = 10;
@@ -9653,7 +10349,7 @@ function createFLOT(positions, options = {}, textAmplifiers = {}) {
 		}
 	};
 	const labels = [];
-	pushHostileEndLabels(labels, allPoints, textAmplifiers.N, options);
+	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options);
 	return {
 		type: "FeatureCollection",
 		features: [feature, ...labels]
@@ -10332,17 +11028,17 @@ function createFortifiedLine(positions, options = {}, textAmplifiers = {}) {
 	const { smooth = DEFAULT_FORTIFIED_LINE_OPTIONS.smooth, smoothResolution = DEFAULT_FORTIFIED_LINE_OPTIONS.smoothResolution } = options;
 	const safeSize = calculateEffectiveSize(options);
 	const projectedPoints = positions.map((p) => project(p[0], p[1]));
-	const allPoints = generateFortifiedPoints(smooth ? evenlySpacePath(catmullRom(projectedPoints, normalizeSmoothResolution$2(smoothResolution, DEFAULT_SMOOTH_RESOLUTION$1)), 2 * safeSize) : projectedPoints, safeSize);
+	const smoothedPath = smooth ? catmullRom(projectedPoints, normalizeSmoothResolution$2(smoothResolution, DEFAULT_SMOOTH_RESOLUTION$1)) : projectedPoints;
 	const feature = {
 		type: "Feature",
 		properties: {},
 		geometry: {
 			type: "LineString",
-			coordinates: allPoints.map((p) => unproject(p[0], p[1]))
+			coordinates: generateFortifiedPoints(smooth ? evenlySpacePath(smoothedPath, 2 * safeSize) : smoothedPath, safeSize).map((p) => unproject(p[0], p[1]))
 		}
 	};
 	const labels = [];
-	pushHostileEndLabels(labels, allPoints, textAmplifiers.N, options);
+	pushHostileEndLabels(labels, smoothedPath, textAmplifiers.N, options);
 	return {
 		type: "FeatureCollection",
 		features: [feature, ...labels]
@@ -10784,6 +11480,200 @@ const ISOLATE = defineControlMeasure({
 	rule: isolateDrawRule
 });
 //#endregion
+//#region src/generators/cm34-mission-tasks/penetrate.ts
+const DEFAULT_PENETRATE_OPTIONS = {
+	arrowheadLengthRatio: .15,
+	arrowheadWidthRatio: .2,
+	labelGapRatio: .2
+};
+const PENETRATE_METADATA = {
+	id: "penetrate",
+	name: "Penetrate",
+	description: "Breaks through an enemy defense and disrupts the continuity of the defensive system.",
+	entity: "Mission Tasks",
+	entityType: "Penetrate",
+	value: "341800",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Area17",
+	capturesLabelSize: true,
+	params: [
+		{
+			key: "arrowheadLengthRatio",
+			label: "Arrowhead length",
+			description: "Arrowhead length as a ratio of the barrier length",
+			type: "number",
+			min: .01,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "arrowheadWidthRatio",
+			label: "Arrowhead width",
+			description: "Arrowhead base width as a ratio of the barrier length",
+			type: "number",
+			min: .01,
+			max: 1,
+			step: .01
+		},
+		{
+			key: "labelGapRatio",
+			label: "Label gap",
+			description: "Size of the shaft gap holding the 'P' label",
+			type: "number",
+			min: 0,
+			max: 1,
+			step: .01
+		}
+	]
+};
+/** Generates the PENETRATE mission task symbol (341800). */
+function createPenetrateSymbol(coordinates, options = {}) {
+	const frame = createProjectedBaselineFrame(project(coordinates[0][0], coordinates[0][1]), project(coordinates[1][0], coordinates[1][1]), {
+		origin: "midpoint",
+		normal: "right"
+	});
+	if (!frame) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const c3 = coordinates[2];
+	const signedTailDistance = c3 ? frame.signedNormalDistance(c3) : frame.length * 1.5;
+	const shaftLength = Math.abs(signedTailDistance);
+	if (shaftLength < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const tip = frame.origin;
+	const tail = vecAdd(frame.origin, vecScale(frame.normal, signedTailDistance));
+	const arrowDirection = vecScale(vecSub(tip, tail), 1 / shaftLength);
+	const labelPoint = vecScale(vecAdd(tail, tip), .5);
+	const gapHalf = shaftLength * Math.min(1, Math.max(0, options.labelGapRatio ?? DEFAULT_PENETRATE_OPTIONS.labelGapRatio)) / 2;
+	const gapStart = vecAdd(labelPoint, vecScale(arrowDirection, -gapHalf));
+	const gapEnd = vecAdd(labelPoint, vecScale(arrowDirection, gapHalf));
+	const headLength = frame.length * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_PENETRATE_OPTIONS.arrowheadLengthRatio);
+	const headWidth = frame.length * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_PENETRATE_OPTIONS.arrowheadWidthRatio);
+	const lineFeature = {
+		type: "Feature",
+		properties: { part: "penetrate" },
+		geometry: {
+			type: "MultiLineString",
+			coordinates: [
+				[coordinates[0], coordinates[1]],
+				[unproject(tail[0], tail[1]), unproject(gapStart[0], gapStart[1])],
+				[unproject(gapEnd[0], gapEnd[1]), unproject(tip[0], tip[1])],
+				createArrowHead$1(tip, arrowDirection, headLength, headWidth)
+			]
+		}
+	};
+	const shaftRotation = Math.atan2(arrowDirection[1], arrowDirection[0]);
+	const renderedLabelRotation = Math.PI - shaftRotation;
+	return {
+		type: "FeatureCollection",
+		features: [lineFeature, createLabelFeature(labelPoint, "P", normalizeRadians(Math.PI - keepTextLeftToRight(renderedLabelRotation)), {
+			labelSize: options.labelSize,
+			labelSizePixels: options.labelSizePixels
+		})]
+	};
+}
+const PENETRATE = defineControlMeasure({
+	metadata: PENETRATE_METADATA,
+	generator: createPenetrateSymbol,
+	defaultOptions: DEFAULT_PENETRATE_OPTIONS,
+	rule: penetrateDrawRule,
+	previewSample: { controlPoints: [
+		[0, .4],
+		[0, -.4],
+		[-1.2, 0]
+	] }
+});
+//#endregion
+//#region src/generators/cm34-mission-tasks/rearward-passage-of-lines.ts
+const DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS = DEFAULT_DELAY_OPTIONS;
+const REARWARD_PASSAGE_OF_LINES_METADATA = {
+	id: "rearward-passage-of-lines",
+	name: "Rearward Passage of Lines",
+	description: "Passes one force through another force's positions toward the rear.",
+	entity: "Mission Tasks",
+	entityType: "Rearward Passage of Lines",
+	value: "344200",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line24",
+	capturesLabelSize: true,
+	params: DELAY_PARAMS
+};
+function createRearwardPassageOfLinesSymbol(coordinates, options = {}) {
+	return createDelayVariantSymbol(coordinates, {
+		glyph: "P(R)",
+		part: "rearward-passage-of-lines"
+	}, options);
+}
+const REARWARD_PASSAGE_OF_LINES = defineControlMeasure({
+	metadata: REARWARD_PASSAGE_OF_LINES_METADATA,
+	generator: createRearwardPassageOfLinesSymbol,
+	defaultOptions: DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS,
+	rule: line24DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.4],
+			[1, -.4],
+			[0, .6]
+		],
+		options: { labelGapRatio: .42 }
+	}
+});
+//#endregion
+//#region src/generators/cm34-mission-tasks/retire.ts
+const DEFAULT_RETIRE_OPTIONS = DEFAULT_DELAY_OPTIONS;
+const RETIRE_METADATA = {
+	id: "retire",
+	name: "Retire/Retirement",
+	description: "Moves a force out of contact away from the enemy.",
+	entity: "Mission Tasks",
+	entityType: "Retire/Retirement",
+	value: "342000",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line24",
+	capturesLabelSize: true,
+	params: DELAY_PARAMS
+};
+/** Generates the RETIRE/RETIREMENT mission task symbol (342000). */
+function createRetireSymbol(coordinates, options = {}) {
+	return createDelayVariantSymbol(coordinates, {
+		glyph: "R",
+		part: "retire"
+	}, options);
+}
+const RETIRE = defineControlMeasure({
+	metadata: RETIRE_METADATA,
+	generator: createRetireSymbol,
+	defaultOptions: DEFAULT_RETIRE_OPTIONS,
+	rule: line24DrawRule
+});
+//#endregion
 //#region src/generators/cm34-mission-tasks/screen.ts
 const DEFAULT_SCREEN_OPTIONS = DEFAULT_SECURITY_TASK_OPTIONS;
 const SCREEN_METADATA = {
@@ -10829,6 +11719,281 @@ const SCREEN = defineControlMeasure({
 	}
 });
 //#endregion
+//#region src/generators/cm34-mission-tasks/seize.ts
+const DEFAULT_SEIZE_OPTIONS = {
+	arrowheadLengthRatio: .1,
+	arrowheadWidthRatio: .12,
+	labelGapRatio: .13,
+	curveSegments: 48,
+	circleSegments: 64
+};
+const SEIZE_METADATA = {
+	id: "seize",
+	name: "Seize",
+	description: "Takes possession of a designated area using overwhelming force and establishes control of it.",
+	entity: "Mission Tasks",
+	entityType: "Seize",
+	value: "342300",
+	minCoordinates: 4,
+	maxCoordinates: 4,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line27",
+	capturesLabelSize: true,
+	params: [
+		{
+			key: "arrowheadLengthRatio",
+			label: "Arrowhead length",
+			description: "Arrowhead length as a ratio of the PT. 2-to-PT. 4 span",
+			type: "number",
+			min: .01,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "arrowheadWidthRatio",
+			label: "Arrowhead width",
+			description: "Arrowhead base width as a ratio of the PT. 2-to-PT. 4 span",
+			type: "number",
+			min: .01,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "labelGapRatio",
+			label: "Label gap",
+			description: "Size of the curve gap holding the S label",
+			type: "number",
+			min: 0,
+			max: .5,
+			step: .01
+		},
+		{
+			key: "curveSegments",
+			label: "Curve segments",
+			description: "Number of straight segments used to approximate the circular arc",
+			type: "number",
+			min: 4,
+			max: 128,
+			step: 1
+		},
+		{
+			key: "circleSegments",
+			label: "Circle segments",
+			description: "Number of straight segments used to approximate the assigned-unit circle",
+			type: "number",
+			min: 12,
+			max: 128,
+			step: 1
+		}
+	]
+};
+function positiveAngle(angle) {
+	const normalized = angle % (Math.PI * 2);
+	return normalized < 0 ? normalized + Math.PI * 2 : normalized;
+}
+/** Returns the unique circular arc from start to end that passes through middle. */
+function threePointArc(start, middle, end) {
+	const [ax, ay] = start;
+	const [bx, by] = middle;
+	const [cx, cy] = end;
+	const determinant = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
+	const scale = Math.max(vecMag(vecSub(middle, start)), vecMag(vecSub(end, start)), 1);
+	if (Math.abs(determinant) < 1e-6 * scale * scale) return null;
+	const a2 = ax * ax + ay * ay;
+	const b2 = bx * bx + by * by;
+	const c2 = cx * cx + cy * cy;
+	const center = [(a2 * (by - cy) + b2 * (cy - ay) + c2 * (ay - by)) / determinant, (a2 * (cx - bx) + b2 * (ax - cx) + c2 * (bx - ax)) / determinant];
+	const radius = vecMag(vecSub(start, center));
+	if (radius < 1e-6) return null;
+	const startAngle = Math.atan2(ay - center[1], ax - center[0]);
+	const middleAngle = Math.atan2(by - center[1], bx - center[0]);
+	const counterclockwiseSweep = positiveAngle(Math.atan2(cy - center[1], cx - center[0]) - startAngle);
+	return {
+		center,
+		radius,
+		startAngle,
+		sweepAngle: positiveAngle(middleAngle - startAngle) <= counterclockwiseSweep ? counterclockwiseSweep : counterclockwiseSweep - Math.PI * 2
+	};
+}
+/** Generates the Seize mission task symbol (342300). */
+function createSeizeSymbol(coordinates, options = {}) {
+	const [c1, c2, c3, c4] = coordinates;
+	const center = project(c1[0], c1[1]);
+	const start = project(c2[0], c2[1]);
+	const curvePoint = project(c3[0], c3[1]);
+	const tip = project(c4[0], c4[1]);
+	const radiusVector = vecSub(start, center);
+	const radius = vecMag(radiusVector);
+	const span = vecMag(vecSub(tip, start));
+	if (radius < 1e-6 || span < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const curveSegments = Math.round(Math.min(128, Math.max(4, options.curveSegments ?? DEFAULT_SEIZE_OPTIONS.curveSegments)));
+	const circleSegments = Math.round(Math.min(128, Math.max(12, options.circleSegments ?? DEFAULT_SEIZE_OPTIONS.circleSegments)));
+	const arc = threePointArc(start, curvePoint, tip);
+	let firstArcPart;
+	let secondArcPart;
+	let arrowDirection;
+	let labelPoint;
+	let tangentAtLabel;
+	if (arc) {
+		const gapHalf = clamp01(options.labelGapRatio ?? DEFAULT_SEIZE_OPTIONS.labelGapRatio) / 2;
+		const gapStart = .5 - gapHalf;
+		const gapEnd = .5 + gapHalf;
+		const sampleArc = (from, to) => {
+			const count = Math.max(1, Math.ceil(curveSegments * (to - from)));
+			const points = [];
+			for (let index = 0; index <= count; index += 1) {
+				const progress = from + (to - from) * index / count;
+				const angle = arc.startAngle + arc.sweepAngle * progress;
+				points.push(toPosition(vecAdd(arc.center, [arc.radius * Math.cos(angle), arc.radius * Math.sin(angle)])));
+			}
+			return points;
+		};
+		firstArcPart = sampleArc(0, gapStart);
+		secondArcPart = sampleArc(gapEnd, 1);
+		const endAngle = arc.startAngle + arc.sweepAngle;
+		const sweepSign = Math.sign(arc.sweepAngle);
+		arrowDirection = [-Math.sin(endAngle) * sweepSign, Math.cos(endAngle) * sweepSign];
+		const labelAngle = arc.startAngle + arc.sweepAngle / 2;
+		labelPoint = vecAdd(arc.center, [arc.radius * Math.cos(labelAngle), arc.radius * Math.sin(labelAngle)]);
+		tangentAtLabel = [-Math.sin(labelAngle) * sweepSign, Math.cos(labelAngle) * sweepSign];
+	} else {
+		labelPoint = vecScale(vecAdd(start, tip), .5);
+		const gapHalf = span * clamp01(options.labelGapRatio ?? DEFAULT_SEIZE_OPTIONS.labelGapRatio) / 2;
+		const direction = vecNorm(vecSub(tip, start));
+		const before = vecAdd(labelPoint, vecScale(direction, -gapHalf));
+		const after = vecAdd(labelPoint, vecScale(direction, gapHalf));
+		firstArcPart = [toPosition(start), toPosition(before)];
+		secondArcPart = [toPosition(after), toPosition(tip)];
+		const terminal = vecSub(tip, curvePoint);
+		arrowDirection = vecMag(terminal) >= 1e-6 ? vecNorm(terminal) : vecNorm(vecSub(tip, start));
+		tangentAtLabel = direction;
+	}
+	const startAngle = Math.atan2(radiusVector[1], radiusVector[0]);
+	const circle = [];
+	for (let index = 0; index <= circleSegments; index += 1) {
+		const angle = startAngle + index / circleSegments * Math.PI * 2;
+		circle.push(toPosition(vecAdd(center, [radius * Math.cos(angle), radius * Math.sin(angle)])));
+	}
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: { part: "seize" },
+			geometry: {
+				type: "MultiLineString",
+				coordinates: [
+					circle,
+					firstArcPart,
+					secondArcPart,
+					createArrowHead$1(tip, arrowDirection, span * Math.max(0, options.arrowheadLengthRatio ?? DEFAULT_SEIZE_OPTIONS.arrowheadLengthRatio), span * Math.max(0, options.arrowheadWidthRatio ?? DEFAULT_SEIZE_OPTIONS.arrowheadWidthRatio))
+				]
+			}
+		}, createLabelFeature(labelPoint, "S", labelRotationAlong(tangentAtLabel), options)]
+	};
+}
+const SEIZE = defineControlMeasure({
+	metadata: SEIZE_METADATA,
+	generator: createSeizeSymbol,
+	defaultOptions: DEFAULT_SEIZE_OPTIONS,
+	rule: line27DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-.8, .35],
+			[-.45, .35],
+			[.15, .25],
+			[.85, -.55]
+		],
+		options: { labelSize: 100 }
+	}
+});
+//#endregion
+//#region src/generators/cm34-mission-tasks/withdraw.ts
+const DEFAULT_WITHDRAW_OPTIONS = DEFAULT_DELAY_OPTIONS;
+const WITHDRAW_METADATA = {
+	id: "withdraw",
+	name: "Withdraw",
+	description: "Disengages a force from the enemy and moves it away from enemy contact.",
+	entity: "Mission Tasks",
+	entityType: "Withdraw",
+	value: "342400",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line24",
+	capturesLabelSize: true,
+	params: DELAY_PARAMS
+};
+function createWithdrawSymbol(coordinates, options = {}) {
+	return createDelayVariantSymbol(coordinates, {
+		glyph: "W",
+		part: "withdraw"
+	}, options);
+}
+const WITHDRAW = defineControlMeasure({
+	metadata: WITHDRAW_METADATA,
+	generator: createWithdrawSymbol,
+	defaultOptions: DEFAULT_WITHDRAW_OPTIONS,
+	rule: line24DrawRule
+});
+//#endregion
+//#region src/generators/cm34-mission-tasks/withdraw-under-pressure.ts
+const DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS = DEFAULT_DELAY_OPTIONS;
+const WITHDRAW_UNDER_PRESSURE_METADATA = {
+	id: "withdraw-under-pressure",
+	name: "Withdraw Under Pressure",
+	description: "Disengages a force from the enemy and moves it away while under enemy pressure.",
+	entity: "Mission Tasks",
+	entityType: "Withdraw Under Pressure",
+	value: "342500",
+	minCoordinates: 3,
+	maxCoordinates: 3,
+	geometry: "line",
+	geometryTypes: ["MultiLineString", "Point"],
+	paints: {
+		stroke: true,
+		fill: "none",
+		text: true
+	},
+	drawRule: "Line24",
+	capturesLabelSize: true,
+	params: DELAY_PARAMS
+};
+function createWithdrawUnderPressureSymbol(coordinates, options = {}) {
+	return createDelayVariantSymbol(coordinates, {
+		glyph: "WP",
+		part: "withdraw-under-pressure"
+	}, options);
+}
+const WITHDRAW_UNDER_PRESSURE = defineControlMeasure({
+	metadata: WITHDRAW_UNDER_PRESSURE_METADATA,
+	generator: createWithdrawUnderPressureSymbol,
+	defaultOptions: DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS,
+	rule: line24DrawRule,
+	previewSample: {
+		controlPoints: [
+			[-1, -.4],
+			[1, -.4],
+			[0, .6]
+		],
+		options: { labelGapRatio: .3 }
+	}
+});
+//#endregion
 //#region src/generators/cm15-maneuver-areas/jointTacticalActionArea.ts
 /** Default options for the Joint tactical action area control measure. */
 const DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS = {
@@ -12699,11 +13864,20 @@ const DEFINITIONS = {
 	canalize: CANALIZE,
 	clear: CLEAR,
 	counterattack: COUNTERATTACK,
+	"counterattack-by-fire": COUNTERATTACK_BY_FIRE,
 	cover: COVER,
 	delay: DELAY,
+	disengage: DISENGAGE,
+	"disrupt-mission-task": DISRUPT_MISSION_TASK,
 	guard: GUARD,
 	isolate: ISOLATE,
+	penetrate: PENETRATE,
+	"rearward-passage-of-lines": REARWARD_PASSAGE_OF_LINES,
+	retire: RETIRE,
 	screen: SCREEN,
+	seize: SEIZE,
+	withdraw: WITHDRAW,
+	"withdraw-under-pressure": WITHDRAW_UNDER_PRESSURE,
 	"antitank-ditch-under-construction": ANTITANK_DITCH_UNDER_CONSTRUCTION,
 	"antitank-ditch-completed": ANTITANK_DITCH_COMPLETED,
 	"antitank-wall": ANTITANK_WALL,
@@ -12733,6 +13907,7 @@ const DEFINITIONS = {
 	block: BLOCK,
 	disrupt: DISRUPT,
 	fix: FIX,
+	"fix-mission-task": FIX_MISSION_TASK,
 	turn: TURN,
 	"obstacle-bypass-easy": OBSTACLE_BYPASS_EASY,
 	"obstacle-bypass-difficult": OBSTACLE_BYPASS_DIFFICULT,
@@ -13100,4 +14275,4 @@ function assertNever(value) {
 	throw new Error(`Unhandled control measure kind: ${String(value)}`);
 }
 //#endregion
-export { DEFAULT_CANALIZE_OPTIONS as $, roundToFixed as $t, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as A, line24DrawRule as At, DEFAULT_GUARD_OPTIONS as B, computeDefaultMidpointPerpendicularPoint as Bt, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as C, resolveAmplifierPlacement as Ct, DEFAULT_FORTIFIED_LINE_OPTIONS as D, axis1DrawRule as Dt, DEFAULT_FORTIFIED_AREA_OPTIONS as E, rectangleDrawRule as Et, DEFAULT_FLOT_OPTIONS as F, attackByFireDrawRule as Ft, DEFAULT_SUPPORTING_ATTACK_OPTIONS as G, createBaselineFrame as Gt, DEFAULT_COVER_OPTIONS as H, getMidpointPerpendicularSignedDistance as Ht, DEFAULT_FIX_OPTIONS as I, point12DrawRule as It, DEFAULT_GENERIC_RECTANGLE_OPTIONS as J, haversineDistance as Jt, DEFAULT_CLEAR_OPTIONS as K, calculateMetrics as Kt, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as L, centerRadiusDrawRule as Lt, DEFAULT_HOLDING_LINE_OPTIONS as M, turnDrawRule as Mt, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as N, line1DrawRule as Nt, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as O, supportByFireDrawRule as Ot, DEFAULT_PHASE_LINE_OPTIONS as P, ambushDrawRule as Pt, DEFAULT_CLASSIC_ARROW_OPTIONS as Q, getMetersPerPixel as Qt, DEFAULT_ENCIRCLEMENT_OPTIONS as R, disruptDrawRule as Rt, DEFAULT_LANDING_ZONE_OPTIONS as S, normalizeTextAmplifiers as St, DEFAULT_FRONTAL_ATTACK_OPTIONS as T, DEFAULT_AIRBORNE_ATTACK_OPTIONS as Tt, DEFAULT_TACTICAL_ARROW_OPTIONS as U, pointOnMidpointPerpendicularAxis as Ut, DEFAULT_DELAY_OPTIONS as V, createMidpointPerpendicularDrawRule as Vt, DEFAULT_COUNTERATTACK_OPTIONS as W, snapToMidpointPerpendicular as Wt, DEFAULT_GENERIC_LINE_OPTIONS as X, unproject as Xt, DEFAULT_GENERIC_POLYGON_OPTIONS as Y, project as Yt, DEFAULT_GENERIC_CIRCLE_OPTIONS as Z, EPSILON as Zt, DEFAULT_PICKUP_ZONE_OPTIONS as _, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as _t, DEFINITIONS as a, DEFAULT_LIGHT_LINE_OPTIONS as at, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as b, TEXT_AMPLIFIER_FIELDS as bt, getDefaultOptions as c, DEFAULT_BLOCK_OPTIONS as ct, DEFAULT_TURN_OPTIONS as d, DEFAULT_ATTACK_BY_FIRE_OPTIONS as dt, DEFAULT_BYPASS_OPTIONS as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, DEFAULT_ANTITANK_WALL_OPTIONS as ft, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as g, DEFAULT_AREA_DEFENSE_OPTIONS as gt, SECONDARY_DIRECTION_OF_FIRE_DASH as h, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as ht, CONTROL_MEASURE_METADATA as i, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as it, DEFAULT_RELEASE_LINE_OPTIONS as j, line23DrawRule as jt, DEFAULT_HANDOVER_LINE_OPTIONS as k, line26DrawRule as kt, listControlMeasureMetadata as l, DEFAULT_BATTLE_POSITION_OPTIONS as lt, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as m, DEFAULT_ASSEMBLY_AREA_OPTIONS as mt, resolveStyleHints as n, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as nt, getControlMeasureMetadata as o, DEFAULT_BOUNDARY_OPTIONS as ot, DEFAULT_STRONG_POINT_OPTIONS as p, DEFAULT_ANTITANK_DITCH_OPTIONS as pt, DEFAULT_GENERIC_TEXT_OPTIONS as q, computeInitialWidthPoint as qt, CONTROL_MEASURE_IDS as r, DEFAULT_GENERIC_C2_LINE_OPTIONS as rt, getControlMeasureMetadataByValue as s, DEFAULT_BLOCK_ARROW_OPTIONS as st, renderControlMeasure as t, DEFAULT_BREACH_OPTIONS as tt, DEFAULT_TURNING_MOVEMENT_OPTIONS as u, DEFAULT_ATTACK_HELICOPTER_OPTIONS as ut, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as v, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as vt, DEFAULT_SCREEN_OPTIONS as w, DEFAULT_AMBUSH_OPTIONS as wt, DEFAULT_MAIN_ATTACK_OPTIONS as x, canonicalTextAmplifierKey as xt, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as y, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as yt, DEFAULT_DISRUPT_OPTIONS as z, blockDrawRule as zt };
+export { DEFAULT_COUNTERATTACK_BY_FIRE_OPTIONS as $, createMidpointPerpendicularDrawRule as $t, DEFAULT_PENETRATE_OPTIONS as A, TEXT_AMPLIFIER_FIELDS as At, DEFAULT_PHASE_LINE_OPTIONS as B, line26DrawRule as Bt, DEFAULT_JOINT_TACTICAL_ACTION_AREA_OPTIONS as C, DEFAULT_ANTITANK_DITCH_OPTIONS as Ct, DEFAULT_SCREEN_OPTIONS as D, DEFAULT_DIRECTION_OF_SUPPORTING_ATTACK_OPTIONS as Dt, DEFAULT_SEIZE_OPTIONS as E, DEFAULT_AREA_DEFENSE_OPTIONS as Et, DEFAULT_HANDOVER_LINE_OPTIONS as F, DEFAULT_AIRBORNE_ATTACK_OPTIONS as Ft, DEFAULT_ENCIRCLEMENT_OPTIONS as G, ambushDrawRule as Gt, DEFAULT_FIX_MISSION_TASK_OPTIONS as H, line23DrawRule as Ht, DEFAULT_FORWARD_EDGE_OF_BATTLE_AREA_OPTIONS as I, rectangleDrawRule as It, DEFAULT_DISRUPT_MISSION_TASK_OPTIONS as J, penetrateDrawRule as Jt, DEFAULT_DISRUPT_OPTIONS as K, attackByFireDrawRule as Kt, DEFAULT_RELEASE_LINE_OPTIONS as L, axis1DrawRule as Lt, DEFAULT_FORTIFIED_AREA_OPTIONS as M, normalizeTextAmplifiers as Mt, DEFAULT_FORTIFIED_LINE_OPTIONS as N, resolveAmplifierPlacement as Nt, DEFAULT_RETIRE_OPTIONS as O, DEFAULT_DIRECTION_OF_MAIN_ATTACK_OPTIONS as Ot, DEFAULT_BATTLE_HANDOVER_LINE_OPTIONS as P, DEFAULT_AMBUSH_OPTIONS as Pt, DEFAULT_TACTICAL_ARROW_OPTIONS as Q, computeDefaultMidpointPerpendicularPoint as Qt, DEFAULT_HOLDING_LINE_OPTIONS as R, supportByFireDrawRule as Rt, DEFAULT_LANDING_ZONE_OPTIONS as S, DEFAULT_ANTITANK_WALL_OPTIONS as St, DEFAULT_WITHDRAW_OPTIONS as T, DEFAULT_AREA_OF_OPERATIONS_OPTIONS as Tt, DEFAULT_FIX_OPTIONS as U, turnDrawRule as Ut, DEFAULT_FLOT_OPTIONS as V, line24DrawRule as Vt, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as W, line1DrawRule as Wt, DEFAULT_DELAY_OPTIONS as X, disruptDrawRule as Xt, DEFAULT_DISENGAGE_OPTIONS as Y, centerRadiusDrawRule as Yt, DEFAULT_COVER_OPTIONS as Z, blockDrawRule as Zt, DEFAULT_PICKUP_ZONE_OPTIONS as _, DEFAULT_BLOCK_ARROW_OPTIONS as _t, DEFINITIONS as a, computeInitialWidthPoint as an, DEFAULT_GENERIC_POLYGON_OPTIONS as at, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as b, DEFAULT_ATTACK_HELICOPTER_OPTIONS as bt, getDefaultOptions as c, unproject as cn, DEFAULT_CLASSIC_ARROW_OPTIONS as ct, DEFAULT_TURN_OPTIONS as d, roundToFixed as dn, DEFAULT_BREACH_OPTIONS as dt, getMidpointPerpendicularSignedDistance as en, DEFAULT_COUNTERATTACK_OPTIONS as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as ft, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as g, DEFAULT_BOUNDARY_OPTIONS as gt, SECONDARY_DIRECTION_OF_FIRE_DASH as h, DEFAULT_LIGHT_LINE_OPTIONS as ht, CONTROL_MEASURE_METADATA as i, calculateMetrics as in, DEFAULT_GENERIC_RECTANGLE_OPTIONS as it, DEFAULT_FRONTAL_ATTACK_OPTIONS as j, canonicalTextAmplifierKey as jt, DEFAULT_REARWARD_PASSAGE_OF_LINES_OPTIONS as k, DEFAULT_DIRECTION_OF_ATTACK_AVIATION_OPTIONS as kt, listControlMeasureMetadata as l, EPSILON as ln, DEFAULT_CANALIZE_OPTIONS as lt, DEFAULT_SECONDARY_DIRECTION_OF_FIRE_OPTIONS as m, DEFAULT_ENGINEER_WORK_LINE_OPTIONS as mt, resolveStyleHints as n, snapToMidpointPerpendicular as nn, DEFAULT_CLEAR_OPTIONS as nt, getControlMeasureMetadata as o, haversineDistance as on, DEFAULT_GENERIC_LINE_OPTIONS as ot, DEFAULT_STRONG_POINT_OPTIONS as p, DEFAULT_GENERIC_C2_LINE_OPTIONS as pt, DEFAULT_GUARD_OPTIONS as q, point12DrawRule as qt, CONTROL_MEASURE_IDS as r, createBaselineFrame as rn, DEFAULT_GENERIC_TEXT_OPTIONS as rt, getControlMeasureMetadataByValue as s, project as sn, DEFAULT_GENERIC_CIRCLE_OPTIONS as st, renderControlMeasure as t, pointOnMidpointPerpendicularAxis as tn, DEFAULT_SUPPORTING_ATTACK_OPTIONS as tt, DEFAULT_TURNING_MOVEMENT_OPTIONS as u, getMetersPerPixel as un, DEFAULT_BYPASS_OPTIONS as ut, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as v, DEFAULT_BLOCK_OPTIONS as vt, DEFAULT_WITHDRAW_UNDER_PRESSURE_OPTIONS as w, DEFAULT_ASSEMBLY_AREA_OPTIONS as wt, DEFAULT_MAIN_ATTACK_OPTIONS as x, DEFAULT_ATTACK_BY_FIRE_OPTIONS as xt, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as y, DEFAULT_BATTLE_POSITION_OPTIONS as yt, DEFAULT_BRIDGEHEAD_LINE_OPTIONS as z, line27DrawRule as zt };