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

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

@@ -23,6 +23,19 @@ interface ControlMeasureDrawRule {
    * `minimumUserPoints` (no early preview).
    */
   readonly minimumPreviewPoints?: number;
+  /**
+   * Opt a fixed-length draw into the standard dashed interaction guide. Fixed
+   * shapes suppress guides by default because their generator preview is
+   * normally sufficient. Use this when the guide communicates an incomplete
+   * construction state, such as Rectangle's P1-P2 baseline.
+   */
+  readonly showGuide?: boolean;
+  /**
+   * Convert raw draw points into the spine rendered by the interaction guide.
+   * Defaults to the raw points. A rule may return the first point again at the
+   * end when it needs to provide its own closed guide geometry.
+   */
+  guidePoints?(points: readonly Position[]): Position[];
   /**
    * Number of trailing slots in the canonical control-point array that are
    * NOT user-clicked spine vertices. For Axis1, this is 1 (the width handle
@@ -162,6 +175,18 @@ interface ControlMeasureDefinition<Id extends string, G extends ControlMeasureGe
    * ADR-0025.
    */
   previewSample?: PreviewSample<NonNullable<Parameters<G>[1]>>;
+  /**
+   * Pins orientation-derived defaults — options whose default value depends on
+   * the shape's current screen orientation (e.g. Battle Position's echelon
+   * anchor, which defaults to the bottom edge) — to their current concrete
+   * values. Returns an options patch to merge onto the working options, or
+   * `undefined` when there is nothing to freeze (already frozen, or nothing
+   * visible to pin). Called by edit hosts when a rotate gesture starts, so a
+   * subsequent rigid rotation of the control points preserves the rendered
+   * appearance instead of an orientation-relative default silently re-deriving
+   * against the new orientation. See ADR-0023.
+   */
+  freezeOrientation?: (controlPoints: Position[], options: NonNullable<Parameters<G>[1]>) => Partial<NonNullable<Parameters<G>[1]>> | undefined;
 }
 /**
  * A measure's representative preview input. Shared between the typed
@@ -315,6 +340,25 @@ interface BattlePositionOptions {
    * @default 0
    */
   echelonPosition?: number;
+  /**
+   * Absolute anchor for the echelon glyph, as a fraction of the total
+   * perimeter measured from the ring seam (the ring's first vertex), wrapped
+   * into `[0, 1)`. When omitted, the anchor is "auto": the bottom edge's
+   * midpoint (the side opposite the front), recomputed from the current
+   * geometry on every render — the long-standing default behavior.
+   * `echelonPosition` still applies on top of this anchor as a signed offset,
+   * exactly as it does against the auto anchor.
+   *
+   * Edit controllers freeze this from "auto" to a concrete fraction the
+   * moment a rotate gesture starts (see `freezeEchelonAnchor` /
+   * `freezeOrientationOptions`): the transform box rotates only the control
+   * points and re-renders, so without a pinned anchor the "bottom edge" would
+   * keep re-deriving against the rotated geometry and the glyph would jump to
+   * a different edge each time a new edge becomes lowest. Freezing the anchor
+   * first makes the rotation rigid — the glyph turns with the shape instead.
+   * See ADR-0023.
+   */
+  echelonAnchor?: number;
   /**
    * Meters-per-pixel at the current zoom/latitude. Stamped by the host when the
    * measure is screen-anchored; required to resolve `echelonSizePixels`.
@@ -1505,6 +1549,17 @@ interface RenderOptions {
  */
 declare function renderControlMeasure<K extends ControlMeasureKind>(cm: ControlMeasure<K>, opts?: RenderOptions): ControlMeasureRender;
 //#endregion
+//#region src/freeze-orientation.d.ts
+/**
+ * Dispatches to a measure kind's `freezeOrientation` hook (see
+ * {@link import("./define").ControlMeasureDefinition.freezeOrientation}),
+ * pinning orientation-derived option defaults to their current concrete
+ * values ahead of a rigid rotation of `controlPoints`. Returns `undefined`
+ * when the kind declares no hook, or when the hook itself finds nothing to
+ * freeze. Edit hosts call this when a rotate gesture starts (ADR-0023).
+ */
+declare function freezeOrientationOptions<K extends ControlMeasureKind>(kind: K, controlPoints: Position[], options: OptionsByKind[K] | undefined): Partial<OptionsByKind[K]> | undefined;
+//#endregion
 //#region src/styleResolver.d.ts
 /**
  * Three-layer style precedence for `renderControlMeasure`.
@@ -1767,4 +1822,4 @@ interface TacticalArrowOptions {
  */
 declare const DEFAULT_TACTICAL_ARROW_OPTIONS: Required<TacticalArrowOptions>;
 //#endregion
