@orbat-mapper/control-measures 0.2.0-alpha.3 → 0.2.0-alpha.5

package/dist/{index-BJYbQlzo.d.mts → index-Ddt-obht.d.mts}

@@ -36,6 +36,12 @@ interface ControlMeasureDrawRule {
    * Defaults to 0 (the entire array is user-clicked spine). See ADR-0008.
    */
   readonly trailingFixedSlots?: number;
+  /**
+   * The user-spine points form a closed ring even though the first point is not
+   * duplicated at the end. TacticalDraw uses this to treat the last→first edge
+   * like every other edge for completion and midpoint insertion.
+   */
+  readonly closedRing?: boolean;
   derive(points: readonly Position[]): Position[];
   transform(event: AnchorTransformEvent): Position[];
 }
@@ -43,7 +49,7 @@ interface ControlMeasureDrawRule {
 //#region src/metadata.d.ts
 type ControlMeasureGeometryType = Geometry["type"];
 type ControlMeasureGeometry = "point" | "line" | "area";
-declare const DRAW_RULE_IDS: readonly ["Area1", "Area7", "Area8", "Area11", "Area12", "Area15", "Area21", "Axis1", "Line1", "Line3", "Line9", "Line10", "Line23", "Line24", "Line29", "Point12"];
+declare const DRAW_RULE_IDS: readonly ["Area1", "Area7", "Area8", "Area11", "Area12", "Area15", "Area21", "Axis1", "Line1", "Line3", "Line9", "Line10", "Line23", "Line24", "Line29", "Point12", "Rectangle"];
 type DrawRuleId = (typeof DRAW_RULE_IDS)[number];
 interface BaseParamDescriptor {
   key: string;
@@ -613,6 +619,47 @@ declare function createBlockArrow(coordinates: Position[], options?: BlockArrowO
   fill: boolean;
 }>;
 //#endregion
+//#region src/generators/cm99-generic-graphics/params.d.ts
+interface SmoothPathOptions {
+  /** Curve the rendered path through the unchanged control points. */
+  smooth?: boolean;
+  /** Number of samples per segment when smoothing is enabled. */
+  smoothResolution?: number;
+}
+interface FilledAreaOptions {
+  /** Fill the polygon interior; false renders only its outline. */
+  filled?: boolean;
+}
+//#endregion
+//#region src/generators/cm99-generic-graphics/line.d.ts
+type GenericLineOptions = SmoothPathOptions;
+declare const DEFAULT_GENERIC_LINE_OPTIONS: Required<GenericLineOptions>;
+declare function createGenericLine(coordinates: Position[], options?: GenericLineOptions): FeatureCollection<LineString>;
+//#endregion
+//#region src/generators/cm99-generic-graphics/polygon.d.ts
+interface GenericPolygonOptions extends SmoothPathOptions, FilledAreaOptions {}
+declare const DEFAULT_GENERIC_POLYGON_OPTIONS: Required<GenericPolygonOptions>;
+declare function createGenericPolygon(coordinates: Position[], options?: GenericPolygonOptions): FeatureCollection<Polygon, {
+  part: string;
+  fill: boolean;
+}>;
+//#endregion
+//#region src/generators/cm99-generic-graphics/rectangle.d.ts
+type GenericRectangleOptions = FilledAreaOptions;
+declare const DEFAULT_GENERIC_RECTANGLE_OPTIONS: Required<GenericRectangleOptions>;
+declare function createGenericRectangle(coordinates: Position[], options?: GenericRectangleOptions): FeatureCollection<Polygon, {
+  part: string;
+  fill: boolean;
+}>;
+//#endregion
+//#region src/generators/cm99-generic-graphics/circle.d.ts
+type GenericCircleOptions = FilledAreaOptions;
+declare const DEFAULT_GENERIC_CIRCLE_OPTIONS: Required<GenericCircleOptions>;
+declare function createGenericCircle(coordinates: Position[], options?: GenericCircleOptions): FeatureCollection<Polygon, {
+  part: string;
+  fill: boolean;
+}>;
+//#endregion
 //#region src/generators/cm15-maneuver-areas/airborneAttack.d.ts
 type AirborneAttackOptions = AttackOptions;
 declare const DEFAULT_AIRBORNE_ATTACK_OPTIONS: Required<AirborneAttackOptions>;
@@ -1265,6 +1312,10 @@ declare const DEFINITIONS: {
   "supporting-attack": ControlMeasureDefinition<"supporting-attack", typeof createSupportingAttack>;
   "classic-arrow": ControlMeasureDefinition<"classic-arrow", typeof createClassicArrow>;
   "block-arrow": ControlMeasureDefinition<"block-arrow", typeof createBlockArrow>;
+  line: ControlMeasureDefinition<"line", typeof createGenericLine>;
+  polygon: ControlMeasureDefinition<"polygon", typeof createGenericPolygon>;
+  rectangle: ControlMeasureDefinition<"rectangle", typeof createGenericRectangle>;
+  circle: ControlMeasureDefinition<"circle", typeof createGenericCircle>;
   "airborne-attack": ControlMeasureDefinition<"airborne-attack", typeof createAirborneAttack>;
   "attack-helicopter": ControlMeasureDefinition<"attack-helicopter", typeof createAttackHelicopter>;
   "support-by-fire": ControlMeasureDefinition<"support-by-fire", typeof createSupportByFire>;
@@ -1599,6 +1650,9 @@ declare const blockDrawRule: ControlMeasureDrawRule;
  */
 declare const disruptDrawRule: ControlMeasureDrawRule;
 //#endregion
+//#region src/draw-rules/area15.d.ts
+declare const centerRadiusDrawRule: ControlMeasureDrawRule;
+//#endregion
 //#region src/draw-rules/point12.d.ts
 /**
  * Point12 anchor draw rule for the obstacle-bypass family.
@@ -1669,6 +1723,9 @@ declare const supportByFireDrawRule: ControlMeasureDrawRule;
 //#region src/draw-rules/axis1.d.ts
 declare const axis1DrawRule: ControlMeasureDrawRule;
 //#endregion
+//#region src/draw-rules/rectangle.d.ts
+declare const rectangleDrawRule: ControlMeasureDrawRule;
+//#endregion
 //#region src/generators/cm14-maneuver-lines/ambush.d.ts
 /**
  * Configuration options for the Ambush tactical symbol.
@@ -1710,4 +1767,4 @@ interface TacticalArrowOptions {
  */
 declare const DEFAULT_TACTICAL_ARROW_OPTIONS: Required<TacticalArrowOptions>;
 //#endregion
-export { listControlMeasureMetadata as $, DEFAULT_ENCIRCLEMENT_OPTIONS as $t, SimpleStyleProps as A, BreachOptions as At, controlMeasureIdFromFeature as B, AttackHelicopterOptions as Bt, BaselineFrameNormal as C, DelayOptions as Ct, EPSILON as D, DEFAULT_CANALIZE_OPTIONS as Dt, createBaselineFrame as E, CanalizeOptions as Et, renderControlMeasure as F, FLOTOptions as Ft, CONTROL_MEASURE_IDS as G, SupportingAttackOptions as Gt, cloneControlMeasure as H, AirborneAttackOptions as Ht, ControlMeasureRender as I, AttackByFireOptions as It, ControlMeasureKind as J, calculateMetrics as Jt, CONTROL_MEASURE_METADATA as K, DEFAULT_MAIN_ATTACK_OPTIONS as Kt, ControlMeasureSnapshot as L, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Lt, toSimpleStyle as M, BlockMissionTaskOptions as Mt, resolveStyleHints as N, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as Nt, getMetersPerPixel as O, BypassOptions as Ot, RenderOptions as P, DEFAULT_FLOT_OPTIONS as Pt, getDefaultOptions as Q, unproject as Qt, FeaturePartProps as R, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as Rt, BaselineFrame as S, DEFAULT_DELAY_OPTIONS as St, BaselineFrameOrigin as T, DEFAULT_CLEAR_OPTIONS as Tt, isKind as U, DEFAULT_AIRBORNE_ATTACK_OPTIONS as Ut, ControlMeasure as V, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Vt, ControlMeasureStyle as W, DEFAULT_SUPPORTING_ATTACK_OPTIONS as Wt, getControlMeasureMetadata as X, Point2D as Xt, OptionsByKind as Y, computeInitialWidthPoint as Yt, getControlMeasureMetadataByValue as Z, project as Zt, computeDefaultMidpointPerpendicularPoint as _, FortifiedLineOptions as _t, axis1DrawRule as a, DEFAULT_STRONG_POINT_OPTIONS as an, ObstacleBypassEasyOptions as at, pointOnMidpointPerpendicularAxis as b, AntitankDitchOptions as bt, line23DrawRule as c, ControlMeasureGeometryType as cn, DEFAULT_FIX_OPTIONS as ct, ambushDrawRule as d, AnchorTransformEvent as dn, DisruptOptions as dt, EncirclementOptions as en, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as et, attackByFireDrawRule as f, ControlMeasureDrawRule as fn, BlockOptions as ft, MidpointPerpendicularDrawRuleOptions as g, DEFAULT_FORTIFIED_LINE_OPTIONS as gt, blockDrawRule as h, FortifiedAreaOptions as ht, DEFAULT_AMBUSH_OPTIONS as i, PrincipalDirectionOfFireOptions as in, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as it, SimpleStyleRender as j, DEFAULT_BREACH_OPTIONS as jt, roundToFixed as k, DEFAULT_BYPASS_OPTIONS as kt, turnDrawRule as l, ControlMeasureMetadata as ln, FixOptions as lt, disruptDrawRule as m, DEFAULT_FORTIFIED_AREA_OPTIONS as mt, TacticalArrowOptions as n, FinalProtectiveFireOptions as nn, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as nt, supportByFireDrawRule as o, StrongPointOptions as on, DEFAULT_TURN_OPTIONS as ot, point12DrawRule as p, DEFAULT_BLOCK_OPTIONS as pt, ControlMeasureId as q, MainAttackOptions as qt, AmbushOptions as r, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as rn, ObstacleBypassDifficultOptions as rt, line24DrawRule as s, ControlMeasureGeometry as sn, TurnOptions as st, DEFAULT_TACTICAL_ARROW_OPTIONS as t, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as tn, ObstacleBypassImpossibleOptions as tt, line1DrawRule as u, ParamDescriptor as un, DEFAULT_DISRUPT_OPTIONS as ut, createMidpointPerpendicularDrawRule as v, AntitankWallOptions as vt, BaselineFrameOptions as w, ClearOptions as wt, snapToMidpointPerpendicular as x, DEFAULT_ANTITANK_DITCH_OPTIONS as xt, getMidpointPerpendicularSignedDistance as y, DEFAULT_ANTITANK_WALL_OPTIONS as yt, StyleHints as z, SupportByFireOptions as zt };
+export { getControlMeasureMetadataByValue as $, GenericLineOptions as $t, getMetersPerPixel as A, BypassOptions as At, FeaturePartProps as B, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as Bt, snapToMidpointPerpendicular as C, DEFAULT_ANTITANK_DITCH_OPTIONS as Ct, BaselineFrameOrigin as D, DEFAULT_CLEAR_OPTIONS as Dt, BaselineFrameOptions as E, ClearOptions as Et, resolveStyleHints as F, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as Ft, isKind as G, DEFAULT_AIRBORNE_ATTACK_OPTIONS as Gt, controlMeasureIdFromFeature as H, AttackHelicopterOptions as Ht, RenderOptions as I, DEFAULT_FLOT_OPTIONS as It, CONTROL_MEASURE_METADATA as J, DEFAULT_GENERIC_RECTANGLE_OPTIONS as Jt, ControlMeasureStyle as K, DEFAULT_GENERIC_CIRCLE_OPTIONS as Kt, renderControlMeasure as L, FLOTOptions as Lt, SimpleStyleProps as M, BreachOptions as Mt, SimpleStyleRender as N, DEFAULT_BREACH_OPTIONS as Nt, createBaselineFrame as O, CanalizeOptions as Ot, toSimpleStyle as P, BlockMissionTaskOptions as Pt, getControlMeasureMetadata as Q, DEFAULT_GENERIC_LINE_OPTIONS as Qt, ControlMeasureRender as R, AttackByFireOptions as Rt, pointOnMidpointPerpendicularAxis as S, ControlMeasureDrawRule as Sn, AntitankDitchOptions as St, BaselineFrameNormal as T, DelayOptions as Tt, ControlMeasure as U, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Ut, StyleHints as V, SupportByFireOptions as Vt, cloneControlMeasure as W, AirborneAttackOptions as Wt, ControlMeasureKind as X, DEFAULT_GENERIC_POLYGON_OPTIONS as Xt, ControlMeasureId as Y, GenericRectangleOptions as Yt, OptionsByKind as Z, GenericPolygonOptions as Zt, blockDrawRule as _, ControlMeasureGeometry as _n, FortifiedAreaOptions as _t, rectangleDrawRule as a, computeInitialWidthPoint as an, ObstacleBypassDifficultOptions as at, createMidpointPerpendicularDrawRule as b, ParamDescriptor as bn, AntitankWallOptions as bt, line24DrawRule as c, unproject as cn, DEFAULT_TURN_OPTIONS as ct, line1DrawRule as d, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as dn, FixOptions as dt, DEFAULT_SUPPORTING_ATTACK_OPTIONS as en, getDefaultOptions as et, ambushDrawRule as f, FinalProtectiveFireOptions as fn, DEFAULT_DISRUPT_OPTIONS as ft, disruptDrawRule as g, StrongPointOptions as gn, DEFAULT_FORTIFIED_AREA_OPTIONS as gt, centerRadiusDrawRule as h, DEFAULT_STRONG_POINT_OPTIONS as hn, DEFAULT_BLOCK_OPTIONS as ht, DEFAULT_AMBUSH_OPTIONS as i, calculateMetrics as in, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as it, roundToFixed as j, DEFAULT_BYPASS_OPTIONS as jt, EPSILON as k, DEFAULT_CANALIZE_OPTIONS as kt, line23DrawRule as l, DEFAULT_ENCIRCLEMENT_OPTIONS as ln, TurnOptions as lt, point12DrawRule as m, PrincipalDirectionOfFireOptions as mn, BlockOptions as mt, TacticalArrowOptions as n, DEFAULT_MAIN_ATTACK_OPTIONS as nn, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as nt, axis1DrawRule as o, Point2D as on, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as ot, attackByFireDrawRule as p, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as pn, DisruptOptions as pt, CONTROL_MEASURE_IDS as q, GenericCircleOptions as qt, AmbushOptions as r, MainAttackOptions as rn, ObstacleBypassImpossibleOptions as rt, supportByFireDrawRule as s, project as sn, ObstacleBypassEasyOptions as st, DEFAULT_TACTICAL_ARROW_OPTIONS as t, SupportingAttackOptions as tn, listControlMeasureMetadata as tt, turnDrawRule as u, EncirclementOptions as un, DEFAULT_FIX_OPTIONS as ut, MidpointPerpendicularDrawRuleOptions as v, ControlMeasureGeometryType as vn, DEFAULT_FORTIFIED_LINE_OPTIONS as vt, BaselineFrame as w, DEFAULT_DELAY_OPTIONS as wt, getMidpointPerpendicularSignedDistance as x, AnchorTransformEvent as xn, DEFAULT_ANTITANK_WALL_OPTIONS as xt, computeDefaultMidpointPerpendicularPoint as y, ControlMeasureMetadata as yn, FortifiedLineOptions as yt, ControlMeasureSnapshot as z, DEFAULT_ATTACK_BY_FIRE_OPTIONS as zt };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as listControlMeasureMetadata, $t as DEFAULT_ENCIRCLEMENT_OPTIONS, A as SimpleStyleProps, At as BreachOptions, B as controlMeasureIdFromFeature, Bt as AttackHelicopterOptions, C as BaselineFrameNormal, Ct as DelayOptions, D as EPSILON, Dt as DEFAULT_CANALIZE_OPTIONS, E as createBaselineFrame, Et as CanalizeOptions, F as renderControlMeasure, Ft as FLOTOptions, G as CONTROL_MEASURE_IDS, Gt as SupportingAttackOptions, H as cloneControlMeasure, Ht as AirborneAttackOptions, I as ControlMeasureRender, It as AttackByFireOptions, J as ControlMeasureKind, Jt as calculateMetrics, K as CONTROL_MEASURE_METADATA, Kt as DEFAULT_MAIN_ATTACK_OPTIONS, L as ControlMeasureSnapshot, Lt as DEFAULT_ATTACK_BY_FIRE_OPTIONS, M as toSimpleStyle, Mt as BlockMissionTaskOptions, N as resolveStyleHints, Nt as DEFAULT_BLOCK_MISSION_TASK_OPTIONS, O as getMetersPerPixel, Ot as BypassOptions, P as RenderOptions, Pt as DEFAULT_FLOT_OPTIONS, Q as getDefaultOptions, Qt as unproject, R as FeaturePartProps, Rt as DEFAULT_SUPPORT_BY_FIRE_OPTIONS, S as BaselineFrame, St as DEFAULT_DELAY_OPTIONS, T as BaselineFrameOrigin, Tt as DEFAULT_CLEAR_OPTIONS, U as isKind, Ut as DEFAULT_AIRBORNE_ATTACK_OPTIONS, V as ControlMeasure, Vt as DEFAULT_ATTACK_HELICOPTER_OPTIONS, W as ControlMeasureStyle, Wt as DEFAULT_SUPPORTING_ATTACK_OPTIONS, X as getControlMeasureMetadata, Xt as Point2D, Y as OptionsByKind, Yt as computeInitialWidthPoint, Z as getControlMeasureMetadataByValue, Zt as project, _ as computeDefaultMidpointPerpendicularPoint, _t as FortifiedLineOptions, a as axis1DrawRule, an as DEFAULT_STRONG_POINT_OPTIONS, at as ObstacleBypassEasyOptions, b as pointOnMidpointPerpendicularAxis, bt as AntitankDitchOptions, c as line23DrawRule, cn as ControlMeasureGeometryType, ct as DEFAULT_FIX_OPTIONS, d as ambushDrawRule, dn as AnchorTransformEvent, dt as DisruptOptions, en as EncirclementOptions, et as DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, f as attackByFireDrawRule, fn as ControlMeasureDrawRule, ft as BlockOptions, g as MidpointPerpendicularDrawRuleOptions, gt as DEFAULT_FORTIFIED_LINE_OPTIONS, h as blockDrawRule, ht as FortifiedAreaOptions, i as DEFAULT_AMBUSH_OPTIONS, in as PrincipalDirectionOfFireOptions, it as DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, j as SimpleStyleRender, jt as DEFAULT_BREACH_OPTIONS, k as roundToFixed, kt as DEFAULT_BYPASS_OPTIONS, l as turnDrawRule, ln as ControlMeasureMetadata, lt as FixOptions, m as disruptDrawRule, mt as DEFAULT_FORTIFIED_AREA_OPTIONS, n as TacticalArrowOptions, nn as FinalProtectiveFireOptions, nt as DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, o as supportByFireDrawRule, on as StrongPointOptions, ot as DEFAULT_TURN_OPTIONS, p as point12DrawRule, pt as DEFAULT_BLOCK_OPTIONS, q as ControlMeasureId, qt as MainAttackOptions, r as AmbushOptions, rn as DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, rt as ObstacleBypassDifficultOptions, s as line24DrawRule, sn as ControlMeasureGeometry, st as TurnOptions, t as DEFAULT_TACTICAL_ARROW_OPTIONS, tn as DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, tt as ObstacleBypassImpossibleOptions, u as line1DrawRule, un as ParamDescriptor, ut as DEFAULT_DISRUPT_OPTIONS, v as createMidpointPerpendicularDrawRule, vt as AntitankWallOptions, w as BaselineFrameOptions, wt as ClearOptions, x as snapToMidpointPerpendicular, xt as DEFAULT_ANTITANK_DITCH_OPTIONS, y as getMidpointPerpendicularSignedDistance, yt as DEFAULT_ANTITANK_WALL_OPTIONS, z as StyleHints, zt as SupportByFireOptions } from "./index-BJYbQlzo.mjs";
-export { type AirborneAttackOptions, type AmbushOptions, type AnchorTransformEvent, type AntitankDitchOptions, type AntitankWallOptions, type AttackByFireOptions, type AttackHelicopterOptions, type BaselineFrame, type BaselineFrameNormal, type BaselineFrameOptions, type BaselineFrameOrigin, type BlockMissionTaskOptions, type BlockOptions, type BreachOptions, type BypassOptions, CONTROL_MEASURE_IDS, CONTROL_MEASURE_METADATA, type CanalizeOptions, type ClearOptions, type ControlMeasure, type ControlMeasureDrawRule, type ControlMeasureGeometry, type ControlMeasureGeometryType, type ControlMeasureId, type ControlMeasureKind, type ControlMeasureMetadata, type ControlMeasureRender, type ControlMeasureSnapshot, type ControlMeasureStyle, DEFAULT_AIRBORNE_ATTACK_OPTIONS, DEFAULT_AMBUSH_OPTIONS, DEFAULT_ANTITANK_DITCH_OPTIONS, DEFAULT_ANTITANK_WALL_OPTIONS, DEFAULT_ATTACK_BY_FIRE_OPTIONS, DEFAULT_ATTACK_HELICOPTER_OPTIONS, DEFAULT_BLOCK_MISSION_TASK_OPTIONS, DEFAULT_BLOCK_OPTIONS, DEFAULT_BREACH_OPTIONS, DEFAULT_BYPASS_OPTIONS, DEFAULT_CANALIZE_OPTIONS, DEFAULT_CLEAR_OPTIONS, DEFAULT_DELAY_OPTIONS, DEFAULT_DISRUPT_OPTIONS, DEFAULT_ENCIRCLEMENT_OPTIONS, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, DEFAULT_FIX_OPTIONS, DEFAULT_FLOT_OPTIONS, DEFAULT_FORTIFIED_AREA_OPTIONS, DEFAULT_FORTIFIED_LINE_OPTIONS, DEFAULT_MAIN_ATTACK_OPTIONS, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, DEFAULT_STRONG_POINT_OPTIONS, DEFAULT_SUPPORTING_ATTACK_OPTIONS, DEFAULT_SUPPORT_BY_FIRE_OPTIONS, DEFAULT_TACTICAL_ARROW_OPTIONS, DEFAULT_TURN_OPTIONS, type DelayOptions, type DisruptOptions, EPSILON, type EncirclementOptions, type FLOTOptions, type FeaturePartProps, type FinalProtectiveFireOptions, type FixOptions, type FortifiedAreaOptions, type FortifiedLineOptions, type MainAttackOptions, type MidpointPerpendicularDrawRuleOptions, type ObstacleBypassDifficultOptions, type ObstacleBypassEasyOptions, type ObstacleBypassImpossibleOptions, type OptionsByKind, type ParamDescriptor, type Point2D, type PrincipalDirectionOfFireOptions, type RenderOptions, type SimpleStyleProps, type SimpleStyleRender, type StrongPointOptions, type StyleHints, type SupportByFireOptions, type SupportingAttackOptions, type TacticalArrowOptions, type TurnOptions, ambushDrawRule, attackByFireDrawRule, axis1DrawRule, blockDrawRule, calculateMetrics, cloneControlMeasure, computeDefaultMidpointPerpendicularPoint, computeInitialWidthPoint, controlMeasureIdFromFeature, createBaselineFrame, createMidpointPerpendicularDrawRule, disruptDrawRule, getControlMeasureMetadata, getControlMeasureMetadataByValue, getDefaultOptions, getMetersPerPixel, getMidpointPerpendicularSignedDistance, isKind, line1DrawRule, line23DrawRule, line24DrawRule, listControlMeasureMetadata, point12DrawRule, pointOnMidpointPerpendicularAxis, project, renderControlMeasure, resolveStyleHints, roundToFixed, snapToMidpointPerpendicular, supportByFireDrawRule, toSimpleStyle, turnDrawRule, unproject };
+import { $ as getControlMeasureMetadataByValue, $t as GenericLineOptions, A as getMetersPerPixel, At as BypassOptions, B as FeaturePartProps, Bt as DEFAULT_SUPPORT_BY_FIRE_OPTIONS, C as snapToMidpointPerpendicular, Ct as DEFAULT_ANTITANK_DITCH_OPTIONS, D as BaselineFrameOrigin, Dt as DEFAULT_CLEAR_OPTIONS, E as BaselineFrameOptions, Et as ClearOptions, F as resolveStyleHints, Ft as DEFAULT_BLOCK_MISSION_TASK_OPTIONS, G as isKind, Gt as DEFAULT_AIRBORNE_ATTACK_OPTIONS, H as controlMeasureIdFromFeature, Ht as AttackHelicopterOptions, I as RenderOptions, It as DEFAULT_FLOT_OPTIONS, J as CONTROL_MEASURE_METADATA, Jt as DEFAULT_GENERIC_RECTANGLE_OPTIONS, K as ControlMeasureStyle, Kt as DEFAULT_GENERIC_CIRCLE_OPTIONS, L as renderControlMeasure, Lt as FLOTOptions, M as SimpleStyleProps, Mt as BreachOptions, N as SimpleStyleRender, Nt as DEFAULT_BREACH_OPTIONS, O as createBaselineFrame, Ot as CanalizeOptions, P as toSimpleStyle, Pt as BlockMissionTaskOptions, Q as getControlMeasureMetadata, Qt as DEFAULT_GENERIC_LINE_OPTIONS, R as ControlMeasureRender, Rt as AttackByFireOptions, S as pointOnMidpointPerpendicularAxis, Sn as ControlMeasureDrawRule, St as AntitankDitchOptions, T as BaselineFrameNormal, Tt as DelayOptions, U as ControlMeasure, Ut as DEFAULT_ATTACK_HELICOPTER_OPTIONS, V as StyleHints, Vt as SupportByFireOptions, W as cloneControlMeasure, Wt as AirborneAttackOptions, X as ControlMeasureKind, Xt as DEFAULT_GENERIC_POLYGON_OPTIONS, Y as ControlMeasureId, Yt as GenericRectangleOptions, Z as OptionsByKind, Zt as GenericPolygonOptions, _ as blockDrawRule, _n as ControlMeasureGeometry, _t as FortifiedAreaOptions, a as rectangleDrawRule, an as computeInitialWidthPoint, at as ObstacleBypassDifficultOptions, b as createMidpointPerpendicularDrawRule, bn as ParamDescriptor, bt as AntitankWallOptions, c as line24DrawRule, cn as unproject, ct as DEFAULT_TURN_OPTIONS, d as line1DrawRule, dn as DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, dt as FixOptions, en as DEFAULT_SUPPORTING_ATTACK_OPTIONS, et as getDefaultOptions, f as ambushDrawRule, fn as FinalProtectiveFireOptions, ft as DEFAULT_DISRUPT_OPTIONS, g as disruptDrawRule, gn as StrongPointOptions, gt as DEFAULT_FORTIFIED_AREA_OPTIONS, h as centerRadiusDrawRule, hn as DEFAULT_STRONG_POINT_OPTIONS, ht as DEFAULT_BLOCK_OPTIONS, i as DEFAULT_AMBUSH_OPTIONS, in as calculateMetrics, it as DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, j as roundToFixed, jt as DEFAULT_BYPASS_OPTIONS, k as EPSILON, kt as DEFAULT_CANALIZE_OPTIONS, l as line23DrawRule, ln as DEFAULT_ENCIRCLEMENT_OPTIONS, lt as TurnOptions, m as point12DrawRule, mn as PrincipalDirectionOfFireOptions, mt as BlockOptions, n as TacticalArrowOptions, nn as DEFAULT_MAIN_ATTACK_OPTIONS, nt as DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, o as axis1DrawRule, on as Point2D, ot as DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, p as attackByFireDrawRule, pn as DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, pt as DisruptOptions, q as CONTROL_MEASURE_IDS, qt as GenericCircleOptions, r as AmbushOptions, rn as MainAttackOptions, rt as ObstacleBypassImpossibleOptions, s as supportByFireDrawRule, sn as project, st as ObstacleBypassEasyOptions, t as DEFAULT_TACTICAL_ARROW_OPTIONS, tn as SupportingAttackOptions, tt as listControlMeasureMetadata, u as turnDrawRule, un as EncirclementOptions, ut as DEFAULT_FIX_OPTIONS, v as MidpointPerpendicularDrawRuleOptions, vn as ControlMeasureGeometryType, vt as DEFAULT_FORTIFIED_LINE_OPTIONS, w as BaselineFrame, wt as DEFAULT_DELAY_OPTIONS, x as getMidpointPerpendicularSignedDistance, xn as AnchorTransformEvent, xt as DEFAULT_ANTITANK_WALL_OPTIONS, y as computeDefaultMidpointPerpendicularPoint, yn as ControlMeasureMetadata, yt as FortifiedLineOptions, z as ControlMeasureSnapshot, zt as DEFAULT_ATTACK_BY_FIRE_OPTIONS } from "./index-Ddt-obht.mjs";
+export { type AirborneAttackOptions, type AmbushOptions, type AnchorTransformEvent, type AntitankDitchOptions, type AntitankWallOptions, type AttackByFireOptions, type AttackHelicopterOptions, type BaselineFrame, type BaselineFrameNormal, type BaselineFrameOptions, type BaselineFrameOrigin, type BlockMissionTaskOptions, type BlockOptions, type BreachOptions, type BypassOptions, CONTROL_MEASURE_IDS, CONTROL_MEASURE_METADATA, type CanalizeOptions, type ClearOptions, type ControlMeasure, type ControlMeasureDrawRule, type ControlMeasureGeometry, type ControlMeasureGeometryType, type ControlMeasureId, type ControlMeasureKind, type ControlMeasureMetadata, type ControlMeasureRender, type ControlMeasureSnapshot, type ControlMeasureStyle, DEFAULT_AIRBORNE_ATTACK_OPTIONS, DEFAULT_AMBUSH_OPTIONS, DEFAULT_ANTITANK_DITCH_OPTIONS, DEFAULT_ANTITANK_WALL_OPTIONS, DEFAULT_ATTACK_BY_FIRE_OPTIONS, DEFAULT_ATTACK_HELICOPTER_OPTIONS, DEFAULT_BLOCK_MISSION_TASK_OPTIONS, DEFAULT_BLOCK_OPTIONS, DEFAULT_BREACH_OPTIONS, DEFAULT_BYPASS_OPTIONS, DEFAULT_CANALIZE_OPTIONS, DEFAULT_CLEAR_OPTIONS, DEFAULT_DELAY_OPTIONS, DEFAULT_DISRUPT_OPTIONS, DEFAULT_ENCIRCLEMENT_OPTIONS, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, DEFAULT_FIX_OPTIONS, DEFAULT_FLOT_OPTIONS, DEFAULT_FORTIFIED_AREA_OPTIONS, DEFAULT_FORTIFIED_LINE_OPTIONS, DEFAULT_GENERIC_CIRCLE_OPTIONS, DEFAULT_GENERIC_LINE_OPTIONS, DEFAULT_GENERIC_POLYGON_OPTIONS, DEFAULT_GENERIC_RECTANGLE_OPTIONS, DEFAULT_MAIN_ATTACK_OPTIONS, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, DEFAULT_STRONG_POINT_OPTIONS, DEFAULT_SUPPORTING_ATTACK_OPTIONS, DEFAULT_SUPPORT_BY_FIRE_OPTIONS, DEFAULT_TACTICAL_ARROW_OPTIONS, DEFAULT_TURN_OPTIONS, type DelayOptions, type DisruptOptions, EPSILON, type EncirclementOptions, type FLOTOptions, type FeaturePartProps, type FinalProtectiveFireOptions, type FixOptions, type FortifiedAreaOptions, type FortifiedLineOptions, type GenericCircleOptions, type GenericLineOptions, type GenericPolygonOptions, type GenericRectangleOptions, type MainAttackOptions, type MidpointPerpendicularDrawRuleOptions, type ObstacleBypassDifficultOptions, type ObstacleBypassEasyOptions, type ObstacleBypassImpossibleOptions, type OptionsByKind, type ParamDescriptor, type Point2D, type PrincipalDirectionOfFireOptions, type RenderOptions, type SimpleStyleProps, type SimpleStyleRender, type StrongPointOptions, type StyleHints, type SupportByFireOptions, type SupportingAttackOptions, type TacticalArrowOptions, type TurnOptions, ambushDrawRule, attackByFireDrawRule, axis1DrawRule, blockDrawRule, calculateMetrics, centerRadiusDrawRule, cloneControlMeasure, computeDefaultMidpointPerpendicularPoint, computeInitialWidthPoint, controlMeasureIdFromFeature, createBaselineFrame, createMidpointPerpendicularDrawRule, disruptDrawRule, getControlMeasureMetadata, getControlMeasureMetadataByValue, getDefaultOptions, getMetersPerPixel, getMidpointPerpendicularSignedDistance, isKind, line1DrawRule, line23DrawRule, line24DrawRule, listControlMeasureMetadata, point12DrawRule, pointOnMidpointPerpendicularAxis, project, rectangleDrawRule, renderControlMeasure, resolveStyleHints, roundToFixed, snapToMidpointPerpendicular, supportByFireDrawRule, toSimpleStyle, turnDrawRule, unproject };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { $ as getMidpointPerpendicularSignedDistance, A as DEFAULT_BYPASS_OPTIONS, B as axis1DrawRule, C as DEFAULT_FIX_OPTIONS, D as DEFAULT_DELAY_OPTIONS, E as DEFAULT_DISRUPT_OPTIONS, F as DEFAULT_ATTACK_BY_FIRE_OPTIONS, G as line1DrawRule, H as line24DrawRule, I as DEFAULT_ANTITANK_WALL_OPTIONS, J as point12DrawRule, K as ambushDrawRule, L as DEFAULT_ANTITANK_DITCH_OPTIONS, M as DEFAULT_BLOCK_MISSION_TASK_OPTIONS, N as DEFAULT_BLOCK_OPTIONS, O as DEFAULT_CLEAR_OPTIONS, P as DEFAULT_ATTACK_HELICOPTER_OPTIONS, Q as createMidpointPerpendicularDrawRule, R as DEFAULT_AMBUSH_OPTIONS, S as DEFAULT_FLOT_OPTIONS, T as DEFAULT_ENCIRCLEMENT_OPTIONS, U as line23DrawRule, V as supportByFireDrawRule, W as turnDrawRule, X as blockDrawRule, Y as disruptDrawRule, Z as computeDefaultMidpointPerpendicularPoint, _ as DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, at as project, b as DEFAULT_FORTIFIED_AREA_OPTIONS, c as getDefaultOptions, ct as getMetersPerPixel, d as DEFAULT_SUPPORTING_ATTACK_OPTIONS, et as pointOnMidpointPerpendicularAxis, f as DEFAULT_SUPPORT_BY_FIRE_OPTIONS, g as DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, h as DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, i as CONTROL_MEASURE_METADATA, it as computeInitialWidthPoint, j as DEFAULT_BREACH_OPTIONS, k as DEFAULT_CANALIZE_OPTIONS, l as listControlMeasureMetadata, lt as roundToFixed, m as DEFAULT_TACTICAL_ARROW_OPTIONS, n as resolveStyleHints, nt as createBaselineFrame, o as getControlMeasureMetadata, ot as unproject, p as DEFAULT_STRONG_POINT_OPTIONS, q as attackByFireDrawRule, r as CONTROL_MEASURE_IDS, rt as calculateMetrics, s as getControlMeasureMetadataByValue, st as EPSILON, t as renderControlMeasure, tt as snapToMidpointPerpendicular, u as DEFAULT_TURN_OPTIONS, v as DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, w as DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, x as DEFAULT_FORTIFIED_LINE_OPTIONS, y as DEFAULT_MAIN_ATTACK_OPTIONS, z as DEFAULT_AIRBORNE_ATTACK_OPTIONS } from "./renderControlMeasure-DkXDSrLz.mjs";
+import { $ as point12DrawRule, A as DEFAULT_GENERIC_POLYGON_OPTIONS, B as DEFAULT_ANTITANK_WALL_OPTIONS, C as DEFAULT_FIX_OPTIONS, D as DEFAULT_DELAY_OPTIONS, E as DEFAULT_DISRUPT_OPTIONS, F as DEFAULT_BREACH_OPTIONS, G as axis1DrawRule, H as DEFAULT_AMBUSH_OPTIONS, I as DEFAULT_BLOCK_MISSION_TASK_OPTIONS, J as line23DrawRule, K as supportByFireDrawRule, L as DEFAULT_BLOCK_OPTIONS, M as DEFAULT_GENERIC_CIRCLE_OPTIONS, N as DEFAULT_CANALIZE_OPTIONS, O as DEFAULT_CLEAR_OPTIONS, P as DEFAULT_BYPASS_OPTIONS, Q as attackByFireDrawRule, R as DEFAULT_ATTACK_HELICOPTER_OPTIONS, S as DEFAULT_FLOT_OPTIONS, T as DEFAULT_ENCIRCLEMENT_OPTIONS, U as DEFAULT_AIRBORNE_ATTACK_OPTIONS, V as DEFAULT_ANTITANK_DITCH_OPTIONS, W as rectangleDrawRule, X as line1DrawRule, Y as turnDrawRule, Z as ambushDrawRule, _ as DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, at as getMidpointPerpendicularSignedDistance, b as DEFAULT_FORTIFIED_AREA_OPTIONS, c as getDefaultOptions, ct as createBaselineFrame, d as DEFAULT_SUPPORTING_ATTACK_OPTIONS, dt as project, et as centerRadiusDrawRule, f as DEFAULT_SUPPORT_BY_FIRE_OPTIONS, ft as unproject, g as DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, h as DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, ht as roundToFixed, i as CONTROL_MEASURE_METADATA, it as createMidpointPerpendicularDrawRule, j as DEFAULT_GENERIC_LINE_OPTIONS, k as DEFAULT_GENERIC_RECTANGLE_OPTIONS, l as listControlMeasureMetadata, lt as calculateMetrics, m as DEFAULT_TACTICAL_ARROW_OPTIONS, mt as getMetersPerPixel, n as resolveStyleHints, nt as blockDrawRule, o as getControlMeasureMetadata, ot as pointOnMidpointPerpendicularAxis, p as DEFAULT_STRONG_POINT_OPTIONS, pt as EPSILON, q as line24DrawRule, r as CONTROL_MEASURE_IDS, rt as computeDefaultMidpointPerpendicularPoint, s as getControlMeasureMetadataByValue, st as snapToMidpointPerpendicular, t as renderControlMeasure, tt as disruptDrawRule, u as DEFAULT_TURN_OPTIONS, ut as computeInitialWidthPoint, v as DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, w as DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, x as DEFAULT_FORTIFIED_LINE_OPTIONS, y as DEFAULT_MAIN_ATTACK_OPTIONS, z as DEFAULT_ATTACK_BY_FIRE_OPTIONS } from "./renderControlMeasure-CDCoQlZ-.mjs";
 //#region src/instance.ts
 function isKind(cm, kind) {
 	return cm.kind === kind;
@@ -99,4 +99,4 @@ function toHexChannel(value) {
 	return Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, "0");
 }
 //#endregion
-export { CONTROL_MEASURE_IDS, CONTROL_MEASURE_METADATA, DEFAULT_AIRBORNE_ATTACK_OPTIONS, DEFAULT_AMBUSH_OPTIONS, DEFAULT_ANTITANK_DITCH_OPTIONS, DEFAULT_ANTITANK_WALL_OPTIONS, DEFAULT_ATTACK_BY_FIRE_OPTIONS, DEFAULT_ATTACK_HELICOPTER_OPTIONS, DEFAULT_BLOCK_MISSION_TASK_OPTIONS, DEFAULT_BLOCK_OPTIONS, DEFAULT_BREACH_OPTIONS, DEFAULT_BYPASS_OPTIONS, DEFAULT_CANALIZE_OPTIONS, DEFAULT_CLEAR_OPTIONS, DEFAULT_DELAY_OPTIONS, DEFAULT_DISRUPT_OPTIONS, DEFAULT_ENCIRCLEMENT_OPTIONS, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, DEFAULT_FIX_OPTIONS, DEFAULT_FLOT_OPTIONS, DEFAULT_FORTIFIED_AREA_OPTIONS, DEFAULT_FORTIFIED_LINE_OPTIONS, DEFAULT_MAIN_ATTACK_OPTIONS, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, DEFAULT_STRONG_POINT_OPTIONS, DEFAULT_SUPPORTING_ATTACK_OPTIONS, DEFAULT_SUPPORT_BY_FIRE_OPTIONS, DEFAULT_TACTICAL_ARROW_OPTIONS, DEFAULT_TURN_OPTIONS, EPSILON, ambushDrawRule, attackByFireDrawRule, axis1DrawRule, blockDrawRule, calculateMetrics, cloneControlMeasure, computeDefaultMidpointPerpendicularPoint, computeInitialWidthPoint, controlMeasureIdFromFeature, createBaselineFrame, createMidpointPerpendicularDrawRule, disruptDrawRule, getControlMeasureMetadata, getControlMeasureMetadataByValue, getDefaultOptions, getMetersPerPixel, getMidpointPerpendicularSignedDistance, isKind, line1DrawRule, line23DrawRule, line24DrawRule, listControlMeasureMetadata, point12DrawRule, pointOnMidpointPerpendicularAxis, project, renderControlMeasure, resolveStyleHints, roundToFixed, snapToMidpointPerpendicular, supportByFireDrawRule, toSimpleStyle, turnDrawRule, unproject };
+export { CONTROL_MEASURE_IDS, CONTROL_MEASURE_METADATA, DEFAULT_AIRBORNE_ATTACK_OPTIONS, DEFAULT_AMBUSH_OPTIONS, DEFAULT_ANTITANK_DITCH_OPTIONS, DEFAULT_ANTITANK_WALL_OPTIONS, DEFAULT_ATTACK_BY_FIRE_OPTIONS, DEFAULT_ATTACK_HELICOPTER_OPTIONS, DEFAULT_BLOCK_MISSION_TASK_OPTIONS, DEFAULT_BLOCK_OPTIONS, DEFAULT_BREACH_OPTIONS, DEFAULT_BYPASS_OPTIONS, DEFAULT_CANALIZE_OPTIONS, DEFAULT_CLEAR_OPTIONS, DEFAULT_DELAY_OPTIONS, DEFAULT_DISRUPT_OPTIONS, DEFAULT_ENCIRCLEMENT_OPTIONS, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, DEFAULT_FIX_OPTIONS, DEFAULT_FLOT_OPTIONS, DEFAULT_FORTIFIED_AREA_OPTIONS, DEFAULT_FORTIFIED_LINE_OPTIONS, DEFAULT_GENERIC_CIRCLE_OPTIONS, DEFAULT_GENERIC_LINE_OPTIONS, DEFAULT_GENERIC_POLYGON_OPTIONS, DEFAULT_GENERIC_RECTANGLE_OPTIONS, DEFAULT_MAIN_ATTACK_OPTIONS, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, DEFAULT_STRONG_POINT_OPTIONS, DEFAULT_SUPPORTING_ATTACK_OPTIONS, DEFAULT_SUPPORT_BY_FIRE_OPTIONS, DEFAULT_TACTICAL_ARROW_OPTIONS, DEFAULT_TURN_OPTIONS, EPSILON, ambushDrawRule, attackByFireDrawRule, axis1DrawRule, blockDrawRule, calculateMetrics, centerRadiusDrawRule, cloneControlMeasure, computeDefaultMidpointPerpendicularPoint, computeInitialWidthPoint, controlMeasureIdFromFeature, createBaselineFrame, createMidpointPerpendicularDrawRule, disruptDrawRule, getControlMeasureMetadata, getControlMeasureMetadataByValue, getDefaultOptions, getMetersPerPixel, getMidpointPerpendicularSignedDistance, isKind, line1DrawRule, line23DrawRule, line24DrawRule, listControlMeasureMetadata, point12DrawRule, pointOnMidpointPerpendicularAxis, project, rectangleDrawRule, renderControlMeasure, resolveStyleHints, roundToFixed, snapToMidpointPerpendicular, supportByFireDrawRule, toSimpleStyle, turnDrawRule, unproject };

package/dist/preview/index.d.mts

@@ -1,4 +1,4 @@
-import { q as ControlMeasureId } from "../index-BJYbQlzo.mjs";
+import { Y as ControlMeasureId } from "../index-Ddt-obht.mjs";
 import { FeatureCollection, Geometry } from "geojson";
 
 //#region src/preview/index.d.ts

package/dist/preview/index.mjs

@@ -1,4 +1,4 @@
-import { a as DEFINITIONS, t as renderControlMeasure } from "../renderControlMeasure-DkXDSrLz.mjs";
+import { a as DEFINITIONS, t as renderControlMeasure } from "../renderControlMeasure-CDCoQlZ-.mjs";
 //#region src/preview/index.ts
 /**
 * Unitless `previewSample` points (~`[-1, 1]`) are scaled by this degree offset

package/dist/{renderControlMeasure-DkXDSrLz.mjs → renderControlMeasure-CDCoQlZ-.mjs}

@@ -483,6 +483,33 @@ function samePosition(a, b) {
 	return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
 }
 //#endregion
+//#region src/draw-rules/area1.ts
+function derive$8(points) {
+	return clonePositions(points);
+}
+/**
+* Area1 anchor draw rule — a free closed area (Battle Position, Strong Point,
+* Encirclement, Fortified Area).
+*
+* Every anchor is a fully free, user-clicked ring vertex; the rule imposes no
+* constraint and derives no extra slots, so `derive`/`transform` pass the
+* points through unchanged. It is the area analog of the free-line {@link
+* line1DrawRule}: variable-length (no `canonicalPointCount`) with a three-point
+* floor to close a polygon. Behaviorally a no-op over the bare variable-length
+* path — it exists so these drawable areas expose a named rule on
+* `metadata.rule` rather than leaving it `undefined`, matching every other
+* doctrinal draw rule. Ring closure is a generator concern, not a draw-rule one.
+*/
+const area1DrawRule = {
+	id: "area1",
+	minimumUserPoints: 3,
+	closedRing: true,
+	derive: derive$8,
+	transform(event) {
+		return derive$8(event.next);
+	}
+};
+//#endregion
 //#region src/draw-rules/area11.ts
 const blockDrawRule = createMidpointPerpendicularDrawRule({ id: "area11:block" });
 //#endregion
@@ -505,14 +532,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$6(points) {
+function derive$7(points) {
 	return clonePositions(points.slice(0, 2));
 }
-const isolateDrawRule = {
-	id: "area15:isolate",
+const centerRadiusDrawRule = {
+	id: "area15:center-radius",
 	minimumUserPoints: 2,
 	canonicalPointCount: 2,
-	derive: derive$6,
+	derive: derive$7,
 	transform(event) {
 		const { previous, next, activePointIndex } = event;
 		if (activePointIndex === 0 && previous.length >= 2 && next.length >= 2) {
@@ -521,9 +548,11 @@ const isolateDrawRule = {
 			const origin = previous[1];
 			return [clonePosition(next[0]), [origin[0] + dx, origin[1] + dy]];
 		}
-		return derive$6(next);
+		return derive$7(next);
 	}
 };
+/** Backward-compatible doctrinal name for Area15's shared center-radius rule. */
+const isolateDrawRule = centerRadiusDrawRule;
 //#endregion
 //#region src/draw-rules/point12.ts
 /**
@@ -564,20 +593,20 @@ const ambushDrawRule = createMidpointPerpendicularDrawRule({
 });
 //#endregion
 //#region src/draw-rules/line1.ts
-function derive$5(points) {
+function derive$6(points) {
 	return clonePositions(points);
 }
 const line1DrawRule = {
 	id: "line1",
 	minimumUserPoints: 2,
-	derive: derive$5,
+	derive: derive$6,
 	transform(event) {
-		return derive$5(event.next);
+		return derive$6(event.next);
 	}
 };
 //#endregion
 //#region src/draw-rules/line3.ts
-function derive$4(points) {
+function derive$5(points) {
 	return clonePositions(points);
 }
 /**
@@ -592,23 +621,23 @@ const line3DrawRule = {
 	id: "line3",
 	minimumUserPoints: 3,
 	canonicalPointCount: 3,
-	derive: derive$4,
+	derive: derive$5,
 	transform(event) {
-		return derive$4(event.next);
+		return derive$5(event.next);
 	}
 };
 //#endregion
 //#region src/draw-rules/line9.ts
-function derive$3(points) {
+function derive$4(points) {
 	return clonePositions(points);
 }
 const line9DrawRule = {
 	id: "line9",
 	minimumUserPoints: 2,
 	canonicalPointCount: 2,
-	derive: derive$3,
+	derive: derive$4,
 	transform(event) {
-		return derive$3(event.next);
+		return derive$4(event.next);
 	}
 };
 //#endregion
@@ -714,7 +743,7 @@ const line24DrawRule = createMidpointPerpendicularDrawRule({
 });
 //#endregion
 //#region src/draw-rules/area8.ts
-function derive$2(points) {
+function derive$3(points) {
 	if (points.length < 2) return clonePositions(points);
 	if (points.length !== 2) return clonePositions(points.slice(0, 4));
 	const p1 = clonePosition(points[0]);
@@ -738,16 +767,16 @@ const supportByFireDrawRule = {
 	id: "area8:support-by-fire",
 	minimumUserPoints: 2,
 	canonicalPointCount: 4,
-	derive: derive$2,
+	derive: derive$3,
 	transform(event) {
 		const { next } = event;
 		if (next.length === 4) return clonePositions(next);
-		return derive$2(next);
+		return derive$3(next);
 	}
 };
 //#endregion
 //#region src/draw-rules/axis1.ts
-function derive$1(points) {
+function derive$2(points) {
 	if (points.length < 2) return clonePositions(points);
 	if (points.length === 2) {
 		const tip = clonePosition(points[0]);
@@ -785,10 +814,10 @@ const axis1DrawRule = {
 	id: "axis1",
 	minimumUserPoints: 2,
 	trailingFixedSlots: 1,
-	derive: derive$1,
+	derive: derive$2,
 	transform(event) {
 		const { previous, next, activePointIndex } = event;
-		if (next.length < 3 || previous.length < 3) return derive$1(next);
+		if (next.length < 3 || previous.length < 3) return derive$2(next);
 		if (!(activePointIndex === 0 || activePointIndex === 1)) return clonePositions(next);
 		const metrics = calculateMetrics(previous);
 		if (!metrics) return clonePositions(next);
@@ -799,7 +828,7 @@ const axis1DrawRule = {
 };
 //#endregion
 //#region src/draw-rules/area21.ts
-function derive(points) {
+function derive$1(points) {
 	if (points.length === 2) return clonePositions([
 		points[0],
 		points[1],
@@ -812,6 +841,24 @@ const searchAreaDrawRule = {
 	minimumUserPoints: 3,
 	minimumPreviewPoints: 2,
 	canonicalPointCount: 3,
+	derive: derive$1,
+	transform(event) {
+		return derive$1(event.next);
+	}
+};
+//#endregion
+//#region src/draw-rules/rectangle.ts
+/**
+* Axis-aligned rectangle: P1 and P2 are opposite corners. Both are user-clicked
+* and persisted; the generator derives the other two corners.
+*/
+function derive(points) {
+	return clonePositions(points.slice(0, 2));
+}
+const rectangleDrawRule = {
+	id: "rectangle",
+	minimumUserPoints: 2,
+	canonicalPointCount: 2,
 	derive,
 	transform(event) {
 		return derive(event.next);
@@ -2470,6 +2517,7 @@ const BATTLE_POSITION = defineControlMeasure({
 	metadata: BATTLE_POSITION_METADATA,
 	generator: createBattlePosition,
 	defaultOptions: DEFAULT_BATTLE_POSITION_OPTIONS,
+	rule: area1DrawRule,
 	previewSample: {
 		controlPoints: [
 			[-1, -.5],
@@ -2567,7 +2615,7 @@ const BLOCK_ARROW_METADATA = {
 	id: "block-arrow",
 	name: "Block Arrow",
 	description: "Solid filled arrow with a controllable shaft width and selectable head (triangle, barbed, concave, diamond, harpoon, swallowtail, tee). Not a doctrinal symbol.",
-	entity: "Generic Arrows",
+	entity: "Generic Graphics",
 	entityType: "Illustrative Arrow",
 	entitySubtype: "Block Arrow",
 	value: "990001",
@@ -3595,7 +3643,7 @@ const CLASSIC_ARROW_METADATA = {
 	id: "classic-arrow",
 	name: "Classic Arrow",
 	description: "Clean straight arrow with a selectable head (triangle, barbed, concave, diamond, harpoon, swallowtail, chevron, circle, tee, open). Not a doctrinal symbol.",
-	entity: "Generic Arrows",
+	entity: "Generic Graphics",
 	entityType: "Illustrative Arrow",
 	entitySubtype: "Classic Arrow",
 	value: "990002",
@@ -3878,6 +3926,256 @@ function normalizeSmoothResolution(value) {
 	return Math.min(MAX_SMOOTH_RESOLUTION, Math.max(MIN_SMOOTH_RESOLUTION, Math.round(value)));
 }
 //#endregion
+//#region src/generators/cm99-generic-graphics/params.ts
+const SMOOTH_PATH_PARAMS = [{
+	key: "smooth",
+	label: "Smooth",
+	description: "Curve the path through the control points.",
+	type: "boolean"
+}, {
+	key: "smoothResolution",
+	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)
+}];
+const FILLED_AREA_PARAMS = [{
+	key: "filled",
+	label: "Filled",
+	description: "Fill the interior instead of rendering an outline only.",
+	type: "boolean"
+}];
+//#endregion
+//#region src/generators/cm99-generic-graphics/circle.ts
+const CIRCLE_SEGMENTS = 64;
+const DEFAULT_GENERIC_CIRCLE_OPTIONS = { filled: false };
+const GENERIC_CIRCLE_METADATA = {
+	id: "circle",
+	name: "Circle",
+	description: "A non-doctrinal circle defined by a center and radius point.",
+	entity: "Generic Graphics",
+	entityType: "Basic Shape",
+	entitySubtype: "Circle",
+	value: "990104",
+	minCoordinates: 2,
+	maxCoordinates: 2,
+	geometry: "area",
+	geometryTypes: ["Polygon"],
+	drawRule: "Area15",
+	params: FILLED_AREA_PARAMS
+};
+function createGenericCircle(coordinates, options = {}) {
+	const center = project(coordinates[0][0], coordinates[0][1]);
+	const radiusVector = vecSub(project(coordinates[1][0], coordinates[1][1]), center);
+	const radius = vecMag(radiusVector);
+	if (radius < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const startAngle = Math.atan2(radiusVector[1], radiusVector[0]);
+	const ring = [];
+	for (let index = 0; index <= CIRCLE_SEGMENTS; index++) {
+		const angle = startAngle + index / CIRCLE_SEGMENTS * Math.PI * 2;
+		ring.push(unproject(center[0] + Math.cos(angle) * radius, center[1] + Math.sin(angle) * radius));
+	}
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: {
+				part: "circle",
+				fill: options.filled ?? DEFAULT_GENERIC_CIRCLE_OPTIONS.filled
+			},
+			geometry: {
+				type: "Polygon",
+				coordinates: [ring]
+			}
+		}]
+	};
+}
+const GENERIC_CIRCLE = defineControlMeasure({
+	metadata: GENERIC_CIRCLE_METADATA,
+	generator: createGenericCircle,
+	defaultOptions: DEFAULT_GENERIC_CIRCLE_OPTIONS,
+	rule: centerRadiusDrawRule,
+	previewSample: { controlPoints: [[0, 0], [.8, 0]] }
+});
+//#endregion
+//#region src/generators/cm99-generic-graphics/line.ts
+const DEFAULT_GENERIC_LINE_OPTIONS = {
+	smooth: false,
+	smoothResolution: 12
+};
+const GENERIC_LINE_METADATA = {
+	id: "line",
+	name: "Line",
+	description: "A non-doctrinal free polyline through two or more control points.",
+	entity: "Generic Graphics",
+	entityType: "Basic Shape",
+	entitySubtype: "Line",
+	value: "990101",
+	minCoordinates: 2,
+	geometry: "line",
+	geometryTypes: ["LineString"],
+	drawRule: "Line1",
+	params: SMOOTH_PATH_PARAMS
+};
+function createGenericLine(coordinates, options = {}) {
+	const projected = coordinates.map((point) => project(point[0], point[1]));
+	if (!projected.some((point, index) => {
+		const next = projected[index + 1];
+		return next ? Math.hypot(next[0] - point[0], next[1] - point[1]) >= 1e-6 : false;
+	})) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const { smooth, smoothResolution } = {
+		...DEFAULT_GENERIC_LINE_OPTIONS,
+		...options
+	};
+	const resolution = normalizeSmoothResolution$2(smoothResolution, 12);
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: { part: "line" },
+			geometry: {
+				type: "LineString",
+				coordinates: (smooth ? catmullRom(projected, resolution) : projected).map((point) => unproject(point[0], point[1]))
+			}
+		}]
+	};
+}
+const GENERIC_LINE = defineControlMeasure({
+	metadata: GENERIC_LINE_METADATA,
+	generator: createGenericLine,
+	defaultOptions: DEFAULT_GENERIC_LINE_OPTIONS,
+	rule: line1DrawRule,
+	previewSample: { controlPoints: [
+		[-1, -.4],
+		[0, .5],
+		[1, -.2]
+	] }
+});
+//#endregion
+//#region src/generators/cm99-generic-graphics/polygon.ts
+const DEFAULT_GENERIC_POLYGON_OPTIONS = {
+	smooth: false,
+	smoothResolution: 12,
+	filled: false
+};
+const GENERIC_POLYGON_METADATA = {
+	id: "polygon",
+	name: "Polygon",
+	description: "A non-doctrinal free polygon with one outer ring.",
+	entity: "Generic Graphics",
+	entityType: "Basic Shape",
+	entitySubtype: "Polygon",
+	value: "990102",
+	minCoordinates: 3,
+	geometry: "area",
+	geometryTypes: ["Polygon"],
+	drawRule: "Area1",
+	params: [...SMOOTH_PATH_PARAMS, ...FILLED_AREA_PARAMS]
+};
+function createGenericPolygon(coordinates, options = {}) {
+	const projected = coordinates.map((point) => project(point[0], point[1]));
+	const ringPoints = projected.length > 1 && vecMag(vecSub(projected[0], projected.at(-1))) < 1e-6 ? projected.slice(0, -1) : projected;
+	if (ringPoints.length < 3) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const { smooth, smoothResolution, filled } = {
+		...DEFAULT_GENERIC_POLYGON_OPTIONS,
+		...options
+	};
+	const resolution = normalizeSmoothResolution$2(smoothResolution, 12);
+	const ring = smooth ? closedCatmullRom(ringPoints, resolution) : [...ringPoints, ringPoints[0]];
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: {
+				part: "polygon",
+				fill: filled
+			},
+			geometry: {
+				type: "Polygon",
+				coordinates: [ring.map((point) => unproject(point[0], point[1]))]
+			}
+		}]
+	};
+}
+const GENERIC_POLYGON = defineControlMeasure({
+	metadata: GENERIC_POLYGON_METADATA,
+	generator: createGenericPolygon,
+	defaultOptions: DEFAULT_GENERIC_POLYGON_OPTIONS,
+	rule: area1DrawRule,
+	previewSample: { controlPoints: [
+		[-.9, -.7],
+		[.8, -.6],
+		[1, .5],
+		[-.4, .8]
+	] }
+});
+//#endregion
+//#region src/generators/cm99-generic-graphics/rectangle.ts
+const DEFAULT_GENERIC_RECTANGLE_OPTIONS = { filled: false };
+const GENERIC_RECTANGLE_METADATA = {
+	id: "rectangle",
+	name: "Rectangle",
+	description: "A non-doctrinal axis-aligned rectangle defined by two opposite corners.",
+	entity: "Generic Graphics",
+	entityType: "Basic Shape",
+	entitySubtype: "Rectangle",
+	value: "990103",
+	minCoordinates: 2,
+	maxCoordinates: 2,
+	geometry: "area",
+	geometryTypes: ["Polygon"],
+	drawRule: "Rectangle",
+	params: FILLED_AREA_PARAMS
+};
+function createGenericRectangle(coordinates, options = {}) {
+	const p1 = project(coordinates[0][0], coordinates[0][1]);
+	const p2 = project(coordinates[1][0], coordinates[1][1]);
+	if (Math.abs(p2[0] - p1[0]) < 1e-6 || Math.abs(p2[1] - p1[1]) < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const ring = [
+		p1,
+		[p2[0], p1[1]],
+		p2,
+		[p1[0], p2[1]],
+		p1
+	].map((point) => unproject(point[0], point[1]));
+	return {
+		type: "FeatureCollection",
+		features: [{
+			type: "Feature",
+			properties: {
+				part: "rectangle",
+				fill: options.filled ?? DEFAULT_GENERIC_RECTANGLE_OPTIONS.filled
+			},
+			geometry: {
+				type: "Polygon",
+				coordinates: [ring]
+			}
+		}]
+	};
+}
+const GENERIC_RECTANGLE = defineControlMeasure({
+	metadata: GENERIC_RECTANGLE_METADATA,
+	generator: createGenericRectangle,
+	defaultOptions: DEFAULT_GENERIC_RECTANGLE_OPTIONS,
+	rule: rectangleDrawRule,
+	previewSample: { controlPoints: [[-.9, -.55], [.9, .55]] }
+});
+//#endregion
 //#region src/generators/cm34-mission-tasks/clear.ts
 /**
 * Default options for the CLEAR symbol.
@@ -4477,6 +4775,7 @@ const ENCIRCLEMENT = defineControlMeasure({
 	metadata: ENCIRCLEMENT_METADATA,
 	generator: createEncirclement,
 	defaultOptions: DEFAULT_ENCIRCLEMENT_OPTIONS,
+	rule: area1DrawRule,
 	previewSample: {
 		controlPoints: [
 			[-1, -.5],
@@ -5243,6 +5542,7 @@ const FORTIFIED_AREA = defineControlMeasure({
 	metadata: FORTIFIED_AREA_METADATA,
 	generator: createFortifiedArea,
 	defaultOptions: DEFAULT_FORTIFIED_AREA_OPTIONS,
+	rule: area1DrawRule,
 	previewSample: { controlPoints: [
 		[-1, -.5],
 		[1, -.5],
@@ -6271,6 +6571,7 @@ const STRONG_POINT = defineControlMeasure({
 	metadata: STRONG_POINT_METADATA,
 	generator: createStrongPoint,
 	defaultOptions: DEFAULT_STRONG_POINT_OPTIONS,
+	rule: area1DrawRule,
 	previewSample: {
 		controlPoints: [
 			[-1, -.5],
@@ -6624,6 +6925,10 @@ const DEFINITIONS = {
 	"supporting-attack": SUPPORTING_ATTACK,
 	"classic-arrow": CLASSIC_ARROW,
 	"block-arrow": BLOCK_ARROW,
+	line: GENERIC_LINE,
+	polygon: GENERIC_POLYGON,
+	rectangle: GENERIC_RECTANGLE,
+	circle: GENERIC_CIRCLE,
 	"airborne-attack": AIRBORNE_ATTACK,
 	"attack-helicopter": ATTACK_HELICOPTER,
 	"support-by-fire": SUPPORT_BY_FIRE,
@@ -6874,4 +7179,4 @@ function assertNever(value) {
 	throw new Error(`Unhandled control measure kind: ${String(value)}`);
 }
 //#endregion
-export { getMidpointPerpendicularSignedDistance as $, DEFAULT_BYPASS_OPTIONS as A, axis1DrawRule as B, DEFAULT_FIX_OPTIONS as C, DEFAULT_DELAY_OPTIONS as D, DEFAULT_DISRUPT_OPTIONS as E, DEFAULT_ATTACK_BY_FIRE_OPTIONS as F, line1DrawRule as G, line24DrawRule as H, DEFAULT_ANTITANK_WALL_OPTIONS as I, point12DrawRule as J, ambushDrawRule as K, DEFAULT_ANTITANK_DITCH_OPTIONS as L, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as M, DEFAULT_BLOCK_OPTIONS as N, DEFAULT_CLEAR_OPTIONS as O, DEFAULT_ATTACK_HELICOPTER_OPTIONS as P, createMidpointPerpendicularDrawRule as Q, DEFAULT_AMBUSH_OPTIONS as R, DEFAULT_FLOT_OPTIONS as S, DEFAULT_ENCIRCLEMENT_OPTIONS as T, line23DrawRule as U, supportByFireDrawRule as V, turnDrawRule as W, blockDrawRule as X, disruptDrawRule as Y, computeDefaultMidpointPerpendicularPoint as Z, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as _, DEFINITIONS as a, project as at, DEFAULT_FORTIFIED_AREA_OPTIONS as b, getDefaultOptions as c, getMetersPerPixel as ct, DEFAULT_SUPPORTING_ATTACK_OPTIONS as d, pointOnMidpointPerpendicularAxis as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as g, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as h, CONTROL_MEASURE_METADATA as i, computeInitialWidthPoint as it, DEFAULT_BREACH_OPTIONS as j, DEFAULT_CANALIZE_OPTIONS as k, listControlMeasureMetadata as l, roundToFixed as lt, DEFAULT_TACTICAL_ARROW_OPTIONS as m, resolveStyleHints as n, createBaselineFrame as nt, getControlMeasureMetadata as o, unproject as ot, DEFAULT_STRONG_POINT_OPTIONS as p, attackByFireDrawRule as q, CONTROL_MEASURE_IDS as r, calculateMetrics as rt, getControlMeasureMetadataByValue as s, EPSILON as st, renderControlMeasure as t, snapToMidpointPerpendicular as tt, DEFAULT_TURN_OPTIONS as u, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as v, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as w, DEFAULT_FORTIFIED_LINE_OPTIONS as x, DEFAULT_MAIN_ATTACK_OPTIONS as y, DEFAULT_AIRBORNE_ATTACK_OPTIONS as z };
+export { point12DrawRule as $, DEFAULT_GENERIC_POLYGON_OPTIONS as A, DEFAULT_ANTITANK_WALL_OPTIONS as B, DEFAULT_FIX_OPTIONS as C, DEFAULT_DELAY_OPTIONS as D, DEFAULT_DISRUPT_OPTIONS as E, DEFAULT_BREACH_OPTIONS as F, axis1DrawRule as G, DEFAULT_AMBUSH_OPTIONS as H, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as I, line23DrawRule as J, supportByFireDrawRule as K, DEFAULT_BLOCK_OPTIONS as L, DEFAULT_GENERIC_CIRCLE_OPTIONS as M, DEFAULT_CANALIZE_OPTIONS as N, DEFAULT_CLEAR_OPTIONS as O, DEFAULT_BYPASS_OPTIONS as P, attackByFireDrawRule as Q, DEFAULT_ATTACK_HELICOPTER_OPTIONS as R, DEFAULT_FLOT_OPTIONS as S, DEFAULT_ENCIRCLEMENT_OPTIONS as T, DEFAULT_AIRBORNE_ATTACK_OPTIONS as U, DEFAULT_ANTITANK_DITCH_OPTIONS as V, rectangleDrawRule as W, line1DrawRule as X, turnDrawRule as Y, ambushDrawRule as Z, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as _, DEFINITIONS as a, getMidpointPerpendicularSignedDistance as at, DEFAULT_FORTIFIED_AREA_OPTIONS as b, getDefaultOptions as c, createBaselineFrame as ct, DEFAULT_SUPPORTING_ATTACK_OPTIONS as d, project as dt, centerRadiusDrawRule as et, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as f, unproject as ft, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as g, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as h, roundToFixed as ht, CONTROL_MEASURE_METADATA as i, createMidpointPerpendicularDrawRule as it, DEFAULT_GENERIC_LINE_OPTIONS as j, DEFAULT_GENERIC_RECTANGLE_OPTIONS as k, listControlMeasureMetadata as l, calculateMetrics as lt, DEFAULT_TACTICAL_ARROW_OPTIONS as m, getMetersPerPixel as mt, resolveStyleHints as n, blockDrawRule as nt, getControlMeasureMetadata as o, pointOnMidpointPerpendicularAxis as ot, DEFAULT_STRONG_POINT_OPTIONS as p, EPSILON as pt, line24DrawRule as q, CONTROL_MEASURE_IDS as r, computeDefaultMidpointPerpendicularPoint as rt, getControlMeasureMetadataByValue as s, snapToMidpointPerpendicular as st, renderControlMeasure as t, disruptDrawRule as tt, DEFAULT_TURN_OPTIONS as u, computeInitialWidthPoint as ut, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as v, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as w, DEFAULT_FORTIFIED_LINE_OPTIONS as x, DEFAULT_MAIN_ATTACK_OPTIONS as y, DEFAULT_ATTACK_BY_FIRE_OPTIONS as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/control-measures",
-  "version": "0.2.0-alpha.3",
+  "version": "0.2.0-alpha.5",
   "description": "Library for drawing tactical graphics and control measures according to MIL-STD-2525 and APP-6 standards.",
   "license": "MIT",
   "author": "Orbat Mapper",