-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 };
+export { getControlMeasureMetadata as $, DEFAULT_GENERIC_LINE_OPTIONS as $t, getMetersPerPixel as A, DEFAULT_CANALIZE_OPTIONS as At, ControlMeasureSnapshot as B, DEFAULT_ATTACK_BY_FIRE_OPTIONS as Bt, snapToMidpointPerpendicular as C, ControlMeasureDrawRule as Cn, AntitankDitchOptions as Ct, BaselineFrameOrigin as D, ClearOptions as Dt, BaselineFrameOptions as E, DelayOptions as Et, resolveStyleHints as F, BlockMissionTaskOptions as Ft, cloneControlMeasure as G, AirborneAttackOptions as Gt, StyleHints as H, SupportByFireOptions as Ht, freezeOrientationOptions as I, DEFAULT_BLOCK_MISSION_TASK_OPTIONS as It, CONTROL_MEASURE_IDS as J, GenericCircleOptions as Jt, isKind as K, DEFAULT_AIRBORNE_ATTACK_OPTIONS as Kt, RenderOptions as L, DEFAULT_FLOT_OPTIONS as Lt, SimpleStyleProps as M, DEFAULT_BYPASS_OPTIONS as Mt, SimpleStyleRender as N, BreachOptions as Nt, createBaselineFrame as O, DEFAULT_CLEAR_OPTIONS as Ot, toSimpleStyle as P, DEFAULT_BREACH_OPTIONS as Pt, OptionsByKind as Q, GenericPolygonOptions as Qt, renderControlMeasure as R, FLOTOptions as Rt, pointOnMidpointPerpendicularAxis as S, AnchorTransformEvent as Sn, DEFAULT_ANTITANK_WALL_OPTIONS as St, BaselineFrameNormal as T, DEFAULT_DELAY_OPTIONS as Tt, controlMeasureIdFromFeature as U, AttackHelicopterOptions as Ut, FeaturePartProps as V, DEFAULT_SUPPORT_BY_FIRE_OPTIONS as Vt, ControlMeasure as W, DEFAULT_ATTACK_HELICOPTER_OPTIONS as Wt, ControlMeasureId as X, GenericRectangleOptions as Xt, CONTROL_MEASURE_METADATA as Y, DEFAULT_GENERIC_RECTANGLE_OPTIONS as Yt, ControlMeasureKind as Z, DEFAULT_GENERIC_POLYGON_OPTIONS as Zt, blockDrawRule as _, StrongPointOptions as _n, DEFAULT_FORTIFIED_AREA_OPTIONS as _t, rectangleDrawRule as a, calculateMetrics as an, DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS as at, createMidpointPerpendicularDrawRule as b, ControlMeasureMetadata as bn, FortifiedLineOptions as bt, line24DrawRule as c, project as cn, ObstacleBypassEasyOptions as ct, line1DrawRule as d, EncirclementOptions as dn, DEFAULT_FIX_OPTIONS as dt, GenericLineOptions as en, getControlMeasureMetadataByValue as et, ambushDrawRule as f, DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS as fn, FixOptions as ft, disruptDrawRule as g, DEFAULT_STRONG_POINT_OPTIONS as gn, DEFAULT_BLOCK_OPTIONS as gt, centerRadiusDrawRule as h, PrincipalDirectionOfFireOptions as hn, BlockOptions as ht, DEFAULT_AMBUSH_OPTIONS as i, MainAttackOptions as in, ObstacleBypassImpossibleOptions as it, roundToFixed as j, BypassOptions as jt, EPSILON as k, CanalizeOptions as kt, line23DrawRule as l, unproject as ln, DEFAULT_TURN_OPTIONS as lt, point12DrawRule as m, DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS as mn, DisruptOptions as mt, TacticalArrowOptions as n, SupportingAttackOptions as nn, listControlMeasureMetadata as nt, axis1DrawRule as o, computeInitialWidthPoint as on, ObstacleBypassDifficultOptions as ot, attackByFireDrawRule as p, FinalProtectiveFireOptions as pn, DEFAULT_DISRUPT_OPTIONS as pt, ControlMeasureStyle as q, DEFAULT_GENERIC_CIRCLE_OPTIONS as qt, AmbushOptions as r, DEFAULT_MAIN_ATTACK_OPTIONS as rn, DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS as rt, supportByFireDrawRule as s, Point2D as sn, DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS as st, DEFAULT_TACTICAL_ARROW_OPTIONS as t, DEFAULT_SUPPORTING_ATTACK_OPTIONS as tn, getDefaultOptions as tt, turnDrawRule as u, DEFAULT_ENCIRCLEMENT_OPTIONS as un, TurnOptions as ut, MidpointPerpendicularDrawRuleOptions as v, ControlMeasureGeometry as vn, FortifiedAreaOptions as vt, BaselineFrame as w, DEFAULT_ANTITANK_DITCH_OPTIONS as wt, getMidpointPerpendicularSignedDistance as x, ParamDescriptor as xn, AntitankWallOptions as xt, computeDefaultMidpointPerpendicularPoint as y, ControlMeasureGeometryType as yn, DEFAULT_FORTIFIED_LINE_OPTIONS as yt, ControlMeasureRender as z, AttackByFireOptions as zt };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-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 };
+import { $ as getControlMeasureMetadata, $t as DEFAULT_GENERIC_LINE_OPTIONS, A as getMetersPerPixel, At as DEFAULT_CANALIZE_OPTIONS, B as ControlMeasureSnapshot, Bt as DEFAULT_ATTACK_BY_FIRE_OPTIONS, C as snapToMidpointPerpendicular, Cn as ControlMeasureDrawRule, Ct as AntitankDitchOptions, D as BaselineFrameOrigin, Dt as ClearOptions, E as BaselineFrameOptions, Et as DelayOptions, F as resolveStyleHints, Ft as BlockMissionTaskOptions, G as cloneControlMeasure, Gt as AirborneAttackOptions, H as StyleHints, Ht as SupportByFireOptions, I as freezeOrientationOptions, It as DEFAULT_BLOCK_MISSION_TASK_OPTIONS, J as CONTROL_MEASURE_IDS, Jt as GenericCircleOptions, K as isKind, Kt as DEFAULT_AIRBORNE_ATTACK_OPTIONS, L as RenderOptions, Lt as DEFAULT_FLOT_OPTIONS, M as SimpleStyleProps, Mt as DEFAULT_BYPASS_OPTIONS, N as SimpleStyleRender, Nt as BreachOptions, O as createBaselineFrame, Ot as DEFAULT_CLEAR_OPTIONS, P as toSimpleStyle, Pt as DEFAULT_BREACH_OPTIONS, Q as OptionsByKind, Qt as GenericPolygonOptions, R as renderControlMeasure, Rt as FLOTOptions, S as pointOnMidpointPerpendicularAxis, Sn as AnchorTransformEvent, St as DEFAULT_ANTITANK_WALL_OPTIONS, T as BaselineFrameNormal, Tt as DEFAULT_DELAY_OPTIONS, U as controlMeasureIdFromFeature, Ut as AttackHelicopterOptions, V as FeaturePartProps, Vt as DEFAULT_SUPPORT_BY_FIRE_OPTIONS, W as ControlMeasure, Wt as DEFAULT_ATTACK_HELICOPTER_OPTIONS, X as ControlMeasureId, Xt as GenericRectangleOptions, Y as CONTROL_MEASURE_METADATA, Yt as DEFAULT_GENERIC_RECTANGLE_OPTIONS, Z as ControlMeasureKind, Zt as DEFAULT_GENERIC_POLYGON_OPTIONS, _ as blockDrawRule, _n as StrongPointOptions, _t as DEFAULT_FORTIFIED_AREA_OPTIONS, a as rectangleDrawRule, an as calculateMetrics, at as DEFAULT_OBSTACLE_BYPASS_DIFFICULT_OPTIONS, b as createMidpointPerpendicularDrawRule, bn as ControlMeasureMetadata, bt as FortifiedLineOptions, c as line24DrawRule, cn as project, ct as ObstacleBypassEasyOptions, d as line1DrawRule, dn as EncirclementOptions, dt as DEFAULT_FIX_OPTIONS, en as GenericLineOptions, et as getControlMeasureMetadataByValue, f as ambushDrawRule, fn as DEFAULT_FINAL_PROTECTIVE_FIRE_OPTIONS, ft as FixOptions, g as disruptDrawRule, gn as DEFAULT_STRONG_POINT_OPTIONS, gt as DEFAULT_BLOCK_OPTIONS, h as centerRadiusDrawRule, hn as PrincipalDirectionOfFireOptions, ht as BlockOptions, i as DEFAULT_AMBUSH_OPTIONS, in as MainAttackOptions, it as ObstacleBypassImpossibleOptions, j as roundToFixed, jt as BypassOptions, k as EPSILON, kt as CanalizeOptions, l as line23DrawRule, ln as unproject, lt as DEFAULT_TURN_OPTIONS, m as point12DrawRule, mn as DEFAULT_PRINCIPAL_DIRECTION_OF_FIRE_OPTIONS, mt as DisruptOptions, n as TacticalArrowOptions, nn as SupportingAttackOptions, nt as listControlMeasureMetadata, o as axis1DrawRule, on as computeInitialWidthPoint, ot as ObstacleBypassDifficultOptions, p as attackByFireDrawRule, pn as FinalProtectiveFireOptions, pt as DEFAULT_DISRUPT_OPTIONS, q as ControlMeasureStyle, qt as DEFAULT_GENERIC_CIRCLE_OPTIONS, r as AmbushOptions, rn as DEFAULT_MAIN_ATTACK_OPTIONS, rt as DEFAULT_OBSTACLE_BYPASS_IMPOSSIBLE_OPTIONS, s as supportByFireDrawRule, sn as Point2D, st as DEFAULT_OBSTACLE_BYPASS_EASY_OPTIONS, t as DEFAULT_TACTICAL_ARROW_OPTIONS, tn as DEFAULT_SUPPORTING_ATTACK_OPTIONS, tt as getDefaultOptions, u as turnDrawRule, un as DEFAULT_ENCIRCLEMENT_OPTIONS, ut as TurnOptions, v as MidpointPerpendicularDrawRuleOptions, vn as ControlMeasureGeometry, vt as FortifiedAreaOptions, w as BaselineFrame, wt as DEFAULT_ANTITANK_DITCH_OPTIONS, x as getMidpointPerpendicularSignedDistance, xn as ParamDescriptor, xt as AntitankWallOptions, y as computeDefaultMidpointPerpendicularPoint, yn as ControlMeasureGeometryType, yt as DEFAULT_FORTIFIED_LINE_OPTIONS, z as ControlMeasureRender, zt as AttackByFireOptions } from "./index-DUGzYzPy.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, freezeOrientationOptions, 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,19 @@
-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";
+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, a as DEFINITIONS, 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-DGWf44sn.mjs";
+//#region src/freeze-orientation.ts
+/**
+* Dispatches to a measure kind's `freezeOrientation` hook (see
+* {@link import("./define").ControlMeasureDefinition.freezeOrientation}),
+* pinning orientation-derived option defaults to their current concrete
+* values ahead of a rigid rotation of `controlPoints`. Returns `undefined`
+* when the kind declares no hook, or when the hook itself finds nothing to
+* freeze. Edit hosts call this when a rotate gesture starts (ADR-0023).
+*/
+function freezeOrientationOptions(kind, controlPoints, options) {
+	const definition = DEFINITIONS[kind];
+	if (!definition.freezeOrientation) return void 0;
+	return definition.freezeOrientation(controlPoints, options ?? {});
+}
+//#endregion
 //#region src/instance.ts
 function isKind(cm, kind) {
 	return cm.kind === kind;
@@ -99,4 +114,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_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 };
+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, freezeOrientationOptions, 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 { Y as ControlMeasureId } from "../index-Ddt-obht.mjs";
+import { X as ControlMeasureId } from "../index-DUGzYzPy.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-CDCoQlZ-.mjs";
+import { a as DEFINITIONS, t as renderControlMeasure } from "../renderControlMeasure-DGWf44sn.mjs";
 //#region src/preview/index.ts
 /**
 * Unitless `previewSample` points (~`[-1, 1]`) are scaled by this degree offset

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

@@ -181,7 +181,7 @@ function pointToInfiniteLineDistance(p, a, b) {
 }
 /**
 * Calculates intersection of two line segments p1-p2 and p3-p4.
-* Returns null if parallel. Assuming they cross as per design.
+* Returns null if parallel or if the infinite lines intersect outside either segment.
 */
 function lineIntersection(p1, p2, p3, p4) {
 	const x1 = p1[0], y1 = p1[1];
@@ -191,6 +191,8 @@ function lineIntersection(p1, p2, p3, p4) {
 	const denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
 	if (Math.abs(denom) < 1e-6) return null;
 	const ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denom;
+	const ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / denom;
+	if (ua < -1e-6 || ua > 1.000001 || ub < -1e-6 || ub > 1.000001) return null;
 	return [x1 + ua * (x2 - x1), y1 + ua * (y2 - y1)];
 }
 //#endregion
@@ -218,15 +220,38 @@ function processAttackGeometry(coordinates, options = {}) {
 	return { geometry: calculateSymbolGeometry(ptTip, ptWidth, spinePoints, shaftRatio, roundedBends, bendSegments) };
 }
 function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, roundedBends, bendSegments) {
-	const ptNeck = spine[spine.length - 1];
+	const initialNeck = spine[spine.length - 1];
+	if (!initialNeck) return null;
+	const initialTipDir = vecNorm(vecSub(ptTip, initialNeck));
+	if (vecMag(initialTipDir) < 1e-6) return null;
+	const headHalfWidth = pointToInfiniteLineDistance(ptWidth, initialNeck, ptTip);
+	const vecTipToWidth = vecSub(ptTip, ptWidth);
+	const requestedHeadLength = Math.max(EPSILON, vecDot(vecTipToWidth, initialTipDir));
+	const path = [...spine, ptTip];
+	let totalArcLength = 0;
+	for (let i = 1; i < path.length; i++) totalArcLength += vecMag(vecSub(path[i], path[i - 1]));
+	const minimumShaftLength = Math.max(EPSILON, totalArcLength * .01);
+	let distanceRemaining = clamp(requestedHeadLength, EPSILON, Math.max(EPSILON, totalArcLength - minimumShaftLength));
+	let ptBase = ptTip;
+	let remainingSpine = spine;
+	for (let i = path.length - 1; i > 0; i--) {
+		const segmentEnd = path[i];
+		const segmentStart = path[i - 1];
+		const segment = vecSub(segmentStart, segmentEnd);
+		const segmentLength = vecMag(segment);
+		if (segmentLength < 1e-6) continue;
+		if (distanceRemaining < segmentLength) {
+			ptBase = vecAdd(segmentEnd, vecScale(segment, distanceRemaining / segmentLength));
+			remainingSpine = path.slice(0, i);
+			break;
+		}
+		distanceRemaining -= segmentLength;
+	}
+	const ptNeck = remainingSpine[remainingSpine.length - 1];
 	if (!ptNeck) return null;
 	const tipDir = vecNorm(vecSub(ptTip, ptNeck));
 	if (vecMag(tipDir) < 1e-6) return null;
-	const headHalfWidth = pointToInfiniteLineDistance(ptWidth, ptNeck, ptTip);
-	const vecTipToWidth = vecSub(ptTip, ptWidth);
-	const maxHeadLength = Math.max(0, vecMag(vecSub(ptTip, ptNeck)) - .1);
-	const headLength = clamp(vecDot(vecTipToWidth, tipDir), EPSILON, maxHeadLength);
-	const ptBase = vecSub(ptTip, vecScale(tipDir, headLength));
+	const headLength = vecMag(vecSub(ptTip, ptBase));
 	const shaftHalfWidth = headHalfWidth * shaftRatio;
 	const perpDir = [-tipDir[1], tipDir[0]];
 	const outerLeft = vecAdd(ptBase, vecScale(perpDir, headHalfWidth));
@@ -234,7 +259,8 @@ function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, roundedBends
 	const innerLeft = vecAdd(ptBase, vecScale(perpDir, shaftHalfWidth));
 	const innerRight = vecAdd(ptBase, vecScale(perpDir, -shaftHalfWidth));
 	const notchDepth = headLength * shaftRatio;
-	const innerTip = vecAdd(ptBase, vecScale(tipDir, Math.min(notchDepth, headLength - EPSILON)));
+	const safeNotchDepth = Math.min(notchDepth, headLength - EPSILON);
+	const innerTip = vecAdd(ptBase, vecScale(tipDir, safeNotchDepth));
 	const shaftEndCenter = ptBase;
 	const headRing = [
 		outerLeft,
@@ -245,7 +271,7 @@ function calculateSymbolGeometry(ptTip, ptWidth, spine, shaftRatio, roundedBends
 		innerLeft,
 		outerLeft
 	];
-	const fullSpine = [...spine, shaftEndCenter];
+	const fullSpine = [...remainingSpine, shaftEndCenter];
 	return {
 		shaftLeft: offsetPolyline(fullSpine, shaftHalfWidth, roundedBends, bendSegments),
 		shaftRight: offsetPolyline(fullSpine, -shaftHalfWidth, roundedBends, bendSegments),
@@ -849,19 +875,91 @@ const searchAreaDrawRule = {
 //#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.
+* Oriented rectangle: P1 and P2 are adjacent corners and define the first
+* edge. P3 is the next corner, constrained to the perpendicular through P2.
+* The generator derives the fourth corner.
 */
 function derive(points) {
-	return clonePositions(points.slice(0, 2));
+	if (points.length < 2) return clonePositions(points);
+	const p1 = clonePosition(points[0]);
+	const p2 = clonePosition(points[1]);
+	if (points.length === 2) return [
+		p1,
+		p2,
+		clonePosition(p2)
+	];
+	const frame = createBaselineFrame(p1, p2, {
+		origin: "p2",
+		normal: "right"
+	});
+	return [
+		p1,
+		p2,
+		frame?.pointAtNormalDistance(frame.signedNormalDistance(points[2])) ?? clonePosition(points[2])
+	];
+}
+function guidePoints(points) {
+	const canonical = derive(points);
+	if (canonical.length < 3) return canonical;
+	const [c1, c2, c3] = canonical;
+	if (!c1 || !c2 || !c3) return canonical;
+	if (c2[0] === c3[0] && c2[1] === c3[1]) return [c1, c2];
+	const p1 = project(c1[0], c1[1]);
+	const p2 = project(c2[0], c2[1]);
+	const p4 = vecAdd(p1, vecSub(project(c3[0], c3[1]), p2));
+	return [
+		c1,
+		c2,
+		c3,
+		unproject(p4[0], p4[1]),
+		clonePosition(c1)
+	];
+}
+function snapToAxis(point, origin, direction) {
+	const snapped = vecAdd(origin, vecScale(direction, vecDot(vecSub(project(point[0], point[1]), origin), direction)));
+	return unproject(snapped[0], snapped[1]);
 }
 const rectangleDrawRule = {
 	id: "rectangle",
-	minimumUserPoints: 2,
-	canonicalPointCount: 2,
+	minimumUserPoints: 3,
+	minimumPreviewPoints: 2,
+	canonicalPointCount: 3,
+	showGuide: true,
+	guidePoints,
 	derive,
 	transform(event) {
-		return derive(event.next);
+		const { previous, next, activePointIndex } = event;
+		if (previous.length < 3 || next.length < 3) return derive(next);
+		const frame = createBaselineFrame(previous[0], previous[1], {
+			origin: "p2",
+			normal: "right"
+		});
+		if (!frame) return derive(next);
+		if (activePointIndex === 0) return [
+			snapToAxis(next[0], frame.p2, frame.direction),
+			clonePosition(previous[1]),
+			clonePosition(previous[2])
+		];
+		if (activePointIndex === 1) {
+			const p2 = snapToAxis(next[1], frame.p1, frame.direction);
+			const delta = vecSub(project(p2[0], p2[1]), frame.p2);
+			const projectedP3 = vecAdd(project(previous[2][0], previous[2][1]), delta);
+			const p3 = unproject(projectedP3[0], projectedP3[1]);
+			return [
+				clonePosition(previous[0]),
+				p2,
+				p3
+			];
+		}
+		if (activePointIndex === 2) {
+			const p3 = frame.pointAtNormalDistance(frame.signedNormalDistance(next[2]));
+			if (p3) return [
+				clonePosition(previous[0]),
+				clonePosition(previous[1]),
+				p3
+			];
+		}
+		return derive(next);
 	}
 };
 //#endregion
@@ -1754,7 +1852,7 @@ function createAttackHelicopter(coordinates, options = {}) {
 		type: "FeatureCollection",
 		features: []
 	};
-	const center = lineIntersection(pL, pIR, pR, pIL);
+	const center = lineIntersection(pL, pIR, pR, pIL) ?? geometry.ptBase;
 	const features = [{
 		type: "Feature",
 		properties: {},
@@ -2266,15 +2364,18 @@ function closedCatmullRom(points, samples) {
 }
 //#endregion
 //#region src/internal/area-echelon.ts
-/** Mean of the ring's distinct vertices, used as the outward-normal reference. */
-function ringCentroid(verts, count) {
-	let cx = 0;
-	let cy = 0;
-	for (let i = 0; i < count; i++) {
-		cx += verts[i][0];
-		cy += verts[i][1];
+/**
+* Twice the ring's signed area (shoelace). Positive when the ring winds
+* counter-clockwise in projected (y-up) coordinates.
+*/
+function ringSignedArea2(verts) {
+	let area2 = 0;
+	for (let i = 0; i < verts.length - 1; i++) {
+		const a = verts[i];
+		const b = verts[i + 1];
+		area2 += a[0] * b[1] - b[0] * a[1];
 	}
-	return [cx / count, cy / count];
+	return area2;
 }
 /**
 * Projects `positions` and returns a closed ring (first == last), optionally
@@ -2294,7 +2395,7 @@ function buildClosedRing(positions, smooth, smoothResolution, defaultSmoothResol
 * projected y), the side opposite the front.
 */
 function buildAreaPerimeter(verts) {
-	const centroid = ringCentroid(verts, verts.length - 1);
+	const ccw = ringSignedArea2(verts) > 0;
 	const segs = [];
 	let totalLength = 0;
 	let anchorTarget = 0;
@@ -2307,8 +2408,7 @@ function buildAreaPerimeter(verts) {
 		if (length < 1e-6) continue;
 		const along = vecNorm(edge);
 		const mid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
-		let perp = [-along[1], along[0]];
-		if (perp[0] * (mid[0] - centroid[0]) + perp[1] * (mid[1] - centroid[1]) < 0) perp = [-perp[0], -perp[1]];
+		const perp = ccw ? [along[1], -along[0]] : [-along[1], along[0]];
 		segs.push({
 			start: a,
 			along,
@@ -2351,13 +2451,21 @@ function resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel) {
 	if (echelonSizePixels !== void 0 && metersPerPixel !== void 0 && metersPerPixel > 0) h = echelonSizePixels * metersPerPixel;
 	return Math.max(EPSILON, h);
 }
+/** Wraps `x` into `[0, 1)`, treating `x` as a fraction (matches the arc-length wrap below). */
+function wrap01(x) {
+	return (x % 1 + 1) % 1;
+}
 /**
 * Places the Field B echelon glyph on the perimeter and computes its masking
-* gap, anchored to the bottom edge and slid by `echelonPosition` (a signed
-* fraction of the perimeter, wrapping at the seam). Returns empty geometry
-* when the echelon resolves to none or the ring is degenerate.
+* gap, anchored by default to the bottom edge and slid by `echelonPosition`
+* (a signed fraction of the perimeter, wrapping at the seam). When
+* `echelonAnchor` is supplied, it replaces the bottom-edge anchor with an
+* absolute perimeter fraction (measured from the ring seam) — see
+* `BattlePositionOptions.echelonAnchor` for why (ADR-0023 rotate-freeze).
+* Returns empty geometry when the echelon resolves to none or the ring is
+* degenerate.
 */
-function placeEchelon(perimeter, h, echelon, echelonPadding, echelonPosition) {
+function placeEchelon(perimeter, h, echelon, echelonPadding, echelonPosition, echelonAnchor) {
 	const { segs, totalLength, anchorTarget } = perimeter;
 	const spec = resolveEchelon(echelon);
 	if (!spec || segs.length === 0 || totalLength < 1e-6) return {
@@ -2365,7 +2473,7 @@ function placeEchelon(perimeter, h, echelon, echelonPadding, echelonPosition) {
 		fills: [],
 		gaps: []
 	};
-	const target = ((anchorTarget + echelonPosition * totalLength) % totalLength + totalLength) % totalLength;
+	const target = (((echelonAnchor !== void 0 ? wrap01(echelonAnchor) * totalLength : anchorTarget) + echelonPosition * totalLength) % totalLength + totalLength) % totalLength;
 	const { point, seg } = pointOnRing(segs, target);
 	const { strokes, fills, width } = buildEchelonGlyph(point, seg.along, seg.perp, h, spec);
 	const gaps = [];
@@ -2475,10 +2583,10 @@ const BATTLE_POSITION_METADATA = {
 * @param options - {@link BattlePositionOptions}.
 */
 function createBattlePosition(positions, options = {}) {
-	const { echelon = DEFAULT_BATTLE_POSITION_OPTIONS.echelon, echelonSize = DEFAULT_BATTLE_POSITION_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_BATTLE_POSITION_OPTIONS.echelonPadding, echelonPosition = DEFAULT_BATTLE_POSITION_OPTIONS.echelonPosition, metersPerPixel, smooth = DEFAULT_BATTLE_POSITION_OPTIONS.smooth, smoothResolution = DEFAULT_BATTLE_POSITION_OPTIONS.smoothResolution } = options;
+	const { echelon = DEFAULT_BATTLE_POSITION_OPTIONS.echelon, echelonSize = DEFAULT_BATTLE_POSITION_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_BATTLE_POSITION_OPTIONS.echelonPadding, echelonPosition = DEFAULT_BATTLE_POSITION_OPTIONS.echelonPosition, echelonAnchor, metersPerPixel, smooth = DEFAULT_BATTLE_POSITION_OPTIONS.smooth, smoothResolution = DEFAULT_BATTLE_POSITION_OPTIONS.smoothResolution } = options;
 	const h = resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel);
 	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION$6);
-	const { strokes, fills, gaps } = placeEchelon(buildAreaPerimeter(verts), h, echelon, echelonPadding, echelonPosition);
+	const { strokes, fills, gaps } = placeEchelon(buildAreaPerimeter(verts), h, echelon, echelonPadding, echelonPosition, echelonAnchor);
 	const boundaryCoords = buildGappedLine(verts, gaps);
 	const features = [];
 	if (boundaryCoords.length > 0) features.push({
@@ -2513,11 +2621,29 @@ function createBattlePosition(positions, options = {}) {
 		features
 	};
 }
+/**
+* `freezeOrientation` hook (ADR-0023) shared by Battle Position and Strong
+* Point: pins the echelon anchor to its current bottom-edge fraction so a
+* subsequent rigid rotation of `controlPoints` (e.g. the transform box's
+* rotate grip) does not re-derive a different "bottom edge" against the
+* rotated geometry. Returns `undefined` — nothing to freeze — when:
+*  - `echelonAnchor` is already set (previously frozen or user-authored), or
+*  - the echelon resolves to none (nothing visible to pin), or
+*  - the ring is degenerate (no segments, or a near-zero perimeter).
+*/
+function freezeEchelonAnchor(controlPoints, options) {
+	if (options.echelonAnchor !== void 0) return void 0;
+	if (!resolveEchelon(options.echelon ?? DEFAULT_BATTLE_POSITION_OPTIONS.echelon)) return void 0;
+	const perimeter = buildAreaPerimeter(buildClosedRing(controlPoints, options.smooth ?? DEFAULT_BATTLE_POSITION_OPTIONS.smooth, options.smoothResolution ?? DEFAULT_BATTLE_POSITION_OPTIONS.smoothResolution, DEFAULT_SMOOTH_RESOLUTION$6));
+	if (perimeter.segs.length === 0 || perimeter.totalLength < 1e-6) return void 0;
+	return { echelonAnchor: perimeter.anchorTarget / perimeter.totalLength };
+}
 const BATTLE_POSITION = defineControlMeasure({
 	metadata: BATTLE_POSITION_METADATA,
 	generator: createBattlePosition,
 	defaultOptions: DEFAULT_BATTLE_POSITION_OPTIONS,
 	rule: area1DrawRule,
+	freezeOrientation: freezeEchelonAnchor,
 	previewSample: {
 		controlPoints: [
 			[-1, -.5],
@@ -4127,30 +4253,41 @@ 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.",
+	description: "A non-doctrinal oriented rectangle defined by three adjacent corners.",
 	entity: "Generic Graphics",
 	entityType: "Basic Shape",
 	entitySubtype: "Rectangle",
 	value: "990103",
-	minCoordinates: 2,
-	maxCoordinates: 2,
+	minCoordinates: 3,
+	maxCoordinates: 3,
 	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 {
+	const [c1, c2, c3] = rectangleDrawRule.derive(coordinates);
+	if (!c1 || !c2 || !c3) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const p1 = project(c1[0], c1[1]);
+	const p2 = project(c2[0], c2[1]);
+	const p3 = project(c3[0], c3[1]);
+	if (Math.hypot(p2[0] - p1[0], p2[1] - p1[1]) < 1e-6) return {
+		type: "FeatureCollection",
+		features: []
+	};
+	const fill = options.filled ?? DEFAULT_GENERIC_RECTANGLE_OPTIONS.filled;
+	if (Math.hypot(p3[0] - p2[0], p3[1] - p2[1]) < 1e-6) return {
 		type: "FeatureCollection",
 		features: []
 	};
 	const ring = [
 		p1,
-		[p2[0], p1[1]],
 		p2,
-		[p1[0], p2[1]],
+		p3,
+		[p1[0] + p3[0] - p2[0], p1[1] + p3[1] - p2[1]],
 		p1
 	].map((point) => unproject(point[0], point[1]));
 	return {
@@ -4159,7 +4296,7 @@ function createGenericRectangle(coordinates, options = {}) {
 			type: "Feature",
 			properties: {
 				part: "rectangle",
-				fill: options.filled ?? DEFAULT_GENERIC_RECTANGLE_OPTIONS.filled
+				fill
 			},
 			geometry: {
 				type: "Polygon",
@@ -4173,7 +4310,11 @@ const GENERIC_RECTANGLE = defineControlMeasure({
 	generator: createGenericRectangle,
 	defaultOptions: DEFAULT_GENERIC_RECTANGLE_OPTIONS,
 	rule: rectangleDrawRule,
-	previewSample: { controlPoints: [[-.9, -.55], [.9, .55]] }
+	previewSample: { controlPoints: [
+		[-.9, -.55],
+		[.9, -.55],
+		[.9, .55]
+	] }
 });
 //#endregion
 //#region src/generators/cm34-mission-tasks/clear.ts
@@ -6519,11 +6660,11 @@ function buildStrongPointTics(perimeter, gaps, h) {
 * @param options - {@link StrongPointOptions}.
 */
 function createStrongPoint(positions, options = {}) {
-	const { echelon = DEFAULT_STRONG_POINT_OPTIONS.echelon, echelonSize = DEFAULT_STRONG_POINT_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_STRONG_POINT_OPTIONS.echelonPadding, echelonPosition = DEFAULT_STRONG_POINT_OPTIONS.echelonPosition, metersPerPixel, smooth = DEFAULT_STRONG_POINT_OPTIONS.smooth, smoothResolution = DEFAULT_STRONG_POINT_OPTIONS.smoothResolution } = options;
+	const { echelon = DEFAULT_STRONG_POINT_OPTIONS.echelon, echelonSize = DEFAULT_STRONG_POINT_OPTIONS.echelonSize, echelonSizePixels, echelonPadding = DEFAULT_STRONG_POINT_OPTIONS.echelonPadding, echelonPosition = DEFAULT_STRONG_POINT_OPTIONS.echelonPosition, echelonAnchor, metersPerPixel, smooth = DEFAULT_STRONG_POINT_OPTIONS.smooth, smoothResolution = DEFAULT_STRONG_POINT_OPTIONS.smoothResolution } = options;
 	const h = resolveEchelonHeight(echelonSize, echelonSizePixels, metersPerPixel);
 	const verts = buildClosedRing(positions, smooth, smoothResolution, DEFAULT_SMOOTH_RESOLUTION);
 	const perimeter = buildAreaPerimeter(verts);
-	const { strokes, fills, gaps } = placeEchelon(perimeter, h, echelon, echelonPadding, echelonPosition);
+	const { strokes, fills, gaps } = placeEchelon(perimeter, h, echelon, echelonPadding, echelonPosition, echelonAnchor);
 	const boundaryCoords = buildGappedLine(verts, gaps);
 	const tics = buildStrongPointTics(perimeter, gaps, h);
 	const features = [];
@@ -6572,6 +6713,7 @@ const STRONG_POINT = defineControlMeasure({
 	generator: createStrongPoint,
 	defaultOptions: DEFAULT_STRONG_POINT_OPTIONS,
 	rule: area1DrawRule,
+	freezeOrientation: freezeEchelonAnchor,
 	previewSample: {
 		controlPoints: [
 			[-1, -.5],

package/package.json

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