@brownnrl/geomlib 0.13.0 → 0.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/bundle.js +1 -1
  2. package/dist/bundle.js.map +1 -1
  3. package/package.json +7 -5
package/dist/bundle.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"bundle.js","mappings":"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","sources":["webpack://geomlib/./src/Colors.ts","webpack://geomlib/./src/Slate.ts","webpack://geomlib/./src/SlateAnimator.ts","webpack://geomlib/./src/SlateControls.ts","webpack://geomlib/./src/elements/Animations.ts","webpack://geomlib/./src/elements/Constructions.ts","webpack://geomlib/./src/elements/GeomElement.ts","webpack://geomlib/./src/elements/circle/CircleAnimations.ts","webpack://geomlib/./src/elements/circle/CircleConstructions.ts","webpack://geomlib/./src/elements/circle/CircleElement.ts","webpack://geomlib/./src/elements/circle/CircumcircleElement.ts","webpack://geomlib/./src/elements/circle/InvertCircleElement.ts","webpack://geomlib/./src/elements/circle/SphereIntersectionElement.ts","webpack://geomlib/./src/elements/group/GroupAnimations.ts","webpack://geomlib/./src/elements/line/Bichord.ts","webpack://geomlib/./src/elements/line/Chord.ts","webpack://geomlib/./src/elements/line/LineAnimations.ts","webpack://geomlib/./src/elements/line/LineConstructions.ts","webpack://geomlib/./src/elements/line/LineElement.ts","webpack://geomlib/./src/elements/line/Perpendicular.ts","webpack://geomlib/./src/elements/line/PlanePerpendicularLine.ts","webpack://geomlib/./src/elements/line/PolylineElement.ts","webpack://geomlib/./src/elements/plane/ParallelPlane.ts","webpack://geomlib/./src/elements/plane/PerpendicularPlane.ts","webpack://geomlib/./src/elements/plane/PlaneConstructions.ts","webpack://geomlib/./src/elements/plane/PlaneElement.ts","webpack://geomlib/./src/elements/point/AngleDividerElement.ts","webpack://geomlib/./src/elements/point/CircleSlider.ts","webpack://geomlib/./src/elements/point/FixedPoint.ts","webpack://geomlib/./src/elements/point/Foot.ts","webpack://geomlib/./src/elements/point/HarmonicElement.ts","webpack://geomlib/./src/elements/point/Intersection.ts","webpack://geomlib/./src/elements/point/InvertPointElement.ts","webpack://geomlib/./src/elements/point/Layoff.ts","webpack://geomlib/./src/elements/point/LineSlider.ts","webpack://geomlib/./src/elements/point/MeanProportionalElement.ts","webpack://geomlib/./src/elements/point/Midpoint.ts","webpack://geomlib/./src/elements/point/PlaneFootElement.ts","webpack://geomlib/./src/elements/point/PlaneIntersection.ts","webpack://geomlib/./src/elements/point/PlaneSlider.ts","webpack://geomlib/./src/elements/point/PointAnimations.ts","webpack://geomlib/./src/elements/point/PointConstructions.ts","webpack://geomlib/./src/elements/point/PointElement.ts","webpack://geomlib/./src/elements/point/ProportionElement.ts","webpack://geomlib/./src/elements/point/SimilarElement.ts","webpack://geomlib/./src/elements/point/SphereSliderElement.ts","webpack://geomlib/./src/elements/polygon/ApplicationElement.ts","webpack://geomlib/./src/elements/polygon/CurvedTriangleElement.ts","webpack://geomlib/./src/elements/polygon/PolygonAnimations.ts","webpack://geomlib/./src/elements/polygon/PolygonConstructions.ts","webpack://geomlib/./src/elements/polygon/PolygonElement.ts","webpack://geomlib/./src/elements/polygon/RegularPolygonElement.ts","webpack://geomlib/./src/elements/polyhedron/PolyhedronConstructions.ts","webpack://geomlib/./src/elements/polyhedron/PolyhedronElement.ts","webpack://geomlib/./src/elements/polyhedron/PrismElement.ts","webpack://geomlib/./src/elements/polyhedron/PyramidElement.ts","webpack://geomlib/./src/elements/sector/AngleMarkerElement.ts","webpack://geomlib/./src/elements/sector/ArcElement.ts","webpack://geomlib/./src/elements/sector/SectorAnimations.ts","webpack://geomlib/./src/elements/sector/SectorConstructions.ts","webpack://geomlib/./src/elements/sector/SectorElement.ts","webpack://geomlib/./src/elements/sphere/SphereConstructions.ts","webpack://geomlib/./src/elements/sphere/SphereElement.ts","webpack://geomlib/./src/index.ts","webpack://geomlib/./src/slideshow.ts","webpack://geomlib/webpack/bootstrap","webpack://geomlib/webpack/startup"],"sourcesContent":["/*----------------------------------------------------------------------+\n| Color parsing and manipulation. |\n| Matches the behavior of Java's Geometry.parseColor() exactly: |\n| 1. null / \"none\" / \"0\" / numeric 0 → null (transparent) |\n| 2. \"random\" → random pastel |\n| 3. \"background\" → bgcolor |\n| 4. \"brighter\" → brighter(bgcolor) |\n| 5. \"darker\" → darker(bgcolor) |\n| 6. Named color (13 names) → rgb string |\n| 7. Hex integer \"rrggbb\" → rgb string |\n| 8. HSB comma triple \"h,s,b\" → rgb string |\n| 9. Fallback → null |\n+----------------------------------------------------------------------*/\n\nexport const colors : {[colorName: string]: string} =\n{\n \"black\": \"rgb(0,0,0)\",\n \"blue\": \"rgb(0,0,255)\",\n \"cyan\": \"rgb(0,255,255)\",\n \"darkGray\": \"rgb(64,64,64)\",\n \"gray\": \"rgb(128,128,128)\",\n \"green\": \"rgb(0,255,0)\",\n \"lightGray\": \"rgb(192,192,192)\",\n \"magenta\": \"rgb(255,0,255)\",\n \"orange\": \"rgb(255,200,0)\",\n \"pink\": \"rgb(255,175,175)\",\n \"red\": \"rgb(255,0,0)\",\n \"white\": \"rgb(255,255,255)\",\n \"yellow\": \"rgb(255,255,0)\"\n};\n\n// Default color cycle for angle markers (#91). Each entry pairs a\n// solid edge color with a translucent face twin so concurrent markers\n// read as distinct, readable wedges. Hues are spread and deliberately\n// avoid gold (#FFD700, the highlight color) so an emphasized marker\n// still contrasts against its own fill. init() assigns these in\n// construction order; authors can override per element.\nexport const anglePalette : {edge: string, face: string}[] =\n[\n { edge: \"rgb(59,110,165)\", face: \"rgba(59,110,165,0.30)\" }, // blue\n { edge: \"rgb(63,142,79)\", face: \"rgba(63,142,79,0.30)\" }, // green\n { edge: \"rgb(122,79,163)\", face: \"rgba(122,79,163,0.30)\" }, // purple\n { edge: \"rgb(194,90,60)\", face: \"rgba(194,90,60,0.30)\" }, // orange-red\n { edge: \"rgb(46,139,139)\", face: \"rgba(46,139,139,0.30)\" }, // teal\n { edge: \"rgb(163,60,122)\", face: \"rgba(163,60,122,0.30)\" } // magenta\n];\n\nexport function parseColor(val: string | number, dfault: string, bgcolor: string) : string {\n // Handle numeric 0 (from IConstructionInfo where vertexColor: 0)\n if (val === 0) return null;\n // Handle null/undefined → use default\n if (val == null) return dfault;\n\n let str = String(val);\n // Transparent keywords\n if (str === \"none\" || str === \"0\" || str === \"\") return null;\n // Special keywords\n if (str === \"random\") return randomColor();\n if (str === \"background\") return bgcolor;\n if (str === \"brighter\") return brighter(bgcolor);\n if (str === \"darker\") return darker(bgcolor);\n // Named color lookup\n if (str in colors) return colors[str];\n // Hex color (e.g. \"ff0000\" or \"#ffe9cd\" → rgb(...))\n // Java does: new Color(Integer.parseInt(str, 16))\n // Also handle CSS #-prefixed hex which Java doesn't use but our\n // test pages do (e.g. background: '#ffe9cd')\n let hex = str.replace(/^#/, \"\");\n if (/^[0-9a-fA-F]+$/.test(hex)) {\n let n = parseInt(hex, 16);\n if (!isNaN(n)) {\n let r = (n >> 16) & 0xFF;\n let g = (n >> 8) & 0xFF;\n let b = n & 0xFF;\n return `rgb(${r},${g},${b})`;\n }\n }\n // HSB comma triple (e.g. \"35,19,100\" → h=35/360, s=19/100, b=100/100)\n let parts = str.split(\",\");\n if (parts.length === 3) {\n let h = parseInt(parts[0]) / 360.0;\n let s = parseInt(parts[1]) / 100.0;\n let b = parseInt(parts[2]) / 100.0;\n if (!isNaN(h) && !isNaN(s) && !isNaN(b)) {\n let c = HSVtoRGB(h, s, b);\n return `rgb(${c.r},${c.g},${c.b})`;\n }\n }\n // Fallback — unrecognized\n return null;\n}\n\nexport function randomColor() : string {\n let c = HSVtoRGB(Math.random(), Math.random(), 1.0);\n return `rgb(${c.r},${c.g},${c.b})`;\n}\n\n// Java Color.brighter() — factor 0.7\n// Each component: if 0 → 3; elif < 3 → 3; else min(component/0.7, 255)\nexport function brighter(col: string) : string {\n let rgb = parseRGB(col);\n if (rgb == null) return col;\n let FACTOR = 0.7;\n let threshold = Math.ceil(1.0 / (1.0 - FACTOR)); // = 4\n let r = rgb.r === 0 ? threshold : Math.min(Math.floor(rgb.r / FACTOR), 255);\n let g = rgb.g === 0 ? threshold : Math.min(Math.floor(rgb.g / FACTOR), 255);\n let b = rgb.b === 0 ? threshold : Math.min(Math.floor(rgb.b / FACTOR), 255);\n if (r < threshold) r = threshold;\n if (g < threshold) g = threshold;\n if (b < threshold) b = threshold;\n return `rgb(${r},${g},${b})`;\n}\n\n// Java Color.darker() — factor 0.7\n// Each component: floor(component * 0.7)\nexport function darker(col: string) : string {\n let rgb = parseRGB(col);\n if (rgb == null) return col;\n let FACTOR = 0.7;\n let r = Math.floor(rgb.r * FACTOR);\n let g = Math.floor(rgb.g * FACTOR);\n let b = Math.floor(rgb.b * FACTOR);\n return `rgb(${r},${g},${b})`;\n}\n\n// Keep old names as aliases for backward compatibility with index.ts\nexport function lighten(col: string) : string {\n return brighter(col);\n}\n\nexport function darken(col: string) : string {\n return darker(col);\n}\n\n// Parse an rgb(...) string or hex color into {r, g, b} components.\n// Handles: \"rgb(r,g,b)\", \"#rrggbb\", \"rrggbb\", named colors, HSB triples\nfunction parseRGB(col: string) : {r: number, g: number, b: number} | null {\n if (col == null) return null;\n // rgb(r,g,b) format\n let m = col.match(/^rgb\\((\\d+),(\\d+),(\\d+)\\)$/);\n if (m) return {r: parseInt(m[1]), g: parseInt(m[2]), b: parseInt(m[3])};\n // Named color → resolve to rgb then re-parse\n if (col in colors) return parseRGB(colors[col]);\n // #rrggbb or rrggbb hex\n let hex = col.replace(/^#/, \"\");\n if (/^[0-9a-fA-F]{6}$/.test(hex)) {\n let n = parseInt(hex, 16);\n return {r: (n >> 16) & 0xFF, g: (n >> 8) & 0xFF, b: n & 0xFF};\n }\n // HSB comma triple — parse it to get RGB\n let parts = col.split(\",\");\n if (parts.length === 3) {\n let h = parseInt(parts[0]) / 360.0;\n let s = parseInt(parts[1]) / 100.0;\n let b = parseInt(parts[2]) / 100.0;\n if (!isNaN(h) && !isNaN(s) && !isNaN(b)) {\n return HSVtoRGB(h, s, b);\n }\n }\n return null;\n}\n\n// see https://stackoverflow.com/questions/17242144/javascript-convert-hsb-hsv-color-to-rgb-accurately\nfunction HSVtoRGB(h: number, s: number, v: number) : {r: number, g: number, b: number} {\n let r: number, g: number, b: number;\n let i = Math.floor(h * 6);\n let f = h * 6 - i;\n let p = v * (1 - s);\n let q = v * (1 - f * s);\n let t = v * (1 - (1 - f) * s);\n switch (i % 6) {\n case 0: r = v; g = t; b = p; break;\n case 1: r = q; g = v; b = p; break;\n case 2: r = p; g = v; b = t; break;\n case 3: r = p; g = q; b = v; break;\n case 4: r = t; g = p; b = v; break;\n case 5: r = v; g = p; b = q; break;\n }\n return {\n r: Math.round(r * 255),\n g: Math.round(g * 255),\n b: Math.round(b * 255)\n };\n}\n","import {GeomElement} from \"./elements/GeomElement\";\nimport {PlaneElement} from \"./elements/plane/PlaneElement\";\nimport {FixedPoint} from \"./elements/point/FixedPoint\";\nimport {AllConstructions, Construction, SortedParams, constructions, getConstructionName} from \"./elements/Constructions\";\nimport {PointElement} from \"./elements/point/PointElement\";\nimport {Canvas} from \"canvas\";\nimport {LineElement} from \"./elements/line/LineElement\";\nimport {PolygonElement} from \"./elements/polygon/PolygonElement\";\nimport {CircleElement} from \"./elements/circle/CircleElement\";\nimport {ISlide, ISlideAnimation, IAnimationConfig} from \"./index\";\nimport {SlateAnimator} from \"./SlateAnimator\";\n\nexport type SlateCanvas = HTMLCanvasElement | Canvas;\n\nexport type ResolveJustification = (ref: string) => string | null | undefined;\n\nexport class Slate {\n\n protected _elements : GeomElement[];\n // Name aliases — secondary names that resolve to existing elements\n // without adding new ones to _elements. The original Geometry Applet\n // and Euclid's *Elements* refer to the same circle by every\n // permutation of its three named points (BCD ≡ CDB ≡ DBC ≡ …) and\n // to lines by either endpoint order (AB ≡ BA). Authors register\n // those equivalences here so the prose-side `{NAME}` shortcode can\n // light up the canonical element without needing a parallel\n // invisible duplicate per alias.\n private _aliases : Map<string, string> = new Map();\n // Optional slideshow walk-through; populated from init().slides.\n // Empty array means no presentation mode is available; SlateControls\n // skips the \"▶ Present\" button.\n private _slides : ISlide[] = [];\n // Consumer-supplied callback resolving a justification ref label\n // (e.g. \"I.Post.3\") to a URL. Returns null/undefined when the ref\n // isn't recognised, in which case the Presentation overlay renders\n // the ref as plain text. Undefined means no resolver was passed.\n private _resolveJustification : ResolveJustification | null = null;\n // Slide-transition animation config (rates, durations, modifiers).\n // The slate ships a default; init() merges in whatever the\n // consumer provides via IInitialization.animationConfig.\n private _animationConfig : IAnimationConfig = {};\n // The frame-driver. Lazy-created on first animateTo() so a\n // headless test slate that never animates doesn't allocate a\n // requestAnimationFrame loop.\n private _animator : SlateAnimator | null = null;\n // Ephemeral helper elements an animation can spawn for its\n // lifetime (compass arms, guide circles, straightedge bars).\n // Drawn on top of _elements in the same face → edge → vertex →\n // name order; never appear in lookupElement; cleared on\n // animator.cancel() as a safety net.\n private _ephemerals : GeomElement[] = [];\n // View transform: model (logical) coords → display px is\n // F·model + T, where F = _viewScale (uniform) and T = (_viewOffsetX,\n // _viewOffsetY). drawElements then scales by dpr to the bitmap; the\n // pick path inverts it. T centres the figure when maximized (#99/#107);\n // F shrinks the figure to fit a narrow display (#71). Defaults\n // F=1, T=(0,0) are a no-op, so every existing render path — and the\n // headless snapshot path — is bit-for-bit unchanged.\n private _viewOffsetX : number = 0;\n private _viewOffsetY : number = 0;\n private _viewScale : number = 1;\n // The construction's authored coordinate extent (logical px). Element\n // coords live here. Defaults to the canvas bitmap so the headless /\n // snapshot path has logical == display == bitmap (fit-scale 1). init()\n // overrides it with the authored size on a real DOM canvas (#71).\n private _logicalWidth : number = 0;\n private _logicalHeight : number = 0;\n // Last-dispatched highlighted-name key, so the geomlib:highlight event\n // (#108) fires only when the SET of highlighted elements changes — not\n // on every redraw frame / emphasisAmount fade.\n private _lastHighlightedKey : string = \"\u0000\";\n protected _screen : PlaneElement;\n protected _pick : PointElement;\n protected _canvas : SlateCanvas;\n private _htmlCanvas : HTMLCanvasElement = null;\n protected _bgcolor : string;\n public inTest : boolean = false;\n private static numSlate : number = 0;\n private _itsNumSlate : number = -1;\n\n constructor(canvas: SlateCanvas) {\n Slate.numSlate += 1;\n this._itsNumSlate = Slate.numSlate;\n\n this._elements = [];\n if(canvas == null) {\n throw new TypeError(\"canvas cannot be null or undefined.\");\n }\n this._canvas = canvas;\n\n let screen_origin = new FixedPoint({x:0,y:0,z:0});\n screen_origin.name = \"screen_origin\";\n let screen_x = new FixedPoint({x:1,y:0,z:0});\n screen_x.name = \"screen_x\";\n let screen_y = new FixedPoint({x:0,y:1,z:0});\n screen_y.name = \"screen_y\";\n\n let screen = new PlaneElement({\n A: screen_origin,\n B: screen_x,\n C: screen_y\n });\n screen.name = \"screen\";\n screen.nameColor = null;\n screen.isScreen = true;\n this._screen = screen;\n this._pick = null;\n\n for(let e of [screen_origin, screen_x, screen_y, screen]) {\n e.nameColor = null;\n e.vertexColor = null;\n e.vertexHighlightColor = null;\n e.faceColor = null;\n e.faceHighlightColor = null;\n this._elements.push(e);\n }\n let slate = this;\n\n let cnv : HTMLCanvasElement = this._canvas as HTMLCanvasElement;\n this._htmlCanvas = cnv;\n\n if(this._htmlCanvas.addEventListener == null) return;\n\n // Pointer Events unify mouse / touch / stylus into one event model.\n // Setting touch-action: none here (rather than relying on\n // consumer-side CSS) tells the browser not to claim drag gestures\n // for scroll/zoom; calling setPointerCapture on pointerdown ensures\n // we keep getting move/up events even when the finger leaves the\n // canvas bounds. See issue #55 for the design rationale.\n this._htmlCanvas.style.touchAction = \"none\";\n\n // Only the primary pointer drives the drag pipeline for now.\n // Multi-touch (two-finger rotation etc.) is intentionally not yet\n // wired — design questions tracked in issue #57.\n let activePointerId: number | null = null;\n\n this._htmlCanvas.addEventListener(\"pointerdown\", (ev: PointerEvent) => {\n if (activePointerId !== null) return; // already tracking a primary\n activePointerId = ev.pointerId;\n try { slate._htmlCanvas.setPointerCapture(ev.pointerId); } catch (_) { /* ignore */ }\n let [x, y] = slate._getCanvasPosition(ev.clientX, ev.clientY);\n slate._onMouseDown(x, y);\n });\n\n this._htmlCanvas.addEventListener(\"pointermove\", (ev: PointerEvent) => {\n if (ev.pointerId !== activePointerId) return;\n let [x, y] = slate._getCanvasPosition(ev.clientX, ev.clientY);\n slate._onMouseDrag(x, y);\n });\n\n let endPointer = (ev: PointerEvent) => {\n if (ev.pointerId !== activePointerId) return;\n let [x, y] = slate._getCanvasPosition(ev.clientX, ev.clientY);\n slate._onMouseUp(x, y);\n try { slate._htmlCanvas.releasePointerCapture(ev.pointerId); } catch (_) { /* ignore */ }\n activePointerId = null;\n };\n\n this._htmlCanvas.addEventListener(\"pointerup\", endPointer);\n this._htmlCanvas.addEventListener(\"pointercancel\", endPointer);\n this._htmlCanvas.addEventListener(\"lostpointercapture\", (ev: PointerEvent) => {\n if (ev.pointerId === activePointerId) {\n // Browser revoked capture (e.g., system gesture); clear pick state.\n if (slate._pick != null) {\n slate._pick = null;\n }\n activePointerId = null;\n }\n });\n\n }\n\n _getCanvasPosition(x: number, y: number) : [number, number] {\n let r = this._htmlCanvas.getBoundingClientRect();\n // Map display px → model (logical) coords: invert the view\n // transform F·model + T, so a click lands on the real element even\n // while the figure is fit-scaled (#71) or slid to centre (#99/#107).\n // getBoundingClientRect is display px; dpr never enters here.\n // F = 1, T = 0 → today's plain rect subtraction.\n const F = this._viewScale || 1;\n return [(x - r.left - this._viewOffsetX) / F,\n (y - r.top - this._viewOffsetY) / F];\n }\n\n _onMouseDown(x: number, y: number) {\n this._pick = null;\n this.movePick(x, y);\n };\n\n _onMouseUp(x: number, y: number) {\n if (this._pick == null) return;\n this.movePick(x, y);\n this._pick = null;\n };\n\n _onMouseDrag(x: number, y: number) {\n if (this._pick == null) return;\n this.movePick(x, y);\n };\n\n get elements() : GeomElement[] {\n return this._elements;\n }\n\n set bgcolor(value: string ) {\n this._bgcolor = value;\n }\n\n get bgcolor() : string {\n return this._bgcolor;\n }\n\n // Public accessor for the underlying canvas. Consumer-side code on\n // multi-canvas pages (e.g. the {NAME} shortcode on euclids-elements.org)\n // needs to compare DOM positions of each slate's canvas against the\n // prose-side <span> to pick the right slate. Was protected before\n // 0.4.0; the few prior callers (s.canvas in elem-ref-highlight.js)\n // were just reading undefined and falling through to a brute-force\n // walk of geomlib.slates.\n get canvas() : SlateCanvas {\n return this._canvas;\n }\n\n lookupElement(name: string) : GeomElement {\n for (let elem of this._elements) {\n if (elem.name == name) {\n return elem;\n }\n }\n // Direct miss — follow the alias map and look up the canonical\n // name. One hop only: we don't chase chains because aliases are\n // expected to point at real element names, not at each other.\n let canonical = this._aliases.get(name);\n if (canonical != null) {\n for (let elem of this._elements) {\n if (elem.name == canonical) return elem;\n }\n }\n return null;\n }\n\n // Register a single secondary name → canonical name mapping. Idempotent.\n // Called by init() when the user passes an `aliases` field.\n addAlias(from: string, to: string) : void {\n this._aliases.set(from, to);\n }\n\n addAliases(aliases: {[from: string]: string}) : void {\n for (let from in aliases) this._aliases.set(from, aliases[from]);\n }\n\n // Draggable elements named here are excluded from the slideshow's\n // every-slide auto-union and follow slide visible sets like any\n // other element — for proof-introduced draggables (\"Take an\n // arbitrary point F\") that shouldn't show before their moment.\n // They stay fully draggable whenever visible (#89). Populated by\n // init() from the `deferDraggables` field.\n private _deferredDraggables : Set<string> = new Set();\n\n get deferredDraggables() : Set<string> {\n return this._deferredDraggables;\n }\n\n deferDraggables(names: string[]) : void {\n for (const n of names || []) this._deferredDraggables.add(n);\n }\n\n get slides() : ISlide[] {\n return this._slides;\n }\n\n set slides(value: ISlide[]) {\n this._slides = value || [];\n }\n\n get resolveJustification() : ResolveJustification | null {\n return this._resolveJustification;\n }\n\n set resolveJustification(value: ResolveJustification | null) {\n this._resolveJustification = value;\n }\n\n get animationConfig() : IAnimationConfig {\n return this._animationConfig;\n }\n\n set animationConfig(value: IAnimationConfig) {\n this._animationConfig = value || {};\n }\n\n get animator() : SlateAnimator | null {\n return this._animator;\n }\n\n get ephemerals() : GeomElement[] {\n return this._ephemerals;\n }\n\n addEphemeral(e: GeomElement) : void {\n this._ephemerals.push(e);\n }\n\n // Register a pre-built element as a persistent (non-ephemeral) member of\n // the figure — drawn in the normal pass, addressable by name, and governed\n // by the slideshow visible-set. Used by macro animations (e.g.\n // A.Circle.compassTransfer's keepCircles) to leave named scaffolding that a\n // later slide can re-show, where addEphemeral's wipe-on-advance won't do.\n addElement(e: GeomElement) : void {\n if (this._elements.indexOf(e) === -1) this._elements.push(e);\n }\n\n removeEphemeral(e: GeomElement) : void {\n const i = this._ephemerals.indexOf(e);\n if (i >= 0) this._ephemerals.splice(i, 1);\n }\n\n clearEphemerals() : void {\n this._ephemerals.length = 0;\n }\n\n get viewOffsetX() : number { return this._viewOffsetX; }\n get viewOffsetY() : number { return this._viewOffsetY; }\n get viewScale() : number { return this._viewScale; }\n\n // Device pixel ratio (#71). The canvas BITMAP is sized to display px ×\n // dpr so drawing lands on native device pixels (crisp on HiDPI/retina).\n // Headless / no window → 1, so node-canvas rendering (and the snapshot\n // goldens) is unchanged.\n private _dpr() : number {\n return (typeof window !== \"undefined\" && window.devicePixelRatio) || 1;\n }\n\n // The authored coordinate extent (logical px) — the space element\n // coords live in. Falls back to the bitmap when unset (headless /\n // snapshot path), so logical == bitmap there. (#71)\n get logicalWidth() : number { return this._logicalWidth || this._canvas.width; }\n get logicalHeight() : number { return this._logicalHeight || this._canvas.height; }\n setLogicalSize(w: number, h: number) : void {\n if (w > 0) this._logicalWidth = w;\n if (h > 0) this._logicalHeight = h;\n }\n\n // The canvas DISPLAY size in CSS px (responsive; clientWidth on a real\n // DOM canvas, the fixed bitmap headless). The figure is fit-scaled from\n // logical → display. (#71)\n get displayWidth() : number {\n const c = this._canvas as any;\n return (typeof c.clientWidth === \"number\" && c.clientWidth) || this._canvas.width;\n }\n get displayHeight() : number {\n const c = this._canvas as any;\n return (typeof c.clientHeight === \"number\" && c.clientHeight) || this._canvas.height;\n }\n\n // Recompute the fit-scale F = min(1, display / logical): shrink the\n // figure to fit a narrow display, never grow it. Called on init/resize.\n recomputeFitScale() : void {\n const sx = this.displayWidth / this.logicalWidth;\n const sy = this.displayHeight / this.logicalHeight;\n this._viewScale = Math.min(1, sx, sy);\n }\n\n // Set the view transform's translate T (display px). drawElements\n // applies F·model + T; the pick path inverts it. (#99/#107)\n setViewOffset(x: number, y: number) : void {\n this._viewOffsetX = x;\n this._viewOffsetY = y;\n }\n\n clearViewOffset() : void {\n this._viewOffsetX = 0;\n this._viewOffsetY = 0;\n }\n\n // Axis-aligned bounding box (canvas px) of the visible figure —\n // every named, visible, non-screen element. Returns null when the\n // figure is empty. Used by cloneAside auto-place for the centre\n // target and the fit check (#99). Points/lines/polygons/circles are\n // measured exactly; sector markers sit inside their vertex (already\n // counted) so they're not separately walked.\n visibleBounds() : { minX: number, maxX: number, minY: number, maxY: number } | null {\n return this._bounds(true);\n }\n\n // Like visibleBounds() but over EVERY named, non-screen element\n // regardless of its `visible` flag — a stable bound that doesn't drift\n // as a presentation reveals/hides elements slide-to-slide. Used to\n // centre the figure in a maximized / presentation view (#107).\n figureBounds() : { minX: number, maxX: number, minY: number, maxY: number } | null {\n return this._bounds(false);\n }\n\n private _bounds(visibleOnly: boolean) : { minX: number, maxX: number, minY: number, maxY: number } | null {\n let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;\n const add = (x: number, y: number) => {\n if (x < minX) minX = x; if (x > maxX) maxX = x;\n if (y < minY) minY = y; if (y > maxY) maxY = y;\n };\n for (let elem of this._elements) {\n if (elem.name == null || elem.name.startsWith(\"screen\")) continue;\n if (visibleOnly && !elem.visible) continue;\n if (elem instanceof PolygonElement) {\n for (let v of elem.V) add(v.x, v.y);\n } else if (elem instanceof CircleElement) {\n const r = elem.radius;\n add(elem.Center.x - r, elem.Center.y - r);\n add(elem.Center.x + r, elem.Center.y + r);\n } else if (elem instanceof LineElement) {\n add(elem.A.x, elem.A.y);\n add(elem.B.x, elem.B.y);\n } else if (elem instanceof PointElement) {\n add(elem.x, elem.y);\n }\n }\n if (minX === Infinity) return null;\n return { minX, maxX, minY, maxY };\n }\n\n // All names that resolve to the element named `canonical`: the\n // element's own name plus every alias whose target is it. Used to tag\n // the geomlib:highlight event so a consumer can match a prose ref by\n // any spelling (BCD ≡ CDB ≡ DBC). (#108)\n namesFor(canonical: string) : string[] {\n const names = [canonical];\n this._aliases.forEach((target, from) => {\n if (target === canonical && from !== canonical) names.push(from);\n });\n return names;\n }\n\n // Lazy-create the animator on first use. Each slate owns at most\n // one — cancel() preserves it for re-use across slide transitions.\n private _ensureAnimator() : SlateAnimator {\n if (this._animator == null) {\n this._animator = new SlateAnimator(this);\n }\n return this._animator;\n }\n\n // Public entry point for slideshow controllers. Diff the current\n // visibility / highlight state against the target, run any slide-\n // listed animations against the elements becoming visible. Newly-\n // visible elements without an explicit animation entry pop in\n // instantly (4b parity). Returns a Promise that resolves when the\n // animator completes the run or cancel() is called.\n animateTo(\n targetVisible: Set<string>,\n targetHighlighted: Set<string>,\n slideAnimations: ISlideAnimation[],\n mode: \"cascade\" | \"parallel\",\n ) : Promise<void> {\n return this._ensureAnimator().run(\n targetVisible, targetHighlighted, slideAnimations, mode,\n );\n }\n\n // Hide every named element whose name is not in the supplied set.\n // Names not matching any element are silently ignored; elements\n // without a name (intermediate construction outputs) are left alone.\n // Screen-helper elements (screen / screen_origin / screen_x /\n // screen_y) follow the same rule: their visible flag does flip, but\n // since they're created with all-null colours they never draw\n // visible pixels anyway. Called by the presentation overlay per\n // slide; consumers can call directly too.\n setVisibleNames(names: string[]) : void {\n const visible = new Set(names);\n for (let elem of this._elements) {\n if (elem.name == null) continue;\n elem.visible = visible.has(elem.name);\n }\n }\n\n // Names of elements that start hidden (angle markers by default, or\n // anything in init's `initiallyHidden`). clearVisibility restores to\n // this baseline rather than blanket-true, so hidden elements stay\n // hidden after a presentation walk. (#100)\n private _initiallyHidden : Set<string> = new Set();\n\n get initiallyHidden() : Set<string> {\n return this._initiallyHidden;\n }\n\n // Mark a named element hidden in the initial figure: flips its\n // visible flag off now and remembers it for clearVisibility.\n setInitiallyHidden(name: string) : void {\n if (name == null) return;\n this._initiallyHidden.add(name);\n const elem = this.lookupElement(name);\n if (elem != null) elem.visible = false;\n }\n\n // Restore every element's visible flag to its initial baseline —\n // true, except names registered as initially hidden. Counterpart to\n // setVisibleNames; called on presentation exit so the canvas\n // returns to its inline default.\n clearVisibility() : void {\n for (let elem of this._elements) {\n elem.visible = !(elem.name != null && this._initiallyHidden.has(elem.name));\n }\n }\n\n // Sort params into P[] (points), E[] (other elements), N[] (integers),\n // matching Java's selectDataChoice (Slate.java lines 344-393).\n // LineElements are expanded into their two endpoint PointElements, unless\n // the target construction opts out (keepLineElements — e.g. curvedTriangle/\n // curvedPolygon take a line intact as a straight-side carrier).\n convertParams(params: any[], keepLineElements: boolean = false) : SortedParams {\n let P: PointElement[] = [];\n let E: GeomElement[] = [];\n let N: number[] = [];\n for(let param of params) {\n switch(typeof(param)) {\n case \"string\":\n let g : GeomElement = this.lookupElement(param);\n if ( g == null )\n throw new TypeError(`Element with name ${param} not found.`);\n if (g instanceof PointElement) {\n P.push(g);\n } else if (g instanceof LineElement && !keepLineElements) {\n // LineElement expands to two PointElements (matching Java)\n P.push(g.A);\n P.push(g.B);\n } else {\n E.push(g);\n }\n break;\n case \"number\":\n N.push(param);\n break;\n default:\n throw new TypeError(\"Expecting only named elements (strings) or numbers.\");\n }\n }\n return {P, E, N};\n }\n\n findConstruction(cm : AllConstructions, sp: SortedParams) : Construction {\n for(let c of constructions) {\n if(c.validateSignature(cm, sp)) {\n return c;\n }\n }\n return null;\n }\n\n createElement(cm : AllConstructions, params: any[], name?: string) : GeomElement {\n // A construction for this method may want LineElement params kept\n // intact (not expanded to endpoints) — see Construction.keepsLineElements.\n let keepLines = constructions.some(c => c.constructionMethod === cm && c.keepsLineElements);\n let sp : SortedParams = this.convertParams(params, keepLines);\n let c : Construction = this.findConstruction(cm, sp);\n if(c == null) {\n let cName : String = getConstructionName(cm);\n if (name == null) {\n name = \"\";\n }\n throw new TypeError(`Construction not found for \"${name}\" ${cName} with params P=[${sp.P}] E=[${sp.E}] N=[${sp.N}]`);\n }\n let [gs, g] = c.construct(this._screen, sp.P, sp.E, sp.N);\n // Mark as preexisting if this element was already in _elements\n // before this construction (e.g., point;first returns an existing\n // PointElement). Preexisting elements are skipped during\n // rotate/translate to avoid double-movement.\n // (Java: Slate.java preexists[] array)\n if (this._elements.indexOf(g) !== -1) {\n g.preexists = true;\n }\n if(name != null)\n g.name = name;\n for (let elem of gs) {\n if (this._elements.indexOf(elem) == -1)\n this._elements.push(elem);\n }\n if(this._elements.indexOf(g) == -1)\n this._elements.push(g);\n return g;\n }\n\n reset() : void {\n for (let element of this._elements) {\n element.reset();\n }\n this.update();\n }\n\n update() : void {\n for(let element of this._elements) element.update();\n this.drawElements();\n }\n\n drawElements(): void {\n if(this.inTest) return;\n let ctx : CanvasRenderingContext2D = this._canvas.getContext(\"2d\") as CanvasRenderingContext2D;\n // View transform (#71/#99/#107): model (logical) coords map to\n // device px as dpr·(F·model + T), where F = _viewScale (fit) and\n // T = view offset (centre). Clear + background fill cover the whole\n // bitmap under identity; the figure + ephemerals then draw under the\n // model→device transform. Headless dpr=1, F=1, T=0 → identity, so\n // node-canvas rendering (and every snapshot golden) is unchanged.\n const dpr = this._dpr(), F = this._viewScale;\n const tx = this._viewOffsetX, ty = this._viewOffsetY;\n // Keep decorations (labels, dots, line widths) a constant on-screen\n // size while the geometry is fit-scaled by F (#71). 1/F ≥ 1; F=1 → 1.\n GeomElement.styleScale = F > 0 ? 1 / F : 1;\n ctx.setTransform(1, 0, 0, 1, 0, 0);\n ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);\n ctx.fillStyle = this._bgcolor;\n ctx.fillRect(0, 0, this._canvas.width, this._canvas.height);\n ctx.setTransform(dpr * F, 0, 0, dpr * F, dpr * tx, dpr * ty);\n for(let element of this._elements) element.drawFace(this._canvas);\n for(let element of this._elements) element.drawEdge(this._canvas);\n for(let element of this._elements) element.drawVertex(this._canvas);\n // and then draw their names.\n for(let element of this._elements)\n element.drawName(this._canvas);\n // Ephemeral animation helpers render on top of the permanent\n // figure (compass arms, guide circles, straightedge bars).\n // Same face → edge → vertex → name pass order so a guide arc\n // overlays correctly without re-clearing the canvas.\n for(let e of this._ephemerals) e.drawFace(this._canvas);\n for(let e of this._ephemerals) e.drawEdge(this._canvas);\n for(let e of this._ephemerals) e.drawVertex(this._canvas);\n for(let e of this._ephemerals) e.drawName(this._canvas);\n ctx.setTransform(1, 0, 0, 1, 0, 0); // reset so nothing leaks\n GeomElement.styleScale = 1;\n this._dispatchHighlightChange();\n }\n\n // #108 — bidirectional highlight binding. After each real draw, if the\n // SET of highlighted elements (shouldHighlight || emphasized — the\n // boolean intent, ignoring the fading emphasisAmount) has changed,\n // emit a `geomlib:highlight` CustomEvent on the canvas so a consuming\n // page can light up every textual reference to those elements. The\n // event carries each element's canonical name + all its aliases. Fires\n // on any highlight source (prose-ref hover, slide `highlighted`) since\n // it lives in the shared redraw path; idempotent (no re-emit on an\n // unchanged set → no feedback loop). No-op when the canvas can't\n // dispatch DOM events (node-canvas in tests).\n private _dispatchHighlightChange() : void {\n const names: string[] = [];\n for (let elem of this._elements) {\n if (elem.name == null || elem.name.startsWith(\"screen\")) continue;\n if (elem.shouldHighlight || elem.emphasized) names.push(elem.name);\n }\n const key = names.sort().join(\"|\");\n if (key === this._lastHighlightedKey) return;\n this._lastHighlightedKey = key;\n const canvas: any = this._canvas;\n if (!canvas || typeof canvas.dispatchEvent !== \"function\"\n || typeof CustomEvent !== \"function\") return;\n const highlighted = names.map(n => ({ name: n, aliases: this.namesFor(n) }));\n canvas.dispatchEvent(new CustomEvent(\"geomlib:highlight\", {\n bubbles: true,\n detail: { highlighted },\n }));\n }\n\n // Update coordinates starting with element[i+1], matching Java's\n // Slate.java updateCoordinates (lines 808-814). Only elements AFTER\n // the picked element are recomputed — elements before it are left\n // untouched to avoid reprojection artifacts after rotation.\n updateCoordinates(i : number) {\n for(++i; i < this._elements.length; i++) {\n if(!this._elements[i].defined())\n this._elements[i].reset();\n this._elements[i].update();\n }\n this.drawElements();\n }\n\n translateCoordinates(dx : number, dy: number) {\n // translate all non-preexisting elements\n // (Java: Slate.java line 819 — if (!preexists[i]) element[i].translate(...))\n for(let i = 0; i < this._elements.length; i++) {\n let elem = this._elements[i];\n if (!elem.preexists)\n elem.translate(dx, dy);\n }\n this.update();\n }\n\n closestVisiblePoint(elements : GeomElement[], p : PointElement, tolerance : number = 30) : PointElement {\n // Use 2D screen distance (x,y only, ignoring z) for picking,\n // matching the Java applet's movePick() at Slate.java:887-889.\n // The canvas is a 2D projection; a 3D point at (x,y,z) renders\n // at screen position (x,y) regardless of z.\n let screenDist2 = (a: PointElement, b: PointElement) =>\n (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);\n let sortedDistanceElements = elements\n .filter(e => e instanceof PointElement)\n .map(e => e as PointElement)\n .filter(e => e.vertexColor != null)\n .sort((a,b) => {\n let adcp = screenDist2(a, p);\n let bdcp = screenDist2(b, p);\n if(adcp < bdcp) {\n return -1;\n } else if (bdcp < adcp) {\n return 1;\n }\n return 0;\n });\n if (sortedDistanceElements.length == 0) return null;\n let bestDistPoint = sortedDistanceElements[0];\n if(Math.sqrt(screenDist2(bestDistPoint, p)) > tolerance) return null;\n return bestDistPoint;\n }\n\n private _getPick(c: number, d: number) : PointElement {\n if (this._pick != null) return this._pick;\n let currentPoint = new PointElement({x:c,y:d});\n let closestVisiblePoint = this.closestVisiblePoint(this._elements, currentPoint);\n if(closestVisiblePoint == null) return;\n this._pick = closestVisiblePoint;\n return this._pick;\n }\n\n // Set the pivot point for scene rotation.\n // Format: \"pointName\" or \"pointName,planeName\"\n // Without a plane, the pivot is set on the screen plane.\n // With a plane, the pivot is set on that plane (for 3D rotation).\n // (Java: Slate.java setPivot, lines 787-801)\n setPivot(param : string) : void {\n let parts = param.split(\",\");\n let pointName = parts[0].trim();\n let e : GeomElement = this.lookupElement(pointName);\n if (e == null || !(e instanceof PointElement)) return;\n let piv : PointElement = e as PointElement;\n\n if (parts.length > 1) {\n // \"A,xyplane\" — set pivot on a specific plane\n let planeName = parts[1].trim();\n let p : GeomElement = this.lookupElement(planeName);\n if (p == null || !(p instanceof PlaneElement)) return;\n (p as PlaneElement).pivot = piv;\n } else {\n // \"A\" — set pivot on screen plane\n piv._AP = this._screen;\n this._screen.pivot = piv;\n }\n }\n\n movePick(c: number, d: number) : void {\n if(this._getPick(c, d) == null) return;\n let picki = this._elements.indexOf(this._pick);\n\n // Clamp the drag to the on-screen region in MODEL coords. Under the\n // view transform F·model + T, the display spans model\n // [−T/F, (display − T)/F] — so the fit-scale (#71) and centre offset\n // (#99/#107) both shift/scale the bounds. F=1, T=0 → [0, display].\n const F = this._viewScale || 1;\n let ox = this._viewOffsetX, oy = this._viewOffsetY;\n let loX = -ox / F, hiX = (this.displayWidth - ox) / F;\n if (c < loX) c = loX; else if (c > hiX) c = hiX;\n let loY = -oy / F, hiY = (this.displayHeight - oy) / F;\n if (d < loY) d = loY; else if (d > hiY) d = hiY;\n if (Math.abs(c - this._pick.x) + Math.abs(d - this._pick.y) < 1.0) {\n return; // no motion\n }\n if ( this._pick.draggable ) {\n if(this._pick.drag(c,d)) {\n this.updateCoordinates(picki);\n } else {\n return;\n }\n } else if (this._pick.AP != null \n && this._pick.AP.pivot != null\n && this._pick.AP.pivot != this._pick) { // rotate around the pivot\n this.rotateCoordinates(c,d);\n } else {\n let dx = c - this._pick.x;\n let dy = d - this._pick.y;\n this.translateCoordinates(dx,dy);\n }\n this.drawElements();\n }\n\n rotateCoordinates(c : number, d : number) : void {\n // rotate space according to how pick goes around pivot in the plane\n let pick : PointElement = this._pick;\n let piv : PointElement = pick.AP.pivot;\n // compute old and new pick's 3D coordinates relative to the pivot\n let oldP : PointElement = PointElement.difference(pick,piv);\n let newx : number = c-piv.x;\n let newy : number = d-piv.y;\t\t//(newz is irrelevant)\n // find their 2D coordinates on the plane\n let S : PointElement = pick.AP.S;\n let T : PointElement = pick.AP.T;\n let olds : number = PointElement.dot(oldP,S);\n let oldt : number = PointElement.dot(oldP,T);\n let den : number = S.x * T.y - S.y * T.x;\n let news : number = (newx*T.y - newy*T.x)/den;\n let newt : number = (newy*S.x - newx*S.y)/den;\n // compute the scale&rotation factors\n den = olds*olds + oldt*oldt;\n let ac : number = (news*olds + newt*oldt)/den;\n let as : number = (newt*olds - news*oldt)/den;\n // Rotate all non-preexisting elements directly.\n // (Java: Slate.java line 843-845)\n for (let elem of this._elements) {\n if (!elem.preexists)\n elem.rotate(piv, ac, as);\n }\n // After direct rotation, recompute derived elements from their (now\n // rotated) parents. Java doesn't need this because element[] carries\n // duplicate entries for shared objects — a Layoff created by\n // line;extend and re-referenced by point;last appears at two indices,\n // one with preexists=false that gets rotated directly. TS dedupes\n // _elements, so a shared object marked preexists=true is skipped,\n // which means Layoff-style points backed by bare LineElement wrappers\n // would never get moved directly (bare LineElement.rotate is a no-op).\n // Running update() rebuilds them from their (rotated) parents, which\n // produces the same result because rotation is a linear operation\n // and Layoff.update() derives its position from parent coords.\n this.update();\n }\n\n}\n","// Slide-transition animator. Drives Animation.build() steps over\n// time via requestAnimationFrame, calling slate.drawElements() each\n// frame so the per-element drawProgress drives the partial geometry.\n// Cascade mode plays one step at a time in slide order; parallel\n// mode runs them all concurrently.\n//\n// Owned lazily by a Slate (created on first animateTo() call) and\n// reused across transitions; cancel() resolves the in-flight promise\n// and finalises every active step so a rapid Next/Prev sequence\n// preempts the previous animation cleanly.\n\nimport {Slate} from \"./Slate\";\nimport {findAnimation, IAnimationStep, Animation} from \"./elements/Animations\";\nimport {GeomElement} from \"./elements/GeomElement\";\nimport {ISlideAnimation} from \"./index\";\n\n// Wrapped step with mutable progress state. The animator manages\n// these; concrete Animations don't see them.\ninterface ActiveStep {\n step: IAnimationStep;\n elapsedMs: number;\n started: boolean;\n finalised: boolean;\n}\n\n// Wrapped per-target group of steps. Each ISlideAnimation entry maps\n// to one Group, and Animation.build() returns the inner step list.\n// Cascade mode runs groups in order; within a group, steps are always\n// sequential (an Animation that wants edge-then-fade returns 2 steps).\ninterface ActiveGroup {\n target: GeomElement;\n steps: ActiveStep[];\n currentIndex: number; // which step is in flight; advances as each finalises\n finishedAtMs?: number; // when the last step finalised (for cascadeGapMs pacing)\n}\n\n// Time source: performance.now() when available (monotonic, high-res,\n// unaffected by NTP adjustments and not subject to wall-clock skew).\n// Falls back to Date.now() in headless environments without\n// performance.now(). dt is computed from the diff between consecutive\n// frames and clamped (see MAX_DT_MS) so background-tab pauses or\n// long single-frame stalls don't cause the next frame to advance by\n// a multi-second jump — hardware with different refresh rates\n// (60 Hz / 120 Hz / 144 Hz) all see the same total wall-clock\n// duration because progress is dt-driven, not frame-count driven.\nconst HAS_RAF = (typeof requestAnimationFrame === \"function\");\nconst NOW: () => number = (typeof performance !== \"undefined\" && performance.now)\n ? () => performance.now()\n : () => Date.now();\n// Clamp per-frame dt. Prevents a backgrounded tab's accumulated\n// pause-time from collapsing an entire animation into one frame on\n// resume; also smooths very long single-frame stalls (e.g. GC pause).\n// 100 ms = 6 frames at 60 Hz worth of catch-up — enough for normal\n// jitter, small enough that a hidden tab resuming after 30 s doesn't\n// blink through 30 s of construction in one paint.\nconst MAX_DT_MS = 100;\n\n// Duration of the post-animation emphasis fade-out. Trims the visible\n// \"snap from 6 px to highlight thickness\" into a smooth taper so the\n// settle isn't jarring when the underlying element is also slide-\n// highlighted (the polygon ABC over the highlighted AB / AC / BC is\n// the canonical case).\nconst EMPHASIS_FADE_OUT_MS = 250;\n\nexport class SlateAnimator {\n private slate: Slate;\n // The currently-running set of groups. Empty when idle.\n private groups: ActiveGroup[] = [];\n private mode: \"cascade\" | \"parallel\" = \"cascade\";\n private resolveCurrent: (() => void) | null = null;\n // For cascade, this index points at the group currently playing.\n private cascadeIndex: number = 0;\n private rafId: number | null = null;\n private lastFrameMs: number = 0;\n // Emphasis fade-out phase tracking. After every group's last step\n // finalises, the animator enters this phase and ticks each target's\n // emphasisAmount from 1 → 0 over EMPHASIS_FADE_OUT_MS before\n // resolving the promise.\n private fadingOut: boolean = false;\n private fadeStartMs: number = 0;\n\n constructor(slate: Slate) {\n this.slate = slate;\n }\n\n // Public entry point. Cancels any in-flight run, computes the\n // diff between current state and the target, builds steps for\n // every slide-listed animation, kicks off the rAF loop, and\n // returns a promise that resolves when every step has finalised\n // (or cancel() is called).\n run(\n targetVisible: Set<string>,\n targetHighlighted: Set<string>,\n slideAnimations: ISlideAnimation[],\n mode: \"cascade\" | \"parallel\",\n ): Promise<void> {\n // Preempt any in-flight run so the new transition starts cleanly.\n if (this.groups.length > 0) this.cancel();\n\n // Build the new groups from the slide's animation list, in\n // array order. Newly-visible elements without an explicit\n // animation entry pop in instantly (4b parity) — handled by\n // the caller before invoking run().\n const groups: ActiveGroup[] = [];\n const config = this.slate.animationConfig || {};\n const speedMul = config.speedMultiplier != null ? config.speedMultiplier : 1;\n const reduced = config.reducedMotion === true || speedMul === 0;\n for (const entry of slideAnimations || []) {\n const target = this.slate.lookupElement(entry.elem);\n if (target == null) continue;\n const animation: Animation | null = findAnimation(entry.name);\n if (animation == null) continue;\n // Type guard: console.warn-and-skip when the animation's\n // elementType doesn't match the actual target class.\n if (!(target instanceof (animation.elementType as any))) {\n if (typeof console !== \"undefined\" && console.warn) {\n console.warn(\n \"[geomlib] animation '\" + animation.name +\n \"' targets \" + (animation.elementType as any).name +\n \" but element '\" + entry.elem + \"' is \" +\n (target.constructor as any).name +\n \" — falling back to instant\"\n );\n }\n target.drawProgress = 1;\n target.visible = true;\n continue;\n }\n const builtSteps: IAnimationStep[] = animation.build(target, this.slate, entry.args || {}) || [];\n // Compute each step's resolved duration per the precedence\n // chain: entry.durationMs > config.durations[name] >\n // config.rates[name] > step.durationMs (already populated\n // by build() from the animation's defaults).\n const resolvedSteps: ActiveStep[] = builtSteps.map(step => ({\n step: {\n ...step,\n durationMs: resolveDuration(\n step.durationMs,\n entry.durationMs,\n config.durations && config.durations[animation.name],\n ),\n },\n elapsedMs: 0,\n started: false,\n finalised: false,\n }));\n groups.push({ target, steps: resolvedSteps, currentIndex: 0 });\n }\n\n // Visibility / highlight target state always applies — the\n // animation only governs HOW newly-visible elements appear.\n // Apply hidden / highlighted state synchronously; visible flips\n // are deferred for elements being animated because their setup\n // hook decides what to do with them.\n const animatedTargets = new Set<GeomElement>(groups.map(g => g.target));\n for (const e of this.slate.elements) {\n if (e.name == null) continue;\n const willBeVisible = targetVisible.has(e.name);\n const willBeHighlighted = targetHighlighted.has(e.name);\n if (animatedTargets.has(e)) {\n // Animation owns the visible flag during its run.\n // Deferred reveal (#83): the target stays hidden until\n // its own first step starts — drawProgress only gates\n // the edge, so a pre-revealed target would render its\n // face fill and name label at full strength while\n // earlier cascade steps play. _startStep flips it\n // visible; finalise() restores the final state on\n // every exit path.\n e.shouldHighlight = willBeHighlighted;\n e.drawProgress = 0;\n e.visible = false;\n } else {\n // Instant flip — matches 4b behaviour.\n e.visible = willBeVisible;\n e.shouldHighlight = willBeHighlighted;\n e.drawProgress = 1;\n }\n }\n\n // Reduced motion / speedMultiplier 0 / no groups: fast path.\n // Finalise everything synchronously and return a resolved\n // promise so the controller can flip the caption immediately.\n if (reduced || groups.length === 0) {\n for (const g of groups) {\n for (const as of g.steps) {\n if (as.step.setup && !as.started) as.step.setup();\n as.step.finalise();\n as.finalised = true;\n }\n }\n // Don't blanket-clear ephemerals here: normal (animated)\n // completion never does, and transient helpers self-remove in\n // their own finalise() (e.g. superpose). Clearing would wipe an\n // animation's *persisted* ephemerals (a cloneAside case-variant\n // copy) for reduced-motion users only — #99.\n this.slate.drawElements();\n return Promise.resolve();\n }\n\n // NOTE: targets are emphasised in _startStep when their own step\n // begins (not here at run start), so an un-started cascade target\n // stays hidden until its turn — otherwise, since #100, a\n // hidden-but-emphasised target would draw fully from t=0 (#104).\n // The emphasis still makes the target's render pop over any\n // slide-highlighted siblings throughout its own animation.\n\n this.groups = groups;\n this.mode = mode;\n this.cascadeIndex = 0;\n this.lastFrameMs = NOW();\n return new Promise<void>(resolve => {\n this.resolveCurrent = resolve;\n this._kickoff();\n this._scheduleFrame();\n });\n }\n\n // Drop the during-animation emphasis bumps from every group target.\n // Called once on completion or cancel so the slide settles back\n // into its plain highlight / not-highlighted steady state.\n private _clearAnimatedEmphasis(): void {\n for (const g of this.groups) {\n g.target.emphasized = false;\n }\n }\n\n // Cancel any in-flight run: finalise every step that started, wipe\n // ephemerals as a safety net, resolve the pending promise.\n cancel(): void {\n if (this.groups.length === 0) return;\n for (const g of this.groups) {\n for (let i = 0; i < g.steps.length; i++) {\n const as = g.steps[i];\n if (as.finalised) continue;\n // Run setup if we never got to it, so finalise sees a\n // consistent post-setup state.\n if (as.step.setup && !as.started) {\n as.step.setup();\n as.started = true;\n }\n as.step.finalise();\n as.finalised = true;\n }\n }\n this._clearAnimatedEmphasis();\n this.slate.clearEphemerals();\n this.slate.drawElements();\n this.groups = [];\n this.fadingOut = false;\n if (this.rafId != null && typeof cancelAnimationFrame === \"function\") {\n cancelAnimationFrame(this.rafId);\n }\n this.rafId = null;\n if (this.resolveCurrent) {\n this.resolveCurrent();\n this.resolveCurrent = null;\n }\n }\n\n // Fire any pending setup() hooks for the steps that are about to\n // tick on the very first frame.\n private _kickoff(): void {\n if (this.mode === \"cascade\") {\n this._startGroupIndex(0);\n } else {\n // Parallel: start the first step of every group at once.\n for (const g of this.groups) {\n this._startStep(g, 0);\n }\n }\n }\n\n private _startGroupIndex(idx: number): void {\n if (idx >= this.groups.length) return;\n this._startStep(this.groups[idx], 0);\n }\n\n private _startStep(g: ActiveGroup, stepIdx: number): void {\n if (stepIdx >= g.steps.length) return;\n const as = g.steps[stepIdx];\n if (as.started) return;\n // Deferred reveal (#83): the target was held invisible through\n // any earlier cascade steps; it appears the moment its own\n // first step begins. The emphasis bump is applied here too (not\n // at run start) so an un-started cascade target stays hidden —\n // since #100 a hidden-but-emphasised element would otherwise\n // draw fully from t=0 (#104). setup() runs after this, so an\n // animation that hides the target to render ephemeral proxies\n // instead can still do so.\n if (stepIdx === 0) {\n g.target.visible = true;\n g.target.emphasized = true;\n }\n if (as.step.setup) as.step.setup();\n as.started = true;\n g.currentIndex = stepIdx;\n }\n\n private _scheduleFrame(): void {\n if (HAS_RAF) {\n this.rafId = requestAnimationFrame(now => this._frame(now));\n } else {\n // No rAF (tests, node): synthesize a frame ~16ms in the\n // future via setTimeout. Mocha tests stub this differently.\n const t = NOW() + 16;\n this.rafId = (setTimeout(() => this._frame(t), 16) as any);\n }\n }\n\n private _frame(nowMs: number): void {\n if (this.groups.length === 0) return;\n const config = this.slate.animationConfig || {};\n const speedMul = config.speedMultiplier != null ? config.speedMultiplier : 1;\n const cascadeGap = config.cascadeGapMs || 0;\n // Real elapsed wall-clock dt, clamped to MAX_DT_MS so a\n // backgrounded tab or long GC pause doesn't fast-forward\n // through the rest of the animation in a single frame.\n let rawDt = nowMs - this.lastFrameMs;\n if (rawDt < 0) rawDt = 0;\n if (rawDt > MAX_DT_MS) rawDt = MAX_DT_MS;\n const dt = rawDt * speedMul;\n this.lastFrameMs = nowMs;\n\n // Advance the active step(s).\n if (this.mode === \"cascade\") {\n this._tickCascade(dt, nowMs, cascadeGap);\n } else {\n this._tickParallel(dt, nowMs);\n }\n\n // Always redraw so partial geometry shows up. Ephemerals\n // drawn alongside permanent elements.\n this.slate.drawElements();\n\n // Once every step's tick has finalised, enter the fade-out\n // phase: tick each target's emphasisAmount from 1 → 0 over\n // EMPHASIS_FADE_OUT_MS, redrawing each frame. Only resolves\n // once the fade completes.\n if (this._allFinalised()) {\n if (!this.fadingOut) {\n this.fadingOut = true;\n this.fadeStartMs = nowMs;\n }\n const fadeElapsed = nowMs - this.fadeStartMs;\n const fp = fadeElapsed >= EMPHASIS_FADE_OUT_MS\n ? 1 : fadeElapsed / EMPHASIS_FADE_OUT_MS;\n const ea = 1 - fp;\n for (const g of this.groups) {\n g.target.emphasisAmount = ea;\n }\n this.slate.drawElements();\n if (fp >= 1) {\n this._clearAnimatedEmphasis();\n this.groups = [];\n this.fadingOut = false;\n this.rafId = null;\n if (this.resolveCurrent) {\n this.resolveCurrent();\n this.resolveCurrent = null;\n }\n return;\n }\n this._scheduleFrame();\n return;\n }\n this._scheduleFrame();\n }\n\n private _tickCascade(dt: number, nowMs: number, cascadeGap: number): void {\n // Advance the current cascade group's current step. When it\n // finalises, optionally wait cascadeGapMs before advancing\n // either to the next step in the same group or to the next\n // group's first step.\n while (this.cascadeIndex < this.groups.length) {\n const g = this.groups[this.cascadeIndex];\n const as = g.steps[g.currentIndex];\n if (!as) {\n this.cascadeIndex += 1;\n if (this.cascadeIndex < this.groups.length) {\n this._startStep(this.groups[this.cascadeIndex], 0);\n }\n continue;\n }\n // Honour cascadeGap between groups.\n if (as.finalised) {\n if (g.finishedAtMs == null) g.finishedAtMs = nowMs;\n if (nowMs - g.finishedAtMs < cascadeGap) return;\n // Advance.\n if (g.currentIndex + 1 < g.steps.length) {\n this._startStep(g, g.currentIndex + 1);\n } else {\n this.cascadeIndex += 1;\n if (this.cascadeIndex < this.groups.length) {\n this._startStep(this.groups[this.cascadeIndex], 0);\n }\n }\n continue;\n }\n // Tick this step.\n this._tickStep(g.target, as, dt, nowMs);\n return; // one step per frame in cascade mode\n }\n }\n\n private _tickParallel(dt: number, nowMs: number): void {\n for (const g of this.groups) {\n const as = g.steps[g.currentIndex];\n if (!as) continue;\n if (as.finalised) {\n if (g.currentIndex + 1 < g.steps.length) {\n this._startStep(g, g.currentIndex + 1);\n }\n continue;\n }\n this._tickStep(g.target, as, dt, nowMs);\n }\n }\n\n private _tickStep(target: GeomElement, as: ActiveStep, dt: number, nowMs: number): void {\n if (!as.started) {\n if (as.step.setup) as.step.setup();\n as.started = true;\n }\n as.elapsedMs += dt;\n const total = as.step.durationMs;\n let p = total > 0 ? as.elapsedMs / total : 1;\n if (p > 1) p = 1;\n if (p < 0) p = 0;\n as.step.tick(p, dt, as.elapsedMs);\n if (p >= 1) {\n as.step.finalise();\n as.finalised = true;\n }\n }\n\n private _allFinalised(): boolean {\n for (const g of this.groups) {\n for (const as of g.steps) {\n if (!as.finalised) return false;\n }\n }\n return true;\n }\n}\n\n// Resolution order, top-down, returning the first defined non-undefined.\nfunction resolveDuration(stepDefault: number, slideOverride?: number, configOverride?: number): number {\n if (slideOverride != null) return slideOverride;\n if (configOverride != null) return configOverride;\n return stepDefault;\n}\n","/*----------------------------------------------------------------------+\n| Title: SlateControls.ts |\n| UI overlay for geometry diagrams: reset, maximize, present. |\n| Buttons are canvas-drawn icons overlaid on each Slate canvas. |\n| Keyboard shortcuts: |\n| r / space → reset |\n| m → maximize/minimize |\n| p → present (when the slate has slides) |\n+----------------------------------------------------------------------*/\n\nimport {Slate} from \"./Slate\";\nimport {computeSlideState} from \"./slideshow\";\n\ninterface IInitConfig {\n background: string;\n title: string;\n align?: number;\n canvasid?: string;\n pivot?: string;\n elements: any[];\n}\n\n// Slate-controls icon sizing. The historical default is 20 px; touch\n// devices (coarse pointer) get a slightly tighter 15-px row per author\n// preference — small enough to stay out of the diagram, still hittable\n// with a fingertip.\nfunction isCoarsePointer(): boolean {\n return typeof window !== \"undefined\"\n && typeof window.matchMedia === \"function\"\n && window.matchMedia(\"(pointer: coarse)\").matches;\n}\nconst BTN_SIZE = isCoarsePointer() ? 18 : 20;\nconst BTN_GAP = isCoarsePointer() ? 4 : 4;\nconst BTN_MARGIN = isCoarsePointer() ? 7 : 8;\n\n// #69 — keep the control buttons hidden until the canvas/wrapper is\n// hovered or focused, so a page full of diagrams isn't cluttered with a\n// button row on every one. CSS-only (`:hover` / `:focus-within`), no\n// per-frame JS; `opacity` keeps the buttons in the layout (no reflow) and\n// fades them. Injected once per document. Touch users tap the canvas\n// first, which focuses it and reveals the controls.\nconst CONTROLS_STYLE_ID = \"geomlib-controls-style\";\nfunction ensureControlsStyle(): void {\n if (typeof document === \"undefined\") return;\n if (document.getElementById(CONTROLS_STYLE_ID)) return;\n const style = document.createElement(\"style\");\n style.id = CONTROLS_STYLE_ID;\n style.textContent =\n \".geomlib-wrapper>button{opacity:0;transition:opacity .15s ease-in-out}\" +\n \".geomlib-wrapper:hover>button,.geomlib-wrapper:focus-within>button{opacity:1}\";\n (document.head || document.documentElement).appendChild(style);\n}\n\n// Minimal event-target interface so this helper is testable without a real\n// `Window`. Browser `Window`, `Document`, and `Element` all satisfy it.\nexport interface IResizeTarget {\n addEventListener(type: \"resize\", listener: () => void): void;\n removeEventListener(type: \"resize\", listener: () => void): void;\n}\n\n/**\n * Attach `callback` to the target's \"resize\" event. Returns a teardown\n * function that removes the listener — call it to stop tracking.\n */\nexport function trackWindowResize(target: IResizeTarget, callback: () => void): () => void {\n const handler = () => callback();\n target.addEventListener(\"resize\", handler);\n return () => target.removeEventListener(\"resize\", handler);\n}\n\nexport function createControls(slate: Slate, canvas: HTMLCanvasElement, config: IInitConfig): void {\n // Skip in headless/test environments\n if (!canvas.parentElement) return;\n\n let controls = new SlateControls(slate, canvas, config);\n controls.init();\n}\n\nclass SlateControls {\n private _slate: Slate;\n private _canvas: HTMLCanvasElement;\n private _config: IInitConfig;\n private _wrapper: HTMLDivElement;\n private _maximized: boolean = false;\n private _savedStyles: {\n wrapperPosition: string;\n wrapperTop: string;\n wrapperLeft: string;\n wrapperWidth: string;\n wrapperHeight: string;\n wrapperZIndex: string;\n wrapperBackground: string;\n canvasStyleWidth: string;\n canvasStyleHeight: string;\n canvasAttrWidth: number;\n canvasAttrHeight: number;\n } = null;\n private _stopTrackingResize: (() => void) | null = null;\n\n // Presentation-mode (slideshow) state. Caption + nav float over\n // the maximized canvas; no fullscreen overlay, no background takeover.\n private _presenting: boolean = false;\n private _presentationIndex: number = 0;\n private _presentationOverlay: HTMLDivElement | null = null;\n private _presentationCaption: HTMLDivElement | null = null;\n private _presentationJusts: HTMLDivElement | null = null;\n private _presentationCounter: HTMLSpanElement | null = null;\n private _presentationOnKey: ((e: KeyboardEvent) => void) | null = null;\n // Single-pin sticky for caption {NAME} refs: only one element may be\n // emphasized at a time. Clicking another ref clears the prior pin\n // before stickying the new one; hover is suppressed while a pin is\n // active so the sticky element stays the dominant one.\n private _stickyRefSpan: HTMLSpanElement | null = null;\n private _stickyRefElem: import(\"./elements/GeomElement\").GeomElement | null = null;\n\n constructor(slate: Slate, canvas: HTMLCanvasElement, config: IInitConfig) {\n this._slate = slate;\n this._canvas = canvas;\n this._config = config;\n }\n\n init(): void {\n this._wrapper = this.createWrapper();\n this.createButtons();\n this.addKeyboardShortcuts();\n // Track window resize for the lifetime of the slate (#71): an inline\n // responsive canvas (`max-width:100%`) must re-fit on orientation\n // flip / column resize, not only while maximized. resizeAndRedraw\n // re-syncs the bitmap, recomputes the fit-scale, and redraws.\n this._stopTrackingResize = trackWindowResize(window, () => this.resizeAndRedraw());\n }\n\n private createWrapper(): HTMLDivElement {\n ensureControlsStyle(); // #69 — hover/focus reveal stylesheet (once)\n let wrapper = document.createElement(\"div\");\n wrapper.className = \"geomlib-wrapper\";\n wrapper.style.position = \"relative\";\n wrapper.style.display = \"inline-block\";\n\n // Insert wrapper before canvas, then move canvas into it\n this._canvas.parentElement.insertBefore(wrapper, this._canvas);\n wrapper.appendChild(this._canvas);\n\n // Make canvas focusable for keyboard shortcuts\n this._canvas.setAttribute(\"tabindex\", \"0\");\n this._canvas.style.outline = \"none\"; // default no outline\n this._canvas.addEventListener(\"focus\", () => {\n this._canvas.style.outline = \"2px solid rgba(66,133,244,0.5)\";\n });\n this._canvas.addEventListener(\"blur\", () => {\n this._canvas.style.outline = \"none\";\n });\n\n return wrapper;\n }\n\n private createButtons(): void {\n let buttons = [\n { draw: drawResetIcon, action: () => this.onReset(), title: \"Reset (r)\" },\n { draw: drawMaximizeIcon, action: () => this.onMaximize(), title: \"Maximize (m)\" },\n ];\n\n // Conditionally append a \"▶ Present\" button when the slate\n // carries any slides. Slates without slides see the same\n // three-button row as before — backwards-compatible.\n if (this._slate.slides.length > 0) {\n buttons.push({\n draw: drawPresentIcon,\n action: () => this.onPresent(),\n title: \"Present (p)\",\n });\n }\n\n for (let i = 0; i < buttons.length; i++) {\n let btn = document.createElement(\"button\");\n btn.style.position = \"absolute\";\n btn.style.top = BTN_MARGIN + \"px\";\n btn.style.right = (BTN_MARGIN + i * (BTN_SIZE + BTN_GAP)) + \"px\";\n btn.style.width = BTN_SIZE + \"px\";\n btn.style.height = BTN_SIZE + \"px\";\n btn.style.padding = \"0\";\n btn.style.border = \"none\";\n btn.style.cursor = \"pointer\";\n btn.style.background = \"rgba(0,0,0,0.12)\";\n btn.style.borderRadius = \"3px\";\n btn.title = buttons[i].title;\n\n btn.addEventListener(\"mouseenter\", () => {\n btn.style.background = \"rgba(0,0,0,0.3)\";\n });\n btn.addEventListener(\"mouseleave\", () => {\n btn.style.background = \"rgba(0,0,0,0.12)\";\n });\n\n // Draw icon on a small canvas inside the button\n let iconCanvas = document.createElement(\"canvas\");\n iconCanvas.width = BTN_SIZE;\n iconCanvas.height = BTN_SIZE;\n iconCanvas.style.display = \"block\";\n let ctx = iconCanvas.getContext(\"2d\");\n buttons[i].draw(ctx, BTN_SIZE);\n btn.appendChild(iconCanvas);\n\n btn.addEventListener(\"click\", (e) => {\n e.stopPropagation();\n buttons[i].action();\n // Return focus to the main canvas after button click\n this._canvas.focus();\n });\n\n // Store reference for maximize icon swap\n if (i === 1) {\n (this as any)._maxBtn = btn;\n (this as any)._maxIconCanvas = iconCanvas;\n }\n\n this._wrapper.appendChild(btn);\n }\n }\n\n private addKeyboardShortcuts(): void {\n this._canvas.addEventListener(\"keydown\", (e: KeyboardEvent) => {\n switch (e.key) {\n case \"r\":\n case \"R\":\n case \" \":\n e.preventDefault();\n this.onReset();\n break;\n case \"m\":\n case \"M\":\n e.preventDefault();\n this.onMaximize();\n break;\n case \"p\":\n case \"P\":\n if (this._slate.slides.length > 0) {\n e.preventDefault();\n this.onPresent();\n }\n break;\n }\n });\n }\n\n private onReset(): void {\n this._slate.reset();\n }\n\n private onMaximize(): void {\n if (this._maximized) {\n this.minimize();\n } else {\n this.maximize();\n }\n }\n\n private maximize(): void {\n // Save current styles AND canvas width/height attributes. The attrs\n // are the canvas bitmap resolution; resizeAndRedraw() overwrites them\n // to match the maximized CSS size, so minimize() must restore them.\n this._savedStyles = {\n wrapperPosition: this._wrapper.style.position,\n wrapperTop: this._wrapper.style.top,\n wrapperLeft: this._wrapper.style.left,\n wrapperWidth: this._wrapper.style.width,\n wrapperHeight: this._wrapper.style.height,\n wrapperZIndex: this._wrapper.style.zIndex,\n wrapperBackground: this._wrapper.style.background,\n canvasStyleWidth: this._canvas.style.width,\n canvasStyleHeight: this._canvas.style.height,\n canvasAttrWidth: this._canvas.width,\n canvasAttrHeight: this._canvas.height,\n };\n\n // Maximize wrapper to fill viewport\n this._wrapper.style.position = \"fixed\";\n this._wrapper.style.top = \"0\";\n this._wrapper.style.left = \"0\";\n this._wrapper.style.width = \"100vw\";\n this._wrapper.style.height = \"100vh\";\n this._wrapper.style.zIndex = \"9999\";\n this._wrapper.style.background = \"white\";\n\n // Expand canvas to fill wrapper\n this._canvas.style.width = \"100%\";\n this._canvas.style.height = \"100%\";\n\n // Set the flag BEFORE resizeAndRedraw so its centring pass (#107)\n // sees the maximized state and slides the figure to centre.\n this._maximized = true;\n this.resizeAndRedraw();\n this.updateMaximizeIcon();\n // Window-resize tracking is persistent (set up in init), so the\n // maximized 100vw × 100vh canvas already re-syncs on viewport change.\n }\n\n private minimize(): void {\n if (!this._savedStyles) return;\n // Resize tracking stays active (persistent since init) so the inline\n // canvas keeps re-fitting after we restore it.\n\n // Restore saved styles\n this._wrapper.style.position = this._savedStyles.wrapperPosition;\n this._wrapper.style.top = this._savedStyles.wrapperTop;\n this._wrapper.style.left = this._savedStyles.wrapperLeft;\n this._wrapper.style.width = this._savedStyles.wrapperWidth;\n this._wrapper.style.height = this._savedStyles.wrapperHeight;\n this._wrapper.style.zIndex = this._savedStyles.wrapperZIndex;\n this._wrapper.style.background = this._savedStyles.wrapperBackground;\n\n this._canvas.style.width = this._savedStyles.canvasStyleWidth;\n this._canvas.style.height = this._savedStyles.canvasStyleHeight;\n\n // Restore the canvas bitmap resolution to match its pre-maximize\n // intrinsic size. Without this, the canvas keeps the enlarged\n // width/height attributes from the maximize pass and (when style\n // width/height are empty) falls back to those attrs for its CSS\n // size — leaving the diagram rendered full-width.\n this._canvas.width = this._savedStyles.canvasAttrWidth;\n this._canvas.height = this._savedStyles.canvasAttrHeight;\n\n // Clear the flag BEFORE resizeAndRedraw so its centring pass (#107)\n // restores the figure to its authored position.\n this._maximized = false;\n this.resizeAndRedraw();\n this._savedStyles = null;\n this.updateMaximizeIcon();\n // Exiting the maximized view also resets the construction to its\n // authored state — same as the reset (r) control — so any dragging\n // done while maximized / presenting is undone on the way out (#107).\n this._slate.reset();\n }\n\n private resizeAndRedraw(): void {\n // Sync the canvas BITMAP to CSS size × dpr so it stays crisp on\n // HiDPI and after CSS scaling (#71). drawElements scales the context\n // by dpr; coordinates stay in CSS px.\n const dpr = (typeof window !== \"undefined\" && window.devicePixelRatio) || 1;\n let w = Math.round(this._canvas.clientWidth * dpr);\n let h = Math.round(this._canvas.clientHeight * dpr);\n if (this._canvas.width !== w || this._canvas.height !== h) {\n this._canvas.width = w;\n this._canvas.height = h;\n }\n this._slate.recomputeFitScale(); // #71 — F = min(1, display/logical)\n this._applyCentring();\n this._slate.update();\n }\n\n // #107 — when maximized (via the control or presentation), slide the\n // whole figure to the centre of the enlarged canvas; when not maximized,\n // restore the authored position (translate 0; the fit-scale handles\n // responsive sizing). Recomputed on every resize so it stays centred as\n // the window changes. figureBounds() is in logical coords, so the centre\n // target is computed in display px through the fit-scale F (#71).\n private _applyCentring(): void {\n if (!this._maximized) { this._slate.clearViewOffset(); return; }\n const b = this._slate.figureBounds();\n if (b == null) { this._slate.clearViewOffset(); return; }\n const cx = (b.minX + b.maxX) / 2, cy = (b.minY + b.maxY) / 2;\n const F = this._slate.viewScale;\n // T (display px) so F·figureCentre + T lands at the display centre.\n this._slate.setViewOffset(this._slate.displayWidth / 2 - F * cx,\n this._slate.displayHeight / 2 - F * cy);\n }\n\n private updateMaximizeIcon(): void {\n let iconCanvas = (this as any)._maxIconCanvas as HTMLCanvasElement;\n let btn = (this as any)._maxBtn as HTMLButtonElement;\n if (!iconCanvas) return;\n let ctx = iconCanvas.getContext(\"2d\");\n ctx.clearRect(0, 0, BTN_SIZE, BTN_SIZE);\n if (this._maximized) {\n drawMinimizeIcon(ctx, BTN_SIZE);\n btn.title = \"Minimize (m)\";\n } else {\n drawMaximizeIcon(ctx, BTN_SIZE);\n btn.title = \"Maximize (m)\";\n }\n }\n\n // --- Presentation mode (slideshow) ---\n //\n // Opens the slate's slides as a step-through. The canvas itself\n // takes over the viewport via the existing maximize state (no\n // separate fullscreen overlay, no black takeover) — the caption\n // and nav controls float on top of the maximized canvas.\n\n private onPresent(): void {\n if (this._presenting) return;\n if (this._slate.slides.length === 0) return;\n if (!this._maximized) this.maximize();\n // #114 — centre ONCE on entering presentation (covers the case\n // where we were already maximized, so maximize() didn't run). Slide\n // advances no longer re-centre.\n this._applyCentring();\n this.buildPresentationOverlay();\n this.bindPresentationKeys();\n this._presenting = true;\n this.showSlide(0);\n }\n\n private exitPresent(): void {\n if (!this._presenting) return;\n this.unbindPresentationKeys();\n this.clearStickyRef();\n this.removePresentationOverlay();\n // #115 — leave presentation mode but STAY in the maximized view,\n // keeping the viewer's manipulation. Only the maximize control\n // un-maximizes (and that's what resets — see minimize()). Drop the\n // parked case-variant ephemerals + the walk's highlight/visibility\n // state, but keep the current view offset (the centre set on enter)\n // and any dragged positions.\n if (this._slate.animator != null) this._slate.animator.cancel();\n this._slate.clearEphemerals();\n this._slate.clearVisibility();\n for (let e of this._slate.elements) {\n e.shouldHighlight = false;\n e.emphasized = false;\n }\n this._presenting = false;\n this._slate.update();\n }\n\n private buildPresentationOverlay(): void {\n // Floating UI panel pinned to the bottom of the viewport.\n // Uses position: fixed and attaches to documentElement so it\n // can't be clipped by any wrapper, transformed parent, or\n // scrollable container — works the same on iOS Safari,\n // Samsung Internet, Android Chrome, and desktop. Solid white\n // (no transparency) so it's never mistaken for background;\n // bright box-shadow so the boundary reads.\n const overlay = document.createElement(\"div\");\n overlay.className = \"geomlib-presentation-overlay\";\n overlay.style.position = \"fixed\";\n overlay.style.left = \"0\";\n overlay.style.right = \"0\";\n overlay.style.bottom = \"0\";\n overlay.style.margin = \"0 auto\";\n // Span the bottom of the viewport so the centred contents\n // can't render off-screen and there's nowhere for the panel\n // to \"hide\". The actual visible chrome is the inner column.\n overlay.style.maxWidth = \"100vw\";\n overlay.style.background = \"#ffffff\";\n overlay.style.color = \"#222\";\n overlay.style.borderTop = \"1px solid rgba(0,0,0,0.18)\";\n overlay.style.boxShadow = \"0 -6px 18px rgba(0,0,0,0.18)\";\n overlay.style.padding = \"12px 16px calc(12px + env(safe-area-inset-bottom, 0px))\";\n // Max possible z-index so nothing can stack above us.\n overlay.style.zIndex = \"2147483647\";\n overlay.style.fontFamily = \"Georgia, 'Times New Roman', serif\";\n overlay.style.touchAction = \"manipulation\";\n overlay.style.boxSizing = \"border-box\";\n overlay.style.textAlign = \"center\";\n\n const caption = document.createElement(\"div\");\n caption.className = \"geomlib-presentation-caption\";\n caption.style.fontSize = \"1.1rem\";\n caption.style.lineHeight = \"1.45\";\n caption.style.textAlign = \"center\";\n caption.style.marginBottom = \"6px\";\n overlay.appendChild(caption);\n\n const justs = document.createElement(\"div\");\n justs.className = \"geomlib-presentation-justs\";\n justs.style.fontSize = \"0.85rem\";\n justs.style.textAlign = \"center\";\n justs.style.opacity = \"0.85\";\n justs.style.minHeight = \"1em\";\n justs.style.marginBottom = \"10px\";\n overlay.appendChild(justs);\n\n const nav = document.createElement(\"div\");\n nav.className = \"geomlib-presentation-nav\";\n nav.style.display = \"flex\";\n nav.style.gap = \"10px\";\n nav.style.alignItems = \"center\";\n nav.style.justifyContent = \"center\";\n\n const prevBtn = makePresentationButton(\"‹ Prev\");\n const counter = document.createElement(\"span\");\n counter.className = \"geomlib-presentation-counter\";\n counter.style.minWidth = \"56px\";\n counter.style.textAlign = \"center\";\n counter.style.opacity = \"0.7\";\n counter.style.fontSize = \"0.9rem\";\n const nextBtn = makePresentationButton(\"Next ›\");\n const exitBtn = makePresentationButton(\"✕ Exit\");\n exitBtn.style.marginLeft = \"16px\";\n\n prevBtn.addEventListener(\"click\", (e) => {\n e.stopPropagation();\n this.showSlide(this._presentationIndex - 1);\n });\n nextBtn.addEventListener(\"click\", (e) => {\n e.stopPropagation();\n this.showSlide(this._presentationIndex + 1);\n });\n exitBtn.addEventListener(\"click\", (e) => {\n e.stopPropagation();\n this.exitPresent();\n });\n\n nav.appendChild(prevBtn);\n nav.appendChild(counter);\n nav.appendChild(nextBtn);\n nav.appendChild(exitBtn);\n overlay.appendChild(nav);\n\n // Append to documentElement (html) — outside body — so a\n // mobile browser's odd body sizing can't clip us.\n document.documentElement.appendChild(overlay);\n this._presentationOverlay = overlay;\n this._presentationCaption = caption;\n this._presentationJusts = justs;\n this._presentationCounter = counter;\n }\n\n private removePresentationOverlay(): void {\n if (this._presentationOverlay && this._presentationOverlay.parentNode) {\n this._presentationOverlay.parentNode.removeChild(this._presentationOverlay);\n }\n this._presentationOverlay = null;\n this._presentationCaption = null;\n this._presentationJusts = null;\n this._presentationCounter = null;\n }\n\n private bindPresentationKeys(): void {\n const handler = (e: KeyboardEvent) => {\n if (!this._presenting) return;\n switch (e.key) {\n case \"ArrowLeft\":\n e.preventDefault();\n this.showSlide(this._presentationIndex - 1);\n break;\n case \"ArrowRight\":\n case \" \":\n e.preventDefault();\n this.showSlide(this._presentationIndex + 1);\n break;\n case \"Escape\":\n e.preventDefault();\n this.exitPresent();\n break;\n }\n };\n this._presentationOnKey = handler;\n document.addEventListener(\"keydown\", handler);\n }\n\n private unbindPresentationKeys(): void {\n if (this._presentationOnKey) {\n document.removeEventListener(\"keydown\", this._presentationOnKey);\n this._presentationOnKey = null;\n }\n }\n\n private showSlide(index: number): void {\n const slides = this._slate.slides;\n if (slides.length === 0) return;\n const clamped = Math.max(0, Math.min(slides.length - 1, index));\n this._presentationIndex = clamped;\n\n const state = computeSlideState(this._slate, slides, clamped);\n // Drop any sticky pin from the previous slide — its span\n // belongs to the prior caption and is about to be replaced\n // anyway.\n this.clearStickyRef();\n // Wipe any ephemerals a prior slide left parked (e.g. a\n // translateAside case-variant clone that persisted for its\n // slide). The animated branch's animateTo→cancel also clears\n // ephemerals, but an instant transition wouldn't — so clear\n // here on every advance.\n this._slate.clearEphemerals();\n // #114 — do NOT re-centre per slide; the figure is centred once on\n // enter (onPresent / maximize) and stays put so a viewer dragging\n // mid-walk isn't yanked back. An autoPlace transition (#99) still\n // eases from the current (centred) offset out to its case layout.\n\n const slide = slides[clamped];\n const transition = slide.transition;\n const animations = transition && transition.animations;\n const mode: \"cascade\" | \"parallel\" =\n (transition && transition.mode === \"parallel\") ? \"parallel\" : \"cascade\";\n // Clear per-element emphasis on every transition so a previous\n // slide's hover state doesn't carry forward.\n for (let e of this._slate.elements) e.emphasized = false;\n\n if (animations && animations.length > 0) {\n // Animated transition — slate.animateTo flips visibility +\n // highlight per-element and runs the configured Animation\n // for each entry. Newly-visible elements without an entry\n // pop in instantly (handled inside animateTo).\n this._slate.animateTo(state.visible, state.highlighted, animations, mode);\n } else {\n // Instant transition (4b behaviour) — flip every element\n // synchronously, no rAF loop.\n for (let e of this._slate.elements) {\n if (e.name == null) continue;\n e.visible = state.visible.has(e.name);\n e.shouldHighlight = state.highlighted.has(e.name);\n e.drawProgress = 1;\n }\n this._slate.update();\n }\n\n if (this._presentationCaption) {\n this.renderCaptionText(this._presentationCaption, slide.text || \"\");\n }\n if (this._presentationCounter) {\n this._presentationCounter.textContent = (clamped + 1) + \" / \" + slides.length;\n }\n if (this._presentationJusts) {\n this._presentationJusts.innerHTML = \"\";\n const resolve = this._slate.resolveJustification;\n if (slide.justifications) {\n for (let i = 0; i < slide.justifications.length; i++) {\n if (i > 0) {\n const sep = document.createElement(\"span\");\n sep.textContent = \" · \";\n sep.style.opacity = \"0.5\";\n this._presentationJusts.appendChild(sep);\n }\n const ref = slide.justifications[i].ref;\n const url = resolve ? resolve(ref) : null;\n if (url) {\n const a = document.createElement(\"a\");\n a.href = url;\n a.textContent = ref;\n a.target = \"_blank\";\n a.rel = \"noopener\";\n a.style.color = \"#0066cc\";\n this._presentationJusts.appendChild(a);\n } else {\n const span = document.createElement(\"span\");\n span.textContent = ref;\n this._presentationJusts.appendChild(span);\n }\n }\n }\n }\n }\n\n // Parse {NAME} tokens in caption text and emit interactive bold-\n // italic spans for any that resolve to a slate element (alias\n // lookups included). Unknown / unresolved refs render as plain\n // text with the braces stripped. Hover / pointerdown toggles\n // element.emphasized so the figure picks the ref up with an\n // extra-thick gold stroke.\n //\n // Display override (#90): {DISPLAY|element} renders DISPLAY but\n // binds the highlight to `element` — for prose names that collide\n // with another element's name, e.g. \"the angle {ABC|angBint}\"\n // where the bare token would resolve to the triangle ABC.\n private renderCaptionText(host: HTMLElement, text: string): void {\n host.innerHTML = \"\";\n const re = /\\{([A-Za-z][A-Za-z0-9'\\-]*)(?:\\|([A-Za-z][A-Za-z0-9'\\-]*))?\\}/g;\n let lastIndex = 0;\n let m: RegExpExecArray | null;\n while ((m = re.exec(text)) !== null) {\n if (m.index > lastIndex) {\n host.appendChild(document.createTextNode(text.slice(lastIndex, m.index)));\n }\n const display = m[1];\n const target = m[2] != null ? m[2] : m[1];\n const elem = this._slate.lookupElement(target);\n if (elem) {\n host.appendChild(this.buildCaptionRef(display, elem));\n } else {\n // Unknown — render plain so a typo doesn't surface as\n // raw \"{XYZ}\" to the reader.\n host.appendChild(document.createTextNode(display));\n }\n lastIndex = m.index + m[0].length;\n }\n if (lastIndex < text.length) {\n host.appendChild(document.createTextNode(text.slice(lastIndex)));\n }\n }\n\n private buildCaptionRef(label: string, elem: import(\"./elements/GeomElement\").GeomElement): HTMLSpanElement {\n const span = document.createElement(\"span\");\n span.className = \"geomlib-presentation-ref\";\n span.textContent = label;\n span.style.fontWeight = \"700\";\n span.style.fontStyle = \"italic\";\n span.style.cursor = \"pointer\";\n span.style.borderBottom = \"1px dotted currentColor\";\n span.addEventListener(\"mouseenter\", () => {\n // Hover does nothing while a sticky pin is active — the\n // pinned element should remain the sole highlighted ref.\n if (this._stickyRefSpan != null) return;\n elem.emphasized = true;\n this._slate.update();\n });\n span.addEventListener(\"mouseleave\", () => {\n if (this._stickyRefSpan != null) return;\n elem.emphasized = false;\n this._slate.update();\n });\n span.addEventListener(\"pointerdown\", (e) => {\n e.preventDefault();\n e.stopPropagation();\n const wasThis = this._stickyRefSpan === span;\n this.clearStickyRef();\n if (!wasThis) this.setStickyRef(span, elem);\n this._slate.update();\n });\n return span;\n }\n\n // Drop the active sticky pin (if any): release the pinned\n // element's emphasis flag and reset the span's visual state.\n private clearStickyRef(): void {\n if (this._stickyRefSpan != null) {\n this._stickyRefSpan.classList.remove(\"active\");\n this._stickyRefSpan.style.color = \"\";\n }\n if (this._stickyRefElem != null) {\n this._stickyRefElem.emphasized = false;\n }\n this._stickyRefSpan = null;\n this._stickyRefElem = null;\n }\n\n // Pin a new sticky ref. Call clearStickyRef() first if another\n // ref is currently pinned.\n private setStickyRef(span: HTMLSpanElement, elem: import(\"./elements/GeomElement\").GeomElement): void {\n span.classList.add(\"active\");\n span.style.color = \"#b08800\";\n elem.emphasized = true;\n this._stickyRefSpan = span;\n this._stickyRefElem = elem;\n }\n}\n\n// Button styling shared by the four nav buttons in the presentation\n// overlay. Matches the soft, light visual of the surrounding panel.\nfunction makePresentationButton(label: string): HTMLButtonElement {\n const b = document.createElement(\"button\");\n b.textContent = label;\n b.style.background = \"rgba(0,0,0,0.08)\";\n b.style.color = \"#222\";\n b.style.border = \"1px solid rgba(0,0,0,0.15)\";\n b.style.borderRadius = \"4px\";\n // Min 44px tap target per Apple HIG / Material guidance; the\n // wider padding also gives Pro Max thumbs some breathing room.\n b.style.padding = \"10px 16px\";\n b.style.minHeight = \"44px\";\n b.style.cursor = \"pointer\";\n b.style.fontFamily = \"inherit\";\n b.style.fontSize = \"1rem\";\n b.style.touchAction = \"manipulation\";\n b.addEventListener(\"mouseenter\", () => { b.style.background = \"rgba(0,0,0,0.16)\"; });\n b.addEventListener(\"mouseleave\", () => { b.style.background = \"rgba(0,0,0,0.08)\"; });\n return b;\n}\n\n// --- Icon drawing functions ---\n// All draw on a size×size canvas with 3px padding\n\nfunction drawResetIcon(ctx: CanvasRenderingContext2D, size: number): void {\n let cx = size / 2;\n let cy = size / 2;\n let r = size * 0.32;\n let pad = 2;\n\n ctx.strokeStyle = \"rgba(0,0,0,0.7)\";\n ctx.fillStyle = \"rgba(0,0,0,0.7)\";\n ctx.lineWidth = 1.5;\n\n // Circular arc (270 degrees)\n ctx.beginPath();\n ctx.arc(cx, cy, r, -Math.PI * 0.5, Math.PI * 0.75);\n ctx.stroke();\n\n // Arrowhead at the end of the arc\n let endAngle = Math.PI * 0.75;\n let ax = cx + r * Math.cos(endAngle);\n let ay = cy + r * Math.sin(endAngle);\n let headLen = 4;\n let a1 = endAngle + Math.PI * 0.3;\n let a2 = endAngle + Math.PI * 0.9;\n ctx.beginPath();\n ctx.moveTo(ax, ay);\n ctx.lineTo(ax + headLen * Math.cos(a1), ay + headLen * Math.sin(a1));\n ctx.lineTo(ax + headLen * Math.cos(a2), ay + headLen * Math.sin(a2));\n ctx.closePath();\n ctx.fill();\n}\n\nfunction drawMaximizeIcon(ctx: CanvasRenderingContext2D, size: number): void {\n let pad = 4;\n let s = size - pad * 2;\n\n ctx.strokeStyle = \"rgba(0,0,0,0.7)\";\n ctx.fillStyle = \"rgba(0,0,0,0.7)\";\n ctx.lineWidth = 1.5;\n\n // Top-right outward arrow\n let ax = pad + s * 0.55;\n let ay = pad + s * 0.45;\n let bx = pad + s;\n let by = pad;\n ctx.beginPath();\n ctx.moveTo(ax, ay);\n ctx.lineTo(bx, by);\n ctx.stroke();\n // Arrowhead\n ctx.beginPath();\n ctx.moveTo(bx, by);\n ctx.lineTo(bx - 5, by);\n ctx.lineTo(bx, by + 5);\n ctx.closePath();\n ctx.fill();\n\n // Bottom-left outward arrow\n ax = pad + s * 0.45;\n ay = pad + s * 0.55;\n bx = pad;\n by = pad + s;\n ctx.beginPath();\n ctx.moveTo(ax, ay);\n ctx.lineTo(bx, by);\n ctx.stroke();\n ctx.beginPath();\n ctx.moveTo(bx, by);\n ctx.lineTo(bx + 5, by);\n ctx.lineTo(bx, by - 5);\n ctx.closePath();\n ctx.fill();\n}\n\nfunction drawMinimizeIcon(ctx: CanvasRenderingContext2D, size: number): void {\n let pad = 4;\n let s = size - pad * 2;\n\n ctx.strokeStyle = \"rgba(0,0,0,0.7)\";\n ctx.fillStyle = \"rgba(0,0,0,0.7)\";\n ctx.lineWidth = 1.5;\n\n // Top-right inward arrow\n let ax = pad + s;\n let ay = pad;\n let bx = pad + s * 0.55;\n let by = pad + s * 0.45;\n ctx.beginPath();\n ctx.moveTo(ax, ay);\n ctx.lineTo(bx, by);\n ctx.stroke();\n ctx.beginPath();\n ctx.moveTo(bx, by);\n ctx.lineTo(bx + 5, by);\n ctx.lineTo(bx, by - 5);\n ctx.closePath();\n ctx.fill();\n\n // Bottom-left inward arrow\n ax = pad;\n ay = pad + s;\n bx = pad + s * 0.45;\n by = pad + s * 0.55;\n ctx.beginPath();\n ctx.moveTo(ax, ay);\n ctx.lineTo(bx, by);\n ctx.stroke();\n ctx.beginPath();\n ctx.moveTo(bx, by);\n ctx.lineTo(bx - 5, by);\n ctx.lineTo(bx, by + 5);\n ctx.closePath();\n ctx.fill();\n}\n\nfunction drawPresentIcon(ctx: CanvasRenderingContext2D, size: number): void {\n // Right-pointing play triangle, centred. The button is square so a\n // little leftward bias visually centres the optical mass.\n let pad = size * 0.28;\n let leftX = pad - 1;\n let rightX = size - pad + 2;\n let topY = pad;\n let bottomY = size - pad;\n ctx.fillStyle = \"rgba(0,0,0,0.7)\";\n ctx.beginPath();\n ctx.moveTo(leftX, topY);\n ctx.lineTo(leftX, bottomY);\n ctx.lineTo(rightX, size / 2);\n ctx.closePath();\n ctx.fill();\n}\n","// Animation registry — parallel to Constructions but distinct purpose.\n//\n// A Construction builds an element once at init() time. An Animation\n// describes how to *reveal* that element when a slide transitions:\n// lines trace from one endpoint to the other, circles sweep an arc,\n// polygons trace edges in order then fade in the face. Multiple\n// animations can target the same element type — e.g. a Line might\n// be revealed via the shorthand A.Line.straightEdgeConnect (pencil\n// stroke A → B) or the long-form A.Line.compassTransfer (compass\n// walks a radius from another line then drops the straightedge).\n// Authors pick the right one per slide.\n//\n// Names follow the same `Type.method` shape as Constructions\n// (E.Line.connect ↔ A.Line.straightEdgeConnect). The enum value is\n// what authors pass; the human-readable name string is used for the\n// string-form fallback (param strings) + console.warn diagnostics.\n\nimport {GeomElement} from \"./GeomElement\";\nimport {Slate} from \"../Slate\";\n\n// Typed enum, parallel to AllConstructions. Numeric backing — typo-\n// safe at compile time and cheap to compare at runtime.\nexport enum AllAnimations {\n INSTANT,\n POINT_APPEAR,\n POINT_INTERSECT, // future\n POINT_SLIDE,\n LINE_STRAIGHT_EDGE_CONNECT,\n LINE_STRAIGHT_EDGE_EXTEND,\n LINE_COMPASS_TRANSFER, // future\n CIRCLE_COMPASS,\n CIRCLE_COMPASS_EXPLICIT, // future\n CIRCLE_COMPASS_TRANSFER,\n POLYGON_OUTLINE,\n POLYGON_OUTLINE_AND_FILL,\n POLYGON_SUPERPOSE,\n POLYGON_EQUILATERAL_BUILD,\n SECTOR_SWEEP,\n GROUP_CLONE_ASIDE,\n}\n\n// Typed constants object, mirroring E for constructions. Authors\n// write `A.Circle.compass` instead of remembering the raw enum.\nexport const A = {\n Point: {\n appear: AllAnimations.POINT_APPEAR,\n intersect: AllAnimations.POINT_INTERSECT, // future\n slide: AllAnimations.POINT_SLIDE,\n },\n Line: {\n straightEdgeConnect: AllAnimations.LINE_STRAIGHT_EDGE_CONNECT,\n straightEdgeExtend: AllAnimations.LINE_STRAIGHT_EDGE_EXTEND,\n compassTransfer: AllAnimations.LINE_COMPASS_TRANSFER, // future\n },\n Circle: {\n compass: AllAnimations.CIRCLE_COMPASS,\n compassExplicit: AllAnimations.CIRCLE_COMPASS_EXPLICIT, // future\n compassTransfer: AllAnimations.CIRCLE_COMPASS_TRANSFER, // I.2 (#127)\n },\n Polygon: {\n outline: AllAnimations.POLYGON_OUTLINE,\n outlineAndFill: AllAnimations.POLYGON_OUTLINE_AND_FILL,\n superpose: AllAnimations.POLYGON_SUPERPOSE,\n equilateralBuild: AllAnimations.POLYGON_EQUILATERAL_BUILD, // I.1 (#127)\n },\n Sector: {\n sweep: AllAnimations.SECTOR_SWEEP,\n },\n Group: {\n cloneAside: AllAnimations.GROUP_CLONE_ASIDE,\n },\n instant: AllAnimations.INSTANT,\n};\n\n// One frame-driven step of an animation. An Animation.build() returns\n// an array of these; the SlateAnimator drives each step's progress\n// from 0 → 1 over its durationMs, then calls finalise().\nexport interface IAnimationStep {\n durationMs: number;\n\n // Setup hook fires once before the first tick. Used to hide the\n // target element (so visual proxies can render over its final\n // position without overlap) and to register ephemeral helper\n // elements via slate.addEphemeral.\n setup?: () => void;\n\n // Called each frame with progress ∈ [0, 1]. Typically sets\n // target.drawProgress = progress; richer animations may also tick\n // ephemeral helpers.\n tick: (progress: number, dtMs: number, totalMs: number) => void;\n\n // Called on cancel, skip, or normal completion. Animations MUST:\n // 1. Remove every ephemeral helper they added.\n // 2. Restore the target element to its final visible state\n // (target.visible = true, drawProgress = 1).\n finalise: () => void;\n}\n\n// Abstract base class for all animations. Concrete subclasses live in\n// the per-element-type sibling files (PointAnimations.ts,\n// LineAnimations.ts, CircleAnimations.ts, PolygonAnimations.ts).\nexport abstract class Animation {\n // Enum value the animation registers under. Mirrors Construction's\n // `constructionMethod: AllConstructions` field shape.\n public abstract animationMethod: AllAnimations;\n\n // Human-readable name in the same `Type.method` shape Construction\n // uses (\"Line.straightEdgeConnect\", \"Circle.compass\", …).\n public abstract name: string;\n\n // Element class the animation can animate. animateTo validates\n // the target before calling build(); a mismatch emits a\n // console.warn and falls through to Instant.\n public abstract elementType: Function;\n\n // Per-animation default duration AND rate. Whichever the slate's\n // animationConfig overrides wins. Null on both means build()\n // computes its own duration from geometry × default rate.\n public defaultDurationMs?: number;\n public defaultRate?: number;\n\n public abstract build(target: GeomElement, slate: Slate, args: any): IAnimationStep[];\n}\n\n// InstantAnimation — the registry's fallback. Used explicitly via\n// A.instant on a slide entry to suppress an inherited animation, or\n// implicitly when an unknown name lookup fails. Just finalises the\n// target to its full-rendered state.\nexport class InstantAnimation extends Animation {\n public animationMethod = AllAnimations.INSTANT;\n public name = \"instant\";\n public elementType = GeomElement;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n return [{\n durationMs: 0,\n tick: () => {},\n finalise: () => {\n target.drawProgress = 1;\n target.visible = true;\n },\n }];\n }\n}\n\n// Module-level registry. Subclass files call registerAnimation(new X())\n// at import time so the registry is populated by the time any consumer\n// looks anything up.\nconst animationsByEnum: Map<AllAnimations, Animation> = new Map();\nconst animationsByName: Map<string, Animation> = new Map();\nconst warnedUnknown: Set<string> = new Set();\n\nexport function registerAnimation(a: Animation): void {\n animationsByEnum.set(a.animationMethod, a);\n animationsByName.set(a.name, a);\n}\n\n// Accepts either the enum value or the string name; returns the\n// registered Animation or null when the name doesn't resolve. An\n// unknown name emits a console.warn once per name across the slate's\n// lifetime so consumers see typos surfaced without log spam.\nexport function findAnimation(ref: AllAnimations | string): Animation | null {\n let a: Animation | undefined;\n if (typeof ref === \"string\") {\n a = animationsByName.get(ref);\n } else {\n a = animationsByEnum.get(ref);\n }\n if (a == null) {\n const key = String(ref);\n if (!warnedUnknown.has(key)) {\n warnedUnknown.add(key);\n // eslint-disable-next-line no-console\n if (typeof console !== \"undefined\" && console.warn) {\n console.warn(\"[geomlib] unknown animation '\" + key + \"' — falling back to instant\");\n }\n }\n return null;\n }\n return a ?? null;\n}\n\n// Register the always-present Instant. Concrete animations in\n// PointAnimations.ts / LineAnimations.ts / … register themselves the\n// same way when their modules are imported.\nregisterAnimation(new InstantAnimation());\n","/*----------------------------------------------------------------------+\n| Title:\tConstructions.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\nimport {GeomElement} from \"./GeomElement\";\nimport {PlaneElement} from \"./plane/PlaneElement\";\nimport {PointElement} from \"./point/PointElement\";\n\nexport enum ConstructionTypes {\n Integer,\n PointElement,\n CircleElement,\n PlaneElement,\n SphereElement,\n PolygonElement,\n PolyhedronElement\n}\n\nexport enum PointConstructions {\n free = 1,\n midpoint = 2,\n intersection = 3,\n first = 4,\n last = 5,\n center = 6,\n lineSlider = 7,\n circleSlider = 8,\n circumcenter = 9,\n vertex = 10,\n foot = 11,\n cutoff = 12,\n extend = 13,\n parallelogram = 14,\n similar = 15,\n perpendicular = 16,\n proportion = 17,\n invert = 18,\n meanProportional = 19,\n planeSlider = 20,\n sphereSlider = 21,\n angleBisector = 22,\n angleDivider = 23,\n fixed = 24,\n lineSegmentSlider = 25,\n harmonic = 26\n}\n\nexport enum LineConstructions {\n connect = 101,\n angleBisector = 102,\n angleDivider = 103,\n foot = 104,\n chord = 105,\n bichord = 106,\n perpendicular = 107,\n cutoff = 108,\n extend = 109,\n parallel = 110,\n similar = 111,\n proportion = 112,\n meanProportional = 113,\n path = 114\n}\n\n\nexport enum CircleConstructions {\n radius = 201,\n circumcircle = 202,\n invert = 203,\n intersection = 204\n}\n\n\nexport enum PolygonConstructions {\n square = 301,\n triangle = 302,\n quadrilateral = 303,\n pentagon = 304,\n hexagon = 305,\n equilateralTriangle = 306,\n parallelogram = 307,\n regularPolygon = 308,\n starPolygon = 309,\n similar = 310,\n application = 311,\n octagon = 312,\n face = 313,\n curvedTriangle = 314\n}\n\nexport enum SectorConstructions {\n sector = 401,\n arc = 402,\n angleMarker = 403,\n angleMarkerReflex = 404\n}\n\nexport enum PlaneConstructions {\n threePoints = 501,\n perpendicular = 502,\n parallel = 503,\n ambient = 504\n}\n\nexport enum SphereConstructions {\n radius = 601\n}\n\nexport enum PolyhedraConstructions {\n tetrahedron = 701,\n parallelepiped = 702,\n prism = 703,\n pyramid = 704\n}\n\nexport function getConstructionName(cm: AllConstructions) : String {\n if(cm < 100) {\n return \"Point.\" + PointConstructions[cm];\n } else if (100 < cm && cm < 200) {\n return \"Line.\" + LineConstructions[cm];\n } else if (300 < cm && cm < 400) {\n return \"Polygon.\" + PolygonConstructions[cm];\n } else if (400 < cm && cm < 500) {\n return \"Sector.\" + SectorConstructions[cm];\n } else if (500 < cm && cm < 600) {\n return \"Plane.\" + PlaneConstructions[cm];\n } else if (600 < cm && cm < 700) {\n return \"Sphere.\" + SphereConstructions[cm];\n } else if (700 < cm && cm < 800) {\n return \"Polyhedra.\" + PolyhedraConstructions[cm];\n }\n\n return \"<Not Valid Construction>\";\n}\n\nexport var E = {\n Point : PointConstructions,\n Line : LineConstructions,\n Circle: CircleConstructions,\n Polygon: PolygonConstructions,\n Sector: SectorConstructions,\n Plane: PlaneConstructions,\n Sphere: SphereConstructions,\n Polyhedra: PolyhedraConstructions\n};\n\nexport type AllConstructions =\n PointConstructions |\n LineConstructions |\n CircleConstructions |\n PlaneConstructions |\n PolygonConstructions |\n SectorConstructions |\n SphereConstructions |\n PolyhedraConstructions;\n\nexport type GeomElementsForUpdate = GeomElement[];\n\n// Type-sorted parameter arrays, matching Java's P[]/E[]/N[] dispatch.\n// P = PointElements (including LineElement endpoint expansions)\n// E = all other elements (Circle, Plane, Sphere, Polygon, Polyhedron)\n// N = integers (numbers)\nexport interface SortedParams {\n P: PointElement[];\n E: GeomElement[];\n N: number[];\n}\n\nexport interface ConstructionSignature {\n points: number;\n elements: number;\n integers: number;\n elementTypes?: Function[];\n}\n\nexport abstract class Construction {\n public abstract constructionMethod : AllConstructions;\n // Signature: type counts + element subtype list for E[] entries.\n // e.g. { points: 2, elements: 1, integers: 0, elementTypes: [PlaneElement] }\n public abstract signature: ConstructionSignature;\n\n // Normally a LineElement param is expanded to its two endpoint points\n // before dispatch (convertParams). A construction that wants a line to\n // arrive INTACT in E[] (e.g. curvedTriangle, where a line is a\n // straight-side carrier) sets this true to suppress that expansion.\n public keepsLineElements: boolean = false;\n\n public abstract construct(screen: PlaneElement, P: PointElement[],\n E: GeomElement[], N: number[]) : [GeomElementsForUpdate, GeomElement];\n\n // Match by counting types (matching Java's selectDataChoice).\n // Position-independent: \"E,Vplane,D,B\" and \"E,D,B,Vplane\" both match\n // { points: 3, elements: 1, elementTypes: [PlaneElement] }.\n public validateSignature(cm: AllConstructions, sp: SortedParams) : boolean {\n if (cm != this.constructionMethod) return false;\n let sig = this.signature;\n if (sig.points !== sp.P.length) return false;\n if (sig.elements !== sp.E.length) return false;\n if (sig.integers !== sp.N.length) return false;\n // Check element subtypes if specified\n if (sig.elementTypes) {\n for (let i = 0; i < sig.elementTypes.length; i++) {\n if (!(sp.E[i] instanceof sig.elementTypes[i])) return false;\n }\n }\n return true;\n }\n}\n\n/***********************************************************************\n * Construction classes — organized by element type. *\n * Each type's constructions live in their own package file and export *\n * a pre-built Construction[] array. *\n * *\n * Point — point/PointConstructions.ts *\n * (also contains CircumcircleConstruction) *\n * Line — line/LineConstructions.ts *\n * Circle — circle/CircleConstructions.ts *\n * Polygon — polygon/PolygonConstructions.ts *\n * Sector — sector/SectorConstructions.ts *\n * Plane — plane/PlaneConstructions.ts *\n * Sphere — sphere/SphereConstructions.ts *\n * Polyhedron — polyhedron/PolyhedronConstructions.ts *\n ***********************************************************************/\n\nimport {pointConstructions} from \"./point/PointConstructions\";\nimport {lineConstructions} from \"./line/LineConstructions\";\nimport {circleConstructions} from \"./circle/CircleConstructions\";\nimport {polygonConstructions} from \"./polygon/PolygonConstructions\";\nimport {sectorConstructions} from \"./sector/SectorConstructions\";\nimport {planeConstructions} from \"./plane/PlaneConstructions\";\nimport {sphereConstructions} from \"./sphere/SphereConstructions\";\nimport {polyhedronConstructions} from \"./polyhedron/PolyhedronConstructions\";\n\n\nexport const constructions: Construction[] = [\n ...pointConstructions,\n ...lineConstructions,\n ...circleConstructions,\n ...sectorConstructions,\n ...polygonConstructions,\n ...planeConstructions,\n ...sphereConstructions,\n ...polyhedronConstructions,\n];\n","/*----------------------------------------------------------------------+\n| Title:\tGeomElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./point/PointElement\"\nimport {SlateCanvas} from \"../Slate\";\n\nexport enum Align {\n CENTRAL,\n LEFT,\n RIGHT,\n ABOVE,\n BELOW\n}\n\nexport abstract class GeomElement {\n\n constructor() {\n }\n\n protected _name: string;\n // True for elements that are references to existing elements (e.g.,\n // point;first returns P[0], point;vertex returns polygon.V[n-1]).\n // Preexisting elements are skipped during rotate/translate to avoid\n // double-movement. Matches Java's preexists[] array in Slate.java.\n public preexists: boolean = false;\n // All colors default to null (transparent) — matching Java's Element.java.\n // Named elements get their colors assigned by init() in index.ts, which\n // computes type-appropriate defaults. Internal/intermediate elements\n // created inside constructions stay null (invisible) unless explicitly set.\n private _nameColor: string = null;\n protected _vertexColor : string = null;\n private _edgeColor : string = null;\n private _faceColor : string = null;\n\n // Highlight defaults pick high-contrast values that read on the typical\n // cream / white backgrounds the library is used against. The previous\n // edge/vertex default of white was invisible on the Elements site's\n // theorem-box background (HSB 35,19,100 ≈ #FFE9CD). Web \"gold\"\n // (#FFD700) is brighter / more saturated than Material amber and\n // still reads against both cream and white.\n private _nameHighlightColor : string = '#FFD700';\n private _vertexHighlightColor : string = '#FFD700';\n private _edgeHighlightColor : string = '#FFD700';\n private _faceHighlightColor : string = '#FFD700';\n\n // Default matches Java: Font(\"TimesRoman\", Font.ITALIC, 18)\n protected static _fontSize : number = 18;\n protected static _fontName : string = \"Times New Roman\";\n\n // Style scale (#71): when the figure is fit-scaled down to a narrow\n // display (view scale F < 1), decorations — label font, vertex dots,\n // line widths — are multiplied by 1/F so they keep a constant on-screen\n // size and stay readable while the geometry shrinks. Slate.drawElements\n // sets it from the view scale before each frame; 1 (the default, and\n // F=1 desktop/headless) leaves rendering bit-for-bit unchanged.\n static styleScale : number = 1;\n\n static setFont(fontName: string, fontSize: number): void {\n GeomElement._fontName = fontName;\n GeomElement._fontSize = fontSize;\n }\n\n // The label font, scaled by the current styleScale.\n static fontString(): string {\n return `italic ${GeomElement._fontSize * GeomElement.styleScale}px ${GeomElement._fontName}`;\n }\n\n private _draggable : boolean;\n private _dimension : number;\n private _align : Align;\n\n private _shouldHighlight : boolean = false;\n // Per-element visibility flag honoured by every draw method. Default\n // true preserves existing consumer behaviour; flipping false makes\n // drawFace / drawEdge / drawVertex / drawName early-return so the\n // element disappears without being removed from _elements (so\n // dependents that read its coordinates still work). Used by\n // Slate.setVisibleNames + the slideshow Presentation overlay.\n private _visible : boolean = true;\n // One step above shouldHighlight: when the slideshow caption's\n // {NAME} ref is hovered or clicked, the matching element flips to\n // emphasized. drawEdge / drawVertex paint with the highlight colour\n // at an even thicker stroke / larger dot so the element pops out\n // from any other already-highlighted ones on the slide. Released on\n // mouseleave (or click-to-toggle for sticky).\n // Emphasis amount in [0, 1]. Boolean emphasized is a thin shim\n // that toggles between 0 and 1; the SlateAnimator fades the\n // amount smoothly from 1 → 0 after an animation finishes so the\n // visible \"shrink back to highlight thickness\" feels less jarring\n // when the underlying element is also slide-highlighted (e.g.\n // ABC polygon edges over the highlighted AB / AC / BC).\n private _emphasisAmount : number = 0;\n // Animation progress for the next slide-transition render. 1 means\n // \"fully drawn\" (the default and the existing behaviour). Values in\n // [0, 1) tell per-type draw methods to render a partial geometry —\n // a half-traced line, a 30° sweep of an arc, the first edge of a\n // polygon plus a fraction of the next. Driven by Animation\n // subclasses through SlateAnimator during slide transitions; flips\n // back to 1 on each animation's finalise() so the canvas returns\n // to the fully-rendered state when the transition completes or is\n // cancelled.\n private _drawProgress : number = 1;\n protected _pixelTolerance : number = 50;\n\n protected _getTextMetrics(ctx: CanvasRenderingContext2D, txt: string) : [number, number] {\n let textMetrics = ctx.measureText(txt);\n let w = textMetrics.width;\n // Use actual font metrics for height; fall back to ascent-based estimate\n let h = (textMetrics.actualBoundingBoxAscent != null)\n ? textMetrics.actualBoundingBoxAscent + textMetrics.actualBoundingBoxDescent\n : 16;\n return [w, h];\n }\n\n drawString(ix : number, iy : number, c: SlateCanvas, overrideAlign? : Align) {\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n if(this._nameColor == null) return;\n ctx.font = GeomElement.fontString();\n ctx.fillStyle = this._nameColor;\n let [w, h] = this._getTextMetrics(ctx, this._name);\n\n switch (overrideAlign || this._align) {\n case Align.LEFT:\n ix = ix - w - 6;\n iy = iy + h/2 - 4;\n ctx.fillText(this._name, ix, iy);\n return;\n case Align.RIGHT:\n ix += 2;\n iy += h/2 - 4;\n ctx.fillText(this._name, ix, iy);\n return;\n case Align.ABOVE:\n ix -= w/2;\n iy += -h/2 + 4;\n ctx.fillText(this._name, ix, iy);\n return;\n case Align.BELOW:\n ix -= w/2;\n iy += h/2 + 6;\n ctx.fillText(this._name, ix, iy);\n return;\n }\n // compute (dx,dy) coordinates relative to center of canvas\n // and normalized\n let cw = c.width;\n let ch = c.height;\n let dx = (ix - cw/2) * ch;\n let dy = (iy - ch/2) * cw;\n if (dy > dx) {\n if (dy >= -dx)\t// put name below\n {\n ix -= w/2;\n iy += h/2 + 6;\n ctx.fillText(this._name, ix, iy);\n }\n else \t\t// put name left\n {\n ix = ix - w - 6;\n iy += h/2 - 4;\n ctx.fillText(this._name, ix, iy);\n }\n }\n else {\n if (dy >= -dx) {\t// put name right\n ix += 2;\n iy += h/2 - 4;\n ctx.fillText(this._name, ix, iy);\n } else { \t\t// put name above\n ix -= w/2;\n iy += -h/2 + 4;\n ctx.fillText(this._name, ix, iy);\n }\n }\n }\n\n public get name() {\n return this._name;\n }\n\n public set name(n : string) {\n this._name = n;\n }\n\n public abstract update() : void;\n public reset() { this.update(); }\n public defined() : boolean { return false; }\n public drag(tox: number, toy: number) : boolean { return false; }\n // drag returns true when the element is actually dragged\n public abstract translate(dx: number, dy: number) : void;\n public abstract rotate(pivot : PointElement, ac : number, as: number) : void;\n public abstract drawName(c: SlateCanvas) : void;\n public abstract drawFace(c: SlateCanvas) : void;\n public abstract drawEdge(c: SlateCanvas) : void;\n public abstract drawVertex(c: SlateCanvas) : void;\n\n set nameColor(value: string) {\n this._nameColor = value;\n }\n\n set edgeColor(value: string) {\n this._edgeColor = value;\n }\n\n set faceColor(value: string) {\n this._faceColor = value;\n }\n\n set nameHighlightColor(value: string) {\n this._nameHighlightColor = value;\n }\n\n set vertexHighlightColor(value: string) {\n this._vertexHighlightColor = value;\n }\n\n set edgeHighlightColor(value: string) {\n this._edgeHighlightColor = value;\n }\n\n set faceHighlightColor(value: string) {\n this._faceHighlightColor = value;\n }\n\n set draggable(value: boolean) {\n this._draggable = value;\n }\n\n set dimension(value: number) {\n this._dimension = value;\n }\n\n set align(value: Align) {\n this._align = value;\n }\n\n set shouldHighlight(value: boolean) {\n this._shouldHighlight = value;\n }\n\n set visible(value: boolean) {\n this._visible = value;\n }\n\n set emphasized(value: boolean) {\n this._emphasisAmount = value ? 1 : 0;\n }\n\n set emphasisAmount(value: number) {\n this._emphasisAmount = value < 0 ? 0 : (value > 1 ? 1 : value);\n }\n\n set drawProgress(value: number) {\n // Clamp to [0, 1] — out-of-range values would push the partial\n // geometry past either endpoint, which is never what callers\n // mean. Animations tick this in [0, 1] and finalise to 1.\n this._drawProgress = value < 0 ? 0 : (value > 1 ? 1 : value);\n }\n\n get nameColor(): string {\n return this._nameColor;\n }\n\n get vertexColor(): string {\n return this._vertexColor;\n }\n\n set vertexColor(c : string) {\n this._vertexColor = c;\n }\n\n get edgeColor(): string {\n return this._edgeColor;\n }\n\n get faceColor(): string {\n return this._faceColor;\n }\n\n get nameHighlightColor(): string {\n return this._nameHighlightColor;\n }\n\n get vertexHighlightColor(): string {\n return this._vertexHighlightColor;\n }\n\n get edgeHighlightColor(): string {\n return this._edgeHighlightColor;\n }\n\n get faceHighlightColor(): string {\n return this._faceHighlightColor;\n }\n\n get draggable(): boolean {\n return this._draggable;\n }\n\n get dimension(): number {\n return this._dimension;\n }\n\n get align(): Align {\n return this._align;\n }\n\n get shouldHighlight(): boolean {\n return this._shouldHighlight;\n }\n\n get visible(): boolean {\n return this._visible;\n }\n\n get emphasized(): boolean {\n return this._emphasisAmount > 0;\n }\n\n get emphasisAmount(): number {\n return this._emphasisAmount;\n }\n\n get drawProgress(): number {\n return this._drawProgress;\n }\n}\n","// Animations targeting CircleElement. See ../Animations.ts for the\n// abstract base + registry mechanics.\n\nimport {Animation, AllAnimations, IAnimationStep, registerAnimation} from \"../Animations\";\nimport {GeomElement} from \"../GeomElement\";\nimport {Slate} from \"../../Slate\";\nimport {CircleElement} from \"./CircleElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {LineElement} from \"../line/LineElement\";\nimport {PolygonElement} from \"../polygon/PolygonElement\";\n\n// Default sweep rate in radians/ms. Calibrated for unhurried teaching:\n// a full circle (2π) draws in ≈ 2 seconds at 0.003 rad/ms. Authors who\n// want a faster compass raise the rate via\n// slate.animationConfig.rates[\"Circle.compass\"].\nconst DEFAULT_ARC_RATE_RAD_PER_MS = 0.003;\n\n// A.Circle.compass — anchor at centre, pick up the pencil at the\n// radius-defining point B, sweep 2π back to the start. Args:\n// { startAngle?: number } — default is computed from the angle from\n// centre to B so the trace begins where a real compass would.\n//\n// Strict two-step sequence (mirrors A.Polygon.outlineAndFill):\n// 1. Edge sweep: drawProgress 0 → 1 over 2π / rate.\n// 2. Face fade-in: faceAlpha 0 → 1 over ~half the sweep duration.\n// The edge stays fully drawn through step 2 because drawProgress\n// finalises to 1 before the fade-in starts, and faceAlpha is the\n// independent driver for drawFace's globalAlpha.\nconst DEFAULT_CIRCLE_FILL_MS = 600;\nexport class CircleCompassAnimation extends Animation {\n public animationMethod = AllAnimations.CIRCLE_COMPASS;\n public name = \"Circle.compass\";\n public elementType = CircleElement;\n public defaultRate = DEFAULT_ARC_RATE_RAD_PER_MS;\n public defaultDurationMs = DEFAULT_CIRCLE_FILL_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const circle = target as CircleElement;\n const explicitStart = (args && typeof args.startAngle === \"number\")\n ? args.startAngle\n : Math.atan2(circle.B.y - circle.Center.y, circle.B.x - circle.Center.x);\n const sweepMs = (2 * Math.PI) / this.defaultRate;\n const fullRestore = () => {\n circle.faceAlpha = 1;\n circle.drawProgress = 1;\n circle.drawStartAngle = 0;\n circle.visible = true;\n };\n // Step 1 — edge sweep with the face hidden.\n const sweep: IAnimationStep = {\n durationMs: sweepMs,\n setup: () => {\n circle.drawStartAngle = explicitStart;\n circle.faceAlpha = 0;\n circle.drawProgress = 0;\n },\n tick: (progress) => { circle.drawProgress = progress; },\n finalise: () => { circle.drawProgress = 1; },\n };\n // A face-less circle has nothing to fade — scheduling the\n // fill step anyway would be pure dead time in the middle of\n // a cascade (#81). Run the sweep alone, with its finalise\n // doing the full restore.\n if (circle.faceColor == null) {\n sweep.finalise = fullRestore;\n return [sweep];\n }\n // Fill ~twice as fast as the sweep, capped by the class-level\n // default so a tiny circle doesn't yield a blink-of-an-eye fade.\n const fillMs = Math.min(sweepMs / 2, this.defaultDurationMs);\n return [\n sweep,\n // Step 2 — face fade-in over the now-complete arc.\n {\n durationMs: fillMs,\n tick: (progress) => { circle.faceAlpha = progress; },\n finalise: fullRestore,\n },\n ];\n }\n}\n\nregisterAnimation(new CircleCompassAnimation());\n\n// A.Circle.compassTransfer — Euclid I.2 (copy a length to a point) as one\n// animation. The target is the declared RADIUS circle the deck keeps: a\n// `circle;radius;P,C,D` (centre P, radius the length |CD| to copy). The\n// macro reads P + the source CD straight off the target, draws the rigorous\n// I.2 walk that justifies that radius — join, the two I.1 circles + the\n// equilateral triangle, the two produced sides, and the two lay-off circles —\n// nine steps, all transitory gold EPHEMERALS\n// (created in step-1 setup, cleared in the last finalise), then reveals the\n// circle. The result is a circle, so its scaffolding side is a free visual\n// choice (args.side, default +1). A deck calls one entry instead of declaring\n// and sequencing the ~8-element rig.\n//\n// Geometry (P = centre, C = near source end, D = far, r = |CD|):\n// T = equilateral apex of P,C M = C + r·unit(C−T) (CM = r, on circle(C,r))\n// N = T + (|TC|+r)·unit(P−T) (PN = r, on circle(T,|TM|)) → the kept radius\nconst CIRCLE_TRANSFER_SWEEP_RATE = 0.0055; // rad/ms — brisk for a long walk\nconst CIRCLE_TRANSFER_TRACE_RATE = 0.3; // px/ms for the straightedge traces\n\nfunction equilateralApex(A: PointElement, B: PointElement, side: number): { x: number, y: number } {\n const mx = (A.x + B.x) / 2, my = (A.y + B.y) / 2;\n const dx = B.x - A.x, dy = B.y - A.y;\n const len = Math.hypot(dx, dy) || 1;\n const h = len * Math.sqrt(3) / 2;\n // perpendicular unit (rotate the base 90°), times the chosen side\n return { x: mx + side * h * (-dy / len), y: my + side * h * (dx / len) };\n}\n\nexport class CircleCompassTransferAnimation extends Animation {\n public animationMethod = AllAnimations.CIRCLE_COMPASS_TRANSFER;\n public name = \"Circle.compassTransfer\";\n public elementType = CircleElement;\n public defaultRate = CIRCLE_TRANSFER_SWEEP_RATE;\n public defaultDurationMs = DEFAULT_CIRCLE_FILL_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const circ = target as CircleElement;\n const P = circ.Center;\n const s0 = circ.A, s1 = circ.B;\n const instant = (): IAnimationStep[] => [{\n durationMs: 0, tick: () => {},\n finalise: () => { circ.faceAlpha = 1; circ.drawProgress = 1; circ.visible = true; },\n }];\n // Need a radius defined by two distinct source points (the length to\n // copy), distinct from the centre — i.e. circle;radius;P,C,D.\n if (s0 == null || s1 == null || s0 === P || s1 === P || s0.distance(s1) < 1e-6) {\n if (typeof console !== \"undefined\" && console.warn) {\n console.warn(\"[geomlib] Circle.compassTransfer: needs a radius defined by two \"\n + \"points distinct from the centre (circle;radius;centre,p1,p2) — skipping\");\n }\n return instant();\n }\n const plane = (P as any).AP || circ.AP;\n const r = s0.distance(s1);\n // Near source end joins the centre; far end is the length's reach.\n const C = (P.distance(s0) <= P.distance(s1)) ? s0 : s1;\n const D = (C === s0) ? s1 : s0;\n const side = (args && (args.side === 1 || args.side === -1)) ? args.side : 1;\n\n const t = equilateralApex(P, C, side);\n const T = new PointElement(); T.x = t.x; T.y = t.y; (T as any).AP = plane;\n const TC = Math.hypot(C.x - t.x, C.y - t.y) || 1;\n // M = C + r·unit(C − T); N = T + (TC + r)·unit(P − T)\n const u1x = (C.x - t.x) / TC, u1y = (C.y - t.y) / TC;\n const M = new PointElement(); M.x = C.x + r * u1x; M.y = C.y + r * u1y; (M as any).AP = plane;\n const TP = Math.hypot(P.x - t.x, P.y - t.y) || 1;\n const u2x = (P.x - t.x) / TP, u2y = (P.y - t.y) / TP;\n const N = new PointElement(); N.x = t.x + (TC + r) * u2x; N.y = t.y + (TC + r) * u2y; (N as any).AP = plane;\n\n // Transitory gold scaffolding (bare ephemerals).\n const join = new LineElement({ A: P, B: C });\n const tri = new PolygonElement(); tri.V = [P, C, T];\n const prodM = new LineElement({ A: C, B: M }); // produced side, C → M\n const prodN = new LineElement({ A: P, B: N }); // produced side, P → N (carries the result)\n const circC = new CircleElement({ C: C, B: D, AP: plane }); // circle(C, r): thru D and M\n const circT = new CircleElement({ C: T, B: M, AP: plane }); // circle(T, |TM|): thru M and N\n const circEp = new CircleElement({ C: P, B: C, AP: plane }); // I.1 circle: centre P thru C\n const circEc = new CircleElement({ C: C, B: P, AP: plane }); // I.1 circle: centre C thru P\n const transitory: GeomElement[] = [join, tri, prodM, prodN];\n // The four construction circles, in walk order (2 equilateral, 2 lay-off).\n const circles: CircleElement[] = [circEp, circEc, circC, circT];\n for (const e of (transitory as GeomElement[]).concat(circles)) {\n (e as any).edgeColor = null; (e as any).faceColor = null;\n (e as any).nameColor = null; (e as any).vertexColor = null;\n e.emphasized = true; // paints in the gold highlight stroke\n }\n // keepCircles: name the four circles so they persist as real, named\n // elements (rather than being wiped on slide advance) — a later slide\n // can re-show / count them. Order matches I.23's [t1Ka, t1Kc, t1Kc2, t1KT].\n const keepNames: string[] | null =\n (args && Array.isArray(args.keepCircles)) ? args.keepCircles : null;\n if (keepNames) circles.forEach((c, i) => { if (keepNames[i]) c.name = String(keepNames[i]); });\n const isKept = (c: CircleElement) => keepNames != null && c.name != null;\n\n const sweepMs = (2 * Math.PI) / this.defaultRate;\n const traceMs = (a: PointElement, b: PointElement) =>\n Math.max(120, a.distance(b) / CIRCLE_TRANSFER_TRACE_RATE);\n const lineStep = (ln: LineElement, ms: number): IAnimationStep => ({\n durationMs: ms,\n setup: () => { ln.drawProgress = 0; },\n tick: (p) => { ln.drawProgress = p; },\n finalise: () => { ln.drawProgress = 1; },\n });\n const sweepStep = (c: CircleElement): IAnimationStep => ({\n durationMs: sweepMs,\n setup: () => { c.drawStartAngle = Math.atan2(c.B.y - c.Center.y, c.B.x - c.Center.x); c.drawProgress = 0; },\n tick: (p) => { c.drawProgress = p; },\n finalise: () => { c.drawProgress = 1; },\n });\n // Clear the transitory scaffolding; kept circles persist (the slideshow's\n // visible-set hides them on advance and can re-show them for a count).\n const clearScaffold = () => {\n for (const e of transitory) slate.removeEphemeral(e);\n for (const c of circles) if (!isKept(c)) slate.removeEphemeral(c);\n };\n\n // Step 1 — join P→C; also registers all scaffolding and hides the\n // result circle until the reveal.\n const step1 = lineStep(join, traceMs(P, C));\n step1.setup = () => {\n circ.drawProgress = 0; circ.faceAlpha = 0; // result stays dark until reveal\n for (const e of transitory) { slate.addEphemeral(e); (e as any).drawProgress = 0; }\n for (const c of circles) {\n c.drawProgress = 0;\n if (isKept(c)) {\n slate.addElement(c); // persist as a real, named element\n slate.setInitiallyHidden(c.name!); // keep it out of the post-presentation figure\n c.visible = true; // but show it now, through the walk\n } else {\n slate.addEphemeral(c);\n }\n }\n join.drawProgress = 0;\n };\n\n const steps: IAnimationStep[] = [\n step1,\n // Steps 2,3 — the two I.1 compass circles that fix the equilateral apex.\n sweepStep(circEp),\n sweepStep(circEc),\n // Step 4 — the equilateral triangle PCT traces.\n { durationMs: traceMs(P, C) + traceMs(C, T),\n setup: () => { tri.drawProgress = 0; },\n tick: (p) => { tri.drawProgress = p; },\n finalise: () => { tri.drawProgress = 1; } },\n // Steps 5,6 — produce the two sides.\n lineStep(prodM, traceMs(C, M)),\n lineStep(prodN, traceMs(P, N)),\n // Steps 7,8 — the two lay-off compass circles.\n sweepStep(circC),\n sweepStep(circT),\n ];\n // Step 7 — reveal the result radius circle, clearing the scaffold as it lands.\n const reveal: IAnimationStep = {\n durationMs: sweepMs,\n setup: () => {\n circ.drawStartAngle = Math.atan2(circ.B.y - P.y, circ.B.x - P.x);\n circ.drawProgress = 0; circ.faceAlpha = 0; circ.visible = true;\n },\n tick: (p) => { circ.drawProgress = p; },\n finalise: () => { circ.drawProgress = 1; circ.faceAlpha = 1; circ.visible = true; clearScaffold(); },\n };\n steps.push(reveal);\n return steps;\n }\n}\n\nregisterAnimation(new CircleCompassTransferAnimation());\n","/*----------------------------------------------------------------------+\n| Circle construction classes — extracted from Constructions.ts |\n| Note: CircumcircleConstruction lives in point/PointConstructions.ts |\n| because CircumcenterConstruction extends it directly. |\n+----------------------------------------------------------------------*/\n\nimport {Construction, ConstructionSignature, SortedParams, AllConstructions,\n CircleConstructions as CircleConstructionsEnum,\n GeomElementsForUpdate} from \"../Constructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {CircleElement} from \"./CircleElement\";\nimport {InvertCircleElement} from \"./InvertCircleElement\";\nimport {SphereIntersectionElement} from \"./SphereIntersectionElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {SphereElement} from \"../sphere/SphereElement\";\n\n/************************\n * Element Class Circle *\n ************************/\n\n// circle\n// radius — points A, B [, plane C = screen]\n// the circle with center A and radius AB in the plane C\n// 2D: 2 points, 0 elements — uses screen plane\n// 3D: 2 points, 1 PlaneElement — uses explicit plane\n// (Java: Slate.java circle case 0 — new CircleElement(A,B,plane))\nexport class CircleRadiusCenterConstruction extends Construction {\n constructionMethod: AllConstructions = CircleConstructionsEnum.radius;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 2 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new CircleElement({C:P[0], B:P[1], AP:plane});\n return [[g], g];\n }\n}\n\n// circle — radius (3-point) — points A, B, C [, plane D = screen]\n// the circle with center A and radius |BC| in the plane D\n// 2D: 3 points, 0 elements — uses screen plane\n// 3D: 3 points, 1 PlaneElement — uses explicit plane\n// MUST be registered BEFORE the 2-point variant in the constructions array\n// (signature variant ordering rule: longer signature first)\n// (Java: Slate.java circle case 0 — new CircleElement(A,B,C,plane))\nexport class CircleRadius3PointConstruction extends Construction {\n constructionMethod: AllConstructions = CircleConstructionsEnum.radius;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new CircleElement({C: P[0], A: P[1], B: P[2], AP: plane});\n return [[g], g];\n }\n}\n\n\n// circle\n// invert\n// circles A, B\n// the image of circle A inverted in circle B\n// (Java: InvertCircle.java — TS: InvertCircleElement.ts)\nexport class InvertCircleConstruction extends Construction {\n constructionMethod: AllConstructions = CircleConstructionsEnum.invert;\n signature = { points: 0, elements: 2, integers: 0, elementTypes: [CircleElement, CircleElement] };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new InvertCircleElement(E[0] as CircleElement, E[1] as CircleElement);\n return [[g], g];\n }\n}\n\n// circle\n// intersection\n// spheres A, B\n// the circle at the intersection of spheres A and B\n// (Java: IntersectionSS.java — TS: SphereIntersectionElement.ts)\nexport class SphereIntersectionConstruction extends Construction {\n constructionMethod: AllConstructions = CircleConstructionsEnum.intersection;\n signature = { points: 0, elements: 2, integers: 0, elementTypes: [SphereElement, SphereElement] };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new SphereIntersectionElement(E[0] as SphereElement, E[1] as SphereElement);\n return [[g], g];\n }\n}\n\nexport const circleConstructions: Construction[] = [\n new CircleRadius3PointConstruction(),\n new CircleRadiusCenterConstruction(),\n new InvertCircleConstruction(),\n new SphereIntersectionConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tCircleElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {GeomElement} from \"../GeomElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {SlateCanvas} from \"../../Slate\";\n\n\nexport interface ICircleElementConstruction {\n C : PointElement; // center of the circle\n B : PointElement; // point defining one end of the radius segment\n A? : PointElement; // point defining the other end of the radius segment\n // (defaults to C — so radius = C.distance(B) in the 2-point form,\n // or A.distance(B) in the 3-point form where A ≠ C)\n AP : PlaneElement;\n}\n\nexport class CircleElement extends GeomElement {\n\n public Center : PointElement;\n public A : PointElement;\n public B : PointElement;\n public AP : PlaneElement;\n\n // Starting angle (radians) for the slide-transition arc sweep.\n // Default 0 keeps the existing closed-circle render path identical\n // when drawProgress is 1. Set by A.Circle.compass before sweeping\n // so the trace begins at the natural compass-point (the angle from\n // centre to the radius-defining B). Reset in finalise().\n private _drawStartAngle : number = 0;\n // Face fill alpha — drives drawFace's globalAlpha independent of\n // drawProgress (which only drives the edge sweep). Default 1 means\n // \"fully opaque\" — every existing render path behaves identically.\n private _faceAlpha : number = 1;\n\n set drawStartAngle(value: number) { this._drawStartAngle = value; }\n get drawStartAngle(): number { return this._drawStartAngle; }\n\n set faceAlpha(value: number) {\n this._faceAlpha = value < 0 ? 0 : (value > 1 ? 1 : value);\n }\n get faceAlpha(): number { return this._faceAlpha; }\n\n constructor(ice? : ICircleElementConstruction) {\n super();\n this.dimension = 2;\n if(ice == null) return;\n this.Center = ice.C;\n this.A = ice.A != null ? ice.A : this.Center;\n this.B = ice.B;\n this.AP = ice.AP;\n }\n\n get radius() {\n return this.A.distance(this.B);\n }\n\n get radius2() {\n return this.A.distance2(this.B);\n }\n\n public defined() : boolean {\n return true;\n //return this.Center.defined() && this.A.defined()\n // && this.B.defined() && this.AP.defined();\n }\n\n\n // drawEllipse and fillEllipse not necessary as they are provided\n // in the canvas api.\n\n // Shared geometry walk. `arcStart` / `arcEnd` let the caller render\n // either a partial arc (the slide-transition edge sweep) or a\n // full circle for fill purposes — the face never gets partial.\n private _drawCircleArc(ctx : CanvasRenderingContext2D, arcStart : number, arcEnd : number) : void {\n ctx.beginPath();\n let r2 : number = this.radius2;\n let r : number = Math.sqrt(r2);\n let amp2 : number = this.AP.S.z*this.AP.S.z + this.AP.T.z*this.AP.T.z;\n if (Math.abs(amp2) < 0.01) { // the circle is flat\n ctx.ellipse(\n this.Center.x,\n this.Center.y,\n r,\n r,\n 0,\n arcStart,\n arcEnd);\n return;\n }\n let h : number = r/Math.sqrt(amp2);\n // determine major and minor radius vectors (a,b) and (c,d)\n let rcos :number = h*this.AP.T.z;\n let rsin :number = -h*this.AP.S.z;\n let majorx :number = rcos*this.AP.S.x + rsin*this.AP.T.x;\n let majory :number = rcos*this.AP.S.y + rsin*this.AP.T.y;\n let factor :number = (amp2 < 1.0)? Math.sqrt(1.0-amp2) : 0.0;\n let minorx :number = -factor*majory;\n let minory :number = factor*majorx;\n let majorR : number = Math.sqrt(majorx*majorx + majory*majory);\n let minorR : number = Math.sqrt(minorx*minorx + minory*minory);\n // Degenerate case: ellipse is so thin it looks like a line.\n // (minorR <= majorR always since minorR = factor * majorR with\n // factor in [0,1], so we only need to check minorR.)\n if (minorR < 0.5) {\n ctx.moveTo(this.Center.x - majorx, this.Center.y - majory);\n ctx.lineTo(this.Center.x + majorx, this.Center.y + majory);\n return;\n }\n // Rotation angle of the major axis\n let rotation : number = Math.atan2(majory, majorx);\n ctx.ellipse(\n this.Center.x,\n this.Center.y,\n majorR,\n minorR,\n rotation,\n arcStart,\n arcEnd);\n }\n\n public drawEdge(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n // Pick the highlight color BEFORE the null bail, matching\n // LineElement / PolygonElement (#81). A circle with a null\n // edgeColor can still render in the highlight stroke while\n // emphasized or slide-highlighted — the \"invisible highlight\n // target\" pattern, and what lets a zero-color transitionary\n // circle show up during its compass animation (SlateAnimator\n // holds emphasisAmount = 1 on animating targets).\n const color = (this.emphasized || this.shouldHighlight)\n ? this.edgeHighlightColor\n : this.edgeColor;\n if (color == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.strokeStyle = color;\n // Match LineElement: smooth interpolation between baseline (1 or 3)\n // and 6 via emphasisAmount. Always assigned explicitly so a\n // previous element's value doesn't leak.\n {\n const baseW = this.shouldHighlight ? 3 : 1;\n ctx.lineWidth = (baseW + this.emphasisAmount * (6 - baseW)) * GeomElement.styleScale;\n }\n // Edge sweep: partial arc from drawStartAngle through\n // 2π · drawProgress. Default progress = 1 yields a full circle.\n let arcStart = this.drawStartAngle;\n let arcEnd = arcStart + 2 * Math.PI * this.drawProgress;\n this._drawCircleArc(ctx, arcStart, arcEnd);\n ctx.stroke();\n }\n\n public drawFace(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.faceColor == null || !this.defined()) return;\n // Face is independent of the edge sweep — always fills the\n // full circle (filling a partial arc would render a pie wedge\n // with a chord bleeding out, which is not what a compass sweep\n // should look like). Alpha is driven by the dedicated faceAlpha\n // field so an animation can fade the fill in after the edge\n // trace completes; default faceAlpha = 1 preserves the\n // fully-opaque behaviour for every consumer that doesn't animate.\n let a = this.faceAlpha;\n if (a <= 0) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.fillStyle = this.faceColor;\n this._drawCircleArc(ctx, 0, 2 * Math.PI);\n if (a < 1) {\n ctx.save();\n ctx.globalAlpha = a;\n ctx.fill();\n ctx.restore();\n } else {\n ctx.fill();\n }\n }\n\n public drawName(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.nameColor != null && this.name != null) {\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.strokeStyle = this.nameColor;\n ctx.font = GeomElement.fontString();\n let [w, h] = this._getTextMetrics(ctx, this.name);\n ctx.fillText(this._name, this.Center.x - w/2, this.Center.y - h/2);\n }\n }\n\n public drawVertex(c: SlateCanvas): void {\n }\n\n public rotate(pivot: PointElement, ac: number, as: number): void {\n }\n\n public translate(dx: number, dy: number): void {\n }\n\n public update(): void {\n }\n\n}\n","/*----------------------------------------------------------------------+\n| Title:\tCircumcenter.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2024, Nelson Brown, brownnrl@gmail.com |\n+----------------------------------------------------------------------*/\n\n// import {GeomElement} from \"../GeomElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {CircleElement} from \"./CircleElement\";\n\nexport class CircumcircleElement extends CircleElement {\n\n /*--------------------------------------------------------------------+\n | This is the circle passing through the three points B, C, and D.\t|\n | It is assumed that all three points lie in the plane AP.\t\t|\n +--------------------------------------------------------------------*/\n public C : PointElement;\n public D : PointElement;\n\n constructor(B: PointElement, C : PointElement, D: PointElement, AP: PlaneElement) {\n super();\n this.dimension = 2;\n this.B = B;\n this.C = C;\n this.D = D;\n this.AP = AP;\n this.Center = new PointElement({AP:AP});\n this.A = this.Center;\n }\n\n update() : void { \n this.Center.toCircumcenter(this.B,this.C,this.D); \n }\n\n translate(dx: number, dy: number) {\n this.Center.translate(dx, dy);\n }\n\n rotate(pivot: PointElement, c: number, s: number) {\n this.Center.rotate(pivot, c, s);\n }\n\n}\n","/*----------------------------------------------------------------------+\n| Title:\tInvertCircleElement.ts |\n| Originally: InvertCircle.java |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {CircleElement} from \"./CircleElement\";\nimport {PointElement} from \"../point/PointElement\";\n\nexport class InvertCircleElement extends CircleElement {\n /*--------------------------------------------------------------------+\n | Invert the circle C in the circle D to get this circle. It is |\n | assumed that C and D lie in the same plane C.AP. |\n +--------------------------------------------------------------------*/\n\n private _C: CircleElement;\n private _D: CircleElement;\n\n constructor(C: CircleElement, D: CircleElement) {\n super();\n this.dimension = 2;\n this._C = C;\n this._D = D;\n this.AP = C.AP;\n this.Center = new PointElement({AP: this.AP});\n this.A = this.Center;\n this.B = new PointElement({AP: this.AP});\n }\n\n public update() {\n let d2 = this._C.Center.distance2(this._D.Center);\n let r2 = this._C.radius2;\n let factor = this._D.radius2 / (d2 - r2);\n this.Center.to(this._C.Center).minus(this._D.Center).times(factor).plus(this._D.Center);\n factor = 1.0 + Math.sqrt(r2 / d2);\n this.B.to(this.Center).minus(this._D.Center).times(factor).plus(this._D.Center);\n }\n\n public translate(dx: number, dy: number) {\n this.Center.translate(dx, dy);\n this.B.translate(dx, dy);\n }\n\n public rotate(pivot: PointElement, ac: number, as: number) {\n this.Center.rotate(pivot, ac, as);\n this.B.rotate(pivot, ac, as);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tSphereIntersectionElement.ts |\n| Originally: IntersectionSS.java (renamed for clarity) |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {CircleElement} from \"./CircleElement\";\nimport {SphereElement} from \"../sphere/SphereElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {PerpendicularPlane} from \"../plane/PerpendicularPlane\";\n\nexport class SphereIntersectionElement extends CircleElement {\n /*--------------------------------------------------------------------+\n | This circle is the intersection of two spheres S and T. The center |\n | of the circle is Center, which is A, lies in the plane AP, and |\n | has radius AB. |\n +--------------------------------------------------------------------*/\n\n private _S: SphereElement;\n private _T: SphereElement;\n\n constructor(S: SphereElement, T: SphereElement) {\n super();\n this.dimension = 2;\n this._S = S;\n this._T = T;\n this.Center = this.A = new PointElement();\n this.B = new PointElement();\n this.AP = new PerpendicularPlane({A: this.Center, E: T.Center});\n this.Center._AP = this.AP;\n }\n\n public update() {\n let d2 = this._T.Center.distance2(this._S.Center);\n let t2 = this._T.radius2();\n let factor = 0.5 + (t2 - this._S.radius2()) / (2.0 * d2);\n this.Center.to(this._S.Center).minus(this._T.Center).times(factor).plus(this._T.Center);\n let radius = Math.sqrt(t2 - this.Center.distance2(this._T.Center));\n this.B.to(this.Center);\n this.B.z += radius;\n this.AP.update();\n }\n\n public translate(dx: number, dy: number) {\n this.Center.translate(dx, dy);\n this.B.translate(dx, dy);\n this.AP.translate(dx, dy);\n }\n\n public rotate(pivot: PointElement, ac: number, as: number) {\n this.Center.rotate(pivot, ac, as);\n this.B.rotate(pivot, ac, as);\n this.AP.rotate(pivot, ac, as);\n }\n}\n","// Cross-type group animations. See ../Animations.ts for the abstract\n// base + registry mechanics.\n\nimport {Animation, AllAnimations, IAnimationStep, registerAnimation} from \"../Animations\";\nimport {GeomElement} from \"../GeomElement\";\nimport {Slate} from \"../../Slate\";\nimport {PointElement} from \"../point/PointElement\";\nimport {LineElement} from \"../line/LineElement\";\nimport {PolygonElement} from \"../polygon/PolygonElement\";\nimport {LineSlider} from \"../point/LineSlider\";\n\nconst CLONE_ASIDE_RATE_PX_PER_MS = 0.4;\nconst CLONE_ASIDE_MIN_MS = 200;\n// Below this canvas (≈ viewport, in presentation mode) width, the legacy\n// explicit-offset path skips the case-variant copies — they were a\n// desktop affordance. The autoPlace path (#99) supersedes this: it slides\n// the figure to centre and only opts out when a copy genuinely can't fit.\nconst CLONE_ASIDE_DESKTOP_MIN_WIDTH = 520;\n\n// autoPlace timing + spacing (#99).\nconst CLONE_ASIDE_AUTOPLACE_MS = 900; // whole centre-then-split beat\nconst AUTOPLACE_CENTRE_FRAC = 0.4; // first 40%: slide figure to centre\nconst AUTOPLACE_MARGIN = 8; // px gap to the canvas edge\nconst AUTOPLACE_GAP = 16; // px gap between figure and a copy\n\n// easeOutCubic for the slide-to-centre phase.\nfunction easeOut(t: number): number { return 1 - Math.pow(1 - t, 3); }\n\n// A mutable clone vertex tracked against its snapshot base, so the\n// animation can slide every clone point by the same offset.\ninterface ClonePoint { pt: PointElement; bx: number; by: number; }\n\n// Snapshot one element into a bare render-copy (no construction refs;\n// update() is a no-op) at its current geometry, returning the ghost\n// plus the list of its mutable points. Supported v1 types: point,\n// line, polygon. Unsupported types return null (skipped with a warn).\nfunction snapshotElement(el: GeomElement): { ghost: GeomElement, pts: ClonePoint[] } | null {\n const bare = (src: PointElement): PointElement => {\n const p = new PointElement();\n p.x = src.x; p.y = src.y; p.z = src.z;\n return p;\n };\n // PolygonElement extends nothing point-like but has V[]; check it\n // before LineElement / PointElement so a polygon isn't mis-typed.\n if (el instanceof PolygonElement) {\n const ghost = new PolygonElement();\n const pts: ClonePoint[] = [];\n for (const v of el.V) {\n const p = bare(v);\n ghost.V.push(p);\n pts.push({ pt: p, bx: p.x, by: p.y });\n }\n ghost.edgeColor = el.edgeColor;\n ghost.faceColor = el.faceColor;\n ghost.faceAlpha = el.faceAlpha;\n ghost.nameColor = el.nameColor;\n ghost.vertexColor = el.vertexColor;\n return { ghost, pts };\n }\n if (el instanceof LineElement) {\n const a = bare(el.A);\n const b = bare(el.B);\n const ghost = new LineElement({ A: a, B: b });\n ghost.edgeColor = el.edgeColor;\n ghost.nameColor = el.nameColor;\n return { ghost, pts: [{ pt: a, bx: a.x, by: a.y }, { pt: b, bx: b.x, by: b.y }] };\n }\n if (el instanceof PointElement) {\n const p = bare(el);\n p.vertexColor = el.vertexColor;\n p.nameColor = el.nameColor;\n if (el.name != null) p.name = el.name;\n return { ghost: p, pts: [{ pt: p, bx: p.x, by: p.y }] };\n }\n return null; // circle / sector / other — deferred\n}\n\ntype Bounds = { minX: number, maxX: number, minY: number, maxY: number };\ntype Side = \"left\" | \"right\" | \"top\" | \"bottom\";\n\n// Resolve the elements a copy clones: \"all\" / missing → every named,\n// visible, non-screen element; otherwise the explicit name list.\nfunction resolveSources(slate: Slate, include: any): GeomElement[] {\n const sources: GeomElement[] = [];\n if (Array.isArray(include)) {\n for (const nm of include) {\n const e = slate.lookupElement(String(nm));\n if (e != null) sources.push(e);\n }\n } else {\n for (const e of slate.elements) {\n if (e.name != null && e.visible && !e.name.startsWith(\"screen\")) {\n sources.push(e);\n }\n }\n }\n return sources;\n}\n\n// Snapshot the figure's current geometry into bare render-copies.\nlet warnedUnsupported = false;\nfunction snapshotSources(sources: GeomElement[]): { ghosts: GeomElement[], pts: ClonePoint[] } {\n const ghosts: GeomElement[] = [];\n const pts: ClonePoint[] = [];\n for (const el of sources) {\n const snap = snapshotElement(el);\n if (snap == null) {\n if (!warnedUnsupported && typeof console !== \"undefined\" && console.warn) {\n console.warn(\"[geomlib] Group.cloneAside: skipping unsupported \"\n + \"element type (\" + el.name + \")\");\n warnedUnsupported = true;\n }\n continue;\n }\n ghosts.push(snap.ghost);\n for (const p of snap.pts) pts.push(p);\n }\n return { ghosts, pts };\n}\n\n// Apply a { elem, to } slider vary, recomputing the figure. Returns a\n// restore thunk (or null when the vary doesn't apply), so the caller can\n// snapshot the varied figure and put the real slider back.\nfunction applyVary(slate: Slate, vary: any): (() => void) | null {\n if (!vary || vary.elem == null || typeof vary.to !== \"number\") return null;\n const s = slate.lookupElement(String(vary.elem));\n if (!(s instanceof LineSlider)) return null;\n const sx = s.x, sy = s.y, sz = s.z;\n const A = (s as any)._A as PointElement;\n const B = (s as any)._B as PointElement;\n s.x = A.x + (B.x - A.x) * vary.to;\n s.y = A.y + (B.y - A.y) * vary.to;\n s.z = A.z + (B.z - A.z) * vary.to;\n slate.update();\n return () => { s.x = sx; s.y = sy; s.z = sz; slate.update(); };\n}\n\nfunction boundsOf(pts: ClonePoint[]): Bounds {\n let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;\n for (const c of pts) {\n if (c.bx < minX) minX = c.bx; if (c.bx > maxX) maxX = c.bx;\n if (c.by < minY) minY = c.by; if (c.by > maxY) maxY = c.by;\n }\n return { minX, maxX, minY, maxY };\n}\n\nfunction sideFromSign(dx: number, dy: number): Side {\n if (Math.abs(dx) >= Math.abs(dy)) return dx < 0 ? \"left\" : \"right\";\n return dy < 0 ? \"top\" : \"bottom\";\n}\n\n\n// A.Group.cloneAside — clone a sub-figure (a named set of elements, or\n// \"all\") into displaced bare copies and slide them aside, where they\n// PERSIST for the slide. Optionally vary a slider point per copy so each\n// shows a different case (a trichotomy's three positions of D). The real\n// figure never moves; only bare render-copies are added as ephemerals.\n//\n// args:\n// include \"all\" (default) or an array of element names — what\n// each copy clones.\n// vary? { elem, to } — set a slider to parameter t (A + t·(B−A);\n// infinite-slider t may be < 0) before snapshotting, so the\n// copy shows the varied figure; the real slider is restored\n// afterward. (Single-copy form.)\n// dx, dy legacy explicit pixel offset for the single copy (no\n// autoPlace). With autoPlace + no `variants`, only the SIGN\n// is used, to pick the copy's preferred side.\n// autoPlace? when true (#99): slide the whole visible figure to the\n// canvas centre (a translate-only slate view offset — the\n// real figure stays draggable), then lay the copies in the\n// freed space around it. Each copy takes its preferred side\n// (left/right/top/bottom), falling back to a free\n// perpendicular side when its first choice can't fit. No\n// scaling.\n// variants? [{ vary?, prefer? }, …] — with autoPlace, the case copies\n// to lay out ATOMICALLY: either every variant gets a slot\n// (all placed), or if any can't fit anywhere free, NONE are\n// placed and the figure doesn't move (both-or-neither).\n// `prefer` is a side name; default by index (left, right,\n// top, bottom). Direction is per-variant independent; only\n// the place/no-place decision is collective.\n//\n// Lifecycle: copies are ephemerals this animation does NOT remove — they\n// persist until the next slide advance clears them (SlateControls.showSlide\n// wipes leftover ephemerals + the view offset on every transition).\n//\n// elementType is GeomElement: the entry's `elem` is a nominal anchor; the\n// clone set comes from args.include.\nexport class GroupCloneAsideAnimation extends Animation {\n public animationMethod = AllAnimations.GROUP_CLONE_ASIDE;\n public name = \"Group.cloneAside\";\n public elementType = GeomElement;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const include = args && args.include;\n const autoPlace = args && args.autoPlace === true;\n const sources = resolveSources(slate, include);\n return autoPlace\n ? [this._autoPlaceStep(target, slate, args, sources)]\n : [this._legacyStep(target, slate, args, sources)];\n }\n\n // Atomic centred layout (#99). Snapshot every variant, centre the\n // figure, assign each copy a free slot (preferred side → fallback);\n // commit all only if every variant fits, else place nothing.\n private _autoPlaceStep(target: GeomElement, slate: Slate, args: any,\n sources: GeomElement[]): IAnimationStep {\n // Normalise to a variant list. No `variants` → a single copy whose\n // preferred side comes from the dx/dy sign (so the old single-copy\n // autoPlace call still works).\n const dx = args && typeof args.dx === \"number\" ? args.dx : 0;\n const dy = args && typeof args.dy === \"number\" ? args.dy : 0;\n const variants: any[] = Array.isArray(args && args.variants) && args.variants.length > 0\n ? args.variants\n : [{ vary: args && args.vary, prefer: sideFromSign(dx, dy) }];\n\n let targetOffX = 0, targetOffY = 0;\n // View offset already in effect at setup time — the presentation /\n // maximize base centring (#107). The centre phase eases from this\n // base to the target, so when the figure is ALREADY centred\n // (base == target) it's a no-op (no jump) and only the copies\n // slide; outside a maximized view base is 0 → centres as before.\n let baseOffX = 0, baseOffY = 0;\n let placed = false;\n // Per placed copy: its mutable points + the slot offset it slides to.\n let copies: { pts: ClonePoint[], edx: number, edy: number }[] = [];\n\n const drive = (p: number) => {\n if (!placed) return;\n const centreP = easeOut(Math.min(1, p / AUTOPLACE_CENTRE_FRAC));\n const splitP = Math.max(0, Math.min(1,\n (p - AUTOPLACE_CENTRE_FRAC) / (1 - AUTOPLACE_CENTRE_FRAC)));\n slate.setViewOffset(baseOffX + (targetOffX - baseOffX) * centreP,\n baseOffY + (targetOffY - baseOffY) * centreP);\n for (const c of copies)\n for (const pt of c.pts) {\n pt.pt.x = pt.bx + c.edx * splitP;\n pt.pt.y = pt.by + c.edy * splitP;\n }\n };\n\n return {\n durationMs: CLONE_ASIDE_AUTOPLACE_MS,\n setup: () => {\n target.drawProgress = 1;\n target.visible = true;\n // Display px (#71): autoPlace runs only while presenting\n // (maximized ⇒ fit-scale 1), so this is the on-screen extent.\n const W = slate.displayWidth;\n const H = slate.displayHeight;\n if (!W || !H) return;\n\n // Snapshot each variant (vary → snapshot → restore).\n const snaps: { ghosts: GeomElement[], pts: ClonePoint[], bbox: Bounds, prefer?: Side }[] = [];\n for (const variant of variants) {\n const restore = applyVary(slate, variant && variant.vary);\n const snap = snapshotSources(sources);\n if (restore) restore();\n if (snap.pts.length === 0) continue;\n snaps.push({\n ghosts: snap.ghosts, pts: snap.pts,\n bbox: boundsOf(snap.pts),\n prefer: variant && variant.prefer,\n });\n }\n if (snaps.length === 0) return;\n\n // Capture the base offset (a maximized/presentation centring,\n // #107) so the centre phase eases from it instead of 0.\n baseOffX = slate.viewOffsetX;\n baseOffY = slate.viewOffsetY;\n\n // Centre target from the real (restored) figure. Use the\n // visibility-independent figure bounds so it matches the\n // #107 base-centring exactly (no shift when already centred).\n const fb = slate.figureBounds();\n if (fb == null) return;\n const figW = fb.maxX - fb.minX, figH = fb.maxY - fb.minY;\n const figCx = (fb.minX + fb.maxX) / 2;\n const figCy = (fb.minY + fb.maxY) / 2;\n targetOffX = W / 2 - figCx;\n targetOffY = H / 2 - figCy;\n\n const M = AUTOPLACE_MARGIN, G = AUTOPLACE_GAP;\n // The slot offset that drops a copy (bbox bb) centred in the\n // freed band on `side`, cross-aligned with the centred\n // figure — or null when it doesn't fit. (display = model +\n // view offset, so edx = bandCentre − targetOff − copyCentre.)\n const slotFor = (side: Side, bb: Bounds): [number, number] | null => {\n const bw = bb.maxX - bb.minX, bh = bb.maxY - bb.minY;\n const ccx = (bb.minX + bb.maxX) / 2, ccy = (bb.minY + bb.maxY) / 2;\n if (side === \"left\" || side === \"right\") {\n if (bh > H - 2 * M) return null;\n const inner = side === \"left\" ? W / 2 - figW / 2 - G : W / 2 + figW / 2 + G;\n const outer = side === \"left\" ? M : W - M;\n if (Math.abs(outer - inner) < bw) return null;\n return [(inner + outer) / 2 - targetOffX - ccx, figCy - ccy];\n }\n if (bw > W - 2 * M) return null;\n const inner = side === \"top\" ? H / 2 - figH / 2 - G : H / 2 + figH / 2 + G;\n const outer = side === \"top\" ? M : H - M;\n if (Math.abs(outer - inner) < bh) return null;\n return [figCx - ccx, (inner + outer) / 2 - targetOffY - ccy];\n };\n\n // Assign each variant a free slot: preferred side first,\n // then any other free side. ATOMIC — if any variant can't be\n // placed, none are (both-or-neither).\n const DEFAULT: Side[] = [\"left\", \"right\", \"top\", \"bottom\"];\n const taken = new Set<Side>();\n const assigned: { pts: ClonePoint[], edx: number, edy: number }[] = [];\n for (let i = 0; i < snaps.length; i++) {\n const s = snaps[i];\n const prefer = s.prefer || DEFAULT[i % DEFAULT.length];\n const order: Side[] = [prefer].concat(DEFAULT.filter(x => x !== prefer));\n let slot: [number, number] | null = null;\n for (const side of order) {\n if (taken.has(side)) continue;\n slot = slotFor(side, s.bbox);\n if (slot != null) { taken.add(side); break; }\n }\n if (slot == null) return; // no free slot — abort, place nothing\n assigned.push({ pts: s.pts, edx: slot[0], edy: slot[1] });\n }\n\n // Commit every copy.\n for (const s of snaps) for (const g of s.ghosts) slate.addEphemeral(g);\n copies = assigned;\n placed = true;\n },\n tick: (p) => { drive(p); },\n finalise: () => { drive(1); },\n };\n }\n\n // Legacy explicit-offset single copy (≤ 0.9.x behaviour, unchanged):\n // clone once, clamp the requested dx/dy into the canvas, only show the\n // copy if it clears the figure; skip on a narrow viewport.\n private _legacyStep(target: GeomElement, slate: Slate, args: any,\n sources: GeomElement[]): IAnimationStep {\n const dx = args && typeof args.dx === \"number\" ? args.dx : 0;\n const dy = args && typeof args.dy === \"number\" ? args.dy : 0;\n const vary = args && args.vary;\n const durationMs = Math.max(CLONE_ASIDE_MIN_MS,\n Math.hypot(dx, dy) / CLONE_ASIDE_RATE_PX_PER_MS);\n\n let cloned: ClonePoint[] = [];\n let edx = dx, edy = dy;\n let placed = false;\n const slideCopy = (p: number) => {\n for (const c of cloned) {\n c.pt.x = c.bx + edx * p;\n c.pt.y = c.by + edy * p;\n }\n };\n\n return {\n durationMs,\n setup: () => {\n target.drawProgress = 1;\n target.visible = true;\n const restore = applyVary(slate, vary);\n const snap = snapshotSources(sources);\n if (restore) restore();\n const temp = snap.ghosts;\n const pts = snap.pts;\n if (temp.length === 0) return;\n\n const bb = boundsOf(pts);\n const bw = bb.maxX - bb.minX, bh = bb.maxY - bb.minY;\n // Display px (#71): autoPlace runs only while presenting\n // (maximized ⇒ fit-scale 1), so this is the on-screen extent.\n const W = slate.displayWidth;\n const H = slate.displayHeight;\n const MARGIN = 6;\n if (W && W < CLONE_ASIDE_DESKTOP_MIN_WIDTH) return;\n edx = dx; edy = dy;\n if (W && H) {\n if (bb.minX + edx < MARGIN) edx = MARGIN - bb.minX;\n if (bb.maxX + edx > W - MARGIN) edx = (W - MARGIN) - bb.maxX;\n if (bb.minY + edy < MARGIN) edy = MARGIN - bb.minY;\n if (bb.maxY + edy > H - MARGIN) edy = (H - MARGIN) - bb.maxY;\n }\n const CLEAR_GAP = 8;\n const clears = Math.abs(edx) >= bw + CLEAR_GAP\n || Math.abs(edy) >= bh + CLEAR_GAP\n || (bw === 0 && bh === 0);\n if (!clears) return;\n\n for (const g of temp) slate.addEphemeral(g);\n cloned = pts;\n placed = true;\n },\n tick: (p) => { if (placed) slideCopy(p); },\n finalise: () => { if (placed) slideCopy(1); },\n };\n }\n}\n\nregisterAnimation(new GroupCloneAsideAnimation());\n","/*----------------------------------------------------------------------+\n| Title:\tBichord.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {LineElement} from \"./LineElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {PointElement} from \"../point/PointElement\";\n\ninterface IBichordElementConstructor {\n C : CircleElement;\n D : CircleElement;\n}\n\nexport class Bichord extends LineElement {\n /*--------------------------------------------------------------------+\n | This line AB connects the two points where the two circles C and D |\n | meet. It is assumed that the two circles lie in the same plane, the |\n | plane of C. |\n +--------------------------------------------------------------------*/\n\n public C: CircleElement;\n public D: CircleElement;\n\n constructor(ibe? : IBichordElementConstructor) {\n super();\n this.dimension = 1;\n if (ibe == null) return;\n\n this._A = new PointElement();\n this._B = new PointElement();\n this.C = ibe.C;\n this.D = ibe.D;\n this._A._AP = this.C.AP;\n this._B._AP = this.C.AP;\n }\n\n public translate(dx: number, dy: number) {\n this._A.translate(dx, dy);\n this._B.translate(dx, dy);\n }\n\n public rotate(pivot : PointElement, ac : number, as : number) {\n this._A.rotate(pivot, ac, as);\n this._B.rotate(pivot, ac, as);\n }\n\n public update() {\n let r : number = this.C.radius;\n let s : number = this.D.radius;\n let d : number = this.C.Center.distance(this.D.Center);\n if (d > r + s) {\n let v = 0.0/0.0;\n this.A.x = v;\n this.A.y = v;\n this.A.z = v;\n this.B.x = v;\n this.B.y = v;\n this.B.z = v;\n return;\n }\n let costheta : number = (d*d + r*r - s*s) / (2.0 * d * r);\n let sintheta : number = Math.sqrt(1.0-costheta*costheta);\n this.A.to(this.D.Center).toCircle(this.C);\n this.B.to(this.A);\n this.A.rotate(this.C.Center,costheta,sintheta,this.C.AP);\n this.B.rotate(this.C.Center,costheta,-sintheta,this.C.AP);\n }\n\n}\n","/*----------------------------------------------------------------------+\n| Title:\tChord.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {LineElement} from \"./LineElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {PointElement} from \"../point/PointElement\";\n\ninterface IChordElementConstructor {\n D : PointElement;\n E : PointElement;\n C : CircleElement;\n}\n\nexport class Chord extends LineElement {\n /*--------------------------------------------------------------------+\n | This line AB is the segment of the line DE (extended) that |\n | intersects the circle C. It is assumed that DE and C lie in the |\n | same plane, namely that of C. |\n +--------------------------------------------------------------------*/\n\n public C: CircleElement;\n public D: PointElement;\n public E: PointElement;\n\n constructor(ice? : IChordElementConstructor) {\n super();\n this.dimension = 1;\n if (ice == null) return;\n\n this.C = ice.C;\n this.D = ice.D;\n this.E = ice.E;\n this._A = new PointElement({AP: this.C.AP});\n this._B = new PointElement({AP: this.C.AP});\n }\n\n public translate(dx: number, dy: number) {\n this._A.translate(dx, dy);\n this._B.translate(dx, dy);\n }\n\n public rotate(pivot : PointElement, ac : number, as : number) {\n this._A.rotate(pivot, ac, as);\n this._B.rotate(pivot, ac, as);\n }\n\n public update() {\n this._B.to(this.C.Center).toLine(this.D, this.E, false);\n let d2 : number = this.C.Center.distance2(this._B);\n let r2 : number = this.C.radius2;\n if (d2 > r2) {\n let v = 0.0/0.0;\n this._A.x = v;\n this._A.y = v;\n this._A.z = v;\n this._B.x = v;\n this._B.y = v;\n this._B.z = v;\n return;\n }\n let s : number = Math.sqrt(r2 - d2);\n let factor : number = s / this.D.distance(this._B);\n if (factor < 1e10) {\n this._A.to(this.D).minus(this._B).times(factor).plus(this._B);\n } else {\n factor = s / this.E.distance(this._B);\n this._A.to(this.E).minus(this._B).times(factor).plus(this._B);\n }\n this._B.times(2.0).minus(this._A);\n }\n\n}\n","// Animations targeting LineElement. See ../Animations.ts for the\n// abstract base + registry mechanics.\n\nimport {Animation, AllAnimations, IAnimationStep, registerAnimation} from \"../Animations\";\nimport {GeomElement} from \"../GeomElement\";\nimport {Slate} from \"../../Slate\";\nimport {LineElement} from \"./LineElement\";\n\n// Default trace rate in px/ms. Calibrated for unhurried teaching: a\n// typical 100-px construction line draws over ~400 ms; 200-px lines\n// take ~800 ms. Authors who want snappier transitions raise the rate\n// via slate.animationConfig.rates[\"Line.straightEdgeConnect\"].\nconst DEFAULT_LINE_RATE_PX_PER_MS = 0.25;\n\n// Common helper: trace the target line from A toward B by driving\n// drawProgress. Used by both StraightEdgeConnect (the canonical\n// straightedge stroke between two existing points) and\n// StraightEdgeExtend (same shape, just visually framed as extending\n// past an endpoint instead of joining two existing ones).\nfunction traceLine(target: LineElement, rate: number): IAnimationStep {\n // duration = length / rate, clamped low so an extremely short\n // line still gets a perceptible draw.\n const dx = target.B.x - target.A.x;\n const dy = target.B.y - target.A.y;\n const length = Math.sqrt(dx * dx + dy * dy);\n const durationMs = Math.max(120, length / rate);\n return {\n durationMs,\n tick: (progress) => { target.drawProgress = progress; },\n finalise: () => {\n target.drawProgress = 1;\n target.visible = true;\n },\n };\n}\n\n// A.Line.straightEdgeConnect — pencil stroke from A toward B.\n// Args: none. Duration = length × default rate (0.5 px/ms).\nexport class LineStraightEdgeConnectAnimation extends Animation {\n public animationMethod = AllAnimations.LINE_STRAIGHT_EDGE_CONNECT;\n public name = \"Line.straightEdgeConnect\";\n public elementType = LineElement;\n public defaultRate = DEFAULT_LINE_RATE_PX_PER_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n return [traceLine(target as LineElement, this.defaultRate)];\n }\n}\n\n// A.Line.straightEdgeExtend — for Line.extend constructions where one\n// endpoint sits on an existing line and the other is the projected\n// new endpoint. v1 renders the same trace as StraightEdgeConnect;\n// future richer variants might pivot a straightedge guide against the\n// existing line first.\nexport class LineStraightEdgeExtendAnimation extends Animation {\n public animationMethod = AllAnimations.LINE_STRAIGHT_EDGE_EXTEND;\n public name = \"Line.straightEdgeExtend\";\n public elementType = LineElement;\n public defaultRate = DEFAULT_LINE_RATE_PX_PER_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n return [traceLine(target as LineElement, this.defaultRate)];\n }\n}\n\nregisterAnimation(new LineStraightEdgeConnectAnimation());\nregisterAnimation(new LineStraightEdgeExtendAnimation());\n","/*----------------------------------------------------------------------+\n| Line construction classes — extracted from Constructions.ts |\n| Each class maps a (type, constructionName, signature) triple to |\n| a construct() method that creates the geometry element. |\n+----------------------------------------------------------------------*/\n\nimport {Construction, ConstructionSignature, SortedParams, AllConstructions, LineConstructions as LineConstructionsEnum,\n GeomElementsForUpdate} from \"../Constructions\";\nimport {PointPerpendicular1Construction, PointPerpendicular2Construction,\n PointPerpendicular3Construction, PointPerpendicular4Construction,\n PointPerpendicular5Construction} from \"../point/PointConstructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {Layoff} from \"../point/Layoff\";\nimport {Foot} from \"../point/Foot\";\nimport {PlaneFootElement} from \"../point/PlaneFootElement\";\nimport {LineElement} from \"./LineElement\";\nimport {PolylineElement} from \"./PolylineElement\";\nimport {Perpendicular} from \"./Perpendicular\";\nimport {PlanePerpendicularLine} from \"./PlanePerpendicularLine\";\nimport {Bichord} from \"./Bichord\";\nimport {Chord} from \"./Chord\";\nimport {SimilarElement} from \"../point/SimilarElement\";\nimport {ProportionElement} from \"../point/ProportionElement\";\nimport {AngleDividerElement} from \"../point/AngleDividerElement\";\nimport {MeanProportionalElement} from \"../point/MeanProportionalElement\";\n\n/**********************\n * Element Class Line *\n **********************/\n\n// line\n// connect\n// points A, B\n// the line AB connecting two points A and B\n// (Java: Slate.java line case 0 — new LineElement(A,B))\nexport class LineConnectConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.connect;\n signature = { points: 2, elements: 0, integers: 0 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new LineElement({A:P[0], B: P[1]});\n\n return [[g], g];\n }\n}\n\n// line\n// angleBisector — points B, A, C [, plane D = screen]\n// line from A to the bisector point of angle BAC on line BC\n// 2D: 3 points, 0 elements — uses screen plane\n// 3D: 3 points, 1 PlaneElement — uses explicit plane\n// (Java: Slate.java line case 1 — AngleDivider(B,A,C,plane,2) + LineElement(A,result))\nexport class AngleBisectorLineConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.angleBisector;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let ad = new AngleDividerElement(P[0], P[1], P[2], plane, 2);\n let g = new LineElement({A: P[1], B: ad});\n return [[ad, g], g];\n }\n}\n\n// line\n// angleDivider — points B, A, C, integer n [, plane D = screen]\n// line from A to the n-th division point of angle BAC on line BC\n// 2D: 3 points, 0 elements, 1 integer — uses screen plane\n// 3D: 3 points, 1 PlaneElement, 1 integer — uses explicit plane\n// (Java: Slate.java line case 2 — AngleDivider(B,A,C,plane,n) + LineElement(A,result))\nexport class AngleDividerLineConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.angleDivider;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 1 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 1\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let ad = new AngleDividerElement(P[0], P[1], P[2], plane, N[0]);\n let g = new LineElement({A: P[1], B: ad});\n return [[ad, g], g];\n }\n}\n\n// line\n// foot (2D variant)\n// 3 points A, B, C\n// the line AD from A to the foot of the perpendicular from A to line BC\n// (Java: Slate.java case 3, choice 0 — Foot(A,B,C) + LineElement(A,foot).\n// Foot class already IMPL at src/elements/point/Foot.ts.)\nexport class LineFootConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.foot;\n signature = { points: 3, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let fo = new Foot(P[0], P[1], P[2]);\n let g = new LineElement({A: P[0], B: fo});\n return [[fo, g], g];\n }\n}\n\n// *Solid Geometry Only*\n// line\n// foot\n// point A plane B\n// the line AD drawn perpendicular to plane B with the point D lying on B\n// (Java: PlaneFoot.java — TS: PlaneFootElement.ts, renamed for clarity)\nexport class PlaneFootLineConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.foot;\n signature = { points: 1, elements: 1, integers: 0, elementTypes: [PlaneElement] };\n\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const fo = new PlaneFootElement(P[0], E[0] as PlaneElement);\n const g = new LineElement({A: P[0], B: fo});\n return [[fo, g], g];\n }\n}\n\n// line\n// chord\n// points A, B, circle C\n// the chord of circle C cut by the line AB\n// (post-LineElement-expansion: A, B are the two endpoints of the input line)\n// (Java: Slate.java line case 4 — new Chord(A,B,C). Java: Chord.java)\nexport class ChordConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.chord;\n signature = { points: 2, elements: 1, integers: 0, elementTypes: [CircleElement] };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new Chord({D: P[0], E: P[1], C: E[0] as CircleElement});\n return [[g], g];\n }\n}\n\n// line\n// bichord\n// circles A, B\n// the common chord connecting the two intersection points of the circles A and B\n// (Java: Slate.java line case 5 — new Bichord(A,B). Java: Bichord.java)\nexport class BichordConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.bichord;\n signature = { points: 0, elements: 2, integers: 0, elementTypes: [CircleElement, CircleElement] };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new Bichord({C: E[0] as CircleElement, D: E[1] as CircleElement});\n return [[g], g];\n }\n}\n\n// Line perpendicular constructions — all 5 variants share the same\n// construct() pattern: call the parent point-perpendicular construct(),\n// then return the Perpendicular LineElement (first in elementsForUpdate).\n// (Java: Slate.java line case 6 — all choices dispatch to a Perpendicular\n// or PlanePerpendicular, then return the LineElement directly.)\nfunction wrapPointAsLine(es: [GeomElementsForUpdate, GeomElement]): [GeomElementsForUpdate, GeomElement] {\n return [es[0], es[0][0]];\n}\n\n// line — perpendicular variant 1: points A, B [plane C (screen)]\n// the line from A to the point D so that AD is equal and perpendicular to AB in plane C\n// (Java: Slate.java line case 6, choice 0 — Perpendicular(A,B,screen,A,B))\nexport class LinePerpendicular1Construction extends PointPerpendicular1Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.perpendicular;\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]) { return wrapPointAsLine(super.construct(screen, P, E, N)); }\n}\n\n// line — perpendicular variant 2: points A, B, plane C\n// (Java: Slate.java line case 6, choice 1 — Perpendicular(A,B,C,A,B))\nexport class LinePerpendicular2Construction extends PointPerpendicular2Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.perpendicular;\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]) { return wrapPointAsLine(super.construct(screen, P, E, N)); }\n}\n\n// line — perpendicular variant 3: points A, B, D, E [plane C (screen)]\n// (Java: Slate.java line case 6, choice 2 — Perpendicular(A,B,screen,D,E))\nexport class LinePerpendicular3Construction extends PointPerpendicular3Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.perpendicular;\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]) { return wrapPointAsLine(super.construct(screen, P, E, N)); }\n}\n\n// line — perpendicular variant 4: points A, B, plane C, points D, E\n// (Java: Slate.java line case 6, choice 3 — Perpendicular(A,B,C,D,E))\nexport class LinePerpendicular4Construction extends PointPerpendicular4Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.perpendicular;\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]) { return wrapPointAsLine(super.construct(screen, P, E, N)); }\n}\n\n// line — perpendicular variant 5: point A, plane B, points C, D\n// (Java: Slate.java line case 6, choice 4 — PlanePerpendicularLine(A,B,C,D))\nexport class LinePerpendicular5Construction extends PointPerpendicular5Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.perpendicular;\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]) { return wrapPointAsLine(super.construct(screen, P, E, N)); }\n}\n\n// line\n// cutoff\n// points A, B, C, D\n// the line AE equal to CD along the line AB\n// (Java: Slate.java line case 7 — Layoff(A,A,B,C,D) + LineElement(A,layoff))\nexport class LineCutoffConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.cutoff;\n signature = { points: 4, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let lo = new Layoff(P[0], P[0], P[1], P[2], P[3]);\n let g = new LineElement({A: P[0], B: lo});\n return [[lo, g], g];\n }\n}\n\n// line\n// extend\n// points A, B, C, D\n// the line BE equal to CD so that A, B, and C are collinear with B between A and C\n// (Java: Slate.java line case 8 — Layoff(B,A,B,C,D) + LineElement(B,layoff))\nexport class LineExtendConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.extend;\n signature = { points: 4, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let lo = new Layoff(P[1], P[0], P[1], P[2], P[3]);\n let g = new LineElement({A: P[1], B: lo});\n return [[lo, g], g];\n }\n}\n\n// line\n// parallel\n// points A, B, C\n// the line AD through A parallel and equal to BC, so D = A + (C - B)\n// (no dedicated Java class — Slate.java case 9 dispatches to a Layoff\n// trick: Layoff(A, B, C, B, C) gives D = A + (C-B), then wraps a fresh\n// LineElement(A, D). Same pattern as LineExtendConstruction above.)\nexport class LineParallelConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.parallel;\n signature = { points: 3, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let lo = new Layoff(P[0], P[1], P[2], P[1], P[2]);\n let g = new LineElement({A: P[0], B: lo});\n return [[lo, g], g];\n }\n}\n\n// line\n// similar — points A, B, D, E, F [, planes C, G = screen]\n// the line AH so that triangle ABH is similar to triangle DEF\n// 2D: 5 points, 0 elements — uses screen plane for both\n// 3D: 5 points, 2 PlaneElements — uses explicit planes\n// (Java: Slate.java line case 10 — Similar(A,B,C,D,E,F,G) + LineElement(A,H))\nexport class SimilarLineConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.similar;\n signature: ConstructionSignature = { points: 5, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 5 && sp.N.length === 0\n && (sp.E.length === 0 || sp.E.length === 2);\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let c = E.length > 0 ? E[0] as PlaneElement : screen;\n let g2 = E.length > 1 ? E[1] as PlaneElement : screen;\n let sim = new SimilarElement(P[0], P[1], c, P[2], P[3], P[4], g2);\n let g = new LineElement({A: P[0], B: sim});\n return [[sim, g], g];\n }\n}\n\n// line\n// proportion\n// 8 points A, B, C, D, E, F, G, H\n// the line GI along GH so that AB:CD = EF:GI\n// (Java: Slate.java line case 11 — Proportion + LineElement(G, result))\nexport class ProportionLineConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.proportion;\n signature = { points: 8, elements: 0, integers: 0 };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let prop = new ProportionElement(P[0], P[1], P[2], P[3], P[4], P[5], P[6], P[7]);\n let g = new LineElement({A: P[6], B: prop});\n return [[prop, g], g];\n }\n}\n\n// line\n// meanProportional\n// 6 points S0, S1, T0, T1, U0, U1\n// the line U0U' along U0U1 so that S:U' = U':T\n// (Java: Slate.java line case 12 — MeanProportional + LineElement(U0, result))\nexport class MeanProportionalLineConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.meanProportional;\n signature = { points: 6, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let mp = new MeanProportionalElement(P[0], P[1], P[2], P[3], P[4], P[5]);\n let g = new LineElement({A: P[4], B: mp});\n return [[mp, g], g];\n }\n}\n\n// line — path — an ordered list of 2+ points\n// An open path (polyline) A → B → C → … that does NOT close back to the\n// first point — the multi-segment generalization of line;connect, a\n// one-dimensional connected route highlightable as one element (#121, the\n// \"bent line\" of Heron's I.20). Variable arity, so validateSignature\n// overrides the default fixed-count match: any number (≥2) of points.\nexport class PolylineConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.path;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.E.length === 0 && sp.N.length === 0 && sp.P.length >= 2;\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new PolylineElement(P.slice());\n return [[g], g];\n }\n}\n\nexport const lineConstructions: Construction[] = [\n new PolylineConstruction(),\n new LineConnectConstruction(),\n new LineExtendConstruction(),\n new LinePerpendicular1Construction(),\n new LinePerpendicular2Construction(),\n new LinePerpendicular3Construction(),\n new LinePerpendicular4Construction(),\n new LinePerpendicular5Construction(),\n new BichordConstruction(),\n new ChordConstruction(),\n new LineParallelConstruction(),\n new LineCutoffConstruction(),\n new PlaneFootLineConstruction(),\n new LineFootConstruction(),\n new SimilarLineConstruction(),\n new ProportionLineConstruction(),\n new AngleBisectorLineConstruction(),\n new AngleDividerLineConstruction(),\n new MeanProportionalLineConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tLineElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\n\nimport {PointElement} from \"../point/PointElement\";\nimport {GeomElement} from \"../GeomElement\";\nimport {SlateCanvas} from \"../../Slate\";\n\ninterface ILineElementConstructor {\n A : PointElement;\n B : PointElement;\n}\n\nexport class LineElement extends GeomElement {\n protected _A : PointElement;\n\n get A() : PointElement { return this._A; }\n\n protected _B : PointElement;\n get B() : PointElement { return this._B; }\n\n constructor(ile?: ILineElementConstructor) {\n super();\n this.dimension = 1;\n this._A = ile && ile.A || null;\n this._B = ile && ile.B || null;\n }\n\n public drawEdge(c: HTMLCanvasElement, color?: string): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (color == null) {\n if (this.emphasized || this.shouldHighlight) {\n color = this.edgeHighlightColor;\n } else {\n color = this.edgeColor;\n }\n }\n\n if (color == null) return;\n\n let ctx = c.getContext(\"2d\");\n ctx.strokeStyle = color;\n // Stroke weight scales smoothly. Baseline is 1 (normal) or 3\n // (slide-highlight); emphasisAmount interpolates up to 6 for\n // full emphasis. emphasisAmount = 0 → baseline; 1 → 6 px;\n // animator fades 1 → 0 over ~250 ms at the end of a transition\n // so the post-animation settle isn't a hard pop.\n const baseW = this.shouldHighlight ? 3 : 1;\n ctx.lineWidth = (baseW + this.emphasisAmount * (6 - baseW)) * GeomElement.styleScale;\n // Slide-transition animation: drawProgress < 1 traces only the\n // first `progress` fraction of the line A → B. Default 1 keeps\n // the full-line behaviour every existing consumer relies on.\n let p = this.drawProgress;\n let endX = this._A.x + (this._B.x - this._A.x) * p;\n let endY = this._A.y + (this._B.y - this._A.y) * p;\n ctx.beginPath();\n ctx.moveTo(this._A.x, this._A.y);\n ctx.lineTo(endX, endY);\n ctx.stroke();\n }\n\n public drawFace(c: SlateCanvas): void {\n }\n\n public drawName(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.nameColor == null || this.name == null) return;\n if (this._A == null || !this._A.defined()) return;\n if (this._B == null || !this._B.defined()) return;\n const ix = Math.round((this._A.x + this._B.x) / 2);\n const iy = Math.round((this._A.y + this._B.y) / 2);\n this.drawString(ix, iy, c);\n }\n\n public drawVertex(c: SlateCanvas): void {\n }\n\n public rotate(pivot: PointElement, ac: number, as: number): void {\n }\n\n public translate(dx: number, dy: number): void {\n }\n\n public update(): void {\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPerpendicular.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\n\nimport {PointElement} from \"../point/PointElement\";\nimport {SlateCanvas} from \"../../Slate\";\nimport {LineElement} from \"./LineElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport interface IPerpendicularElementConstructor {\n C : PointElement;\n D : PointElement;\n P : PlaneElement;\n E : PointElement;\n F : PointElement;\n}\n\nexport class Perpendicular extends LineElement {\n // draw perpendicular to CD in the plane P. A is the proj of\n // C onto P, while AB is perpendicular to CD and equals EF.\n\n protected _C : PointElement;\n protected _D : PointElement;\n protected _E : PointElement;\n protected _F : PointElement;\n protected _P : PlaneElement;\n\n constructor(ipe?: IPerpendicularElementConstructor) {\n super();\n this.dimension = 1;\n if(ipe == null) return;\n this._P = ipe.P;\n this._A = new PointElement({AP: ipe.P});\n this._B = new PointElement({AP: ipe.P});\n this._C = ipe.C;\n this._D = ipe.D;\n this._E = ipe.E;\n this._F = ipe.F;\n }\n\n public rotate(pivot: PointElement, ac: number, as: number): void {\n this.A.rotate(pivot, ac, as);\n this.B.rotate(pivot, ac, as);\n }\n\n public translate(dx: number, dy: number): void {\n this.A.translate(dx,dy);\n this.B.translate(dx,dy);\n }\n\n public update(): void {\n this._A.to(this._C).toPlane(this._P);\n this._B.to(this._D).minus(this._A);\n let Bs : number = PointElement.dot(this.B,this._P.S);\n let Bt : number = PointElement.dot(this.B,this._P.T);\n let factor : number = Math.sqrt(this._E.distance2(this._F)/(Bs*Bs+Bt*Bt));\n Bs = -Bs/factor;\n Bt /= factor;\n this._B.x = Bt*this._P.S.x + Bs*this._P.T.x + this._A.x;\n this._B.y = Bt*this._P.S.y + Bs*this._P.T.y + this._A.y;\n this._B.z = Bt*this._P.S.z + Bs*this._P.T.z + this._A.z;\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPlanePerpendicularLine.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2023, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"../point/PointElement\";\nimport {SlateCanvas} from \"../../Slate\";\nimport {LineElement} from \"./LineElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {IPerpendicularElementConstructor} from \"./Perpendicular\";\n\nexport interface IPlanePerpendicularLineConstructor {\n C : PointElement;\n P : PlaneElement;\n D : PointElement;\n E : PointElement;\n}\n\nexport class PlanePerpendicularLine extends LineElement {\n \n // draw perpendicular at C to the plane P. A is the proj of C onto P, while\n // AB is perpendicular to P and equal to DE\n\n protected _C : PointElement;\n protected _P : PlaneElement;\n protected _D : PointElement;\n protected _E : PointElement;\n \n // The line AB will be perpendicular to the plane P. A will be the projection\n // of C on to the plane P. AB will equal DE.\n\n constructor(ipe?: IPlanePerpendicularLineConstructor) {\n super();\n this.dimension = 1;\n if(ipe == null) return;\n this._A = new PointElement({AP: ipe.P});\n this._B = new PointElement();\n this._C = ipe.C;\n this._D = ipe.D;\n this._E = ipe.E;\n this._P = ipe.P;\n }\n\n public rotate(pivot: PointElement, ac: number, as: number): void {\n this.A.rotate(pivot, ac, as);\n this.B.rotate(pivot, ac, as);\n }\n\n public translate(dx: number, dy: number): void {\n this.A.translate(dx,dy);\n this.B.translate(dx,dy);\n }\n\n public update(): void {\n this._A.to(this._C).toPlane(this._P);\n this._B.toCross(this._P.S, this._P.T);\n this._B.times(this._D.distance(this._E)).plus(this._A)\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPolylineElement.ts |\n| Part of the geomlib port of David E. Joyce's Geometry Applet. |\n| TypeScript: 2026, Nelson Brown, brownnrl@gmail.com |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"../point/PointElement\";\nimport {GeomElement} from \"../GeomElement\";\nimport {SlateCanvas} from \"../../Slate\";\n\n// An open path (polyline): an ordered run of connected segments through\n// the given points (A → B → C → …) that, unlike a polygon, does NOT close\n// back to the first point. It is a one-dimensional route — the \"bent line\"\n// of, e.g., Heron's minimum-distance problem (the path A→E→B) — drawn and\n// highlightable as ONE element, so a prose ref to the whole route lights\n// every segment together.\n//\n// Mirrors PolygonElement's edge trace (drawProgress-aware), but open and\n// with no face. Its points are independent slate elements that move by\n// their own handlers, so translate/rotate are no-ops.\nexport class PolylineElement extends GeomElement {\n\n public V : PointElement[];\n\n constructor(ps?: PointElement[]) {\n super();\n this.dimension = 1;\n this.V = ps == null ? [] : ps;\n }\n\n public defined() : boolean {\n if (this.V.length < 2) return false;\n for (let v of this.V) if (!v.defined()) return false;\n return true;\n }\n\n public drawEdge(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n const color = (this.emphasized || this.shouldHighlight)\n ? this.edgeHighlightColor\n : this.edgeColor;\n if (color == null || this.V.length < 2) return;\n\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.beginPath();\n ctx.strokeStyle = color;\n {\n const baseW = this.shouldHighlight ? 3 : 1;\n ctx.lineWidth = (baseW + this.emphasisAmount * (6 - baseW)) * GeomElement.styleScale;\n }\n // Open path: V.length - 1 edges (no closing edge). Each integer\n // step of drawProgress · edgeCount advances one full segment; the\n // fractional remainder partially traces the next. drawProgress = 1\n // (default) traces the whole route.\n const n = this.V.length;\n const edgeCount = n - 1;\n const total = this.drawProgress * edgeCount;\n const fullEdges = Math.floor(total);\n const frac = total - fullEdges;\n\n ctx.moveTo(this.V[0].x, this.V[0].y);\n for (let i = 0; i < fullEdges; i++) {\n const to = this.V[i + 1];\n ctx.lineTo(to.x, to.y);\n ctx.stroke();\n }\n if (frac > 0 && fullEdges < edgeCount) {\n const from = this.V[fullEdges];\n const to = this.V[fullEdges + 1];\n ctx.lineTo(from.x + (to.x - from.x) * frac, from.y + (to.y - from.y) * frac);\n ctx.stroke();\n }\n }\n\n // Open route: no enclosed area to fill.\n public drawFace(c: SlateCanvas) : void {}\n\n public drawVertex(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.vertexColor != null && this.defined()) {\n for (let v of this.V) v.drawVertex(c, this.vertexColor);\n }\n }\n\n public drawName(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.nameColor != null && this.name != null && this.defined()) {\n let x = 0, y = 0;\n for (let v of this.V) { x += v.x; y += v.y; }\n const k = this.V.length;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n let [w, h] = this._getTextMetrics(ctx, this._name);\n ctx.beginPath();\n ctx.fillStyle = this.nameColor;\n ctx.fillText(this._name, x / k - w / 2, y / k + h / 4);\n }\n }\n\n public rotate(pivot: PointElement, ac: number, as: number) : void {}\n public translate(dx: number, dy: number) : void {}\n public update() : void {}\n}\n","/*----------------------------------------------------------------------+\n| Title:\tParallelPlane.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PlaneElement} from \"./PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\n\nexport class ParallelPlane extends PlaneElement {\n /*--------------------------------------------------------------------+\n | this is the plane parallel to the plane P passing through the |\n | point A |\n +--------------------------------------------------------------------*/\n\n private _P: PlaneElement;\n\n constructor(P: PlaneElement, A: PointElement) {\n super();\n this.dimension = 2;\n this._P = P;\n this.A = A;\n this.B = new PointElement();\n this.C = new PointElement();\n this.S = P.S;\n this.T = P.T;\n this.U = P.U;\n }\n\n public translate(dx: number, dy: number) {\n this.B.translate(dx, dy);\n this.C.translate(dx, dy);\n }\n\n public rotate(pivot: PointElement, ac: number, as: number) {\n this.B.rotate(pivot, ac, as);\n this.C.rotate(pivot, ac, as);\n }\n\n public update() {\n this.B.to(this._P.B).minus(this._P.A).plus(this.A);\n this.C.to(this._P.C).minus(this._P.A).plus(this.A);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPerpendicularPlane.ts |\n| Originally: PerpendicularPL.java (renamed for clarity) |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2024, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"../point/PointElement\";\nimport {PlaneElement} from \"./PlaneElement\";\n\nexport interface IPerpendicularPlaneElementConstruction {\n A : PointElement;\n E : PointElement;\n}\n\nexport class PerpendicularPlane extends PlaneElement {\n\n // this is the plane perpendicular to the line AE at the point A\n\n public E : PointElement;\n\n constructor(ippe? : IPerpendicularPlaneElementConstruction) {\n super();\n this.A = ippe.A;\n this.E = ippe.E;\n this.B = new PointElement({AP: this});\n this.C = new PointElement({AP: this});\n this.S = new PointElement();\n this.T = new PointElement();\n }\n\n translate(dx: number, dy: number) : void {\n this.B.translate(dx, dy);\n this.C.translate(dx, dy);\n }\n\n rotate(pivot : PointElement, ac: number, as: number) {\n this.B.rotate(pivot, ac, as);\n this.C.rotate(pivot, ac, as);\n super.update();\n }\n\n update() {\n this.U = PointElement.difference(this.E,this.A);\n let len : number = this.U.length();\n // TODO: Check division by 0?\n this.U.times(1.0/len);\n let lxy : number = Math.sqrt(this.U.x*this.U.x + this.U.y*this.U.y);\n if(lxy >= 0.000001) {\n this.S.x = -this.U.y/lxy;\n this.S.y = this.U.x/lxy;\n this.T.toCross(this.U,this.S);\n } else {\n this.S.x = 1.0;\n this.S.y = 0.0;\n this.S.z = 0.0;\n this.T.x = 0.0;\n this.T.y = 1.0;\n this.T.z = 0.0;\n }\n this.B.to(this.S).times(len).plus(this.A);\n this.C.to(this.T).times(len).plus(this.A);\n }\n}\n","/*----------------------------------------------------------------------+\n| Plane construction classes — extracted from Constructions.ts |\n+----------------------------------------------------------------------*/\n\nimport {Construction, AllConstructions,\n PlaneConstructions as PlaneConstructionsEnum,\n GeomElementsForUpdate} from \"../Constructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {PlaneElement} from \"./PlaneElement\";\nimport {PerpendicularPlane} from \"./PerpendicularPlane\";\nimport {ParallelPlane} from \"./ParallelPlane\";\n\n// plane — 3points — points A, B, C\n// (Java: Slate.java plane case 0 — new PlaneElement(A, B, C))\nexport class Plane3PointsConstruction extends Construction {\n constructionMethod: AllConstructions = PlaneConstructionsEnum.threePoints;\n signature = { points: 3, elements: 0, integers: 0 };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new PlaneElement({A: P[0], B: P[1], C: P[2]});\n return [[g], g];\n }\n}\n\n// plane — perpendicular — points A, B\n// (Java: Slate.java plane case 1 — new PerpendicularPL(A,B))\nexport class PerpendicularPlaneConstruction extends Construction {\n constructionMethod: AllConstructions = PlaneConstructionsEnum.perpendicular;\n signature = { points: 2, elements: 0, integers: 0 };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new PerpendicularPlane({A: P[0], E: P[1]});\n return [[g], g];\n }\n}\n\n// plane — parallel — plane P, point A\n// (Java: ParallelP.java — 26 lines, line-for-line port)\nexport class PlaneParallelConstruction extends Construction {\n constructionMethod: AllConstructions = PlaneConstructionsEnum.parallel;\n signature = { points: 1, elements: 1, integers: 0, elementTypes: [PlaneElement] };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new ParallelPlane(E[0] as PlaneElement, P[0]);\n return [[g], g];\n }\n}\n\n// plane — ambient (point variant) — point A\n// (Java: Slate.java plane case 3, choice 0 — returns P[0].AP)\nexport class AmbientPlanePointConstruction extends Construction {\n constructionMethod: AllConstructions = PlaneConstructionsEnum.ambient;\n signature = { points: 1, elements: 0, integers: 0 };\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n return [[P[0]._AP], P[0]._AP];\n }\n}\n\n// plane — ambient (circle variant) — circle A\n// (Java: Slate.java plane case 3, choice 1 — returns ((CircleElement)E[0]).AP)\nexport class AmbientPlaneCircleConstruction extends Construction {\n constructionMethod: AllConstructions = PlaneConstructionsEnum.ambient;\n signature = { points: 0, elements: 1, integers: 0, elementTypes: [CircleElement] };\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const c = E[0] as CircleElement;\n return [[c.AP], c.AP];\n }\n}\n\nexport const planeConstructions: Construction[] = [\n new Plane3PointsConstruction(),\n new PerpendicularPlaneConstruction(),\n new PlaneParallelConstruction(),\n new AmbientPlanePointConstruction(),\n new AmbientPlaneCircleConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tPlaneElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {GeomElement} from \"../GeomElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {SlateCanvas} from \"../../Slate\";\n\n\nexport interface IPlaneElementConstruction {\n A : PointElement;\n B : PointElement;\n C : PointElement;\n}\n\ntype iplec = IPlaneElementConstruction\n\nexport class PlaneElement extends GeomElement {\n\n /*--------------------------------------------------------------------+\n | The plane is represented by three points on it. It's displayed as |\n | a parallelogram with three vertices A, B, and C,projected onto the |\n | xy-plane. S is a unit vector in the direction AB, T is a |\n | perpendicular unit in the plane, and U is perpendicular to both. |\n +--------------------------------------------------------------------*/\n public A : PointElement;\n public B : PointElement;\n public C : PointElement;\n public S : PointElement;\n public T : PointElement;\n public U : PointElement;\n\n public pivot : PointElement; // pivot point for the plane, if any\n public isScreen : boolean; // set true only for initial screen plane\n\n constructor(ip? : IPlaneElementConstruction) {\n super();\n this.dimension = 2;\n this.isScreen = false;\n if (ip != null) {\n this.A = ip.A;\n this.B = ip.B;\n this.C = ip.C;\n this.S = new PointElement();\n this.T = new PointElement();\n this.U = new PointElement();\n }\n }\n\n public defined(): boolean {\n return this.A != null && this.B != null && this.C != null;\n }\n\n // A plane renders as a parallelogram with corners A, B, D, C\n // where D = B + C - A (the 4th corner in the plane of A, B, C).\n\n public drawEdge(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.edgeColor == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.save();\n ctx.strokeStyle = this.edgeColor;\n let dx = this.B.x + this.C.x - this.A.x;\n let dy = this.B.y + this.C.y - this.A.y;\n ctx.beginPath();\n ctx.moveTo(this.A.x, this.A.y);\n ctx.lineTo(this.B.x, this.B.y);\n ctx.lineTo(dx, dy);\n ctx.lineTo(this.C.x, this.C.y);\n ctx.closePath();\n ctx.stroke();\n ctx.restore();\n }\n\n public drawFace(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.faceColor == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.save();\n ctx.fillStyle = this.faceColor;\n let dx = this.B.x + this.C.x - this.A.x;\n let dy = this.B.y + this.C.y - this.A.y;\n ctx.beginPath();\n ctx.moveTo(this.A.x, this.A.y);\n ctx.lineTo(this.B.x, this.B.y);\n ctx.lineTo(dx, dy);\n ctx.lineTo(this.C.x, this.C.y);\n ctx.closePath();\n ctx.fill();\n ctx.restore();\n }\n\n public drawName(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.nameColor == null || this.name == null || !this.defined()) return;\n // Label placed at midpoint of BC, matching Java PlaneElement.drawName\n let ix = Math.round((this.B.x + this.C.x) / 2.0);\n let iy = Math.round((this.B.y + this.C.y) / 2.0);\n this.drawString(ix, iy, c);\n }\n\n public drawVertex(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.vertexColor == null || !this.defined()) return;\n // Draw vertex at D = B + C - A (the 4th parallelogram corner).\n // A, B, C are drawn by their own drawVertex calls in Slate.\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n let dx = this.B.x + this.C.x - this.A.x;\n let dy = this.B.y + this.C.y - this.A.y;\n ctx.beginPath();\n ctx.fillStyle = this.vertexColor;\n ctx.arc(dx, dy, 2, 0, 2*Math.PI, false);\n ctx.fill();\n }\n\n public rotate(pivot: PointElement, ac: number, as: number): void {\n this.update();\n }\n\n public translate(dx: number, dy: number): void {\n }\n\n public update(): void {\n if (this.isScreen && (this.A.z!=0.0 || this.B.z!=0.0 || this.C.z!=0.0))\n this.isScreen = false;\n // update the frame S,T,U\n this.S.to(this.B).minus(this.A);\n this.T.to(this.C).minus(this.A);\n this.S.times(1.0/this.S.length());\n let st : number = PointElement.dot(this.T, this.S);\n this.T.x -= st*this.S.x;\n this.T.y -= st*this.S.y;\n this.T.z -= st*this.S.z;\n this.T.times(1.0/this.T.length());\n this.U.toCross(this.S,this.T);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tAngleDividerElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class AngleDividerElement extends PointElement {\n /*--------------------------------------------------------------------+\n | n-sect angle BAC in the ambient plane AP |\n +--------------------------------------------------------------------*/\n\n private _A: PointElement; // vertex of the angle\n private _B: PointElement; // first ray point\n private _C: PointElement; // second ray point\n private _n: number; // divisor (2 = bisector)\n\n constructor(B: PointElement, A: PointElement, C: PointElement,\n AP: PlaneElement, n: number) {\n super();\n this.dimension = 0;\n this._A = A;\n this._B = B;\n this._C = C;\n this._AP = AP;\n this._n = n;\n }\n\n public update() {\n let theta : number = this._A.angle(this._B, this._C, this._AP) / this._n;\n let cos : number = Math.cos(theta);\n let sin : number = Math.sin(theta);\n if (this._AP.isScreen) {\n this._x = this._A.x + cos * (this._B.x - this._A.x) - sin * (this._B.y - this._A.y);\n this._y = this._A.y + sin * (this._B.x - this._A.x) + cos * (this._B.y - this._A.y);\n this._z = 0.0;\n } else {\n this.to(this._B).rotate(this._A, cos, sin, this._AP);\n }\n this.toIntersection(this, this._A, this._B, this._C, this._AP);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tCircleSlider.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\nimport {PointElement} from \"./PointElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\n\nexport class CircleSlider extends PointElement {\n _C : CircleElement;\n _initx : number;\n _inity : number;\n _initz : number;\n\n _newP : PointElement = new PointElement();\n\n constructor(C: CircleElement,\n x: number, y: number, z: number) {\n super();\n this.dimension = 0;\n this.draggable = true;\n this._C = C;\n this._x = x;\n this._initx = x;\n this._y = y;\n this._inity = y;\n this._z = z;\n this._initz = z;\n }\n\n public reset() {\n this._x = this._initx;\n this._y = this._inity;\n this._z = this._initz;\n this.toCircle(this._C);\n }\n\n public update() {\n this.toCircle(this._C);\n }\n\n public drag(tox: number, toy: number): boolean {\n this._x = tox;\n this._y = toy;\n if (!this.defined()) this._z = this._initz;\n this._newP.to(this).uptoPlane(this._C.AP);\n if (!this._newP.defined())\t// vertical plane\n this._newP.to(this).toPlane(this._C.AP);\n this._newP.toSphere(this._C.Center, this._C.radius);\n if ((this._newP.x-this.x)*(this._newP.x-this.x) +\n (this._newP.y-this.y)*(this._newP.y-this.y) < 0.5)\n return false;\n this.to(this._newP);\n return true;\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tFixedPoint.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\nimport {PointElement, IPointElementConstruction} from \"./PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class FixedPoint extends PointElement {\n\n protected _initx : number;\n protected _inity : number;\n protected _initz : number;\n\n constructor(ip? : IPointElementConstruction) {\n super(ip);\n this._initx = this._x;\n this._inity = this._y;\n this._initz = this._z;\n }\n\n public reset() : void {\n this._x = this._initx;\n this._y = this._inity;\n this._z = this._initz;\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tFoot.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2024, Nelson Brown, brownnrl@gmail.com |\n+----------------------------------------------------------------------*/\nimport {PointElement} from \"./PointElement\";\n\nexport class Foot extends PointElement {\n _A : PointElement;\n _B : PointElement;\n _C : PointElement;\n\n constructor(A: PointElement, B: PointElement, C: PointElement) {\n super();\n this.dimension = 0;\n this._A = A;\n this._B = B;\n this._C = C;\n if (this._B.AP == this._C.AP) {\n this._AP = this._B.AP;\n }\n }\n\n public update() : void {\n this.to(this._A).toLine(this._B, this._C, false)\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tHarmonicElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\n\nexport class HarmonicElement extends PointElement {\n /*--------------------------------------------------------------------+\n | The harmonic conjugate A of B with respect to the points C and D. |\n | If B,C,D are collinear, then A also lies on that line; if not, |\n | A lies on the circumcircle through B,C,D. |\n +--------------------------------------------------------------------*/\n\n private _B: PointElement;\n private _C: PointElement;\n private _D: PointElement;\n private _E: PointElement;\n private _F: PointElement;\n private _M: PointElement;\n\n constructor(B: PointElement, C: PointElement, D: PointElement) {\n super();\n this.dimension = 0;\n this._B = B;\n this._C = C;\n this._D = D;\n this._E = new PointElement();\n this._F = new PointElement();\n this._M = new PointElement();\n }\n\n public update() {\n if (this._B.z === 0.0 && this._C.z === 0.0 && this._D.z === 0.0) {\n // 2D case: treat B,C,D as complex numbers\n // A = (C(B-D) + D(B-C)) / ((B-D) + (B-C))\n let Ex = this._B.x - this._C.x, Ey = this._B.y - this._C.y;\n let Fx = this._B.x - this._D.x, Fy = this._B.y - this._D.y;\n let BFx = this._C.x * Fx - this._C.y * Fy;\n let BFy = this._C.x * Fy + this._C.y * Fx;\n let DEx = this._D.x * Ex - this._D.y * Ey;\n let DEy = this._D.x * Ey + this._D.y * Ex;\n let den = (Fx + Ex) * (Fx + Ex) + (Fy + Ey) * (Fy + Ey);\n let numx = (BFx + DEx) * (Fx + Ex) + (BFy + DEy) * (Fy + Ey);\n let numy = -(BFx + DEx) * (Fy + Ey) + (BFy + DEy) * (Fx + Ex);\n this._x = numx / den;\n this._y = numy / den;\n } else {\n // 3D case\n this._M.to(this._C).plus(this._D).times(0.5); // M = (C+D)/2\n this._F.to(this._C).minus(this._M); // F = C-M\n this._E.to(this._B).minus(this._M); // E = B-M\n let rB2 = 1.0 / this._E.length2();\n let C2 = this._F.length2();\n this.to(this._F)\n .times(2.0 * PointElement.dot(this._E, this._F))\n .minus(this._E.times(C2))\n .times(rB2)\n .plus(this._M);\n }\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tIntersection.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2024, Nelson Brown, brownnrl@gmail.com |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class Intersection extends PointElement {\n \n A : PointElement;\n B : PointElement;\n C : PointElement;\n D : PointElement;\n\n constructor(A: PointElement,\n B: PointElement,\n C: PointElement,\n D: PointElement,\n AP: PlaneElement) {\n super({AP: AP});\n this.dimension = 0;\n this.A = A;\n this.B = B;\n this.C = C;\n this.D = D;\n }\n\n update(): void {\n this.toIntersection(this.A, this.B, this.C, this.D, this.AP);\n }\n}\n\n\n","/*----------------------------------------------------------------------+\n| Title:\tInvertPointElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\n\nexport class InvertPointElement extends PointElement {\n /*--------------------------------------------------------------------+\n | Invert the point A in the circle C to get this point |\n +--------------------------------------------------------------------*/\n\n private _A: PointElement;\n private _C: CircleElement;\n\n constructor(A: PointElement, C: CircleElement) {\n super();\n this.dimension = 0;\n this._A = A;\n this._C = C;\n this._AP = C.AP;\n }\n\n public update() {\n this.toInvertPoint(this._A, this._C);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tLayoff.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\n\nexport class Layoff extends PointElement {\n\n // Lay off a line AB with endpoint A given, so that AB is parallel to CD\n // and equal to EF. (this is B)\n\n protected _A : PointElement;\n protected _C : PointElement;\n protected _D : PointElement;\n protected _E : PointElement;\n protected _F : PointElement;\n\n\n constructor(A: PointElement,\n C: PointElement,\n D: PointElement,\n E: PointElement,\n F: PointElement) {\n super();\n this.dimension = 0;\n this._A = A;\n this._C = C;\n this._D = D;\n this._E = E;\n this._F = F;\n if (A.AP == C.AP && A.AP == D.AP) {\n this._AP = A.AP;\n }\n }\n\n public update() {\n let factor : number = this._E.distance(this._F) / this._C.distance(this._D);\n this.to(this._D).minus(this._C);\n this.times(factor).plus(this._A);\n }\n\n}\n","/*----------------------------------------------------------------------+\n| Title:\tLineSlider.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\nimport {PointElement} from \"./PointElement\";\n\nexport class LineSlider extends PointElement {\n _A : PointElement;\n _B : PointElement;\n _initx : number;\n _inity : number;\n _initz : number;\n _segment : boolean;\n\n constructor(A: PointElement, B: PointElement,\n x: number, y: number, z: number, segment: boolean) {\n super();\n this.dimension = 0;\n this.draggable = true;\n this._A = A;\n this._B = B;\n this._x = x;\n this._initx = x;\n this._y = y;\n this._inity = y;\n this._z = z;\n this._initz = z;\n this._segment = segment;\n if(this._A.AP == this._B.AP) this._AP = this._A.AP;\n }\n\n public reset() {\n this._x = this._initx;\n this._y = this._inity;\n this._z = this._initz;\n this.toLine(this._A, this._B, this._segment);\n }\n\n public update() {\n this.toLine(this._A, this._B, this._segment);\n }\n\n public drag(tox: number, toy: number): boolean {\n tox -= this._A.x;\n toy -= this._A.y;\n let dx : number = this._B.x - this._A.x;\n let dy : number = this._B.y - this._A.y;\n let factor : number = (tox*dx + toy*dy)/(dx*dx + dy*dy);\n if (this._segment) {\n if (factor < 0.0) factor = 0.0;\n else if (factor > 1.0) factor = 1.0;\n }\n tox = this._A.x + dx*factor;\n toy = this._A.y + dy*factor;\n if ((tox-this._x)*(tox-this._x) + (tox-this._y)*(tox-this._y) < 0.5) return false;\n // now drag this point\n this._x = tox;\n this._y = toy;\n this._z = this._A.z + (this._B.z-this._A.z)*factor;\n return true;\n }\n}","/*----------------------------------------------------------------------+\n| Title:\tMeanProportionalElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\n\nexport class MeanProportionalElement extends PointElement {\n /*--------------------------------------------------------------------+\n | Given lines S,T,U cut off from U a mean proportional U' so that |\n | S:U'=U':T |\n +--------------------------------------------------------------------*/\n\n private _S0: PointElement;\n private _S1: PointElement;\n private _T0: PointElement;\n private _T1: PointElement;\n private _U0: PointElement;\n private _U1: PointElement;\n\n constructor(S0: PointElement, S1: PointElement, T0: PointElement,\n T1: PointElement, U0: PointElement, U1: PointElement) {\n super();\n this.dimension = 0;\n this._S0 = S0; this._S1 = S1;\n this._T0 = T0; this._T1 = T1;\n this._U0 = U0; this._U1 = U1;\n if (U0._AP === U1._AP) {\n this._AP = U0._AP;\n }\n }\n\n public update() {\n let factor : number = Math.sqrt(this._S0.distance2(this._S1) * this._T0.distance2(this._T1));\n factor = Math.sqrt(factor / this._U0.distance2(this._U1));\n this.to(this._U1).minus(this._U0);\n this.times(factor).plus(this._U0);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tMidpoint.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\nimport {PointElement} from \"./PointElement\";\n\nexport class Midpoint extends PointElement {\n _A : PointElement;\n _B : PointElement;\n\n constructor(A: PointElement, B: PointElement) {\n super();\n this.dimension = 0;\n this._A = A;\n this._B = B;\n if (this._A.AP == this._B.AP) {\n this._AP = this._A.AP;\n }\n }\n\n public update() : void {\n this._x = (this._A.x + this._B.x) / 2.0;\n this._y = (this._A.y + this._B.y) / 2.0;\n this._z = (this._A.z + this._B.z) / 2.0;\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPlaneFootElement.ts |\n| Originally: PlaneFoot.java (renamed for clarity) |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class PlaneFootElement extends PointElement {\n // foot of perpendicular from point A to the ambient plane AP\n\n private _A: PointElement;\n\n constructor(A: PointElement, P: PlaneElement) {\n super();\n this.dimension = 0;\n this._A = A;\n this._AP = P;\n }\n\n public update() {\n this.to(this._A).toPlane(this._AP);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPlaneIntersection.ts |\n| Originally: IntersectionPL.java (renamed for clarity) |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n| |\n| NOTE: This file was previously a copy of Intersection.ts |\n| (line-line intersection). Rewritten 2026-04-12 to implement the |\n| actual plane-line intersection via toIntersectionPL(). |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class PlaneIntersection extends PointElement {\n // this point is the intersection of the ambient plane AP and the line AB\n\n private _A: PointElement;\n private _B: PointElement;\n\n constructor(AP: PlaneElement, A: PointElement, B: PointElement) {\n super();\n this.dimension = 0;\n this._A = A;\n this._B = B;\n this._AP = AP;\n }\n\n update(): void {\n this.toIntersectionPL(this._AP, this._A, this._B);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPlaneSlider.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\nimport {PointElement} from \"./PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class PlaneSlider extends PointElement {\n\n // this point can be dragged anywhere on the ambient plane AP\n\n protected _initx : number;\n protected _inity : number;\n protected _initz : number;\n\n protected _newP : PointElement = new PointElement();\n\n constructor(Qval : PlaneElement, xVal : number, yVal : number, zVal : number) {\n super();\n this.dimension = 0;\n this.draggable = true;\n this._AP = Qval;\n this._x = this._initx = xVal;\n this._y = this._inity = yVal;\n this._z = this._initz = zVal;\n }\n\n public update() : void {\n this.toPlane(this._AP);\n }\n\n public reset() : void {\n this._x = this._initx;\n this._y = this._inity;\n this._z = this._initz;\n this.toPlane(this._AP);\n }\n\n public drag(tox : number, toy : number) : boolean {\n this._x = tox;\n this._y = toy;\n if (!this.defined()) { this._z = this._initz; }\n this._newP.to(this).uptoPlane(this._AP);\n if(this._newP.defined()) {\n this.to(this._newP);\n } else {\n this.toPlane(this._AP);\n }\n\n return true;\n }\n\n\n\n}\n","// Animations targeting PointElement. See ../Animations.ts for the\n// abstract base + registry mechanics.\n\nimport {Animation, AllAnimations, IAnimationStep, registerAnimation} from \"../Animations\";\nimport {GeomElement} from \"../GeomElement\";\nimport {Slate} from \"../../Slate\";\nimport {PointElement} from \"./PointElement\";\nimport {LineSlider} from \"./LineSlider\";\n\n// A.Point.appear — the marker radius scales from 0 to its final value\n// over a short duration. Args: none. Used as the simplest reveal for a\n// point that lands at a constructed position (e.g. Joyce's \"point C at\n// which the circles cut\").\nexport class PointAppearAnimation extends Animation {\n public animationMethod = AllAnimations.POINT_APPEAR;\n public name = \"Point.appear\";\n public elementType = PointElement;\n public defaultDurationMs = 350;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n return [{\n durationMs: this.defaultDurationMs,\n tick: (progress) => {\n target.drawProgress = progress;\n },\n finalise: () => {\n target.drawProgress = 1;\n target.visible = true;\n },\n }];\n }\n}\n\n// A.Point.slide — glide a slider point along its line to a target\n// parameter `t` (the scripted counterpart of a reader dragging it).\n// The point really travels its constraint and its dependents follow.\n// Args: { to: number } — the target parameter along A→B (0 = A, 1 = B;\n// for a segment slider it's clamped to [0,1] by the slider's own\n// projection). Optional durationMs; default ~ a standard transition\n// glide, resolved through the usual chain.\n//\n// elementType is LineSlider — covers both `lineSlider` and\n// `lineSegmentSlider`. A non-slider target warns + falls through to\n// instant (the registry contract).\nexport class PointSlideAnimation extends Animation {\n public animationMethod = AllAnimations.POINT_SLIDE;\n public name = \"Point.slide\";\n public elementType = LineSlider;\n public defaultDurationMs = 650;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const slider = target as LineSlider;\n const to = args && typeof args.to === \"number\" ? args.to : 1;\n // Start + target positions are captured at setup time (after\n // any earlier-slide motion has settled), both on the line A→B,\n // so the lerp between them stays collinear and the slider's own\n // re-projection in update() is a no-op.\n let sx = 0, sy = 0, sz = 0; // start\n let tx = 0, ty = 0, tz = 0; // target = A + t·(B−A)\n const apply = (p: number) => {\n slider.x = sx + (tx - sx) * p;\n slider.y = sy + (ty - sy) * p;\n slider.z = sz + (tz - sz) * p;\n // Drive dependents from the new position this frame.\n slate.update();\n };\n return [{\n durationMs: this.defaultDurationMs,\n setup: () => {\n // A slide is not a reveal — the point is already on\n // stage; undo the animator's reveal pre-zeroing.\n slider.drawProgress = 1;\n slider.visible = true;\n sx = slider.x; sy = slider.y; sz = slider.z;\n const A = (slider as any)._A as PointElement;\n const B = (slider as any)._B as PointElement;\n tx = A.x + (B.x - A.x) * to;\n ty = A.y + (B.y - A.y) * to;\n tz = A.z + (B.z - A.z) * to;\n },\n tick: (progress) => { apply(progress); },\n finalise: () => {\n apply(1);\n slider.drawProgress = 1;\n slider.visible = true;\n },\n }];\n }\n}\n\nregisterAnimation(new PointAppearAnimation());\nregisterAnimation(new PointSlideAnimation());\n","/*----------------------------------------------------------------------+\n| Point construction classes — extracted from Constructions.ts |\n| Each class maps a (type, constructionName, signature) triple to |\n| a construct() method that creates the geometry element. |\n+----------------------------------------------------------------------*/\n\nimport {Construction, ConstructionSignature, SortedParams, AllConstructions, PointConstructions,\n CircleConstructions, GeomElementsForUpdate} from \"../Constructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {CircumcircleElement} from \"../circle/CircumcircleElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"./PointElement\";\nimport {FixedPoint} from \"./FixedPoint\";\nimport {PlaneSlider} from \"./PlaneSlider\";\nimport {Midpoint} from \"./Midpoint\";\nimport {Intersection} from \"./Intersection\";\nimport {PlaneIntersection} from \"./PlaneIntersection\";\nimport {LineSlider} from \"./LineSlider\";\nimport {Layoff} from \"./Layoff\";\nimport {Foot} from \"./Foot\";\nimport {PlaneFootElement} from \"./PlaneFootElement\";\nimport {CircleSlider} from \"./CircleSlider\";\nimport {SimilarElement} from \"./SimilarElement\";\nimport {ProportionElement} from \"./ProportionElement\";\nimport {AngleDividerElement} from \"./AngleDividerElement\";\nimport {MeanProportionalElement} from \"./MeanProportionalElement\";\nimport {HarmonicElement} from \"./HarmonicElement\";\nimport {InvertPointElement} from \"./InvertPointElement\";\nimport {SphereSliderElement} from \"./SphereSliderElement\";\nimport {Perpendicular} from \"../line/Perpendicular\";\nimport {PlanePerpendicularLine} from \"../line/PlanePerpendicularLine\";\nimport {SphereElement} from \"../sphere/SphereElement\";\nimport {PolygonElement} from \"../polygon/PolygonElement\";\n\n/***********************\n * Element Class Point *\n ***********************/\n\n/* point\n * free\n * integers x, y\n * a freely dragable point in the screen plane with initial coordinates (x,y,0)\n * (Java: Slate.java point case 0 — new PlaneSlider(screen, x, y, 0))\n */\nexport class FreePointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.free;\n signature: ConstructionSignature = { points: 0, elements: 0, integers: 2 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new PlaneSlider(screen, N[0], N[1], 0);\n\n return [[g], g];\n }\n\n}\n\n// point\n// midpoint\n// points A, B\n// the midpoint of a line AB\n// (Java: Slate.java point case 1 — new Midpoint(A, B))\nexport class MidPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.midpoint;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new Midpoint(P[0], P[1]);\n\n return [[g], g];\n }\n}\n\n// point\n// intersection\n// points A, B, C, D [, plane E = screen]\n// the intersection of two lines AB and CD in the plane E\n// (Java: Slate.java point case 2 — new Intersection(A,B,C,D,E))\nexport class IntersectionConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.intersection;\n signature: ConstructionSignature = { points: 4, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 4 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new Intersection(P[0], P[1], P[2], P[3], plane);\n return [[g], g];\n }\n}\n\n// point\n// intersection (plane-line variant)\n// plane A, points B, C\n// the intersection of the plane A and the line BC\n// (Java: IntersectionPL.java — TS: PlaneIntersection.ts, renamed for clarity)\nexport class PlaneIntersectionConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.intersection;\n signature: ConstructionSignature = { points: 2, elements: 1, integers: 0, elementTypes: [PlaneElement] };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new PlaneIntersection(E[0] as PlaneElement, P[0], P[1]);\n return [[g], g];\n }\n}\n\n// point\n// first\n// points A, B\n// the first end A of the line AB\n// (Java: Slate.java point case 3 — returns P[0], preexists=true)\nexport class FirstPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.first;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n return [[], P[0]];\n }\n\n}\n\n// point\n// last\n// points A, B\n// the last end B of the line AB\n// (Java: Slate.java point case 4 — returns P[1], preexists=true)\nexport class LastPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.last;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n return [[], P[1]];\n }\n}\n\n// point\n// center\n// circle A\n// the center of the circle A\n// (Java: Slate.java point case 5, choice 0 — returns ((CircleElement)E[0]).Center)\nexport class CircleCenterConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.center;\n signature: ConstructionSignature = { points: 0, elements: 1, integers: 0, elementTypes: [CircleElement] };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n return [[], (E[0] as CircleElement).Center as PointElement];\n }\n}\n\n// point\n// center (sphere variant)\n// sphere A\n// the center of the sphere A\n// (Java: Slate.java point case 5, choice 1 — returns ((SphereElement)E[0]).Center)\nexport class SphereCenterConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.center;\n signature: ConstructionSignature = { points: 0, elements: 1, integers: 0, elementTypes: [SphereElement] };\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n return [[], (E[0] as SphereElement).Center as PointElement];\n }\n}\n\n// point\n// lineSlider\n// points A, B, integers x, y, [z=0]\n// a point that slides along a line AB with initial coordinates (x,y,z)\n// (Java: Slate.java point case 6 — new LineSlider(A,B,x,y,z,false))\nexport class LineSliderConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.lineSlider;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 2 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 2 && sp.E.length === 0 && (sp.N.length === 2 || sp.N.length === 3);\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = this.createSlider(P[0], P[1], N[0], N[1], N.length > 2 ? N[2] : 0);\n return [[g], g];\n }\n protected createSlider(a: PointElement, b: PointElement, x: number, y: number, z: number) {\n return new LineSlider(a, b, x, y, z, false);\n }\n}\n\n// point\n// circleSlider\n// circle A, integers x, y, [z=0]\n// a point that slides along a circle A with given initial coordinates (x,y,z)\n// (Java: Slate.java point case 7 — new CircleSlider(E[0], x, y, z))\nexport class CircleSliderConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.circleSlider;\n signature: ConstructionSignature = { points: 0, elements: 1, integers: 2, elementTypes: [CircleElement] };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 0 && sp.E.length === 1 && (sp.N.length === 2 || sp.N.length === 3)\n && sp.E[0] instanceof CircleElement;\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new CircleSlider(E[0] as CircleElement, N[0], N[1], N.length > 2 ? N[2] : 0);\n return [[g], g];\n }\n}\n\n// circle\n// circumcircle — points A, B, C [, plane D = screen]\n// the circle passing through 3 points A, B, and C in the plane D\n// (Java: Slate.java circle case 1 — new Circumcircle(A,B,C,D))\nexport class CircumcircleConstruction extends Construction {\n constructionMethod: AllConstructions = CircleConstructions.circumcircle;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new CircumcircleElement(P[0], P[1], P[2], plane);\n return [[g], g];\n }\n}\n\n// point\n// circumcenter — points A, B, C [, plane D = screen]\n// the center of a circle ABC passing through 3 points A, B, and C in the plane D\n// (Java: Slate.java point case 8 — new Circumcircle(A,B,C,D), returns circ.Center)\nexport class CircumcenterConstruction extends CircumcircleConstruction {\n constructionMethod: AllConstructions = PointConstructions.circumcenter;\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let es = super.construct(screen, P, E, N);\n let g : CircleElement = es[1] as CircleElement;\n es[0].push(g.Center);\n return [es[0], g.Center];\n }\n}\n\n/* point\n * foot\n * points A, B, C\n * the foot of a perpendicular drawn from A to a line BC\n */\n// (Java: Slate.java point case 10, choice 0 — new Foot(A,B,C))\nexport class FootPointConstruction extends Construction {\n constructionMethod : AllConstructions = PointConstructions.foot;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]) : [GeomElementsForUpdate, GeomElement] {\n let g = new Foot(P[0], P[1], P[2]);\n\n return [[g], g];\n }\n}\n\n// point\n// foot (plane variant — solid geometry)\n// point A plane B\n// the foot of a perpendicular drawn from A to a plane B\n// (Java: PlaneFoot.java — TS: PlaneFootElement.ts, renamed for clarity)\nexport class PlaneFootPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.foot;\n signature: ConstructionSignature = { points: 1, elements: 1, integers: 0, elementTypes: [PlaneElement] };\n\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new PlaneFootElement(P[0], E[0] as PlaneElement);\n return [[g], g];\n }\n}\n\n// point\n// layoff used for extend and cutoff\nexport abstract class LayoffConstruction extends Construction {\n signature: ConstructionSignature = { points: 4, elements: 0, integers: 0 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = this._createLayoff(P);\n return [[g], g];\n }\n\n protected abstract _createLayoff(ps: PointElement[]) : GeomElement;\n}\n\n// point\n// cutoff\n// points A, B, C, D\n// the point E on a line AB so that AE = CD\n// (Java: Slate.java point case 11 — new Layoff(A,A,B,C,D))\nexport class CutoffConstruction extends LayoffConstruction {\n constructionMethod: AllConstructions = PointConstructions.cutoff;\n protected _createLayoff(ps: PointElement[]) : GeomElement {\n return new Layoff(ps[0], ps[0], ps[1], ps[2], ps[3]);\n }\n}\n\n// point\n// extend\n// points A, B, C, D\n// the point E on a line AB so that BE = CD\n// (Java: Slate.java point case 12 — new Layoff(B,A,B,C,D))\nexport class ExtendConstruction extends LayoffConstruction {\n constructionMethod: AllConstructions = PointConstructions.extend;\n protected _createLayoff(ps: PointElement[]) : GeomElement {\n return new Layoff(ps[1], ps[0], ps[1], ps[2], ps[3]);\n }\n}\n\n// point\n// parallelogram\n// points C, A, B\n// the 4th vertex D' of the parallelogram C-A-B-D' given 3 vertices C, A, B\n// D' = C + (B - A) [reuses Layoff with equal direction and length vectors]\n// (Java: Slate.java point case 13 — new Layoff(C,A,B,A,B))\nexport class ParallelogramConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.parallelogram;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new Layoff(P[0], P[1], P[2], P[1], P[2]);\n return [[g], g];\n }\n}\n\n// point\n// similar — points A, B, D, E, F [, planes C, G = screen]\n// the point H so that triangle ABH in plane C is similar to triangle DEF in plane G\n// (Java: Slate.java point case 14 — Similar.java)\nexport class SimilarPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.similar;\n signature: ConstructionSignature = { points: 5, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 5 && sp.N.length === 0\n && (sp.E.length === 0 || sp.E.length === 2);\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let c = E.length > 0 ? E[0] as PlaneElement : screen;\n let g2 = E.length > 1 ? E[1] as PlaneElement : screen;\n let g = new SimilarElement(P[0], P[1], c, P[2], P[3], P[4], g2);\n return [[g], g];\n }\n}\n\n// point perpendicular constructions\nexport abstract class PointPerpendicularConstruction extends Construction {\n constructionMethod : AllConstructions = PointConstructions.perpendicular;\n}\n\n\n/* point\n * perpendicular\n * points A, B, [plane C (screen)]\n * the point D so that AD is equal and perpendicular to AB in plane C\n * (Java: Slate.java point case 15, choice 0 — new Perpendicular(A,B,screen,A,B))\n */\nexport class PointPerpendicular1Construction extends PointPerpendicularConstruction {\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new Perpendicular({C:P[0], D:P[1],P:screen, E:P[0], F:P[1]});\n return [[g], g.B];\n }\n}\n\n\n/* point\n * perpendicular\n * points A, B, plane C\n * the point D so that AD is equal and perpendicular to AB in plane C\n * (Java: Slate.java point case 15, choice 1 — new Perpendicular(A,B,C,A,B))\n */\nexport class PointPerpendicular2Construction extends PointPerpendicularConstruction {\n signature: ConstructionSignature = { points: 2, elements: 1, integers: 0, elementTypes: [PlaneElement] };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new Perpendicular({C:P[0], D:P[1],P:E[0] as PlaneElement, E:P[0], F:P[1]});\n return [[g], g.B];\n }\n}\n\n\n/* point\n * perpendicular\n * points A, B, D, E [plane C (screen)]\n * the point F so that AF is perpendicular to AB in plane C and equals DE\n * (Java: Slate.java point case 15, choice 2 — new Perpendicular(A,B,screen,D,E))\n */\nexport class PointPerpendicular3Construction extends PointPerpendicularConstruction {\n signature: ConstructionSignature = { points: 4, elements: 0, integers: 0 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new Perpendicular({C:P[0], D:P[1],P:screen, E:P[2], F:P[3]});\n return [[g], g.B];\n }\n}\n\n\n/* point\n * perpendicular\n * points A, B, plane C, points D, E\n * the point F so that AF is perpendicular to AB in plane C and equals DE\n * (Java: Slate.java point case 15, choice 3 — new Perpendicular(A,B,C,D,E))\n */\nexport class PointPerpendicular4Construction extends PointPerpendicularConstruction {\n signature: ConstructionSignature = { points: 4, elements: 1, integers: 0, elementTypes: [PlaneElement] };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new Perpendicular({C:P[0], D:P[1],P:E[0] as PlaneElement, E:P[2], F:P[3]});\n return [[g], g.B];\n }\n}\n\n\n/* point\n * perpendicular\n * point A, plane B, points C, D\n * the point E on the line perpendicular to plane B passing through\n * A so that the distance from E to B equals CD\n * (Java: Slate.java point case 15, choice 4 — new PlanePerpendicular(A,B,C,D))\n */\nexport class PointPerpendicular5Construction extends PointPerpendicularConstruction {\n signature: ConstructionSignature = { points: 3, elements: 1, integers: 0, elementTypes: [PlaneElement] };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new PlanePerpendicularLine({C:P[0], P:E[0] as PlaneElement, D:P[1], E:P[2]});\n return [[g], g.B];\n }\n}\n\n\n// point\n// proportion\n// 8 points S0, S1, T0, T1, U0, U1, V0, V1\n// the point V' on V0V1 so that |S0S1|:|T0T1| = |U0U1|:|V0V'|\n// (Java: Proportion.java — 26 lines, line-for-line port)\nexport class ProportionPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.proportion;\n signature: ConstructionSignature = { points: 8, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new ProportionElement(P[0], P[1], P[2], P[3], P[4], P[5], P[6], P[7]);\n return [[g], g];\n }\n}\n\n// point\n// invert\n// point A circle B\n// the image of a point A inverted in the circle B\n// (Java: InvertPoint.java — 16 lines, calls toInvertPoint(A, C))\nexport class InvertPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.invert;\n signature: ConstructionSignature = { points: 1, elements: 1, integers: 0, elementTypes: [CircleElement] };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new InvertPointElement(P[0], E[0] as CircleElement);\n return [[g], g];\n }\n}\n\n// point\n// meanProportional\n// 6 points S0, S1, T0, T1, U0, U1\n// the point U' on U0U1 so that S:U' = U':T (geometric mean)\n// (Java: MeanProportional.java — 23 lines, line-for-line port)\nexport class MeanProportionalPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.meanProportional;\n signature: ConstructionSignature = { points: 6, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new MeanProportionalElement(P[0], P[1], P[2], P[3], P[4], P[5]);\n return [[g], g];\n }\n}\n\n// point\n// planeSlider\n// plane A integers x, y, z\n// a point that slides on the plane A with initial coordinates (x,y,z)\n// (Java: Slate.java point case 19 — new PlaneSlider((PlaneElement)E[0], N[0], N[1], N[2]).\n// PlaneSlider.ts already has the full constructor + update() + drag().)\nexport class PlaneSliderConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.planeSlider;\n signature: ConstructionSignature = { points: 0, elements: 1, integers: 3, elementTypes: [PlaneElement] };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new PlaneSlider(E[0] as PlaneElement, N[0], N[1], N[2]);\n return [[g], g];\n }\n}\n\n// point\n// sphereSlider\n// sphere A integers x, y, z\n// a point that slides on the sphere A with initial coordinates (x,y,z)\n// (Java: SphereSlider.java — 43 lines, line-for-line port)\nexport class SphereSliderConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.sphereSlider;\n signature: ConstructionSignature = { points: 0, elements: 1, integers: 3, elementTypes: [SphereElement] };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new SphereSliderElement(E[0] as SphereElement, N[0], N[1], N[2]);\n return [[g], g];\n }\n}\n\n// point\n// angleBisector — points B, A, C [, plane D = screen]\n// bisect angle BAC — the point on BC where the bisector from A meets BC\n// (Java: AngleDivider.java with n=2, Slate.java point case 21)\nexport class AngleBisectorPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.angleBisector;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new AngleDividerElement(P[0], P[1], P[2], plane, 2);\n return [[g], g];\n }\n}\n\n// point\n// angleDivider — points B, A, C, integer n [, plane D = screen]\n// n-sect angle BAC — the point on BC where the 1/n ray from A meets BC\n// (Java: AngleDivider.java with variable n, Slate.java point case 22)\nexport class AngleDividerPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.angleDivider;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 1 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 1\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new AngleDividerElement(P[0], P[1], P[2], plane, N[0]);\n return [[g], g];\n }\n}\n\n// point\n// fixed\n// integers x, y [, z=0]\n// the fixed point with coordinates (x, y, z). z defaults to 0 if not provided.\n// (Java: Slate.java point case 23 — new FixedPoint(x,y,z))\nexport class FixedPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.fixed;\n signature: ConstructionSignature = { points: 0, elements: 0, integers: 2 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 0 && sp.E.length === 0 && (sp.N.length === 2 || sp.N.length === 3);\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new FixedPoint({x:N[0], y:N[1], z: N.length > 2 ? N[2] : 0});\n return [[g], g];\n }\n}\n\n// point\n// lineSegmentSlider\n// points A, B, integers x, y, [z]\n// a point that slides along within the line segment AB with initial coordinates (x,y,z)\n// (Java: Slate.java point case 24 — new LineSlider(A,B,x,y,z,true))\nexport class LineSliderSegmentConstruction extends LineSliderConstruction {\n constructionMethod: AllConstructions = PointConstructions.lineSegmentSlider;\n protected createSlider(a: PointElement, b: PointElement, x: number, y: number, z: number) {\n return new LineSlider(a, b, x, y, z, true);\n }\n}\n\n\n// point\n// harmonic\n// points B, C, D\n// the harmonic conjugate of B with respect to C and D\n// (Java: Harmonic.java — 43 lines, line-for-line port.\n// Slate.java point case 25 — new Harmonic(P[0], P[1], P[2]))\nexport class HarmonicPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.harmonic;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new HarmonicElement(P[0], P[1], P[2]);\n return [[g], g];\n }\n}\n\n// point\n// vertex\n// polygon A, integer n\n// the nth vertex (1-based) of polygon A\n// (Java: Slate.java point case 9 — returns ((PolygonElement)E[0]).V[n-1])\nexport class VertexConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.vertex;\n signature: ConstructionSignature = { points: 0, elements: 1, integers: 1, elementTypes: [PolygonElement] };\n\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const poly = E[0] as PolygonElement;\n const vertex = poly.V[N[0] - 1];\n return [[vertex], vertex];\n }\n}\n\nexport const pointConstructions: Construction[] = [\n new FreePointConstruction(),\n new FixedPointConstruction(),\n new FirstPointConstruction(),\n new LastPointConstruction(),\n new CircleCenterConstruction(),\n new CircumcenterConstruction(),\n new MidPointConstruction(),\n new IntersectionConstruction(),\n new FootPointConstruction(),\n new PlaneFootPointConstruction(),\n new ExtendConstruction(),\n new CutoffConstruction(),\n new ParallelogramConstruction(),\n new SimilarPointConstruction(),\n new ProportionPointConstruction(),\n new AngleBisectorPointConstruction(),\n new AngleDividerPointConstruction(),\n new MeanProportionalPointConstruction(),\n new PlaneSliderConstruction(),\n new SphereSliderConstruction(),\n new HarmonicPointConstruction(),\n new InvertPointConstruction(),\n new PlaneIntersectionConstruction(),\n new SphereCenterConstruction(),\n new CircumcircleConstruction(),\n new LineSliderConstruction(),\n new LineSliderSegmentConstruction(),\n new CircleSliderConstruction(),\n new PointPerpendicular1Construction(),\n new PointPerpendicular2Construction(),\n new PointPerpendicular3Construction(),\n new PointPerpendicular4Construction(),\n new PointPerpendicular5Construction(),\n new VertexConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tPointElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {GeomElement} from \"../GeomElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {SlateCanvas} from \"../../Slate\";\n\nexport interface IPointElementConstruction {\n x? : number;\n y? : number;\n z? : number;\n AP? : PlaneElement;\n}\n\nexport class PointElement extends GeomElement {\n\n protected _x : number;\n protected _y : number;\n protected _z : number;\n _AP : PlaneElement;\n\n constructor(ip? : IPointElementConstruction) {\n super();\n this.dimension = 0;\n this._x = ip && ip.x || 0;\n this._y = ip && ip.y || 0;\n this._z = ip && ip.z || 0;\n this._AP = ip && ip.AP || null;\n }\n\n get x() { return this._x }\n set x(value: number) { this._x = value }\n get y() { return this._y }\n set y(value: number) { this._y = value }\n get z() { return this._z }\n set z(value: number) { this._z = value }\n\n get AP() { return this._AP; }\n set AP(v : PlaneElement) { this._AP = v; }\n\n\n public defined() : boolean {\n return !isNaN(this._x) && !isNaN(this._y) && !isNaN(this._z)\n && this._x != null && true && this._y != null && true && this._z != null;\n }\n\n to(B : PointElement ) : PointElement {this._x = B._x; this._y = B._y; this._z= B._z; return this;}\n plus(B : PointElement ) : PointElement {this._x += B._x; this._y += B._y; this._z+= B._z; return this;}\n minus(B : PointElement) : PointElement {this._x -= B._x; this._y -= B._y; this._z-= B._z; return this;}\n times(a : number) : PointElement {this._x *= a; this._y *= a; this._z *= a; return this;}\n\n static difference(A : PointElement, B : PointElement) : PointElement {\n return new PointElement({x:A.x-B.x, y:A.y-B.y, z:A.z-B.z, AP: null});\n }\n\n static product(a : number, B : PointElement) : PointElement {\n return new PointElement({x:a*B.x, y:a*B.y, z:a*B.z, AP: null});\n }\n\n static dot(A : PointElement, B : PointElement) : number {\n return A.x * B.x + A.y * B.y + A.z * B.z;\n }\n\n public length2() : number {\n return this._x * this._x + this._y * this._y + this._z * this._z;\n }\n\n public length() : number {\n return Math.sqrt(this.length2());\n }\n\n public distance2(B : PointElement) : number {\n return (this._x-B.x)*(this._x-B.x) +\n (this._y-B.y)*(this._y-B.y) +\n (this._z-B.z)*(this._z-B.z);\n }\n\n public distance(B : PointElement) : number {\n return Math.sqrt(this.distance2(B));\n }\n\n public toCross(A : PointElement, B : PointElement) : PointElement {\n // set to the cross product of A and B\n this._x = A.y*B.z - A.z*B.y;\n this._y = A.z*B.x - A.x*B.z;\n this._z = A.x*B.y - A.y*B.x;\n return this;\n }\n\n public static cross(A: PointElement, B: PointElement) : PointElement {\n // return the cross product of A and B\n return new PointElement({x: A.y*B.z - A.z*B.y,\n y: A.z*B.x - A.x*B.z,\n z: A.x*B.y - A.y*B.x,\n AP: null});\n }\n\n public static triple(A: PointElement, B: PointElement, C: PointElement) : number {\n // return the triple product of A, B, and C\n return A.x*(B.y*C.z - B.z*C.y) +\n B.x*(C.y*A.z - C.z*A.y) +\n C.x*(A.y*B.z - A.z*B.y);\n }\n\n toLine(A: PointElement, B: PointElement, segment: boolean) : PointElement{\n /*---------------------------------------------------------------------+\n | Project this point to the foot of the perpendicular from it to the |\n | line determined by the points A and B. If A were the origin, then |\n | the foot would be at ((this dot B)/B^2) B. When segment is true |\n | and the foot is beyond A or B, then move the point to the closer |\n | of A and B. |\n +---------------------------------------------------------------------*/\n let V : PointElement = PointElement.difference(B,A);\n this.minus(A);\n let factor : number= PointElement.dot(V,this)/V.length2();\n if (segment) {\n if (factor < 0.0) factor = 0.0;\n else if (factor > 1.0) factor = 1.0;\n }\n V.times(factor);\n return this.to(V).plus(A);\n }\n\n\n public toPlane (P : PlaneElement) : PointElement {\n /*---------------------------------------------------------------------+\n | Project this point to the foot of the perpendicular from it to the |\n | plane P. |\n +---------------------------------------------------------------------*/\n if (P.isScreen) {\n this._z = 0.0;\n } else {\n this.minus(P.A);\n let s : number = PointElement.dot(this, P.S);\n let t = PointElement.dot(this, P.T);\n this.to(P.S).times(s).plus(PointElement.product(t,P.T)).plus(P.A);\n }\n return this;\n }\n\n uptoPlane(P : PlaneElement) : PointElement {\n /*---------------------------------------------------------------------+\n | Project this point to the point on the plane P where the vertical |\n | line through this meets P. |\n +---------------------------------------------------------------------*/\n if (P.isScreen) {\n this._z = 0.0;\n } else {\n this.minus(P.A);\n let den : number = P.S.x*P.T.y - P.S.y*P.T.x;\n let s : number = (this.x*P.T.y - this.y*P.T.x) / den;\n let t : number = (this.y*P.S.x - this.x*P.S.y) / den;\n this.to(P.S).times(s).plus(PointElement.product(t,P.T)).plus(P.A);\n }\n return this;\n }\n\n\n toCircumcenter (A: PointElement, B: PointElement, C: PointElement) : PointElement{\n /*---------------------------------------------------------------------+\n | Move this point to the center of the circle passing through the |\n | points A, B, and C. |\n +---------------------------------------------------------------------*/\n if (A.z == 0.0 && B.z == 0.0 && C.z == 0.0) {\n let u : number = ((A.x-B.x)*(A.x+B.x) + (A.y-B.y)*(A.y+B.y)) / 2.0;\n let v : number = ((B.x-C.x)*(B.x+C.x) + (B.y-C.y)*(B.y+C.y)) / 2.0;\n let den : number = (A.x-B.x)*(B.y-C.y) - (B.x-C.x)*(A.y-B.y);\n this._x = (u * (B.y-C.y) - v*(A.y-B.y)) / den;\n this._y = (v * (A.x-B.x) - u*(B.x-C.x)) / den;\n this._z = 0.0;\n } else {\n let BmA : PointElement = PointElement.difference(B,A)\n let CmA : PointElement = PointElement.difference(C,A);\n let BC : number = PointElement.dot(BmA,CmA);\n let B2 : number = BmA.length2();\n let C2 : number = CmA.length2();\n //double BC2 = BC*BC;\n let den : number = 2.0*(B2*C2-BC*BC);\n let s : number = C2*(B2-BC)/den;\n let t : number = B2*(C2-BC)/den;\n this.to(A).plus(BmA.times(s)).plus(CmA.times(t));\n }\n return this;\n }\n\n toCircle (C: CircleElement) : PointElement {\n /*---------------------------------------------------------------------+\n | Move this point to the nearest point on the circle C. |\n +---------------------------------------------------------------------*/\n if (C.AP.isScreen) {\n let factor : number = C.radius / this.distance(C.Center);\n this._x = C.Center.x + factor*(this._x - C.Center.x);\n this._y = C.Center.y + factor*(this._y - C.Center.y);\n this._z = 0.0;\n } else { // 3d case: project to plane of circle then move to sphere of circle\n this.toPlane(C.AP);\n this.toSphere(C.Center,C.radius);\n }\n return this;\n }\n\n toSphere (Center : PointElement, radius : number) : PointElement{\n /*---------------------------------------------------------------------+\n | Move this point to the nearest point on the sphere S. |\n +---------------------------------------------------------------------*/\n let factor : number = radius / this.distance(Center);\n this._x = Center.x + factor*(this._x - Center.x);\n this._y = Center.y + factor*(this._y - Center.y);\n this._z = Center.z + factor*(this._z - Center.z);\n return this;\n }\n\n public static area(A: PointElement, B: PointElement, C: PointElement) {\n // return the area of the triangle ABC\n let U : PointElement = PointElement.difference(B,A);\n let V : PointElement = PointElement.difference(C,A);\n return this.cross(U,V).length()/2.0;\n }\n\n public angle(B: PointElement, C: PointElement, P: PlaneElement) : number {\n // Determine the angle BAC in the plane P where this is A.\n // The angle lies between -pi and pi (-180 degrees and 180 degrees)\n let Bx : number = B.x - this._x, Cx = C.x - this._x;\n let By : number = B.y - this._y, Cy = C.y - this._y;\n if (P.isScreen) {\n return Math.atan2 (Bx*Cy - By*Cx, Bx*Cx + By*Cy);\n } else { // 3d case. First get P-coordinates for B and C\n let Bz : number = B.z -this._z, Cz = C.z -this._z;\n let Bs : number = Bx * P.S.x + By * P.S.y + Bz * P.S.z;\n let Bt : number = Bx * P.T.x + By * P.T.y + Bz * P.T.z;\n let Cs : number = Cx * P.S.x + Cy * P.S.y + Cz * P.S.z;\n let Ct : number = Cx * P.T.x + Cy * P.T.y + Cz * P.T.z;\n return Math.atan2(Bs * Ct - Bt * Cs, Bs * Cs + Bt * Ct);\n }\n }\n\n toIntersection (\n A: PointElement,\n B: PointElement,\n C: PointElement,\n D: PointElement,\n P: PlaneElement) : PointElement {\n if (P.isScreen) {\n // move this point to where the two lines AB and CD meet\n let d0 : number = A.x*B.y - A.y*B.x;\n let d1 : number = C.x*D.y - C.y*D.x;\n let den : number = (B.y-A.y)*(C.x-D.x) - (A.x-B.x)*(D.y-C.y);\n this._x = (d0*(C.x-D.x) - d1*(A.x-B.x)) / den;\n this._y = (d1*(B.y-A.y) - d0*(D.y-C.y)) / den;\n } else { // 3d case\n let AmA : PointElement = PointElement.difference(A,P.A);\n let BmA : PointElement = PointElement.difference(B,P.A);\n let CmA : PointElement = PointElement.difference(C,P.A);\n let DmA : PointElement = PointElement.difference(D,P.A);\n let Ax = PointElement.dot(AmA,P.S);\n let Ay = PointElement.dot(AmA,P.T);\n let Bx = PointElement.dot(BmA,P.S);\n let By = PointElement.dot(BmA,P.T);\n let Cx = PointElement.dot(CmA,P.S);\n let Cy = PointElement.dot(CmA,P.T);\n let Dx = PointElement.dot(DmA,P.S);\n let Dy = PointElement.dot(DmA,P.T);\n let d0 = Ax*By - Ay*Bx;\n let d1 = Cx*Dy - Cy*Dx;\n let den = (By-Ay)*(Cx-Dx) - (Ax-Bx)*(Dy-Cy);\n let s = (d0*(Cx-Dx) - d1*(Ax-Bx)) / den;\n let t = (d1*(By-Ay) - d0*(Dy-Cy)) / den;\n this.to(P.S).times(s).plus(PointElement.product(t,P.T)).plus(P.A);\n }\n return this;\n }\n\n toIntersectionPL (\n P: PlaneElement,\n D: PointElement,\n E: PointElement) : PointElement {\n // move this point to where the plane P meets the line DE\n this.to(E).minus(D);\n let DmA : PointElement = PointElement.difference(D,P.A);\n let u : number = -PointElement.triple(P.S,P.T,DmA)\n / PointElement.triple(P.S,P.T,this);\n return this.times(u).plus(D);\n }\n\n toInvertPoint (A: PointElement, C: CircleElement) : PointElement {\n // move this point to the inversion of the point A in the circle C\n let factor : number = C.radius2 / A.distance2(C.Center);\n return this.to(A).minus(C.Center).times(factor).plus(C.Center);\n }\n\n toSimilar (\n A: PointElement,\n B: PointElement,\n P : PlaneElement,\n D: PointElement,\n E: PointElement,\n F: PointElement,\n Q: PlaneElement) : PointElement {\n // move this point to the location C so that triangle ABC is similar\n // to triangle DEF.\n let theta : number = D.angle(E,F,Q);\n let co : number = Math.cos(theta), si : number = Math.sin(theta);\n let factor : number = D.distance(F) / D.distance(E);\n if (P.isScreen) {\n this._x = B.x;\n this._y = B.y;\n this.rotate(A,co,si,P);\n this._x = A.x + factor*(this._x - A.x);\n this._y = A.y + factor*(this._y - A.y);\n this._z = 0.0;\n } else {\n let BmA : PointElement = PointElement.difference(B,A);\n let s : number = PointElement.dot(BmA,P.S);\n let t : number = PointElement.dot(BmA,P.T);\n let ss : number = factor*(co*s - si*t);\n let tt : number = factor*(si*s + co*t);\n this._x = ss*P.S.x + tt*P.T.x + A.x;\n this._y = ss*P.S.y + tt*P.T.y + A.y;\n this._z = ss*P.S.z + tt*P.T.z + A.z;\n }\n return this;\n }\n\n public rotate ( pivot : PointElement,\n ac : number,\n as : number,\n plane?: PlaneElement) : void {\n /*--------------------------------------------------------------------------+\n | Scale and rotate this point around the axis through the pivot and\t\t|\n | perpendicular to the plane. Scale by a factor of a, and rotate by the\t|\n | angle theta where ac = a cos theta, and as = a sin theta.\t\t\t|\n +--------------------------------------------------------------------------*/\n if (plane == null) plane = pivot._AP;\n if (this == pivot) return;\n if (plane.isScreen) {\n let dx : number = this.x - pivot.x;\n let dy : number = this.y - pivot.y;\n this._x = pivot.x + ac*dx - as*dy;\n this._y = pivot.y + as*dx + ac*dy;\n } else {\n this.minus(pivot);\n let S : PointElement = plane.S;\n let T : PointElement = plane.T;\n let U : PointElement = plane.U;\n let s : number = PointElement.dot(this,S);\n let t : number = PointElement.dot(this,T);\n let z1 : number = PointElement.dot(this,U);\n let x1 : number = ac*s - as*t;\n let y1 : number = as*s + ac*t;\n this._x = pivot.x + x1*S.x + y1*T.x + z1*U.x;\n this._y = pivot.y + x1*S.y + y1*T.y + z1*U.y;\n this._z = pivot.z + x1*S.z + y1*T.z + z1*U.z;\n }\n }\n\n public drawName(c: SlateCanvas): void {\n // A point shows its dot/label only when it is actually revealed\n // (visible). Highlight / emphasis style a SHOWN point — they must not\n // force a hidden one to draw: a deferred reveal target (visible=false\n // until its appear step flips it true) or a point not in the slide's\n // visible set must stay dark even when it is in the highlighted set.\n // (#126; the dot's radius already zeroes at drawProgress=0, but the\n // label had no such guard.)\n if (!this.visible) return;\n // The label snaps in only once the marker is fully revealed: through a\n // Point.appear pulse (drawProgress 0→1) the dot grows, then the label\n // lands at completion — it does not ride the pulse. Static points are\n // drawProgress = 1, so this is a no-op for them. (#126)\n if (this.drawProgress < 1) return;\n if (this.nameColor != null && this.name != null && this.defined()) {\n this.drawString(Math.round(this.x), Math.round(this.y), c)\n }\n }\n\n public drawVertex(c: SlateCanvas, color?: string): void {\n if (!this.visible) return; // see drawName — highlight never reveals a hidden point (#126)\n let ctx : CanvasRenderingContext2D = c.getContext(\"2d\") as CanvasRenderingContext2D;\n if (color == null) {\n if (this.emphasized || this.shouldHighlight) {\n color = this.vertexHighlightColor;\n } else {\n color = this.vertexColor;\n }\n }\n if (color == null) return;\n // Radius interpolates by emphasisAmount: baseline 2 (normal) or\n // 4 (highlight) → 6 at full emphasis. drawProgress then scales\n // the result so A.Point.appear can pulse the marker in from 0.\n const baseR = this.shouldHighlight ? 4 : 2;\n let r = baseR + this.emphasisAmount * (6 - baseR);\n r *= this.drawProgress * GeomElement.styleScale; // constant on-screen dot under fit-scale (#71)\n if (r < 0.5) return; // avoid degenerate sub-pixel arcs\n ctx.beginPath();\n ctx.fillStyle = color;\n ctx.arc(this._x, this._y, r, 0, 2*Math.PI, false);\n ctx.fill();\n }\n\n\n public translate(dx: number, dy: number): void {\n this._x += dx;\n this._y += dy;\n }\n\n public update(): void {\n }\n\n public drawEdge(c: SlateCanvas): void {\n }\n\n public drawFace(c: SlateCanvas): void {\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tProportionElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\n\nexport class ProportionElement extends PointElement {\n /*--------------------------------------------------------------------+\n | Given lines S(S0,S1), T(T0,T1), U(U0,U1), V(V0,V1), cut off from |\n | V a fourth proportional V' so that S:T = U:V'. |\n +--------------------------------------------------------------------*/\n\n private _S0: PointElement;\n private _S1: PointElement;\n private _T0: PointElement;\n private _T1: PointElement;\n private _U0: PointElement;\n private _U1: PointElement;\n private _V0: PointElement;\n private _V1: PointElement;\n\n constructor(S0: PointElement, S1: PointElement, T0: PointElement,\n T1: PointElement, U0: PointElement, U1: PointElement,\n V0: PointElement, V1: PointElement) {\n super();\n this.dimension = 0;\n this._S0 = S0; this._S1 = S1;\n this._T0 = T0; this._T1 = T1;\n this._U0 = U0; this._U1 = U1;\n this._V0 = V0; this._V1 = V1;\n if (V0._AP === V1._AP) {\n this._AP = V0._AP;\n }\n }\n\n public update() {\n let factor : number = this._T0.distance2(this._T1) * this._U0.distance2(this._U1)\n / (this._S0.distance2(this._S1) * this._V0.distance2(this._V1));\n factor = Math.sqrt(factor);\n this.to(this._V1).minus(this._V0);\n this.times(factor).plus(this._V0);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tSimilarElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class SimilarElement extends PointElement {\n /*--------------------------------------------------------------------+\n | Construct a triangle AB(this) in the plane AP similar to the |\n | triangle DEF in the plane Q. |\n +--------------------------------------------------------------------*/\n\n private _parentA: PointElement;\n private _parentB: PointElement;\n private _D: PointElement;\n private _E: PointElement;\n private _F: PointElement;\n private _Q: PlaneElement;\n\n constructor(A: PointElement, B: PointElement, AP: PlaneElement,\n D: PointElement, E: PointElement, F: PointElement,\n Q: PlaneElement) {\n super();\n this.dimension = 0;\n this._parentA = A;\n this._parentB = B;\n this._AP = AP;\n this._D = D;\n this._E = E;\n this._F = F;\n this._Q = Q;\n }\n\n public update() {\n this.toSimilar(this._parentA, this._parentB, this._AP,\n this._D, this._E, this._F, this._Q);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tSphereSliderElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\nimport {SphereElement} from \"../sphere/SphereElement\";\n\nexport class SphereSliderElement extends PointElement {\n\n private _S: SphereElement;\n private _initx: number;\n private _inity: number;\n private _initz: number;\n\n constructor(S: SphereElement, x: number, y: number, z: number) {\n super();\n this.dimension = 0;\n this.draggable = true;\n this._S = S;\n this._x = this._initx = x;\n this._y = this._inity = y;\n this._z = this._initz = z;\n }\n\n public reset() {\n this._x = this._initx;\n this._y = this._inity;\n this._z = this._initz;\n this.toSphere(this._S.Center, this._S.radius());\n }\n\n public update() {\n this.toSphere(this._S.Center, this._S.radius());\n }\n\n public drag(tox: number, toy: number): boolean {\n let dist2 = (this._S.Center.x - tox) * (this._S.Center.x - tox)\n + (this._S.Center.y - toy) * (this._S.Center.y - toy);\n let r2 = this._S.radius2();\n if (dist2 <= r2) {\n this._x = tox;\n this._y = toy;\n if (this._z > this._S.Center.z)\n this._z = this._S.Center.z + Math.sqrt(r2 - dist2);\n else\n this._z = this._S.Center.z - Math.sqrt(r2 - dist2);\n } else {\n // beyond shadow of sphere\n tox -= this._S.Center.x;\n toy -= this._S.Center.y;\n let factor = Math.sqrt((tox * tox + toy * toy) / r2);\n tox = tox / factor + this._S.Center.x;\n toy = toy / factor + this._S.Center.y;\n if ((tox - this._x) * (tox - this._x) + (toy - this._y) * (toy - this._y) < 0.5)\n return false;\n this._x = tox;\n this._y = toy;\n this._z = this._S.Center.z;\n }\n return true;\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tApplicationElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PolygonElement} from \"./PolygonElement\";\nimport {PointElement} from \"../point/PointElement\";\n\nexport class ApplicationElement extends PolygonElement {\n /*--------------------------------------------------------------------+\n | Apply a polygon P to get a parallelogram |\n | with a side AB in an angle CAB |\n +--------------------------------------------------------------------*/\n\n private _P: PolygonElement;\n private _C: PointElement;\n\n constructor(P: PolygonElement, A: PointElement, B: PointElement, C: PointElement) {\n super();\n this.dimension = 2;\n this._P = P;\n this._C = C;\n this.V = new Array(4);\n this.V[0] = A;\n this.V[1] = B;\n this.V[2] = new PointElement();\n this.V[3] = new PointElement();\n if (A._AP === B._AP && A._AP === C._AP) {\n this.V[2]._AP = A._AP;\n this.V[3]._AP = A._AP;\n }\n }\n\n public translate(dx: number, dy: number) {\n this.V[2].translate(dx, dy);\n this.V[3].translate(dx, dy);\n }\n\n public rotate(pivot: PointElement, ac: number, as: number) {\n this.V[2].rotate(pivot, ac, as);\n this.V[3].rotate(pivot, ac, as);\n }\n\n public update() {\n let factor : number = this._P.area() / (2.0 * PointElement.area(this.V[0], this.V[1], this._C));\n factor = Math.abs(factor);\n this.V[3].x = this.V[0].x + factor * (this._C.x - this.V[0].x);\n this.V[3].y = this.V[0].y + factor * (this._C.y - this.V[0].y);\n this.V[3].z = this.V[0].z + factor * (this._C.z - this.V[0].z);\n this.V[2].x = this.V[1].x + this.V[3].x - this.V[0].x;\n this.V[2].y = this.V[1].y + this.V[3].y - this.V[0].y;\n this.V[2].z = this.V[1].z + this.V[3].z - this.V[0].z;\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tCurvedTriangleElement.ts |\n| Part of the geomlib port of David E. Joyce's Geometry Applet. |\n| TypeScript: 2026, Nelson Brown, brownnrl@gmail.com |\n+----------------------------------------------------------------------*/\n\nimport {GeomElement} from \"../GeomElement\";\nimport {SlateCanvas} from \"../../Slate\";\nimport {PointElement} from \"../point/PointElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {LineElement} from \"../line/LineElement\";\n\n// A triangle whose three sides are circular arcs rather than straight\n// segments — the figure of non-Euclidean geometry (an elliptic triangle on\n// the disk model, a hyperbolic triangle in the Poincaré disk; both have\n// circular-arc sides).\n//\n// It is defined by 3 vertices A, B, C and 3 side carriers (one per side,\n// **positionally**: side i connects vertex i to vertex i+1 and lies on\n// carrier i). A carrier is the \"line\" the side lies on:\n// - a CircleElement → the side is the minor arc of that circle between the\n// two vertices, clipped to them (it stops at the corners, unlike the full\n// great-circle arc that runs on to the disk boundary);\n// - a LineElement → the side is the straight chord between the two vertices\n// (a disk diameter, whose geodesic is straight).\n//\n// It IS the side-segments — it draws and (optionally) fills them itself, so it\n// is one highlightable/fillable element (hovering \"triangle ABC\" lights the\n// curved sides gold). The minor arc makes the curve well-defined; positional\n// carriers make \"which circle\" well-defined. (The side tracing is written for\n// N sides, so a general curved polygon is a later, easy generalisation.)\n//\n// The vertices and carriers are independent slate elements that move by their\n// own handlers, so translate/rotate are no-ops.\ntype SideCarrier = CircleElement | LineElement;\n\nexport class CurvedTriangleElement extends GeomElement {\n\n private _vertices : PointElement[]; // A, B, C in order\n private _sides : SideCarrier[]; // carrier for side i (Vi → V(i+1))\n\n constructor(vertices: PointElement[], sides: SideCarrier[]) {\n super();\n this.dimension = 1;\n this._vertices = vertices;\n this._sides = sides;\n }\n\n update() : void {}\n\n // A vertex lies on a circle carrier (|dist − r| small) / a line carrier\n // (perpendicular distance small). Tolerances are relative to the carrier's\n // own scale, with a 0.5px floor: generous against float error, but catches\n // a carrier that simply doesn't pass through the side's endpoints.\n private static _onCircle(v: PointElement, c: CircleElement) : boolean {\n const r = c.radius;\n return Math.abs(v.distance(c.Center) - r) <= Math.max(0.5, 1e-3 * r);\n }\n private static _onLine(v: PointElement, l: LineElement) : boolean {\n const ax = l.A.x, ay = l.A.y, bx = l.B.x, by = l.B.y;\n const dx = bx - ax, dy = by - ay;\n const len = Math.hypot(dx, dy);\n if (len === 0) return false;\n const perp = Math.abs((v.x - ax) * dy - (v.y - ay) * dx) / len;\n return perp <= Math.max(0.5, 1e-3 * len);\n }\n\n defined() : boolean {\n const n = this._vertices.length;\n if (n < 3 || this._sides.length !== n) return false;\n for (let v of this._vertices) if (!v.defined()) return false;\n // Each carrier must be defined AND pass through BOTH vertices of its\n // side, else the figure is ill-posed — undefined, so we draw no\n // misleading arcs. (LineElement inherits no real defined(), so a line\n // carrier is \"defined\" when both its endpoints are.)\n for (let i = 0; i < n; i++) {\n const V = this._vertices[i];\n const W = this._vertices[(i + 1) % n];\n const s = this._sides[i];\n if (s instanceof CircleElement) {\n if (!s.defined()) return false;\n if (!CurvedTriangleElement._onCircle(V, s) || !CurvedTriangleElement._onCircle(W, s)) return false;\n } else {\n const l = s as LineElement;\n if (l.A == null || l.B == null || !l.A.defined() || !l.B.defined()) return false;\n if (!CurvedTriangleElement._onLine(V, l) || !CurvedTriangleElement._onLine(W, l)) return false;\n }\n }\n return true;\n }\n\n // The signed minor angle from a0 to a1 around a centre, in (−π, π].\n private static _delta(a0: number, a1: number) : number {\n let d = a1 - a0;\n while (d > Math.PI) d -= 2 * Math.PI;\n while (d <= -Math.PI) d += 2 * Math.PI;\n return d;\n }\n\n // Trace the closed curved boundary into the current ctx path (no\n // beginPath / stroke / fill). Shared by drawEdge and drawFace so the\n // stroked outline and the filled region are the exact same path.\n private _traceBoundary(ctx: CanvasRenderingContext2D) : void {\n const n = this._vertices.length;\n const V0 = this._vertices[0];\n ctx.moveTo(V0.x, V0.y);\n for (let i = 0; i < n; i++) {\n const V = this._vertices[i];\n const W = this._vertices[(i + 1) % n];\n const s = this._sides[i];\n if (s instanceof CircleElement) {\n const cx = s.Center.x, cy = s.Center.y, r = s.radius;\n const a0 = Math.atan2(V.y - cy, V.x - cx);\n const a1 = Math.atan2(W.y - cy, W.x - cx);\n const d = CurvedTriangleElement._delta(a0, a1);\n // V is on the circle, so ctx.arc's implicit lineTo to the arc\n // start is zero-length and the path stays continuous.\n ctx.arc(cx, cy, r, a0, a0 + d, d < 0);\n } else {\n // Straight side (line carrier / diameter): chord to the vertex.\n ctx.lineTo(W.x, W.y);\n }\n }\n ctx.closePath();\n }\n\n drawFace(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.faceColor == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.beginPath();\n this._traceBoundary(ctx);\n ctx.fillStyle = this.faceColor;\n ctx.fill();\n }\n\n drawEdge(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n const color = (this.emphasized || this.shouldHighlight)\n ? this.edgeHighlightColor\n : this.edgeColor;\n if (color == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.strokeStyle = color;\n const baseW = this.shouldHighlight ? 3 : 1;\n ctx.lineWidth = (baseW + this.emphasisAmount * (6 - baseW)) * GeomElement.styleScale;\n ctx.beginPath();\n this._traceBoundary(ctx);\n ctx.stroke();\n }\n\n drawVertex(c: SlateCanvas) : void {}\n\n drawName(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (!this.defined()) return; // drawString() guards on a null name/colour\n let x = 0, y = 0;\n for (let v of this._vertices) { x += v.x; y += v.y; }\n this.drawString(x / this._vertices.length, y / this._vertices.length, c);\n }\n\n translate(dx: number, dy: number) : void {}\n rotate(pivot: PointElement, ac: number, as: number) : void {}\n}\n","// Animations targeting PolygonElement. See ../Animations.ts for the\n// abstract base + registry mechanics.\n\nimport {Animation, AllAnimations, IAnimationStep, registerAnimation} from \"../Animations\";\nimport {GeomElement} from \"../GeomElement\";\nimport {Slate} from \"../../Slate\";\nimport {PolygonElement} from \"./PolygonElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\n\n// Default per-edge trace rate matches LineAnimations so a polygon's\n// edges feel like the same instrument tracing each side in turn.\nconst DEFAULT_POLYGON_EDGE_RATE_PX_PER_MS = 0.25;\nconst DEFAULT_POLYGON_FILL_MS = 500;\n\n// Total perimeter (closed if V.length > 2, otherwise open) — used to\n// compute the outline duration from edge rate.\nfunction perimeter(poly: PolygonElement): number {\n const n = poly.V.length;\n if (n < 2) return 0;\n let total = 0;\n const closed = n > 2;\n const edgeCount = closed ? n : n - 1;\n for (let i = 0; i < edgeCount; i++) {\n const a = poly.V[i];\n const b = poly.V[(i + 1) % n];\n const dx = b.x - a.x;\n const dy = b.y - a.y;\n total += Math.sqrt(dx * dx + dy * dy);\n }\n return total;\n}\n\n// A.Polygon.outline — cascade-trace each edge in V[] order.\n// PolygonElement.drawEdge already partitions drawProgress over edges\n// so a single step driving drawProgress 0 → 1 traces every edge in\n// sequence with the right per-edge proportion.\nexport class PolygonOutlineAnimation extends Animation {\n public animationMethod = AllAnimations.POLYGON_OUTLINE;\n public name = \"Polygon.outline\";\n public elementType = PolygonElement;\n public defaultRate = DEFAULT_POLYGON_EDGE_RATE_PX_PER_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const poly = target as PolygonElement;\n const durationMs = Math.max(180, perimeter(poly) / this.defaultRate);\n return [{\n durationMs,\n tick: (progress) => { poly.drawProgress = progress; },\n finalise: () => {\n poly.drawProgress = 1;\n poly.visible = true;\n },\n }];\n }\n}\n\n// A.Polygon.outlineAndFill — strict sequence: outline-trace step\n// completes first, then a separate fill-fade step. PolygonElement\n// now has two independent fields driving this — drawProgress for the\n// edge trace (consumed by drawEdge) and faceAlpha for the fill\n// (consumed by drawFace). The outline step finalises drawProgress to\n// 1 (full edges) before the fill step starts ticking faceAlpha\n// 0 → 1; the edges remain stable at full while the face fades in.\n//\n// The fade duration is intentionally shorter than the outline trace\n// — the eye has already absorbed the polygon's shape from the trace,\n// so the fill should land quickly. v1: half the outline's runtime,\n// capped by defaultDurationMs.\nexport class PolygonOutlineAndFillAnimation extends Animation {\n public animationMethod = AllAnimations.POLYGON_OUTLINE_AND_FILL;\n public name = \"Polygon.outlineAndFill\";\n public elementType = PolygonElement;\n public defaultRate = DEFAULT_POLYGON_EDGE_RATE_PX_PER_MS;\n public defaultDurationMs = DEFAULT_POLYGON_FILL_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const poly = target as PolygonElement;\n const outlineMs = Math.max(180, perimeter(poly) / this.defaultRate);\n const fullRestore = () => {\n poly.faceAlpha = 1;\n poly.drawProgress = 1;\n poly.visible = true;\n };\n // Step 1 — outline trace.\n const outline: IAnimationStep = {\n durationMs: outlineMs,\n setup: () => {\n poly.drawProgress = 0;\n poly.faceAlpha = 0; // hide fill until step 2\n },\n tick: (progress) => { poly.drawProgress = progress; },\n finalise: () => { poly.drawProgress = 1; },\n };\n // A face-less polygon has nothing to fade — scheduling the\n // fill step anyway would be pure dead time in the middle of\n // a cascade (#81). Run the outline alone, with its finalise\n // doing the full restore.\n if (poly.faceColor == null) {\n outline.finalise = fullRestore;\n return [outline];\n }\n // Fill ~twice as fast as the outline, capped at the\n // class-level default so a giant polygon doesn't yield a\n // glacial fade.\n const fillMs = Math.min(outlineMs / 2, this.defaultDurationMs);\n return [\n outline,\n // Step 2 — face fade-in over the already-traced outline.\n {\n durationMs: fillMs,\n tick: (progress) => { poly.faceAlpha = progress; },\n finalise: fullRestore,\n },\n ];\n }\n}\n\n// A.Polygon.superpose — Euclid's superposition (I.4): an ephemeral\n// gold-outline ghost copy of the target lifts off, translates so its\n// vertex 0 lands on the `onto` polygon's vertex 0, rotates about the\n// landing point to lay side 0→1 onto the target side 0→1 (carrying\n// the remaining vertices with it), holds a beat coinciding, then\n// retraces both motions home. The real polygon never moves — the\n// ephemeral system owns the moving copy and its cleanup.\n//\n// Args: { onto: string } — the polygon to superpose onto. Must\n// resolve to a PolygonElement with the same vertex count; anything\n// else warns and falls through to an instant no-op.\nconst SUPERPOSE_TRANSLATE_RATE_PX_PER_MS = 0.25;\nconst SUPERPOSE_ROTATE_RATE_RAD_PER_MS = 0.003;\nconst SUPERPOSE_MIN_STEP_MS = 250;\nconst SUPERPOSE_HOLD_MS = 800;\nconst GHOST_COLOR = \"#FFD700\";\n\nexport class PolygonSuperposeAnimation extends Animation {\n public animationMethod = AllAnimations.POLYGON_SUPERPOSE;\n public name = \"Polygon.superpose\";\n public elementType = PolygonElement;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const poly = target as PolygonElement;\n const ontoName = args && args.onto;\n const onto = ontoName != null ? slate.lookupElement(String(ontoName)) : null;\n if (!(onto instanceof PolygonElement) || onto.V.length !== poly.V.length) {\n if (typeof console !== \"undefined\" && console.warn) {\n console.warn(\"[geomlib] Polygon.superpose: args.onto ('\"\n + ontoName + \"') is not a polygon with \"\n + poly.V.length + \" vertices — skipping\");\n }\n return [{\n durationMs: 0,\n tick: () => {},\n finalise: () => {\n poly.drawProgress = 1;\n poly.visible = true;\n },\n }];\n }\n\n // Source coordinates are captured at setup time (not build\n // time) so the ghost reflects any drags that happened between\n // slide construction and this step actually starting.\n const n = poly.V.length;\n let src: Array<{x: number, y: number}> = [];\n let dx = 0, dy = 0; // translate delta: V[0] → onto.V[0]\n let theta = 0; // rotation about the landing point\n const ghostPts: PointElement[] = [];\n const ghost = new PolygonElement();\n ghost.edgeColor = GHOST_COLOR;\n ghost.faceColor = null;\n ghost.nameColor = null;\n ghost.vertexColor = null;\n\n const setGhost = (coords: Array<{x: number, y: number}>) => {\n for (let i = 0; i < n; i++) {\n ghostPts[i].x = coords[i].x;\n ghostPts[i].y = coords[i].y;\n }\n };\n const translated = (t: number) =>\n src.map(p => ({ x: p.x + dx * t, y: p.y + dy * t }));\n // Rotate the fully-translated coords about the landing point\n // (onto.V[0]) by angle · t.\n const rotated = (t: number) => {\n const cx = onto.V[0].x, cy = onto.V[0].y;\n const cos = Math.cos(theta * t), sin = Math.sin(theta * t);\n return translated(1).map(p => ({\n x: cx + (p.x - cx) * cos - (p.y - cy) * sin,\n y: cy + (p.x - cx) * sin + (p.y - cy) * cos,\n }));\n };\n\n // Durations are estimated from build-time geometry; the exact\n // path re-derives from setup-time coords so a stale estimate\n // only affects pacing, never correctness.\n const estDist = Math.hypot(onto.V[0].x - poly.V[0].x, onto.V[0].y - poly.V[0].y);\n const translateMs = Math.max(SUPERPOSE_MIN_STEP_MS,\n estDist / SUPERPOSE_TRANSLATE_RATE_PX_PER_MS);\n const estTheta = Math.abs(this._sideAngleDelta(poly, onto));\n const rotateMs = Math.max(SUPERPOSE_MIN_STEP_MS,\n estTheta / SUPERPOSE_ROTATE_RATE_RAD_PER_MS);\n\n return [\n // ① glide: vertex 0 travels to onto's vertex 0.\n {\n durationMs: translateMs,\n setup: () => {\n // Superpose is not a reveal — the real polygon is\n // already on stage and must stay fully drawn while\n // its ghost travels. Undo the animator's reveal-\n // convention pre-zeroing.\n poly.drawProgress = 1;\n poly.visible = true;\n src = poly.V.map(p => ({ x: p.x, y: p.y }));\n dx = onto.V[0].x - src[0].x;\n dy = onto.V[0].y - src[0].y;\n theta = this._sideAngleDelta(poly, onto);\n for (let i = 0; i < n; i++) {\n const gp = new PointElement();\n gp.x = src[i].x;\n gp.y = src[i].y;\n ghostPts.push(gp);\n ghost.V.push(gp);\n }\n slate.addEphemeral(ghost);\n },\n tick: (p) => { setGhost(translated(p)); },\n finalise: () => { setGhost(translated(1)); },\n },\n // ② rotate about the landing point: side 0→1 lays onto\n // the target's side 0→1.\n {\n durationMs: rotateMs,\n tick: (p) => { setGhost(rotated(p)); },\n finalise: () => { setGhost(rotated(1)); },\n },\n // ③ hold, coinciding.\n {\n durationMs: SUPERPOSE_HOLD_MS,\n tick: () => {},\n finalise: () => {},\n },\n // ④ rotate home.\n {\n durationMs: rotateMs,\n tick: (p) => { setGhost(rotated(1 - p)); },\n finalise: () => { setGhost(translated(1)); },\n },\n // ⑤ glide home; the ghost's work is done.\n {\n durationMs: translateMs,\n tick: (p) => { setGhost(translated(1 - p)); },\n finalise: () => {\n slate.removeEphemeral(ghost);\n poly.drawProgress = 1;\n poly.visible = true;\n },\n },\n ];\n }\n\n // Angle that carries the source side V[0]→V[1] onto the target\n // side, normalized to [-π, π] so the ghost takes the short way.\n private _sideAngleDelta(from: PolygonElement, onto: PolygonElement): number {\n const a = Math.atan2(from.V[1].y - from.V[0].y, from.V[1].x - from.V[0].x);\n const b = Math.atan2(onto.V[1].y - onto.V[0].y, onto.V[1].x - onto.V[0].x);\n let d = b - a;\n while (d > Math.PI) d -= 2 * Math.PI;\n while (d < -Math.PI) d += 2 * Math.PI;\n return d;\n }\n}\n\n// A.Polygon.equilateralBuild — Euclid I.1: build the equilateral triangle\n// on a base as a transitory compass walk. Two gold compass circles (centre\n// V[0] through V[1], centre V[1] through V[0]) sweep out, then the triangle\n// traces (and fills) — and the circles vanish, leaving just the triangle.\n// The target is the declared `polygon;equilateralTriangle` (V[0]=A, V[1]=B,\n// V[2]=apex); the circles are bare EPHEMERALS the animation owns and clears,\n// so a deck calls one entry instead of declaring + sequencing the rig.\n//\n// Unlike A.Polygon.superpose (whose target is already on stage), this target\n// is a DEFERRED REVEAL: it stays dark (drawProgress=0, faceAlpha=0) through\n// the circle sweeps and only traces in on the outline step.\nconst EQUILATERAL_SWEEP_RATE_RAD_PER_MS = 0.0045; // brisker than the lone compass\n\nexport class PolygonEquilateralBuildAnimation extends Animation {\n public animationMethod = AllAnimations.POLYGON_EQUILATERAL_BUILD;\n public name = \"Polygon.equilateralBuild\";\n public elementType = PolygonElement;\n public defaultRate = EQUILATERAL_SWEEP_RATE_RAD_PER_MS;\n public defaultDurationMs = DEFAULT_POLYGON_FILL_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const poly = target as PolygonElement;\n // Need a base (A, B) to centre the two compass circles on.\n if (poly.V.length < 2) {\n return [{ durationMs: 0, tick: () => {},\n finalise: () => { poly.drawProgress = 1; poly.faceAlpha = 1; poly.visible = true; } }];\n }\n const A = poly.V[0], B = poly.V[1];\n const plane = A.AP;\n const sweepMs = (2 * Math.PI) / this.defaultRate;\n // Bare ephemeral circles (no face — a compass walk is the arc only).\n // They paint gold via the highlight stroke because they're emphasised.\n const circAB = new CircleElement({ C: A, B: B, AP: plane }); // centre A through B\n const circBA = new CircleElement({ C: B, B: A, AP: plane }); // centre B through A\n for (const c of [circAB, circBA]) {\n c.edgeColor = null; c.faceColor = null; c.nameColor = null; c.vertexColor = null;\n c.emphasized = true;\n }\n const startAngle = (c: CircleElement) =>\n Math.atan2(c.B.y - c.Center.y, c.B.x - c.Center.x);\n const sweep = (c: CircleElement): IAnimationStep => ({\n durationMs: sweepMs,\n setup: () => { c.drawStartAngle = startAngle(c); c.drawProgress = 0; },\n tick: (p) => { c.drawProgress = p; },\n finalise: () => { c.drawProgress = 1; },\n });\n\n const outlineMs = Math.max(180, perimeter(poly) / DEFAULT_POLYGON_EDGE_RATE_PX_PER_MS);\n const clearCircles = () => { slate.removeEphemeral(circAB); slate.removeEphemeral(circBA); };\n const fullRestore = () => {\n poly.drawProgress = 1; poly.faceAlpha = 1; poly.visible = true;\n clearCircles();\n };\n\n // Step 1 — first compass circle; also creates + registers both ephemerals\n // and hides the polygon until its outline step.\n const first = sweep(circAB);\n const firstSetup = first.setup;\n first.setup = () => {\n poly.drawProgress = 0; poly.faceAlpha = 0; // deferred reveal — stay dark\n slate.addEphemeral(circAB); slate.addEphemeral(circBA);\n // Both circles start un-drawn: a fresh CircleElement defaults to\n // drawProgress = 1, and ephemerals get no animator pre-zeroing, so\n // the second circle would otherwise flash full during the first sweep.\n circAB.drawProgress = 0; circBA.drawProgress = 0;\n if (firstSetup) firstSetup();\n };\n\n // Step N — outline trace. Reveals the triangle; clears the circles last\n // (after a faceless polygon, or before the fill step takes over).\n const outline: IAnimationStep = {\n durationMs: outlineMs,\n setup: () => { poly.drawProgress = 0; poly.faceAlpha = 0; },\n tick: (p) => { poly.drawProgress = p; },\n finalise: () => { poly.drawProgress = 1; },\n };\n if (poly.faceColor == null) {\n outline.finalise = fullRestore;\n return [first, sweep(circBA), outline];\n }\n const fillMs = Math.min(outlineMs / 2, this.defaultDurationMs);\n return [\n first,\n sweep(circBA),\n outline,\n // Final step — face fade-in; clears the circles as the triangle lands.\n { durationMs: fillMs, tick: (p) => { poly.faceAlpha = p; }, finalise: fullRestore },\n ];\n }\n}\n\nregisterAnimation(new PolygonOutlineAnimation());\nregisterAnimation(new PolygonOutlineAndFillAnimation());\nregisterAnimation(new PolygonSuperposeAnimation());\nregisterAnimation(new PolygonEquilateralBuildAnimation());\n","/*----------------------------------------------------------------------+\n| Polygon construction classes — extracted from Constructions.ts |\n| Each class maps a (type, constructionName, signature) triple to |\n| a construct() method that creates the geometry element. |\n+----------------------------------------------------------------------*/\n\nimport {Construction, ConstructionSignature, SortedParams, AllConstructions,\n PolygonConstructions as PolygonConstructionsEnum,\n GeomElementsForUpdate} from \"../Constructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {Layoff} from \"../point/Layoff\";\nimport {SimilarElement} from \"../point/SimilarElement\";\nimport {PolygonElement} from \"./PolygonElement\";\nimport {CurvedTriangleElement} from \"./CurvedTriangleElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {LineElement} from \"../line/LineElement\";\nimport {RegularPolygonElement} from \"./RegularPolygonElement\";\nimport {ApplicationElement} from \"./ApplicationElement\";\nimport {PolyhedronElement} from \"../polyhedron/PolyhedronElement\";\n\n/*************************\n * Element Class Polygon *\n *************************/\n\nexport abstract class PolyConstruction extends Construction {\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new PolygonElement(P);\n return [[g],g];\n }\n}\n\n// polygon\n// square — points A, B [, plane C = screen]\n// the square on a side AB in plane C\n// 2D: 2 points, 0 elements — uses screen plane\n// 3D: 2 points, 1 PlaneElement — uses explicit plane\n// (Java: RegularPolygon.java with n=4 — same class as equilateralTriangle)\nexport class SquarePolygonConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.square;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 2 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const plane = E.length > 0 ? E[0] as PlaneElement : screen;\n const g = new RegularPolygonElement(P[0], P[1], plane, 4);\n return [[g], g];\n }\n}\n\n// polygon\n// triangle\n// points A, B, C\n// the triangle ABC given 3 vertices A, B, and C\n// (Java: Slate.java polygon case 1 — new PolygonElement(A,B,C))\nexport class TrianglePolygonConstruction extends PolyConstruction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.triangle;\n signature = { points: 3, elements: 0, integers: 0 };\n}\n\n// polygon\n// quadrilateral\n// points A, B, C, D\n// the quadrilateral ABCD given 4 vertices A, B, C, and D\n// (Java: Slate.java polygon case 2 — new PolygonElement(A,B,C,D))\nexport class QuadrilateralPolygonConstruction extends PolyConstruction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.quadrilateral;\n signature = { points: 4, elements: 0, integers: 0 };\n}\n\n// polygon\n// pentagon\n// points A, B, C, D, E\n// the pentagon given 5 vertices (free points, not a regular pentagon)\n// (Java: Slate.java polygon case 3 — new PolygonElement(A,B,C,D,E))\nexport class PentagonPolygonConstruction extends PolyConstruction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.pentagon;\n signature = { points: 5, elements: 0, integers: 0 };\n}\n\n// polygon\n// hexagon\n// points A, B, C, D, E, F\n// the hexagon given 6 vertices (free points)\n// (Java: Slate.java polygon case 4 — new PolygonElement(A,B,C,D,E,F))\nexport class HexagonPolygonConstruction extends PolyConstruction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.hexagon;\n signature = { points: 6, elements: 0, integers: 0 };\n}\n\n// polygon\n// equilateralTriangle — points A, B [, plane C = screen]\n// the equilateral triangle on side AB in the plane C\n// 2D: 2 points, 0 elements — uses screen plane\n// 3D: 2 points, 1 PlaneElement — uses explicit plane\n// (Java: Slate.java polygon case 5 — new RegularPolygon(A,B,plane,3))\nexport class EquilateralTriangleConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.equilateralTriangle;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 2 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const plane = E.length > 0 ? E[0] as PlaneElement : screen;\n const g = new RegularPolygonElement(P[0], P[1], plane, 3);\n return [[g], g];\n }\n}\n\n// polygon\n// parallelogram\n// points A, B, C\n// the parallelogram ABCD given A, B, and C, where D = A + (C - B)\n// (no dedicated Java class — Slate.java case 6 dispatches to a Layoff\n// trick identical to the point;parallelogram and line;parallel patterns)\nexport class ParallelogramPolygonConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.parallelogram;\n signature = { points: 3, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let lo = new Layoff(P[0], P[1], P[2], P[1], P[2]);\n let g = new PolygonElement([P[0], P[1], P[2], lo]);\n return [[lo, g], g];\n }\n}\n\n// polygon\n// regularPolygon — points A, B, integer n [, plane C = screen]\n// the regular n-gon on side AB in the plane C\n// 2D: 2 points, 0 elements, 1 integer — uses screen plane\n// 3D: 2 points, 1 PlaneElement, 1 integer — uses explicit plane\n// (Java: Slate.java polygon case 7 — RegularPolygon(A,B,plane,n))\nexport class RegularPolygonConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.regularPolygon;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 1 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 2 && sp.N.length === 1\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const plane = E.length > 0 ? E[0] as PlaneElement : screen;\n const g = new RegularPolygonElement(P[0], P[1], plane, N[0]);\n return [[g], g];\n }\n}\n\n// polygon\n// starPolygon (2D variant)\n// points A, B, integers n, d\n// the star polygon {n/d} on side AB in the screen plane\n// (Java: Slate.java polygon case 8 — new RegularPolygon(A,B,screen,n,d))\nexport class StarPolygonConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.starPolygon;\n signature = { points: 2, elements: 0, integers: 2 };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new RegularPolygonElement(P[0], P[1], screen, N[0], N[1]);\n return [[g], g];\n }\n}\n\n\n// polygon\n// similar — points A, B, D, E, F [, planes C, G = screen]\n// the triangle ABH where H is the similar point so triangle ABH ~ triangle DEF\n// 2D: 5 points, 0 elements — uses screen plane for both\n// 3D: 5 points, 2 PlaneElements — uses explicit planes\n// (Java: Slate.java polygon case 9 — Similar(A,B,C,D,E,F,G) + PolygonElement(A,B,H))\nexport class SimilarPolygonConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.similar;\n signature: ConstructionSignature = { points: 5, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 5 && sp.N.length === 0\n && (sp.E.length === 0 || sp.E.length === 2);\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let c = E.length > 0 ? E[0] as PlaneElement : screen;\n let g2 = E.length > 1 ? E[1] as PlaneElement : screen;\n let sim = new SimilarElement(P[0], P[1], c, P[2], P[3], P[4], g2);\n let g = new PolygonElement([P[0], P[1], sim]);\n return [[sim, g], g];\n }\n}\n\n// polygon\n// application\n// polygon A points B, C, D\n// the parallelogram equal to the given polygon A with one side BC and one angle BCD\n// (Java: Application.java — parallelogram with area = P.area(), side BC, angle DCB)\nexport class ApplicationPolygonConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.application;\n signature = { points: 3, elements: 1, integers: 0, elementTypes: [PolygonElement] };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new ApplicationElement(E[0] as PolygonElement, P[0], P[1], P[2]);\n return [[g], g];\n }\n}\n\n// polygon\n// octagon\n// 8 points A, B, C, D, E, F, G, H\n// the octagon given 8 vertices (free points, pass-through)\n// (Java: Slate.java polygon case 11 — new PolygonElement(A,B,C,D,E,F,G,H))\nexport class OctagonPolygonConstruction extends PolyConstruction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.octagon;\n signature = { points: 8, elements: 0, integers: 0 };\n}\n\n// polygon\n// face\n// polyhedron A integer n\n// the nth face (1-based) of polyhedron A\n// (Java: Slate.java polygon case 12 — ((PolyhedronElement)E[0]).P[N[0]-1])\n// Same pattern as point;vertex (returns polygon from polyhedron, not point from polygon)\nexport class FacePolygonConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.face;\n signature = { points: 0, elements: 1, integers: 1, elementTypes: [PolyhedronElement] };\n\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const polyhedron = E[0] as PolyhedronElement;\n const face = polyhedron.P[N[0] - 1];\n return [[face], face];\n }\n}\n\n// A side carrier is the \"line\" a curved side lies on: a CircleElement (arc\n// side) or a LineElement (straight side / diameter). Lines reach us intact\n// because the construction sets keepsLineElements (see convertParams).\nfunction isCarrier(e: GeomElement): boolean {\n return e instanceof CircleElement || e instanceof LineElement;\n}\n\n// polygon — curvedTriangle — 3 vertices A,B,C + 3 side carriers\n// A triangle whose sides are circular arcs (an elliptic or hyperbolic\n// triangle): side i is the minor arc on carrier i from vertex i to vertex\n// i+1, clipped to the vertices (a line carrier gives a straight side). It\n// draws/fills/highlights those three side-segments itself, as one element\n// (#119). Strict 3 vertices + 3 carriers.\nexport class CurvedTriangleConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.curvedTriangle;\n signature: ConstructionSignature = { points: 3, elements: 3, integers: 0 };\n keepsLineElements: boolean = true;\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0\n && sp.E.length === 3 && sp.E.every(isCarrier);\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new CurvedTriangleElement(P.slice(), E.slice() as any[]);\n return [[g], g];\n }\n}\n\nexport const polygonConstructions: Construction[] = [\n new CurvedTriangleConstruction(),\n new TrianglePolygonConstruction(),\n new StarPolygonConstruction(),\n new RegularPolygonConstruction(),\n new SquarePolygonConstruction(),\n new EquilateralTriangleConstruction(),\n new ParallelogramPolygonConstruction(),\n new QuadrilateralPolygonConstruction(),\n new OctagonPolygonConstruction(),\n new PentagonPolygonConstruction(),\n new HexagonPolygonConstruction(),\n new SimilarPolygonConstruction(),\n new ApplicationPolygonConstruction(),\n new FacePolygonConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tLineElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\n\nimport {PointElement} from \"../point/PointElement\";\nimport {GeomElement} from \"../GeomElement\";\nimport {SlateCanvas} from \"../../Slate\";\n\nexport class PolygonElement extends GeomElement {\n\n public V : PointElement[];\n\n // Face fill alpha — drives drawFace's globalAlpha independent of\n // drawProgress (which drives the edge trace). Lets an animation\n // run the outline to completion at drawProgress = 1 first, then\n // separately fade the fill in by ticking faceAlpha 0 → 1. Default\n // 1 means \"fully opaque\" — every existing render path behaves\n // identically.\n private _faceAlpha : number = 1;\n\n set faceAlpha(value: number) {\n this._faceAlpha = value < 0 ? 0 : (value > 1 ? 1 : value);\n }\n get faceAlpha(): number { return this._faceAlpha; }\n\n constructor(ps?: PointElement[]) {\n super();\n this.dimension = 2;\n if (ps == null) {\n this.V = [];\n return;\n }\n this.V = ps;\n }\n\n public area() : number {\n // Ported from PolygonElement.java area() — 2026-04-12\n // Compute the area of this polygon (assuming it's planar & convex).\n // Uses fan triangulation from V[0].\n let sum = 0.0;\n for (let i = 0; i < this.V.length - 2; ++i) {\n sum += PointElement.area(this.V[0], this.V[i + 1], this.V[i + 2]);\n }\n return sum;\n }\n\n public drawEdge(c: HTMLCanvasElement, color?: string): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (color == null) {\n if (this.emphasized || this.shouldHighlight) {\n color = this.edgeHighlightColor;\n } else {\n color = this.edgeColor;\n }\n }\n\n if (color == null) return;\n if (this.V.length <= 1) return;\n\n let ctx = c.getContext(\"2d\");\n ctx.beginPath();\n ctx.strokeStyle = color;\n {\n const baseW = this.shouldHighlight ? 3 : 1;\n ctx.lineWidth = (baseW + this.emphasisAmount * (6 - baseW)) * GeomElement.styleScale;\n }\n // Edge enumeration: a closed polygon (>2 verts) has V.length\n // edges including the closing one; an open polyline has\n // V.length - 1. Each integer step of drawProgress · edgeCount\n // advances one full edge; the fractional remainder partially\n // traces the next. drawProgress = 1 (default) reproduces the\n // pre-animation full-trace behaviour bit-for-bit.\n let n = this.V.length;\n let isClosed = n > 2;\n let edgeCount = isClosed ? n : n - 1;\n let p = this.drawProgress;\n let totalProgress = p * edgeCount;\n let fullEdges = Math.floor(totalProgress);\n let fractionalEdge = totalProgress - fullEdges;\n\n ctx.moveTo(this.V[0].x, this.V[0].y);\n for (let i = 0; i < fullEdges; i++) {\n let to = this.V[(i + 1) % n];\n ctx.lineTo(to.x, to.y);\n ctx.stroke();\n }\n if (fractionalEdge > 0 && fullEdges < edgeCount) {\n let from = this.V[fullEdges];\n let to = this.V[(fullEdges + 1) % n];\n let px = from.x + (to.x - from.x) * fractionalEdge;\n let py = from.y + (to.y - from.y) * fractionalEdge;\n ctx.lineTo(px, py);\n ctx.stroke();\n }\n }\n\n public defined() : boolean {\n if (this.V.length == 0) return false;\n for(let v of this.V) {\n if (!v.defined()) return false;\n }\n return true;\n }\n\n public drawFace(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if(this.faceColor != null && this.defined() && this.V.length > 2) {\n let ctx : CanvasRenderingContext2D = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.beginPath();\n ctx.fillStyle = this.faceColor;\n let firstPoint = this.V[0];\n let rest = this.V.slice(1);\n ctx.moveTo(firstPoint.x, firstPoint.y);\n for(let vertex of rest)\n ctx.lineTo(vertex.x, vertex.y);\n ctx.closePath();\n // Animate the fill via the dedicated faceAlpha field so\n // outline-then-fill animations can run the edge trace to\n // completion at drawProgress = 1 first, then independently\n // tick faceAlpha from 0 to 1 for the fade-in. Default\n // faceAlpha = 1 preserves the fully-opaque behaviour for\n // every consumer that doesn't animate.\n let a = this.faceAlpha;\n if (a < 1) {\n if (a <= 0) return; // fully transparent — skip\n ctx.save();\n ctx.globalAlpha = a;\n ctx.fill();\n ctx.restore();\n } else {\n ctx.fill();\n }\n }\n }\n\n public drawName(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.nameColor != null && this.name != null && this.defined()) {\n let x : number = 0;\n let y : number = 0;\n for(let v of this.V) {\n x += v.x;\n y += v.y;\n }\n let n : number = this.V.length;\n x = x / n;\n y = y / n;\n let ctx : CanvasRenderingContext2D = c.getContext(\"2d\") as CanvasRenderingContext2D;\n let [w, h] = this._getTextMetrics(ctx, this._name);\n ctx.beginPath();\n ctx.fillStyle = this.nameColor;\n ctx.fillText(this._name, x - w/2., y + h/4.);\n }\n }\n\n public drawVertex(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.vertexColor != null && this.defined() ) {\n for(let v of this.V) {\n v.drawVertex(c, this.vertexColor);\n }\n }\n }\n\n public rotate(pivot: PointElement, ac: number, as: number): void {\n }\n\n public translate(dx: number, dy: number): void {\n }\n\n public update(): void {\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tRegularPolygonElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PolygonElement} from \"./PolygonElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class RegularPolygonElement extends PolygonElement {\n\n private _cos: number;\n private _sin: number;\n private _P: PlaneElement;\n\n constructor(A: PointElement, B: PointElement, plane: PlaneElement, n: number, d: number = 1) {\n super();\n this._P = plane;\n const theta = Math.PI * d * (n - 2) / n;\n this._cos = Math.cos(theta);\n this._sin = Math.sin(theta);\n this.V = new Array(n);\n this.V[0] = A;\n this.V[1] = B;\n for (let i = 2; i < n; i++) {\n this.V[i] = new PointElement({ AP: plane });\n }\n }\n\n update(): void {\n for (let i = 2; i < this.V.length; i++) {\n this.V[i].to(this.V[i - 2]);\n this.V[i].rotate(this.V[i - 1], this._cos, this._sin, this._P);\n }\n }\n\n translate(dx: number, dy: number): void {\n for (let i = 2; i < this.V.length; i++) {\n this.V[i].translate(dx, dy);\n }\n }\n\n rotate(pivot: PointElement, ac: number, as: number): void {\n for (let i = 2; i < this.V.length; i++) {\n this.V[i].rotate(pivot, ac, as, this._P);\n }\n }\n}\n","/*----------------------------------------------------------------------+\n| Polyhedron construction classes — extracted from Constructions.ts |\n+----------------------------------------------------------------------*/\n\nimport {Construction, AllConstructions,\n PolyhedraConstructions as PolyhedraConstructionsEnum,\n GeomElementsForUpdate} from \"../Constructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {Layoff} from \"../point/Layoff\";\nimport {PolygonElement} from \"../polygon/PolygonElement\";\nimport {PyramidElement} from \"./PyramidElement\";\nimport {PrismElement} from \"./PrismElement\";\n\n// polyhedron — tetrahedron — points A, B, C, D\n// (Java: Slate.java polyhedron case 0 — PolygonElement(A,B,C) + Pyramid(base,D))\nexport class TetrahedronConstruction extends Construction {\n constructionMethod: AllConstructions = PolyhedraConstructionsEnum.tetrahedron;\n signature = { points: 4, elements: 0, integers: 0 };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let base = new PolygonElement([P[0], P[1], P[2]]);\n let g = new PyramidElement(base, P[3]);\n return [[base, g], g];\n }\n}\n\n// polyhedron — parallelepiped — points A, B, C, D\n// (Java: Slate.java polyhedron case 1 — Layoff(B,A,C,A,C) + PolygonElement(B,A,C,fourth) + Prism(base,A,D))\nexport class ParallelepipedConstruction extends Construction {\n constructionMethod: AllConstructions = PolyhedraConstructionsEnum.parallelepiped;\n signature = { points: 4, elements: 0, integers: 0 };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let fourth = new Layoff(P[1], P[0], P[2], P[0], P[2]);\n let base = new PolygonElement([P[1], P[0], P[2], fourth]);\n let g = new PrismElement(base, P[0], P[3]);\n return [[fourth, base, g], g];\n }\n}\n\n// polyhedron — prism — polygon A, points B, C\n// (Java: Prism.java — 41 lines, line-for-line port)\nexport class PrismConstruction extends Construction {\n constructionMethod: AllConstructions = PolyhedraConstructionsEnum.prism;\n signature = { points: 2, elements: 1, integers: 0, elementTypes: [PolygonElement] };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new PrismElement(E[0] as PolygonElement, P[0], P[1]);\n return [[g], g];\n }\n}\n\n// polyhedron — pyramid — polygon A, point B\n// (Java: Pyramid.java — 11 lines, line-for-line port)\nexport class PyramidConstruction extends Construction {\n constructionMethod: AllConstructions = PolyhedraConstructionsEnum.pyramid;\n signature = { points: 1, elements: 1, integers: 0, elementTypes: [PolygonElement] };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new PyramidElement(E[0] as PolygonElement, P[0]);\n return [[g], g];\n }\n}\n\nexport const polyhedronConstructions: Construction[] = [\n new TetrahedronConstruction(),\n new ParallelepipedConstruction(),\n new PrismConstruction(),\n new PyramidConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tPolyhedronElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {GeomElement} from \"../GeomElement\";\nimport {PolygonElement} from \"../polygon/PolygonElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {SlateCanvas} from \"../../Slate\";\n\nexport class PolyhedronElement extends GeomElement {\n\n public P: PolygonElement[]; // array of face polygons\n\n constructor() {\n super();\n this.dimension = 2;\n this.P = [];\n }\n\n public defined(): boolean {\n for (let i = 0; i < this.P.length; ++i) {\n if (!this.P[i].defined()) return false;\n }\n return true;\n }\n\n public drawName(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.nameColor != null && this.name != null && this.defined()) {\n let x = 0, y = 0, ct = 0;\n for (let j = 0; j < this.P.length; ++j) {\n for (let i = 0; i < this.P[j].V.length; ++i) {\n x += this.P[j].V[i].x;\n y += this.P[j].V[i].y;\n ++ct;\n }\n }\n x /= ct;\n y /= ct;\n this.drawString(Math.round(x), Math.round(y), c);\n }\n }\n\n public drawVertex(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.vertexColor != null && this.defined()) {\n for (let j = 0; j < this.P.length; ++j) {\n for (let i = 0; i < this.P[j].V.length; ++i) {\n this.P[j].V[i].drawVertex(c, this.vertexColor);\n }\n }\n }\n }\n\n public drawEdge(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.edgeColor != null && this.defined()) {\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.strokeStyle = this.edgeColor;\n for (let j = 0; j < this.P.length; ++j) {\n for (let i = 0; i < this.P[j].V.length; ++i) {\n let a = this.P[j].V[i];\n let b = this.P[j].V[(i + 1) % this.P[j].V.length];\n ctx.beginPath();\n ctx.moveTo(a.x, a.y);\n ctx.lineTo(b.x, b.y);\n ctx.stroke();\n }\n }\n }\n }\n\n public drawFace(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.faceColor != null && this.defined()) {\n for (let j = 0; j < this.P.length; ++j) {\n // Pass the polyhedron's faceColor to each face polygon,\n // matching Java's P[j].drawFace(g, faceColor)\n let savedColor = this.P[j].faceColor;\n this.P[j].faceColor = this.faceColor;\n this.P[j].drawFace(c);\n this.P[j].faceColor = savedColor;\n }\n }\n }\n\n public update(): void {}\n public translate(dx: number, dy: number): void {}\n public rotate(pivot: PointElement, ac: number, as: number): void {}\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPrismElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PolyhedronElement} from \"./PolyhedronElement\";\nimport {PolygonElement} from \"../polygon/PolygonElement\";\nimport {PointElement} from \"../point/PointElement\";\n\nexport class PrismElement extends PolyhedronElement {\n\n // The base is given as well as a line segment CD for the sides to be\n // parallel to.\n\n private _C: PointElement;\n private _D: PointElement;\n\n constructor(Base: PolygonElement, C: PointElement, D: PointElement) {\n super();\n this.dimension = 2;\n this._C = C;\n this._D = D;\n let baseN = Base.V.length;\n let n = 2 + baseN;\n this.P = new Array(n);\n this.P[0] = Base;\n // create the top — vertices translated by (D-C) from base\n let topVerts : PointElement[] = new Array(baseN);\n for (let j = 0; j < baseN; ++j) {\n topVerts[j] = new PointElement();\n topVerts[j].to(Base.V[j]).plus(D).minus(C);\n }\n this.P[1] = new PolygonElement(topVerts);\n // create the sides — quadrilaterals connecting base and top edges\n for (let i = 2; i < n; ++i) {\n this.P[i] = new PolygonElement([\n Base.V[i - 2],\n Base.V[(i - 1) % baseN],\n this.P[1].V[(i - 1) % baseN],\n this.P[1].V[i - 2]\n ]);\n }\n }\n\n public translate(dx: number, dy: number) {\n for (let i = 0; i < this.P[1].V.length; ++i) {\n this.P[1].V[i].translate(dx, dy);\n }\n }\n\n public rotate(pivot: PointElement, ac: number, as: number) {\n for (let i = 0; i < this.P[1].V.length; ++i) {\n this.P[1].V[i].rotate(pivot, ac, as);\n }\n }\n\n public update() {\n for (let j = 0; j < this.P[1].V.length; ++j) {\n this.P[1].V[j].to(this.P[0].V[j]).plus(this._D).minus(this._C);\n }\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPyramidElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PolyhedronElement} from \"./PolyhedronElement\";\nimport {PolygonElement} from \"../polygon/PolygonElement\";\nimport {PointElement} from \"../point/PointElement\";\n\nexport class PyramidElement extends PolyhedronElement {\n\n constructor(Base: PolygonElement, Apex: PointElement) {\n super();\n this.dimension = 2;\n let n = 1 + Base.V.length;\n this.P = new Array(n);\n this.P[0] = Base;\n for (let i = 1; i < n; ++i) {\n this.P[i] = new PolygonElement([Apex, Base.V[i - 1], Base.V[i % Base.V.length]]);\n }\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tAngleMarkerElement.ts |\n| Part of the geomlib port of David E. Joyce's Geometry Applet. |\n| TypeScript: 2026, Nelson Brown, brownnrl@gmail.com |\n+----------------------------------------------------------------------*/\n\nimport {SectorElement} from \"./SectorElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\n// A small sector drawn at a vertex to mark the interior angle between\n// two arms. Unlike a plain `sector;sector` (whose radius is the\n// vertex-to-arm distance, so it swings with arm length), an angle\n// marker computes its OWN fixed radius — a sensible px default,\n// clamped to a fraction of the shorter arm so it never overshoots.\n// It also auto-orients to the interior arc, removing the per-marker\n// arm-order sign-check the old midpoint-chain pattern needed (#91).\n//\n// The vertex (_Center) and the two arm points are real slate elements\n// (drags follow them automatically). _A / _B are INTERNAL points,\n// recomputed each update() at the marker radius along each arm — they\n// are never registered on the slate. The inherited SectorElement\n// drawEdge / drawFace then render the wedge, with drawProgress,\n// emphasisAmount, and faceAlpha all working unchanged.\nexport const DEFAULT_ANGLE_MARKER_RADIUS_PX = 22;\nexport const ANGLE_MARKER_MAX_ARM_FRACTION = 0.45;\nexport const ANGLE_MARKER_RING_STEP = 9;\n\nexport class AngleMarkerElement extends SectorElement {\n\n private _arm1 : PointElement;\n private _arm2 : PointElement;\n private _radiusOverride : number;\n\n // Concentric-ring index for same-vertex markers. 0.8.1 will assign\n // this automatically so overlapping markers nest; for now it\n // defaults to 0 and can be set by hand. Each step bumps the radius\n // by ANGLE_MARKER_RING_STEP.\n public ringIndex : number = 0;\n\n // Draw the major (reflex, > 180°) arc instead of the interior\n // minor one. Default false — interior is the faithful Euclidean\n // case (his angles live in 0..180°). Set via the\n // `angleMarkerReflex` construction for the rare reflex marking\n // (e.g. a III.20-style central angle).\n public reflex : boolean = false;\n\n constructor(vertex: PointElement, arm1: PointElement, arm2: PointElement,\n plane: PlaneElement, radiusOverride?: number, reflex?: boolean) {\n super();\n this.dimension = 2;\n this._Center = vertex;\n this._arm1 = arm1;\n this._arm2 = arm2;\n this._P = plane;\n this._radiusOverride = radiusOverride != null ? radiusOverride : null;\n this.reflex = reflex === true;\n // Internal arc endpoints — placed in update().\n this._A = new PointElement();\n this._B = new PointElement();\n }\n\n // The vertex this marker sits at — used to group same-vertex\n // markers for auto radius-stepping (#103).\n get vertex() : PointElement { return this._Center; }\n\n // Whether the author pinned an explicit radius (opts the marker out\n // of auto radius-stepping).\n get hasRadiusOverride() : boolean { return this._radiusOverride != null; }\n\n // The interior angle magnitude (radians) between the two arms,\n // computed directly from the arm points so it's available before\n // update() places _A/_B. Used to order a same-vertex group\n // (smallest angle innermost).\n spanRadians() : number {\n return Math.abs(this._Center.angle(this._arm1, this._arm2, this._P));\n }\n\n // update() orders _A/_B so the inherited minor angle is negative\n // (interior, drawn with the default anticlockwise=true). A reflex\n // marker draws the MAJOR arc between the same two rays — same\n // endpoints, opposite side — which is the magnitude 2π−|minor| with\n // the anticlockwise flag flipped (see _anticlockwise).\n protected _arcAngle(): number {\n const minor = this._Center.angle(this._A, this._B, this._P);\n return this.reflex ? (2 * Math.PI - Math.abs(minor)) : minor;\n }\n\n protected _anticlockwise(): boolean {\n return !this.reflex;\n }\n\n // Angle markers flash their whole wedge during a transition (the\n // emphasis bump), not just the edge.\n protected _flashFace(): boolean {\n return true;\n }\n\n radius() : number {\n const a1 = this._Center.distance(this._arm1);\n const a2 = this._Center.distance(this._arm2);\n const shorter = Math.min(a1, a2);\n const base = this._radiusOverride != null\n ? this._radiusOverride\n : DEFAULT_ANGLE_MARKER_RADIUS_PX;\n const clamped = Math.min(base, shorter * ANGLE_MARKER_MAX_ARM_FRACTION);\n return clamped + this.ringIndex * ANGLE_MARKER_RING_STEP;\n }\n\n // Place an internal endpoint at distance r from the vertex along\n // the direction of `arm`.\n private _place(target: PointElement, arm: PointElement, r: number) : void {\n const dx = arm.x - this._Center.x;\n const dy = arm.y - this._Center.y;\n const dz = arm.z - this._Center.z;\n const len = Math.sqrt(dx*dx + dy*dy + dz*dz);\n if (len === 0) {\n target.x = this._Center.x;\n target.y = this._Center.y;\n target.z = this._Center.z;\n return;\n }\n target.x = this._Center.x + dx / len * r;\n target.y = this._Center.y + dy / len * r;\n target.z = this._Center.z + dz / len * r;\n }\n\n update() : void {\n const r = this.radius();\n this._place(this._A, this._arm1, r);\n this._place(this._B, this._arm2, r);\n // Auto-interior: PointElement.angle is signed (−π..π) and atan2\n // already returns the short way, so the magnitude is the\n // interior angle; only the rendered sweep direction matters.\n // The empirically-interior case (matching the old sign-checks)\n // is angle(_A, _B) < 0 — if it's positive, swap the arms.\n const ang = this._Center.angle(this._A, this._B, this._P);\n if (ang > 0) {\n this._place(this._A, this._arm2, r);\n this._place(this._B, this._arm1, r);\n }\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tArcElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {SectorElement} from \"./SectorElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\n/**\n * Port of geom_applet/source/Arc.java — an arc through three points.\n *\n * Given points A, M, B (with M on the arc between A and B), draws the\n * arc of the unique circle passing through all three. The circle's\n * center is recomputed on every update() as circumcenter(A, M, B) and\n * stored in the inherited _Center field; SectorElement.drawEdge then\n * sweeps the arc from A to B using the inherited angle math.\n *\n * _Center is an internal bare PointElement, not registered on the\n * slate. Arc.update() writes into it directly, so it stays in sync\n * with A, M, B without needing a separate elementsForUpdate entry.\n *\n * translate / rotate are overridden so that grabbing and moving the\n * arc (either via a drag or via a global pivot rotation) perturbs\n * only the inherited _Center; A, M, B are independent slate elements\n * and are moved by their own handlers. This mirrors Java Arc.java\n * exactly — see geom_applet/source/Arc.java lines 19-23.\n */\nexport class ArcElement extends SectorElement {\n\n _M : PointElement; // the \"through\" point on the arc between A and B\n\n constructor(A: PointElement, M: PointElement, B: PointElement, P: PlaneElement) {\n super();\n this.dimension = 2;\n this._Center = new PointElement();\n this._A = A;\n this._M = M;\n this._B = B;\n this._P = P;\n }\n\n update(): void {\n // Java Arc.update() explicitly calls P.update() first. The TS\n // slate already updates elements in dependency order, so this\n // is arguably redundant — but we keep it for parity with Java\n // in case some emergent behavior depends on it.\n this._P.update();\n this._Center.toCircumcenter(this._A, this._M, this._B);\n }\n\n translate(dx: number, dy: number): void {\n this._Center.translate(dx, dy);\n }\n\n rotate(pivot: PointElement, ac: number, as: number): void {\n this._Center.rotate(pivot, ac, as);\n }\n}\n","// Animations targeting SectorElement (and its ArcElement subclass).\n// See ../Animations.ts for the abstract base + registry mechanics.\n\nimport {Animation, AllAnimations, IAnimationStep, registerAnimation} from \"../Animations\";\nimport {GeomElement} from \"../GeomElement\";\nimport {Slate} from \"../../Slate\";\nimport {SectorElement} from \"./SectorElement\";\n\n// Same sweep rate as Circle.compass so an angle arc feels like the\n// same instrument; a typical quarter-turn marker (~π/2) sweeps in\n// ~500 ms. Min duration keeps a narrow angle from blinking past.\nconst DEFAULT_SWEEP_RATE_RAD_PER_MS = 0.003;\nconst MIN_SWEEP_MS = 250;\nconst DEFAULT_SECTOR_FILL_MS = 500;\n\n// A.Sector.sweep — the arc grows from the A arm toward the B arm by\n// driving drawProgress. Args: none. Duration = |arcAngle| / rate.\n//\n// Two-step when the sector has a face (sweep then face fade-in,\n// mirroring Circle.compass); a face-less sector skips the fill step\n// entirely (#81 pattern) — which is the common case for zero-color\n// angle markers that render gold only while animating.\nexport class SectorSweepAnimation extends Animation {\n public animationMethod = AllAnimations.SECTOR_SWEEP;\n public name = \"Sector.sweep\";\n public elementType = SectorElement;\n public defaultRate = DEFAULT_SWEEP_RATE_RAD_PER_MS;\n public defaultDurationMs = DEFAULT_SECTOR_FILL_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const sector = target as SectorElement;\n // arcSpan() reflects what's actually drawn (the major arc for a\n // reflex marker), so the duration matches the visible sweep.\n const arcAngle = sector.arcSpan();\n const sweepMs = Math.max(MIN_SWEEP_MS, arcAngle / this.defaultRate);\n const fullRestore = () => {\n sector.faceAlpha = 1;\n sector.drawProgress = 1;\n sector.visible = true;\n };\n const sweep: IAnimationStep = {\n durationMs: sweepMs,\n setup: () => {\n sector.faceAlpha = 0;\n sector.drawProgress = 0;\n },\n tick: (progress) => { sector.drawProgress = progress; },\n finalise: () => { sector.drawProgress = 1; },\n };\n if (sector.faceColor == null) {\n sweep.finalise = fullRestore;\n return [sweep];\n }\n const fillMs = Math.min(sweepMs / 2, this.defaultDurationMs);\n return [\n sweep,\n {\n durationMs: fillMs,\n tick: (progress) => { sector.faceAlpha = progress; },\n finalise: fullRestore,\n },\n ];\n }\n}\n\nregisterAnimation(new SectorSweepAnimation());\n","/*----------------------------------------------------------------------+\n| Sector construction classes — extracted from Constructions.ts |\n+----------------------------------------------------------------------*/\n\nimport {Construction, ConstructionSignature, SortedParams, AllConstructions,\n SectorConstructions as SectorConstructionsEnum,\n GeomElementsForUpdate} from \"../Constructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {SectorElement} from \"./SectorElement\";\nimport {ArcElement} from \"./ArcElement\";\nimport {AngleMarkerElement} from \"./AngleMarkerElement\";\n\n// sector — points A, B, C [, plane D = screen]\n// 2D: 3 points, 0 elements — uses screen plane\n// 3D: 3 points, 1 PlaneElement — uses explicit plane\n// (Java: Slate.java sector case 0 — new SectorElement(A,B,C,plane))\nexport class SectorConstruction extends Construction {\n constructionMethod: AllConstructions = SectorConstructionsEnum.sector;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new SectorElement({O:P[0], A:P[1], B:P[2], P: plane});\n return [[g], g];\n }\n}\n\n// sector — arc — points A, M, B [, plane D = screen]\n// 2D: 3 points, 0 elements — uses screen plane\n// 3D: 3 points, 1 PlaneElement — uses explicit plane\n// (Java: Slate.java sector case 1 — new ArcElement(A,M,B,plane))\nexport class ArcConstruction extends Construction {\n constructionMethod: AllConstructions = SectorConstructionsEnum.arc;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new ArcElement(P[0], P[1], P[2], plane);\n return [[g], g];\n }\n}\n\n// angleMarker — vertex V, arm points P1, P2 [, int radiusPx]\n// Marks the interior angle P1-V-P2 with a small fixed-radius sector\n// (radius computed by the element, not the arm length). The optional\n// integer overrides the default px radius. 2D screen-plane only for\n// v1. (#91)\nexport class AngleMarkerConstruction extends Construction {\n constructionMethod: AllConstructions = SectorConstructionsEnum.angleMarker;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0 && sp.E.length === 0;\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new AngleMarkerElement(P[0], P[1], P[2], screen);\n return [[g], g];\n }\n}\n\n// angleMarker with an explicit px radius override.\nexport class AngleMarkerRadiusConstruction extends Construction {\n constructionMethod: AllConstructions = SectorConstructionsEnum.angleMarker;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 1 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 1 && sp.E.length === 0;\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new AngleMarkerElement(P[0], P[1], P[2], screen, N[0]);\n return [[g], g];\n }\n}\n\n// angleMarkerReflex — same as angleMarker but draws the major (reflex,\n// > 180°) arc. Rare; Euclid avoids reflex angles, so this is for the\n// occasional teaching case (a III.20-style central angle). (#91)\nexport class AngleMarkerReflexConstruction extends Construction {\n constructionMethod: AllConstructions = SectorConstructionsEnum.angleMarkerReflex;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0 && sp.E.length === 0;\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new AngleMarkerElement(P[0], P[1], P[2], screen, undefined, true);\n return [[g], g];\n }\n}\n\nexport class AngleMarkerReflexRadiusConstruction extends Construction {\n constructionMethod: AllConstructions = SectorConstructionsEnum.angleMarkerReflex;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 1 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 1 && sp.E.length === 0;\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new AngleMarkerElement(P[0], P[1], P[2], screen, N[0], true);\n return [[g], g];\n }\n}\n\nexport const sectorConstructions: Construction[] = [\n new SectorConstruction(),\n new ArcConstruction(),\n new AngleMarkerConstruction(),\n new AngleMarkerRadiusConstruction(),\n new AngleMarkerReflexConstruction(),\n new AngleMarkerReflexRadiusConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tSectorElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {GeomElement} from \"../GeomElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {Midpoint} from \"../point/Midpoint\";\nimport {SlateCanvas} from \"../../Slate\";\n\nexport interface ISectorElementConstruction {\n O: PointElement;\n A: PointElement;\n B: PointElement;\n P: PlaneElement;\n}\n\nexport class SectorElement extends GeomElement {\n\n _Center : PointElement;\n _A : PointElement;\n _B : PointElement;\n // A and B are two points on a circle with the given center\n\n _P : PlaneElement; // plane of the circle\n\n _angle : number = null;\n\n // Face fill alpha — drives drawFace's globalAlpha independent of\n // drawProgress (which drives the arc sweep). Default 1 keeps every\n // existing render path identical. Mirrors Circle/Polygon (#86).\n private _faceAlpha : number = 1;\n\n set faceAlpha(value: number) {\n this._faceAlpha = value < 0 ? 0 : (value > 1 ? 1 : value);\n }\n get faceAlpha(): number { return this._faceAlpha; }\n\n constructor(isec?: ISectorElementConstruction) {\n super();\n this.dimension = 2;\n if(isec != null) {\n this._Center = isec.O;\n this._A = isec.A;\n this._B = isec.B;\n this._P = isec.P;\n }\n }\n\n radius() : number {\n return this._Center.distance(this._A);\n }\n\n defined() {\n return this._A.defined() && this._B.defined() && this._Center.defined();\n }\n\n\n // Here, we differ from the original implementation.\n // Since A and B are on the circle, we find the midpoint M between them.\n // Then we calculate a radius distance along the line from Center M\n // as the \"through\" point.\n\n _updateThroughPoint() : void {\n let r = this.radius();\n if(r == 0) { // degenerate circle\n return;\n }\n this._angle = Math.atan2(this._B.y - this._A.y, this._B.x - this._A.x) -\n Math.atan2(this._Center.y - this._A.y, this._Center.x - this._A.x);\n let x = this._Center.x + Math.cos(this._angle/2) * r;\n let y = this._Center.y + Math.sin(this._angle/2) * r;\n }\n\n drawEdge(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n // Pick the highlight color BEFORE the null bail, matching the\n // other element types (#81 / #86) — a zero-color sector can\n // still render in the highlight stroke while emphasized or\n // slide-highlighted, which is what lets invisible angle\n // markers light up on demand.\n const color = (this.emphasized || this.shouldHighlight)\n ? this.edgeHighlightColor\n : this.edgeColor;\n if (color == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.strokeStyle = color;\n {\n const baseW = this.shouldHighlight ? 3 : 1;\n ctx.lineWidth = (baseW + this.emphasisAmount * (6 - baseW)) * GeomElement.styleScale;\n }\n ctx.beginPath();\n let r = this.radius();\n let startAngle = Math.atan2(\n this._A.y - this._Center.y,\n this._A.x - this._Center.x);\n let arcAngle = this._arcAngle();\n // Partial sweep for slide-transition animation: the arc grows\n // from the A arm toward the B arm as drawProgress goes 0 → 1.\n // Default progress = 1 reproduces the full arc bit-for-bit.\n let endAngle = startAngle + arcAngle * this.drawProgress;\n ctx.arc(this._Center.x, this._Center.y, r, startAngle, endAngle, this._anticlockwise());\n ctx.stroke();\n }\n\n // The signed arc to sweep from the A arm to the B arm, in radians.\n // Default is the minor signed angle (−π..π). AngleMarkerElement\n // overrides this to optionally sweep the major (reflex) arc.\n protected _arcAngle(): number {\n return this._Center.angle(this._A, this._B, this._P);\n }\n\n // Sweep direction passed to ctx.arc. Fixed true for plain sectors /\n // arcs (their authors order _A/_B for that). AngleMarkerElement\n // flips it to draw the major arc between the same two rays for a\n // reflex marker.\n protected _anticlockwise(): boolean {\n return true;\n }\n\n // Magnitude of the swept arc — used by A.Sector.sweep to size the\n // animation duration to what's actually drawn (so a reflex marker\n // doesn't sweep a big arc in a tiny time).\n public arcSpan(): number {\n return Math.abs(this._arcAngle());\n }\n\n // Trace the closed wedge path (arc + the two radii back to centre)\n // into the current ctx path. Shared by the face fill and the flash\n // overlay so they cover exactly the same region.\n protected _traceWedge(ctx: CanvasRenderingContext2D, r: number): void {\n let startAngle = Math.atan2(\n this._A.y - this._Center.y,\n this._A.x - this._Center.x);\n let arcAngle = this._arcAngle();\n let endAngle = startAngle + arcAngle;\n ctx.beginPath();\n ctx.arc(this._Center.x, this._Center.y, r, startAngle, endAngle, this._anticlockwise());\n ctx.moveTo(this._Center.x, this._Center.y);\n if(arcAngle <= 180.) {\n ctx.lineTo(this._A.x, this._A.y);\n ctx.lineTo(this._B.x, this._B.y);\n } else {\n ctx.lineTo(this._B.x, this._B.y);\n ctx.lineTo(this._A.x, this._A.y);\n }\n ctx.lineTo(this._Center.x, this._Center.y);\n }\n\n // Whether the whole wedge should flash (fill with the highlight\n // color) while emphasised. False for plain sectors/arcs — only\n // angle markers light up their fill during a slide transition.\n protected _flashFace(): boolean {\n return false;\n }\n\n drawFace(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.faceColor == null || !this.defined()) return;\n // Face is independent of the edge sweep — always the full\n // sector wedge, with alpha driven by the dedicated faceAlpha\n // field (mirrors Circle/Polygon, #86). Default 1 preserves\n // the fully-opaque behaviour for every non-animating consumer.\n let a = this.faceAlpha;\n if (a <= 0) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n let r = this.radius();\n ctx.fillStyle = this.faceColor;\n this._traceWedge(ctx, r);\n if (a < 1) {\n ctx.save();\n ctx.globalAlpha = a;\n ctx.fill();\n ctx.restore();\n } else {\n ctx.fill();\n }\n // Transition flash: while emphasised (the animator bumps\n // emphasisAmount to 1 during a sweep and fades it 1 → 0\n // afterward), light the ENTIRE wedge with the highlight color,\n // fading with the emphasis. Edge-only emphasis (stroke width /\n // gold) already happens in drawEdge; this fills the area too.\n if (this._flashFace() && this.emphasisAmount > 0) {\n ctx.save();\n ctx.fillStyle = this.faceHighlightColor;\n ctx.globalAlpha = 0.55 * this.emphasisAmount;\n this._traceWedge(ctx, r);\n ctx.fill();\n ctx.restore();\n }\n }\n\n drawName(c: SlateCanvas): void {\n }\n\n drawVertex(c: SlateCanvas): void {}\n\n rotate(pivot: PointElement, ac: number, as: number): void {}\n\n translate(dx: number, dy: number): void {}\n\n update(): void {\n this._updateThroughPoint();\n }\n\n}\n","/*----------------------------------------------------------------------+\n| Sphere construction classes — extracted from Constructions.ts |\n+----------------------------------------------------------------------*/\n\nimport {Construction, AllConstructions,\n SphereConstructions as SphereConstructionsEnum,\n GeomElementsForUpdate} from \"../Constructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {SphereElement} from \"./SphereElement\";\n\n// sphere — radius — points A, B\n// (Java: Slate.java sphere case 0 — new SphereElement(A, A, B))\nexport class SphereRadiusConstruction extends Construction {\n constructionMethod: AllConstructions = SphereConstructionsEnum.radius;\n signature = { points: 2, elements: 0, integers: 0 };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new SphereElement({Center: P[0], B: P[1]});\n return [[g], g];\n }\n}\n\n// sphere — radius (3-point) — points A, B, C — center A, radius |BC|\n// (Java: Slate.java sphere case 0, choice 1 — new SphereElement(A,B,C))\nexport class SphereRadius3PointConstruction extends Construction {\n constructionMethod: AllConstructions = SphereConstructionsEnum.radius;\n signature = { points: 3, elements: 0, integers: 0 };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new SphereElement({Center: P[0], A: P[1], B: P[2]});\n return [[g], g];\n }\n}\n\nexport const sphereConstructions: Construction[] = [\n new SphereRadius3PointConstruction(),\n new SphereRadiusConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tSphereElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2024, Nelson Brown, brownnrl@gmail.com |\n+----------------------------------------------------------------------*/\n\n\nimport {GeomElement, Align} from \"../GeomElement\"\nimport {SlateCanvas} from \"../../Slate\";\nimport {PointElement} from \"../point/PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport interface ISphereElementConstruction {\n Center? : PointElement;\n A? : PointElement; // radius is AB\n B? : PointElement; // A assumed to be Center unless provided\n}\n\nexport class SphereElement extends GeomElement {\n\n protected _Center : PointElement;\n protected _A : PointElement; // radius is AB\n protected _B : PointElement;\n\n get Center() : PointElement { return this._Center; }\n\n constructor(ip? : ISphereElementConstruction) {\n super();\n this.dimension = 2;\n this._Center = ip && ip.Center || new PointElement();\n this._A = ip && ip.A || this._Center;\n this._B = ip && ip.B || new PointElement();\n }\n\n public drawName(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if(this.nameColor != null && this.name != null && this.defined()) {\n this.drawString(Math.round(this._Center.x), Math.round(this._Center.y), c, Align.CENTRAL);\n }\n }\n\n public defined() : boolean {\n return true;\n }\n\n public drawEdge(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.edgeColor == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.save();\n ctx.strokeStyle = this.edgeColor;\n let r = this.radius();\n ctx.beginPath();\n // ellipse() takes (centerX, centerY, radiusX, radiusY, ...)\n ctx.ellipse(\n this._Center.x,\n this._Center.y,\n r,\n r,\n 0,\n 0,\n 2*Math.PI);\n ctx.stroke();\n ctx.restore();\n }\n\n public drawFace(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.faceColor == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.save();\n ctx.fillStyle = this.faceColor;\n let r = this.radius();\n ctx.beginPath();\n ctx.ellipse(\n this._Center.x,\n this._Center.y,\n r,\n r,\n 0,\n 0,\n 2*Math.PI);\n ctx.fill();\n ctx.restore();\n }\n\n public radius() : number { return this._A.distance(this._B); }\n public radius2() : number { return this._A.distance2(this._B); }\n\n public drawVertex() {}\n public update(): void {}\n public translate(dx: number, dy: number): void {}\n public rotate(pivot: PointElement, ac: number, as : number, plane?: PlaneElement) : void {\n }\n\n}\n","import {GeomElement, Align as align} from \"./elements/GeomElement\"\nimport {AllConstructions, E as e} from \"./elements/Constructions\"\nimport {AllAnimations, A} from \"./elements/Animations\"\n// Per-type animation modules — imported for side effects so each\n// Animation subclass registers with the registry at module load. Adding\n// a new animation file is a one-line `import \"./elements/.../X\"` here.\nimport \"./elements/point/PointAnimations\";\nimport \"./elements/line/LineAnimations\";\nimport \"./elements/circle/CircleAnimations\";\nimport \"./elements/polygon/PolygonAnimations\";\nimport \"./elements/sector/SectorAnimations\";\nimport \"./elements/group/GroupAnimations\";\nimport {PointElement} from \"./elements/point/PointElement\";\nimport {Slate} from \"./Slate\";\nimport {PlaneSlider} from \"./elements/point/PlaneSlider\";\nimport {AngleMarkerElement} from \"./elements/sector/AngleMarkerElement\";\nimport {colors, randomColor, lighten, darken, parseColor, anglePalette} from \"./Colors\";\nimport {createControls} from \"./SlateControls\";\n\nexport type IndexAllConstructions = AllConstructions;\nexport {align as Align};\nexport {e as E};\nexport {AllAnimations, A};\n\n// Build marker — bumped when behaviour-affecting changes ship so consumers\n// (e.g. the test pages used to investigate #55) can confirm which bundle\n// they're actually running.\nexport const BUILD_MARKER = \"pointer-events-refactor-v1 (Slate.ts #55)\";\n\nexport let slates : Slate[] = [];\n\n// #130 — highlight a named element across MORE THAN ONE canvas at once.\n// A proposition drawn as several figures that share element names (e.g.\n// I.26's two case triangles, both labelled ABC/DEF) wants a single prose\n// reference to light the element in EVERY canvas it appears in, not just\n// one. This sets `emphasized` on each matching element — alias-aware, via\n// `slate.lookupElement` (so a ref spelled \"CBA\" still matches \"ABC\") —\n// across all live slates, or only those whose canvas id is listed in\n// `opts.canvasids` (scope correctly on a page with unrelated figures).\n// Each touched slate is redrawn, which fires that canvas's\n// `geomlib:highlight` event (#108) so the page lights every prose span.\n// Returns the number of canvases the element was found in.\nexport function highlightByName(name: string, on: boolean = true,\n opts?: { canvasids?: string[] }): number {\n const ids = opts && opts.canvasids;\n let hits = 0;\n for (const slate of slates) {\n if (ids != null) {\n const id = (slate.canvas as any) && (slate.canvas as any).id;\n if (ids.indexOf(id) === -1) continue;\n }\n const el = slate.lookupElement(name);\n if (el == null) continue;\n el.emphasized = on;\n slate.update();\n hits++;\n }\n return hits;\n}\n\nexport interface IConstructionInfo {\n name: string;\n construction: IndexAllConstructions;\n params: any[];\n nameColor?: string | number;\n vertexColor?: string | number;\n edgeColor?: string | number;\n faceColor?: string | number;\n}\n\n// Marginal-reference shape for slides. The `ref` is a symbolic label\n// such as \"I.Post.3\" or \"C.N.1\"; URL resolution happens via the\n// consumer-supplied resolveJustification callback so the data here\n// doesn't go stale if a referenced page moves on the consumer site.\nexport interface ISlideJust {\n ref: string;\n}\n\n// One step in the slideshow / presentation walk-through. The DSL is\n// declarative: each slide describes its full effective state, and the\n// Presentation controller computes the transitions between them.\n//\n// - visible inherits from the previous slide if omitted, so authors\n// only re-specify on state change.\n// - highlighted defaults to [] (clears between slides), so a\n// highlight only persists when re-specified on the next slide.\n// - Draggable elements (e.draggable === true) are auto-unioned into\n// the visible set by the Presentation controller; authors don't\n// need to list free construction points per slide.\n// - Highlighted elements are auto-unioned into visible — you can't\n// highlight what isn't drawn.\n// Per-element animation choice on one slide. Cascade order = the\n// array order. An element revealed by the slide but not listed here\n// pops in instantly. See A.* / AllAnimations for valid name values.\nexport interface ISlideAnimation {\n elem: string;\n name: AllAnimations | string;\n args?: any;\n durationMs?: number;\n}\n\nexport interface ISlideTransition {\n mode?: \"cascade\" | \"parallel\";\n animations?: ISlideAnimation[];\n}\n\nexport interface ISlide {\n text: string;\n visible?: string[];\n highlighted?: string[];\n justifications?: ISlideJust[];\n transition?: ISlideTransition;\n}\n\n// Slate-level animation tuning. No \"default animations\" — animations\n// are strictly opt-in per slide via slide.transition.animations. A\n// slate that never sets animationConfig keeps the 0.5.0 instant\n// behaviour everywhere.\nexport interface IAnimationConfig {\n // Per-animation rate overrides, keyed by animation name. Lets a\n // consumer dial all \"Line.straightEdgeConnect\" animations 30%\n // slower without touching individual slides.\n rates?: { [animationName: string]: number };\n // Per-animation duration overrides.\n durations?: { [animationName: string]: number };\n // Pause between cascaded steps; default 0.\n cascadeGapMs?: number;\n // Global multiplier; 1.0 default; 0 = jump-to-final.\n speedMultiplier?: number;\n // Default reads prefers-reduced-motion CSS media query at init().\n reducedMotion?: boolean;\n}\n\nexport interface IInitialization {\n background : string;\n title : string;\n align? : align;\n canvasid? : string;\n pivot?: string;\n font?: string;\n fontsize?: number;\n // Authored logical coordinate size (#71). Optional — normally inferred\n // from the canvas's CSS style px / width-height attribute. Set it to\n // pin the coordinate space when neither is declared, or to override.\n width?: number;\n height?: number;\n elements: (IConstructionInfo | string)[];\n // Secondary element names that resolve to a canonical element.\n // Lets prose name an element under any of the conventional\n // letter-permutations (e.g. \"circle BCD\" ≡ \"circle CDB\") without\n // forcing the canvas to carry an invisible duplicate per alias.\n // Resolved by Slate.lookupElement after a direct-name miss.\n aliases?: {[from: string]: string};\n // Draggable element names excluded from the slideshow's\n // every-slide auto-union (#89). Use for draggables the proof\n // introduces mid-walk (\"Take an arbitrary point F\") so they stay\n // hidden until a slide's visible set includes them. They remain\n // fully draggable whenever shown. No effect outside presentation\n // mode.\n deferDraggables?: string[];\n // 0.9.0+ — element names that start hidden in the static figure\n // (visible = false). Revealed by a slide's visible set, or when the\n // element is highlighted / its {NAME} ref is hovered. clearVisibility\n // (presentation exit) restores to this baseline. (#100)\n initiallyHidden?: string[];\n // 0.9.0+ — show angle markers (E.Sector.angleMarker /\n // angleMarkerReflex) in the static figure. Default false: markers\n // are hidden initially (Euclid's source diagram draws no angle arcs)\n // and appear during the slide walk or on hover. (#100)\n showAngles?: boolean;\n // Optional slideshow walk-through. When provided + non-empty,\n // SlateControls renders a \"▶ Present\" button that opens the\n // Presentation overlay. Stays empty (no button, no behaviour\n // change) for consumers that don't opt in.\n slides?: ISlide[];\n // Consumer lookup that maps a justification ref (\"I.Post.3\") to\n // a URL string. Returning null/undefined renders the ref as\n // plain text. Sync; the lektor site wires this to a page-emitted\n // window.eucrefs map.\n resolveJustification?: (ref: string) => string | null | undefined;\n // Slide-transition animation config. Optional; without it, the\n // slideshow keeps the 0.5.0 instant behaviour. Animations are\n // also strictly per-slide opt-in — even with animationConfig set,\n // a slide without transition.animations pops in instantly.\n animationConfig?: IAnimationConfig;\n}\n\n// Map Java element class names to E object keys\nconst typeMap: {[key: string]: string} = {\n \"point\": \"Point\", \"line\": \"Line\", \"circle\": \"Circle\",\n \"polygon\": \"Polygon\", \"sector\": \"Sector\", \"plane\": \"Plane\",\n \"sphere\": \"Sphere\", \"polyhedron\": \"Polyhedra\"\n};\n\n// Parse a Java applet param value string into an IConstructionInfo.\n// Format: \"name;type;construction;arg1,arg2,...[;nameColor[;vertexColor[;edgeColor[;faceColor]]]]\"\n// Example: \"M;point;midpoint;A,B;0;0\" → { name: \"M\", construction: E.Point.midpoint, params: [\"A\",\"B\"], nameColor: \"0\", vertexColor: \"0\" }\nexport function parseParam(value: string): IConstructionInfo {\n let fields = value.split(\";\");\n if (fields.length < 4) {\n throw new Error(`parseParam: expected at least 4 semicolon-separated fields, got ${fields.length}: \"${value}\"`);\n }\n\n let name = fields[0];\n let type = fields[1];\n let construction = fields[2];\n let data = fields[3];\n\n // Look up the construction enum value\n let typeKey = typeMap[type];\n if (typeKey == null) {\n throw new Error(`parseParam: unknown element type \"${type}\" in \"${value}\"`);\n }\n let enumObj = (e as any)[typeKey];\n // Handle Java names that differ from TS enum keys\n let enumKey = construction === \"3points\" ? \"threePoints\" : construction;\n let constructionEnum = enumObj[enumKey];\n if (constructionEnum == null) {\n throw new Error(`parseParam: unknown construction \"${type};${construction}\" in \"${value}\"`);\n }\n\n // Parse params: split on comma, convert numeric strings to numbers\n let params: any[] = data.split(\",\").map(s => {\n let n = Number(s);\n return (s !== \"\" && !isNaN(n)) ? n : s;\n });\n\n // Parse optional color fields (positions 4-7)\n let result: IConstructionInfo = { name, construction: constructionEnum, params };\n if (fields.length > 4 && fields[4] !== undefined) result.nameColor = fields[4];\n if (fields.length > 5 && fields[5] !== undefined) result.vertexColor = fields[5];\n if (fields.length > 6 && fields[6] !== undefined) result.edgeColor = fields[6];\n if (fields.length > 7 && fields[7] !== undefined) result.faceColor = fields[7];\n\n return result;\n}\n\n// The construction's authored coordinate extent (logical px). Element\n// coords are authored in this space; the figure is fit-scaled from here to\n// the (responsive) display. Read before the bitmap is resized. (#71)\nfunction authoredLogicalSize(i: IInitialization, canvas: HTMLCanvasElement) : [number, number] {\n const c = canvas as any;\n const px = (s: any) => {\n const m = /^\\s*(\\d+(?:\\.\\d+)?)\\s*px\\s*$/.exec(typeof s === \"string\" ? s : \"\");\n return m ? parseFloat(m[1]) : 0;\n };\n const style = c.style || {};\n const attr = (n: string) => (typeof c.getAttribute === \"function\"\n ? parseInt(c.getAttribute(n) || \"0\", 10) || 0 : 0);\n const w = (i.width || 0) || px(style.width) || attr(\"width\") || c.clientWidth || canvas.width;\n const h = (i.height || 0) || px(style.height) || attr(\"height\") || c.clientHeight || canvas.height;\n return [w, h];\n}\n\n// Size the canvas BITMAP to its CSS display size × devicePixelRatio so it\n// renders crisp on HiDPI / retina (#71). The construction coordinate space\n// stays in CSS px (clientWidth/Height); drawElements scales the context by\n// dpr. Headless / no window → dpr 1, so node rendering is unchanged.\n// see https://stackoverflow.com/questions/4938346/canvas-width-and-height-in-html5\nfunction resizeCanvasToDisplaySize(canvas: HTMLCanvasElement) : void {\n const dpr = (typeof window !== \"undefined\" && window.devicePixelRatio) || 1;\n const width = Math.round(canvas.clientWidth * dpr);\n const height = Math.round(canvas.clientHeight * dpr);\n\n if (canvas.width != width || canvas.height != height) {\n canvas.width = width;\n canvas.height = height;\n }\n}\n\n/**\n * If init() fails partway, the canvas stays blank and the user sees\n * nothing — the <noscript> tag won't fire because JS *is* running, it\n * just errored. This helper looks for a <noscript> sibling of the\n * canvas (the conventional location for the static-image fallback,\n * e.g. <noscript><img src=\"propI4.gif\"/></noscript>), reparses its\n * contents, inserts them as a visible sibling, and hides the canvas.\n *\n * Safe no-op if `canvas` is null, has no noscript sibling, or any\n * DOM operation throws. Exported so consumers can call it directly\n * if they have their own error-handling path.\n */\nexport function revealNoscriptFallback(canvas: HTMLCanvasElement | null): void {\n if (!canvas) return;\n try {\n // Scan up to ~5 element siblings forward — the <noscript> is\n // usually the immediate next, but the document may have other\n // markup interleaved.\n let sibling = canvas.nextElementSibling;\n let attempts = 0;\n while (sibling && attempts++ < 5 && sibling.tagName !== \"NOSCRIPT\") {\n sibling = sibling.nextElementSibling;\n }\n if (!sibling || sibling.tagName !== \"NOSCRIPT\") return;\n\n // With JS enabled, <noscript>'s contents are a single text node\n // holding the raw markup. Reparse via a wrapper div.\n let html = sibling.innerHTML;\n if (!html) return;\n let wrapper = document.createElement(\"div\");\n wrapper.innerHTML = html;\n sibling.parentNode?.insertBefore(wrapper, sibling);\n canvas.style.display = \"none\";\n } catch (_) {\n // Swallow: this is an emergency fallback. If we can't reveal it,\n // the user is no worse off than before this helper existed.\n }\n}\n\nexport function init(i : IInitialization) {\n let canvasid : string = i.canvasid != null ? i.canvasid : \"canvasid\";\n let canvas = document.getElementById(canvasid) as HTMLCanvasElement;\n try {\n initInner(i, canvas);\n } catch (err) {\n // Blank canvas + console error = silent failure from the\n // visitor's point of view. Reveal the conventional <noscript>\n // static-image fallback so they at least see the diagram, then\n // re-throw so callers / test harnesses can detect the failure.\n console.error(\"[geomlib] init failed:\", err);\n revealNoscriptFallback(canvas);\n throw err;\n }\n}\n\nfunction initInner(i: IInitialization, canvas: HTMLCanvasElement) {\n // Java defaults to CENTRAL (0) — dynamic placement based on\n // position relative to canvas center. Override with align param.\n let defaultAlign : align = i.align != null ? i.align : align.CENTRAL;\n\n // Capture the authored LOGICAL coordinate size (#71) before\n // resizeCanvasToDisplaySize overwrites the bitmap: explicit config →\n // CSS style px → width/height attribute → clientWidth. The first three\n // are the uncapped authored size (so a figure stays its logical size\n // even when CSS shrinks the display on a narrow column); clientWidth is\n // the last-resort legacy behaviour.\n const [logicalW, logicalH] = authoredLogicalSize(i, canvas);\n resizeCanvasToDisplaySize(canvas);\n let slate : Slate = new Slate(canvas);\n slate.setLogicalSize(logicalW, logicalH);\n slate.recomputeFitScale();\n slates.push(slate);\n\n // Set font — Java defaults: Font(\"TimesRoman\", Font.ITALIC, 18)\n let fontName = i.font != null ? i.font : \"Times New Roman\";\n let fontSize = i.fontsize != null ? i.fontsize : 18;\n GeomElement.setFont(fontName, fontSize);\n // Parse background through parseColor so HSB triples like \"35,19,100\"\n // are converted to valid CSS rgb() strings for ctx.fillStyle.\n slate.bgcolor = parseColor(i.background, \"#ffffff\", \"#ffffff\");\n // Cycles the angle-marker palette in construction order (#91) so\n // concurrent markers get distinct colors.\n let angleMarkerCount = 0;\n for(let raw of i.elements) {\n let param: IConstructionInfo = typeof raw === \"string\" ? parseParam(raw) : raw;\n let element = slate.createElement(param.construction, param.params, param.name);\n\n element.align = defaultAlign;\n\n // Angle markers default to a translucent palette fill + solid\n // colored edge instead of the dim2 lighten-bg face / black edge.\n // The rgba face is set directly (it wouldn't survive parseColor)\n // unless the author supplies an explicit faceColor param.\n if (element instanceof AngleMarkerElement) {\n const swatch = anglePalette[angleMarkerCount % anglePalette.length];\n angleMarkerCount++;\n element.nameColor = parseColor(param.nameColor, null, slate.bgcolor);\n element.vertexColor = parseColor(param.vertexColor, null, slate.bgcolor);\n element.edgeColor = parseColor(param.edgeColor, swatch.edge, slate.bgcolor);\n if (param.faceColor != null) {\n element.faceColor = parseColor(param.faceColor, swatch.edge, slate.bgcolor);\n } else {\n element.faceColor = swatch.face;\n }\n continue;\n }\n\n // Name string\n let defaultNameColor = element instanceof PointElement ? \"black\" : null;\n element.nameColor = parseColor(param.nameColor, defaultNameColor, slate.bgcolor);\n\n let defaultVertexColor = element.draggable ?\n ((element instanceof PlaneSlider) ?\n 'red' : 'orange')\n : 'black';\n element.vertexColor = parseColor(param.vertexColor, defaultVertexColor, slate.bgcolor);\n\n element.edgeColor = parseColor(param.edgeColor, \"black\", slate.bgcolor);\n\n let lighterColor = lighten(slate.bgcolor);\n let defaultFaceColor = element.dimension == 2 ? lighterColor : null;\n element.faceColor = parseColor(param.faceColor, defaultFaceColor, slate.bgcolor);\n }\n\n if (i.aliases != null) {\n slate.addAliases(i.aliases);\n }\n\n if (i.deferDraggables != null) {\n slate.deferDraggables(i.deferDraggables);\n }\n\n // Angle markers are hidden in the static figure by default (Euclid's\n // diagram draws no angle arcs); init({ showAngles: true }) reveals\n // them. Plus any explicit initiallyHidden names. clearVisibility\n // restores to this baseline. (#100)\n if (!i.showAngles) {\n for (let elem of slate.elements) {\n if (elem instanceof AngleMarkerElement && elem.name != null) {\n slate.setInitiallyHidden(elem.name);\n }\n }\n }\n if (i.initiallyHidden != null) {\n for (let name of i.initiallyHidden) slate.setInitiallyHidden(name);\n }\n\n // Same-vertex angle markers auto-nest: group by shared vertex and\n // step each one's radius into a concentric ring (smallest interior\n // angle innermost), with distinct palette colors within the group,\n // so they don't overlap. Author radiusPx overrides opt out of the\n // ring-stepping. Runs before update() places the arc endpoints. (#103)\n {\n const byVertex = new Map<PointElement, AngleMarkerElement[]>();\n for (let elem of slate.elements) {\n if (elem instanceof AngleMarkerElement) {\n let g = byVertex.get(elem.vertex);\n if (g == null) { g = []; byVertex.set(elem.vertex, g); }\n g.push(elem);\n }\n }\n byVertex.forEach((group: AngleMarkerElement[]) => {\n if (group.length <= 1) return;\n // Smallest angle innermost so a tight wedge nests inside a\n // wider one sharing the vertex.\n group.sort((a, b) => a.spanRadians() - b.spanRadians());\n let ring = 0;\n group.forEach((m, idx) => {\n // Distinct color per group member (de-clash by group\n // position). Author param-color overrides are left alone.\n const isDefault = anglePalette.some(p => p.face === m.faceColor);\n if (isDefault) {\n const sw = anglePalette[idx % anglePalette.length];\n m.edgeColor = sw.edge;\n m.faceColor = sw.face;\n }\n // Pinned-radius markers keep their explicit radius (ring\n // 0); only auto-radius markers step outward, consecutively.\n if (!m.hasRadiusOverride) { m.ringIndex = ring; ring++; }\n });\n });\n }\n\n if (i.slides != null && i.slides.length > 0) {\n slate.slides = i.slides;\n }\n\n if (i.resolveJustification != null) {\n slate.resolveJustification = i.resolveJustification;\n }\n\n if (i.animationConfig != null) {\n slate.animationConfig = i.animationConfig;\n }\n\n if(i.pivot != null) {\n slate.setPivot(i.pivot);\n }\n\n slate.update();\n slate.updateCoordinates(0);\n\n // Add UI controls (reset, maximize, present) if running in browser\n if (canvas && canvas.parentElement) {\n createControls(slate, canvas, i);\n }\n}\n\n","// Pure-data helpers for the slideshow presentation mode (issue #75).\n// Lives in its own module so SlideTest can exercise the state-machine\n// rules without any DOM, while SlateControls.ts owns the overlay.\n\nimport {Slate} from \"./Slate\";\nimport {ISlide} from \"./index\";\n\n// Compute the visible + highlighted name sets for slide `index` given:\n// - visible inherits from the previous slide if omitted;\n// \"hide all at start\" applies when no earlier slide ever declared\n// visible (initial state is the empty set).\n// - highlighted clears each slide (defaults to []).\n// - Every draggable element on the slate is auto-unioned into\n// visible — free construction points always stay interactive —\n// EXCEPT names in slate.deferredDraggables (#89): draggables the\n// proof introduces mid-walk follow visible sets like any other\n// element.\n// - Every highlighted name is auto-unioned into visible — you can't\n// highlight what isn't drawn.\nexport function computeSlideState(\n slate: Slate,\n slides: ISlide[],\n index: number,\n): { visible: Set<string>, highlighted: Set<string> } {\n // Walk back to find the most recent explicit `visible` array.\n let baseVisible: string[] = [];\n for (let i = index; i >= 0; i--) {\n if (slides[i].visible != null) {\n baseVisible = slides[i].visible;\n break;\n }\n }\n const visible = new Set<string>(baseVisible);\n\n const slide = slides[index];\n const highlighted = new Set<string>(slide.highlighted || []);\n\n for (const e of slate.elements) {\n if (e.draggable && e.name != null\n && !slate.deferredDraggables.has(e.name)) {\n visible.add(e.name);\n }\n }\n highlighted.forEach(name => visible.add(name));\n\n return { visible, highlighted };\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// startup\n// Load entry module and return exports\n// This entry module is referenced by other modules so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(8156);\n"],"names":["randomColor","c","HSVtoRGB","Math","random","r","g","b","brighter","col","rgb","parseRGB","FACTOR","threshold","ceil","min","floor","darker","m","match","parseInt","colors","hex","replace","test","n","parts","split","length","h","s","isNaN","v","i","f","p","q","t","round","val","dfault","bgcolor","str","String","anglePalette","edge","face","canvas","_aliases","Map","_slides","_resolveJustification","_animationConfig","_animator","_ephemerals","_viewOffsetX","_viewOffsetY","_viewScale","_logicalWidth","_logicalHeight","_lastHighlightedKey","_htmlCanvas","inTest","_itsNumSlate","_deferredDraggables","Set","_initiallyHidden","Slate","numSlate","this","_elements","TypeError","_canvas","screen_origin","FixedPoint","x","y","z","name","screen_x","screen_y","screen","PlaneElement","A","B","C","nameColor","isScreen","_screen","_pick","e","vertexColor","vertexHighlightColor","faceColor","faceHighlightColor","push","slate","cnv","addEventListener","style","touchAction","activePointerId","ev","pointerId","setPointerCapture","_","_getCanvasPosition","clientX","clientY","_onMouseDown","_onMouseDrag","endPointer","_onMouseUp","releasePointerCapture","getBoundingClientRect","F","left","top","movePick","_bgcolor","value","lookupElement","elem","canonical","get","addAlias","from","to","set","addAliases","aliases","deferDraggables","names","add","addEphemeral","addElement","indexOf","removeEphemeral","splice","clearEphemerals","_dpr","window","devicePixelRatio","width","height","setLogicalSize","w","clientWidth","clientHeight","recomputeFitScale","sx","displayWidth","logicalWidth","sy","displayHeight","logicalHeight","setViewOffset","clearViewOffset","visibleBounds","_bounds","figureBounds","visibleOnly","minX","Infinity","maxX","minY","maxY","startsWith","visible","PolygonElement","V","CircleElement","radius","Center","LineElement","PointElement","namesFor","forEach","target","_ensureAnimator","SlateAnimator","animateTo","targetVisible","targetHighlighted","slideAnimations","mode","run","setVisibleNames","has","setInitiallyHidden","clearVisibility","convertParams","params","keepLineElements","P","E","N","param","findConstruction","cm","sp","constructions","validateSignature","createElement","keepLines","some","constructionMethod","keepsLineElements","cName","getConstructionName","construct","gs","preexists","reset","update","drawElements","ctx","getContext","dpr","tx","ty","GeomElement","styleScale","setTransform","clearRect","fillStyle","fillRect","drawFace","drawEdge","drawVertex","drawName","_dispatchHighlightChange","shouldHighlight","emphasized","key","sort","join","dispatchEvent","CustomEvent","highlighted","map","bubbles","detail","updateCoordinates","defined","translateCoordinates","dx","dy","translate","closestVisiblePoint","elements","tolerance","screenDist2","a","sortedDistanceElements","filter","adcp","bdcp","bestDistPoint","sqrt","_getPick","d","currentPoint","setPivot","pointName","trim","piv","planeName","pivot","_AP","picki","ox","oy","loX","hiX","loY","hiY","abs","draggable","drag","AP","rotateCoordinates","pick","oldP","difference","newx","newy","S","T","olds","dot","oldt","den","news","newt","ac","as","rotate","HAS_RAF","requestAnimationFrame","NOW","performance","now","Date","groups","resolveCurrent","cascadeIndex","rafId","lastFrameMs","fadingOut","fadeStartMs","cancel","config","animationConfig","speedMul","speedMultiplier","reduced","reducedMotion","entry","animation","findAnimation","elementType","console","warn","constructor","drawProgress","resolvedSteps","build","args","step","durationMs","stepDefault","slideOverride","configOverride","durations","elapsedMs","started","finalised","steps","currentIndex","animatedTargets","willBeVisible","willBeHighlighted","setup","finalise","Promise","resolve","_kickoff","_scheduleFrame","_clearAnimatedEmphasis","cancelAnimationFrame","_startGroupIndex","_startStep","idx","stepIdx","_frame","setTimeout","nowMs","cascadeGap","cascadeGapMs","rawDt","dt","_tickCascade","_tickParallel","_allFinalised","fadeElapsed","fp","ea","emphasisAmount","_tickStep","finishedAtMs","total","tick","parentElement","SlateControls","init","isCoarsePointer","matchMedia","matches","BTN_SIZE","BTN_GAP","BTN_MARGIN","CONTROLS_STYLE_ID","trackWindowResize","callback","handler","removeEventListener","_maximized","_savedStyles","_stopTrackingResize","_presenting","_presentationIndex","_presentationOverlay","_presentationCaption","_presentationJusts","_presentationCounter","_presentationOnKey","_stickyRefSpan","_stickyRefElem","_slate","_config","_wrapper","createWrapper","createButtons","addKeyboardShortcuts","resizeAndRedraw","document","getElementById","id","textContent","head","documentElement","appendChild","ensureControlsStyle","wrapper","className","position","display","insertBefore","setAttribute","outline","buttons","draw","drawResetIcon","action","onReset","title","drawMaximizeIcon","onMaximize","slides","drawPresentIcon","onPresent","btn","right","padding","border","cursor","background","borderRadius","iconCanvas","stopPropagation","focus","_maxBtn","_maxIconCanvas","preventDefault","minimize","maximize","wrapperPosition","wrapperTop","wrapperLeft","wrapperWidth","wrapperHeight","wrapperZIndex","zIndex","wrapperBackground","canvasStyleWidth","canvasStyleHeight","canvasAttrWidth","canvasAttrHeight","updateMaximizeIcon","_applyCentring","cx","cy","viewScale","size","pad","strokeStyle","lineWidth","ax","ay","bx","by","beginPath","moveTo","lineTo","stroke","closePath","fill","drawMinimizeIcon","buildPresentationOverlay","bindPresentationKeys","showSlide","exitPresent","unbindPresentationKeys","clearStickyRef","removePresentationOverlay","animator","overlay","bottom","margin","maxWidth","color","borderTop","boxShadow","fontFamily","boxSizing","textAlign","caption","fontSize","lineHeight","marginBottom","justs","opacity","minHeight","nav","gap","alignItems","justifyContent","prevBtn","makePresentationButton","counter","minWidth","nextBtn","exitBtn","marginLeft","parentNode","removeChild","index","clamped","max","state","computeSlideState","slide","transition","animations","renderCaptionText","text","innerHTML","resolveJustification","justifications","sep","ref","url","href","rel","span","host","re","lastIndex","exec","createTextNode","slice","buildCaptionRef","label","fontWeight","fontStyle","borderBottom","wasThis","setStickyRef","classList","remove","arc","PI","endAngle","cos","sin","a1","a2","leftX","rightX","topY","bottomY","animationsByName","animationsByEnum","warnedUnknown","AllAnimations","Point","appear","POINT_APPEAR","intersect","POINT_INTERSECT","POINT_SLIDE","Line","straightEdgeConnect","LINE_STRAIGHT_EDGE_CONNECT","straightEdgeExtend","LINE_STRAIGHT_EDGE_EXTEND","compassTransfer","LINE_COMPASS_TRANSFER","Circle","compass","CIRCLE_COMPASS","compassExplicit","CIRCLE_COMPASS_EXPLICIT","CIRCLE_COMPASS_TRANSFER","Polygon","POLYGON_OUTLINE","outlineAndFill","POLYGON_OUTLINE_AND_FILL","superpose","POLYGON_SUPERPOSE","equilateralBuild","POLYGON_EQUILATERAL_BUILD","Sector","sweep","SECTOR_SWEEP","Group","cloneAside","GROUP_CLONE_ASIDE","instant","INSTANT","Animation","animationMethod","InstantAnimation","registerAnimation","ConstructionTypes","PointConstructions","LineConstructions","CircleConstructions","PolygonConstructions","SectorConstructions","PlaneConstructions","SphereConstructions","PolyhedraConstructions","Plane","Sphere","Polyhedra","sig","signature","points","integers","elementTypes","Construction","pointConstructions","lineConstructions","circleConstructions","sectorConstructions","polygonConstructions","planeConstructions","sphereConstructions","polyhedronConstructions","Align","_nameColor","_vertexColor","_edgeColor","_faceColor","_nameHighlightColor","_vertexHighlightColor","_edgeHighlightColor","_faceHighlightColor","_shouldHighlight","_visible","_emphasisAmount","_drawProgress","_pixelTolerance","setFont","fontName","_fontName","_fontSize","fontString","_getTextMetrics","txt","textMetrics","measureText","actualBoundingBoxAscent","actualBoundingBoxDescent","drawString","ix","iy","overrideAlign","font","_name","_align","LEFT","fillText","RIGHT","ABOVE","BELOW","cw","ch","tox","toy","_draggable","_dimension","defaultRate","defaultDurationMs","circle","explicitStart","startAngle","atan2","sweepMs","fullRestore","faceAlpha","drawStartAngle","progress","CircleCompassAnimation","circ","s0","s1","distance","plane","D","side","mx","my","len","hypot","equilateralApex","TC","u1x","u1y","M","TP","u2x","u2y","tri","prodM","prodN","circC","circT","circEp","circEc","transitory","circles","concat","edgeColor","keepNames","Array","isArray","keepCircles","isKept","traceMs","lineStep","ln","ms","sweepStep","step1","reveal","clearScaffold","CircleCompassTransferAnimation","CircleRadiusCenterConstruction","CircleRadius3PointConstruction","invert","InvertCircleElement","InvertCircleConstruction","intersection","SphereElement","SphereIntersectionElement","SphereIntersectionConstruction","ice","_drawStartAngle","_faceAlpha","dimension","distance2","_drawCircleArc","arcStart","arcEnd","r2","radius2","amp2","ellipse","rcos","rsin","majorx","majory","factor","minorx","minory","majorR","minorR","rotation","edgeHighlightColor","baseW","save","globalAlpha","restore","toCircumcenter","CircumcircleElement","_C","_D","d2","minus","times","plus","_S","_T","PerpendicularPlane","t2","snapshotElement","el","bare","src","ghost","pts","pt","warnedUnsupported","snapshotSources","sources","ghosts","snap","applyVary","vary","LineSlider","sz","_A","_B","boundsOf","sideFromSign","include","autoPlace","nm","resolveSources","_autoPlaceStep","_legacyStep","variants","prefer","targetOffX","targetOffY","baseOffX","baseOffY","placed","copies","drive","centreP","pow","splitP","edx","edy","W","H","snaps","variant","bbox","viewOffsetX","viewOffsetY","fb","figW","figH","figCx","figCy","slotFor","bb","bw","bh","ccx","ccy","inner","outer","DEFAULT","taken","assigned","slot","cloned","slideCopy","temp","GroupCloneAsideAnimation","ibe","costheta","sintheta","toCircle","Bichord","toLine","Chord","traceLine","rate","LineStraightEdgeConnectAnimation","LineStraightEdgeExtendAnimation","connect","LineConnectConstruction","angleBisector","ad","AngleDividerElement","AngleBisectorLineConstruction","angleDivider","AngleDividerLineConstruction","foot","fo","Foot","LineFootConstruction","PlaneFootElement","PlaneFootLineConstruction","chord","ChordConstruction","bichord","wrapPointAsLine","es","BichordConstruction","perpendicular","PointPerpendicular1Construction","LinePerpendicular1Construction","PointPerpendicular2Construction","LinePerpendicular2Construction","PointPerpendicular3Construction","LinePerpendicular3Construction","PointPerpendicular4Construction","LinePerpendicular4Construction","PointPerpendicular5Construction","LinePerpendicular5Construction","cutoff","lo","Layoff","LineCutoffConstruction","extend","LineExtendConstruction","parallel","LineParallelConstruction","similar","g2","sim","SimilarElement","SimilarLineConstruction","proportion","prop","ProportionElement","ProportionLineConstruction","meanProportional","mp","MeanProportionalElement","MeanProportionalLineConstruction","path","PolylineElement","PolylineConstruction","ile","endX","endY","ipe","_P","_E","_F","toPlane","Bs","Bt","Perpendicular","toCross","PlanePerpendicularLine","ps","edgeCount","fullEdges","frac","k","U","ParallelPlane","ippe","lxy","threePoints","Plane3PointsConstruction","PerpendicularPlaneConstruction","PlaneParallelConstruction","ambient","AmbientPlanePointConstruction","AmbientPlaneCircleConstruction","ip","st","_n","theta","angle","_x","_y","_z","toIntersection","_newP","_initx","_inity","_initz","uptoPlane","toSphere","CircleSlider","_M","Ex","Ey","Fx","Fy","BFx","BFy","DEx","DEy","numx","numy","rB2","length2","C2","HarmonicElement","Intersection","toInvertPoint","InvertPointElement","segment","_segment","S0","S1","T0","T1","U0","U1","_S0","_S1","_T0","_T1","_U0","_U1","Midpoint","toIntersectionPL","PlaneIntersection","Qval","xVal","yVal","zVal","PlaneSlider","PointAppearAnimation","slider","tz","apply","PointSlideAnimation","free","FreePointConstruction","midpoint","MidPointConstruction","IntersectionConstruction","PlaneIntersectionConstruction","first","FirstPointConstruction","last","LastPointConstruction","center","CircleCenterConstruction","SphereCenterConstruction","lineSlider","createSlider","LineSliderConstruction","circleSlider","CircleSliderConstruction","circumcircle","CircumcircleConstruction","circumcenter","CircumcenterConstruction","FootPointConstruction","PlaneFootPointConstruction","_createLayoff","LayoffConstruction","CutoffConstruction","ExtendConstruction","parallelogram","ParallelogramConstruction","SimilarPointConstruction","PointPerpendicularConstruction","ProportionPointConstruction","InvertPointConstruction","MeanProportionalPointConstruction","planeSlider","PlaneSliderConstruction","sphereSlider","SphereSliderElement","SphereSliderConstruction","AngleBisectorPointConstruction","AngleDividerPointConstruction","fixed","FixedPointConstruction","lineSegmentSlider","LineSliderSegmentConstruction","harmonic","HarmonicPointConstruction","vertex","VertexConstruction","product","cross","triple","u","BmA","CmA","BC","B2","area","Bx","Cx","By","Cy","Bz","Cz","Cs","Ct","d0","d1","AmA","DmA","Ax","Ay","Dx","Dy","toSimilar","Q","co","si","ss","tt","z1","x1","y1","baseR","V0","V1","_V0","_V1","_parentA","_parentB","_Q","dist2","ApplicationElement","vertices","sides","_vertices","_sides","_onCircle","_onLine","l","CurvedTriangleElement","_delta","a0","_traceBoundary","DEFAULT_POLYGON_EDGE_RATE_PX_PER_MS","perimeter","poly","PolygonOutlineAnimation","outlineMs","PolygonOutlineAndFillAnimation","ontoName","onto","ghostPts","setGhost","coords","translated","rotated","estDist","translateMs","estTheta","_sideAngleDelta","rotateMs","gp","PolygonSuperposeAnimation","circAB","circBA","firstSetup","fillMs","PolygonEquilateralBuildAnimation","PolyConstruction","square","RegularPolygonElement","SquarePolygonConstruction","triangle","TrianglePolygonConstruction","quadrilateral","QuadrilateralPolygonConstruction","pentagon","PentagonPolygonConstruction","hexagon","HexagonPolygonConstruction","equilateralTriangle","EquilateralTriangleConstruction","ParallelogramPolygonConstruction","regularPolygon","RegularPolygonConstruction","starPolygon","StarPolygonConstruction","SimilarPolygonConstruction","application","ApplicationPolygonConstruction","octagon","OctagonPolygonConstruction","PolyhedronElement","isCarrier","FacePolygonConstruction","curvedTriangle","every","CurvedTriangleConstruction","sum","totalProgress","fractionalEdge","px","py","firstPoint","rest","_cos","_sin","tetrahedron","base","PyramidElement","TetrahedronConstruction","parallelepiped","fourth","PrismElement","ParallelepipedConstruction","prism","PrismConstruction","pyramid","PyramidConstruction","ct","j","savedColor","Base","baseN","topVerts","Apex","DEFAULT_ANGLE_MARKER_RADIUS_PX","ANGLE_MARKER_MAX_ARM_FRACTION","ANGLE_MARKER_RING_STEP","arm1","arm2","radiusOverride","reflex","ringIndex","_Center","_arm1","_arm2","_radiusOverride","spanRadians","_arcAngle","minor","_anticlockwise","_flashFace","shorter","_place","arm","dz","SectorElement","AngleMarkerElement","ArcElement","sector","arcAngle","arcSpan","SectorSweepAnimation","O","SectorConstruction","ArcConstruction","angleMarker","AngleMarkerConstruction","AngleMarkerRadiusConstruction","angleMarkerReflex","undefined","AngleMarkerReflexConstruction","AngleMarkerReflexRadiusConstruction","isec","_angle","_updateThroughPoint","_traceWedge","SphereRadiusConstruction","SphereRadius3PointConstruction","CENTRAL","on","opts","ids","canvasids","hits","slates","canvasid","defaultAlign","align","parseFloat","attr","getAttribute","authoredLogicalSize","logicalW","logicalH","resizeCanvasToDisplaySize","fontsize","parseColor","angleMarkerCount","raw","parseParam","element","construction","swatch","defaultNameColor","defaultVertexColor","lighterColor","lighten","defaultFaceColor","showAngles","initiallyHidden","byVertex","group","ring","sw","hasRadiusOverride","createControls","initInner","err","error","revealNoscriptFallback","BUILD_MARKER","typeMap","fields","Error","type","data","typeKey","constructionEnum","result","Number","sibling","nextElementSibling","attempts","tagName","html","baseVisible","deferredDraggables","__webpack_module_cache__","__webpack_exports__","__webpack_require__","moduleId","cachedModule","exports","module","__webpack_modules__","call"],"sourceRoot":""}
1
+ {"version":3,"file":"bundle.js","mappings":"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","sources":["webpack://geomlib/./src/Colors.ts","webpack://geomlib/./src/Diagnostics.ts","webpack://geomlib/./src/Slate.ts","webpack://geomlib/./src/SlateAnimator.ts","webpack://geomlib/./src/SlateControls.ts","webpack://geomlib/./src/elements/Animations.ts","webpack://geomlib/./src/elements/Constructions.ts","webpack://geomlib/./src/elements/GeomElement.ts","webpack://geomlib/./src/elements/circle/CircleAnimations.ts","webpack://geomlib/./src/elements/circle/CircleConstructions.ts","webpack://geomlib/./src/elements/circle/CircleElement.ts","webpack://geomlib/./src/elements/circle/CircumcircleElement.ts","webpack://geomlib/./src/elements/circle/InvertCircleElement.ts","webpack://geomlib/./src/elements/circle/SphereIntersectionElement.ts","webpack://geomlib/./src/elements/group/GroupAnimations.ts","webpack://geomlib/./src/elements/line/Bichord.ts","webpack://geomlib/./src/elements/line/Chord.ts","webpack://geomlib/./src/elements/line/LineAnimations.ts","webpack://geomlib/./src/elements/line/LineConstructions.ts","webpack://geomlib/./src/elements/line/LineElement.ts","webpack://geomlib/./src/elements/line/Perpendicular.ts","webpack://geomlib/./src/elements/line/PlanePerpendicularLine.ts","webpack://geomlib/./src/elements/line/PolylineElement.ts","webpack://geomlib/./src/elements/plane/ParallelPlane.ts","webpack://geomlib/./src/elements/plane/PerpendicularPlane.ts","webpack://geomlib/./src/elements/plane/PlaneConstructions.ts","webpack://geomlib/./src/elements/plane/PlaneElement.ts","webpack://geomlib/./src/elements/point/AngleDividerElement.ts","webpack://geomlib/./src/elements/point/CircleSlider.ts","webpack://geomlib/./src/elements/point/FixedPoint.ts","webpack://geomlib/./src/elements/point/Foot.ts","webpack://geomlib/./src/elements/point/HarmonicElement.ts","webpack://geomlib/./src/elements/point/Intersection.ts","webpack://geomlib/./src/elements/point/InvertPointElement.ts","webpack://geomlib/./src/elements/point/Layoff.ts","webpack://geomlib/./src/elements/point/LineSlider.ts","webpack://geomlib/./src/elements/point/MeanProportionalElement.ts","webpack://geomlib/./src/elements/point/Midpoint.ts","webpack://geomlib/./src/elements/point/PlaneFootElement.ts","webpack://geomlib/./src/elements/point/PlaneIntersection.ts","webpack://geomlib/./src/elements/point/PlaneSlider.ts","webpack://geomlib/./src/elements/point/PointAnimations.ts","webpack://geomlib/./src/elements/point/PointConstructions.ts","webpack://geomlib/./src/elements/point/PointElement.ts","webpack://geomlib/./src/elements/point/ProportionElement.ts","webpack://geomlib/./src/elements/point/SimilarElement.ts","webpack://geomlib/./src/elements/point/SphereSliderElement.ts","webpack://geomlib/./src/elements/polygon/ApplicationElement.ts","webpack://geomlib/./src/elements/polygon/CurvedTriangleElement.ts","webpack://geomlib/./src/elements/polygon/PolygonAnimations.ts","webpack://geomlib/./src/elements/polygon/PolygonConstructions.ts","webpack://geomlib/./src/elements/polygon/PolygonElement.ts","webpack://geomlib/./src/elements/polygon/RegularPolygonElement.ts","webpack://geomlib/./src/elements/polyhedron/PolyhedronConstructions.ts","webpack://geomlib/./src/elements/polyhedron/PolyhedronElement.ts","webpack://geomlib/./src/elements/polyhedron/PrismElement.ts","webpack://geomlib/./src/elements/polyhedron/PyramidElement.ts","webpack://geomlib/./src/elements/sector/AngleMarkerElement.ts","webpack://geomlib/./src/elements/sector/ArcElement.ts","webpack://geomlib/./src/elements/sector/SectorAnimations.ts","webpack://geomlib/./src/elements/sector/SectorConstructions.ts","webpack://geomlib/./src/elements/sector/SectorElement.ts","webpack://geomlib/./src/elements/sphere/SphereConstructions.ts","webpack://geomlib/./src/elements/sphere/SphereElement.ts","webpack://geomlib/./src/index.ts","webpack://geomlib/./src/slideshow.ts","webpack://geomlib/webpack/bootstrap","webpack://geomlib/webpack/startup"],"sourcesContent":["/*----------------------------------------------------------------------+\n| Color parsing and manipulation. |\n| Matches the behavior of Java's Geometry.parseColor() exactly: |\n| 1. null / \"none\" / \"0\" / numeric 0 → null (transparent) |\n| 2. \"random\" → random pastel |\n| 3. \"background\" → bgcolor |\n| 4. \"brighter\" → brighter(bgcolor) |\n| 5. \"darker\" → darker(bgcolor) |\n| 6. Named color (CSS set, case-insensitive; 5 Java exceptions) |\n| 7. Hex integer \"rrggbb\" → rgb string |\n| 8. HSB comma triple \"h,s,b\" → rgb string |\n| 9. Fallback → null |\n+----------------------------------------------------------------------*/\n\n// The original 13 Java AWT named colors, with their exact (camelCase)\n// spellings. Kept as the back-compat fast path: existing fixtures/decks use\n// these exact names, so every current render resolves here, byte-identically.\n// Five of these DELIBERATELY differ from W3C/CSS and keep the Java values —\n// green, orange, pink, darkGray, lightGray (#125). cssColors below also pins\n// those five (under their lowercase keys) so case-insensitive lookups agree.\nexport const colors : {[colorName: string]: string} =\n{\n \"black\": \"rgb(0,0,0)\",\n \"blue\": \"rgb(0,0,255)\",\n \"cyan\": \"rgb(0,255,255)\",\n \"darkGray\": \"rgb(64,64,64)\",\n \"gray\": \"rgb(128,128,128)\",\n \"green\": \"rgb(0,255,0)\",\n \"lightGray\": \"rgb(192,192,192)\",\n \"magenta\": \"rgb(255,0,255)\",\n \"orange\": \"rgb(255,200,0)\",\n \"pink\": \"rgb(255,175,175)\",\n \"red\": \"rgb(255,0,0)\",\n \"white\": \"rgb(255,255,255)\",\n \"yellow\": \"rgb(255,255,0)\"\n};\n\n// The full W3C/CSS named-color set (CSS Color Module Level 4), lowercase keys,\n// looked up case-insensitively (#125). Static literal — NO runtime dependency.\n// FIVE entries deviate from the CSS value to preserve geomlib/Java AWT history\n// (marked GEOMLIB below); `grey`-spelling aliases are included. New names take\n// their standard CSS rgb. Authors can now write crimson/teal/gold/navy/etc.\n// instead of falling through to silent-null.\nexport const cssColors : {[colorName: string]: string} =\n{\n \"aliceblue\": \"rgb(240,248,255)\", \"antiquewhite\": \"rgb(250,235,215)\",\n \"aqua\": \"rgb(0,255,255)\", \"aquamarine\": \"rgb(127,255,212)\",\n \"azure\": \"rgb(240,255,255)\", \"beige\": \"rgb(245,245,220)\",\n \"bisque\": \"rgb(255,228,196)\", \"black\": \"rgb(0,0,0)\",\n \"blanchedalmond\": \"rgb(255,235,205)\", \"blue\": \"rgb(0,0,255)\",\n \"blueviolet\": \"rgb(138,43,226)\", \"brown\": \"rgb(165,42,42)\",\n \"burlywood\": \"rgb(222,184,135)\", \"cadetblue\": \"rgb(95,158,160)\",\n \"chartreuse\": \"rgb(127,255,0)\", \"chocolate\": \"rgb(210,105,30)\",\n \"coral\": \"rgb(255,127,80)\", \"cornflowerblue\": \"rgb(100,149,237)\",\n \"cornsilk\": \"rgb(255,248,220)\", \"crimson\": \"rgb(220,20,60)\",\n \"cyan\": \"rgb(0,255,255)\", \"darkblue\": \"rgb(0,0,139)\",\n \"darkcyan\": \"rgb(0,139,139)\", \"darkgoldenrod\": \"rgb(184,134,11)\",\n \"darkgray\": \"rgb(64,64,64)\", \"darkgrey\": \"rgb(64,64,64)\", // GEOMLIB (CSS: 169,169,169)\n \"darkgreen\": \"rgb(0,100,0)\", \"darkkhaki\": \"rgb(189,183,107)\",\n \"darkmagenta\": \"rgb(139,0,139)\", \"darkolivegreen\": \"rgb(85,107,47)\",\n \"darkorange\": \"rgb(255,140,0)\", \"darkorchid\": \"rgb(153,50,204)\",\n \"darkred\": \"rgb(139,0,0)\", \"darksalmon\": \"rgb(233,150,122)\",\n \"darkseagreen\": \"rgb(143,188,143)\", \"darkslateblue\": \"rgb(72,61,139)\",\n \"darkslategray\": \"rgb(47,79,79)\", \"darkslategrey\": \"rgb(47,79,79)\",\n \"darkturquoise\": \"rgb(0,206,209)\", \"darkviolet\": \"rgb(148,0,211)\",\n \"deeppink\": \"rgb(255,20,147)\", \"deepskyblue\": \"rgb(0,191,255)\",\n \"dimgray\": \"rgb(105,105,105)\", \"dimgrey\": \"rgb(105,105,105)\",\n \"dodgerblue\": \"rgb(30,144,255)\", \"firebrick\": \"rgb(178,34,34)\",\n \"floralwhite\": \"rgb(255,250,240)\", \"forestgreen\": \"rgb(34,139,34)\",\n \"fuchsia\": \"rgb(255,0,255)\", \"gainsboro\": \"rgb(220,220,220)\",\n \"ghostwhite\": \"rgb(248,248,255)\", \"gold\": \"rgb(255,215,0)\",\n \"goldenrod\": \"rgb(218,165,32)\", \"gray\": \"rgb(128,128,128)\",\n \"grey\": \"rgb(128,128,128)\", \"green\": \"rgb(0,255,0)\", // GEOMLIB (CSS: 0,128,0)\n \"greenyellow\": \"rgb(173,255,47)\", \"honeydew\": \"rgb(240,255,240)\",\n \"hotpink\": \"rgb(255,105,180)\", \"indianred\": \"rgb(205,92,92)\",\n \"indigo\": \"rgb(75,0,130)\", \"ivory\": \"rgb(255,255,240)\",\n \"khaki\": \"rgb(240,230,140)\", \"lavender\": \"rgb(230,230,250)\",\n \"lavenderblush\": \"rgb(255,240,245)\", \"lawngreen\": \"rgb(124,252,0)\",\n \"lemonchiffon\": \"rgb(255,250,205)\", \"lightblue\": \"rgb(173,216,230)\",\n \"lightcoral\": \"rgb(240,128,128)\", \"lightcyan\": \"rgb(224,255,255)\",\n \"lightgoldenrodyellow\": \"rgb(250,250,210)\",\n \"lightgray\": \"rgb(192,192,192)\", \"lightgrey\": \"rgb(192,192,192)\", // GEOMLIB (CSS: 211,211,211)\n \"lightgreen\": \"rgb(144,238,144)\", \"lightpink\": \"rgb(255,182,193)\",\n \"lightsalmon\": \"rgb(255,160,122)\", \"lightseagreen\": \"rgb(32,178,170)\",\n \"lightskyblue\": \"rgb(135,206,250)\", \"lightslategray\": \"rgb(119,136,153)\",\n \"lightslategrey\": \"rgb(119,136,153)\", \"lightsteelblue\": \"rgb(176,196,222)\",\n \"lightyellow\": \"rgb(255,255,224)\", \"lime\": \"rgb(0,255,0)\",\n \"limegreen\": \"rgb(50,205,50)\", \"linen\": \"rgb(250,240,230)\",\n \"magenta\": \"rgb(255,0,255)\", \"maroon\": \"rgb(128,0,0)\",\n \"mediumaquamarine\": \"rgb(102,205,170)\", \"mediumblue\": \"rgb(0,0,205)\",\n \"mediumorchid\": \"rgb(186,85,211)\", \"mediumpurple\": \"rgb(147,112,219)\",\n \"mediumseagreen\": \"rgb(60,179,113)\", \"mediumslateblue\": \"rgb(123,104,238)\",\n \"mediumspringgreen\": \"rgb(0,250,154)\", \"mediumturquoise\": \"rgb(72,209,204)\",\n \"mediumvioletred\": \"rgb(199,21,133)\", \"midnightblue\": \"rgb(25,25,112)\",\n \"mintcream\": \"rgb(245,255,250)\", \"mistyrose\": \"rgb(255,228,225)\",\n \"moccasin\": \"rgb(255,228,181)\", \"navajowhite\": \"rgb(255,222,173)\",\n \"navy\": \"rgb(0,0,128)\", \"oldlace\": \"rgb(253,245,230)\",\n \"olive\": \"rgb(128,128,0)\", \"olivedrab\": \"rgb(107,142,35)\",\n \"orange\": \"rgb(255,200,0)\", // GEOMLIB (CSS: 255,165,0)\n \"orangered\": \"rgb(255,69,0)\", \"orchid\": \"rgb(218,112,214)\",\n \"palegoldenrod\": \"rgb(238,232,170)\", \"palegreen\": \"rgb(152,251,152)\",\n \"paleturquoise\": \"rgb(175,238,238)\", \"palevioletred\": \"rgb(219,112,147)\",\n \"papayawhip\": \"rgb(255,239,213)\", \"peachpuff\": \"rgb(255,218,185)\",\n \"peru\": \"rgb(205,133,63)\", \"pink\": \"rgb(255,175,175)\", // GEOMLIB (CSS: 255,192,203)\n \"plum\": \"rgb(221,160,221)\", \"powderblue\": \"rgb(176,224,230)\",\n \"purple\": \"rgb(128,0,128)\", \"rebeccapurple\": \"rgb(102,51,153)\",\n \"red\": \"rgb(255,0,0)\", \"rosybrown\": \"rgb(188,143,143)\",\n \"royalblue\": \"rgb(65,105,225)\", \"saddlebrown\": \"rgb(139,69,19)\",\n \"salmon\": \"rgb(250,128,114)\", \"sandybrown\": \"rgb(244,164,96)\",\n \"seagreen\": \"rgb(46,139,87)\", \"seashell\": \"rgb(255,245,238)\",\n \"sienna\": \"rgb(160,82,45)\", \"silver\": \"rgb(192,192,192)\",\n \"skyblue\": \"rgb(135,206,235)\", \"slateblue\": \"rgb(106,90,205)\",\n \"slategray\": \"rgb(112,128,144)\", \"slategrey\": \"rgb(112,128,144)\",\n \"snow\": \"rgb(255,250,250)\", \"springgreen\": \"rgb(0,255,127)\",\n \"steelblue\": \"rgb(70,130,180)\", \"tan\": \"rgb(210,180,140)\",\n \"teal\": \"rgb(0,128,128)\", \"thistle\": \"rgb(216,191,216)\",\n \"tomato\": \"rgb(255,99,71)\", \"turquoise\": \"rgb(64,224,208)\",\n \"violet\": \"rgb(238,130,238)\", \"wheat\": \"rgb(245,222,179)\",\n \"white\": \"rgb(255,255,255)\", \"whitesmoke\": \"rgb(245,245,245)\",\n \"yellow\": \"rgb(255,255,0)\", \"yellowgreen\": \"rgb(154,205,50)\"\n};\n\n// Default color cycle for angle markers (#91). Each entry pairs a\n// solid edge color with a translucent face twin so concurrent markers\n// read as distinct, readable wedges. Hues are spread and deliberately\n// avoid gold (#FFD700, the highlight color) so an emphasized marker\n// still contrasts against its own fill. init() assigns these in\n// construction order; authors can override per element.\nexport const anglePalette : {edge: string, face: string}[] =\n[\n { edge: \"rgb(59,110,165)\", face: \"rgba(59,110,165,0.30)\" }, // blue\n { edge: \"rgb(63,142,79)\", face: \"rgba(63,142,79,0.30)\" }, // green\n { edge: \"rgb(122,79,163)\", face: \"rgba(122,79,163,0.30)\" }, // purple\n { edge: \"rgb(194,90,60)\", face: \"rgba(194,90,60,0.30)\" }, // orange-red\n { edge: \"rgb(46,139,139)\", face: \"rgba(46,139,139,0.30)\" }, // teal\n { edge: \"rgb(163,60,122)\", face: \"rgba(163,60,122,0.30)\" } // magenta\n];\n\nexport function parseColor(val: string | number, dfault: string, bgcolor: string) : string {\n // Handle numeric 0 (from IConstructionInfo where vertexColor: 0)\n if (val === 0) return null;\n // Handle null/undefined → use default\n if (val == null) return dfault;\n\n let str = String(val);\n // Transparent keywords\n if (str === \"none\" || str === \"0\" || str === \"\") return null;\n // Special keywords\n if (str === \"random\") return randomColor();\n if (str === \"background\") return bgcolor;\n if (str === \"brighter\") return brighter(bgcolor);\n if (str === \"darker\") return darker(bgcolor);\n // Named color lookup — exact (the 13 back-compat camelCase spellings)\n // first, then the full CSS set case-insensitively (#125).\n if (str in colors) return colors[str];\n let lower = str.toLowerCase();\n if (lower in cssColors) return cssColors[lower];\n // Hex color (e.g. \"ff0000\" or \"#ffe9cd\" → rgb(...))\n // Java does: new Color(Integer.parseInt(str, 16))\n // Also handle CSS #-prefixed hex which Java doesn't use but our\n // test pages do (e.g. background: '#ffe9cd')\n let hex = str.replace(/^#/, \"\");\n if (/^[0-9a-fA-F]+$/.test(hex)) {\n let n = parseInt(hex, 16);\n if (!isNaN(n)) {\n let r = (n >> 16) & 0xFF;\n let g = (n >> 8) & 0xFF;\n let b = n & 0xFF;\n return `rgb(${r},${g},${b})`;\n }\n }\n // HSB comma triple (e.g. \"35,19,100\" → h=35/360, s=19/100, b=100/100)\n let parts = str.split(\",\");\n if (parts.length === 3) {\n let h = parseInt(parts[0]) / 360.0;\n let s = parseInt(parts[1]) / 100.0;\n let b = parseInt(parts[2]) / 100.0;\n if (!isNaN(h) && !isNaN(s) && !isNaN(b)) {\n let c = HSVtoRGB(h, s, b);\n return `rgb(${c.r},${c.g},${c.b})`;\n }\n }\n // Fallback — unrecognized\n return null;\n}\n\nexport function randomColor() : string {\n let c = HSVtoRGB(Math.random(), Math.random(), 1.0);\n return `rgb(${c.r},${c.g},${c.b})`;\n}\n\n// Java Color.brighter() — factor 0.7\n// Each component: if 0 → 3; elif < 3 → 3; else min(component/0.7, 255)\nexport function brighter(col: string) : string {\n let rgb = parseRGB(col);\n if (rgb == null) return col;\n let FACTOR = 0.7;\n let threshold = Math.ceil(1.0 / (1.0 - FACTOR)); // = 4\n let r = rgb.r === 0 ? threshold : Math.min(Math.floor(rgb.r / FACTOR), 255);\n let g = rgb.g === 0 ? threshold : Math.min(Math.floor(rgb.g / FACTOR), 255);\n let b = rgb.b === 0 ? threshold : Math.min(Math.floor(rgb.b / FACTOR), 255);\n if (r < threshold) r = threshold;\n if (g < threshold) g = threshold;\n if (b < threshold) b = threshold;\n return `rgb(${r},${g},${b})`;\n}\n\n// Java Color.darker() — factor 0.7\n// Each component: floor(component * 0.7)\nexport function darker(col: string) : string {\n let rgb = parseRGB(col);\n if (rgb == null) return col;\n let FACTOR = 0.7;\n let r = Math.floor(rgb.r * FACTOR);\n let g = Math.floor(rgb.g * FACTOR);\n let b = Math.floor(rgb.b * FACTOR);\n return `rgb(${r},${g},${b})`;\n}\n\n// Keep old names as aliases for backward compatibility with index.ts\nexport function lighten(col: string) : string {\n return brighter(col);\n}\n\nexport function darken(col: string) : string {\n return darker(col);\n}\n\n// Parse an rgb(...) string or hex color into {r, g, b} components.\n// Handles: \"rgb(r,g,b)\", \"#rrggbb\", \"rrggbb\", named colors, HSB triples\nfunction parseRGB(col: string) : {r: number, g: number, b: number} | null {\n if (col == null) return null;\n // rgb(r,g,b) format\n let m = col.match(/^rgb\\((\\d+),(\\d+),(\\d+)\\)$/);\n if (m) return {r: parseInt(m[1]), g: parseInt(m[2]), b: parseInt(m[3])};\n // Named color → resolve to rgb then re-parse\n if (col in colors) return parseRGB(colors[col]);\n // #rrggbb or rrggbb hex\n let hex = col.replace(/^#/, \"\");\n if (/^[0-9a-fA-F]{6}$/.test(hex)) {\n let n = parseInt(hex, 16);\n return {r: (n >> 16) & 0xFF, g: (n >> 8) & 0xFF, b: n & 0xFF};\n }\n // HSB comma triple — parse it to get RGB\n let parts = col.split(\",\");\n if (parts.length === 3) {\n let h = parseInt(parts[0]) / 360.0;\n let s = parseInt(parts[1]) / 100.0;\n let b = parseInt(parts[2]) / 100.0;\n if (!isNaN(h) && !isNaN(s) && !isNaN(b)) {\n return HSVtoRGB(h, s, b);\n }\n }\n return null;\n}\n\n// see https://stackoverflow.com/questions/17242144/javascript-convert-hsb-hsv-color-to-rgb-accurately\nfunction HSVtoRGB(h: number, s: number, v: number) : {r: number, g: number, b: number} {\n let r: number, g: number, b: number;\n let i = Math.floor(h * 6);\n let f = h * 6 - i;\n let p = v * (1 - s);\n let q = v * (1 - f * s);\n let t = v * (1 - (1 - f) * s);\n switch (i % 6) {\n case 0: r = v; g = t; b = p; break;\n case 1: r = q; g = v; b = p; break;\n case 2: r = p; g = v; b = t; break;\n case 3: r = p; g = q; b = v; break;\n case 4: r = t; g = p; b = v; break;\n case 5: r = v; g = p; b = q; break;\n }\n return {\n r: Math.round(r * 255),\n g: Math.round(g * 255),\n b: Math.round(b * 255)\n };\n}\n","/*----------------------------------------------------------------------+\n| Title: Diagnostics.ts |\n| Per-slate diagnostic records (#154). |\n| |\n| geomlib fails quietly by design: an animation whose target does |\n| not resolve is skipped, a slide name that matches nothing is |\n| ignored. That keeps a bad deck rendering, but it also means the |\n| only evidence is a console line nobody has open. This module is |\n| the record of what went wrong, so a slate can show a badge and a |\n| consumer can read the list. |\n| |\n| Deliberately free of any DOM or Slate import: every decision the |\n| badge makes (which severity wins, whether to show anything at |\n| all) is made here, where it can be unit-tested without a browser. |\n+----------------------------------------------------------------------*/\n\nexport type DiagnosticSeverity = \"warning\" | \"error\";\n\n// Ordering for \"error supersedes warning\". One place, so the badge and\n// the page-wide aggregator can't disagree about which is worse.\nexport const SEVERITY_RANK: { [k: string]: number } = { warning: 1, error: 2 };\n\nexport interface IDiagnostic {\n severity: DiagnosticSeverity;\n // Stable machine-readable class (\"unknown-animation\", \"init-failed\").\n // The badge must not parse English, and a consumer filtering by kind\n // shouldn't have to regex prose.\n code: string;\n // Human text, WITHOUT the \"[geomlib] \" prefix — the console mirror\n // adds that, so the stored message stays clean for a UI to render.\n message: string;\n detail?: { [k: string]: any };\n // Time of FIRST occurrence. Useful for ordering; note it makes the\n // record nondeterministic, so drop it before serialising in a test.\n at: number;\n // How many times this dedupe key fired, including the first.\n count: number;\n}\n\nexport interface IDiagnosticInput {\n code: string;\n message: string;\n severity?: DiagnosticSeverity; // default \"warning\"\n detail?: { [k: string]: any };\n // Dedupe discriminator. Defaults to the message, but naming the\n // varying part explicitly (\"the element name\") keeps the key stable\n // when the wording of the message changes.\n key?: string;\n}\n\nexport function dedupeKeyOf(input: IDiagnosticInput): string {\n const sev = input.severity != null ? input.severity : \"warning\";\n const k = input.key != null ? input.key : input.message;\n return sev + \"|\" + input.code + \"|\" + k;\n}\n\n/** The worse of two severities; null means \"clean\". */\nexport function worstSeverity(\n a: DiagnosticSeverity | null,\n b: DiagnosticSeverity | null,\n): DiagnosticSeverity | null {\n if (a == null) return b;\n if (b == null) return a;\n return SEVERITY_RANK[a] >= SEVERITY_RANK[b] ? a : b;\n}\n\n/**\n * An append-only log of what a slate has complained about.\n *\n * Never evicts: a diagnostic reported on slide 4 is still there on slide\n * 5, so a warning cannot scroll past unnoticed. Cleared only explicitly.\n */\nexport class DiagnosticLog {\n\n private _entries: IDiagnostic[] = [];\n private _byKey: { [key: string]: IDiagnostic } = {};\n private _worst: DiagnosticSeverity | null = null;\n\n /**\n * Record a diagnostic. Returns the new record, or null when this key\n * has already been seen — so a caller can mirror to the console only\n * on first occurrence, which is what the old per-module dedupe flags\n * were doing, except now scoped to one slate instead of the page.\n */\n report(input: IDiagnosticInput, now: number): IDiagnostic | null {\n const key = dedupeKeyOf(input);\n const existing = this._byKey[key];\n if (existing != null) {\n existing.count++;\n return null;\n }\n const rec: IDiagnostic = {\n severity: input.severity != null ? input.severity : \"warning\",\n code: input.code,\n message: input.message,\n at: now,\n count: 1,\n };\n if (input.detail != null) rec.detail = input.detail;\n this._byKey[key] = rec;\n this._entries.push(rec);\n this._worst = worstSeverity(this._worst, rec.severity);\n return rec;\n }\n\n get entries(): IDiagnostic[] {\n return this._entries.slice();\n }\n\n /** Worst severity recorded, or null when the slate is clean. */\n get severity(): DiagnosticSeverity | null {\n return this._worst;\n }\n\n /** Distinct diagnostics (not total occurrences). */\n get count(): number {\n return this._entries.length;\n }\n\n clear(): void {\n this._entries = [];\n this._byKey = {};\n this._worst = null;\n }\n}\n\n/**\n * Payload for the `geomlib:diagnostic` CustomEvent. Extracted so the\n * event's shape is testable without a DOM — the dispatch site is then\n * just a capability guard plus a wrap.\n *\n * `diagnostic` is null when the log was cleared, so a listener can\n * un-render without special-casing.\n */\nexport function diagnosticEventDetail(\n log: DiagnosticLog,\n d: IDiagnostic | null,\n): { diagnostic: IDiagnostic | null; severity: DiagnosticSeverity | null; count: number } {\n return { diagnostic: d, severity: log.severity, count: log.count };\n}\n","import {GeomElement} from \"./elements/GeomElement\";\nimport {PlaneElement} from \"./elements/plane/PlaneElement\";\nimport {FixedPoint} from \"./elements/point/FixedPoint\";\nimport {AllConstructions, Construction, SortedParams, constructions, getConstructionName} from \"./elements/Constructions\";\nimport {PointElement} from \"./elements/point/PointElement\";\nimport {Canvas} from \"canvas\";\nimport {LineElement} from \"./elements/line/LineElement\";\nimport {PolygonElement} from \"./elements/polygon/PolygonElement\";\nimport {CircleElement} from \"./elements/circle/CircleElement\";\nimport {ISlide, ISlideAnimation, IAnimationConfig} from \"./index\";\nimport {SlateAnimator} from \"./SlateAnimator\";\nimport {DiagnosticLog, IDiagnostic, IDiagnosticInput, DiagnosticSeverity,\n diagnosticEventDetail} from \"./Diagnostics\";\n\nexport type SlateCanvas = HTMLCanvasElement | Canvas;\n\nexport type ResolveJustification = (ref: string) => string | null | undefined;\n\n// #140 — an element that is highlighted or mid-animation is what the viewer\n// is meant to be looking at, so it should not be painted over by whatever\n// happens to be declared after it in the deck's `elements` array.\n//\n// `emphasized` is `_emphasisAmount > 0`, so this stays true through the\n// post-animation fade taper — an element can't drop back down in z-order\n// while it is still visibly gold. `drawProgress < 1` is the independent\n// \"currently being drawn in\" flag: it defaults to 1 and every animation's\n// finalise()/cancel resets it to 1, so it covers an animation that drives\n// partial geometry without touching emphasis.\nexport function isPromoted(e: GeomElement): boolean {\n return e.shouldHighlight || e.emphasized || e.drawProgress < 1;\n}\n\n/**\n * Reorder one draw pass so promoted elements paint last (on top), while\n * both groups keep their existing relative order.\n *\n * The promotion is deliberately *within a pass*, not to the top of the whole\n * figure: `drawElements` runs face → edge → vertex → name, so a promoted\n * face still stays under every edge. Highlighting a filled polygon therefore\n * can't hide the lines drawn across it.\n *\n * When nothing is promoted this returns the input order, so the render is\n * bit-for-bit unchanged for every static figure and every snapshot golden.\n */\nexport function promotedDrawOrder(elements: GeomElement[]): GeomElement[] {\n let promoted: GeomElement[] | null = null;\n for (let e of elements) {\n if (isPromoted(e)) {\n if (promoted == null) promoted = [];\n promoted.push(e);\n }\n }\n // Nothing highlighted or animating — the overwhelmingly common case.\n // Hand back the original array untouched (no allocation, no reorder).\n if (promoted == null) return elements;\n const rest: GeomElement[] = [];\n for (let e of elements) if (!isPromoted(e)) rest.push(e);\n return rest.concat(promoted);\n}\n\nexport class Slate {\n\n protected _elements : GeomElement[];\n // Name aliases — secondary names that resolve to existing elements\n // without adding new ones to _elements. The original Geometry Applet\n // and Euclid's *Elements* refer to the same circle by every\n // permutation of its three named points (BCD ≡ CDB ≡ DBC ≡ …) and\n // to lines by either endpoint order (AB ≡ BA). Authors register\n // those equivalences here so the prose-side `{NAME}` shortcode can\n // light up the canonical element without needing a parallel\n // invisible duplicate per alias.\n private _aliases : Map<string, string> = new Map();\n // #140 — draw highlighted / mid-animation elements last within each\n // pass so they aren't painted over by later-declared neighbours.\n // On by default; set false to keep the strict declaration order.\n private _highlightOnTop : boolean = true;\n // Optional slideshow walk-through; populated from init().slides.\n // Empty array means no presentation mode is available; SlateControls\n // skips the \"▶ Present\" button.\n private _slides : ISlide[] = [];\n // Consumer-supplied callback resolving a justification ref label\n // (e.g. \"I.Post.3\") to a URL. Returns null/undefined when the ref\n // isn't recognised, in which case the Presentation overlay renders\n // the ref as plain text. Undefined means no resolver was passed.\n private _resolveJustification : ResolveJustification | null = null;\n // Slide-transition animation config (rates, durations, modifiers).\n // The slate ships a default; init() merges in whatever the\n // consumer provides via IInitialization.animationConfig.\n private _animationConfig : IAnimationConfig = {};\n // The frame-driver. Lazy-created on first animateTo() so a\n // headless test slate that never animates doesn't allocate a\n // requestAnimationFrame loop.\n private _animator : SlateAnimator | null = null;\n // Ephemeral helper elements an animation can spawn for its\n // lifetime (compass arms, guide circles, straightedge bars).\n // Drawn on top of _elements in the same face → edge → vertex →\n // name order; never appear in lookupElement; cleared on\n // animator.cancel() as a safety net.\n private _ephemerals : GeomElement[] = [];\n // View transform: model (logical) coords → display px is\n // F·model + T, where F = _viewScale (uniform) and T = (_viewOffsetX,\n // _viewOffsetY). drawElements then scales by dpr to the bitmap; the\n // pick path inverts it. T centres the figure when maximized (#99/#107);\n // F shrinks the figure to fit a narrow display (#71). Defaults\n // F=1, T=(0,0) are a no-op, so every existing render path — and the\n // headless snapshot path — is bit-for-bit unchanged.\n // #138 — the bounding box the maximized / presentation centring was\n // computed from. Captured ONCE on entering the maximized view (#114\n // centres once, not per slide) and cleared on leaving, so the centre\n // can't drift as slides reveal and hide elements, and so cloneAside's\n // centre phase (#99) eases to exactly the same target.\n private _centringBounds : { minX: number, maxX: number, minY: number, maxY: number } | null = null;\n private _viewOffsetX : number = 0;\n private _viewOffsetY : number = 0;\n private _viewScale : number = 1;\n // The construction's authored coordinate extent (logical px). Element\n // coords live here. Defaults to the canvas bitmap so the headless /\n // snapshot path has logical == display == bitmap (fit-scale 1). init()\n // overrides it with the authored size on a real DOM canvas (#71).\n private _logicalWidth : number = 0;\n private _logicalHeight : number = 0;\n // Last-dispatched highlighted-name key, so the geomlib:highlight event\n // (#108) fires only when the SET of highlighted elements changes — not\n // on every redraw frame / emphasisAmount fade.\n private _lastHighlightedKey : string = \"\\u0000\";\n // #154 — what this slate has complained about, so a badge can show it\n // and a consumer can read it. Per-slate on purpose: the dedupe flags\n // this replaced were module-global, so one figure's warning silenced\n // every other figure on the page.\n private _diagnostics : DiagnosticLog = new DiagnosticLog();\n private _diagnosticListeners : Array<(s: Slate) => void> = [];\n protected _screen : PlaneElement;\n protected _pick : PointElement;\n protected _canvas : SlateCanvas;\n private _htmlCanvas : HTMLCanvasElement = null;\n protected _bgcolor : string;\n public inTest : boolean = false;\n private static numSlate : number = 0;\n private _itsNumSlate : number = -1;\n\n constructor(canvas: SlateCanvas) {\n Slate.numSlate += 1;\n this._itsNumSlate = Slate.numSlate;\n\n this._elements = [];\n if(canvas == null) {\n throw new TypeError(\"canvas cannot be null or undefined.\");\n }\n this._canvas = canvas;\n\n let screen_origin = new FixedPoint({x:0,y:0,z:0});\n screen_origin.name = \"screen_origin\";\n let screen_x = new FixedPoint({x:1,y:0,z:0});\n screen_x.name = \"screen_x\";\n let screen_y = new FixedPoint({x:0,y:1,z:0});\n screen_y.name = \"screen_y\";\n\n let screen = new PlaneElement({\n A: screen_origin,\n B: screen_x,\n C: screen_y\n });\n screen.name = \"screen\";\n screen.nameColor = null;\n screen.isScreen = true;\n this._screen = screen;\n this._pick = null;\n\n for(let e of [screen_origin, screen_x, screen_y, screen]) {\n e.nameColor = null;\n e.vertexColor = null;\n e.vertexHighlightColor = null;\n e.faceColor = null;\n e.faceHighlightColor = null;\n this._elements.push(e);\n }\n let slate = this;\n\n let cnv : HTMLCanvasElement = this._canvas as HTMLCanvasElement;\n this._htmlCanvas = cnv;\n\n if(this._htmlCanvas.addEventListener == null) return;\n\n // Pointer Events unify mouse / touch / stylus into one event model.\n // Setting touch-action: none here (rather than relying on\n // consumer-side CSS) tells the browser not to claim drag gestures\n // for scroll/zoom; calling setPointerCapture on pointerdown ensures\n // we keep getting move/up events even when the finger leaves the\n // canvas bounds. See issue #55 for the design rationale.\n this._htmlCanvas.style.touchAction = \"none\";\n\n // Only the primary pointer drives the drag pipeline for now.\n // Multi-touch (two-finger rotation etc.) is intentionally not yet\n // wired — design questions tracked in issue #57.\n let activePointerId: number | null = null;\n\n this._htmlCanvas.addEventListener(\"pointerdown\", (ev: PointerEvent) => {\n if (activePointerId !== null) return; // already tracking a primary\n activePointerId = ev.pointerId;\n try { slate._htmlCanvas.setPointerCapture(ev.pointerId); } catch (_) { /* ignore */ }\n let [x, y] = slate._getCanvasPosition(ev.clientX, ev.clientY);\n slate._onMouseDown(x, y);\n });\n\n this._htmlCanvas.addEventListener(\"pointermove\", (ev: PointerEvent) => {\n if (ev.pointerId !== activePointerId) return;\n let [x, y] = slate._getCanvasPosition(ev.clientX, ev.clientY);\n slate._onMouseDrag(x, y);\n });\n\n let endPointer = (ev: PointerEvent) => {\n if (ev.pointerId !== activePointerId) return;\n let [x, y] = slate._getCanvasPosition(ev.clientX, ev.clientY);\n slate._onMouseUp(x, y);\n try { slate._htmlCanvas.releasePointerCapture(ev.pointerId); } catch (_) { /* ignore */ }\n activePointerId = null;\n };\n\n this._htmlCanvas.addEventListener(\"pointerup\", endPointer);\n this._htmlCanvas.addEventListener(\"pointercancel\", endPointer);\n this._htmlCanvas.addEventListener(\"lostpointercapture\", (ev: PointerEvent) => {\n if (ev.pointerId === activePointerId) {\n // Browser revoked capture (e.g., system gesture); clear pick state.\n if (slate._pick != null) {\n slate._pick = null;\n }\n activePointerId = null;\n }\n });\n\n }\n\n _getCanvasPosition(x: number, y: number) : [number, number] {\n let r = this._htmlCanvas.getBoundingClientRect();\n // Map display px → model (logical) coords: invert the view\n // transform F·model + T, so a click lands on the real element even\n // while the figure is fit-scaled (#71) or slid to centre (#99/#107).\n // getBoundingClientRect is display px; dpr never enters here.\n // F = 1, T = 0 → today's plain rect subtraction.\n const F = this._viewScale || 1;\n return [(x - r.left - this._viewOffsetX) / F,\n (y - r.top - this._viewOffsetY) / F];\n }\n\n _onMouseDown(x: number, y: number) {\n this._pick = null;\n this.movePick(x, y);\n };\n\n _onMouseUp(x: number, y: number) {\n if (this._pick == null) return;\n this.movePick(x, y);\n this._pick = null;\n };\n\n _onMouseDrag(x: number, y: number) {\n if (this._pick == null) return;\n this.movePick(x, y);\n };\n\n get elements() : GeomElement[] {\n return this._elements;\n }\n\n set highlightOnTop(value: boolean) {\n this._highlightOnTop = value;\n }\n\n get highlightOnTop() : boolean {\n return this._highlightOnTop;\n }\n\n set bgcolor(value: string ) {\n this._bgcolor = value;\n }\n\n get bgcolor() : string {\n return this._bgcolor;\n }\n\n // Public accessor for the underlying canvas. Consumer-side code on\n // multi-canvas pages (e.g. the {NAME} shortcode on euclids-elements.org)\n // needs to compare DOM positions of each slate's canvas against the\n // prose-side <span> to pick the right slate. Was protected before\n // 0.4.0; the few prior callers (s.canvas in elem-ref-highlight.js)\n // were just reading undefined and falling through to a brute-force\n // walk of geomlib.slates.\n get canvas() : SlateCanvas {\n return this._canvas;\n }\n\n lookupElement(name: string) : GeomElement {\n for (let elem of this._elements) {\n if (elem.name == name) {\n return elem;\n }\n }\n // Direct miss — follow the alias map and look up the canonical\n // name. One hop only: we don't chase chains because aliases are\n // expected to point at real element names, not at each other.\n let canonical = this._aliases.get(name);\n if (canonical != null) {\n for (let elem of this._elements) {\n if (elem.name == canonical) return elem;\n }\n }\n return null;\n }\n\n // Register a single secondary name → canonical name mapping. Idempotent.\n // Called by init() when the user passes an `aliases` field.\n addAlias(from: string, to: string) : void {\n this._aliases.set(from, to);\n }\n\n addAliases(aliases: {[from: string]: string}) : void {\n for (let from in aliases) this._aliases.set(from, aliases[from]);\n }\n\n // Draggable elements named here are excluded from the slideshow's\n // every-slide auto-union and follow slide visible sets like any\n // other element — for proof-introduced draggables (\"Take an\n // arbitrary point F\") that shouldn't show before their moment.\n // They stay fully draggable whenever visible (#89). Populated by\n // init() from the `deferDraggables` field.\n private _deferredDraggables : Set<string> = new Set();\n\n get deferredDraggables() : Set<string> {\n return this._deferredDraggables;\n }\n\n deferDraggables(names: string[]) : void {\n for (const n of names || []) this._deferredDraggables.add(n);\n }\n\n get slides() : ISlide[] {\n return this._slides;\n }\n\n set slides(value: ISlide[]) {\n this._slides = value || [];\n }\n\n get resolveJustification() : ResolveJustification | null {\n return this._resolveJustification;\n }\n\n set resolveJustification(value: ResolveJustification | null) {\n this._resolveJustification = value;\n }\n\n get animationConfig() : IAnimationConfig {\n return this._animationConfig;\n }\n\n set animationConfig(value: IAnimationConfig) {\n this._animationConfig = value || {};\n }\n\n get animator() : SlateAnimator | null {\n return this._animator;\n }\n\n get ephemerals() : GeomElement[] {\n return this._ephemerals;\n }\n\n addEphemeral(e: GeomElement) : void {\n this._ephemerals.push(e);\n }\n\n // Register a pre-built element as a persistent (non-ephemeral) member of\n // the figure — drawn in the normal pass, addressable by name, and governed\n // by the slideshow visible-set. Used by macro animations (e.g.\n // A.Circle.compassTransfer's keepCircles) to leave named scaffolding that a\n // later slide can re-show, where addEphemeral's wipe-on-advance won't do.\n addElement(e: GeomElement) : void {\n if (this._elements.indexOf(e) === -1) this._elements.push(e);\n }\n\n removeEphemeral(e: GeomElement) : void {\n const i = this._ephemerals.indexOf(e);\n if (i >= 0) this._ephemerals.splice(i, 1);\n }\n\n clearEphemerals() : void {\n this._ephemerals.length = 0;\n }\n\n get viewOffsetX() : number { return this._viewOffsetX; }\n get viewOffsetY() : number { return this._viewOffsetY; }\n get viewScale() : number { return this._viewScale; }\n\n // Device pixel ratio (#71). The canvas BITMAP is sized to display px ×\n // dpr so drawing lands on native device pixels (crisp on HiDPI/retina).\n // Headless / no window → 1, so node-canvas rendering (and the snapshot\n // goldens) is unchanged.\n private _dpr() : number {\n return (typeof window !== \"undefined\" && window.devicePixelRatio) || 1;\n }\n\n // The authored coordinate extent (logical px) — the space element\n // coords live in. Falls back to the bitmap when unset (headless /\n // snapshot path), so logical == bitmap there. (#71)\n get logicalWidth() : number { return this._logicalWidth || this._canvas.width; }\n get logicalHeight() : number { return this._logicalHeight || this._canvas.height; }\n setLogicalSize(w: number, h: number) : void {\n if (w > 0) this._logicalWidth = w;\n if (h > 0) this._logicalHeight = h;\n }\n\n // The canvas DISPLAY size in CSS px (responsive; clientWidth on a real\n // DOM canvas, the fixed bitmap headless). The figure is fit-scaled from\n // logical → display. (#71)\n get displayWidth() : number {\n const c = this._canvas as any;\n return (typeof c.clientWidth === \"number\" && c.clientWidth) || this._canvas.width;\n }\n get displayHeight() : number {\n const c = this._canvas as any;\n return (typeof c.clientHeight === \"number\" && c.clientHeight) || this._canvas.height;\n }\n\n // Recompute the fit-scale F = min(1, display / logical): shrink the\n // figure to fit a narrow display, never grow it. Called on init/resize.\n recomputeFitScale() : void {\n const sx = this.displayWidth / this.logicalWidth;\n const sy = this.displayHeight / this.logicalHeight;\n this._viewScale = Math.min(1, sx, sy);\n }\n\n // Set the view transform's translate T (display px). drawElements\n // applies F·model + T; the pick path inverts it. (#99/#107)\n setViewOffset(x: number, y: number) : void {\n this._viewOffsetX = x;\n this._viewOffsetY = y;\n }\n\n clearViewOffset() : void {\n this._viewOffsetX = 0;\n this._viewOffsetY = 0;\n }\n\n // Axis-aligned bounding box (canvas px) of the visible figure —\n // every named, visible, non-screen element. Returns null when the\n // figure is empty. Used by cloneAside auto-place for the centre\n // target and the fit check (#99). Points/lines/polygons/circles are\n // measured exactly; sector markers sit inside their vertex (already\n // counted) so they're not separately walked.\n visibleBounds() : { minX: number, maxX: number, minY: number, maxY: number } | null {\n return this._bounds(true);\n }\n\n // Like visibleBounds() but over EVERY named, non-screen element\n // regardless of its `visible` flag — a stable bound that doesn't drift\n // as a presentation reveals/hides elements slide-to-slide. Used to\n // centre the figure in a maximized / presentation view (#107).\n figureBounds() : { minX: number, maxX: number, minY: number, maxY: number } | null {\n return this._bounds(false);\n }\n\n // #138 — does this element put any ink on the canvas?\n //\n // Deck figures carry construction helpers that exist only to define a\n // direction or a slider's track — a \"point at infinity\" aim, the two\n // anchors a lineSlider runs between — authored with zero colours so they\n // draw nothing. They are still `visible`, so a visibility filter does NOT\n // exclude them; only asking what actually paints does.\n //\n // The test is per type because a colour slot an element never uses tells\n // us nothing: PointElement.drawEdge / drawFace are no-ops, so a point's\n // edgeColor (which defaults to black when the author omits the field)\n // must not count as ink — that default is exactly what made these helpers\n // look paintable.\n private _paintsInk(elem: GeomElement) : boolean {\n if (!elem.visible) return false;\n if (elem.nameColor != null) return true;\n if (elem instanceof PointElement) return elem.vertexColor != null;\n return elem.edgeColor != null || elem.faceColor != null;\n }\n\n // Bounding box to centre the figure on in the maximized / presentation\n // view (#107). Measures only elements that actually paint, so an\n // off-screen zero-colour helper can't inflate the box and translate the\n // real geometry off-canvas — the #138 blank-slideshow bug, hit on I.35,\n // I.42 and I.43.\n //\n // Captured once per maximized session rather than recomputed: the result\n // must not move as slides change visibility, and cloneAside reads the\n // same captured box so its centre phase lands where the base centring\n // already is. Falls back to the all-elements bounds if nothing paints at\n // all (a figure built entirely from helpers), so the caller always gets\n // the same shape of answer as before.\n captureCentringBounds() : { minX: number, maxX: number, minY: number, maxY: number } | null {\n const inked = this._bounds(false, (e) => this._paintsInk(e));\n this._centringBounds = inked != null ? inked : this._bounds(false);\n return this._centringBounds;\n }\n\n get centringBounds() : { minX: number, maxX: number, minY: number, maxY: number } | null {\n return this._centringBounds;\n }\n\n clearCentringBounds() : void {\n this._centringBounds = null;\n }\n\n private _bounds(visibleOnly: boolean,\n accept?: (e: GeomElement) => boolean) : { minX: number, maxX: number, minY: number, maxY: number } | null {\n let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;\n const add = (x: number, y: number) => {\n if (x < minX) minX = x; if (x > maxX) maxX = x;\n if (y < minY) minY = y; if (y > maxY) maxY = y;\n };\n for (let elem of this._elements) {\n if (elem.name == null || elem.name.startsWith(\"screen\")) continue;\n if (visibleOnly && !elem.visible) continue;\n if (accept != null && !accept(elem)) continue;\n if (elem instanceof PolygonElement) {\n for (let v of elem.V) add(v.x, v.y);\n } else if (elem instanceof CircleElement) {\n const r = elem.radius;\n add(elem.Center.x - r, elem.Center.y - r);\n add(elem.Center.x + r, elem.Center.y + r);\n } else if (elem instanceof LineElement) {\n add(elem.A.x, elem.A.y);\n add(elem.B.x, elem.B.y);\n } else if (elem instanceof PointElement) {\n add(elem.x, elem.y);\n }\n }\n if (minX === Infinity) return null;\n return { minX, maxX, minY, maxY };\n }\n\n // All names that resolve to the element named `canonical`: the\n // element's own name plus every alias whose target is it. Used to tag\n // the geomlib:highlight event so a consumer can match a prose ref by\n // any spelling (BCD ≡ CDB ≡ DBC). (#108)\n namesFor(canonical: string) : string[] {\n const names = [canonical];\n this._aliases.forEach((target, from) => {\n if (target === canonical && from !== canonical) names.push(from);\n });\n return names;\n }\n\n // Lazy-create the animator on first use. Each slate owns at most\n // one — cancel() preserves it for re-use across slide transitions.\n private _ensureAnimator() : SlateAnimator {\n if (this._animator == null) {\n this._animator = new SlateAnimator(this);\n }\n return this._animator;\n }\n\n // Public entry point for slideshow controllers. Diff the current\n // visibility / highlight state against the target, run any slide-\n // listed animations against the elements becoming visible. Newly-\n // visible elements without an explicit animation entry pop in\n // instantly (4b parity). Returns a Promise that resolves when the\n // animator completes the run or cancel() is called.\n animateTo(\n targetVisible: Set<string>,\n targetHighlighted: Set<string>,\n slideAnimations: ISlideAnimation[],\n mode: \"cascade\" | \"parallel\",\n ) : Promise<void> {\n return this._ensureAnimator().run(\n targetVisible, targetHighlighted, slideAnimations, mode,\n );\n }\n\n // Hide every named element whose name is not in the supplied set.\n // Names not matching any element are silently ignored; elements\n // without a name (intermediate construction outputs) are left alone.\n // Screen-helper elements (screen / screen_origin / screen_x /\n // screen_y) follow the same rule: their visible flag does flip, but\n // since they're created with all-null colours they never draw\n // visible pixels anyway. Called by the presentation overlay per\n // slide; consumers can call directly too.\n setVisibleNames(names: string[]) : void {\n const visible = new Set(names);\n for (let elem of this._elements) {\n if (elem.name == null) continue;\n elem.visible = visible.has(elem.name);\n }\n }\n\n // Names of elements that start hidden (angle markers by default, or\n // anything in init's `initiallyHidden`). clearVisibility restores to\n // this baseline rather than blanket-true, so hidden elements stay\n // hidden after a presentation walk. (#100)\n private _initiallyHidden : Set<string> = new Set();\n\n get initiallyHidden() : Set<string> {\n return this._initiallyHidden;\n }\n\n // Mark a named element hidden in the initial figure: flips its\n // visible flag off now and remembers it for clearVisibility.\n setInitiallyHidden(name: string) : void {\n if (name == null) return;\n this._initiallyHidden.add(name);\n const elem = this.lookupElement(name);\n if (elem != null) elem.visible = false;\n }\n\n // Restore every element's visible flag to its initial baseline —\n // true, except names registered as initially hidden. Counterpart to\n // setVisibleNames; called on presentation exit so the canvas\n // returns to its inline default.\n clearVisibility() : void {\n for (let elem of this._elements) {\n elem.visible = !(elem.name != null && this._initiallyHidden.has(elem.name));\n }\n }\n\n // Sort params into P[] (points), E[] (other elements), N[] (integers),\n // matching Java's selectDataChoice (Slate.java lines 344-393).\n // LineElements are expanded into their two endpoint PointElements, unless\n // the target construction opts out (keepLineElements — e.g. curvedTriangle/\n // curvedPolygon take a line intact as a straight-side carrier).\n convertParams(params: any[], keepLineElements: boolean = false) : SortedParams {\n let P: PointElement[] = [];\n let E: GeomElement[] = [];\n let N: number[] = [];\n for(let param of params) {\n switch(typeof(param)) {\n case \"string\":\n let g : GeomElement = this.lookupElement(param);\n if ( g == null )\n throw new TypeError(`Element with name ${param} not found.`);\n if (g instanceof PointElement) {\n P.push(g);\n } else if (g instanceof LineElement && !keepLineElements) {\n // LineElement expands to two PointElements (matching Java)\n P.push(g.A);\n P.push(g.B);\n } else {\n E.push(g);\n }\n break;\n case \"number\":\n N.push(param);\n break;\n default:\n throw new TypeError(\"Expecting only named elements (strings) or numbers.\");\n }\n }\n return {P, E, N};\n }\n\n findConstruction(cm : AllConstructions, sp: SortedParams) : Construction {\n for(let c of constructions) {\n if(c.validateSignature(cm, sp)) {\n return c;\n }\n }\n return null;\n }\n\n createElement(cm : AllConstructions, params: any[], name?: string) : GeomElement {\n // A construction for this method may want LineElement params kept\n // intact (not expanded to endpoints) — see Construction.keepsLineElements.\n let keepLines = constructions.some(c => c.constructionMethod === cm && c.keepsLineElements);\n let sp : SortedParams = this.convertParams(params, keepLines);\n let c : Construction = this.findConstruction(cm, sp);\n if(c == null) {\n let cName : String = getConstructionName(cm);\n if (name == null) {\n name = \"\";\n }\n throw new TypeError(`Construction not found for \"${name}\" ${cName} with params P=[${sp.P}] E=[${sp.E}] N=[${sp.N}]`);\n }\n let [gs, g] = c.construct(this._screen, sp.P, sp.E, sp.N);\n // Mark as preexisting if this element was already in _elements\n // before this construction (e.g., point;first returns an existing\n // PointElement). Preexisting elements are skipped during\n // rotate/translate to avoid double-movement.\n // (Java: Slate.java preexists[] array)\n if (this._elements.indexOf(g) !== -1) {\n g.preexists = true;\n }\n if(name != null)\n g.name = name;\n for (let elem of gs) {\n if (this._elements.indexOf(elem) == -1)\n this._elements.push(elem);\n }\n if(this._elements.indexOf(g) == -1)\n this._elements.push(g);\n return g;\n }\n\n reset() : void {\n for (let element of this._elements) {\n element.reset();\n }\n this.update();\n }\n\n update() : void {\n for(let element of this._elements) element.update();\n this.drawElements();\n }\n\n drawElements(): void {\n if(this.inTest) return;\n let ctx : CanvasRenderingContext2D = this._canvas.getContext(\"2d\") as CanvasRenderingContext2D;\n // View transform (#71/#99/#107): model (logical) coords map to\n // device px as dpr·(F·model + T), where F = _viewScale (fit) and\n // T = view offset (centre). Clear + background fill cover the whole\n // bitmap under identity; the figure + ephemerals then draw under the\n // model→device transform. Headless dpr=1, F=1, T=0 → identity, so\n // node-canvas rendering (and every snapshot golden) is unchanged.\n const dpr = this._dpr(), F = this._viewScale;\n const tx = this._viewOffsetX, ty = this._viewOffsetY;\n // Keep decorations (labels, dots, line widths) a constant on-screen\n // size while the geometry is fit-scaled by F (#71). 1/F ≥ 1; F=1 → 1.\n GeomElement.styleScale = F > 0 ? 1 / F : 1;\n ctx.setTransform(1, 0, 0, 1, 0, 0);\n ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);\n ctx.fillStyle = this._bgcolor;\n ctx.fillRect(0, 0, this._canvas.width, this._canvas.height);\n ctx.setTransform(dpr * F, 0, 0, dpr * F, dpr * tx, dpr * ty);\n // #140 — highlighted / mid-animation elements paint last within each\n // pass, so a later-declared neighbour can't chop the gold stroke\n // where it crosses. Identity when nothing is promoted.\n const order = this._highlightOnTop\n ? promotedDrawOrder(this._elements) : this._elements;\n for(let element of order) element.drawFace(this._canvas);\n for(let element of order) element.drawEdge(this._canvas);\n for(let element of order) element.drawVertex(this._canvas);\n // and then draw their names.\n for(let element of order)\n element.drawName(this._canvas);\n // Ephemeral animation helpers render on top of the permanent\n // figure (compass arms, guide circles, straightedge bars).\n // Same face → edge → vertex → name pass order so a guide arc\n // overlays correctly without re-clearing the canvas.\n for(let e of this._ephemerals) e.drawFace(this._canvas);\n for(let e of this._ephemerals) e.drawEdge(this._canvas);\n for(let e of this._ephemerals) e.drawVertex(this._canvas);\n for(let e of this._ephemerals) e.drawName(this._canvas);\n ctx.setTransform(1, 0, 0, 1, 0, 0); // reset so nothing leaks\n GeomElement.styleScale = 1;\n this._dispatchHighlightChange();\n }\n\n // #108 — bidirectional highlight binding. After each real draw, if the\n // SET of highlighted elements (shouldHighlight || emphasized — the\n // boolean intent, ignoring the fading emphasisAmount) has changed,\n // emit a `geomlib:highlight` CustomEvent on the canvas so a consuming\n // page can light up every textual reference to those elements. The\n // event carries each element's canonical name + all its aliases. Fires\n // on any highlight source (prose-ref hover, slide `highlighted`) since\n // it lives in the shared redraw path; idempotent (no re-emit on an\n // unchanged set → no feedback loop). No-op when the canvas can't\n // dispatch DOM events (node-canvas in tests).\n private _dispatchHighlightChange() : void {\n const names: string[] = [];\n for (let elem of this._elements) {\n if (elem.name == null || elem.name.startsWith(\"screen\")) continue;\n if (elem.shouldHighlight || elem.emphasized) names.push(elem.name);\n }\n const key = names.sort().join(\"|\");\n if (key === this._lastHighlightedKey) return;\n this._lastHighlightedKey = key;\n const canvas: any = this._canvas;\n if (!canvas || typeof canvas.dispatchEvent !== \"function\"\n || typeof CustomEvent !== \"function\") return;\n const highlighted = names.map(n => ({ name: n, aliases: this.namesFor(n) }));\n canvas.dispatchEvent(new CustomEvent(\"geomlib:highlight\", {\n bubbles: true,\n detail: { highlighted },\n }));\n }\n\n // ---- Diagnostics (#154) ------------------------------------------\n //\n // geomlib skips what it cannot resolve and keeps rendering, which is\n // the right behaviour — a deck with one bad name should still draw.\n // The cost is that the only evidence was a console line nobody has\n // open. Reporting through here records it too, so SlateControls can\n // badge the canvas and a consumer can read the list.\n\n /**\n * Record a diagnostic and mirror it to the console.\n *\n * Deduped per key, per slate: repeat reports bump a counter without\n * a second console line. That replaces two module-global dedupe\n * flags which silenced a warning for every OTHER figure on the page\n * once any one figure tripped them.\n */\n reportDiagnostic(input: IDiagnosticInput) : void {\n const rec = this._diagnostics.report(input, Date.now());\n if (rec == null) return; // already reported on this slate\n\n if (typeof console !== \"undefined\") {\n const fn = rec.severity === \"error\" ? console.error : console.warn;\n if (fn) fn(\"[geomlib] \" + rec.message);\n }\n this._dispatchDiagnostic(rec);\n this._notifyDiagnosticListeners();\n }\n\n /** Everything this slate has reported, oldest first. */\n get diagnostics() : IDiagnostic[] {\n return this._diagnostics.entries;\n }\n\n /** Worst severity reported, or null when the slate is clean. */\n get diagnosticSeverity() : DiagnosticSeverity | null {\n return this._diagnostics.severity;\n }\n\n /**\n * Forget everything reported so far.\n *\n * NOT called from reset(): minimize() and presentation-exit both run\n * reset() internally, and construction-time diagnostics never fire\n * again, so clearing there would silently discard exactly the\n * warnings worth keeping. SlateControls calls this from the explicit\n * reset control / `r` key instead — a deliberate viewer gesture.\n */\n clearDiagnostics() : void {\n this._diagnostics.clear();\n this._dispatchDiagnostic(null);\n this._notifyDiagnosticListeners();\n }\n\n /** Subscribe to diagnostic changes. Returns an unsubscribe fn. */\n onDiagnosticsChanged(listener: (s: Slate) => void) : () => void {\n this._diagnosticListeners.push(listener);\n return () => {\n const i = this._diagnosticListeners.indexOf(listener);\n if (i >= 0) this._diagnosticListeners.splice(i, 1);\n };\n }\n\n private _notifyDiagnosticListeners() : void {\n for (const l of this._diagnosticListeners.slice()) {\n try { l(this); } catch (_) { /* a listener must not break reporting */ }\n }\n }\n\n // Same capability guard as the geomlib:highlight dispatch above — a\n // node-canvas Canvas has no dispatchEvent, so the headless path\n // short-circuits here exactly as it does for highlights.\n private _dispatchDiagnostic(d: IDiagnostic | null) : void {\n const canvas: any = this._canvas;\n if (!canvas || typeof canvas.dispatchEvent !== \"function\"\n || typeof CustomEvent !== \"function\") return;\n canvas.dispatchEvent(new CustomEvent(\"geomlib:diagnostic\", {\n bubbles: true,\n detail: diagnosticEventDetail(this._diagnostics, d),\n }));\n }\n\n // Update coordinates starting with element[i+1], matching Java's\n // Slate.java updateCoordinates (lines 808-814). Only elements AFTER\n // the picked element are recomputed — elements before it are left\n // untouched to avoid reprojection artifacts after rotation.\n updateCoordinates(i : number) {\n for(++i; i < this._elements.length; i++) {\n if(!this._elements[i].defined())\n this._elements[i].reset();\n this._elements[i].update();\n }\n this.drawElements();\n }\n\n translateCoordinates(dx : number, dy: number) {\n // translate all non-preexisting elements\n // (Java: Slate.java line 819 — if (!preexists[i]) element[i].translate(...))\n for(let i = 0; i < this._elements.length; i++) {\n let elem = this._elements[i];\n if (!elem.preexists)\n elem.translate(dx, dy);\n }\n this.update();\n }\n\n closestVisiblePoint(elements : GeomElement[], p : PointElement, tolerance : number = 30) : PointElement {\n // Use 2D screen distance (x,y only, ignoring z) for picking,\n // matching the Java applet's movePick() at Slate.java:887-889.\n // The canvas is a 2D projection; a 3D point at (x,y,z) renders\n // at screen position (x,y) regardless of z.\n let screenDist2 = (a: PointElement, b: PointElement) =>\n (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);\n let sortedDistanceElements = elements\n .filter(e => e instanceof PointElement)\n .map(e => e as PointElement)\n .filter(e => e.vertexColor != null)\n .sort((a,b) => {\n let adcp = screenDist2(a, p);\n let bdcp = screenDist2(b, p);\n if(adcp < bdcp) {\n return -1;\n } else if (bdcp < adcp) {\n return 1;\n }\n return 0;\n });\n if (sortedDistanceElements.length == 0) return null;\n let bestDistPoint = sortedDistanceElements[0];\n if(Math.sqrt(screenDist2(bestDistPoint, p)) > tolerance) return null;\n return bestDistPoint;\n }\n\n private _getPick(c: number, d: number) : PointElement {\n if (this._pick != null) return this._pick;\n let currentPoint = new PointElement({x:c,y:d});\n let closestVisiblePoint = this.closestVisiblePoint(this._elements, currentPoint);\n if(closestVisiblePoint == null) return;\n this._pick = closestVisiblePoint;\n return this._pick;\n }\n\n // Set the pivot point for scene rotation.\n // Format: \"pointName\" or \"pointName,planeName\"\n // Without a plane, the pivot is set on the screen plane.\n // With a plane, the pivot is set on that plane (for 3D rotation).\n // (Java: Slate.java setPivot, lines 787-801)\n setPivot(param : string) : void {\n let parts = param.split(\",\");\n let pointName = parts[0].trim();\n let e : GeomElement = this.lookupElement(pointName);\n if (e == null || !(e instanceof PointElement)) return;\n let piv : PointElement = e as PointElement;\n\n if (parts.length > 1) {\n // \"A,xyplane\" — set pivot on a specific plane\n let planeName = parts[1].trim();\n let p : GeomElement = this.lookupElement(planeName);\n if (p == null || !(p instanceof PlaneElement)) return;\n (p as PlaneElement).pivot = piv;\n } else {\n // \"A\" — set pivot on screen plane\n piv._AP = this._screen;\n this._screen.pivot = piv;\n }\n }\n\n movePick(c: number, d: number) : void {\n if(this._getPick(c, d) == null) return;\n let picki = this._elements.indexOf(this._pick);\n\n // Clamp the drag to the on-screen region in MODEL coords. Under the\n // view transform F·model + T, the display spans model\n // [−T/F, (display − T)/F] — so the fit-scale (#71) and centre offset\n // (#99/#107) both shift/scale the bounds. F=1, T=0 → [0, display].\n const F = this._viewScale || 1;\n let ox = this._viewOffsetX, oy = this._viewOffsetY;\n let loX = -ox / F, hiX = (this.displayWidth - ox) / F;\n if (c < loX) c = loX; else if (c > hiX) c = hiX;\n let loY = -oy / F, hiY = (this.displayHeight - oy) / F;\n if (d < loY) d = loY; else if (d > hiY) d = hiY;\n if (Math.abs(c - this._pick.x) + Math.abs(d - this._pick.y) < 1.0) {\n return; // no motion\n }\n if ( this._pick.draggable ) {\n if(this._pick.drag(c,d)) {\n this.updateCoordinates(picki);\n } else {\n return;\n }\n } else if (this._pick.AP != null \n && this._pick.AP.pivot != null\n && this._pick.AP.pivot != this._pick) { // rotate around the pivot\n this.rotateCoordinates(c,d);\n } else {\n let dx = c - this._pick.x;\n let dy = d - this._pick.y;\n this.translateCoordinates(dx,dy);\n }\n this.drawElements();\n }\n\n rotateCoordinates(c : number, d : number) : void {\n // rotate space according to how pick goes around pivot in the plane\n let pick : PointElement = this._pick;\n let piv : PointElement = pick.AP.pivot;\n // compute old and new pick's 3D coordinates relative to the pivot\n let oldP : PointElement = PointElement.difference(pick,piv);\n let newx : number = c-piv.x;\n let newy : number = d-piv.y;\t\t//(newz is irrelevant)\n // find their 2D coordinates on the plane\n let S : PointElement = pick.AP.S;\n let T : PointElement = pick.AP.T;\n let olds : number = PointElement.dot(oldP,S);\n let oldt : number = PointElement.dot(oldP,T);\n let den : number = S.x * T.y - S.y * T.x;\n let news : number = (newx*T.y - newy*T.x)/den;\n let newt : number = (newy*S.x - newx*S.y)/den;\n // compute the scale&rotation factors\n den = olds*olds + oldt*oldt;\n let ac : number = (news*olds + newt*oldt)/den;\n let as : number = (newt*olds - news*oldt)/den;\n // Rotate all non-preexisting elements directly.\n // (Java: Slate.java line 843-845)\n for (let elem of this._elements) {\n if (!elem.preexists)\n elem.rotate(piv, ac, as);\n }\n // After direct rotation, recompute derived elements from their (now\n // rotated) parents. Java doesn't need this because element[] carries\n // duplicate entries for shared objects — a Layoff created by\n // line;extend and re-referenced by point;last appears at two indices,\n // one with preexists=false that gets rotated directly. TS dedupes\n // _elements, so a shared object marked preexists=true is skipped,\n // which means Layoff-style points backed by bare LineElement wrappers\n // would never get moved directly (bare LineElement.rotate is a no-op).\n // Running update() rebuilds them from their (rotated) parents, which\n // produces the same result because rotation is a linear operation\n // and Layoff.update() derives its position from parent coords.\n this.update();\n }\n\n}\n","// Slide-transition animator. Drives Animation.build() steps over\n// time via requestAnimationFrame, calling slate.drawElements() each\n// frame so the per-element drawProgress drives the partial geometry.\n// Cascade mode plays one step at a time in slide order; parallel\n// mode runs them all concurrently.\n//\n// Owned lazily by a Slate (created on first animateTo() call) and\n// reused across transitions; cancel() resolves the in-flight promise\n// and finalises every active step so a rapid Next/Prev sequence\n// preempts the previous animation cleanly.\n\nimport {Slate} from \"./Slate\";\nimport {findAnimation, IAnimationStep, Animation} from \"./elements/Animations\";\nimport {GeomElement} from \"./elements/GeomElement\";\nimport {ISlideAnimation} from \"./index\";\n\n// Wrapped step with mutable progress state. The animator manages\n// these; concrete Animations don't see them.\ninterface ActiveStep {\n step: IAnimationStep;\n elapsedMs: number;\n started: boolean;\n finalised: boolean;\n}\n\n// Wrapped per-target group of steps. Each ISlideAnimation entry maps\n// to one Group, and Animation.build() returns the inner step list.\n// Cascade mode runs groups in order; within a group, steps are always\n// sequential (an Animation that wants edge-then-fade returns 2 steps).\ninterface ActiveGroup {\n target: GeomElement;\n steps: ActiveStep[];\n currentIndex: number; // which step is in flight; advances as each finalises\n finishedAtMs?: number; // when the last step finalised (for cascadeGapMs pacing)\n}\n\n// Time source: performance.now() when available (monotonic, high-res,\n// unaffected by NTP adjustments and not subject to wall-clock skew).\n// Falls back to Date.now() in headless environments without\n// performance.now(). dt is computed from the diff between consecutive\n// frames and clamped (see MAX_DT_MS) so background-tab pauses or\n// long single-frame stalls don't cause the next frame to advance by\n// a multi-second jump — hardware with different refresh rates\n// (60 Hz / 120 Hz / 144 Hz) all see the same total wall-clock\n// duration because progress is dt-driven, not frame-count driven.\nconst HAS_RAF = (typeof requestAnimationFrame === \"function\");\nconst NOW: () => number = (typeof performance !== \"undefined\" && performance.now)\n ? () => performance.now()\n : () => Date.now();\n// Clamp per-frame dt. Prevents a backgrounded tab's accumulated\n// pause-time from collapsing an entire animation into one frame on\n// resume; also smooths very long single-frame stalls (e.g. GC pause).\n// 100 ms = 6 frames at 60 Hz worth of catch-up — enough for normal\n// jitter, small enough that a hidden tab resuming after 30 s doesn't\n// blink through 30 s of construction in one paint.\nconst MAX_DT_MS = 100;\n\n// Duration of the post-animation emphasis fade-out. Trims the visible\n// \"snap from 6 px to highlight thickness\" into a smooth taper so the\n// settle isn't jarring when the underlying element is also slide-\n// highlighted (the polygon ABC over the highlighted AB / AC / BC is\n// the canonical case).\nconst EMPHASIS_FADE_OUT_MS = 250;\n\nexport class SlateAnimator {\n private slate: Slate;\n // The currently-running set of groups. Empty when idle.\n private groups: ActiveGroup[] = [];\n private mode: \"cascade\" | \"parallel\" = \"cascade\";\n private resolveCurrent: (() => void) | null = null;\n // For cascade, this index points at the group currently playing.\n private cascadeIndex: number = 0;\n private rafId: number | null = null;\n private lastFrameMs: number = 0;\n // Emphasis fade-out phase tracking. After every group's last step\n // finalises, the animator enters this phase and ticks each target's\n // emphasisAmount from 1 → 0 over EMPHASIS_FADE_OUT_MS before\n // resolving the promise.\n private fadingOut: boolean = false;\n private fadeStartMs: number = 0;\n\n constructor(slate: Slate) {\n this.slate = slate;\n }\n\n // Public entry point. Cancels any in-flight run, computes the\n // diff between current state and the target, builds steps for\n // every slide-listed animation, kicks off the rAF loop, and\n // returns a promise that resolves when every step has finalised\n // (or cancel() is called).\n run(\n targetVisible: Set<string>,\n targetHighlighted: Set<string>,\n slideAnimations: ISlideAnimation[],\n mode: \"cascade\" | \"parallel\",\n ): Promise<void> {\n // Preempt any in-flight run so the new transition starts cleanly.\n if (this.groups.length > 0) this.cancel();\n\n // Build the new groups from the slide's animation list, in\n // array order. Newly-visible elements without an explicit\n // animation entry pop in instantly (4b parity) — handled by\n // the caller before invoking run().\n const groups: ActiveGroup[] = [];\n const config = this.slate.animationConfig || {};\n const speedMul = config.speedMultiplier != null ? config.speedMultiplier : 1;\n const reduced = config.reducedMotion === true || speedMul === 0;\n for (const entry of slideAnimations || []) {\n const target = this.slate.lookupElement(entry.elem);\n if (target == null) {\n // #151 — say so. A silent skip here is how a stale target\n // survives a figure refactor: the animation entry stays in\n // the deck, resolves to nothing, and simply never plays.\n this.slate.reportDiagnostic({\n code: \"unknown-element\",\n key: String(entry.elem),\n message: \"animation targets '\" + entry.elem +\n \"', but no element or alias resolves to it \\u2014 \" +\n \"the step is skipped. Check for a typo, or for a \" +\n \"target left behind by a figure change.\",\n detail: { elem: entry.elem },\n });\n continue;\n }\n const animation: Animation | null = findAnimation(entry.name);\n if (animation == null) {\n // #154 — reported here rather than inside findAnimation,\n // which has no slate to attribute it to.\n this.slate.reportDiagnostic({\n code: \"unknown-animation\",\n key: String(entry.name),\n message: \"unknown animation '\" + String(entry.name) +\n \"' \\u2014 falling back to instant\",\n detail: { name: String(entry.name), elem: entry.elem },\n });\n continue;\n }\n // Type guard: console.warn-and-skip when the animation's\n // elementType doesn't match the actual target class.\n if (!(target instanceof (animation.elementType as any))) {\n this.slate.reportDiagnostic({\n code: \"animation-type-mismatch\",\n key: String(animation.name) + \"|\" + String(entry.elem),\n message: \"animation '\" + animation.name +\n \"' targets \" + (animation.elementType as any).name +\n \" but element '\" + entry.elem + \"' is \" +\n (target.constructor as any).name +\n \" \\u2014 falling back to instant\",\n detail: { animation: String(animation.name), elem: entry.elem },\n });\n target.drawProgress = 1;\n target.visible = true;\n continue;\n }\n const builtSteps: IAnimationStep[] = animation.build(target, this.slate, entry.args || {}) || [];\n // Compute each step's resolved duration per the precedence\n // chain: entry.durationMs > config.durations[name] >\n // config.rates[name] > step.durationMs (already populated\n // by build() from the animation's defaults).\n const resolvedSteps: ActiveStep[] = builtSteps.map(step => ({\n step: {\n ...step,\n durationMs: resolveDuration(\n step.durationMs,\n entry.durationMs,\n config.durations && config.durations[animation.name],\n ),\n },\n elapsedMs: 0,\n started: false,\n finalised: false,\n }));\n groups.push({ target, steps: resolvedSteps, currentIndex: 0 });\n }\n\n // Visibility / highlight target state always applies — the\n // animation only governs HOW newly-visible elements appear.\n // Apply hidden / highlighted state synchronously; visible flips\n // are deferred for elements being animated because their setup\n // hook decides what to do with them.\n const animatedTargets = new Set<GeomElement>(groups.map(g => g.target));\n for (const e of this.slate.elements) {\n if (e.name == null) continue;\n const willBeVisible = targetVisible.has(e.name);\n const willBeHighlighted = targetHighlighted.has(e.name);\n if (animatedTargets.has(e)) {\n // Animation owns the visible flag during its run.\n // Deferred reveal (#83): the target stays hidden until\n // its own first step starts — drawProgress only gates\n // the edge, so a pre-revealed target would render its\n // face fill and name label at full strength while\n // earlier cascade steps play. _startStep flips it\n // visible; finalise() restores the final state on\n // every exit path.\n e.shouldHighlight = willBeHighlighted;\n e.drawProgress = 0;\n e.visible = false;\n } else {\n // Instant flip — matches 4b behaviour.\n e.visible = willBeVisible;\n e.shouldHighlight = willBeHighlighted;\n e.drawProgress = 1;\n }\n }\n\n // Reduced motion / speedMultiplier 0 / no groups: fast path.\n // Finalise everything synchronously and return a resolved\n // promise so the controller can flip the caption immediately.\n if (reduced || groups.length === 0) {\n for (const g of groups) {\n for (const as of g.steps) {\n if (as.step.setup && !as.started) as.step.setup();\n as.step.finalise();\n as.finalised = true;\n }\n }\n // Don't blanket-clear ephemerals here: normal (animated)\n // completion never does, and transient helpers self-remove in\n // their own finalise() (e.g. superpose). Clearing would wipe an\n // animation's *persisted* ephemerals (a cloneAside case-variant\n // copy) for reduced-motion users only — #99.\n this.slate.drawElements();\n return Promise.resolve();\n }\n\n // NOTE: targets are emphasised in _startStep when their own step\n // begins (not here at run start), so an un-started cascade target\n // stays hidden until its turn — otherwise, since #100, a\n // hidden-but-emphasised target would draw fully from t=0 (#104).\n // The emphasis still makes the target's render pop over any\n // slide-highlighted siblings throughout its own animation.\n\n this.groups = groups;\n this.mode = mode;\n this.cascadeIndex = 0;\n this.lastFrameMs = NOW();\n return new Promise<void>(resolve => {\n this.resolveCurrent = resolve;\n this._kickoff();\n this._scheduleFrame();\n });\n }\n\n // Drop the during-animation emphasis bumps from every group target.\n // Called once on completion or cancel so the slide settles back\n // into its plain highlight / not-highlighted steady state.\n private _clearAnimatedEmphasis(): void {\n for (const g of this.groups) {\n g.target.emphasized = false;\n }\n }\n\n // Cancel any in-flight run: finalise every step that started, wipe\n // ephemerals as a safety net, resolve the pending promise.\n cancel(): void {\n if (this.groups.length === 0) return;\n for (const g of this.groups) {\n for (let i = 0; i < g.steps.length; i++) {\n const as = g.steps[i];\n if (as.finalised) continue;\n // Run setup if we never got to it, so finalise sees a\n // consistent post-setup state.\n if (as.step.setup && !as.started) {\n as.step.setup();\n as.started = true;\n }\n as.step.finalise();\n as.finalised = true;\n }\n }\n this._clearAnimatedEmphasis();\n this.slate.clearEphemerals();\n this.slate.drawElements();\n this.groups = [];\n this.fadingOut = false;\n if (this.rafId != null && typeof cancelAnimationFrame === \"function\") {\n cancelAnimationFrame(this.rafId);\n }\n this.rafId = null;\n if (this.resolveCurrent) {\n this.resolveCurrent();\n this.resolveCurrent = null;\n }\n }\n\n // Fire any pending setup() hooks for the steps that are about to\n // tick on the very first frame.\n private _kickoff(): void {\n if (this.mode === \"cascade\") {\n this._startGroupIndex(0);\n } else {\n // Parallel: start the first step of every group at once.\n for (const g of this.groups) {\n this._startStep(g, 0);\n }\n }\n }\n\n private _startGroupIndex(idx: number): void {\n if (idx >= this.groups.length) return;\n this._startStep(this.groups[idx], 0);\n }\n\n private _startStep(g: ActiveGroup, stepIdx: number): void {\n if (stepIdx >= g.steps.length) return;\n const as = g.steps[stepIdx];\n if (as.started) return;\n // Deferred reveal (#83): the target was held invisible through\n // any earlier cascade steps; it appears the moment its own\n // first step begins. The emphasis bump is applied here too (not\n // at run start) so an un-started cascade target stays hidden —\n // since #100 a hidden-but-emphasised element would otherwise\n // draw fully from t=0 (#104). setup() runs after this, so an\n // animation that hides the target to render ephemeral proxies\n // instead can still do so.\n if (stepIdx === 0) {\n g.target.visible = true;\n g.target.emphasized = true;\n }\n if (as.step.setup) as.step.setup();\n as.started = true;\n g.currentIndex = stepIdx;\n }\n\n private _scheduleFrame(): void {\n if (HAS_RAF) {\n this.rafId = requestAnimationFrame(now => this._frame(now));\n } else {\n // No rAF (tests, node): synthesize a frame ~16ms in the\n // future via setTimeout. Mocha tests stub this differently.\n const t = NOW() + 16;\n this.rafId = (setTimeout(() => this._frame(t), 16) as any);\n }\n }\n\n private _frame(nowMs: number): void {\n if (this.groups.length === 0) return;\n const config = this.slate.animationConfig || {};\n const speedMul = config.speedMultiplier != null ? config.speedMultiplier : 1;\n const cascadeGap = config.cascadeGapMs || 0;\n // Real elapsed wall-clock dt, clamped to MAX_DT_MS so a\n // backgrounded tab or long GC pause doesn't fast-forward\n // through the rest of the animation in a single frame.\n let rawDt = nowMs - this.lastFrameMs;\n if (rawDt < 0) rawDt = 0;\n if (rawDt > MAX_DT_MS) rawDt = MAX_DT_MS;\n const dt = rawDt * speedMul;\n this.lastFrameMs = nowMs;\n\n // Advance the active step(s).\n if (this.mode === \"cascade\") {\n this._tickCascade(dt, nowMs, cascadeGap);\n } else {\n this._tickParallel(dt, nowMs);\n }\n\n // Always redraw so partial geometry shows up. Ephemerals\n // drawn alongside permanent elements.\n this.slate.drawElements();\n\n // Once every step's tick has finalised, enter the fade-out\n // phase: tick each target's emphasisAmount from 1 → 0 over\n // EMPHASIS_FADE_OUT_MS, redrawing each frame. Only resolves\n // once the fade completes.\n if (this._allFinalised()) {\n if (!this.fadingOut) {\n this.fadingOut = true;\n this.fadeStartMs = nowMs;\n }\n const fadeElapsed = nowMs - this.fadeStartMs;\n const fp = fadeElapsed >= EMPHASIS_FADE_OUT_MS\n ? 1 : fadeElapsed / EMPHASIS_FADE_OUT_MS;\n const ea = 1 - fp;\n for (const g of this.groups) {\n g.target.emphasisAmount = ea;\n }\n this.slate.drawElements();\n if (fp >= 1) {\n this._clearAnimatedEmphasis();\n this.groups = [];\n this.fadingOut = false;\n this.rafId = null;\n if (this.resolveCurrent) {\n this.resolveCurrent();\n this.resolveCurrent = null;\n }\n return;\n }\n this._scheduleFrame();\n return;\n }\n this._scheduleFrame();\n }\n\n private _tickCascade(dt: number, nowMs: number, cascadeGap: number): void {\n // Advance the current cascade group's current step. When it\n // finalises, optionally wait cascadeGapMs before advancing\n // either to the next step in the same group or to the next\n // group's first step.\n while (this.cascadeIndex < this.groups.length) {\n const g = this.groups[this.cascadeIndex];\n const as = g.steps[g.currentIndex];\n if (!as) {\n this.cascadeIndex += 1;\n if (this.cascadeIndex < this.groups.length) {\n this._startStep(this.groups[this.cascadeIndex], 0);\n }\n continue;\n }\n // Honour cascadeGap between groups.\n if (as.finalised) {\n if (g.finishedAtMs == null) g.finishedAtMs = nowMs;\n if (nowMs - g.finishedAtMs < cascadeGap) return;\n // Advance.\n if (g.currentIndex + 1 < g.steps.length) {\n this._startStep(g, g.currentIndex + 1);\n } else {\n this.cascadeIndex += 1;\n if (this.cascadeIndex < this.groups.length) {\n this._startStep(this.groups[this.cascadeIndex], 0);\n }\n }\n continue;\n }\n // Tick this step.\n this._tickStep(g.target, as, dt, nowMs);\n return; // one step per frame in cascade mode\n }\n }\n\n private _tickParallel(dt: number, nowMs: number): void {\n for (const g of this.groups) {\n const as = g.steps[g.currentIndex];\n if (!as) continue;\n if (as.finalised) {\n if (g.currentIndex + 1 < g.steps.length) {\n this._startStep(g, g.currentIndex + 1);\n }\n continue;\n }\n this._tickStep(g.target, as, dt, nowMs);\n }\n }\n\n private _tickStep(target: GeomElement, as: ActiveStep, dt: number, nowMs: number): void {\n if (!as.started) {\n if (as.step.setup) as.step.setup();\n as.started = true;\n }\n as.elapsedMs += dt;\n const total = as.step.durationMs;\n let p = total > 0 ? as.elapsedMs / total : 1;\n if (p > 1) p = 1;\n if (p < 0) p = 0;\n as.step.tick(p, dt, as.elapsedMs);\n if (p >= 1) {\n as.step.finalise();\n as.finalised = true;\n }\n }\n\n private _allFinalised(): boolean {\n for (const g of this.groups) {\n for (const as of g.steps) {\n if (!as.finalised) return false;\n }\n }\n return true;\n }\n}\n\n// Resolution order, top-down, returning the first defined non-undefined.\nfunction resolveDuration(stepDefault: number, slideOverride?: number, configOverride?: number): number {\n if (slideOverride != null) return slideOverride;\n if (configOverride != null) return configOverride;\n return stepDefault;\n}\n","/*----------------------------------------------------------------------+\n| Title: SlateControls.ts |\n| UI overlay for geometry diagrams: reset, maximize, present. |\n| Buttons are canvas-drawn icons overlaid on each Slate canvas. |\n| Keyboard shortcuts: |\n| r / space → reset |\n| m → maximize/minimize |\n| p → present (when the slate has slides) |\n| Escape → leave presentation, then leave the maximized view |\n| (one layer per press; see escapeAction) |\n+----------------------------------------------------------------------*/\n\nimport {Slate} from \"./Slate\";\nimport {computeSlideState} from \"./slideshow\";\nimport {ISlideJust} from \"./index\";\nimport {DiagnosticSeverity} from \"./Diagnostics\";\n\ninterface IInitConfig {\n background: string;\n title: string;\n align?: number;\n canvasid?: string;\n pivot?: string;\n elements: any[];\n}\n\n// Slate-controls icon sizing. The historical default is 20 px; touch\n// devices (coarse pointer) get a slightly tighter 15-px row per author\n// preference — small enough to stay out of the diagram, still hittable\n// with a fingertip.\nfunction isCoarsePointer(): boolean {\n return typeof window !== \"undefined\"\n && typeof window.matchMedia === \"function\"\n && window.matchMedia(\"(pointer: coarse)\").matches;\n}\nconst BTN_SIZE = isCoarsePointer() ? 18 : 20;\nconst BTN_GAP = isCoarsePointer() ? 4 : 4;\nconst BTN_MARGIN = isCoarsePointer() ? 7 : 8;\n\n// #69 — keep the control buttons hidden until the canvas/wrapper is\n// hovered or focused, so a page full of diagrams isn't cluttered with a\n// button row on every one. CSS-only (`:hover` / `:focus-within`), no\n// per-frame JS; `opacity` keeps the buttons in the layout (no reflow) and\n// fades them. Injected once per document. Touch users tap the canvas\n// first, which focuses it and reveals the controls.\nconst CONTROLS_STYLE_ID = \"geomlib-controls-style\";\nfunction ensureControlsStyle(): void {\n if (typeof document === \"undefined\") return;\n if (document.getElementById(CONTROLS_STYLE_ID)) return;\n const style = document.createElement(\"style\");\n style.id = CONTROLS_STYLE_ID;\n style.textContent =\n \".geomlib-wrapper>button{opacity:0;transition:opacity .15s ease-in-out}\" +\n \".geomlib-wrapper:hover>button,.geomlib-wrapper:focus-within>button{opacity:1}\";\n (document.head || document.documentElement).appendChild(style);\n}\n\n// Minimal event-target interface so this helper is testable without a real\n// `Window`. Browser `Window`, `Document`, and `Element` all satisfy it.\nexport interface IResizeTarget {\n addEventListener(type: \"resize\", listener: () => void): void;\n removeEventListener(type: \"resize\", listener: () => void): void;\n}\n\n/**\n * Attach `callback` to the target's \"resize\" event. Returns a teardown\n * function that removes the listener — call it to stop tracking.\n */\nexport function trackWindowResize(target: IResizeTarget, callback: () => void): () => void {\n const handler = () => callback();\n target.addEventListener(\"resize\", handler);\n return () => target.removeEventListener(\"resize\", handler);\n}\n\n// #139 — what one Escape press should do. Escape peels off ONE layer of\n// takeover at a time: a slideshow exits to the maximized view it opened in\n// (#115 — the viewer keeps their manipulation), and a second press leaves\n// the maximized view. Pure so it is testable without a DOM.\nexport type EscapeAction = \"exitPresent\" | \"minimize\" | \"none\";\n\nexport function escapeAction(state: {presenting: boolean; maximized: boolean}): EscapeAction {\n if (state.presenting) return \"exitPresent\";\n if (state.maximized) return \"minimize\";\n return \"none\";\n}\n\n// One piece of a rendered caption: literal text, or a reference that binds\n// `display` to the slate element named `target`.\nexport type CaptionToken =\n | { kind: \"text\"; text: string }\n | { kind: \"ref\"; display: string; target: string };\n\n// Caption token grammar.\n//\n// {AB} — display and element name are the same\n// {ABC|angBint} — display override (#90): render \"ABC\" but\n// bind to angBint, for prose names that\n// collide with another element's name\n// {the side from D to A|sideDA}\n// — #136: the DISPLAY half may be a phrase.\n//\n// The two halves have deliberately different grammars. The element name\n// stays strict (identifier-ish), because it has to resolve against the\n// slate. The display half is anything up to the closing brace — it is\n// prose, and restricting it to a single word forced authors to bind one\n// keyword inside a phrase (`the {side|sideDA} from D to A`) when what they\n// meant was to light the whole phrase.\nconst CAPTION_NAME = \"[A-Za-z][A-Za-z0-9'\\\\-]*\";\nconst CAPTION_RE = new RegExp(\n \"\\\\{([^{}|]+)\\\\|(\" + CAPTION_NAME + \")\\\\}\" + // {display|element}\n \"|\\\\{(\" + CAPTION_NAME + \")\\\\}\", // {element}\n \"g\");\n\nexport function parseCaptionTokens(text: string): CaptionToken[] {\n const out: CaptionToken[] = [];\n const re = new RegExp(CAPTION_RE.source, \"g\");\n let lastIndex = 0;\n let m: RegExpExecArray | null;\n while ((m = re.exec(text)) !== null) {\n if (m.index > lastIndex) {\n out.push({ kind: \"text\", text: text.slice(lastIndex, m.index) });\n }\n // Piped form fills groups 1-2; bare form fills group 3.\n const piped = m[2] != null;\n const display = piped ? m[1] : m[3];\n const target = piped ? m[2] : m[3];\n out.push({ kind: \"ref\", display: display, target: target });\n lastIndex = m.index + m[0].length;\n }\n if (lastIndex < text.length) {\n out.push({ kind: \"text\", text: text.slice(lastIndex) });\n }\n return out;\n}\n\n// #146 — how a slide's justification panel should lay out.\n//\n// A bare citation (\"I.15\") is a chip; several of them read fine as one\n// dot-separated row. A claim turns each entry into a statement\n// (\"angle EGB = angle AGH — I.15\"), and statements do not read as a row —\n// they want a line each. Mixed slides stack too: an entry without a claim\n// still belongs on its own line next to ones that have them.\n//\n// Pure so the layout rule is testable without a DOM.\nexport function justsUseStackedLayout(justs: ISlideJust[] | null | undefined): boolean {\n if (justs == null) return false;\n return justs.some((j) => j.claim != null && j.claim !== \"\");\n}\n\nexport function createControls(slate: Slate, canvas: HTMLCanvasElement, config: IInitConfig): void {\n // Skip in headless/test environments\n if (!canvas.parentElement) return;\n\n let controls = new SlateControls(slate, canvas, config);\n controls.init();\n}\n\nclass SlateControls {\n private _slate: Slate;\n private _canvas: HTMLCanvasElement;\n private _config: IInitConfig;\n private _wrapper: HTMLDivElement;\n private _maximized: boolean = false;\n private _savedStyles: {\n wrapperPosition: string;\n wrapperTop: string;\n wrapperLeft: string;\n wrapperWidth: string;\n wrapperHeight: string;\n wrapperZIndex: string;\n wrapperBackground: string;\n canvasStyleWidth: string;\n canvasStyleHeight: string;\n canvasAttrWidth: number;\n canvasAttrHeight: number;\n } = null;\n private _stopTrackingResize: (() => void) | null = null;\n // #154 — lazy: a clean diagram adds no DOM at all.\n private _badge: HTMLDivElement | null = null;\n private _badgeSeverity: DiagnosticSeverity | null = null;\n private _stopDiagnostics: (() => void) | null = null;\n private _maximizedOnKey: ((e: KeyboardEvent) => void) | null = null;\n\n // Presentation-mode (slideshow) state. Caption + nav float over\n // the maximized canvas; no fullscreen overlay, no background takeover.\n private _presenting: boolean = false;\n private _presentationIndex: number = 0;\n private _presentationOverlay: HTMLDivElement | null = null;\n private _presentationCaption: HTMLDivElement | null = null;\n private _presentationJusts: HTMLDivElement | null = null;\n private _presentationCounter: HTMLSpanElement | null = null;\n private _presentationOnKey: ((e: KeyboardEvent) => void) | null = null;\n // Single-pin sticky for caption {NAME} refs: only one element may be\n // emphasized at a time. Clicking another ref clears the prior pin\n // before stickying the new one; hover is suppressed while a pin is\n // active so the sticky element stays the dominant one.\n private _stickyRefSpan: HTMLSpanElement | null = null;\n private _stickyRefElem: import(\"./elements/GeomElement\").GeomElement | null = null;\n\n constructor(slate: Slate, canvas: HTMLCanvasElement, config: IInitConfig) {\n this._slate = slate;\n this._canvas = canvas;\n this._config = config;\n }\n\n init(): void {\n this._wrapper = this.createWrapper();\n this.createButtons();\n this.addKeyboardShortcuts();\n // Track window resize for the lifetime of the slate (#71): an inline\n // responsive canvas (`max-width:100%`) must re-fit on orientation\n // flip / column resize, not only while maximized. resizeAndRedraw\n // re-syncs the bitmap, recomputes the fit-scale, and redraws.\n this._stopTrackingResize = trackWindowResize(window, () => this.resizeAndRedraw());\n // #154 — subscribe, then paint once. The second call matters:\n // createControls is the LAST statement of initInner, so anything\n // reported while the figure was being built is already in the log\n // by the time this badge exists.\n this._stopDiagnostics = this._slate.onDiagnosticsChanged(() => this.updateBadge());\n this.updateBadge();\n }\n\n // Reconcile the badge with the slate's worst severity. Creates the\n // node on first need, hides it when the slate is clean, and repaints\n // in place when a warning escalates to an error.\n private updateBadge(): void {\n const severity = this._slate.diagnosticSeverity;\n if (severity == null) {\n if (this._badge) this._badge.style.display = \"none\";\n this._badgeSeverity = null;\n return;\n }\n if (!this._badge) {\n this._badge = createDiagnosticBadge(severity);\n this._badge.style.position = \"absolute\";\n // Top-LEFT: the control buttons use style.right, and the\n // presentation overlay is fixed to the bottom of the viewport,\n // so nothing else claims this corner. Absolute on the wrapper\n // means maximize/presentation carry it along for free.\n this._badge.style.top = BTN_MARGIN + \"px\";\n this._badge.style.left = BTN_MARGIN + \"px\";\n this._badge.style.zIndex = \"1\";\n this._wrapper.appendChild(this._badge);\n this._badgeSeverity = severity;\n return;\n }\n this._badge.style.display = \"\";\n if (severity !== this._badgeSeverity) {\n paintDiagnosticBadge(this._badge, severity);\n this._badgeSeverity = severity;\n }\n }\n\n private createWrapper(): HTMLDivElement {\n ensureControlsStyle(); // #69 — hover/focus reveal stylesheet (once)\n let wrapper = document.createElement(\"div\");\n wrapper.className = \"geomlib-wrapper\";\n wrapper.style.position = \"relative\";\n wrapper.style.display = \"inline-block\";\n\n // Insert wrapper before canvas, then move canvas into it\n this._canvas.parentElement.insertBefore(wrapper, this._canvas);\n wrapper.appendChild(this._canvas);\n\n // Make canvas focusable for keyboard shortcuts\n this._canvas.setAttribute(\"tabindex\", \"0\");\n this._canvas.style.outline = \"none\"; // default no outline\n this._canvas.addEventListener(\"focus\", () => {\n this._canvas.style.outline = \"2px solid rgba(66,133,244,0.5)\";\n });\n this._canvas.addEventListener(\"blur\", () => {\n this._canvas.style.outline = \"none\";\n });\n\n return wrapper;\n }\n\n private createButtons(): void {\n let buttons = [\n { draw: drawResetIcon, action: () => this.onReset(), title: \"Reset (r)\" },\n { draw: drawMaximizeIcon, action: () => this.onMaximize(), title: \"Maximize (m)\" },\n ];\n\n // Conditionally append a \"▶ Present\" button when the slate\n // carries any slides. Slates without slides see the same\n // three-button row as before — backwards-compatible.\n if (this._slate.slides.length > 0) {\n buttons.push({\n draw: drawPresentIcon,\n action: () => this.onPresent(),\n title: \"Present (p)\",\n });\n }\n\n for (let i = 0; i < buttons.length; i++) {\n let btn = document.createElement(\"button\");\n btn.style.position = \"absolute\";\n btn.style.top = BTN_MARGIN + \"px\";\n btn.style.right = (BTN_MARGIN + i * (BTN_SIZE + BTN_GAP)) + \"px\";\n btn.style.width = BTN_SIZE + \"px\";\n btn.style.height = BTN_SIZE + \"px\";\n btn.style.padding = \"0\";\n btn.style.border = \"none\";\n btn.style.cursor = \"pointer\";\n btn.style.background = \"rgba(0,0,0,0.12)\";\n btn.style.borderRadius = \"3px\";\n btn.title = buttons[i].title;\n\n btn.addEventListener(\"mouseenter\", () => {\n btn.style.background = \"rgba(0,0,0,0.3)\";\n });\n btn.addEventListener(\"mouseleave\", () => {\n btn.style.background = \"rgba(0,0,0,0.12)\";\n });\n\n // Draw icon on a small canvas inside the button\n let iconCanvas = document.createElement(\"canvas\");\n iconCanvas.width = BTN_SIZE;\n iconCanvas.height = BTN_SIZE;\n iconCanvas.style.display = \"block\";\n let ctx = iconCanvas.getContext(\"2d\");\n buttons[i].draw(ctx, BTN_SIZE);\n btn.appendChild(iconCanvas);\n\n btn.addEventListener(\"click\", (e) => {\n e.stopPropagation();\n buttons[i].action();\n // Return focus to the main canvas after button click\n this._canvas.focus();\n });\n\n // Store reference for maximize icon swap\n if (i === 1) {\n (this as any)._maxBtn = btn;\n (this as any)._maxIconCanvas = iconCanvas;\n }\n\n this._wrapper.appendChild(btn);\n }\n }\n\n private addKeyboardShortcuts(): void {\n this._canvas.addEventListener(\"keydown\", (e: KeyboardEvent) => {\n switch (e.key) {\n case \"r\":\n case \"R\":\n case \" \":\n e.preventDefault();\n this.onReset();\n break;\n case \"m\":\n case \"M\":\n e.preventDefault();\n this.onMaximize();\n break;\n case \"p\":\n case \"P\":\n if (this._slate.slides.length > 0) {\n e.preventDefault();\n this.onPresent();\n }\n break;\n }\n });\n }\n\n private onReset(): void {\n this._slate.reset();\n // #154 — the badge latches until the viewer explicitly resets.\n // Cleared HERE rather than inside Slate.reset() on purpose:\n // minimize() and presentation-exit both call reset() internally,\n // and construction-time diagnostics never fire again, so clearing\n // there would quietly discard the warnings most worth keeping.\n this._slate.clearDiagnostics();\n }\n\n private onMaximize(): void {\n if (this._maximized) {\n this.minimize();\n } else {\n this.maximize();\n }\n }\n\n private maximize(): void {\n // Save current styles AND canvas width/height attributes. The attrs\n // are the canvas bitmap resolution; resizeAndRedraw() overwrites them\n // to match the maximized CSS size, so minimize() must restore them.\n this._savedStyles = {\n wrapperPosition: this._wrapper.style.position,\n wrapperTop: this._wrapper.style.top,\n wrapperLeft: this._wrapper.style.left,\n wrapperWidth: this._wrapper.style.width,\n wrapperHeight: this._wrapper.style.height,\n wrapperZIndex: this._wrapper.style.zIndex,\n wrapperBackground: this._wrapper.style.background,\n canvasStyleWidth: this._canvas.style.width,\n canvasStyleHeight: this._canvas.style.height,\n canvasAttrWidth: this._canvas.width,\n canvasAttrHeight: this._canvas.height,\n };\n\n // Maximize wrapper to fill viewport\n this._wrapper.style.position = \"fixed\";\n this._wrapper.style.top = \"0\";\n this._wrapper.style.left = \"0\";\n this._wrapper.style.width = \"100vw\";\n this._wrapper.style.height = \"100vh\";\n this._wrapper.style.zIndex = \"9999\";\n this._wrapper.style.background = \"white\";\n\n // Expand canvas to fill wrapper\n this._canvas.style.width = \"100%\";\n this._canvas.style.height = \"100%\";\n\n // Set the flag BEFORE resizeAndRedraw so its centring pass (#107)\n // sees the maximized state and slides the figure to centre.\n this._maximized = true;\n this.resizeAndRedraw();\n this.updateMaximizeIcon();\n this.bindMaximizedKeys();\n // Window-resize tracking is persistent (set up in init), so the\n // maximized 100vw × 100vh canvas already re-syncs on viewport change.\n }\n\n // #139 — Escape while the canvas owns the viewport. Bound on `document`,\n // not the canvas: the r/m/p shortcuts only fire when the canvas itself\n // has focus, and maximizing by CLICKING the control leaves focus on the\n // button, so a canvas-bound Escape would never fire.\n //\n // This handler is the single owner of Escape (bindPresentationKeys\n // deliberately does not bind it). Two document-level handlers both\n // matching Escape would fire on one keypress and blow through\n // presentation AND maximize at once. onPresent() maximizes first, so\n // presenting implies maximized — this handler is always bound while a\n // slideshow is running, and escapeAction() decides which layer to peel.\n private bindMaximizedKeys(): void {\n if (this._maximizedOnKey) return;\n const handler = (e: KeyboardEvent) => {\n if (e.key !== \"Escape\") return;\n switch (escapeAction({presenting: this._presenting, maximized: this._maximized})) {\n case \"exitPresent\":\n e.preventDefault();\n this.exitPresent();\n break;\n case \"minimize\":\n e.preventDefault();\n this.minimize();\n break;\n }\n };\n this._maximizedOnKey = handler;\n document.addEventListener(\"keydown\", handler);\n }\n\n private unbindMaximizedKeys(): void {\n if (this._maximizedOnKey) {\n document.removeEventListener(\"keydown\", this._maximizedOnKey);\n this._maximizedOnKey = null;\n }\n }\n\n private minimize(): void {\n if (!this._savedStyles) return;\n // Resize tracking stays active (persistent since init) so the inline\n // canvas keeps re-fitting after we restore it.\n\n // Restore saved styles\n this._wrapper.style.position = this._savedStyles.wrapperPosition;\n this._wrapper.style.top = this._savedStyles.wrapperTop;\n this._wrapper.style.left = this._savedStyles.wrapperLeft;\n this._wrapper.style.width = this._savedStyles.wrapperWidth;\n this._wrapper.style.height = this._savedStyles.wrapperHeight;\n this._wrapper.style.zIndex = this._savedStyles.wrapperZIndex;\n this._wrapper.style.background = this._savedStyles.wrapperBackground;\n\n this._canvas.style.width = this._savedStyles.canvasStyleWidth;\n this._canvas.style.height = this._savedStyles.canvasStyleHeight;\n\n // Restore the canvas bitmap resolution to match its pre-maximize\n // intrinsic size. Without this, the canvas keeps the enlarged\n // width/height attributes from the maximize pass and (when style\n // width/height are empty) falls back to those attrs for its CSS\n // size — leaving the diagram rendered full-width.\n this._canvas.width = this._savedStyles.canvasAttrWidth;\n this._canvas.height = this._savedStyles.canvasAttrHeight;\n\n // Clear the flag BEFORE resizeAndRedraw so its centring pass (#107)\n // restores the figure to its authored position.\n this._maximized = false;\n this.unbindMaximizedKeys();\n this.resizeAndRedraw();\n this._savedStyles = null;\n this.updateMaximizeIcon();\n // Exiting the maximized view also resets the construction to its\n // authored state — same as the reset (r) control — so any dragging\n // done while maximized / presenting is undone on the way out (#107).\n this._slate.reset();\n }\n\n private resizeAndRedraw(): void {\n // Sync the canvas BITMAP to CSS size × dpr so it stays crisp on\n // HiDPI and after CSS scaling (#71). drawElements scales the context\n // by dpr; coordinates stay in CSS px.\n const dpr = (typeof window !== \"undefined\" && window.devicePixelRatio) || 1;\n let w = Math.round(this._canvas.clientWidth * dpr);\n let h = Math.round(this._canvas.clientHeight * dpr);\n if (this._canvas.width !== w || this._canvas.height !== h) {\n this._canvas.width = w;\n this._canvas.height = h;\n }\n this._slate.recomputeFitScale(); // #71 — F = min(1, display/logical)\n this._applyCentring();\n this._slate.update();\n }\n\n // #107 — when maximized (via the control or presentation), slide the\n // whole figure to the centre of the enlarged canvas; when not maximized,\n // restore the authored position (translate 0; the fit-scale handles\n // responsive sizing). Recomputed on every resize so it stays centred as\n // the window changes. figureBounds() is in logical coords, so the centre\n // target is computed in display px through the fit-scale F (#71).\n private _applyCentring(): void {\n if (!this._maximized) {\n this._slate.clearViewOffset();\n this._slate.clearCentringBounds();\n return;\n }\n // #138 — measure once per maximized session, from elements that\n // actually paint. Once, because a resize mid-walk must re-centre on\n // the same box the walk started from rather than on whatever the\n // current slide happens to reveal; painting elements only, because a\n // zero-colour off-screen helper would otherwise define the frame and\n // shove the figure off-canvas (I.35, I.42, I.43 all hit this).\n const b = this._slate.centringBounds != null\n ? this._slate.centringBounds : this._slate.captureCentringBounds();\n if (b == null) { this._slate.clearViewOffset(); return; }\n const cx = (b.minX + b.maxX) / 2, cy = (b.minY + b.maxY) / 2;\n const F = this._slate.viewScale;\n // T (display px) so F·figureCentre + T lands at the display centre.\n this._slate.setViewOffset(this._slate.displayWidth / 2 - F * cx,\n this._slate.displayHeight / 2 - F * cy);\n }\n\n private updateMaximizeIcon(): void {\n let iconCanvas = (this as any)._maxIconCanvas as HTMLCanvasElement;\n let btn = (this as any)._maxBtn as HTMLButtonElement;\n if (!iconCanvas) return;\n let ctx = iconCanvas.getContext(\"2d\");\n ctx.clearRect(0, 0, BTN_SIZE, BTN_SIZE);\n if (this._maximized) {\n drawMinimizeIcon(ctx, BTN_SIZE);\n btn.title = \"Minimize (m)\";\n } else {\n drawMaximizeIcon(ctx, BTN_SIZE);\n btn.title = \"Maximize (m)\";\n }\n }\n\n // --- Presentation mode (slideshow) ---\n //\n // Opens the slate's slides as a step-through. The canvas itself\n // takes over the viewport via the existing maximize state (no\n // separate fullscreen overlay, no black takeover) — the caption\n // and nav controls float on top of the maximized canvas.\n\n private onPresent(): void {\n if (this._presenting) return;\n if (this._slate.slides.length === 0) return;\n if (!this._maximized) this.maximize();\n // #114 — centre ONCE on entering presentation (covers the case\n // where we were already maximized, so maximize() didn't run). Slide\n // advances no longer re-centre. #138 — drop any box captured by an\n // earlier plain maximize so present-enter measures the figure as it\n // stands now.\n this._slate.clearCentringBounds();\n this._applyCentring();\n this.buildPresentationOverlay();\n this.bindPresentationKeys();\n this._presenting = true;\n this.showSlide(0);\n }\n\n private exitPresent(): void {\n if (!this._presenting) return;\n this.unbindPresentationKeys();\n this.clearStickyRef();\n this.removePresentationOverlay();\n // #115 — leave presentation mode but STAY in the maximized view,\n // keeping the viewer's manipulation. Only the maximize control\n // un-maximizes (and that's what resets — see minimize()). Drop the\n // parked case-variant ephemerals + the walk's highlight/visibility\n // state, but keep the current view offset (the centre set on enter)\n // and any dragged positions.\n if (this._slate.animator != null) this._slate.animator.cancel();\n this._slate.clearEphemerals();\n this._slate.clearVisibility();\n for (let e of this._slate.elements) {\n e.shouldHighlight = false;\n e.emphasized = false;\n }\n this._presenting = false;\n this._slate.update();\n }\n\n private buildPresentationOverlay(): void {\n // Floating UI panel pinned to the bottom of the viewport.\n // Uses position: fixed and attaches to documentElement so it\n // can't be clipped by any wrapper, transformed parent, or\n // scrollable container — works the same on iOS Safari,\n // Samsung Internet, Android Chrome, and desktop. Solid white\n // (no transparency) so it's never mistaken for background;\n // bright box-shadow so the boundary reads.\n const overlay = document.createElement(\"div\");\n overlay.className = \"geomlib-presentation-overlay\";\n overlay.style.position = \"fixed\";\n overlay.style.left = \"0\";\n overlay.style.right = \"0\";\n overlay.style.bottom = \"0\";\n overlay.style.margin = \"0 auto\";\n // Span the bottom of the viewport so the centred contents\n // can't render off-screen and there's nowhere for the panel\n // to \"hide\". The actual visible chrome is the inner column.\n overlay.style.maxWidth = \"100vw\";\n overlay.style.background = \"#ffffff\";\n overlay.style.color = \"#222\";\n overlay.style.borderTop = \"1px solid rgba(0,0,0,0.18)\";\n overlay.style.boxShadow = \"0 -6px 18px rgba(0,0,0,0.18)\";\n overlay.style.padding = \"12px 16px calc(12px + env(safe-area-inset-bottom, 0px))\";\n // Max possible z-index so nothing can stack above us.\n overlay.style.zIndex = \"2147483647\";\n overlay.style.fontFamily = \"Georgia, 'Times New Roman', serif\";\n overlay.style.touchAction = \"manipulation\";\n overlay.style.boxSizing = \"border-box\";\n overlay.style.textAlign = \"center\";\n\n const caption = document.createElement(\"div\");\n caption.className = \"geomlib-presentation-caption\";\n caption.style.fontSize = \"1.1rem\";\n caption.style.lineHeight = \"1.45\";\n caption.style.textAlign = \"center\";\n caption.style.marginBottom = \"6px\";\n overlay.appendChild(caption);\n\n const justs = document.createElement(\"div\");\n justs.className = \"geomlib-presentation-justs\";\n justs.style.fontSize = \"0.85rem\";\n justs.style.textAlign = \"center\";\n justs.style.opacity = \"0.85\";\n justs.style.minHeight = \"1em\";\n justs.style.marginBottom = \"10px\";\n overlay.appendChild(justs);\n\n const nav = document.createElement(\"div\");\n nav.className = \"geomlib-presentation-nav\";\n nav.style.display = \"flex\";\n nav.style.gap = \"10px\";\n nav.style.alignItems = \"center\";\n nav.style.justifyContent = \"center\";\n\n // #142 — these glyphs must not reach the bundle as raw UTF-8: a\n // consumer page without <meta charset> decodes our <script src>\n // using its own encoding and geomlib's controls turn to mojibake.\n // Escaping them HERE does not help (tsc decodes the escape, the\n // minifier re-normalises it) — it is enforced at emit by\n // `ascii_only` in webpack.config.js, and checked by\n // scripts/check-bundle-ascii.js at publish time.\n const prevBtn = makePresentationButton(\"‹ Prev\");\n const counter = document.createElement(\"span\");\n counter.className = \"geomlib-presentation-counter\";\n counter.style.minWidth = \"56px\";\n counter.style.textAlign = \"center\";\n counter.style.opacity = \"0.7\";\n counter.style.fontSize = \"0.9rem\";\n const nextBtn = makePresentationButton(\"Next ›\");\n const exitBtn = makePresentationButton(\"✕ Exit\");\n exitBtn.style.marginLeft = \"16px\";\n\n prevBtn.addEventListener(\"click\", (e) => {\n e.stopPropagation();\n this.showSlide(this._presentationIndex - 1);\n });\n nextBtn.addEventListener(\"click\", (e) => {\n e.stopPropagation();\n this.showSlide(this._presentationIndex + 1);\n });\n exitBtn.addEventListener(\"click\", (e) => {\n e.stopPropagation();\n this.exitPresent();\n });\n\n nav.appendChild(prevBtn);\n nav.appendChild(counter);\n nav.appendChild(nextBtn);\n nav.appendChild(exitBtn);\n overlay.appendChild(nav);\n\n // Append to documentElement (html) — outside body — so a\n // mobile browser's odd body sizing can't clip us.\n document.documentElement.appendChild(overlay);\n this._presentationOverlay = overlay;\n this._presentationCaption = caption;\n this._presentationJusts = justs;\n this._presentationCounter = counter;\n }\n\n private removePresentationOverlay(): void {\n if (this._presentationOverlay && this._presentationOverlay.parentNode) {\n this._presentationOverlay.parentNode.removeChild(this._presentationOverlay);\n }\n this._presentationOverlay = null;\n this._presentationCaption = null;\n this._presentationJusts = null;\n this._presentationCounter = null;\n }\n\n private bindPresentationKeys(): void {\n const handler = (e: KeyboardEvent) => {\n if (!this._presenting) return;\n switch (e.key) {\n case \"ArrowLeft\":\n e.preventDefault();\n this.showSlide(this._presentationIndex - 1);\n break;\n case \"ArrowRight\":\n case \" \":\n e.preventDefault();\n this.showSlide(this._presentationIndex + 1);\n break;\n // Escape is NOT bound here — the maximized-state handler\n // (bindMaximizedKeys, #139) owns it and routes the first\n // press to exitPresent(). Binding it in both places would\n // exit presentation and minimize on a single keypress.\n }\n };\n this._presentationOnKey = handler;\n document.addEventListener(\"keydown\", handler);\n }\n\n private unbindPresentationKeys(): void {\n if (this._presentationOnKey) {\n document.removeEventListener(\"keydown\", this._presentationOnKey);\n this._presentationOnKey = null;\n }\n }\n\n private showSlide(index: number): void {\n const slides = this._slate.slides;\n if (slides.length === 0) return;\n const clamped = Math.max(0, Math.min(slides.length - 1, index));\n this._presentationIndex = clamped;\n\n const state = computeSlideState(this._slate, slides, clamped);\n // Drop any sticky pin from the previous slide — its span\n // belongs to the prior caption and is about to be replaced\n // anyway.\n this.clearStickyRef();\n // Wipe any ephemerals a prior slide left parked (e.g. a\n // translateAside case-variant clone that persisted for its\n // slide). The animated branch's animateTo→cancel also clears\n // ephemerals, but an instant transition wouldn't — so clear\n // here on every advance.\n this._slate.clearEphemerals();\n // #114 — do NOT re-centre per slide; the figure is centred once on\n // enter (onPresent / maximize) and stays put so a viewer dragging\n // mid-walk isn't yanked back. An autoPlace transition (#99) still\n // eases from the current (centred) offset out to its case layout.\n\n const slide = slides[clamped];\n const transition = slide.transition;\n const animations = transition && transition.animations;\n const mode: \"cascade\" | \"parallel\" =\n (transition && transition.mode === \"parallel\") ? \"parallel\" : \"cascade\";\n // Clear per-element emphasis on every transition so a previous\n // slide's hover state doesn't carry forward.\n for (let e of this._slate.elements) e.emphasized = false;\n\n if (animations && animations.length > 0) {\n // Animated transition — slate.animateTo flips visibility +\n // highlight per-element and runs the configured Animation\n // for each entry. Newly-visible elements without an entry\n // pop in instantly (handled inside animateTo).\n this._slate.animateTo(state.visible, state.highlighted, animations, mode);\n } else {\n // Instant transition (4b behaviour) — flip every element\n // synchronously, no rAF loop.\n for (let e of this._slate.elements) {\n if (e.name == null) continue;\n e.visible = state.visible.has(e.name);\n e.shouldHighlight = state.highlighted.has(e.name);\n e.drawProgress = 1;\n }\n this._slate.update();\n }\n\n if (this._presentationCaption) {\n this.renderCaptionText(this._presentationCaption, slide.text || \"\");\n }\n if (this._presentationCounter) {\n this._presentationCounter.textContent = (clamped + 1) + \" / \" + slides.length;\n }\n if (this._presentationJusts) {\n this._presentationJusts.innerHTML = \"\";\n const resolve = this._slate.resolveJustification;\n const justs = slide.justifications;\n if (justs) {\n // #146 — a claim makes each entry a statement rather than a\n // bare citation, and statements don't read as a row joined\n // by dots. So: any claim on the slide and every entry gets\n // its own line; no claims and the panel is the same\n // dot-separated row it has always been.\n const stacked = justsUseStackedLayout(justs);\n for (let i = 0; i < justs.length; i++) {\n const host = stacked\n ? document.createElement(\"div\") : this._presentationJusts;\n if (!stacked && i > 0) {\n const sep = document.createElement(\"span\");\n sep.textContent = \" · \";\n sep.style.opacity = \"0.5\";\n host.appendChild(sep);\n }\n const claim = justs[i].claim;\n if (claim != null && claim !== \"\") {\n const c = document.createElement(\"span\");\n c.textContent = claim;\n host.appendChild(c);\n const dash = document.createElement(\"span\");\n dash.textContent = \" — \";\n dash.style.opacity = \"0.5\";\n host.appendChild(dash);\n }\n const ref = justs[i].ref;\n const url = resolve ? resolve(ref) : null;\n if (url) {\n const a = document.createElement(\"a\");\n a.href = url;\n a.textContent = ref;\n a.target = \"_blank\";\n a.rel = \"noopener\";\n a.style.color = \"#0066cc\";\n host.appendChild(a);\n } else {\n const span = document.createElement(\"span\");\n span.textContent = ref;\n host.appendChild(span);\n }\n if (stacked) this._presentationJusts.appendChild(host);\n }\n }\n }\n }\n\n // Parse {NAME} tokens in caption text and emit interactive bold-\n // italic spans for any that resolve to a slate element (alias\n // lookups included). Unknown / unresolved refs render as plain\n // text with the braces stripped. Hover / pointerdown toggles\n // element.emphasized so the figure picks the ref up with an\n // extra-thick gold stroke.\n //\n // Display override (#90): {DISPLAY|element} renders DISPLAY but\n // binds the highlight to `element` — for prose names that collide\n // with another element's name, e.g. \"the angle {ABC|angBint}\"\n // where the bare token would resolve to the triangle ABC. Since #136\n // the DISPLAY half may be a whole phrase; see parseCaptionTokens.\n private renderCaptionText(host: HTMLElement, text: string): void {\n host.innerHTML = \"\";\n for (const tok of parseCaptionTokens(text)) {\n if (tok.kind === \"text\") {\n host.appendChild(document.createTextNode(tok.text));\n continue;\n }\n const elem = this._slate.lookupElement(tok.target);\n if (elem) {\n host.appendChild(this.buildCaptionRef(tok.display, elem));\n } else {\n // Unknown — render plain so a typo doesn't surface as\n // raw \"{XYZ}\" to the reader.\n host.appendChild(document.createTextNode(tok.display));\n }\n }\n }\n\n private buildCaptionRef(label: string, elem: import(\"./elements/GeomElement\").GeomElement): HTMLSpanElement {\n const span = document.createElement(\"span\");\n span.className = \"geomlib-presentation-ref\";\n span.textContent = label;\n span.style.fontWeight = \"700\";\n span.style.fontStyle = \"italic\";\n span.style.cursor = \"pointer\";\n span.style.borderBottom = \"1px dotted currentColor\";\n span.addEventListener(\"mouseenter\", () => {\n // Hover does nothing while a sticky pin is active — the\n // pinned element should remain the sole highlighted ref.\n if (this._stickyRefSpan != null) return;\n elem.emphasized = true;\n this._slate.update();\n });\n span.addEventListener(\"mouseleave\", () => {\n if (this._stickyRefSpan != null) return;\n elem.emphasized = false;\n this._slate.update();\n });\n span.addEventListener(\"pointerdown\", (e) => {\n e.preventDefault();\n e.stopPropagation();\n const wasThis = this._stickyRefSpan === span;\n this.clearStickyRef();\n if (!wasThis) this.setStickyRef(span, elem);\n this._slate.update();\n });\n return span;\n }\n\n // Drop the active sticky pin (if any): release the pinned\n // element's emphasis flag and reset the span's visual state.\n private clearStickyRef(): void {\n if (this._stickyRefSpan != null) {\n this._stickyRefSpan.classList.remove(\"active\");\n this._stickyRefSpan.style.color = \"\";\n }\n if (this._stickyRefElem != null) {\n this._stickyRefElem.emphasized = false;\n }\n this._stickyRefSpan = null;\n this._stickyRefElem = null;\n }\n\n // Pin a new sticky ref. Call clearStickyRef() first if another\n // ref is currently pinned.\n private setStickyRef(span: HTMLSpanElement, elem: import(\"./elements/GeomElement\").GeomElement): void {\n span.classList.add(\"active\");\n span.style.color = \"#b08800\";\n elem.emphasized = true;\n this._stickyRefSpan = span;\n this._stickyRefElem = elem;\n }\n}\n\n// Button styling shared by the four nav buttons in the presentation\n// overlay. Matches the soft, light visual of the surrounding panel.\nfunction makePresentationButton(label: string): HTMLButtonElement {\n const b = document.createElement(\"button\");\n b.textContent = label;\n b.style.background = \"rgba(0,0,0,0.08)\";\n b.style.color = \"#222\";\n b.style.border = \"1px solid rgba(0,0,0,0.15)\";\n b.style.borderRadius = \"4px\";\n // Min 44px tap target per Apple HIG / Material guidance; the\n // wider padding also gives Pro Max thumbs some breathing room.\n b.style.padding = \"10px 16px\";\n b.style.minHeight = \"44px\";\n b.style.cursor = \"pointer\";\n b.style.fontFamily = \"inherit\";\n b.style.fontSize = \"1rem\";\n b.style.touchAction = \"manipulation\";\n b.addEventListener(\"mouseenter\", () => { b.style.background = \"rgba(0,0,0,0.16)\"; });\n b.addEventListener(\"mouseleave\", () => { b.style.background = \"rgba(0,0,0,0.08)\"; });\n return b;\n}\n\n// --- Icon drawing functions ---\n// All draw on a size×size canvas with 3px padding\n\nfunction drawResetIcon(ctx: CanvasRenderingContext2D, size: number): void {\n let cx = size / 2;\n let cy = size / 2;\n let r = size * 0.32;\n let pad = 2;\n\n ctx.strokeStyle = \"rgba(0,0,0,0.7)\";\n ctx.fillStyle = \"rgba(0,0,0,0.7)\";\n ctx.lineWidth = 1.5;\n\n // Circular arc (270 degrees)\n ctx.beginPath();\n ctx.arc(cx, cy, r, -Math.PI * 0.5, Math.PI * 0.75);\n ctx.stroke();\n\n // Arrowhead at the end of the arc\n let endAngle = Math.PI * 0.75;\n let ax = cx + r * Math.cos(endAngle);\n let ay = cy + r * Math.sin(endAngle);\n let headLen = 4;\n let a1 = endAngle + Math.PI * 0.3;\n let a2 = endAngle + Math.PI * 0.9;\n ctx.beginPath();\n ctx.moveTo(ax, ay);\n ctx.lineTo(ax + headLen * Math.cos(a1), ay + headLen * Math.sin(a1));\n ctx.lineTo(ax + headLen * Math.cos(a2), ay + headLen * Math.sin(a2));\n ctx.closePath();\n ctx.fill();\n}\n\nfunction drawMaximizeIcon(ctx: CanvasRenderingContext2D, size: number): void {\n let pad = 4;\n let s = size - pad * 2;\n\n ctx.strokeStyle = \"rgba(0,0,0,0.7)\";\n ctx.fillStyle = \"rgba(0,0,0,0.7)\";\n ctx.lineWidth = 1.5;\n\n // Top-right outward arrow\n let ax = pad + s * 0.55;\n let ay = pad + s * 0.45;\n let bx = pad + s;\n let by = pad;\n ctx.beginPath();\n ctx.moveTo(ax, ay);\n ctx.lineTo(bx, by);\n ctx.stroke();\n // Arrowhead\n ctx.beginPath();\n ctx.moveTo(bx, by);\n ctx.lineTo(bx - 5, by);\n ctx.lineTo(bx, by + 5);\n ctx.closePath();\n ctx.fill();\n\n // Bottom-left outward arrow\n ax = pad + s * 0.45;\n ay = pad + s * 0.55;\n bx = pad;\n by = pad + s;\n ctx.beginPath();\n ctx.moveTo(ax, ay);\n ctx.lineTo(bx, by);\n ctx.stroke();\n ctx.beginPath();\n ctx.moveTo(bx, by);\n ctx.lineTo(bx + 5, by);\n ctx.lineTo(bx, by - 5);\n ctx.closePath();\n ctx.fill();\n}\n\nfunction drawMinimizeIcon(ctx: CanvasRenderingContext2D, size: number): void {\n let pad = 4;\n let s = size - pad * 2;\n\n ctx.strokeStyle = \"rgba(0,0,0,0.7)\";\n ctx.fillStyle = \"rgba(0,0,0,0.7)\";\n ctx.lineWidth = 1.5;\n\n // Top-right inward arrow\n let ax = pad + s;\n let ay = pad;\n let bx = pad + s * 0.55;\n let by = pad + s * 0.45;\n ctx.beginPath();\n ctx.moveTo(ax, ay);\n ctx.lineTo(bx, by);\n ctx.stroke();\n ctx.beginPath();\n ctx.moveTo(bx, by);\n ctx.lineTo(bx + 5, by);\n ctx.lineTo(bx, by - 5);\n ctx.closePath();\n ctx.fill();\n\n // Bottom-left inward arrow\n ax = pad;\n ay = pad + s;\n bx = pad + s * 0.45;\n by = pad + s * 0.55;\n ctx.beginPath();\n ctx.moveTo(ax, ay);\n ctx.lineTo(bx, by);\n ctx.stroke();\n ctx.beginPath();\n ctx.moveTo(bx, by);\n ctx.lineTo(bx - 5, by);\n ctx.lineTo(bx, by + 5);\n ctx.closePath();\n ctx.fill();\n}\n\n// #154 — the diagnostic badge.\n//\n// A <div>, deliberately NOT a <button>: ensureControlsStyle() hides\n// `.geomlib-wrapper>button` until hover (#69), and a diagnostic that only\n// appears when you already went looking for it is useless. It is also\n// non-interactive — no click handler, no tab stop — so it adds nothing to\n// the keyboard order and never fights the buttons' :focus-within reveal.\nexport const BADGE_TOOLTIP = \"geomlib generated warnings - check console\";\n\nexport function createDiagnosticBadge(\n severity: DiagnosticSeverity,\n size?: number,\n): HTMLDivElement {\n const px = size != null ? size : BTN_SIZE;\n const badge = document.createElement(\"div\");\n badge.className = \"geomlib-badge\";\n badge.setAttribute(\"role\", \"img\");\n // Native title attribute, same mechanism as the buttons (btn.title):\n // no positioning code, and it survives maximize with no z-index fight.\n badge.title = BADGE_TOOLTIP;\n badge.setAttribute(\"aria-label\", BADGE_TOOLTIP);\n badge.style.width = px + \"px\";\n badge.style.height = px + \"px\";\n badge.style.lineHeight = \"0\";\n badge.style.cursor = \"default\";\n paintDiagnosticBadge(badge, severity, px);\n return badge;\n}\n\n// Redraw an existing badge in place, so a warning that escalates to an\n// error swaps its icon without churning the DOM node.\nexport function paintDiagnosticBadge(\n badge: HTMLElement,\n severity: DiagnosticSeverity,\n size?: number,\n): void {\n const px = size != null ? size : BTN_SIZE;\n let icon = badge.firstChild as HTMLCanvasElement;\n if (!icon || (icon as any).tagName !== \"CANVAS\") {\n badge.innerHTML = \"\";\n icon = document.createElement(\"canvas\");\n badge.appendChild(icon);\n }\n icon.width = px;\n icon.height = px;\n const ctx = icon.getContext(\"2d\");\n if (!ctx) return;\n ctx.clearRect(0, 0, px, px);\n if (severity === \"error\") drawErrorIcon(ctx, px);\n else drawWarningIcon(ctx, px);\n}\n\n// Icons are DRAWN, not text glyphs. A \"\\u26A0\" in a string literal is the\n// mojibake class #142 exists to prevent, and a glyph would drag in a font\n// metric dependency the rest of the icon set doesn't have.\n//\n// Unlike the control icons (a neutral rgba(0,0,0,0.7)), these are\n// coloured: the badge has to read as a diagnostic, not as another\n// control the viewer can press.\nexport function drawWarningIcon(ctx: CanvasRenderingContext2D, size: number): void {\n const pad = size * 0.06;\n const left = pad, right = size - pad;\n const top = pad, bottom = size - pad * 1.2;\n // Amber triangle, apex up.\n ctx.fillStyle = \"#e6a700\";\n ctx.beginPath();\n ctx.moveTo(size / 2, top);\n ctx.lineTo(right, bottom);\n ctx.lineTo(left, bottom);\n ctx.closePath();\n ctx.fill();\n // \"!\" as a bar plus a dot — no fillText, so no font dependency.\n const barW = Math.max(1.5, size * 0.11);\n ctx.fillStyle = \"#ffffff\";\n ctx.fillRect(size / 2 - barW / 2, size * 0.34, barW, size * 0.3);\n ctx.fillRect(size / 2 - barW / 2, size * 0.71, barW, barW);\n}\n\nexport function drawErrorIcon(ctx: CanvasRenderingContext2D, size: number): void {\n // A stop-sign octagon with a white X. Reads as \"stop\" at 20px in a way\n // a bare X does not, and its silhouette is distinct from the warning\n // triangle even before colour registers.\n const cx = size / 2, cy = size / 2;\n const r = size * 0.47;\n ctx.fillStyle = \"#d13438\";\n ctx.beginPath();\n for (let k = 0; k < 8; k++) {\n // Start at 22.5 degrees so the octagon sits flat-topped, the way a\n // road sign does, rather than resting on a vertex.\n const a = Math.PI / 8 + k * Math.PI / 4;\n const x = cx + r * Math.cos(a);\n const y = cy + r * Math.sin(a);\n if (k === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);\n }\n ctx.closePath();\n ctx.fill();\n\n const pad = size * 0.34;\n ctx.strokeStyle = \"#ffffff\";\n ctx.lineWidth = Math.max(1.5, size * 0.11);\n ctx.lineCap = \"round\";\n ctx.beginPath();\n ctx.moveTo(pad, pad);\n ctx.lineTo(size - pad, size - pad);\n ctx.moveTo(size - pad, pad);\n ctx.lineTo(pad, size - pad);\n ctx.stroke();\n}\n\nfunction drawPresentIcon(ctx: CanvasRenderingContext2D, size: number): void {\n // Right-pointing play triangle, centred. The button is square so a\n // little leftward bias visually centres the optical mass.\n let pad = size * 0.28;\n let leftX = pad - 1;\n let rightX = size - pad + 2;\n let topY = pad;\n let bottomY = size - pad;\n ctx.fillStyle = \"rgba(0,0,0,0.7)\";\n ctx.beginPath();\n ctx.moveTo(leftX, topY);\n ctx.lineTo(leftX, bottomY);\n ctx.lineTo(rightX, size / 2);\n ctx.closePath();\n ctx.fill();\n}\n","// Animation registry — parallel to Constructions but distinct purpose.\n//\n// A Construction builds an element once at init() time. An Animation\n// describes how to *reveal* that element when a slide transitions:\n// lines trace from one endpoint to the other, circles sweep an arc,\n// polygons trace edges in order then fade in the face. Multiple\n// animations can target the same element type — e.g. a Line might\n// be revealed via the shorthand A.Line.straightEdgeConnect (pencil\n// stroke A → B) or the long-form A.Line.compassTransfer (compass\n// walks a radius from another line then drops the straightedge).\n// Authors pick the right one per slide.\n//\n// Names follow the same `Type.method` shape as Constructions\n// (E.Line.connect ↔ A.Line.straightEdgeConnect). The enum value is\n// what authors pass; the human-readable name string is used for the\n// string-form fallback (param strings) + console.warn diagnostics.\n\nimport {GeomElement} from \"./GeomElement\";\nimport {Slate} from \"../Slate\";\n\n// Typed enum, parallel to AllConstructions. Numeric backing — typo-\n// safe at compile time and cheap to compare at runtime.\nexport enum AllAnimations {\n INSTANT,\n POINT_APPEAR,\n POINT_INTERSECT, // future\n POINT_SLIDE,\n LINE_STRAIGHT_EDGE_CONNECT,\n LINE_STRAIGHT_EDGE_EXTEND,\n LINE_COMPASS_TRANSFER, // future\n CIRCLE_COMPASS,\n CIRCLE_COMPASS_EXPLICIT, // future\n CIRCLE_COMPASS_TRANSFER,\n POLYGON_OUTLINE,\n POLYGON_OUTLINE_AND_FILL,\n POLYGON_SUPERPOSE,\n POLYGON_EQUILATERAL_BUILD,\n SECTOR_SWEEP,\n GROUP_CLONE_ASIDE,\n}\n\n// Typed constants object, mirroring E for constructions. Authors\n// write `A.Circle.compass` instead of remembering the raw enum.\nexport const A = {\n Point: {\n appear: AllAnimations.POINT_APPEAR,\n intersect: AllAnimations.POINT_INTERSECT, // future\n slide: AllAnimations.POINT_SLIDE,\n },\n Line: {\n straightEdgeConnect: AllAnimations.LINE_STRAIGHT_EDGE_CONNECT,\n straightEdgeExtend: AllAnimations.LINE_STRAIGHT_EDGE_EXTEND,\n compassTransfer: AllAnimations.LINE_COMPASS_TRANSFER, // future\n },\n Circle: {\n compass: AllAnimations.CIRCLE_COMPASS,\n compassExplicit: AllAnimations.CIRCLE_COMPASS_EXPLICIT, // future\n compassTransfer: AllAnimations.CIRCLE_COMPASS_TRANSFER, // I.2 (#127)\n },\n Polygon: {\n outline: AllAnimations.POLYGON_OUTLINE,\n outlineAndFill: AllAnimations.POLYGON_OUTLINE_AND_FILL,\n superpose: AllAnimations.POLYGON_SUPERPOSE,\n equilateralBuild: AllAnimations.POLYGON_EQUILATERAL_BUILD, // I.1 (#127)\n },\n Sector: {\n sweep: AllAnimations.SECTOR_SWEEP,\n },\n Group: {\n cloneAside: AllAnimations.GROUP_CLONE_ASIDE,\n },\n instant: AllAnimations.INSTANT,\n};\n\n// One frame-driven step of an animation. An Animation.build() returns\n// an array of these; the SlateAnimator drives each step's progress\n// from 0 → 1 over its durationMs, then calls finalise().\nexport interface IAnimationStep {\n durationMs: number;\n\n // Setup hook fires once before the first tick. Used to hide the\n // target element (so visual proxies can render over its final\n // position without overlap) and to register ephemeral helper\n // elements via slate.addEphemeral.\n setup?: () => void;\n\n // Called each frame with progress ∈ [0, 1]. Typically sets\n // target.drawProgress = progress; richer animations may also tick\n // ephemeral helpers.\n tick: (progress: number, dtMs: number, totalMs: number) => void;\n\n // Called on cancel, skip, or normal completion. Animations MUST:\n // 1. Remove every ephemeral helper they added.\n // 2. Restore the target element to its final visible state\n // (target.visible = true, drawProgress = 1).\n finalise: () => void;\n}\n\n// Abstract base class for all animations. Concrete subclasses live in\n// the per-element-type sibling files (PointAnimations.ts,\n// LineAnimations.ts, CircleAnimations.ts, PolygonAnimations.ts).\nexport abstract class Animation {\n // Enum value the animation registers under. Mirrors Construction's\n // `constructionMethod: AllConstructions` field shape.\n public abstract animationMethod: AllAnimations;\n\n // Human-readable name in the same `Type.method` shape Construction\n // uses (\"Line.straightEdgeConnect\", \"Circle.compass\", …).\n public abstract name: string;\n\n // Element class the animation can animate. animateTo validates\n // the target before calling build(); a mismatch emits a\n // console.warn and falls through to Instant.\n public abstract elementType: Function;\n\n // Per-animation default duration AND rate. Whichever the slate's\n // animationConfig overrides wins. Null on both means build()\n // computes its own duration from geometry × default rate.\n public defaultDurationMs?: number;\n public defaultRate?: number;\n\n public abstract build(target: GeomElement, slate: Slate, args: any): IAnimationStep[];\n}\n\n// InstantAnimation — the registry's fallback. Used explicitly via\n// A.instant on a slide entry to suppress an inherited animation, or\n// implicitly when an unknown name lookup fails. Just finalises the\n// target to its full-rendered state.\nexport class InstantAnimation extends Animation {\n public animationMethod = AllAnimations.INSTANT;\n public name = \"instant\";\n public elementType = GeomElement;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n return [{\n durationMs: 0,\n tick: () => {},\n finalise: () => {\n target.drawProgress = 1;\n target.visible = true;\n },\n }];\n }\n}\n\n// Module-level registry. Subclass files call registerAnimation(new X())\n// at import time so the registry is populated by the time any consumer\n// looks anything up.\nconst animationsByEnum: Map<AllAnimations, Animation> = new Map();\nconst animationsByName: Map<string, Animation> = new Map();\n\nexport function registerAnimation(a: Animation): void {\n animationsByEnum.set(a.animationMethod, a);\n animationsByName.set(a.name, a);\n}\n\n// Accepts either the enum value or the string name; returns the\n// registered Animation or null when the name doesn't resolve.\n//\n// Pure lookup: it does NOT report an unknown name. #154 moved that to\n// the caller (SlateAnimator.run), which holds the slate the diagnostic\n// belongs to. That also retired a module-global \"already warned\" Set\n// which suppressed the warning for every OTHER slate on the page once\n// any one slate hit the same bad name.\nexport function findAnimation(ref: AllAnimations | string): Animation | null {\n let a: Animation | undefined;\n if (typeof ref === \"string\") {\n a = animationsByName.get(ref);\n } else {\n a = animationsByEnum.get(ref);\n }\n return a ?? null;\n}\n\n// Register the always-present Instant. Concrete animations in\n// PointAnimations.ts / LineAnimations.ts / … register themselves the\n// same way when their modules are imported.\nregisterAnimation(new InstantAnimation());\n","/*----------------------------------------------------------------------+\n| Title:\tConstructions.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\nimport {GeomElement} from \"./GeomElement\";\nimport {PlaneElement} from \"./plane/PlaneElement\";\nimport {PointElement} from \"./point/PointElement\";\n\nexport enum ConstructionTypes {\n Integer,\n PointElement,\n CircleElement,\n PlaneElement,\n SphereElement,\n PolygonElement,\n PolyhedronElement\n}\n\nexport enum PointConstructions {\n free = 1,\n midpoint = 2,\n intersection = 3,\n first = 4,\n last = 5,\n center = 6,\n lineSlider = 7,\n circleSlider = 8,\n circumcenter = 9,\n vertex = 10,\n foot = 11,\n cutoff = 12,\n extend = 13,\n parallelogram = 14,\n similar = 15,\n perpendicular = 16,\n proportion = 17,\n invert = 18,\n meanProportional = 19,\n planeSlider = 20,\n sphereSlider = 21,\n angleBisector = 22,\n angleDivider = 23,\n fixed = 24,\n lineSegmentSlider = 25,\n harmonic = 26\n}\n\nexport enum LineConstructions {\n connect = 101,\n angleBisector = 102,\n angleDivider = 103,\n foot = 104,\n chord = 105,\n bichord = 106,\n perpendicular = 107,\n cutoff = 108,\n extend = 109,\n parallel = 110,\n similar = 111,\n proportion = 112,\n meanProportional = 113,\n path = 114\n}\n\n\nexport enum CircleConstructions {\n radius = 201,\n circumcircle = 202,\n invert = 203,\n intersection = 204\n}\n\n\nexport enum PolygonConstructions {\n square = 301,\n triangle = 302,\n quadrilateral = 303,\n pentagon = 304,\n hexagon = 305,\n equilateralTriangle = 306,\n parallelogram = 307,\n regularPolygon = 308,\n starPolygon = 309,\n similar = 310,\n application = 311,\n octagon = 312,\n face = 313,\n curvedTriangle = 314\n}\n\nexport enum SectorConstructions {\n sector = 401,\n arc = 402,\n angleMarker = 403,\n angleMarkerReflex = 404\n}\n\nexport enum PlaneConstructions {\n threePoints = 501,\n perpendicular = 502,\n parallel = 503,\n ambient = 504\n}\n\nexport enum SphereConstructions {\n radius = 601\n}\n\nexport enum PolyhedraConstructions {\n tetrahedron = 701,\n parallelepiped = 702,\n prism = 703,\n pyramid = 704\n}\n\nexport function getConstructionName(cm: AllConstructions) : String {\n if(cm < 100) {\n return \"Point.\" + PointConstructions[cm];\n } else if (100 < cm && cm < 200) {\n return \"Line.\" + LineConstructions[cm];\n } else if (300 < cm && cm < 400) {\n return \"Polygon.\" + PolygonConstructions[cm];\n } else if (400 < cm && cm < 500) {\n return \"Sector.\" + SectorConstructions[cm];\n } else if (500 < cm && cm < 600) {\n return \"Plane.\" + PlaneConstructions[cm];\n } else if (600 < cm && cm < 700) {\n return \"Sphere.\" + SphereConstructions[cm];\n } else if (700 < cm && cm < 800) {\n return \"Polyhedra.\" + PolyhedraConstructions[cm];\n }\n\n return \"<Not Valid Construction>\";\n}\n\nexport var E = {\n Point : PointConstructions,\n Line : LineConstructions,\n Circle: CircleConstructions,\n Polygon: PolygonConstructions,\n Sector: SectorConstructions,\n Plane: PlaneConstructions,\n Sphere: SphereConstructions,\n Polyhedra: PolyhedraConstructions\n};\n\nexport type AllConstructions =\n PointConstructions |\n LineConstructions |\n CircleConstructions |\n PlaneConstructions |\n PolygonConstructions |\n SectorConstructions |\n SphereConstructions |\n PolyhedraConstructions;\n\nexport type GeomElementsForUpdate = GeomElement[];\n\n// Type-sorted parameter arrays, matching Java's P[]/E[]/N[] dispatch.\n// P = PointElements (including LineElement endpoint expansions)\n// E = all other elements (Circle, Plane, Sphere, Polygon, Polyhedron)\n// N = integers (numbers)\nexport interface SortedParams {\n P: PointElement[];\n E: GeomElement[];\n N: number[];\n}\n\nexport interface ConstructionSignature {\n points: number;\n elements: number;\n integers: number;\n elementTypes?: Function[];\n}\n\nexport abstract class Construction {\n public abstract constructionMethod : AllConstructions;\n // Signature: type counts + element subtype list for E[] entries.\n // e.g. { points: 2, elements: 1, integers: 0, elementTypes: [PlaneElement] }\n public abstract signature: ConstructionSignature;\n\n // Normally a LineElement param is expanded to its two endpoint points\n // before dispatch (convertParams). A construction that wants a line to\n // arrive INTACT in E[] (e.g. curvedTriangle, where a line is a\n // straight-side carrier) sets this true to suppress that expansion.\n public keepsLineElements: boolean = false;\n\n public abstract construct(screen: PlaneElement, P: PointElement[],\n E: GeomElement[], N: number[]) : [GeomElementsForUpdate, GeomElement];\n\n // Match by counting types (matching Java's selectDataChoice).\n // Position-independent: \"E,Vplane,D,B\" and \"E,D,B,Vplane\" both match\n // { points: 3, elements: 1, elementTypes: [PlaneElement] }.\n public validateSignature(cm: AllConstructions, sp: SortedParams) : boolean {\n if (cm != this.constructionMethod) return false;\n let sig = this.signature;\n if (sig.points !== sp.P.length) return false;\n if (sig.elements !== sp.E.length) return false;\n if (sig.integers !== sp.N.length) return false;\n // Check element subtypes if specified\n if (sig.elementTypes) {\n for (let i = 0; i < sig.elementTypes.length; i++) {\n if (!(sp.E[i] instanceof sig.elementTypes[i])) return false;\n }\n }\n return true;\n }\n}\n\n/***********************************************************************\n * Construction classes — organized by element type. *\n * Each type's constructions live in their own package file and export *\n * a pre-built Construction[] array. *\n * *\n * Point — point/PointConstructions.ts *\n * (also contains CircumcircleConstruction) *\n * Line — line/LineConstructions.ts *\n * Circle — circle/CircleConstructions.ts *\n * Polygon — polygon/PolygonConstructions.ts *\n * Sector — sector/SectorConstructions.ts *\n * Plane — plane/PlaneConstructions.ts *\n * Sphere — sphere/SphereConstructions.ts *\n * Polyhedron — polyhedron/PolyhedronConstructions.ts *\n ***********************************************************************/\n\nimport {pointConstructions} from \"./point/PointConstructions\";\nimport {lineConstructions} from \"./line/LineConstructions\";\nimport {circleConstructions} from \"./circle/CircleConstructions\";\nimport {polygonConstructions} from \"./polygon/PolygonConstructions\";\nimport {sectorConstructions} from \"./sector/SectorConstructions\";\nimport {planeConstructions} from \"./plane/PlaneConstructions\";\nimport {sphereConstructions} from \"./sphere/SphereConstructions\";\nimport {polyhedronConstructions} from \"./polyhedron/PolyhedronConstructions\";\n\n\nexport const constructions: Construction[] = [\n ...pointConstructions,\n ...lineConstructions,\n ...circleConstructions,\n ...sectorConstructions,\n ...polygonConstructions,\n ...planeConstructions,\n ...sphereConstructions,\n ...polyhedronConstructions,\n];\n","/*----------------------------------------------------------------------+\n| Title:\tGeomElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./point/PointElement\"\nimport {SlateCanvas} from \"../Slate\";\n\nexport enum Align {\n CENTRAL,\n LEFT,\n RIGHT,\n ABOVE,\n BELOW\n}\n\nexport abstract class GeomElement {\n\n constructor() {\n }\n\n protected _name: string;\n // True for elements that are references to existing elements (e.g.,\n // point;first returns P[0], point;vertex returns polygon.V[n-1]).\n // Preexisting elements are skipped during rotate/translate to avoid\n // double-movement. Matches Java's preexists[] array in Slate.java.\n public preexists: boolean = false;\n // All colors default to null (transparent) — matching Java's Element.java.\n // Named elements get their colors assigned by init() in index.ts, which\n // computes type-appropriate defaults. Internal/intermediate elements\n // created inside constructions stay null (invisible) unless explicitly set.\n private _nameColor: string = null;\n protected _vertexColor : string = null;\n private _edgeColor : string = null;\n private _faceColor : string = null;\n\n // Highlight defaults pick high-contrast values that read on the typical\n // cream / white backgrounds the library is used against. The previous\n // edge/vertex default of white was invisible on the Elements site's\n // theorem-box background (HSB 35,19,100 ≈ #FFE9CD). Web \"gold\"\n // (#FFD700) is brighter / more saturated than Material amber and\n // still reads against both cream and white.\n private _nameHighlightColor : string = '#FFD700';\n private _vertexHighlightColor : string = '#FFD700';\n private _edgeHighlightColor : string = '#FFD700';\n private _faceHighlightColor : string = '#FFD700';\n\n // Default matches Java: Font(\"TimesRoman\", Font.ITALIC, 18)\n protected static _fontSize : number = 18;\n protected static _fontName : string = \"Times New Roman\";\n\n // Style scale (#71): when the figure is fit-scaled down to a narrow\n // display (view scale F < 1), decorations — label font, vertex dots,\n // line widths — are multiplied by 1/F so they keep a constant on-screen\n // size and stay readable while the geometry shrinks. Slate.drawElements\n // sets it from the view scale before each frame; 1 (the default, and\n // F=1 desktop/headless) leaves rendering bit-for-bit unchanged.\n static styleScale : number = 1;\n\n static setFont(fontName: string, fontSize: number): void {\n GeomElement._fontName = fontName;\n GeomElement._fontSize = fontSize;\n }\n\n // The label font, scaled by the current styleScale.\n static fontString(): string {\n return `italic ${GeomElement._fontSize * GeomElement.styleScale}px ${GeomElement._fontName}`;\n }\n\n private _draggable : boolean;\n private _dimension : number;\n private _align : Align;\n\n private _shouldHighlight : boolean = false;\n // Per-element visibility flag honoured by every draw method. Default\n // true preserves existing consumer behaviour; flipping false makes\n // drawFace / drawEdge / drawVertex / drawName early-return so the\n // element disappears without being removed from _elements (so\n // dependents that read its coordinates still work). Used by\n // Slate.setVisibleNames + the slideshow Presentation overlay.\n private _visible : boolean = true;\n // One step above shouldHighlight: when the slideshow caption's\n // {NAME} ref is hovered or clicked, the matching element flips to\n // emphasized. drawEdge / drawVertex paint with the highlight colour\n // at an even thicker stroke / larger dot so the element pops out\n // from any other already-highlighted ones on the slide. Released on\n // mouseleave (or click-to-toggle for sticky).\n // Emphasis amount in [0, 1]. Boolean emphasized is a thin shim\n // that toggles between 0 and 1; the SlateAnimator fades the\n // amount smoothly from 1 → 0 after an animation finishes so the\n // visible \"shrink back to highlight thickness\" feels less jarring\n // when the underlying element is also slide-highlighted (e.g.\n // ABC polygon edges over the highlighted AB / AC / BC).\n private _emphasisAmount : number = 0;\n // Animation progress for the next slide-transition render. 1 means\n // \"fully drawn\" (the default and the existing behaviour). Values in\n // [0, 1) tell per-type draw methods to render a partial geometry —\n // a half-traced line, a 30° sweep of an arc, the first edge of a\n // polygon plus a fraction of the next. Driven by Animation\n // subclasses through SlateAnimator during slide transitions; flips\n // back to 1 on each animation's finalise() so the canvas returns\n // to the fully-rendered state when the transition completes or is\n // cancelled.\n private _drawProgress : number = 1;\n protected _pixelTolerance : number = 50;\n\n protected _getTextMetrics(ctx: CanvasRenderingContext2D, txt: string) : [number, number] {\n let textMetrics = ctx.measureText(txt);\n let w = textMetrics.width;\n // Use actual font metrics for height; fall back to ascent-based estimate\n let h = (textMetrics.actualBoundingBoxAscent != null)\n ? textMetrics.actualBoundingBoxAscent + textMetrics.actualBoundingBoxDescent\n : 16;\n return [w, h];\n }\n\n drawString(ix : number, iy : number, c: SlateCanvas, overrideAlign? : Align) {\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n if(this._nameColor == null) return;\n ctx.font = GeomElement.fontString();\n ctx.fillStyle = this._nameColor;\n let [w, h] = this._getTextMetrics(ctx, this._name);\n\n switch (overrideAlign || this._align) {\n case Align.LEFT:\n ix = ix - w - 6;\n iy = iy + h/2 - 4;\n ctx.fillText(this._name, ix, iy);\n return;\n case Align.RIGHT:\n ix += 2;\n iy += h/2 - 4;\n ctx.fillText(this._name, ix, iy);\n return;\n case Align.ABOVE:\n ix -= w/2;\n iy += -h/2 + 4;\n ctx.fillText(this._name, ix, iy);\n return;\n case Align.BELOW:\n ix -= w/2;\n iy += h/2 + 6;\n ctx.fillText(this._name, ix, iy);\n return;\n }\n // compute (dx,dy) coordinates relative to center of canvas\n // and normalized\n let cw = c.width;\n let ch = c.height;\n let dx = (ix - cw/2) * ch;\n let dy = (iy - ch/2) * cw;\n if (dy > dx) {\n if (dy >= -dx)\t// put name below\n {\n ix -= w/2;\n iy += h/2 + 6;\n ctx.fillText(this._name, ix, iy);\n }\n else \t\t// put name left\n {\n ix = ix - w - 6;\n iy += h/2 - 4;\n ctx.fillText(this._name, ix, iy);\n }\n }\n else {\n if (dy >= -dx) {\t// put name right\n ix += 2;\n iy += h/2 - 4;\n ctx.fillText(this._name, ix, iy);\n } else { \t\t// put name above\n ix -= w/2;\n iy += -h/2 + 4;\n ctx.fillText(this._name, ix, iy);\n }\n }\n }\n\n public get name() {\n return this._name;\n }\n\n public set name(n : string) {\n this._name = n;\n }\n\n public abstract update() : void;\n public reset() { this.update(); }\n public defined() : boolean { return false; }\n public drag(tox: number, toy: number) : boolean { return false; }\n // drag returns true when the element is actually dragged\n public abstract translate(dx: number, dy: number) : void;\n public abstract rotate(pivot : PointElement, ac : number, as: number) : void;\n public abstract drawName(c: SlateCanvas) : void;\n public abstract drawFace(c: SlateCanvas) : void;\n public abstract drawEdge(c: SlateCanvas) : void;\n public abstract drawVertex(c: SlateCanvas) : void;\n\n set nameColor(value: string) {\n this._nameColor = value;\n }\n\n set edgeColor(value: string) {\n this._edgeColor = value;\n }\n\n set faceColor(value: string) {\n this._faceColor = value;\n }\n\n set nameHighlightColor(value: string) {\n this._nameHighlightColor = value;\n }\n\n set vertexHighlightColor(value: string) {\n this._vertexHighlightColor = value;\n }\n\n set edgeHighlightColor(value: string) {\n this._edgeHighlightColor = value;\n }\n\n set faceHighlightColor(value: string) {\n this._faceHighlightColor = value;\n }\n\n set draggable(value: boolean) {\n this._draggable = value;\n }\n\n set dimension(value: number) {\n this._dimension = value;\n }\n\n set align(value: Align) {\n this._align = value;\n }\n\n set shouldHighlight(value: boolean) {\n this._shouldHighlight = value;\n }\n\n set visible(value: boolean) {\n this._visible = value;\n }\n\n set emphasized(value: boolean) {\n this._emphasisAmount = value ? 1 : 0;\n }\n\n set emphasisAmount(value: number) {\n this._emphasisAmount = value < 0 ? 0 : (value > 1 ? 1 : value);\n }\n\n set drawProgress(value: number) {\n // Clamp to [0, 1] — out-of-range values would push the partial\n // geometry past either endpoint, which is never what callers\n // mean. Animations tick this in [0, 1] and finalise to 1.\n this._drawProgress = value < 0 ? 0 : (value > 1 ? 1 : value);\n }\n\n get nameColor(): string {\n return this._nameColor;\n }\n\n get vertexColor(): string {\n return this._vertexColor;\n }\n\n set vertexColor(c : string) {\n this._vertexColor = c;\n }\n\n get edgeColor(): string {\n return this._edgeColor;\n }\n\n get faceColor(): string {\n return this._faceColor;\n }\n\n get nameHighlightColor(): string {\n return this._nameHighlightColor;\n }\n\n get vertexHighlightColor(): string {\n return this._vertexHighlightColor;\n }\n\n get edgeHighlightColor(): string {\n return this._edgeHighlightColor;\n }\n\n get faceHighlightColor(): string {\n return this._faceHighlightColor;\n }\n\n get draggable(): boolean {\n return this._draggable;\n }\n\n get dimension(): number {\n return this._dimension;\n }\n\n get align(): Align {\n return this._align;\n }\n\n get shouldHighlight(): boolean {\n return this._shouldHighlight;\n }\n\n get visible(): boolean {\n return this._visible;\n }\n\n get emphasized(): boolean {\n return this._emphasisAmount > 0;\n }\n\n get emphasisAmount(): number {\n return this._emphasisAmount;\n }\n\n get drawProgress(): number {\n return this._drawProgress;\n }\n}\n","// Animations targeting CircleElement. See ../Animations.ts for the\n// abstract base + registry mechanics.\n\nimport {Animation, AllAnimations, IAnimationStep, registerAnimation} from \"../Animations\";\nimport {GeomElement} from \"../GeomElement\";\nimport {Slate} from \"../../Slate\";\nimport {CircleElement} from \"./CircleElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {LineElement} from \"../line/LineElement\";\nimport {PolygonElement} from \"../polygon/PolygonElement\";\n\n// Default sweep rate in radians/ms. Calibrated for unhurried teaching:\n// a full circle (2π) draws in ≈ 2 seconds at 0.003 rad/ms. Authors who\n// want a faster compass raise the rate via\n// slate.animationConfig.rates[\"Circle.compass\"].\nconst DEFAULT_ARC_RATE_RAD_PER_MS = 0.003;\n\n// A.Circle.compass — anchor at centre, pick up the pencil at the\n// radius-defining point B, sweep 2π back to the start. Args:\n// { startAngle?: number } — default is computed from the angle from\n// centre to B so the trace begins where a real compass would.\n//\n// Strict two-step sequence (mirrors A.Polygon.outlineAndFill):\n// 1. Edge sweep: drawProgress 0 → 1 over 2π / rate.\n// 2. Face fade-in: faceAlpha 0 → 1 over ~half the sweep duration.\n// The edge stays fully drawn through step 2 because drawProgress\n// finalises to 1 before the fade-in starts, and faceAlpha is the\n// independent driver for drawFace's globalAlpha.\nconst DEFAULT_CIRCLE_FILL_MS = 600;\nexport class CircleCompassAnimation extends Animation {\n public animationMethod = AllAnimations.CIRCLE_COMPASS;\n public name = \"Circle.compass\";\n public elementType = CircleElement;\n public defaultRate = DEFAULT_ARC_RATE_RAD_PER_MS;\n public defaultDurationMs = DEFAULT_CIRCLE_FILL_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const circle = target as CircleElement;\n const explicitStart = (args && typeof args.startAngle === \"number\")\n ? args.startAngle\n : Math.atan2(circle.B.y - circle.Center.y, circle.B.x - circle.Center.x);\n const sweepMs = (2 * Math.PI) / this.defaultRate;\n const fullRestore = () => {\n circle.faceAlpha = 1;\n circle.drawProgress = 1;\n circle.drawStartAngle = 0;\n circle.visible = true;\n };\n // Step 1 — edge sweep with the face hidden.\n const sweep: IAnimationStep = {\n durationMs: sweepMs,\n setup: () => {\n circle.drawStartAngle = explicitStart;\n circle.faceAlpha = 0;\n circle.drawProgress = 0;\n },\n tick: (progress) => { circle.drawProgress = progress; },\n finalise: () => { circle.drawProgress = 1; },\n };\n // A face-less circle has nothing to fade — scheduling the\n // fill step anyway would be pure dead time in the middle of\n // a cascade (#81). Run the sweep alone, with its finalise\n // doing the full restore.\n if (circle.faceColor == null) {\n sweep.finalise = fullRestore;\n return [sweep];\n }\n // Fill ~twice as fast as the sweep, capped by the class-level\n // default so a tiny circle doesn't yield a blink-of-an-eye fade.\n const fillMs = Math.min(sweepMs / 2, this.defaultDurationMs);\n return [\n sweep,\n // Step 2 — face fade-in over the now-complete arc.\n {\n durationMs: fillMs,\n tick: (progress) => { circle.faceAlpha = progress; },\n finalise: fullRestore,\n },\n ];\n }\n}\n\nregisterAnimation(new CircleCompassAnimation());\n\n// A.Circle.compassTransfer — Euclid I.2 (copy a length to a point) as one\n// animation. The target is the declared RADIUS circle the deck keeps: a\n// `circle;radius;P,C,D` (centre P, radius the length |CD| to copy). The\n// macro reads P + the source CD straight off the target, draws the rigorous\n// I.2 walk that justifies that radius — join, the two I.1 circles + the\n// equilateral triangle, the two produced sides, and the two lay-off circles —\n// nine steps, all transitory gold EPHEMERALS\n// (created in step-1 setup, cleared in the last finalise), then reveals the\n// circle. The result is a circle, so its scaffolding side is a free visual\n// choice (args.side, default +1). A deck calls one entry instead of declaring\n// and sequencing the ~8-element rig.\n//\n// Geometry (P = centre, C = near source end, D = far, r = |CD|):\n// T = equilateral apex of P,C M = C + r·unit(C−T) (CM = r, on circle(C,r))\n// N = T + (|TC|+r)·unit(P−T) (PN = r, on circle(T,|TM|)) → the kept radius\nconst CIRCLE_TRANSFER_SWEEP_RATE = 0.0055; // rad/ms — brisk for a long walk\nconst CIRCLE_TRANSFER_TRACE_RATE = 0.3; // px/ms for the straightedge traces\n\nfunction equilateralApex(A: PointElement, B: PointElement, side: number): { x: number, y: number } {\n const mx = (A.x + B.x) / 2, my = (A.y + B.y) / 2;\n const dx = B.x - A.x, dy = B.y - A.y;\n const len = Math.hypot(dx, dy) || 1;\n const h = len * Math.sqrt(3) / 2;\n // perpendicular unit (rotate the base 90°), times the chosen side\n return { x: mx + side * h * (-dy / len), y: my + side * h * (dx / len) };\n}\n\nexport class CircleCompassTransferAnimation extends Animation {\n public animationMethod = AllAnimations.CIRCLE_COMPASS_TRANSFER;\n public name = \"Circle.compassTransfer\";\n public elementType = CircleElement;\n public defaultRate = CIRCLE_TRANSFER_SWEEP_RATE;\n public defaultDurationMs = DEFAULT_CIRCLE_FILL_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const circ = target as CircleElement;\n const P = circ.Center;\n const s0 = circ.A, s1 = circ.B;\n const instant = (): IAnimationStep[] => [{\n durationMs: 0, tick: () => {},\n finalise: () => { circ.faceAlpha = 1; circ.drawProgress = 1; circ.visible = true; },\n }];\n // Need a radius defined by two distinct source points (the length to\n // copy), distinct from the centre — i.e. circle;radius;P,C,D.\n if (s0 == null || s1 == null || s0 === P || s1 === P || s0.distance(s1) < 1e-6) {\n slate.reportDiagnostic({\n code: \"bad-animation-args\",\n key: \"Circle.compassTransfer|\" + String(circ.name),\n message: \"Circle.compassTransfer: needs a radius defined by two \"\n + \"points distinct from the centre (circle;radius;centre,p1,p2) — skipping\",\n detail: { animation: \"Circle.compassTransfer\", elem: String(circ.name) },\n });\n return instant();\n }\n const plane = (P as any).AP || circ.AP;\n const r = s0.distance(s1);\n // Near source end joins the centre; far end is the length's reach.\n const C = (P.distance(s0) <= P.distance(s1)) ? s0 : s1;\n const D = (C === s0) ? s1 : s0;\n const side = (args && (args.side === 1 || args.side === -1)) ? args.side : 1;\n\n const t = equilateralApex(P, C, side);\n const T = new PointElement(); T.x = t.x; T.y = t.y; (T as any).AP = plane;\n const TC = Math.hypot(C.x - t.x, C.y - t.y) || 1;\n // M = C + r·unit(C − T); N = T + (TC + r)·unit(P − T)\n const u1x = (C.x - t.x) / TC, u1y = (C.y - t.y) / TC;\n const M = new PointElement(); M.x = C.x + r * u1x; M.y = C.y + r * u1y; (M as any).AP = plane;\n const TP = Math.hypot(P.x - t.x, P.y - t.y) || 1;\n const u2x = (P.x - t.x) / TP, u2y = (P.y - t.y) / TP;\n const N = new PointElement(); N.x = t.x + (TC + r) * u2x; N.y = t.y + (TC + r) * u2y; (N as any).AP = plane;\n\n // Transitory gold scaffolding (bare ephemerals).\n const join = new LineElement({ A: P, B: C });\n const tri = new PolygonElement(); tri.V = [P, C, T];\n const prodM = new LineElement({ A: C, B: M }); // produced side, C → M\n const prodN = new LineElement({ A: P, B: N }); // produced side, P → N (carries the result)\n const circC = new CircleElement({ C: C, B: D, AP: plane }); // circle(C, r): thru D and M\n const circT = new CircleElement({ C: T, B: M, AP: plane }); // circle(T, |TM|): thru M and N\n const circEp = new CircleElement({ C: P, B: C, AP: plane }); // I.1 circle: centre P thru C\n const circEc = new CircleElement({ C: C, B: P, AP: plane }); // I.1 circle: centre C thru P\n const transitory: GeomElement[] = [join, tri, prodM, prodN];\n // The four construction circles, in walk order (2 equilateral, 2 lay-off).\n const circles: CircleElement[] = [circEp, circEc, circC, circT];\n for (const e of (transitory as GeomElement[]).concat(circles)) {\n (e as any).edgeColor = null; (e as any).faceColor = null;\n (e as any).nameColor = null; (e as any).vertexColor = null;\n e.emphasized = true; // paints in the gold highlight stroke\n }\n // keepCircles: name the four circles so they persist as real, named\n // elements (rather than being wiped on slide advance) — a later slide\n // can re-show / count them. Order matches I.23's [t1Ka, t1Kc, t1Kc2, t1KT].\n const keepNames: string[] | null =\n (args && Array.isArray(args.keepCircles)) ? args.keepCircles : null;\n if (keepNames) circles.forEach((c, i) => { if (keepNames[i]) c.name = String(keepNames[i]); });\n const isKept = (c: CircleElement) => keepNames != null && c.name != null;\n\n const sweepMs = (2 * Math.PI) / this.defaultRate;\n const traceMs = (a: PointElement, b: PointElement) =>\n Math.max(120, a.distance(b) / CIRCLE_TRANSFER_TRACE_RATE);\n const lineStep = (ln: LineElement, ms: number): IAnimationStep => ({\n durationMs: ms,\n setup: () => { ln.drawProgress = 0; },\n tick: (p) => { ln.drawProgress = p; },\n finalise: () => { ln.drawProgress = 1; },\n });\n const sweepStep = (c: CircleElement): IAnimationStep => ({\n durationMs: sweepMs,\n setup: () => { c.drawStartAngle = Math.atan2(c.B.y - c.Center.y, c.B.x - c.Center.x); c.drawProgress = 0; },\n tick: (p) => { c.drawProgress = p; },\n finalise: () => { c.drawProgress = 1; },\n });\n // Clear the transitory scaffolding; kept circles persist (the slideshow's\n // visible-set hides them on advance and can re-show them for a count).\n const clearScaffold = () => {\n for (const e of transitory) slate.removeEphemeral(e);\n for (const c of circles) if (!isKept(c)) slate.removeEphemeral(c);\n };\n\n // Step 1 — join P→C; also registers all scaffolding and hides the\n // result circle until the reveal.\n const step1 = lineStep(join, traceMs(P, C));\n step1.setup = () => {\n circ.drawProgress = 0; circ.faceAlpha = 0; // result stays dark until reveal\n for (const e of transitory) { slate.addEphemeral(e); (e as any).drawProgress = 0; }\n for (const c of circles) {\n c.drawProgress = 0;\n if (isKept(c)) {\n slate.addElement(c); // persist as a real, named element\n slate.setInitiallyHidden(c.name!); // keep it out of the post-presentation figure\n c.visible = true; // but show it now, through the walk\n } else {\n slate.addEphemeral(c);\n }\n }\n join.drawProgress = 0;\n };\n\n const steps: IAnimationStep[] = [\n step1,\n // Steps 2,3 — the two I.1 compass circles that fix the equilateral apex.\n sweepStep(circEp),\n sweepStep(circEc),\n // Step 4 — the equilateral triangle PCT traces.\n { durationMs: traceMs(P, C) + traceMs(C, T),\n setup: () => { tri.drawProgress = 0; },\n tick: (p) => { tri.drawProgress = p; },\n finalise: () => { tri.drawProgress = 1; } },\n // Steps 5,6 — produce the two sides.\n lineStep(prodM, traceMs(C, M)),\n lineStep(prodN, traceMs(P, N)),\n // Steps 7,8 — the two lay-off compass circles.\n sweepStep(circC),\n sweepStep(circT),\n ];\n // Step 7 — reveal the result radius circle, clearing the scaffold as it lands.\n const reveal: IAnimationStep = {\n durationMs: sweepMs,\n setup: () => {\n circ.drawStartAngle = Math.atan2(circ.B.y - P.y, circ.B.x - P.x);\n circ.drawProgress = 0; circ.faceAlpha = 0; circ.visible = true;\n },\n tick: (p) => { circ.drawProgress = p; },\n finalise: () => { circ.drawProgress = 1; circ.faceAlpha = 1; circ.visible = true; clearScaffold(); },\n };\n steps.push(reveal);\n return steps;\n }\n}\n\nregisterAnimation(new CircleCompassTransferAnimation());\n","/*----------------------------------------------------------------------+\n| Circle construction classes — extracted from Constructions.ts |\n| Note: CircumcircleConstruction lives in point/PointConstructions.ts |\n| because CircumcenterConstruction extends it directly. |\n+----------------------------------------------------------------------*/\n\nimport {Construction, ConstructionSignature, SortedParams, AllConstructions,\n CircleConstructions as CircleConstructionsEnum,\n GeomElementsForUpdate} from \"../Constructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {CircleElement} from \"./CircleElement\";\nimport {InvertCircleElement} from \"./InvertCircleElement\";\nimport {SphereIntersectionElement} from \"./SphereIntersectionElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {SphereElement} from \"../sphere/SphereElement\";\n\n/************************\n * Element Class Circle *\n ************************/\n\n// circle\n// radius — points A, B [, plane C = screen]\n// the circle with center A and radius AB in the plane C\n// 2D: 2 points, 0 elements — uses screen plane\n// 3D: 2 points, 1 PlaneElement — uses explicit plane\n// (Java: Slate.java circle case 0 — new CircleElement(A,B,plane))\nexport class CircleRadiusCenterConstruction extends Construction {\n constructionMethod: AllConstructions = CircleConstructionsEnum.radius;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 2 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new CircleElement({C:P[0], B:P[1], AP:plane});\n return [[g], g];\n }\n}\n\n// circle — radius (3-point) — points A, B, C [, plane D = screen]\n// the circle with center A and radius |BC| in the plane D\n// 2D: 3 points, 0 elements — uses screen plane\n// 3D: 3 points, 1 PlaneElement — uses explicit plane\n// MUST be registered BEFORE the 2-point variant in the constructions array\n// (signature variant ordering rule: longer signature first)\n// (Java: Slate.java circle case 0 — new CircleElement(A,B,C,plane))\nexport class CircleRadius3PointConstruction extends Construction {\n constructionMethod: AllConstructions = CircleConstructionsEnum.radius;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new CircleElement({C: P[0], A: P[1], B: P[2], AP: plane});\n return [[g], g];\n }\n}\n\n\n// circle\n// invert\n// circles A, B\n// the image of circle A inverted in circle B\n// (Java: InvertCircle.java — TS: InvertCircleElement.ts)\nexport class InvertCircleConstruction extends Construction {\n constructionMethod: AllConstructions = CircleConstructionsEnum.invert;\n signature = { points: 0, elements: 2, integers: 0, elementTypes: [CircleElement, CircleElement] };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new InvertCircleElement(E[0] as CircleElement, E[1] as CircleElement);\n return [[g], g];\n }\n}\n\n// circle\n// intersection\n// spheres A, B\n// the circle at the intersection of spheres A and B\n// (Java: IntersectionSS.java — TS: SphereIntersectionElement.ts)\nexport class SphereIntersectionConstruction extends Construction {\n constructionMethod: AllConstructions = CircleConstructionsEnum.intersection;\n signature = { points: 0, elements: 2, integers: 0, elementTypes: [SphereElement, SphereElement] };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new SphereIntersectionElement(E[0] as SphereElement, E[1] as SphereElement);\n return [[g], g];\n }\n}\n\nexport const circleConstructions: Construction[] = [\n new CircleRadius3PointConstruction(),\n new CircleRadiusCenterConstruction(),\n new InvertCircleConstruction(),\n new SphereIntersectionConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tCircleElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {GeomElement} from \"../GeomElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {SlateCanvas} from \"../../Slate\";\n\n\nexport interface ICircleElementConstruction {\n C : PointElement; // center of the circle\n B : PointElement; // point defining one end of the radius segment\n A? : PointElement; // point defining the other end of the radius segment\n // (defaults to C — so radius = C.distance(B) in the 2-point form,\n // or A.distance(B) in the 3-point form where A ≠ C)\n AP : PlaneElement;\n}\n\nexport class CircleElement extends GeomElement {\n\n public Center : PointElement;\n public A : PointElement;\n public B : PointElement;\n public AP : PlaneElement;\n\n // Starting angle (radians) for the slide-transition arc sweep.\n // Default 0 keeps the existing closed-circle render path identical\n // when drawProgress is 1. Set by A.Circle.compass before sweeping\n // so the trace begins at the natural compass-point (the angle from\n // centre to the radius-defining B). Reset in finalise().\n private _drawStartAngle : number = 0;\n // Face fill alpha — drives drawFace's globalAlpha independent of\n // drawProgress (which only drives the edge sweep). Default 1 means\n // \"fully opaque\" — every existing render path behaves identically.\n private _faceAlpha : number = 1;\n\n set drawStartAngle(value: number) { this._drawStartAngle = value; }\n get drawStartAngle(): number { return this._drawStartAngle; }\n\n set faceAlpha(value: number) {\n this._faceAlpha = value < 0 ? 0 : (value > 1 ? 1 : value);\n }\n get faceAlpha(): number { return this._faceAlpha; }\n\n constructor(ice? : ICircleElementConstruction) {\n super();\n this.dimension = 2;\n if(ice == null) return;\n this.Center = ice.C;\n this.A = ice.A != null ? ice.A : this.Center;\n this.B = ice.B;\n this.AP = ice.AP;\n }\n\n get radius() {\n return this.A.distance(this.B);\n }\n\n get radius2() {\n return this.A.distance2(this.B);\n }\n\n public defined() : boolean {\n return true;\n //return this.Center.defined() && this.A.defined()\n // && this.B.defined() && this.AP.defined();\n }\n\n\n // drawEllipse and fillEllipse not necessary as they are provided\n // in the canvas api.\n\n // Shared geometry walk. `arcStart` / `arcEnd` let the caller render\n // either a partial arc (the slide-transition edge sweep) or a\n // full circle for fill purposes — the face never gets partial.\n private _drawCircleArc(ctx : CanvasRenderingContext2D, arcStart : number, arcEnd : number) : void {\n ctx.beginPath();\n let r2 : number = this.radius2;\n let r : number = Math.sqrt(r2);\n let amp2 : number = this.AP.S.z*this.AP.S.z + this.AP.T.z*this.AP.T.z;\n if (Math.abs(amp2) < 0.01) { // the circle is flat\n ctx.ellipse(\n this.Center.x,\n this.Center.y,\n r,\n r,\n 0,\n arcStart,\n arcEnd);\n return;\n }\n let h : number = r/Math.sqrt(amp2);\n // determine major and minor radius vectors (a,b) and (c,d)\n let rcos :number = h*this.AP.T.z;\n let rsin :number = -h*this.AP.S.z;\n let majorx :number = rcos*this.AP.S.x + rsin*this.AP.T.x;\n let majory :number = rcos*this.AP.S.y + rsin*this.AP.T.y;\n let factor :number = (amp2 < 1.0)? Math.sqrt(1.0-amp2) : 0.0;\n let minorx :number = -factor*majory;\n let minory :number = factor*majorx;\n let majorR : number = Math.sqrt(majorx*majorx + majory*majory);\n let minorR : number = Math.sqrt(minorx*minorx + minory*minory);\n // Degenerate case: ellipse is so thin it looks like a line.\n // (minorR <= majorR always since minorR = factor * majorR with\n // factor in [0,1], so we only need to check minorR.)\n if (minorR < 0.5) {\n ctx.moveTo(this.Center.x - majorx, this.Center.y - majory);\n ctx.lineTo(this.Center.x + majorx, this.Center.y + majory);\n return;\n }\n // Rotation angle of the major axis\n let rotation : number = Math.atan2(majory, majorx);\n ctx.ellipse(\n this.Center.x,\n this.Center.y,\n majorR,\n minorR,\n rotation,\n arcStart,\n arcEnd);\n }\n\n public drawEdge(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n // Pick the highlight color BEFORE the null bail, matching\n // LineElement / PolygonElement (#81). A circle with a null\n // edgeColor can still render in the highlight stroke while\n // emphasized or slide-highlighted — the \"invisible highlight\n // target\" pattern, and what lets a zero-color transitionary\n // circle show up during its compass animation (SlateAnimator\n // holds emphasisAmount = 1 on animating targets).\n const color = (this.emphasized || this.shouldHighlight)\n ? this.edgeHighlightColor\n : this.edgeColor;\n if (color == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.strokeStyle = color;\n // Match LineElement: smooth interpolation between baseline (1 or 3)\n // and 6 via emphasisAmount. Always assigned explicitly so a\n // previous element's value doesn't leak.\n {\n const baseW = this.shouldHighlight ? 3 : 1;\n ctx.lineWidth = (baseW + this.emphasisAmount * (6 - baseW)) * GeomElement.styleScale;\n }\n // Edge sweep: partial arc from drawStartAngle through\n // 2π · drawProgress. Default progress = 1 yields a full circle.\n let arcStart = this.drawStartAngle;\n let arcEnd = arcStart + 2 * Math.PI * this.drawProgress;\n this._drawCircleArc(ctx, arcStart, arcEnd);\n ctx.stroke();\n }\n\n public drawFace(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.faceColor == null || !this.defined()) return;\n // Face is independent of the edge sweep — always fills the\n // full circle (filling a partial arc would render a pie wedge\n // with a chord bleeding out, which is not what a compass sweep\n // should look like). Alpha is driven by the dedicated faceAlpha\n // field so an animation can fade the fill in after the edge\n // trace completes; default faceAlpha = 1 preserves the\n // fully-opaque behaviour for every consumer that doesn't animate.\n let a = this.faceAlpha;\n if (a <= 0) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.fillStyle = this.faceColor;\n this._drawCircleArc(ctx, 0, 2 * Math.PI);\n if (a < 1) {\n ctx.save();\n ctx.globalAlpha = a;\n ctx.fill();\n ctx.restore();\n } else {\n ctx.fill();\n }\n }\n\n public drawName(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.nameColor != null && this.name != null) {\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.strokeStyle = this.nameColor;\n ctx.font = GeomElement.fontString();\n let [w, h] = this._getTextMetrics(ctx, this.name);\n ctx.fillText(this._name, this.Center.x - w/2, this.Center.y - h/2);\n }\n }\n\n public drawVertex(c: SlateCanvas): void {\n }\n\n public rotate(pivot: PointElement, ac: number, as: number): void {\n }\n\n public translate(dx: number, dy: number): void {\n }\n\n public update(): void {\n }\n\n}\n","/*----------------------------------------------------------------------+\n| Title:\tCircumcenter.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2024, Nelson Brown, brownnrl@gmail.com |\n+----------------------------------------------------------------------*/\n\n// import {GeomElement} from \"../GeomElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {CircleElement} from \"./CircleElement\";\n\nexport class CircumcircleElement extends CircleElement {\n\n /*--------------------------------------------------------------------+\n | This is the circle passing through the three points B, C, and D.\t|\n | It is assumed that all three points lie in the plane AP.\t\t|\n +--------------------------------------------------------------------*/\n public C : PointElement;\n public D : PointElement;\n\n constructor(B: PointElement, C : PointElement, D: PointElement, AP: PlaneElement) {\n super();\n this.dimension = 2;\n this.B = B;\n this.C = C;\n this.D = D;\n this.AP = AP;\n this.Center = new PointElement({AP:AP});\n this.A = this.Center;\n }\n\n update() : void { \n this.Center.toCircumcenter(this.B,this.C,this.D); \n }\n\n translate(dx: number, dy: number) {\n this.Center.translate(dx, dy);\n }\n\n rotate(pivot: PointElement, c: number, s: number) {\n this.Center.rotate(pivot, c, s);\n }\n\n}\n","/*----------------------------------------------------------------------+\n| Title:\tInvertCircleElement.ts |\n| Originally: InvertCircle.java |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {CircleElement} from \"./CircleElement\";\nimport {PointElement} from \"../point/PointElement\";\n\nexport class InvertCircleElement extends CircleElement {\n /*--------------------------------------------------------------------+\n | Invert the circle C in the circle D to get this circle. It is |\n | assumed that C and D lie in the same plane C.AP. |\n +--------------------------------------------------------------------*/\n\n private _C: CircleElement;\n private _D: CircleElement;\n\n constructor(C: CircleElement, D: CircleElement) {\n super();\n this.dimension = 2;\n this._C = C;\n this._D = D;\n this.AP = C.AP;\n this.Center = new PointElement({AP: this.AP});\n this.A = this.Center;\n this.B = new PointElement({AP: this.AP});\n }\n\n public update() {\n let d2 = this._C.Center.distance2(this._D.Center);\n let r2 = this._C.radius2;\n let factor = this._D.radius2 / (d2 - r2);\n this.Center.to(this._C.Center).minus(this._D.Center).times(factor).plus(this._D.Center);\n factor = 1.0 + Math.sqrt(r2 / d2);\n this.B.to(this.Center).minus(this._D.Center).times(factor).plus(this._D.Center);\n }\n\n public translate(dx: number, dy: number) {\n this.Center.translate(dx, dy);\n this.B.translate(dx, dy);\n }\n\n public rotate(pivot: PointElement, ac: number, as: number) {\n this.Center.rotate(pivot, ac, as);\n this.B.rotate(pivot, ac, as);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tSphereIntersectionElement.ts |\n| Originally: IntersectionSS.java (renamed for clarity) |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {CircleElement} from \"./CircleElement\";\nimport {SphereElement} from \"../sphere/SphereElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {PerpendicularPlane} from \"../plane/PerpendicularPlane\";\n\nexport class SphereIntersectionElement extends CircleElement {\n /*--------------------------------------------------------------------+\n | This circle is the intersection of two spheres S and T. The center |\n | of the circle is Center, which is A, lies in the plane AP, and |\n | has radius AB. |\n +--------------------------------------------------------------------*/\n\n private _S: SphereElement;\n private _T: SphereElement;\n\n constructor(S: SphereElement, T: SphereElement) {\n super();\n this.dimension = 2;\n this._S = S;\n this._T = T;\n this.Center = this.A = new PointElement();\n this.B = new PointElement();\n this.AP = new PerpendicularPlane({A: this.Center, E: T.Center});\n this.Center._AP = this.AP;\n }\n\n public update() {\n let d2 = this._T.Center.distance2(this._S.Center);\n let t2 = this._T.radius2();\n let factor = 0.5 + (t2 - this._S.radius2()) / (2.0 * d2);\n this.Center.to(this._S.Center).minus(this._T.Center).times(factor).plus(this._T.Center);\n let radius = Math.sqrt(t2 - this.Center.distance2(this._T.Center));\n this.B.to(this.Center);\n this.B.z += radius;\n this.AP.update();\n }\n\n public translate(dx: number, dy: number) {\n this.Center.translate(dx, dy);\n this.B.translate(dx, dy);\n this.AP.translate(dx, dy);\n }\n\n public rotate(pivot: PointElement, ac: number, as: number) {\n this.Center.rotate(pivot, ac, as);\n this.B.rotate(pivot, ac, as);\n this.AP.rotate(pivot, ac, as);\n }\n}\n","// Cross-type group animations. See ../Animations.ts for the abstract\n// base + registry mechanics.\n\nimport {Animation, AllAnimations, IAnimationStep, registerAnimation} from \"../Animations\";\nimport {GeomElement} from \"../GeomElement\";\nimport {Slate} from \"../../Slate\";\nimport {PointElement} from \"../point/PointElement\";\nimport {LineElement} from \"../line/LineElement\";\nimport {PolygonElement} from \"../polygon/PolygonElement\";\nimport {LineSlider} from \"../point/LineSlider\";\n\nconst CLONE_ASIDE_RATE_PX_PER_MS = 0.4;\nconst CLONE_ASIDE_MIN_MS = 200;\n// Below this canvas (≈ viewport, in presentation mode) width, the legacy\n// explicit-offset path skips the case-variant copies — they were a\n// desktop affordance. The autoPlace path (#99) supersedes this: it slides\n// the figure to centre and only opts out when a copy genuinely can't fit.\nconst CLONE_ASIDE_DESKTOP_MIN_WIDTH = 520;\n\n// autoPlace timing + spacing (#99).\nconst CLONE_ASIDE_AUTOPLACE_MS = 900; // whole centre-then-split beat\nconst AUTOPLACE_CENTRE_FRAC = 0.4; // first 40%: slide figure to centre\nconst AUTOPLACE_MARGIN = 8; // px gap to the canvas edge\nconst AUTOPLACE_GAP = 16; // px gap between figure and a copy\n\n// easeOutCubic for the slide-to-centre phase.\nfunction easeOut(t: number): number { return 1 - Math.pow(1 - t, 3); }\n\n// A mutable clone vertex tracked against its snapshot base, so the\n// animation can slide every clone point by the same offset.\ninterface ClonePoint { pt: PointElement; bx: number; by: number; }\n\n// Snapshot one element into a bare render-copy (no construction refs;\n// update() is a no-op) at its current geometry, returning the ghost\n// plus the list of its mutable points. Supported v1 types: point,\n// line, polygon. Unsupported types return null (skipped with a warn).\nfunction snapshotElement(el: GeomElement): { ghost: GeomElement, pts: ClonePoint[] } | null {\n const bare = (src: PointElement): PointElement => {\n const p = new PointElement();\n p.x = src.x; p.y = src.y; p.z = src.z;\n return p;\n };\n // PolygonElement extends nothing point-like but has V[]; check it\n // before LineElement / PointElement so a polygon isn't mis-typed.\n if (el instanceof PolygonElement) {\n const ghost = new PolygonElement();\n const pts: ClonePoint[] = [];\n for (const v of el.V) {\n const p = bare(v);\n ghost.V.push(p);\n pts.push({ pt: p, bx: p.x, by: p.y });\n }\n ghost.edgeColor = el.edgeColor;\n ghost.faceColor = el.faceColor;\n ghost.faceAlpha = el.faceAlpha;\n ghost.nameColor = el.nameColor;\n ghost.vertexColor = el.vertexColor;\n return { ghost, pts };\n }\n if (el instanceof LineElement) {\n const a = bare(el.A);\n const b = bare(el.B);\n const ghost = new LineElement({ A: a, B: b });\n ghost.edgeColor = el.edgeColor;\n ghost.nameColor = el.nameColor;\n return { ghost, pts: [{ pt: a, bx: a.x, by: a.y }, { pt: b, bx: b.x, by: b.y }] };\n }\n if (el instanceof PointElement) {\n const p = bare(el);\n p.vertexColor = el.vertexColor;\n p.nameColor = el.nameColor;\n if (el.name != null) p.name = el.name;\n return { ghost: p, pts: [{ pt: p, bx: p.x, by: p.y }] };\n }\n return null; // circle / sector / other — deferred\n}\n\ntype Bounds = { minX: number, maxX: number, minY: number, maxY: number };\ntype Side = \"left\" | \"right\" | \"top\" | \"bottom\";\n\n// Resolve the elements a copy clones: \"all\" / missing → every named,\n// visible, non-screen element; otherwise the explicit name list.\nfunction resolveSources(slate: Slate, include: any): GeomElement[] {\n const sources: GeomElement[] = [];\n if (Array.isArray(include)) {\n for (const nm of include) {\n const e = slate.lookupElement(String(nm));\n if (e != null) sources.push(e);\n }\n } else {\n for (const e of slate.elements) {\n if (e.name != null && e.visible && !e.name.startsWith(\"screen\")) {\n sources.push(e);\n }\n }\n }\n return sources;\n}\n\n// Snapshot the figure's current geometry into bare render-copies.\n//\n// Takes the slate purely so an unsupported element can be reported\n// against it (#154). It used to latch a module-global boolean, which hid\n// the 2nd..Nth distinct unsupported element even within one figure, and\n// silenced the warning entirely for every later figure on the page.\nfunction snapshotSources(sources: GeomElement[], slate: Slate): { ghosts: GeomElement[], pts: ClonePoint[] } {\n const ghosts: GeomElement[] = [];\n const pts: ClonePoint[] = [];\n for (const el of sources) {\n const snap = snapshotElement(el);\n if (snap == null) {\n slate.reportDiagnostic({\n code: \"unsupported-element\",\n key: String(el.name),\n message: \"Group.cloneAside: skipping unsupported \"\n + \"element type (\" + el.name + \")\",\n detail: { animation: \"Group.cloneAside\", elem: String(el.name) },\n });\n continue;\n }\n ghosts.push(snap.ghost);\n for (const p of snap.pts) pts.push(p);\n }\n return { ghosts, pts };\n}\n\n// Apply a { elem, to } slider vary, recomputing the figure. Returns a\n// restore thunk (or null when the vary doesn't apply), so the caller can\n// snapshot the varied figure and put the real slider back.\nfunction applyVary(slate: Slate, vary: any): (() => void) | null {\n if (!vary || vary.elem == null || typeof vary.to !== \"number\") return null;\n const s = slate.lookupElement(String(vary.elem));\n if (!(s instanceof LineSlider)) return null;\n const sx = s.x, sy = s.y, sz = s.z;\n const A = (s as any)._A as PointElement;\n const B = (s as any)._B as PointElement;\n s.x = A.x + (B.x - A.x) * vary.to;\n s.y = A.y + (B.y - A.y) * vary.to;\n s.z = A.z + (B.z - A.z) * vary.to;\n slate.update();\n return () => { s.x = sx; s.y = sy; s.z = sz; slate.update(); };\n}\n\nfunction boundsOf(pts: ClonePoint[]): Bounds {\n let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;\n for (const c of pts) {\n if (c.bx < minX) minX = c.bx; if (c.bx > maxX) maxX = c.bx;\n if (c.by < minY) minY = c.by; if (c.by > maxY) maxY = c.by;\n }\n return { minX, maxX, minY, maxY };\n}\n\nfunction sideFromSign(dx: number, dy: number): Side {\n if (Math.abs(dx) >= Math.abs(dy)) return dx < 0 ? \"left\" : \"right\";\n return dy < 0 ? \"top\" : \"bottom\";\n}\n\n\n// A.Group.cloneAside — clone a sub-figure (a named set of elements, or\n// \"all\") into displaced bare copies and slide them aside, where they\n// PERSIST for the slide. Optionally vary a slider point per copy so each\n// shows a different case (a trichotomy's three positions of D). The real\n// figure never moves; only bare render-copies are added as ephemerals.\n//\n// args:\n// include \"all\" (default) or an array of element names — what\n// each copy clones.\n// vary? { elem, to } — set a slider to parameter t (A + t·(B−A);\n// infinite-slider t may be < 0) before snapshotting, so the\n// copy shows the varied figure; the real slider is restored\n// afterward. (Single-copy form.)\n// dx, dy legacy explicit pixel offset for the single copy (no\n// autoPlace). With autoPlace + no `variants`, only the SIGN\n// is used, to pick the copy's preferred side.\n// autoPlace? when true (#99): slide the whole visible figure to the\n// canvas centre (a translate-only slate view offset — the\n// real figure stays draggable), then lay the copies in the\n// freed space around it. Each copy takes its preferred side\n// (left/right/top/bottom), falling back to a free\n// perpendicular side when its first choice can't fit. No\n// scaling.\n// variants? [{ vary?, prefer? }, …] — with autoPlace, the case copies\n// to lay out ATOMICALLY: either every variant gets a slot\n// (all placed), or if any can't fit anywhere free, NONE are\n// placed and the figure doesn't move (both-or-neither).\n// `prefer` is a side name; default by index (left, right,\n// top, bottom). Direction is per-variant independent; only\n// the place/no-place decision is collective.\n//\n// Lifecycle: copies are ephemerals this animation does NOT remove — they\n// persist until the next slide advance clears them (SlateControls.showSlide\n// wipes leftover ephemerals + the view offset on every transition).\n//\n// elementType is GeomElement: the entry's `elem` is a nominal anchor; the\n// clone set comes from args.include.\nexport class GroupCloneAsideAnimation extends Animation {\n public animationMethod = AllAnimations.GROUP_CLONE_ASIDE;\n public name = \"Group.cloneAside\";\n public elementType = GeomElement;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const include = args && args.include;\n const autoPlace = args && args.autoPlace === true;\n const sources = resolveSources(slate, include);\n return autoPlace\n ? [this._autoPlaceStep(target, slate, args, sources)]\n : [this._legacyStep(target, slate, args, sources)];\n }\n\n // Atomic centred layout (#99). Snapshot every variant, centre the\n // figure, assign each copy a free slot (preferred side → fallback);\n // commit all only if every variant fits, else place nothing.\n private _autoPlaceStep(target: GeomElement, slate: Slate, args: any,\n sources: GeomElement[]): IAnimationStep {\n // Normalise to a variant list. No `variants` → a single copy whose\n // preferred side comes from the dx/dy sign (so the old single-copy\n // autoPlace call still works).\n const dx = args && typeof args.dx === \"number\" ? args.dx : 0;\n const dy = args && typeof args.dy === \"number\" ? args.dy : 0;\n const variants: any[] = Array.isArray(args && args.variants) && args.variants.length > 0\n ? args.variants\n : [{ vary: args && args.vary, prefer: sideFromSign(dx, dy) }];\n\n let targetOffX = 0, targetOffY = 0;\n // View offset already in effect at setup time — the presentation /\n // maximize base centring (#107). The centre phase eases from this\n // base to the target, so when the figure is ALREADY centred\n // (base == target) it's a no-op (no jump) and only the copies\n // slide; outside a maximized view base is 0 → centres as before.\n let baseOffX = 0, baseOffY = 0;\n let placed = false;\n // Per placed copy: its mutable points + the slot offset it slides to.\n let copies: { pts: ClonePoint[], edx: number, edy: number }[] = [];\n\n const drive = (p: number) => {\n if (!placed) return;\n const centreP = easeOut(Math.min(1, p / AUTOPLACE_CENTRE_FRAC));\n const splitP = Math.max(0, Math.min(1,\n (p - AUTOPLACE_CENTRE_FRAC) / (1 - AUTOPLACE_CENTRE_FRAC)));\n slate.setViewOffset(baseOffX + (targetOffX - baseOffX) * centreP,\n baseOffY + (targetOffY - baseOffY) * centreP);\n for (const c of copies)\n for (const pt of c.pts) {\n pt.pt.x = pt.bx + c.edx * splitP;\n pt.pt.y = pt.by + c.edy * splitP;\n }\n };\n\n return {\n durationMs: CLONE_ASIDE_AUTOPLACE_MS,\n setup: () => {\n target.drawProgress = 1;\n target.visible = true;\n // Display px (#71): autoPlace runs only while presenting\n // (maximized ⇒ fit-scale 1), so this is the on-screen extent.\n const W = slate.displayWidth;\n const H = slate.displayHeight;\n if (!W || !H) return;\n\n // Snapshot each variant (vary → snapshot → restore).\n const snaps: { ghosts: GeomElement[], pts: ClonePoint[], bbox: Bounds, prefer?: Side }[] = [];\n for (const variant of variants) {\n const restore = applyVary(slate, variant && variant.vary);\n const snap = snapshotSources(sources, slate);\n if (restore) restore();\n if (snap.pts.length === 0) continue;\n snaps.push({\n ghosts: snap.ghosts, pts: snap.pts,\n bbox: boundsOf(snap.pts),\n prefer: variant && variant.prefer,\n });\n }\n if (snaps.length === 0) return;\n\n // Capture the base offset (a maximized/presentation centring,\n // #107) so the centre phase eases from it instead of 0.\n baseOffX = slate.viewOffsetX;\n baseOffY = slate.viewOffsetY;\n\n // Centre target from the real (restored) figure. Read the\n // box the #107 base-centring was computed from so this lands\n // exactly where the figure already sits (no shift when\n // already centred). #138 — that is now the captured\n // painting-elements box; fall back to figureBounds() when\n // nothing captured it (not maximized / no presentation).\n const fb = slate.centringBounds != null\n ? slate.centringBounds : slate.figureBounds();\n if (fb == null) return;\n const figW = fb.maxX - fb.minX, figH = fb.maxY - fb.minY;\n const figCx = (fb.minX + fb.maxX) / 2;\n const figCy = (fb.minY + fb.maxY) / 2;\n targetOffX = W / 2 - figCx;\n targetOffY = H / 2 - figCy;\n\n const M = AUTOPLACE_MARGIN, G = AUTOPLACE_GAP;\n // The slot offset that drops a copy (bbox bb) centred in the\n // freed band on `side`, cross-aligned with the centred\n // figure — or null when it doesn't fit. (display = model +\n // view offset, so edx = bandCentre − targetOff − copyCentre.)\n const slotFor = (side: Side, bb: Bounds): [number, number] | null => {\n const bw = bb.maxX - bb.minX, bh = bb.maxY - bb.minY;\n const ccx = (bb.minX + bb.maxX) / 2, ccy = (bb.minY + bb.maxY) / 2;\n if (side === \"left\" || side === \"right\") {\n if (bh > H - 2 * M) return null;\n const inner = side === \"left\" ? W / 2 - figW / 2 - G : W / 2 + figW / 2 + G;\n const outer = side === \"left\" ? M : W - M;\n if (Math.abs(outer - inner) < bw) return null;\n return [(inner + outer) / 2 - targetOffX - ccx, figCy - ccy];\n }\n if (bw > W - 2 * M) return null;\n const inner = side === \"top\" ? H / 2 - figH / 2 - G : H / 2 + figH / 2 + G;\n const outer = side === \"top\" ? M : H - M;\n if (Math.abs(outer - inner) < bh) return null;\n return [figCx - ccx, (inner + outer) / 2 - targetOffY - ccy];\n };\n\n // Assign each variant a free slot: preferred side first,\n // then any other free side. ATOMIC — if any variant can't be\n // placed, none are (both-or-neither).\n const DEFAULT: Side[] = [\"left\", \"right\", \"top\", \"bottom\"];\n const taken = new Set<Side>();\n const assigned: { pts: ClonePoint[], edx: number, edy: number }[] = [];\n for (let i = 0; i < snaps.length; i++) {\n const s = snaps[i];\n const prefer = s.prefer || DEFAULT[i % DEFAULT.length];\n const order: Side[] = [prefer].concat(DEFAULT.filter(x => x !== prefer));\n let slot: [number, number] | null = null;\n for (const side of order) {\n if (taken.has(side)) continue;\n slot = slotFor(side, s.bbox);\n if (slot != null) { taken.add(side); break; }\n }\n if (slot == null) return; // no free slot — abort, place nothing\n assigned.push({ pts: s.pts, edx: slot[0], edy: slot[1] });\n }\n\n // Commit every copy.\n for (const s of snaps) for (const g of s.ghosts) slate.addEphemeral(g);\n copies = assigned;\n placed = true;\n },\n tick: (p) => { drive(p); },\n finalise: () => { drive(1); },\n };\n }\n\n // Legacy explicit-offset single copy (≤ 0.9.x behaviour, unchanged):\n // clone once, clamp the requested dx/dy into the canvas, only show the\n // copy if it clears the figure; skip on a narrow viewport.\n private _legacyStep(target: GeomElement, slate: Slate, args: any,\n sources: GeomElement[]): IAnimationStep {\n const dx = args && typeof args.dx === \"number\" ? args.dx : 0;\n const dy = args && typeof args.dy === \"number\" ? args.dy : 0;\n const vary = args && args.vary;\n const durationMs = Math.max(CLONE_ASIDE_MIN_MS,\n Math.hypot(dx, dy) / CLONE_ASIDE_RATE_PX_PER_MS);\n\n let cloned: ClonePoint[] = [];\n let edx = dx, edy = dy;\n let placed = false;\n const slideCopy = (p: number) => {\n for (const c of cloned) {\n c.pt.x = c.bx + edx * p;\n c.pt.y = c.by + edy * p;\n }\n };\n\n return {\n durationMs,\n setup: () => {\n target.drawProgress = 1;\n target.visible = true;\n const restore = applyVary(slate, vary);\n const snap = snapshotSources(sources, slate);\n if (restore) restore();\n const temp = snap.ghosts;\n const pts = snap.pts;\n if (temp.length === 0) return;\n\n const bb = boundsOf(pts);\n const bw = bb.maxX - bb.minX, bh = bb.maxY - bb.minY;\n // Display px (#71): autoPlace runs only while presenting\n // (maximized ⇒ fit-scale 1), so this is the on-screen extent.\n const W = slate.displayWidth;\n const H = slate.displayHeight;\n const MARGIN = 6;\n if (W && W < CLONE_ASIDE_DESKTOP_MIN_WIDTH) return;\n edx = dx; edy = dy;\n if (W && H) {\n if (bb.minX + edx < MARGIN) edx = MARGIN - bb.minX;\n if (bb.maxX + edx > W - MARGIN) edx = (W - MARGIN) - bb.maxX;\n if (bb.minY + edy < MARGIN) edy = MARGIN - bb.minY;\n if (bb.maxY + edy > H - MARGIN) edy = (H - MARGIN) - bb.maxY;\n }\n const CLEAR_GAP = 8;\n const clears = Math.abs(edx) >= bw + CLEAR_GAP\n || Math.abs(edy) >= bh + CLEAR_GAP\n || (bw === 0 && bh === 0);\n if (!clears) return;\n\n for (const g of temp) slate.addEphemeral(g);\n cloned = pts;\n placed = true;\n },\n tick: (p) => { if (placed) slideCopy(p); },\n finalise: () => { if (placed) slideCopy(1); },\n };\n }\n}\n\nregisterAnimation(new GroupCloneAsideAnimation());\n","/*----------------------------------------------------------------------+\n| Title:\tBichord.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {LineElement} from \"./LineElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {PointElement} from \"../point/PointElement\";\n\ninterface IBichordElementConstructor {\n C : CircleElement;\n D : CircleElement;\n}\n\nexport class Bichord extends LineElement {\n /*--------------------------------------------------------------------+\n | This line AB connects the two points where the two circles C and D |\n | meet. It is assumed that the two circles lie in the same plane, the |\n | plane of C. |\n +--------------------------------------------------------------------*/\n\n public C: CircleElement;\n public D: CircleElement;\n\n constructor(ibe? : IBichordElementConstructor) {\n super();\n this.dimension = 1;\n if (ibe == null) return;\n\n this._A = new PointElement();\n this._B = new PointElement();\n this.C = ibe.C;\n this.D = ibe.D;\n this._A._AP = this.C.AP;\n this._B._AP = this.C.AP;\n }\n\n public translate(dx: number, dy: number) {\n this._A.translate(dx, dy);\n this._B.translate(dx, dy);\n }\n\n public rotate(pivot : PointElement, ac : number, as : number) {\n this._A.rotate(pivot, ac, as);\n this._B.rotate(pivot, ac, as);\n }\n\n public update() {\n let r : number = this.C.radius;\n let s : number = this.D.radius;\n let d : number = this.C.Center.distance(this.D.Center);\n if (d > r + s) {\n let v = 0.0/0.0;\n this.A.x = v;\n this.A.y = v;\n this.A.z = v;\n this.B.x = v;\n this.B.y = v;\n this.B.z = v;\n return;\n }\n let costheta : number = (d*d + r*r - s*s) / (2.0 * d * r);\n let sintheta : number = Math.sqrt(1.0-costheta*costheta);\n this.A.to(this.D.Center).toCircle(this.C);\n this.B.to(this.A);\n this.A.rotate(this.C.Center,costheta,sintheta,this.C.AP);\n this.B.rotate(this.C.Center,costheta,-sintheta,this.C.AP);\n }\n\n}\n","/*----------------------------------------------------------------------+\n| Title:\tChord.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {LineElement} from \"./LineElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {PointElement} from \"../point/PointElement\";\n\ninterface IChordElementConstructor {\n D : PointElement;\n E : PointElement;\n C : CircleElement;\n}\n\nexport class Chord extends LineElement {\n /*--------------------------------------------------------------------+\n | This line AB is the segment of the line DE (extended) that |\n | intersects the circle C. It is assumed that DE and C lie in the |\n | same plane, namely that of C. |\n +--------------------------------------------------------------------*/\n\n public C: CircleElement;\n public D: PointElement;\n public E: PointElement;\n\n constructor(ice? : IChordElementConstructor) {\n super();\n this.dimension = 1;\n if (ice == null) return;\n\n this.C = ice.C;\n this.D = ice.D;\n this.E = ice.E;\n this._A = new PointElement({AP: this.C.AP});\n this._B = new PointElement({AP: this.C.AP});\n }\n\n public translate(dx: number, dy: number) {\n this._A.translate(dx, dy);\n this._B.translate(dx, dy);\n }\n\n public rotate(pivot : PointElement, ac : number, as : number) {\n this._A.rotate(pivot, ac, as);\n this._B.rotate(pivot, ac, as);\n }\n\n public update() {\n this._B.to(this.C.Center).toLine(this.D, this.E, false);\n let d2 : number = this.C.Center.distance2(this._B);\n let r2 : number = this.C.radius2;\n if (d2 > r2) {\n let v = 0.0/0.0;\n this._A.x = v;\n this._A.y = v;\n this._A.z = v;\n this._B.x = v;\n this._B.y = v;\n this._B.z = v;\n return;\n }\n let s : number = Math.sqrt(r2 - d2);\n let factor : number = s / this.D.distance(this._B);\n if (factor < 1e10) {\n this._A.to(this.D).minus(this._B).times(factor).plus(this._B);\n } else {\n factor = s / this.E.distance(this._B);\n this._A.to(this.E).minus(this._B).times(factor).plus(this._B);\n }\n this._B.times(2.0).minus(this._A);\n }\n\n}\n","// Animations targeting LineElement. See ../Animations.ts for the\n// abstract base + registry mechanics.\n\nimport {Animation, AllAnimations, IAnimationStep, registerAnimation} from \"../Animations\";\nimport {GeomElement} from \"../GeomElement\";\nimport {Slate} from \"../../Slate\";\nimport {LineElement} from \"./LineElement\";\n\n// Default trace rate in px/ms. Calibrated for unhurried teaching: a\n// typical 100-px construction line draws over ~400 ms; 200-px lines\n// take ~800 ms. Authors who want snappier transitions raise the rate\n// via slate.animationConfig.rates[\"Line.straightEdgeConnect\"].\nconst DEFAULT_LINE_RATE_PX_PER_MS = 0.25;\n\n// Common helper: trace the target line from A toward B by driving\n// drawProgress. Used by both StraightEdgeConnect (the canonical\n// straightedge stroke between two existing points) and\n// StraightEdgeExtend (same shape, just visually framed as extending\n// past an endpoint instead of joining two existing ones).\nfunction traceLine(target: LineElement, rate: number): IAnimationStep {\n // duration = length / rate, clamped low so an extremely short\n // line still gets a perceptible draw.\n const dx = target.B.x - target.A.x;\n const dy = target.B.y - target.A.y;\n const length = Math.sqrt(dx * dx + dy * dy);\n const durationMs = Math.max(120, length / rate);\n return {\n durationMs,\n tick: (progress) => { target.drawProgress = progress; },\n finalise: () => {\n target.drawProgress = 1;\n target.visible = true;\n },\n };\n}\n\n// A.Line.straightEdgeConnect — pencil stroke from A toward B.\n// Args: none. Duration = length × default rate (0.5 px/ms).\nexport class LineStraightEdgeConnectAnimation extends Animation {\n public animationMethod = AllAnimations.LINE_STRAIGHT_EDGE_CONNECT;\n public name = \"Line.straightEdgeConnect\";\n public elementType = LineElement;\n public defaultRate = DEFAULT_LINE_RATE_PX_PER_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n return [traceLine(target as LineElement, this.defaultRate)];\n }\n}\n\n// A.Line.straightEdgeExtend — for Line.extend constructions where one\n// endpoint sits on an existing line and the other is the projected\n// new endpoint. v1 renders the same trace as StraightEdgeConnect;\n// future richer variants might pivot a straightedge guide against the\n// existing line first.\nexport class LineStraightEdgeExtendAnimation extends Animation {\n public animationMethod = AllAnimations.LINE_STRAIGHT_EDGE_EXTEND;\n public name = \"Line.straightEdgeExtend\";\n public elementType = LineElement;\n public defaultRate = DEFAULT_LINE_RATE_PX_PER_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n return [traceLine(target as LineElement, this.defaultRate)];\n }\n}\n\nregisterAnimation(new LineStraightEdgeConnectAnimation());\nregisterAnimation(new LineStraightEdgeExtendAnimation());\n","/*----------------------------------------------------------------------+\n| Line construction classes — extracted from Constructions.ts |\n| Each class maps a (type, constructionName, signature) triple to |\n| a construct() method that creates the geometry element. |\n+----------------------------------------------------------------------*/\n\nimport {Construction, ConstructionSignature, SortedParams, AllConstructions, LineConstructions as LineConstructionsEnum,\n GeomElementsForUpdate} from \"../Constructions\";\nimport {PointPerpendicular1Construction, PointPerpendicular2Construction,\n PointPerpendicular3Construction, PointPerpendicular4Construction,\n PointPerpendicular5Construction} from \"../point/PointConstructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {Layoff} from \"../point/Layoff\";\nimport {Foot} from \"../point/Foot\";\nimport {PlaneFootElement} from \"../point/PlaneFootElement\";\nimport {LineElement} from \"./LineElement\";\nimport {PolylineElement} from \"./PolylineElement\";\nimport {Perpendicular} from \"./Perpendicular\";\nimport {PlanePerpendicularLine} from \"./PlanePerpendicularLine\";\nimport {Bichord} from \"./Bichord\";\nimport {Chord} from \"./Chord\";\nimport {SimilarElement} from \"../point/SimilarElement\";\nimport {ProportionElement} from \"../point/ProportionElement\";\nimport {AngleDividerElement} from \"../point/AngleDividerElement\";\nimport {MeanProportionalElement} from \"../point/MeanProportionalElement\";\n\n/**********************\n * Element Class Line *\n **********************/\n\n// line\n// connect\n// points A, B\n// the line AB connecting two points A and B\n// (Java: Slate.java line case 0 — new LineElement(A,B))\nexport class LineConnectConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.connect;\n signature = { points: 2, elements: 0, integers: 0 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new LineElement({A:P[0], B: P[1]});\n\n return [[g], g];\n }\n}\n\n// line\n// angleBisector — points B, A, C [, plane D = screen]\n// line from A to the bisector point of angle BAC on line BC\n// 2D: 3 points, 0 elements — uses screen plane\n// 3D: 3 points, 1 PlaneElement — uses explicit plane\n// (Java: Slate.java line case 1 — AngleDivider(B,A,C,plane,2) + LineElement(A,result))\nexport class AngleBisectorLineConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.angleBisector;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let ad = new AngleDividerElement(P[0], P[1], P[2], plane, 2);\n let g = new LineElement({A: P[1], B: ad});\n return [[ad, g], g];\n }\n}\n\n// line\n// angleDivider — points B, A, C, integer n [, plane D = screen]\n// line from A to the n-th division point of angle BAC on line BC\n// 2D: 3 points, 0 elements, 1 integer — uses screen plane\n// 3D: 3 points, 1 PlaneElement, 1 integer — uses explicit plane\n// (Java: Slate.java line case 2 — AngleDivider(B,A,C,plane,n) + LineElement(A,result))\nexport class AngleDividerLineConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.angleDivider;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 1 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 1\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let ad = new AngleDividerElement(P[0], P[1], P[2], plane, N[0]);\n let g = new LineElement({A: P[1], B: ad});\n return [[ad, g], g];\n }\n}\n\n// line\n// foot (2D variant)\n// 3 points A, B, C\n// the line AD from A to the foot of the perpendicular from A to line BC\n// (Java: Slate.java case 3, choice 0 — Foot(A,B,C) + LineElement(A,foot).\n// Foot class already IMPL at src/elements/point/Foot.ts.)\nexport class LineFootConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.foot;\n signature = { points: 3, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let fo = new Foot(P[0], P[1], P[2]);\n let g = new LineElement({A: P[0], B: fo});\n return [[fo, g], g];\n }\n}\n\n// *Solid Geometry Only*\n// line\n// foot\n// point A plane B\n// the line AD drawn perpendicular to plane B with the point D lying on B\n// (Java: PlaneFoot.java — TS: PlaneFootElement.ts, renamed for clarity)\nexport class PlaneFootLineConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.foot;\n signature = { points: 1, elements: 1, integers: 0, elementTypes: [PlaneElement] };\n\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const fo = new PlaneFootElement(P[0], E[0] as PlaneElement);\n const g = new LineElement({A: P[0], B: fo});\n return [[fo, g], g];\n }\n}\n\n// line\n// chord\n// points A, B, circle C\n// the chord of circle C cut by the line AB\n// (post-LineElement-expansion: A, B are the two endpoints of the input line)\n// (Java: Slate.java line case 4 — new Chord(A,B,C). Java: Chord.java)\nexport class ChordConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.chord;\n signature = { points: 2, elements: 1, integers: 0, elementTypes: [CircleElement] };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new Chord({D: P[0], E: P[1], C: E[0] as CircleElement});\n return [[g], g];\n }\n}\n\n// line\n// bichord\n// circles A, B\n// the common chord connecting the two intersection points of the circles A and B\n// (Java: Slate.java line case 5 — new Bichord(A,B). Java: Bichord.java)\nexport class BichordConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.bichord;\n signature = { points: 0, elements: 2, integers: 0, elementTypes: [CircleElement, CircleElement] };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new Bichord({C: E[0] as CircleElement, D: E[1] as CircleElement});\n return [[g], g];\n }\n}\n\n// Line perpendicular constructions — all 5 variants share the same\n// construct() pattern: call the parent point-perpendicular construct(),\n// then return the Perpendicular LineElement (first in elementsForUpdate).\n// (Java: Slate.java line case 6 — all choices dispatch to a Perpendicular\n// or PlanePerpendicular, then return the LineElement directly.)\nfunction wrapPointAsLine(es: [GeomElementsForUpdate, GeomElement]): [GeomElementsForUpdate, GeomElement] {\n return [es[0], es[0][0]];\n}\n\n// line — perpendicular variant 1: points A, B [plane C (screen)]\n// the line from A to the point D so that AD is equal and perpendicular to AB in plane C\n// (Java: Slate.java line case 6, choice 0 — Perpendicular(A,B,screen,A,B))\nexport class LinePerpendicular1Construction extends PointPerpendicular1Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.perpendicular;\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]) { return wrapPointAsLine(super.construct(screen, P, E, N)); }\n}\n\n// line — perpendicular variant 2: points A, B, plane C\n// (Java: Slate.java line case 6, choice 1 — Perpendicular(A,B,C,A,B))\nexport class LinePerpendicular2Construction extends PointPerpendicular2Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.perpendicular;\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]) { return wrapPointAsLine(super.construct(screen, P, E, N)); }\n}\n\n// line — perpendicular variant 3: points A, B, D, E [plane C (screen)]\n// (Java: Slate.java line case 6, choice 2 — Perpendicular(A,B,screen,D,E))\nexport class LinePerpendicular3Construction extends PointPerpendicular3Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.perpendicular;\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]) { return wrapPointAsLine(super.construct(screen, P, E, N)); }\n}\n\n// line — perpendicular variant 4: points A, B, plane C, points D, E\n// (Java: Slate.java line case 6, choice 3 — Perpendicular(A,B,C,D,E))\nexport class LinePerpendicular4Construction extends PointPerpendicular4Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.perpendicular;\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]) { return wrapPointAsLine(super.construct(screen, P, E, N)); }\n}\n\n// line — perpendicular variant 5: point A, plane B, points C, D\n// (Java: Slate.java line case 6, choice 4 — PlanePerpendicularLine(A,B,C,D))\nexport class LinePerpendicular5Construction extends PointPerpendicular5Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.perpendicular;\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]) { return wrapPointAsLine(super.construct(screen, P, E, N)); }\n}\n\n// line\n// cutoff\n// points A, B, C, D\n// the line AE equal to CD along the line AB\n// (Java: Slate.java line case 7 — Layoff(A,A,B,C,D) + LineElement(A,layoff))\nexport class LineCutoffConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.cutoff;\n signature = { points: 4, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let lo = new Layoff(P[0], P[0], P[1], P[2], P[3]);\n let g = new LineElement({A: P[0], B: lo});\n return [[lo, g], g];\n }\n}\n\n// line\n// extend\n// points A, B, C, D\n// the line BE equal to CD so that A, B, and C are collinear with B between A and C\n// (Java: Slate.java line case 8 — Layoff(B,A,B,C,D) + LineElement(B,layoff))\nexport class LineExtendConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.extend;\n signature = { points: 4, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let lo = new Layoff(P[1], P[0], P[1], P[2], P[3]);\n let g = new LineElement({A: P[1], B: lo});\n return [[lo, g], g];\n }\n}\n\n// line\n// parallel\n// points A, B, C\n// the line AD through A parallel and equal to BC, so D = A + (C - B)\n// (no dedicated Java class — Slate.java case 9 dispatches to a Layoff\n// trick: Layoff(A, B, C, B, C) gives D = A + (C-B), then wraps a fresh\n// LineElement(A, D). Same pattern as LineExtendConstruction above.)\nexport class LineParallelConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.parallel;\n signature = { points: 3, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let lo = new Layoff(P[0], P[1], P[2], P[1], P[2]);\n let g = new LineElement({A: P[0], B: lo});\n return [[lo, g], g];\n }\n}\n\n// line\n// similar — points A, B, D, E, F [, planes C, G = screen]\n// the line AH so that triangle ABH is similar to triangle DEF\n// 2D: 5 points, 0 elements — uses screen plane for both\n// 3D: 5 points, 2 PlaneElements — uses explicit planes\n// (Java: Slate.java line case 10 — Similar(A,B,C,D,E,F,G) + LineElement(A,H))\nexport class SimilarLineConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.similar;\n signature: ConstructionSignature = { points: 5, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 5 && sp.N.length === 0\n && (sp.E.length === 0 || sp.E.length === 2);\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let c = E.length > 0 ? E[0] as PlaneElement : screen;\n let g2 = E.length > 1 ? E[1] as PlaneElement : screen;\n let sim = new SimilarElement(P[0], P[1], c, P[2], P[3], P[4], g2);\n let g = new LineElement({A: P[0], B: sim});\n return [[sim, g], g];\n }\n}\n\n// line\n// proportion\n// 8 points A, B, C, D, E, F, G, H\n// the line GI along GH so that AB:CD = EF:GI\n// (Java: Slate.java line case 11 — Proportion + LineElement(G, result))\nexport class ProportionLineConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.proportion;\n signature = { points: 8, elements: 0, integers: 0 };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let prop = new ProportionElement(P[0], P[1], P[2], P[3], P[4], P[5], P[6], P[7]);\n let g = new LineElement({A: P[6], B: prop});\n return [[prop, g], g];\n }\n}\n\n// line\n// meanProportional\n// 6 points S0, S1, T0, T1, U0, U1\n// the line U0U' along U0U1 so that S:U' = U':T\n// (Java: Slate.java line case 12 — MeanProportional + LineElement(U0, result))\nexport class MeanProportionalLineConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.meanProportional;\n signature = { points: 6, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let mp = new MeanProportionalElement(P[0], P[1], P[2], P[3], P[4], P[5]);\n let g = new LineElement({A: P[4], B: mp});\n return [[mp, g], g];\n }\n}\n\n// line — path — an ordered list of 2+ points\n// An open path (polyline) A → B → C → … that does NOT close back to the\n// first point — the multi-segment generalization of line;connect, a\n// one-dimensional connected route highlightable as one element (#121, the\n// \"bent line\" of Heron's I.20). Variable arity, so validateSignature\n// overrides the default fixed-count match: any number (≥2) of points.\nexport class PolylineConstruction extends Construction {\n constructionMethod: AllConstructions = LineConstructionsEnum.path;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.E.length === 0 && sp.N.length === 0 && sp.P.length >= 2;\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new PolylineElement(P.slice());\n return [[g], g];\n }\n}\n\nexport const lineConstructions: Construction[] = [\n new PolylineConstruction(),\n new LineConnectConstruction(),\n new LineExtendConstruction(),\n new LinePerpendicular1Construction(),\n new LinePerpendicular2Construction(),\n new LinePerpendicular3Construction(),\n new LinePerpendicular4Construction(),\n new LinePerpendicular5Construction(),\n new BichordConstruction(),\n new ChordConstruction(),\n new LineParallelConstruction(),\n new LineCutoffConstruction(),\n new PlaneFootLineConstruction(),\n new LineFootConstruction(),\n new SimilarLineConstruction(),\n new ProportionLineConstruction(),\n new AngleBisectorLineConstruction(),\n new AngleDividerLineConstruction(),\n new MeanProportionalLineConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tLineElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\n\nimport {PointElement} from \"../point/PointElement\";\nimport {GeomElement} from \"../GeomElement\";\nimport {SlateCanvas} from \"../../Slate\";\n\ninterface ILineElementConstructor {\n A : PointElement;\n B : PointElement;\n}\n\nexport class LineElement extends GeomElement {\n protected _A : PointElement;\n\n get A() : PointElement { return this._A; }\n\n protected _B : PointElement;\n get B() : PointElement { return this._B; }\n\n constructor(ile?: ILineElementConstructor) {\n super();\n this.dimension = 1;\n this._A = ile && ile.A || null;\n this._B = ile && ile.B || null;\n }\n\n public drawEdge(c: HTMLCanvasElement, color?: string): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (color == null) {\n if (this.emphasized || this.shouldHighlight) {\n color = this.edgeHighlightColor;\n } else {\n color = this.edgeColor;\n }\n }\n\n if (color == null) return;\n\n let ctx = c.getContext(\"2d\");\n ctx.strokeStyle = color;\n // Stroke weight scales smoothly. Baseline is 1 (normal) or 3\n // (slide-highlight); emphasisAmount interpolates up to 6 for\n // full emphasis. emphasisAmount = 0 → baseline; 1 → 6 px;\n // animator fades 1 → 0 over ~250 ms at the end of a transition\n // so the post-animation settle isn't a hard pop.\n const baseW = this.shouldHighlight ? 3 : 1;\n ctx.lineWidth = (baseW + this.emphasisAmount * (6 - baseW)) * GeomElement.styleScale;\n // Slide-transition animation: drawProgress < 1 traces only the\n // first `progress` fraction of the line A → B. Default 1 keeps\n // the full-line behaviour every existing consumer relies on.\n let p = this.drawProgress;\n let endX = this._A.x + (this._B.x - this._A.x) * p;\n let endY = this._A.y + (this._B.y - this._A.y) * p;\n ctx.beginPath();\n ctx.moveTo(this._A.x, this._A.y);\n ctx.lineTo(endX, endY);\n ctx.stroke();\n }\n\n public drawFace(c: SlateCanvas): void {\n }\n\n public drawName(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.nameColor == null || this.name == null) return;\n if (this._A == null || !this._A.defined()) return;\n if (this._B == null || !this._B.defined()) return;\n const ix = Math.round((this._A.x + this._B.x) / 2);\n const iy = Math.round((this._A.y + this._B.y) / 2);\n this.drawString(ix, iy, c);\n }\n\n public drawVertex(c: SlateCanvas): void {\n }\n\n public rotate(pivot: PointElement, ac: number, as: number): void {\n }\n\n public translate(dx: number, dy: number): void {\n }\n\n public update(): void {\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPerpendicular.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\n\nimport {PointElement} from \"../point/PointElement\";\nimport {SlateCanvas} from \"../../Slate\";\nimport {LineElement} from \"./LineElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport interface IPerpendicularElementConstructor {\n C : PointElement;\n D : PointElement;\n P : PlaneElement;\n E : PointElement;\n F : PointElement;\n}\n\nexport class Perpendicular extends LineElement {\n // draw perpendicular to CD in the plane P. A is the proj of\n // C onto P, while AB is perpendicular to CD and equals EF.\n\n protected _C : PointElement;\n protected _D : PointElement;\n protected _E : PointElement;\n protected _F : PointElement;\n protected _P : PlaneElement;\n\n constructor(ipe?: IPerpendicularElementConstructor) {\n super();\n this.dimension = 1;\n if(ipe == null) return;\n this._P = ipe.P;\n this._A = new PointElement({AP: ipe.P});\n this._B = new PointElement({AP: ipe.P});\n this._C = ipe.C;\n this._D = ipe.D;\n this._E = ipe.E;\n this._F = ipe.F;\n }\n\n public rotate(pivot: PointElement, ac: number, as: number): void {\n this.A.rotate(pivot, ac, as);\n this.B.rotate(pivot, ac, as);\n }\n\n public translate(dx: number, dy: number): void {\n this.A.translate(dx,dy);\n this.B.translate(dx,dy);\n }\n\n public update(): void {\n this._A.to(this._C).toPlane(this._P);\n this._B.to(this._D).minus(this._A);\n let Bs : number = PointElement.dot(this.B,this._P.S);\n let Bt : number = PointElement.dot(this.B,this._P.T);\n let factor : number = Math.sqrt(this._E.distance2(this._F)/(Bs*Bs+Bt*Bt));\n Bs = -Bs/factor;\n Bt /= factor;\n this._B.x = Bt*this._P.S.x + Bs*this._P.T.x + this._A.x;\n this._B.y = Bt*this._P.S.y + Bs*this._P.T.y + this._A.y;\n this._B.z = Bt*this._P.S.z + Bs*this._P.T.z + this._A.z;\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPlanePerpendicularLine.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2023, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"../point/PointElement\";\nimport {SlateCanvas} from \"../../Slate\";\nimport {LineElement} from \"./LineElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {IPerpendicularElementConstructor} from \"./Perpendicular\";\n\nexport interface IPlanePerpendicularLineConstructor {\n C : PointElement;\n P : PlaneElement;\n D : PointElement;\n E : PointElement;\n}\n\nexport class PlanePerpendicularLine extends LineElement {\n \n // draw perpendicular at C to the plane P. A is the proj of C onto P, while\n // AB is perpendicular to P and equal to DE\n\n protected _C : PointElement;\n protected _P : PlaneElement;\n protected _D : PointElement;\n protected _E : PointElement;\n \n // The line AB will be perpendicular to the plane P. A will be the projection\n // of C on to the plane P. AB will equal DE.\n\n constructor(ipe?: IPlanePerpendicularLineConstructor) {\n super();\n this.dimension = 1;\n if(ipe == null) return;\n this._A = new PointElement({AP: ipe.P});\n this._B = new PointElement();\n this._C = ipe.C;\n this._D = ipe.D;\n this._E = ipe.E;\n this._P = ipe.P;\n }\n\n public rotate(pivot: PointElement, ac: number, as: number): void {\n this.A.rotate(pivot, ac, as);\n this.B.rotate(pivot, ac, as);\n }\n\n public translate(dx: number, dy: number): void {\n this.A.translate(dx,dy);\n this.B.translate(dx,dy);\n }\n\n public update(): void {\n this._A.to(this._C).toPlane(this._P);\n this._B.toCross(this._P.S, this._P.T);\n this._B.times(this._D.distance(this._E)).plus(this._A)\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPolylineElement.ts |\n| Part of the geomlib port of David E. Joyce's Geometry Applet. |\n| TypeScript: 2026, Nelson Brown, brownnrl@gmail.com |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"../point/PointElement\";\nimport {GeomElement} from \"../GeomElement\";\nimport {SlateCanvas} from \"../../Slate\";\n\n// An open path (polyline): an ordered run of connected segments through\n// the given points (A → B → C → …) that, unlike a polygon, does NOT close\n// back to the first point. It is a one-dimensional route — the \"bent line\"\n// of, e.g., Heron's minimum-distance problem (the path A→E→B) — drawn and\n// highlightable as ONE element, so a prose ref to the whole route lights\n// every segment together.\n//\n// Mirrors PolygonElement's edge trace (drawProgress-aware), but open and\n// with no face. Its points are independent slate elements that move by\n// their own handlers, so translate/rotate are no-ops.\nexport class PolylineElement extends GeomElement {\n\n public V : PointElement[];\n\n constructor(ps?: PointElement[]) {\n super();\n this.dimension = 1;\n this.V = ps == null ? [] : ps;\n }\n\n public defined() : boolean {\n if (this.V.length < 2) return false;\n for (let v of this.V) if (!v.defined()) return false;\n return true;\n }\n\n public drawEdge(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n const color = (this.emphasized || this.shouldHighlight)\n ? this.edgeHighlightColor\n : this.edgeColor;\n if (color == null || this.V.length < 2) return;\n\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.beginPath();\n ctx.strokeStyle = color;\n {\n const baseW = this.shouldHighlight ? 3 : 1;\n ctx.lineWidth = (baseW + this.emphasisAmount * (6 - baseW)) * GeomElement.styleScale;\n }\n // Open path: V.length - 1 edges (no closing edge). Each integer\n // step of drawProgress · edgeCount advances one full segment; the\n // fractional remainder partially traces the next. drawProgress = 1\n // (default) traces the whole route.\n const n = this.V.length;\n const edgeCount = n - 1;\n const total = this.drawProgress * edgeCount;\n const fullEdges = Math.floor(total);\n const frac = total - fullEdges;\n\n ctx.moveTo(this.V[0].x, this.V[0].y);\n for (let i = 0; i < fullEdges; i++) {\n const to = this.V[i + 1];\n ctx.lineTo(to.x, to.y);\n ctx.stroke();\n }\n if (frac > 0 && fullEdges < edgeCount) {\n const from = this.V[fullEdges];\n const to = this.V[fullEdges + 1];\n ctx.lineTo(from.x + (to.x - from.x) * frac, from.y + (to.y - from.y) * frac);\n ctx.stroke();\n }\n }\n\n // Open route: no enclosed area to fill.\n public drawFace(c: SlateCanvas) : void {}\n\n public drawVertex(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.vertexColor != null && this.defined()) {\n for (let v of this.V) v.drawVertex(c, this.vertexColor);\n }\n }\n\n public drawName(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.nameColor != null && this.name != null && this.defined()) {\n let x = 0, y = 0;\n for (let v of this.V) { x += v.x; y += v.y; }\n const k = this.V.length;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n let [w, h] = this._getTextMetrics(ctx, this._name);\n ctx.beginPath();\n ctx.fillStyle = this.nameColor;\n ctx.fillText(this._name, x / k - w / 2, y / k + h / 4);\n }\n }\n\n public rotate(pivot: PointElement, ac: number, as: number) : void {}\n public translate(dx: number, dy: number) : void {}\n public update() : void {}\n}\n","/*----------------------------------------------------------------------+\n| Title:\tParallelPlane.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PlaneElement} from \"./PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\n\nexport class ParallelPlane extends PlaneElement {\n /*--------------------------------------------------------------------+\n | this is the plane parallel to the plane P passing through the |\n | point A |\n +--------------------------------------------------------------------*/\n\n private _P: PlaneElement;\n\n constructor(P: PlaneElement, A: PointElement) {\n super();\n this.dimension = 2;\n this._P = P;\n this.A = A;\n this.B = new PointElement();\n this.C = new PointElement();\n this.S = P.S;\n this.T = P.T;\n this.U = P.U;\n }\n\n public translate(dx: number, dy: number) {\n this.B.translate(dx, dy);\n this.C.translate(dx, dy);\n }\n\n public rotate(pivot: PointElement, ac: number, as: number) {\n this.B.rotate(pivot, ac, as);\n this.C.rotate(pivot, ac, as);\n }\n\n public update() {\n this.B.to(this._P.B).minus(this._P.A).plus(this.A);\n this.C.to(this._P.C).minus(this._P.A).plus(this.A);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPerpendicularPlane.ts |\n| Originally: PerpendicularPL.java (renamed for clarity) |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2024, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"../point/PointElement\";\nimport {PlaneElement} from \"./PlaneElement\";\n\nexport interface IPerpendicularPlaneElementConstruction {\n A : PointElement;\n E : PointElement;\n}\n\nexport class PerpendicularPlane extends PlaneElement {\n\n // this is the plane perpendicular to the line AE at the point A\n\n public E : PointElement;\n\n constructor(ippe? : IPerpendicularPlaneElementConstruction) {\n super();\n this.A = ippe.A;\n this.E = ippe.E;\n this.B = new PointElement({AP: this});\n this.C = new PointElement({AP: this});\n this.S = new PointElement();\n this.T = new PointElement();\n }\n\n translate(dx: number, dy: number) : void {\n this.B.translate(dx, dy);\n this.C.translate(dx, dy);\n }\n\n rotate(pivot : PointElement, ac: number, as: number) {\n this.B.rotate(pivot, ac, as);\n this.C.rotate(pivot, ac, as);\n super.update();\n }\n\n update() {\n this.U = PointElement.difference(this.E,this.A);\n let len : number = this.U.length();\n // TODO: Check division by 0?\n this.U.times(1.0/len);\n let lxy : number = Math.sqrt(this.U.x*this.U.x + this.U.y*this.U.y);\n if(lxy >= 0.000001) {\n this.S.x = -this.U.y/lxy;\n this.S.y = this.U.x/lxy;\n this.T.toCross(this.U,this.S);\n } else {\n this.S.x = 1.0;\n this.S.y = 0.0;\n this.S.z = 0.0;\n this.T.x = 0.0;\n this.T.y = 1.0;\n this.T.z = 0.0;\n }\n this.B.to(this.S).times(len).plus(this.A);\n this.C.to(this.T).times(len).plus(this.A);\n }\n}\n","/*----------------------------------------------------------------------+\n| Plane construction classes — extracted from Constructions.ts |\n+----------------------------------------------------------------------*/\n\nimport {Construction, AllConstructions,\n PlaneConstructions as PlaneConstructionsEnum,\n GeomElementsForUpdate} from \"../Constructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {PlaneElement} from \"./PlaneElement\";\nimport {PerpendicularPlane} from \"./PerpendicularPlane\";\nimport {ParallelPlane} from \"./ParallelPlane\";\n\n// plane — 3points — points A, B, C\n// (Java: Slate.java plane case 0 — new PlaneElement(A, B, C))\nexport class Plane3PointsConstruction extends Construction {\n constructionMethod: AllConstructions = PlaneConstructionsEnum.threePoints;\n signature = { points: 3, elements: 0, integers: 0 };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new PlaneElement({A: P[0], B: P[1], C: P[2]});\n return [[g], g];\n }\n}\n\n// plane — perpendicular — points A, B\n// (Java: Slate.java plane case 1 — new PerpendicularPL(A,B))\nexport class PerpendicularPlaneConstruction extends Construction {\n constructionMethod: AllConstructions = PlaneConstructionsEnum.perpendicular;\n signature = { points: 2, elements: 0, integers: 0 };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new PerpendicularPlane({A: P[0], E: P[1]});\n return [[g], g];\n }\n}\n\n// plane — parallel — plane P, point A\n// (Java: ParallelP.java — 26 lines, line-for-line port)\nexport class PlaneParallelConstruction extends Construction {\n constructionMethod: AllConstructions = PlaneConstructionsEnum.parallel;\n signature = { points: 1, elements: 1, integers: 0, elementTypes: [PlaneElement] };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new ParallelPlane(E[0] as PlaneElement, P[0]);\n return [[g], g];\n }\n}\n\n// plane — ambient (point variant) — point A\n// (Java: Slate.java plane case 3, choice 0 — returns P[0].AP)\nexport class AmbientPlanePointConstruction extends Construction {\n constructionMethod: AllConstructions = PlaneConstructionsEnum.ambient;\n signature = { points: 1, elements: 0, integers: 0 };\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n return [[P[0]._AP], P[0]._AP];\n }\n}\n\n// plane — ambient (circle variant) — circle A\n// (Java: Slate.java plane case 3, choice 1 — returns ((CircleElement)E[0]).AP)\nexport class AmbientPlaneCircleConstruction extends Construction {\n constructionMethod: AllConstructions = PlaneConstructionsEnum.ambient;\n signature = { points: 0, elements: 1, integers: 0, elementTypes: [CircleElement] };\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const c = E[0] as CircleElement;\n return [[c.AP], c.AP];\n }\n}\n\nexport const planeConstructions: Construction[] = [\n new Plane3PointsConstruction(),\n new PerpendicularPlaneConstruction(),\n new PlaneParallelConstruction(),\n new AmbientPlanePointConstruction(),\n new AmbientPlaneCircleConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tPlaneElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {GeomElement} from \"../GeomElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {SlateCanvas} from \"../../Slate\";\n\n\nexport interface IPlaneElementConstruction {\n A : PointElement;\n B : PointElement;\n C : PointElement;\n}\n\ntype iplec = IPlaneElementConstruction\n\nexport class PlaneElement extends GeomElement {\n\n /*--------------------------------------------------------------------+\n | The plane is represented by three points on it. It's displayed as |\n | a parallelogram with three vertices A, B, and C,projected onto the |\n | xy-plane. S is a unit vector in the direction AB, T is a |\n | perpendicular unit in the plane, and U is perpendicular to both. |\n +--------------------------------------------------------------------*/\n public A : PointElement;\n public B : PointElement;\n public C : PointElement;\n public S : PointElement;\n public T : PointElement;\n public U : PointElement;\n\n public pivot : PointElement; // pivot point for the plane, if any\n public isScreen : boolean; // set true only for initial screen plane\n\n constructor(ip? : IPlaneElementConstruction) {\n super();\n this.dimension = 2;\n this.isScreen = false;\n if (ip != null) {\n this.A = ip.A;\n this.B = ip.B;\n this.C = ip.C;\n this.S = new PointElement();\n this.T = new PointElement();\n this.U = new PointElement();\n }\n }\n\n public defined(): boolean {\n return this.A != null && this.B != null && this.C != null;\n }\n\n // A plane renders as a parallelogram with corners A, B, D, C\n // where D = B + C - A (the 4th corner in the plane of A, B, C).\n\n public drawEdge(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.edgeColor == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.save();\n ctx.strokeStyle = this.edgeColor;\n let dx = this.B.x + this.C.x - this.A.x;\n let dy = this.B.y + this.C.y - this.A.y;\n ctx.beginPath();\n ctx.moveTo(this.A.x, this.A.y);\n ctx.lineTo(this.B.x, this.B.y);\n ctx.lineTo(dx, dy);\n ctx.lineTo(this.C.x, this.C.y);\n ctx.closePath();\n ctx.stroke();\n ctx.restore();\n }\n\n public drawFace(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.faceColor == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.save();\n ctx.fillStyle = this.faceColor;\n let dx = this.B.x + this.C.x - this.A.x;\n let dy = this.B.y + this.C.y - this.A.y;\n ctx.beginPath();\n ctx.moveTo(this.A.x, this.A.y);\n ctx.lineTo(this.B.x, this.B.y);\n ctx.lineTo(dx, dy);\n ctx.lineTo(this.C.x, this.C.y);\n ctx.closePath();\n ctx.fill();\n ctx.restore();\n }\n\n public drawName(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.nameColor == null || this.name == null || !this.defined()) return;\n // Label placed at midpoint of BC, matching Java PlaneElement.drawName\n let ix = Math.round((this.B.x + this.C.x) / 2.0);\n let iy = Math.round((this.B.y + this.C.y) / 2.0);\n this.drawString(ix, iy, c);\n }\n\n public drawVertex(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.vertexColor == null || !this.defined()) return;\n // Draw vertex at D = B + C - A (the 4th parallelogram corner).\n // A, B, C are drawn by their own drawVertex calls in Slate.\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n let dx = this.B.x + this.C.x - this.A.x;\n let dy = this.B.y + this.C.y - this.A.y;\n ctx.beginPath();\n ctx.fillStyle = this.vertexColor;\n ctx.arc(dx, dy, 2, 0, 2*Math.PI, false);\n ctx.fill();\n }\n\n public rotate(pivot: PointElement, ac: number, as: number): void {\n this.update();\n }\n\n public translate(dx: number, dy: number): void {\n }\n\n public update(): void {\n if (this.isScreen && (this.A.z!=0.0 || this.B.z!=0.0 || this.C.z!=0.0))\n this.isScreen = false;\n // update the frame S,T,U\n this.S.to(this.B).minus(this.A);\n this.T.to(this.C).minus(this.A);\n this.S.times(1.0/this.S.length());\n let st : number = PointElement.dot(this.T, this.S);\n this.T.x -= st*this.S.x;\n this.T.y -= st*this.S.y;\n this.T.z -= st*this.S.z;\n this.T.times(1.0/this.T.length());\n this.U.toCross(this.S,this.T);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tAngleDividerElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class AngleDividerElement extends PointElement {\n /*--------------------------------------------------------------------+\n | n-sect angle BAC in the ambient plane AP |\n +--------------------------------------------------------------------*/\n\n private _A: PointElement; // vertex of the angle\n private _B: PointElement; // first ray point\n private _C: PointElement; // second ray point\n private _n: number; // divisor (2 = bisector)\n\n constructor(B: PointElement, A: PointElement, C: PointElement,\n AP: PlaneElement, n: number) {\n super();\n this.dimension = 0;\n this._A = A;\n this._B = B;\n this._C = C;\n this._AP = AP;\n this._n = n;\n }\n\n public update() {\n let theta : number = this._A.angle(this._B, this._C, this._AP) / this._n;\n let cos : number = Math.cos(theta);\n let sin : number = Math.sin(theta);\n if (this._AP.isScreen) {\n this._x = this._A.x + cos * (this._B.x - this._A.x) - sin * (this._B.y - this._A.y);\n this._y = this._A.y + sin * (this._B.x - this._A.x) + cos * (this._B.y - this._A.y);\n this._z = 0.0;\n } else {\n this.to(this._B).rotate(this._A, cos, sin, this._AP);\n }\n this.toIntersection(this, this._A, this._B, this._C, this._AP);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tCircleSlider.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\nimport {PointElement} from \"./PointElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\n\nexport class CircleSlider extends PointElement {\n _C : CircleElement;\n _initx : number;\n _inity : number;\n _initz : number;\n\n _newP : PointElement = new PointElement();\n\n constructor(C: CircleElement,\n x: number, y: number, z: number) {\n super();\n this.dimension = 0;\n this.draggable = true;\n this._C = C;\n this._x = x;\n this._initx = x;\n this._y = y;\n this._inity = y;\n this._z = z;\n this._initz = z;\n }\n\n public reset() {\n this._x = this._initx;\n this._y = this._inity;\n this._z = this._initz;\n this.toCircle(this._C);\n }\n\n public update() {\n this.toCircle(this._C);\n }\n\n public drag(tox: number, toy: number): boolean {\n this._x = tox;\n this._y = toy;\n if (!this.defined()) this._z = this._initz;\n this._newP.to(this).uptoPlane(this._C.AP);\n if (!this._newP.defined())\t// vertical plane\n this._newP.to(this).toPlane(this._C.AP);\n this._newP.toSphere(this._C.Center, this._C.radius);\n if ((this._newP.x-this.x)*(this._newP.x-this.x) +\n (this._newP.y-this.y)*(this._newP.y-this.y) < 0.5)\n return false;\n this.to(this._newP);\n return true;\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tFixedPoint.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\nimport {PointElement, IPointElementConstruction} from \"./PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class FixedPoint extends PointElement {\n\n protected _initx : number;\n protected _inity : number;\n protected _initz : number;\n\n constructor(ip? : IPointElementConstruction) {\n super(ip);\n this._initx = this._x;\n this._inity = this._y;\n this._initz = this._z;\n }\n\n public reset() : void {\n this._x = this._initx;\n this._y = this._inity;\n this._z = this._initz;\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tFoot.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2024, Nelson Brown, brownnrl@gmail.com |\n+----------------------------------------------------------------------*/\nimport {PointElement} from \"./PointElement\";\n\nexport class Foot extends PointElement {\n _A : PointElement;\n _B : PointElement;\n _C : PointElement;\n\n constructor(A: PointElement, B: PointElement, C: PointElement) {\n super();\n this.dimension = 0;\n this._A = A;\n this._B = B;\n this._C = C;\n if (this._B.AP == this._C.AP) {\n this._AP = this._B.AP;\n }\n }\n\n public update() : void {\n this.to(this._A).toLine(this._B, this._C, false)\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tHarmonicElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\n\nexport class HarmonicElement extends PointElement {\n /*--------------------------------------------------------------------+\n | The harmonic conjugate A of B with respect to the points C and D. |\n | If B,C,D are collinear, then A also lies on that line; if not, |\n | A lies on the circumcircle through B,C,D. |\n +--------------------------------------------------------------------*/\n\n private _B: PointElement;\n private _C: PointElement;\n private _D: PointElement;\n private _E: PointElement;\n private _F: PointElement;\n private _M: PointElement;\n\n constructor(B: PointElement, C: PointElement, D: PointElement) {\n super();\n this.dimension = 0;\n this._B = B;\n this._C = C;\n this._D = D;\n this._E = new PointElement();\n this._F = new PointElement();\n this._M = new PointElement();\n }\n\n public update() {\n if (this._B.z === 0.0 && this._C.z === 0.0 && this._D.z === 0.0) {\n // 2D case: treat B,C,D as complex numbers\n // A = (C(B-D) + D(B-C)) / ((B-D) + (B-C))\n let Ex = this._B.x - this._C.x, Ey = this._B.y - this._C.y;\n let Fx = this._B.x - this._D.x, Fy = this._B.y - this._D.y;\n let BFx = this._C.x * Fx - this._C.y * Fy;\n let BFy = this._C.x * Fy + this._C.y * Fx;\n let DEx = this._D.x * Ex - this._D.y * Ey;\n let DEy = this._D.x * Ey + this._D.y * Ex;\n let den = (Fx + Ex) * (Fx + Ex) + (Fy + Ey) * (Fy + Ey);\n let numx = (BFx + DEx) * (Fx + Ex) + (BFy + DEy) * (Fy + Ey);\n let numy = -(BFx + DEx) * (Fy + Ey) + (BFy + DEy) * (Fx + Ex);\n this._x = numx / den;\n this._y = numy / den;\n } else {\n // 3D case\n this._M.to(this._C).plus(this._D).times(0.5); // M = (C+D)/2\n this._F.to(this._C).minus(this._M); // F = C-M\n this._E.to(this._B).minus(this._M); // E = B-M\n let rB2 = 1.0 / this._E.length2();\n let C2 = this._F.length2();\n this.to(this._F)\n .times(2.0 * PointElement.dot(this._E, this._F))\n .minus(this._E.times(C2))\n .times(rB2)\n .plus(this._M);\n }\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tIntersection.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2024, Nelson Brown, brownnrl@gmail.com |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class Intersection extends PointElement {\n \n A : PointElement;\n B : PointElement;\n C : PointElement;\n D : PointElement;\n\n constructor(A: PointElement,\n B: PointElement,\n C: PointElement,\n D: PointElement,\n AP: PlaneElement) {\n super({AP: AP});\n this.dimension = 0;\n this.A = A;\n this.B = B;\n this.C = C;\n this.D = D;\n }\n\n update(): void {\n this.toIntersection(this.A, this.B, this.C, this.D, this.AP);\n }\n}\n\n\n","/*----------------------------------------------------------------------+\n| Title:\tInvertPointElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\n\nexport class InvertPointElement extends PointElement {\n /*--------------------------------------------------------------------+\n | Invert the point A in the circle C to get this point |\n +--------------------------------------------------------------------*/\n\n private _A: PointElement;\n private _C: CircleElement;\n\n constructor(A: PointElement, C: CircleElement) {\n super();\n this.dimension = 0;\n this._A = A;\n this._C = C;\n this._AP = C.AP;\n }\n\n public update() {\n this.toInvertPoint(this._A, this._C);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tLayoff.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\n\nexport class Layoff extends PointElement {\n\n // Lay off a line AB with endpoint A given, so that AB is parallel to CD\n // and equal to EF. (this is B)\n\n protected _A : PointElement;\n protected _C : PointElement;\n protected _D : PointElement;\n protected _E : PointElement;\n protected _F : PointElement;\n\n\n constructor(A: PointElement,\n C: PointElement,\n D: PointElement,\n E: PointElement,\n F: PointElement) {\n super();\n this.dimension = 0;\n this._A = A;\n this._C = C;\n this._D = D;\n this._E = E;\n this._F = F;\n if (A.AP == C.AP && A.AP == D.AP) {\n this._AP = A.AP;\n }\n }\n\n public update() {\n let factor : number = this._E.distance(this._F) / this._C.distance(this._D);\n this.to(this._D).minus(this._C);\n this.times(factor).plus(this._A);\n }\n\n}\n","/*----------------------------------------------------------------------+\n| Title:\tLineSlider.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\nimport {PointElement} from \"./PointElement\";\n\nexport class LineSlider extends PointElement {\n _A : PointElement;\n _B : PointElement;\n _initx : number;\n _inity : number;\n _initz : number;\n _segment : boolean;\n\n constructor(A: PointElement, B: PointElement,\n x: number, y: number, z: number, segment: boolean) {\n super();\n this.dimension = 0;\n this.draggable = true;\n this._A = A;\n this._B = B;\n this._x = x;\n this._initx = x;\n this._y = y;\n this._inity = y;\n this._z = z;\n this._initz = z;\n this._segment = segment;\n if(this._A.AP == this._B.AP) this._AP = this._A.AP;\n }\n\n public reset() {\n this._x = this._initx;\n this._y = this._inity;\n this._z = this._initz;\n this.toLine(this._A, this._B, this._segment);\n }\n\n public update() {\n this.toLine(this._A, this._B, this._segment);\n }\n\n public drag(tox: number, toy: number): boolean {\n tox -= this._A.x;\n toy -= this._A.y;\n let dx : number = this._B.x - this._A.x;\n let dy : number = this._B.y - this._A.y;\n let factor : number = (tox*dx + toy*dy)/(dx*dx + dy*dy);\n if (this._segment) {\n if (factor < 0.0) factor = 0.0;\n else if (factor > 1.0) factor = 1.0;\n }\n tox = this._A.x + dx*factor;\n toy = this._A.y + dy*factor;\n if ((tox-this._x)*(tox-this._x) + (tox-this._y)*(tox-this._y) < 0.5) return false;\n // now drag this point\n this._x = tox;\n this._y = toy;\n this._z = this._A.z + (this._B.z-this._A.z)*factor;\n return true;\n }\n}","/*----------------------------------------------------------------------+\n| Title:\tMeanProportionalElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\n\nexport class MeanProportionalElement extends PointElement {\n /*--------------------------------------------------------------------+\n | Given lines S,T,U cut off from U a mean proportional U' so that |\n | S:U'=U':T |\n +--------------------------------------------------------------------*/\n\n private _S0: PointElement;\n private _S1: PointElement;\n private _T0: PointElement;\n private _T1: PointElement;\n private _U0: PointElement;\n private _U1: PointElement;\n\n constructor(S0: PointElement, S1: PointElement, T0: PointElement,\n T1: PointElement, U0: PointElement, U1: PointElement) {\n super();\n this.dimension = 0;\n this._S0 = S0; this._S1 = S1;\n this._T0 = T0; this._T1 = T1;\n this._U0 = U0; this._U1 = U1;\n if (U0._AP === U1._AP) {\n this._AP = U0._AP;\n }\n }\n\n public update() {\n let factor : number = Math.sqrt(this._S0.distance2(this._S1) * this._T0.distance2(this._T1));\n factor = Math.sqrt(factor / this._U0.distance2(this._U1));\n this.to(this._U1).minus(this._U0);\n this.times(factor).plus(this._U0);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tMidpoint.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\nimport {PointElement} from \"./PointElement\";\n\nexport class Midpoint extends PointElement {\n _A : PointElement;\n _B : PointElement;\n\n constructor(A: PointElement, B: PointElement) {\n super();\n this.dimension = 0;\n this._A = A;\n this._B = B;\n if (this._A.AP == this._B.AP) {\n this._AP = this._A.AP;\n }\n }\n\n public update() : void {\n this._x = (this._A.x + this._B.x) / 2.0;\n this._y = (this._A.y + this._B.y) / 2.0;\n this._z = (this._A.z + this._B.z) / 2.0;\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPlaneFootElement.ts |\n| Originally: PlaneFoot.java (renamed for clarity) |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class PlaneFootElement extends PointElement {\n // foot of perpendicular from point A to the ambient plane AP\n\n private _A: PointElement;\n\n constructor(A: PointElement, P: PlaneElement) {\n super();\n this.dimension = 0;\n this._A = A;\n this._AP = P;\n }\n\n public update() {\n this.to(this._A).toPlane(this._AP);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPlaneIntersection.ts |\n| Originally: IntersectionPL.java (renamed for clarity) |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n| |\n| NOTE: This file was previously a copy of Intersection.ts |\n| (line-line intersection). Rewritten 2026-04-12 to implement the |\n| actual plane-line intersection via toIntersectionPL(). |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class PlaneIntersection extends PointElement {\n // this point is the intersection of the ambient plane AP and the line AB\n\n private _A: PointElement;\n private _B: PointElement;\n\n constructor(AP: PlaneElement, A: PointElement, B: PointElement) {\n super();\n this.dimension = 0;\n this._A = A;\n this._B = B;\n this._AP = AP;\n }\n\n update(): void {\n this.toIntersectionPL(this._AP, this._A, this._B);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPlaneSlider.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\nimport {PointElement} from \"./PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class PlaneSlider extends PointElement {\n\n // this point can be dragged anywhere on the ambient plane AP\n\n protected _initx : number;\n protected _inity : number;\n protected _initz : number;\n\n protected _newP : PointElement = new PointElement();\n\n constructor(Qval : PlaneElement, xVal : number, yVal : number, zVal : number) {\n super();\n this.dimension = 0;\n this.draggable = true;\n this._AP = Qval;\n this._x = this._initx = xVal;\n this._y = this._inity = yVal;\n this._z = this._initz = zVal;\n }\n\n public update() : void {\n this.toPlane(this._AP);\n }\n\n public reset() : void {\n this._x = this._initx;\n this._y = this._inity;\n this._z = this._initz;\n this.toPlane(this._AP);\n }\n\n public drag(tox : number, toy : number) : boolean {\n this._x = tox;\n this._y = toy;\n if (!this.defined()) { this._z = this._initz; }\n this._newP.to(this).uptoPlane(this._AP);\n if(this._newP.defined()) {\n this.to(this._newP);\n } else {\n this.toPlane(this._AP);\n }\n\n return true;\n }\n\n\n\n}\n","// Animations targeting PointElement. See ../Animations.ts for the\n// abstract base + registry mechanics.\n\nimport {Animation, AllAnimations, IAnimationStep, registerAnimation} from \"../Animations\";\nimport {GeomElement} from \"../GeomElement\";\nimport {Slate} from \"../../Slate\";\nimport {PointElement} from \"./PointElement\";\nimport {LineSlider} from \"./LineSlider\";\n\n// A.Point.appear — the marker radius scales from 0 to its final value\n// over a short duration. Args: none. Used as the simplest reveal for a\n// point that lands at a constructed position (e.g. Joyce's \"point C at\n// which the circles cut\").\nexport class PointAppearAnimation extends Animation {\n public animationMethod = AllAnimations.POINT_APPEAR;\n public name = \"Point.appear\";\n public elementType = PointElement;\n public defaultDurationMs = 350;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n return [{\n durationMs: this.defaultDurationMs,\n tick: (progress) => {\n target.drawProgress = progress;\n },\n finalise: () => {\n target.drawProgress = 1;\n target.visible = true;\n },\n }];\n }\n}\n\n// A.Point.slide — glide a slider point along its line to a target\n// (the scripted counterpart of a reader dragging it). The point really\n// travels its constraint and its dependents follow.\n//\n// Args (one of):\n// { to: number } — a target parameter along A→B (0 = A, 1 = B;\n// for a segment slider it's clamped to [0,1] by\n// the slider's own projection). Default 1.\n// { to: \"E\" } / { toElement: \"E\" } — a target ELEMENT (#122). At setup\n// the named point is resolved via lookupElement,\n// projected onto the slider's line (nearest point,\n// clamped to the segment domain), and the slider\n// glides there. Resolved at runtime, so it tracks\n// a derived point (e.g. an intersection) even after\n// the reader drags the givens. A non-resolvable /\n// non-point name warns and stays put.\n// Optional durationMs; default ~ a standard transition glide.\n//\n// elementType is LineSlider — covers both `lineSlider` and\n// `lineSegmentSlider`. A non-slider target warns + falls through to\n// instant (the registry contract).\nexport class PointSlideAnimation extends Animation {\n public animationMethod = AllAnimations.POINT_SLIDE;\n public name = \"Point.slide\";\n public elementType = LineSlider;\n public defaultDurationMs = 650;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const slider = target as LineSlider;\n const toNum = args && typeof args.to === \"number\" ? args.to : null;\n // A string `to` (or the explicit `toElement`) names a target point.\n const toName: string | null = args\n ? (typeof args.to === \"string\" ? args.to\n : (typeof args.toElement === \"string\" ? args.toElement : null))\n : null;\n // Start + target positions are captured at setup time (after\n // any earlier-slide motion has settled), both on the line A→B,\n // so the lerp between them stays collinear and the slider's own\n // re-projection in update() is a no-op.\n let sx = 0, sy = 0, sz = 0; // start\n let tx = 0, ty = 0, tz = 0; // target = A + factor·(B−A)\n const apply = (p: number) => {\n slider.x = sx + (tx - sx) * p;\n slider.y = sy + (ty - sy) * p;\n slider.z = sz + (tz - sz) * p;\n // Drive dependents from the new position this frame.\n slate.update();\n };\n return [{\n durationMs: this.defaultDurationMs,\n setup: () => {\n // A slide is not a reveal — the point is already on\n // stage; undo the animator's reveal pre-zeroing.\n slider.drawProgress = 1;\n slider.visible = true;\n sx = slider.x; sy = slider.y; sz = slider.z;\n const A = (slider as any)._A as PointElement;\n const B = (slider as any)._B as PointElement;\n const segment = !!(slider as any)._segment;\n const dx = B.x - A.x, dy = B.y - A.y, dz = B.z - A.z;\n // factor along A→B that the slider will lerp to.\n let factor: number;\n if (toName != null) {\n // Resolve the target element and project it onto the line.\n const tgt = slate.lookupElement(toName) as PointElement;\n if (tgt == null || !(tgt instanceof PointElement)) {\n // #154 — was the one site with no typeof-console\n // guard; reportDiagnostic owns that check now.\n slate.reportDiagnostic({\n code: \"unresolvable-target\",\n key: \"Point.slide|\" + String(toName),\n message: `Point.slide: target \"${toName}\" is not a resolvable point — staying put`,\n detail: { animation: \"Point.slide\", to: String(toName) },\n });\n tx = sx; ty = sy; tz = sz;\n return;\n }\n const denom = dx * dx + dy * dy + dz * dz;\n factor = denom > 1e-9\n ? ((tgt.x - A.x) * dx + (tgt.y - A.y) * dy + (tgt.z - A.z) * dz) / denom\n : 0;\n if (segment) factor = Math.max(0, Math.min(1, factor));\n } else {\n factor = toNum != null ? toNum : 1;\n }\n tx = A.x + dx * factor;\n ty = A.y + dy * factor;\n tz = A.z + dz * factor;\n },\n tick: (progress) => { apply(progress); },\n finalise: () => {\n apply(1);\n slider.drawProgress = 1;\n slider.visible = true;\n },\n }];\n }\n}\n\nregisterAnimation(new PointAppearAnimation());\nregisterAnimation(new PointSlideAnimation());\n","/*----------------------------------------------------------------------+\n| Point construction classes — extracted from Constructions.ts |\n| Each class maps a (type, constructionName, signature) triple to |\n| a construct() method that creates the geometry element. |\n+----------------------------------------------------------------------*/\n\nimport {Construction, ConstructionSignature, SortedParams, AllConstructions, PointConstructions,\n CircleConstructions, GeomElementsForUpdate} from \"../Constructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {CircumcircleElement} from \"../circle/CircumcircleElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"./PointElement\";\nimport {FixedPoint} from \"./FixedPoint\";\nimport {PlaneSlider} from \"./PlaneSlider\";\nimport {Midpoint} from \"./Midpoint\";\nimport {Intersection} from \"./Intersection\";\nimport {PlaneIntersection} from \"./PlaneIntersection\";\nimport {LineSlider} from \"./LineSlider\";\nimport {Layoff} from \"./Layoff\";\nimport {Foot} from \"./Foot\";\nimport {PlaneFootElement} from \"./PlaneFootElement\";\nimport {CircleSlider} from \"./CircleSlider\";\nimport {SimilarElement} from \"./SimilarElement\";\nimport {ProportionElement} from \"./ProportionElement\";\nimport {AngleDividerElement} from \"./AngleDividerElement\";\nimport {MeanProportionalElement} from \"./MeanProportionalElement\";\nimport {HarmonicElement} from \"./HarmonicElement\";\nimport {InvertPointElement} from \"./InvertPointElement\";\nimport {SphereSliderElement} from \"./SphereSliderElement\";\nimport {Perpendicular} from \"../line/Perpendicular\";\nimport {PlanePerpendicularLine} from \"../line/PlanePerpendicularLine\";\nimport {SphereElement} from \"../sphere/SphereElement\";\nimport {PolygonElement} from \"../polygon/PolygonElement\";\n\n/***********************\n * Element Class Point *\n ***********************/\n\n/* point\n * free\n * integers x, y\n * a freely dragable point in the screen plane with initial coordinates (x,y,0)\n * (Java: Slate.java point case 0 — new PlaneSlider(screen, x, y, 0))\n */\nexport class FreePointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.free;\n signature: ConstructionSignature = { points: 0, elements: 0, integers: 2 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new PlaneSlider(screen, N[0], N[1], 0);\n\n return [[g], g];\n }\n\n}\n\n// point\n// midpoint\n// points A, B\n// the midpoint of a line AB\n// (Java: Slate.java point case 1 — new Midpoint(A, B))\nexport class MidPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.midpoint;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new Midpoint(P[0], P[1]);\n\n return [[g], g];\n }\n}\n\n// point\n// intersection\n// points A, B, C, D [, plane E = screen]\n// the intersection of two lines AB and CD in the plane E\n// (Java: Slate.java point case 2 — new Intersection(A,B,C,D,E))\nexport class IntersectionConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.intersection;\n signature: ConstructionSignature = { points: 4, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 4 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new Intersection(P[0], P[1], P[2], P[3], plane);\n return [[g], g];\n }\n}\n\n// point\n// intersection (plane-line variant)\n// plane A, points B, C\n// the intersection of the plane A and the line BC\n// (Java: IntersectionPL.java — TS: PlaneIntersection.ts, renamed for clarity)\nexport class PlaneIntersectionConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.intersection;\n signature: ConstructionSignature = { points: 2, elements: 1, integers: 0, elementTypes: [PlaneElement] };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new PlaneIntersection(E[0] as PlaneElement, P[0], P[1]);\n return [[g], g];\n }\n}\n\n// point\n// first\n// points A, B\n// the first end A of the line AB\n// (Java: Slate.java point case 3 — returns P[0], preexists=true)\nexport class FirstPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.first;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n return [[], P[0]];\n }\n\n}\n\n// point\n// last\n// points A, B\n// the last end B of the line AB\n// (Java: Slate.java point case 4 — returns P[1], preexists=true)\nexport class LastPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.last;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n return [[], P[1]];\n }\n}\n\n// point\n// center\n// circle A\n// the center of the circle A\n// (Java: Slate.java point case 5, choice 0 — returns ((CircleElement)E[0]).Center)\nexport class CircleCenterConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.center;\n signature: ConstructionSignature = { points: 0, elements: 1, integers: 0, elementTypes: [CircleElement] };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n return [[], (E[0] as CircleElement).Center as PointElement];\n }\n}\n\n// point\n// center (sphere variant)\n// sphere A\n// the center of the sphere A\n// (Java: Slate.java point case 5, choice 1 — returns ((SphereElement)E[0]).Center)\nexport class SphereCenterConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.center;\n signature: ConstructionSignature = { points: 0, elements: 1, integers: 0, elementTypes: [SphereElement] };\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n return [[], (E[0] as SphereElement).Center as PointElement];\n }\n}\n\n// point\n// lineSlider\n// points A, B, integers x, y, [z=0]\n// a point that slides along a line AB with initial coordinates (x,y,z)\n// (Java: Slate.java point case 6 — new LineSlider(A,B,x,y,z,false))\nexport class LineSliderConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.lineSlider;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 2 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 2 && sp.E.length === 0 && (sp.N.length === 2 || sp.N.length === 3);\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = this.createSlider(P[0], P[1], N[0], N[1], N.length > 2 ? N[2] : 0);\n return [[g], g];\n }\n protected createSlider(a: PointElement, b: PointElement, x: number, y: number, z: number) {\n return new LineSlider(a, b, x, y, z, false);\n }\n}\n\n// point\n// circleSlider\n// circle A, integers x, y, [z=0]\n// a point that slides along a circle A with given initial coordinates (x,y,z)\n// (Java: Slate.java point case 7 — new CircleSlider(E[0], x, y, z))\nexport class CircleSliderConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.circleSlider;\n signature: ConstructionSignature = { points: 0, elements: 1, integers: 2, elementTypes: [CircleElement] };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 0 && sp.E.length === 1 && (sp.N.length === 2 || sp.N.length === 3)\n && sp.E[0] instanceof CircleElement;\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new CircleSlider(E[0] as CircleElement, N[0], N[1], N.length > 2 ? N[2] : 0);\n return [[g], g];\n }\n}\n\n// circle\n// circumcircle — points A, B, C [, plane D = screen]\n// the circle passing through 3 points A, B, and C in the plane D\n// (Java: Slate.java circle case 1 — new Circumcircle(A,B,C,D))\nexport class CircumcircleConstruction extends Construction {\n constructionMethod: AllConstructions = CircleConstructions.circumcircle;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new CircumcircleElement(P[0], P[1], P[2], plane);\n return [[g], g];\n }\n}\n\n// point\n// circumcenter — points A, B, C [, plane D = screen]\n// the center of a circle ABC passing through 3 points A, B, and C in the plane D\n// (Java: Slate.java point case 8 — new Circumcircle(A,B,C,D), returns circ.Center)\nexport class CircumcenterConstruction extends CircumcircleConstruction {\n constructionMethod: AllConstructions = PointConstructions.circumcenter;\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let es = super.construct(screen, P, E, N);\n let g : CircleElement = es[1] as CircleElement;\n es[0].push(g.Center);\n return [es[0], g.Center];\n }\n}\n\n/* point\n * foot\n * points A, B, C\n * the foot of a perpendicular drawn from A to a line BC\n */\n// (Java: Slate.java point case 10, choice 0 — new Foot(A,B,C))\nexport class FootPointConstruction extends Construction {\n constructionMethod : AllConstructions = PointConstructions.foot;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]) : [GeomElementsForUpdate, GeomElement] {\n let g = new Foot(P[0], P[1], P[2]);\n\n return [[g], g];\n }\n}\n\n// point\n// foot (plane variant — solid geometry)\n// point A plane B\n// the foot of a perpendicular drawn from A to a plane B\n// (Java: PlaneFoot.java — TS: PlaneFootElement.ts, renamed for clarity)\nexport class PlaneFootPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.foot;\n signature: ConstructionSignature = { points: 1, elements: 1, integers: 0, elementTypes: [PlaneElement] };\n\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new PlaneFootElement(P[0], E[0] as PlaneElement);\n return [[g], g];\n }\n}\n\n// point\n// layoff used for extend and cutoff\nexport abstract class LayoffConstruction extends Construction {\n signature: ConstructionSignature = { points: 4, elements: 0, integers: 0 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = this._createLayoff(P);\n return [[g], g];\n }\n\n protected abstract _createLayoff(ps: PointElement[]) : GeomElement;\n}\n\n// point\n// cutoff\n// points A, B, C, D\n// the point E on a line AB so that AE = CD\n// (Java: Slate.java point case 11 — new Layoff(A,A,B,C,D))\nexport class CutoffConstruction extends LayoffConstruction {\n constructionMethod: AllConstructions = PointConstructions.cutoff;\n protected _createLayoff(ps: PointElement[]) : GeomElement {\n return new Layoff(ps[0], ps[0], ps[1], ps[2], ps[3]);\n }\n}\n\n// point\n// extend\n// points A, B, C, D\n// the point E on a line AB so that BE = CD\n// (Java: Slate.java point case 12 — new Layoff(B,A,B,C,D))\nexport class ExtendConstruction extends LayoffConstruction {\n constructionMethod: AllConstructions = PointConstructions.extend;\n protected _createLayoff(ps: PointElement[]) : GeomElement {\n return new Layoff(ps[1], ps[0], ps[1], ps[2], ps[3]);\n }\n}\n\n// point\n// parallelogram\n// points C, A, B\n// the 4th vertex D' of the parallelogram C-A-B-D' given 3 vertices C, A, B\n// D' = C + (B - A) [reuses Layoff with equal direction and length vectors]\n// (Java: Slate.java point case 13 — new Layoff(C,A,B,A,B))\nexport class ParallelogramConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.parallelogram;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new Layoff(P[0], P[1], P[2], P[1], P[2]);\n return [[g], g];\n }\n}\n\n// point\n// similar — points A, B, D, E, F [, planes C, G = screen]\n// the point H so that triangle ABH in plane C is similar to triangle DEF in plane G\n// (Java: Slate.java point case 14 — Similar.java)\nexport class SimilarPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.similar;\n signature: ConstructionSignature = { points: 5, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 5 && sp.N.length === 0\n && (sp.E.length === 0 || sp.E.length === 2);\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let c = E.length > 0 ? E[0] as PlaneElement : screen;\n let g2 = E.length > 1 ? E[1] as PlaneElement : screen;\n let g = new SimilarElement(P[0], P[1], c, P[2], P[3], P[4], g2);\n return [[g], g];\n }\n}\n\n// point perpendicular constructions\nexport abstract class PointPerpendicularConstruction extends Construction {\n constructionMethod : AllConstructions = PointConstructions.perpendicular;\n}\n\n\n/* point\n * perpendicular\n * points A, B, [plane C (screen)]\n * the point D so that AD is equal and perpendicular to AB in plane C\n * (Java: Slate.java point case 15, choice 0 — new Perpendicular(A,B,screen,A,B))\n */\nexport class PointPerpendicular1Construction extends PointPerpendicularConstruction {\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new Perpendicular({C:P[0], D:P[1],P:screen, E:P[0], F:P[1]});\n return [[g], g.B];\n }\n}\n\n\n/* point\n * perpendicular\n * points A, B, plane C\n * the point D so that AD is equal and perpendicular to AB in plane C\n * (Java: Slate.java point case 15, choice 1 — new Perpendicular(A,B,C,A,B))\n */\nexport class PointPerpendicular2Construction extends PointPerpendicularConstruction {\n signature: ConstructionSignature = { points: 2, elements: 1, integers: 0, elementTypes: [PlaneElement] };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new Perpendicular({C:P[0], D:P[1],P:E[0] as PlaneElement, E:P[0], F:P[1]});\n return [[g], g.B];\n }\n}\n\n\n/* point\n * perpendicular\n * points A, B, D, E [plane C (screen)]\n * the point F so that AF is perpendicular to AB in plane C and equals DE\n * (Java: Slate.java point case 15, choice 2 — new Perpendicular(A,B,screen,D,E))\n */\nexport class PointPerpendicular3Construction extends PointPerpendicularConstruction {\n signature: ConstructionSignature = { points: 4, elements: 0, integers: 0 };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new Perpendicular({C:P[0], D:P[1],P:screen, E:P[2], F:P[3]});\n return [[g], g.B];\n }\n}\n\n\n/* point\n * perpendicular\n * points A, B, plane C, points D, E\n * the point F so that AF is perpendicular to AB in plane C and equals DE\n * (Java: Slate.java point case 15, choice 3 — new Perpendicular(A,B,C,D,E))\n */\nexport class PointPerpendicular4Construction extends PointPerpendicularConstruction {\n signature: ConstructionSignature = { points: 4, elements: 1, integers: 0, elementTypes: [PlaneElement] };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new Perpendicular({C:P[0], D:P[1],P:E[0] as PlaneElement, E:P[2], F:P[3]});\n return [[g], g.B];\n }\n}\n\n\n/* point\n * perpendicular\n * point A, plane B, points C, D\n * the point E on the line perpendicular to plane B passing through\n * A so that the distance from E to B equals CD\n * (Java: Slate.java point case 15, choice 4 — new PlanePerpendicular(A,B,C,D))\n */\nexport class PointPerpendicular5Construction extends PointPerpendicularConstruction {\n signature: ConstructionSignature = { points: 3, elements: 1, integers: 0, elementTypes: [PlaneElement] };\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new PlanePerpendicularLine({C:P[0], P:E[0] as PlaneElement, D:P[1], E:P[2]});\n return [[g], g.B];\n }\n}\n\n\n// point\n// proportion\n// 8 points S0, S1, T0, T1, U0, U1, V0, V1\n// the point V' on V0V1 so that |S0S1|:|T0T1| = |U0U1|:|V0V'|\n// (Java: Proportion.java — 26 lines, line-for-line port)\nexport class ProportionPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.proportion;\n signature: ConstructionSignature = { points: 8, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new ProportionElement(P[0], P[1], P[2], P[3], P[4], P[5], P[6], P[7]);\n return [[g], g];\n }\n}\n\n// point\n// invert\n// point A circle B\n// the image of a point A inverted in the circle B\n// (Java: InvertPoint.java — 16 lines, calls toInvertPoint(A, C))\nexport class InvertPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.invert;\n signature: ConstructionSignature = { points: 1, elements: 1, integers: 0, elementTypes: [CircleElement] };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new InvertPointElement(P[0], E[0] as CircleElement);\n return [[g], g];\n }\n}\n\n// point\n// meanProportional\n// 6 points S0, S1, T0, T1, U0, U1\n// the point U' on U0U1 so that S:U' = U':T (geometric mean)\n// (Java: MeanProportional.java — 23 lines, line-for-line port)\nexport class MeanProportionalPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.meanProportional;\n signature: ConstructionSignature = { points: 6, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new MeanProportionalElement(P[0], P[1], P[2], P[3], P[4], P[5]);\n return [[g], g];\n }\n}\n\n// point\n// planeSlider\n// plane A integers x, y, z\n// a point that slides on the plane A with initial coordinates (x,y,z)\n// (Java: Slate.java point case 19 — new PlaneSlider((PlaneElement)E[0], N[0], N[1], N[2]).\n// PlaneSlider.ts already has the full constructor + update() + drag().)\nexport class PlaneSliderConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.planeSlider;\n signature: ConstructionSignature = { points: 0, elements: 1, integers: 3, elementTypes: [PlaneElement] };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new PlaneSlider(E[0] as PlaneElement, N[0], N[1], N[2]);\n return [[g], g];\n }\n}\n\n// point\n// sphereSlider\n// sphere A integers x, y, z\n// a point that slides on the sphere A with initial coordinates (x,y,z)\n// (Java: SphereSlider.java — 43 lines, line-for-line port)\nexport class SphereSliderConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.sphereSlider;\n signature: ConstructionSignature = { points: 0, elements: 1, integers: 3, elementTypes: [SphereElement] };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new SphereSliderElement(E[0] as SphereElement, N[0], N[1], N[2]);\n return [[g], g];\n }\n}\n\n// point\n// angleBisector — points B, A, C [, plane D = screen]\n// bisect angle BAC — the point on BC where the bisector from A meets BC\n// (Java: AngleDivider.java with n=2, Slate.java point case 21)\nexport class AngleBisectorPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.angleBisector;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new AngleDividerElement(P[0], P[1], P[2], plane, 2);\n return [[g], g];\n }\n}\n\n// point\n// angleDivider — points B, A, C, integer n [, plane D = screen]\n// n-sect angle BAC — the point on BC where the 1/n ray from A meets BC\n// (Java: AngleDivider.java with variable n, Slate.java point case 22)\nexport class AngleDividerPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.angleDivider;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 1 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 1\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new AngleDividerElement(P[0], P[1], P[2], plane, N[0]);\n return [[g], g];\n }\n}\n\n// point\n// fixed\n// integers x, y [, z=0]\n// the fixed point with coordinates (x, y, z). z defaults to 0 if not provided.\n// (Java: Slate.java point case 23 — new FixedPoint(x,y,z))\nexport class FixedPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.fixed;\n signature: ConstructionSignature = { points: 0, elements: 0, integers: 2 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 0 && sp.E.length === 0 && (sp.N.length === 2 || sp.N.length === 3);\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new FixedPoint({x:N[0], y:N[1], z: N.length > 2 ? N[2] : 0});\n return [[g], g];\n }\n}\n\n// point\n// lineSegmentSlider\n// points A, B, integers x, y, [z]\n// a point that slides along within the line segment AB with initial coordinates (x,y,z)\n// (Java: Slate.java point case 24 — new LineSlider(A,B,x,y,z,true))\nexport class LineSliderSegmentConstruction extends LineSliderConstruction {\n constructionMethod: AllConstructions = PointConstructions.lineSegmentSlider;\n protected createSlider(a: PointElement, b: PointElement, x: number, y: number, z: number) {\n return new LineSlider(a, b, x, y, z, true);\n }\n}\n\n\n// point\n// harmonic\n// points B, C, D\n// the harmonic conjugate of B with respect to C and D\n// (Java: Harmonic.java — 43 lines, line-for-line port.\n// Slate.java point case 25 — new Harmonic(P[0], P[1], P[2]))\nexport class HarmonicPointConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.harmonic;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new HarmonicElement(P[0], P[1], P[2]);\n return [[g], g];\n }\n}\n\n// point\n// vertex\n// polygon A, integer n\n// the nth vertex (1-based) of polygon A\n// (Java: Slate.java point case 9 — returns ((PolygonElement)E[0]).V[n-1])\nexport class VertexConstruction extends Construction {\n constructionMethod: AllConstructions = PointConstructions.vertex;\n signature: ConstructionSignature = { points: 0, elements: 1, integers: 1, elementTypes: [PolygonElement] };\n\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const poly = E[0] as PolygonElement;\n const vertex = poly.V[N[0] - 1];\n return [[vertex], vertex];\n }\n}\n\nexport const pointConstructions: Construction[] = [\n new FreePointConstruction(),\n new FixedPointConstruction(),\n new FirstPointConstruction(),\n new LastPointConstruction(),\n new CircleCenterConstruction(),\n new CircumcenterConstruction(),\n new MidPointConstruction(),\n new IntersectionConstruction(),\n new FootPointConstruction(),\n new PlaneFootPointConstruction(),\n new ExtendConstruction(),\n new CutoffConstruction(),\n new ParallelogramConstruction(),\n new SimilarPointConstruction(),\n new ProportionPointConstruction(),\n new AngleBisectorPointConstruction(),\n new AngleDividerPointConstruction(),\n new MeanProportionalPointConstruction(),\n new PlaneSliderConstruction(),\n new SphereSliderConstruction(),\n new HarmonicPointConstruction(),\n new InvertPointConstruction(),\n new PlaneIntersectionConstruction(),\n new SphereCenterConstruction(),\n new CircumcircleConstruction(),\n new LineSliderConstruction(),\n new LineSliderSegmentConstruction(),\n new CircleSliderConstruction(),\n new PointPerpendicular1Construction(),\n new PointPerpendicular2Construction(),\n new PointPerpendicular3Construction(),\n new PointPerpendicular4Construction(),\n new PointPerpendicular5Construction(),\n new VertexConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tPointElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {GeomElement} from \"../GeomElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {SlateCanvas} from \"../../Slate\";\n\nexport interface IPointElementConstruction {\n x? : number;\n y? : number;\n z? : number;\n AP? : PlaneElement;\n}\n\nexport class PointElement extends GeomElement {\n\n protected _x : number;\n protected _y : number;\n protected _z : number;\n _AP : PlaneElement;\n\n constructor(ip? : IPointElementConstruction) {\n super();\n this.dimension = 0;\n this._x = ip && ip.x || 0;\n this._y = ip && ip.y || 0;\n this._z = ip && ip.z || 0;\n this._AP = ip && ip.AP || null;\n }\n\n get x() { return this._x }\n set x(value: number) { this._x = value }\n get y() { return this._y }\n set y(value: number) { this._y = value }\n get z() { return this._z }\n set z(value: number) { this._z = value }\n\n get AP() { return this._AP; }\n set AP(v : PlaneElement) { this._AP = v; }\n\n\n public defined() : boolean {\n return !isNaN(this._x) && !isNaN(this._y) && !isNaN(this._z)\n && this._x != null && true && this._y != null && true && this._z != null;\n }\n\n to(B : PointElement ) : PointElement {this._x = B._x; this._y = B._y; this._z= B._z; return this;}\n plus(B : PointElement ) : PointElement {this._x += B._x; this._y += B._y; this._z+= B._z; return this;}\n minus(B : PointElement) : PointElement {this._x -= B._x; this._y -= B._y; this._z-= B._z; return this;}\n times(a : number) : PointElement {this._x *= a; this._y *= a; this._z *= a; return this;}\n\n static difference(A : PointElement, B : PointElement) : PointElement {\n return new PointElement({x:A.x-B.x, y:A.y-B.y, z:A.z-B.z, AP: null});\n }\n\n static product(a : number, B : PointElement) : PointElement {\n return new PointElement({x:a*B.x, y:a*B.y, z:a*B.z, AP: null});\n }\n\n static dot(A : PointElement, B : PointElement) : number {\n return A.x * B.x + A.y * B.y + A.z * B.z;\n }\n\n public length2() : number {\n return this._x * this._x + this._y * this._y + this._z * this._z;\n }\n\n public length() : number {\n return Math.sqrt(this.length2());\n }\n\n public distance2(B : PointElement) : number {\n return (this._x-B.x)*(this._x-B.x) +\n (this._y-B.y)*(this._y-B.y) +\n (this._z-B.z)*(this._z-B.z);\n }\n\n public distance(B : PointElement) : number {\n return Math.sqrt(this.distance2(B));\n }\n\n public toCross(A : PointElement, B : PointElement) : PointElement {\n // set to the cross product of A and B\n this._x = A.y*B.z - A.z*B.y;\n this._y = A.z*B.x - A.x*B.z;\n this._z = A.x*B.y - A.y*B.x;\n return this;\n }\n\n public static cross(A: PointElement, B: PointElement) : PointElement {\n // return the cross product of A and B\n return new PointElement({x: A.y*B.z - A.z*B.y,\n y: A.z*B.x - A.x*B.z,\n z: A.x*B.y - A.y*B.x,\n AP: null});\n }\n\n public static triple(A: PointElement, B: PointElement, C: PointElement) : number {\n // return the triple product of A, B, and C\n return A.x*(B.y*C.z - B.z*C.y) +\n B.x*(C.y*A.z - C.z*A.y) +\n C.x*(A.y*B.z - A.z*B.y);\n }\n\n toLine(A: PointElement, B: PointElement, segment: boolean) : PointElement{\n /*---------------------------------------------------------------------+\n | Project this point to the foot of the perpendicular from it to the |\n | line determined by the points A and B. If A were the origin, then |\n | the foot would be at ((this dot B)/B^2) B. When segment is true |\n | and the foot is beyond A or B, then move the point to the closer |\n | of A and B. |\n +---------------------------------------------------------------------*/\n let V : PointElement = PointElement.difference(B,A);\n this.minus(A);\n let factor : number= PointElement.dot(V,this)/V.length2();\n if (segment) {\n if (factor < 0.0) factor = 0.0;\n else if (factor > 1.0) factor = 1.0;\n }\n V.times(factor);\n return this.to(V).plus(A);\n }\n\n\n public toPlane (P : PlaneElement) : PointElement {\n /*---------------------------------------------------------------------+\n | Project this point to the foot of the perpendicular from it to the |\n | plane P. |\n +---------------------------------------------------------------------*/\n if (P.isScreen) {\n this._z = 0.0;\n } else {\n this.minus(P.A);\n let s : number = PointElement.dot(this, P.S);\n let t = PointElement.dot(this, P.T);\n this.to(P.S).times(s).plus(PointElement.product(t,P.T)).plus(P.A);\n }\n return this;\n }\n\n uptoPlane(P : PlaneElement) : PointElement {\n /*---------------------------------------------------------------------+\n | Project this point to the point on the plane P where the vertical |\n | line through this meets P. |\n +---------------------------------------------------------------------*/\n if (P.isScreen) {\n this._z = 0.0;\n } else {\n this.minus(P.A);\n let den : number = P.S.x*P.T.y - P.S.y*P.T.x;\n let s : number = (this.x*P.T.y - this.y*P.T.x) / den;\n let t : number = (this.y*P.S.x - this.x*P.S.y) / den;\n this.to(P.S).times(s).plus(PointElement.product(t,P.T)).plus(P.A);\n }\n return this;\n }\n\n\n toCircumcenter (A: PointElement, B: PointElement, C: PointElement) : PointElement{\n /*---------------------------------------------------------------------+\n | Move this point to the center of the circle passing through the |\n | points A, B, and C. |\n +---------------------------------------------------------------------*/\n if (A.z == 0.0 && B.z == 0.0 && C.z == 0.0) {\n let u : number = ((A.x-B.x)*(A.x+B.x) + (A.y-B.y)*(A.y+B.y)) / 2.0;\n let v : number = ((B.x-C.x)*(B.x+C.x) + (B.y-C.y)*(B.y+C.y)) / 2.0;\n let den : number = (A.x-B.x)*(B.y-C.y) - (B.x-C.x)*(A.y-B.y);\n this._x = (u * (B.y-C.y) - v*(A.y-B.y)) / den;\n this._y = (v * (A.x-B.x) - u*(B.x-C.x)) / den;\n this._z = 0.0;\n } else {\n let BmA : PointElement = PointElement.difference(B,A)\n let CmA : PointElement = PointElement.difference(C,A);\n let BC : number = PointElement.dot(BmA,CmA);\n let B2 : number = BmA.length2();\n let C2 : number = CmA.length2();\n //double BC2 = BC*BC;\n let den : number = 2.0*(B2*C2-BC*BC);\n let s : number = C2*(B2-BC)/den;\n let t : number = B2*(C2-BC)/den;\n this.to(A).plus(BmA.times(s)).plus(CmA.times(t));\n }\n return this;\n }\n\n toCircle (C: CircleElement) : PointElement {\n /*---------------------------------------------------------------------+\n | Move this point to the nearest point on the circle C. |\n +---------------------------------------------------------------------*/\n if (C.AP.isScreen) {\n let factor : number = C.radius / this.distance(C.Center);\n this._x = C.Center.x + factor*(this._x - C.Center.x);\n this._y = C.Center.y + factor*(this._y - C.Center.y);\n this._z = 0.0;\n } else { // 3d case: project to plane of circle then move to sphere of circle\n this.toPlane(C.AP);\n this.toSphere(C.Center,C.radius);\n }\n return this;\n }\n\n toSphere (Center : PointElement, radius : number) : PointElement{\n /*---------------------------------------------------------------------+\n | Move this point to the nearest point on the sphere S. |\n +---------------------------------------------------------------------*/\n let factor : number = radius / this.distance(Center);\n this._x = Center.x + factor*(this._x - Center.x);\n this._y = Center.y + factor*(this._y - Center.y);\n this._z = Center.z + factor*(this._z - Center.z);\n return this;\n }\n\n public static area(A: PointElement, B: PointElement, C: PointElement) {\n // return the area of the triangle ABC\n let U : PointElement = PointElement.difference(B,A);\n let V : PointElement = PointElement.difference(C,A);\n return this.cross(U,V).length()/2.0;\n }\n\n public angle(B: PointElement, C: PointElement, P: PlaneElement) : number {\n // Determine the angle BAC in the plane P where this is A.\n // The angle lies between -pi and pi (-180 degrees and 180 degrees)\n let Bx : number = B.x - this._x, Cx = C.x - this._x;\n let By : number = B.y - this._y, Cy = C.y - this._y;\n if (P.isScreen) {\n return Math.atan2 (Bx*Cy - By*Cx, Bx*Cx + By*Cy);\n } else { // 3d case. First get P-coordinates for B and C\n let Bz : number = B.z -this._z, Cz = C.z -this._z;\n let Bs : number = Bx * P.S.x + By * P.S.y + Bz * P.S.z;\n let Bt : number = Bx * P.T.x + By * P.T.y + Bz * P.T.z;\n let Cs : number = Cx * P.S.x + Cy * P.S.y + Cz * P.S.z;\n let Ct : number = Cx * P.T.x + Cy * P.T.y + Cz * P.T.z;\n return Math.atan2(Bs * Ct - Bt * Cs, Bs * Cs + Bt * Ct);\n }\n }\n\n toIntersection (\n A: PointElement,\n B: PointElement,\n C: PointElement,\n D: PointElement,\n P: PlaneElement) : PointElement {\n if (P.isScreen) {\n // move this point to where the two lines AB and CD meet\n let d0 : number = A.x*B.y - A.y*B.x;\n let d1 : number = C.x*D.y - C.y*D.x;\n let den : number = (B.y-A.y)*(C.x-D.x) - (A.x-B.x)*(D.y-C.y);\n this._x = (d0*(C.x-D.x) - d1*(A.x-B.x)) / den;\n this._y = (d1*(B.y-A.y) - d0*(D.y-C.y)) / den;\n } else { // 3d case\n let AmA : PointElement = PointElement.difference(A,P.A);\n let BmA : PointElement = PointElement.difference(B,P.A);\n let CmA : PointElement = PointElement.difference(C,P.A);\n let DmA : PointElement = PointElement.difference(D,P.A);\n let Ax = PointElement.dot(AmA,P.S);\n let Ay = PointElement.dot(AmA,P.T);\n let Bx = PointElement.dot(BmA,P.S);\n let By = PointElement.dot(BmA,P.T);\n let Cx = PointElement.dot(CmA,P.S);\n let Cy = PointElement.dot(CmA,P.T);\n let Dx = PointElement.dot(DmA,P.S);\n let Dy = PointElement.dot(DmA,P.T);\n let d0 = Ax*By - Ay*Bx;\n let d1 = Cx*Dy - Cy*Dx;\n let den = (By-Ay)*(Cx-Dx) - (Ax-Bx)*(Dy-Cy);\n let s = (d0*(Cx-Dx) - d1*(Ax-Bx)) / den;\n let t = (d1*(By-Ay) - d0*(Dy-Cy)) / den;\n this.to(P.S).times(s).plus(PointElement.product(t,P.T)).plus(P.A);\n }\n return this;\n }\n\n toIntersectionPL (\n P: PlaneElement,\n D: PointElement,\n E: PointElement) : PointElement {\n // move this point to where the plane P meets the line DE\n this.to(E).minus(D);\n let DmA : PointElement = PointElement.difference(D,P.A);\n let u : number = -PointElement.triple(P.S,P.T,DmA)\n / PointElement.triple(P.S,P.T,this);\n return this.times(u).plus(D);\n }\n\n toInvertPoint (A: PointElement, C: CircleElement) : PointElement {\n // move this point to the inversion of the point A in the circle C\n let factor : number = C.radius2 / A.distance2(C.Center);\n return this.to(A).minus(C.Center).times(factor).plus(C.Center);\n }\n\n toSimilar (\n A: PointElement,\n B: PointElement,\n P : PlaneElement,\n D: PointElement,\n E: PointElement,\n F: PointElement,\n Q: PlaneElement) : PointElement {\n // move this point to the location C so that triangle ABC is similar\n // to triangle DEF.\n let theta : number = D.angle(E,F,Q);\n let co : number = Math.cos(theta), si : number = Math.sin(theta);\n let factor : number = D.distance(F) / D.distance(E);\n if (P.isScreen) {\n this._x = B.x;\n this._y = B.y;\n this.rotate(A,co,si,P);\n this._x = A.x + factor*(this._x - A.x);\n this._y = A.y + factor*(this._y - A.y);\n this._z = 0.0;\n } else {\n let BmA : PointElement = PointElement.difference(B,A);\n let s : number = PointElement.dot(BmA,P.S);\n let t : number = PointElement.dot(BmA,P.T);\n let ss : number = factor*(co*s - si*t);\n let tt : number = factor*(si*s + co*t);\n this._x = ss*P.S.x + tt*P.T.x + A.x;\n this._y = ss*P.S.y + tt*P.T.y + A.y;\n this._z = ss*P.S.z + tt*P.T.z + A.z;\n }\n return this;\n }\n\n public rotate ( pivot : PointElement,\n ac : number,\n as : number,\n plane?: PlaneElement) : void {\n /*--------------------------------------------------------------------------+\n | Scale and rotate this point around the axis through the pivot and\t\t|\n | perpendicular to the plane. Scale by a factor of a, and rotate by the\t|\n | angle theta where ac = a cos theta, and as = a sin theta.\t\t\t|\n +--------------------------------------------------------------------------*/\n if (plane == null) plane = pivot._AP;\n if (this == pivot) return;\n if (plane.isScreen) {\n let dx : number = this.x - pivot.x;\n let dy : number = this.y - pivot.y;\n this._x = pivot.x + ac*dx - as*dy;\n this._y = pivot.y + as*dx + ac*dy;\n } else {\n this.minus(pivot);\n let S : PointElement = plane.S;\n let T : PointElement = plane.T;\n let U : PointElement = plane.U;\n let s : number = PointElement.dot(this,S);\n let t : number = PointElement.dot(this,T);\n let z1 : number = PointElement.dot(this,U);\n let x1 : number = ac*s - as*t;\n let y1 : number = as*s + ac*t;\n this._x = pivot.x + x1*S.x + y1*T.x + z1*U.x;\n this._y = pivot.y + x1*S.y + y1*T.y + z1*U.y;\n this._z = pivot.z + x1*S.z + y1*T.z + z1*U.z;\n }\n }\n\n public drawName(c: SlateCanvas): void {\n // A point shows its dot/label only when it is actually revealed\n // (visible). Highlight / emphasis style a SHOWN point — they must not\n // force a hidden one to draw: a deferred reveal target (visible=false\n // until its appear step flips it true) or a point not in the slide's\n // visible set must stay dark even when it is in the highlighted set.\n // (#126; the dot's radius already zeroes at drawProgress=0, but the\n // label had no such guard.)\n if (!this.visible) return;\n // The label snaps in only once the marker is fully revealed: through a\n // Point.appear pulse (drawProgress 0→1) the dot grows, then the label\n // lands at completion — it does not ride the pulse. Static points are\n // drawProgress = 1, so this is a no-op for them. (#126)\n if (this.drawProgress < 1) return;\n if (this.nameColor != null && this.name != null && this.defined()) {\n this.drawString(Math.round(this.x), Math.round(this.y), c)\n }\n }\n\n public drawVertex(c: SlateCanvas, color?: string): void {\n if (!this.visible) return; // see drawName — highlight never reveals a hidden point (#126)\n let ctx : CanvasRenderingContext2D = c.getContext(\"2d\") as CanvasRenderingContext2D;\n if (color == null) {\n if (this.emphasized || this.shouldHighlight) {\n color = this.vertexHighlightColor;\n } else {\n color = this.vertexColor;\n }\n }\n if (color == null) return;\n // Radius interpolates by emphasisAmount: baseline 2 (normal) or\n // 4 (highlight) → 6 at full emphasis. drawProgress then scales\n // the result so A.Point.appear can pulse the marker in from 0.\n const baseR = this.shouldHighlight ? 4 : 2;\n let r = baseR + this.emphasisAmount * (6 - baseR);\n r *= this.drawProgress * GeomElement.styleScale; // constant on-screen dot under fit-scale (#71)\n if (r < 0.5) return; // avoid degenerate sub-pixel arcs\n ctx.beginPath();\n ctx.fillStyle = color;\n ctx.arc(this._x, this._y, r, 0, 2*Math.PI, false);\n ctx.fill();\n }\n\n\n public translate(dx: number, dy: number): void {\n this._x += dx;\n this._y += dy;\n }\n\n public update(): void {\n }\n\n public drawEdge(c: SlateCanvas): void {\n }\n\n public drawFace(c: SlateCanvas): void {\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tProportionElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\n\nexport class ProportionElement extends PointElement {\n /*--------------------------------------------------------------------+\n | Given lines S(S0,S1), T(T0,T1), U(U0,U1), V(V0,V1), cut off from |\n | V a fourth proportional V' so that S:T = U:V'. |\n +--------------------------------------------------------------------*/\n\n private _S0: PointElement;\n private _S1: PointElement;\n private _T0: PointElement;\n private _T1: PointElement;\n private _U0: PointElement;\n private _U1: PointElement;\n private _V0: PointElement;\n private _V1: PointElement;\n\n constructor(S0: PointElement, S1: PointElement, T0: PointElement,\n T1: PointElement, U0: PointElement, U1: PointElement,\n V0: PointElement, V1: PointElement) {\n super();\n this.dimension = 0;\n this._S0 = S0; this._S1 = S1;\n this._T0 = T0; this._T1 = T1;\n this._U0 = U0; this._U1 = U1;\n this._V0 = V0; this._V1 = V1;\n if (V0._AP === V1._AP) {\n this._AP = V0._AP;\n }\n }\n\n public update() {\n let factor : number = this._T0.distance2(this._T1) * this._U0.distance2(this._U1)\n / (this._S0.distance2(this._S1) * this._V0.distance2(this._V1));\n factor = Math.sqrt(factor);\n this.to(this._V1).minus(this._V0);\n this.times(factor).plus(this._V0);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tSimilarElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class SimilarElement extends PointElement {\n /*--------------------------------------------------------------------+\n | Construct a triangle AB(this) in the plane AP similar to the |\n | triangle DEF in the plane Q. |\n +--------------------------------------------------------------------*/\n\n private _parentA: PointElement;\n private _parentB: PointElement;\n private _D: PointElement;\n private _E: PointElement;\n private _F: PointElement;\n private _Q: PlaneElement;\n\n constructor(A: PointElement, B: PointElement, AP: PlaneElement,\n D: PointElement, E: PointElement, F: PointElement,\n Q: PlaneElement) {\n super();\n this.dimension = 0;\n this._parentA = A;\n this._parentB = B;\n this._AP = AP;\n this._D = D;\n this._E = E;\n this._F = F;\n this._Q = Q;\n }\n\n public update() {\n this.toSimilar(this._parentA, this._parentB, this._AP,\n this._D, this._E, this._F, this._Q);\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tSphereSliderElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PointElement} from \"./PointElement\";\nimport {SphereElement} from \"../sphere/SphereElement\";\n\nexport class SphereSliderElement extends PointElement {\n\n private _S: SphereElement;\n private _initx: number;\n private _inity: number;\n private _initz: number;\n\n constructor(S: SphereElement, x: number, y: number, z: number) {\n super();\n this.dimension = 0;\n this.draggable = true;\n this._S = S;\n this._x = this._initx = x;\n this._y = this._inity = y;\n this._z = this._initz = z;\n }\n\n public reset() {\n this._x = this._initx;\n this._y = this._inity;\n this._z = this._initz;\n this.toSphere(this._S.Center, this._S.radius());\n }\n\n public update() {\n this.toSphere(this._S.Center, this._S.radius());\n }\n\n public drag(tox: number, toy: number): boolean {\n let dist2 = (this._S.Center.x - tox) * (this._S.Center.x - tox)\n + (this._S.Center.y - toy) * (this._S.Center.y - toy);\n let r2 = this._S.radius2();\n if (dist2 <= r2) {\n this._x = tox;\n this._y = toy;\n if (this._z > this._S.Center.z)\n this._z = this._S.Center.z + Math.sqrt(r2 - dist2);\n else\n this._z = this._S.Center.z - Math.sqrt(r2 - dist2);\n } else {\n // beyond shadow of sphere\n tox -= this._S.Center.x;\n toy -= this._S.Center.y;\n let factor = Math.sqrt((tox * tox + toy * toy) / r2);\n tox = tox / factor + this._S.Center.x;\n toy = toy / factor + this._S.Center.y;\n if ((tox - this._x) * (tox - this._x) + (toy - this._y) * (toy - this._y) < 0.5)\n return false;\n this._x = tox;\n this._y = toy;\n this._z = this._S.Center.z;\n }\n return true;\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tApplicationElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PolygonElement} from \"./PolygonElement\";\nimport {PointElement} from \"../point/PointElement\";\n\nexport class ApplicationElement extends PolygonElement {\n /*--------------------------------------------------------------------+\n | Apply a polygon P to get a parallelogram |\n | with a side AB in an angle CAB |\n +--------------------------------------------------------------------*/\n\n private _P: PolygonElement;\n private _C: PointElement;\n\n constructor(P: PolygonElement, A: PointElement, B: PointElement, C: PointElement) {\n super();\n this.dimension = 2;\n this._P = P;\n this._C = C;\n this.V = new Array(4);\n this.V[0] = A;\n this.V[1] = B;\n this.V[2] = new PointElement();\n this.V[3] = new PointElement();\n if (A._AP === B._AP && A._AP === C._AP) {\n this.V[2]._AP = A._AP;\n this.V[3]._AP = A._AP;\n }\n }\n\n public translate(dx: number, dy: number) {\n this.V[2].translate(dx, dy);\n this.V[3].translate(dx, dy);\n }\n\n public rotate(pivot: PointElement, ac: number, as: number) {\n this.V[2].rotate(pivot, ac, as);\n this.V[3].rotate(pivot, ac, as);\n }\n\n public update() {\n let factor : number = this._P.area() / (2.0 * PointElement.area(this.V[0], this.V[1], this._C));\n factor = Math.abs(factor);\n this.V[3].x = this.V[0].x + factor * (this._C.x - this.V[0].x);\n this.V[3].y = this.V[0].y + factor * (this._C.y - this.V[0].y);\n this.V[3].z = this.V[0].z + factor * (this._C.z - this.V[0].z);\n this.V[2].x = this.V[1].x + this.V[3].x - this.V[0].x;\n this.V[2].y = this.V[1].y + this.V[3].y - this.V[0].y;\n this.V[2].z = this.V[1].z + this.V[3].z - this.V[0].z;\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tCurvedTriangleElement.ts |\n| Part of the geomlib port of David E. Joyce's Geometry Applet. |\n| TypeScript: 2026, Nelson Brown, brownnrl@gmail.com |\n+----------------------------------------------------------------------*/\n\nimport {GeomElement} from \"../GeomElement\";\nimport {SlateCanvas} from \"../../Slate\";\nimport {PointElement} from \"../point/PointElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {LineElement} from \"../line/LineElement\";\n\n// A triangle whose three sides are circular arcs rather than straight\n// segments — the figure of non-Euclidean geometry (an elliptic triangle on\n// the disk model, a hyperbolic triangle in the Poincaré disk; both have\n// circular-arc sides).\n//\n// It is defined by 3 vertices A, B, C and 3 side carriers (one per side,\n// **positionally**: side i connects vertex i to vertex i+1 and lies on\n// carrier i). A carrier is the \"line\" the side lies on:\n// - a CircleElement → the side is the minor arc of that circle between the\n// two vertices, clipped to them (it stops at the corners, unlike the full\n// great-circle arc that runs on to the disk boundary);\n// - a LineElement → the side is the straight chord between the two vertices\n// (a disk diameter, whose geodesic is straight).\n//\n// It IS the side-segments — it draws and (optionally) fills them itself, so it\n// is one highlightable/fillable element (hovering \"triangle ABC\" lights the\n// curved sides gold). The minor arc makes the curve well-defined; positional\n// carriers make \"which circle\" well-defined. (The side tracing is written for\n// N sides, so a general curved polygon is a later, easy generalisation.)\n//\n// The vertices and carriers are independent slate elements that move by their\n// own handlers, so translate/rotate are no-ops.\ntype SideCarrier = CircleElement | LineElement;\n\nexport class CurvedTriangleElement extends GeomElement {\n\n private _vertices : PointElement[]; // A, B, C in order\n private _sides : SideCarrier[]; // carrier for side i (Vi → V(i+1))\n\n constructor(vertices: PointElement[], sides: SideCarrier[]) {\n super();\n this.dimension = 1;\n this._vertices = vertices;\n this._sides = sides;\n }\n\n update() : void {}\n\n // A vertex lies on a circle carrier (|dist − r| small) / a line carrier\n // (perpendicular distance small). Tolerances are relative to the carrier's\n // own scale, with a 0.5px floor: generous against float error, but catches\n // a carrier that simply doesn't pass through the side's endpoints.\n private static _onCircle(v: PointElement, c: CircleElement) : boolean {\n const r = c.radius;\n return Math.abs(v.distance(c.Center) - r) <= Math.max(0.5, 1e-3 * r);\n }\n private static _onLine(v: PointElement, l: LineElement) : boolean {\n const ax = l.A.x, ay = l.A.y, bx = l.B.x, by = l.B.y;\n const dx = bx - ax, dy = by - ay;\n const len = Math.hypot(dx, dy);\n if (len === 0) return false;\n const perp = Math.abs((v.x - ax) * dy - (v.y - ay) * dx) / len;\n return perp <= Math.max(0.5, 1e-3 * len);\n }\n\n defined() : boolean {\n const n = this._vertices.length;\n if (n < 3 || this._sides.length !== n) return false;\n for (let v of this._vertices) if (!v.defined()) return false;\n // Each carrier must be defined AND pass through BOTH vertices of its\n // side, else the figure is ill-posed — undefined, so we draw no\n // misleading arcs. (LineElement inherits no real defined(), so a line\n // carrier is \"defined\" when both its endpoints are.)\n for (let i = 0; i < n; i++) {\n const V = this._vertices[i];\n const W = this._vertices[(i + 1) % n];\n const s = this._sides[i];\n if (s instanceof CircleElement) {\n if (!s.defined()) return false;\n if (!CurvedTriangleElement._onCircle(V, s) || !CurvedTriangleElement._onCircle(W, s)) return false;\n } else {\n const l = s as LineElement;\n if (l.A == null || l.B == null || !l.A.defined() || !l.B.defined()) return false;\n if (!CurvedTriangleElement._onLine(V, l) || !CurvedTriangleElement._onLine(W, l)) return false;\n }\n }\n return true;\n }\n\n // The signed minor angle from a0 to a1 around a centre, in (−π, π].\n private static _delta(a0: number, a1: number) : number {\n let d = a1 - a0;\n while (d > Math.PI) d -= 2 * Math.PI;\n while (d <= -Math.PI) d += 2 * Math.PI;\n return d;\n }\n\n // Trace the closed curved boundary into the current ctx path (no\n // beginPath / stroke / fill). Shared by drawEdge and drawFace so the\n // stroked outline and the filled region are the exact same path.\n private _traceBoundary(ctx: CanvasRenderingContext2D) : void {\n const n = this._vertices.length;\n const V0 = this._vertices[0];\n ctx.moveTo(V0.x, V0.y);\n for (let i = 0; i < n; i++) {\n const V = this._vertices[i];\n const W = this._vertices[(i + 1) % n];\n const s = this._sides[i];\n if (s instanceof CircleElement) {\n const cx = s.Center.x, cy = s.Center.y, r = s.radius;\n const a0 = Math.atan2(V.y - cy, V.x - cx);\n const a1 = Math.atan2(W.y - cy, W.x - cx);\n const d = CurvedTriangleElement._delta(a0, a1);\n // V is on the circle, so ctx.arc's implicit lineTo to the arc\n // start is zero-length and the path stays continuous.\n ctx.arc(cx, cy, r, a0, a0 + d, d < 0);\n } else {\n // Straight side (line carrier / diameter): chord to the vertex.\n ctx.lineTo(W.x, W.y);\n }\n }\n ctx.closePath();\n }\n\n drawFace(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.faceColor == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.beginPath();\n this._traceBoundary(ctx);\n ctx.fillStyle = this.faceColor;\n ctx.fill();\n }\n\n drawEdge(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n const color = (this.emphasized || this.shouldHighlight)\n ? this.edgeHighlightColor\n : this.edgeColor;\n if (color == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.strokeStyle = color;\n const baseW = this.shouldHighlight ? 3 : 1;\n ctx.lineWidth = (baseW + this.emphasisAmount * (6 - baseW)) * GeomElement.styleScale;\n ctx.beginPath();\n this._traceBoundary(ctx);\n ctx.stroke();\n }\n\n drawVertex(c: SlateCanvas) : void {}\n\n drawName(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (!this.defined()) return; // drawString() guards on a null name/colour\n let x = 0, y = 0;\n for (let v of this._vertices) { x += v.x; y += v.y; }\n this.drawString(x / this._vertices.length, y / this._vertices.length, c);\n }\n\n translate(dx: number, dy: number) : void {}\n rotate(pivot: PointElement, ac: number, as: number) : void {}\n}\n","// Animations targeting PolygonElement. See ../Animations.ts for the\n// abstract base + registry mechanics.\n\nimport {Animation, AllAnimations, IAnimationStep, registerAnimation} from \"../Animations\";\nimport {GeomElement} from \"../GeomElement\";\nimport {Slate} from \"../../Slate\";\nimport {PolygonElement} from \"./PolygonElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\n\n// Default per-edge trace rate matches LineAnimations so a polygon's\n// edges feel like the same instrument tracing each side in turn.\nconst DEFAULT_POLYGON_EDGE_RATE_PX_PER_MS = 0.25;\nconst DEFAULT_POLYGON_FILL_MS = 500;\n\n// Total perimeter (closed if V.length > 2, otherwise open) — used to\n// compute the outline duration from edge rate.\nfunction perimeter(poly: PolygonElement): number {\n const n = poly.V.length;\n if (n < 2) return 0;\n let total = 0;\n const closed = n > 2;\n const edgeCount = closed ? n : n - 1;\n for (let i = 0; i < edgeCount; i++) {\n const a = poly.V[i];\n const b = poly.V[(i + 1) % n];\n const dx = b.x - a.x;\n const dy = b.y - a.y;\n total += Math.sqrt(dx * dx + dy * dy);\n }\n return total;\n}\n\n// A.Polygon.outline — cascade-trace each edge in V[] order.\n// PolygonElement.drawEdge already partitions drawProgress over edges\n// so a single step driving drawProgress 0 → 1 traces every edge in\n// sequence with the right per-edge proportion.\nexport class PolygonOutlineAnimation extends Animation {\n public animationMethod = AllAnimations.POLYGON_OUTLINE;\n public name = \"Polygon.outline\";\n public elementType = PolygonElement;\n public defaultRate = DEFAULT_POLYGON_EDGE_RATE_PX_PER_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const poly = target as PolygonElement;\n const durationMs = Math.max(180, perimeter(poly) / this.defaultRate);\n return [{\n durationMs,\n tick: (progress) => { poly.drawProgress = progress; },\n finalise: () => {\n poly.drawProgress = 1;\n poly.visible = true;\n },\n }];\n }\n}\n\n// A.Polygon.outlineAndFill — strict sequence: outline-trace step\n// completes first, then a separate fill-fade step. PolygonElement\n// now has two independent fields driving this — drawProgress for the\n// edge trace (consumed by drawEdge) and faceAlpha for the fill\n// (consumed by drawFace). The outline step finalises drawProgress to\n// 1 (full edges) before the fill step starts ticking faceAlpha\n// 0 → 1; the edges remain stable at full while the face fades in.\n//\n// The fade duration is intentionally shorter than the outline trace\n// — the eye has already absorbed the polygon's shape from the trace,\n// so the fill should land quickly. v1: half the outline's runtime,\n// capped by defaultDurationMs.\nexport class PolygonOutlineAndFillAnimation extends Animation {\n public animationMethod = AllAnimations.POLYGON_OUTLINE_AND_FILL;\n public name = \"Polygon.outlineAndFill\";\n public elementType = PolygonElement;\n public defaultRate = DEFAULT_POLYGON_EDGE_RATE_PX_PER_MS;\n public defaultDurationMs = DEFAULT_POLYGON_FILL_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const poly = target as PolygonElement;\n const outlineMs = Math.max(180, perimeter(poly) / this.defaultRate);\n const fullRestore = () => {\n poly.faceAlpha = 1;\n poly.drawProgress = 1;\n poly.visible = true;\n };\n // Step 1 — outline trace.\n const outline: IAnimationStep = {\n durationMs: outlineMs,\n setup: () => {\n poly.drawProgress = 0;\n poly.faceAlpha = 0; // hide fill until step 2\n },\n tick: (progress) => { poly.drawProgress = progress; },\n finalise: () => { poly.drawProgress = 1; },\n };\n // A face-less polygon has nothing to fade — scheduling the\n // fill step anyway would be pure dead time in the middle of\n // a cascade (#81). Run the outline alone, with its finalise\n // doing the full restore.\n if (poly.faceColor == null) {\n outline.finalise = fullRestore;\n return [outline];\n }\n // Fill ~twice as fast as the outline, capped at the\n // class-level default so a giant polygon doesn't yield a\n // glacial fade.\n const fillMs = Math.min(outlineMs / 2, this.defaultDurationMs);\n return [\n outline,\n // Step 2 — face fade-in over the already-traced outline.\n {\n durationMs: fillMs,\n tick: (progress) => { poly.faceAlpha = progress; },\n finalise: fullRestore,\n },\n ];\n }\n}\n\n// A.Polygon.superpose — Euclid's superposition (I.4): an ephemeral\n// gold-outline ghost copy of the target lifts off, translates so its\n// vertex 0 lands on the `onto` polygon's vertex 0, rotates about the\n// landing point to lay side 0→1 onto the target side 0→1 (carrying\n// the remaining vertices with it), holds a beat coinciding, then\n// retraces both motions home. The real polygon never moves — the\n// ephemeral system owns the moving copy and its cleanup.\n//\n// Args: { onto: string } — the polygon to superpose onto. Must\n// resolve to a PolygonElement with the same vertex count; anything\n// else warns and falls through to an instant no-op.\nconst SUPERPOSE_TRANSLATE_RATE_PX_PER_MS = 0.25;\nconst SUPERPOSE_ROTATE_RATE_RAD_PER_MS = 0.003;\nconst SUPERPOSE_MIN_STEP_MS = 250;\nconst SUPERPOSE_HOLD_MS = 800;\nconst GHOST_COLOR = \"#FFD700\";\n\nexport class PolygonSuperposeAnimation extends Animation {\n public animationMethod = AllAnimations.POLYGON_SUPERPOSE;\n public name = \"Polygon.superpose\";\n public elementType = PolygonElement;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const poly = target as PolygonElement;\n const ontoName = args && args.onto;\n const onto = ontoName != null ? slate.lookupElement(String(ontoName)) : null;\n if (!(onto instanceof PolygonElement) || onto.V.length !== poly.V.length) {\n slate.reportDiagnostic({\n code: \"bad-animation-args\",\n key: \"Polygon.superpose|\" + String(poly.name) + \"|\" + String(ontoName),\n message: \"Polygon.superpose: args.onto ('\"\n + ontoName + \"') is not a polygon with \"\n + poly.V.length + \" vertices — skipping\",\n detail: { animation: \"Polygon.superpose\", elem: String(poly.name), onto: String(ontoName) },\n });\n return [{\n durationMs: 0,\n tick: () => {},\n finalise: () => {\n poly.drawProgress = 1;\n poly.visible = true;\n },\n }];\n }\n\n // Source coordinates are captured at setup time (not build\n // time) so the ghost reflects any drags that happened between\n // slide construction and this step actually starting.\n const n = poly.V.length;\n let src: Array<{x: number, y: number}> = [];\n let dx = 0, dy = 0; // translate delta: V[0] → onto.V[0]\n let theta = 0; // rotation about the landing point\n const ghostPts: PointElement[] = [];\n const ghost = new PolygonElement();\n ghost.edgeColor = GHOST_COLOR;\n ghost.faceColor = null;\n ghost.nameColor = null;\n ghost.vertexColor = null;\n\n const setGhost = (coords: Array<{x: number, y: number}>) => {\n for (let i = 0; i < n; i++) {\n ghostPts[i].x = coords[i].x;\n ghostPts[i].y = coords[i].y;\n }\n };\n const translated = (t: number) =>\n src.map(p => ({ x: p.x + dx * t, y: p.y + dy * t }));\n // Rotate the fully-translated coords about the landing point\n // (onto.V[0]) by angle · t.\n const rotated = (t: number) => {\n const cx = onto.V[0].x, cy = onto.V[0].y;\n const cos = Math.cos(theta * t), sin = Math.sin(theta * t);\n return translated(1).map(p => ({\n x: cx + (p.x - cx) * cos - (p.y - cy) * sin,\n y: cy + (p.x - cx) * sin + (p.y - cy) * cos,\n }));\n };\n\n // Durations are estimated from build-time geometry; the exact\n // path re-derives from setup-time coords so a stale estimate\n // only affects pacing, never correctness.\n const estDist = Math.hypot(onto.V[0].x - poly.V[0].x, onto.V[0].y - poly.V[0].y);\n const translateMs = Math.max(SUPERPOSE_MIN_STEP_MS,\n estDist / SUPERPOSE_TRANSLATE_RATE_PX_PER_MS);\n const estTheta = Math.abs(this._sideAngleDelta(poly, onto));\n const rotateMs = Math.max(SUPERPOSE_MIN_STEP_MS,\n estTheta / SUPERPOSE_ROTATE_RATE_RAD_PER_MS);\n\n return [\n // ① glide: vertex 0 travels to onto's vertex 0.\n {\n durationMs: translateMs,\n setup: () => {\n // Superpose is not a reveal — the real polygon is\n // already on stage and must stay fully drawn while\n // its ghost travels. Undo the animator's reveal-\n // convention pre-zeroing.\n poly.drawProgress = 1;\n poly.visible = true;\n src = poly.V.map(p => ({ x: p.x, y: p.y }));\n dx = onto.V[0].x - src[0].x;\n dy = onto.V[0].y - src[0].y;\n theta = this._sideAngleDelta(poly, onto);\n for (let i = 0; i < n; i++) {\n const gp = new PointElement();\n gp.x = src[i].x;\n gp.y = src[i].y;\n ghostPts.push(gp);\n ghost.V.push(gp);\n }\n slate.addEphemeral(ghost);\n },\n tick: (p) => { setGhost(translated(p)); },\n finalise: () => { setGhost(translated(1)); },\n },\n // ② rotate about the landing point: side 0→1 lays onto\n // the target's side 0→1.\n {\n durationMs: rotateMs,\n tick: (p) => { setGhost(rotated(p)); },\n finalise: () => { setGhost(rotated(1)); },\n },\n // ③ hold, coinciding.\n {\n durationMs: SUPERPOSE_HOLD_MS,\n tick: () => {},\n finalise: () => {},\n },\n // ④ rotate home.\n {\n durationMs: rotateMs,\n tick: (p) => { setGhost(rotated(1 - p)); },\n finalise: () => { setGhost(translated(1)); },\n },\n // ⑤ glide home; the ghost's work is done.\n {\n durationMs: translateMs,\n tick: (p) => { setGhost(translated(1 - p)); },\n finalise: () => {\n slate.removeEphemeral(ghost);\n poly.drawProgress = 1;\n poly.visible = true;\n },\n },\n ];\n }\n\n // Angle that carries the source side V[0]→V[1] onto the target\n // side, normalized to [-π, π] so the ghost takes the short way.\n private _sideAngleDelta(from: PolygonElement, onto: PolygonElement): number {\n const a = Math.atan2(from.V[1].y - from.V[0].y, from.V[1].x - from.V[0].x);\n const b = Math.atan2(onto.V[1].y - onto.V[0].y, onto.V[1].x - onto.V[0].x);\n let d = b - a;\n while (d > Math.PI) d -= 2 * Math.PI;\n while (d < -Math.PI) d += 2 * Math.PI;\n return d;\n }\n}\n\n// A.Polygon.equilateralBuild — Euclid I.1: build the equilateral triangle\n// on a base as a transitory compass walk. Two gold compass circles (centre\n// V[0] through V[1], centre V[1] through V[0]) sweep out, then the triangle\n// traces (and fills) — and the circles vanish, leaving just the triangle.\n// The target is the declared `polygon;equilateralTriangle` (V[0]=A, V[1]=B,\n// V[2]=apex); the circles are bare EPHEMERALS the animation owns and clears,\n// so a deck calls one entry instead of declaring + sequencing the rig.\n//\n// Unlike A.Polygon.superpose (whose target is already on stage), this target\n// is a DEFERRED REVEAL: it stays dark (drawProgress=0, faceAlpha=0) through\n// the circle sweeps and only traces in on the outline step.\nconst EQUILATERAL_SWEEP_RATE_RAD_PER_MS = 0.0045; // brisker than the lone compass\n\nexport class PolygonEquilateralBuildAnimation extends Animation {\n public animationMethod = AllAnimations.POLYGON_EQUILATERAL_BUILD;\n public name = \"Polygon.equilateralBuild\";\n public elementType = PolygonElement;\n public defaultRate = EQUILATERAL_SWEEP_RATE_RAD_PER_MS;\n public defaultDurationMs = DEFAULT_POLYGON_FILL_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const poly = target as PolygonElement;\n // Need a base (A, B) to centre the two compass circles on.\n if (poly.V.length < 2) {\n return [{ durationMs: 0, tick: () => {},\n finalise: () => { poly.drawProgress = 1; poly.faceAlpha = 1; poly.visible = true; } }];\n }\n const A = poly.V[0], B = poly.V[1];\n const plane = A.AP;\n const sweepMs = (2 * Math.PI) / this.defaultRate;\n // Bare ephemeral circles (no face — a compass walk is the arc only).\n // They paint gold via the highlight stroke because they're emphasised.\n const circAB = new CircleElement({ C: A, B: B, AP: plane }); // centre A through B\n const circBA = new CircleElement({ C: B, B: A, AP: plane }); // centre B through A\n for (const c of [circAB, circBA]) {\n c.edgeColor = null; c.faceColor = null; c.nameColor = null; c.vertexColor = null;\n c.emphasized = true;\n }\n const startAngle = (c: CircleElement) =>\n Math.atan2(c.B.y - c.Center.y, c.B.x - c.Center.x);\n const sweep = (c: CircleElement): IAnimationStep => ({\n durationMs: sweepMs,\n setup: () => { c.drawStartAngle = startAngle(c); c.drawProgress = 0; },\n tick: (p) => { c.drawProgress = p; },\n finalise: () => { c.drawProgress = 1; },\n });\n\n const outlineMs = Math.max(180, perimeter(poly) / DEFAULT_POLYGON_EDGE_RATE_PX_PER_MS);\n const clearCircles = () => { slate.removeEphemeral(circAB); slate.removeEphemeral(circBA); };\n const fullRestore = () => {\n poly.drawProgress = 1; poly.faceAlpha = 1; poly.visible = true;\n clearCircles();\n };\n\n // Step 1 — first compass circle; also creates + registers both ephemerals\n // and hides the polygon until its outline step.\n const first = sweep(circAB);\n const firstSetup = first.setup;\n first.setup = () => {\n poly.drawProgress = 0; poly.faceAlpha = 0; // deferred reveal — stay dark\n slate.addEphemeral(circAB); slate.addEphemeral(circBA);\n // Both circles start un-drawn: a fresh CircleElement defaults to\n // drawProgress = 1, and ephemerals get no animator pre-zeroing, so\n // the second circle would otherwise flash full during the first sweep.\n circAB.drawProgress = 0; circBA.drawProgress = 0;\n if (firstSetup) firstSetup();\n };\n\n // Step N — outline trace. Reveals the triangle; clears the circles last\n // (after a faceless polygon, or before the fill step takes over).\n const outline: IAnimationStep = {\n durationMs: outlineMs,\n setup: () => { poly.drawProgress = 0; poly.faceAlpha = 0; },\n tick: (p) => { poly.drawProgress = p; },\n finalise: () => { poly.drawProgress = 1; },\n };\n if (poly.faceColor == null) {\n outline.finalise = fullRestore;\n return [first, sweep(circBA), outline];\n }\n const fillMs = Math.min(outlineMs / 2, this.defaultDurationMs);\n return [\n first,\n sweep(circBA),\n outline,\n // Final step — face fade-in; clears the circles as the triangle lands.\n { durationMs: fillMs, tick: (p) => { poly.faceAlpha = p; }, finalise: fullRestore },\n ];\n }\n}\n\nregisterAnimation(new PolygonOutlineAnimation());\nregisterAnimation(new PolygonOutlineAndFillAnimation());\nregisterAnimation(new PolygonSuperposeAnimation());\nregisterAnimation(new PolygonEquilateralBuildAnimation());\n","/*----------------------------------------------------------------------+\n| Polygon construction classes — extracted from Constructions.ts |\n| Each class maps a (type, constructionName, signature) triple to |\n| a construct() method that creates the geometry element. |\n+----------------------------------------------------------------------*/\n\nimport {Construction, ConstructionSignature, SortedParams, AllConstructions,\n PolygonConstructions as PolygonConstructionsEnum,\n GeomElementsForUpdate} from \"../Constructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {Layoff} from \"../point/Layoff\";\nimport {SimilarElement} from \"../point/SimilarElement\";\nimport {PolygonElement} from \"./PolygonElement\";\nimport {CurvedTriangleElement} from \"./CurvedTriangleElement\";\nimport {CircleElement} from \"../circle/CircleElement\";\nimport {LineElement} from \"../line/LineElement\";\nimport {RegularPolygonElement} from \"./RegularPolygonElement\";\nimport {ApplicationElement} from \"./ApplicationElement\";\nimport {PolyhedronElement} from \"../polyhedron/PolyhedronElement\";\n\n/*************************\n * Element Class Polygon *\n *************************/\n\nexport abstract class PolyConstruction extends Construction {\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new PolygonElement(P);\n return [[g],g];\n }\n}\n\n// polygon\n// square — points A, B [, plane C = screen]\n// the square on a side AB in plane C\n// 2D: 2 points, 0 elements — uses screen plane\n// 3D: 2 points, 1 PlaneElement — uses explicit plane\n// (Java: RegularPolygon.java with n=4 — same class as equilateralTriangle)\nexport class SquarePolygonConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.square;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 2 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const plane = E.length > 0 ? E[0] as PlaneElement : screen;\n const g = new RegularPolygonElement(P[0], P[1], plane, 4);\n return [[g], g];\n }\n}\n\n// polygon\n// triangle\n// points A, B, C\n// the triangle ABC given 3 vertices A, B, and C\n// (Java: Slate.java polygon case 1 — new PolygonElement(A,B,C))\nexport class TrianglePolygonConstruction extends PolyConstruction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.triangle;\n signature = { points: 3, elements: 0, integers: 0 };\n}\n\n// polygon\n// quadrilateral\n// points A, B, C, D\n// the quadrilateral ABCD given 4 vertices A, B, C, and D\n// (Java: Slate.java polygon case 2 — new PolygonElement(A,B,C,D))\nexport class QuadrilateralPolygonConstruction extends PolyConstruction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.quadrilateral;\n signature = { points: 4, elements: 0, integers: 0 };\n}\n\n// polygon\n// pentagon\n// points A, B, C, D, E\n// the pentagon given 5 vertices (free points, not a regular pentagon)\n// (Java: Slate.java polygon case 3 — new PolygonElement(A,B,C,D,E))\nexport class PentagonPolygonConstruction extends PolyConstruction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.pentagon;\n signature = { points: 5, elements: 0, integers: 0 };\n}\n\n// polygon\n// hexagon\n// points A, B, C, D, E, F\n// the hexagon given 6 vertices (free points)\n// (Java: Slate.java polygon case 4 — new PolygonElement(A,B,C,D,E,F))\nexport class HexagonPolygonConstruction extends PolyConstruction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.hexagon;\n signature = { points: 6, elements: 0, integers: 0 };\n}\n\n// polygon\n// equilateralTriangle — points A, B [, plane C = screen]\n// the equilateral triangle on side AB in the plane C\n// 2D: 2 points, 0 elements — uses screen plane\n// 3D: 2 points, 1 PlaneElement — uses explicit plane\n// (Java: Slate.java polygon case 5 — new RegularPolygon(A,B,plane,3))\nexport class EquilateralTriangleConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.equilateralTriangle;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 2 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const plane = E.length > 0 ? E[0] as PlaneElement : screen;\n const g = new RegularPolygonElement(P[0], P[1], plane, 3);\n return [[g], g];\n }\n}\n\n// polygon\n// parallelogram\n// points A, B, C\n// the parallelogram ABCD given A, B, and C, where D = A + (C - B)\n// (no dedicated Java class — Slate.java case 6 dispatches to a Layoff\n// trick identical to the point;parallelogram and line;parallel patterns)\nexport class ParallelogramPolygonConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.parallelogram;\n signature = { points: 3, elements: 0, integers: 0 };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let lo = new Layoff(P[0], P[1], P[2], P[1], P[2]);\n let g = new PolygonElement([P[0], P[1], P[2], lo]);\n return [[lo, g], g];\n }\n}\n\n// polygon\n// regularPolygon — points A, B, integer n [, plane C = screen]\n// the regular n-gon on side AB in the plane C\n// 2D: 2 points, 0 elements, 1 integer — uses screen plane\n// 3D: 2 points, 1 PlaneElement, 1 integer — uses explicit plane\n// (Java: Slate.java polygon case 7 — RegularPolygon(A,B,plane,n))\nexport class RegularPolygonConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.regularPolygon;\n signature: ConstructionSignature = { points: 2, elements: 0, integers: 1 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 2 && sp.N.length === 1\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const plane = E.length > 0 ? E[0] as PlaneElement : screen;\n const g = new RegularPolygonElement(P[0], P[1], plane, N[0]);\n return [[g], g];\n }\n}\n\n// polygon\n// starPolygon (2D variant)\n// points A, B, integers n, d\n// the star polygon {n/d} on side AB in the screen plane\n// (Java: Slate.java polygon case 8 — new RegularPolygon(A,B,screen,n,d))\nexport class StarPolygonConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.starPolygon;\n signature = { points: 2, elements: 0, integers: 2 };\n\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new RegularPolygonElement(P[0], P[1], screen, N[0], N[1]);\n return [[g], g];\n }\n}\n\n\n// polygon\n// similar — points A, B, D, E, F [, planes C, G = screen]\n// the triangle ABH where H is the similar point so triangle ABH ~ triangle DEF\n// 2D: 5 points, 0 elements — uses screen plane for both\n// 3D: 5 points, 2 PlaneElements — uses explicit planes\n// (Java: Slate.java polygon case 9 — Similar(A,B,C,D,E,F,G) + PolygonElement(A,B,H))\nexport class SimilarPolygonConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.similar;\n signature: ConstructionSignature = { points: 5, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 5 && sp.N.length === 0\n && (sp.E.length === 0 || sp.E.length === 2);\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let c = E.length > 0 ? E[0] as PlaneElement : screen;\n let g2 = E.length > 1 ? E[1] as PlaneElement : screen;\n let sim = new SimilarElement(P[0], P[1], c, P[2], P[3], P[4], g2);\n let g = new PolygonElement([P[0], P[1], sim]);\n return [[sim, g], g];\n }\n}\n\n// polygon\n// application\n// polygon A points B, C, D\n// the parallelogram equal to the given polygon A with one side BC and one angle BCD\n// (Java: Application.java — parallelogram with area = P.area(), side BC, angle DCB)\nexport class ApplicationPolygonConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.application;\n signature = { points: 3, elements: 1, integers: 0, elementTypes: [PolygonElement] };\n\n construct(screen : PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new ApplicationElement(E[0] as PolygonElement, P[0], P[1], P[2]);\n return [[g], g];\n }\n}\n\n// polygon\n// octagon\n// 8 points A, B, C, D, E, F, G, H\n// the octagon given 8 vertices (free points, pass-through)\n// (Java: Slate.java polygon case 11 — new PolygonElement(A,B,C,D,E,F,G,H))\nexport class OctagonPolygonConstruction extends PolyConstruction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.octagon;\n signature = { points: 8, elements: 0, integers: 0 };\n}\n\n// polygon\n// face\n// polyhedron A integer n\n// the nth face (1-based) of polyhedron A\n// (Java: Slate.java polygon case 12 — ((PolyhedronElement)E[0]).P[N[0]-1])\n// Same pattern as point;vertex (returns polygon from polyhedron, not point from polygon)\nexport class FacePolygonConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.face;\n signature = { points: 0, elements: 1, integers: 1, elementTypes: [PolyhedronElement] };\n\n construct(_screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const polyhedron = E[0] as PolyhedronElement;\n const face = polyhedron.P[N[0] - 1];\n return [[face], face];\n }\n}\n\n// A side carrier is the \"line\" a curved side lies on: a CircleElement (arc\n// side) or a LineElement (straight side / diameter). Lines reach us intact\n// because the construction sets keepsLineElements (see convertParams).\nfunction isCarrier(e: GeomElement): boolean {\n return e instanceof CircleElement || e instanceof LineElement;\n}\n\n// polygon — curvedTriangle — 3 vertices A,B,C + 3 side carriers\n// A triangle whose sides are circular arcs (an elliptic or hyperbolic\n// triangle): side i is the minor arc on carrier i from vertex i to vertex\n// i+1, clipped to the vertices (a line carrier gives a straight side). It\n// draws/fills/highlights those three side-segments itself, as one element\n// (#119). Strict 3 vertices + 3 carriers.\nexport class CurvedTriangleConstruction extends Construction {\n constructionMethod: AllConstructions = PolygonConstructionsEnum.curvedTriangle;\n signature: ConstructionSignature = { points: 3, elements: 3, integers: 0 };\n keepsLineElements: boolean = true;\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0\n && sp.E.length === 3 && sp.E.every(isCarrier);\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new CurvedTriangleElement(P.slice(), E.slice() as any[]);\n return [[g], g];\n }\n}\n\nexport const polygonConstructions: Construction[] = [\n new CurvedTriangleConstruction(),\n new TrianglePolygonConstruction(),\n new StarPolygonConstruction(),\n new RegularPolygonConstruction(),\n new SquarePolygonConstruction(),\n new EquilateralTriangleConstruction(),\n new ParallelogramPolygonConstruction(),\n new QuadrilateralPolygonConstruction(),\n new OctagonPolygonConstruction(),\n new PentagonPolygonConstruction(),\n new HexagonPolygonConstruction(),\n new SimilarPolygonConstruction(),\n new ApplicationPolygonConstruction(),\n new FacePolygonConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tLineElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\n\nimport {PointElement} from \"../point/PointElement\";\nimport {GeomElement} from \"../GeomElement\";\nimport {SlateCanvas} from \"../../Slate\";\n\nexport class PolygonElement extends GeomElement {\n\n public V : PointElement[];\n\n // Face fill alpha — drives drawFace's globalAlpha independent of\n // drawProgress (which drives the edge trace). Lets an animation\n // run the outline to completion at drawProgress = 1 first, then\n // separately fade the fill in by ticking faceAlpha 0 → 1. Default\n // 1 means \"fully opaque\" — every existing render path behaves\n // identically.\n private _faceAlpha : number = 1;\n\n set faceAlpha(value: number) {\n this._faceAlpha = value < 0 ? 0 : (value > 1 ? 1 : value);\n }\n get faceAlpha(): number { return this._faceAlpha; }\n\n constructor(ps?: PointElement[]) {\n super();\n this.dimension = 2;\n if (ps == null) {\n this.V = [];\n return;\n }\n this.V = ps;\n }\n\n public area() : number {\n // Ported from PolygonElement.java area() — 2026-04-12\n // Compute the area of this polygon (assuming it's planar & convex).\n // Uses fan triangulation from V[0].\n let sum = 0.0;\n for (let i = 0; i < this.V.length - 2; ++i) {\n sum += PointElement.area(this.V[0], this.V[i + 1], this.V[i + 2]);\n }\n return sum;\n }\n\n public drawEdge(c: HTMLCanvasElement, color?: string): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (color == null) {\n if (this.emphasized || this.shouldHighlight) {\n color = this.edgeHighlightColor;\n } else {\n color = this.edgeColor;\n }\n }\n\n if (color == null) return;\n if (this.V.length <= 1) return;\n\n let ctx = c.getContext(\"2d\");\n ctx.beginPath();\n ctx.strokeStyle = color;\n {\n const baseW = this.shouldHighlight ? 3 : 1;\n ctx.lineWidth = (baseW + this.emphasisAmount * (6 - baseW)) * GeomElement.styleScale;\n }\n // Edge enumeration: a closed polygon (>2 verts) has V.length\n // edges including the closing one; an open polyline has\n // V.length - 1. Each integer step of drawProgress · edgeCount\n // advances one full edge; the fractional remainder partially\n // traces the next. drawProgress = 1 (default) reproduces the\n // pre-animation full-trace behaviour bit-for-bit.\n let n = this.V.length;\n let isClosed = n > 2;\n let edgeCount = isClosed ? n : n - 1;\n let p = this.drawProgress;\n let totalProgress = p * edgeCount;\n let fullEdges = Math.floor(totalProgress);\n let fractionalEdge = totalProgress - fullEdges;\n\n ctx.moveTo(this.V[0].x, this.V[0].y);\n for (let i = 0; i < fullEdges; i++) {\n let to = this.V[(i + 1) % n];\n ctx.lineTo(to.x, to.y);\n ctx.stroke();\n }\n if (fractionalEdge > 0 && fullEdges < edgeCount) {\n let from = this.V[fullEdges];\n let to = this.V[(fullEdges + 1) % n];\n let px = from.x + (to.x - from.x) * fractionalEdge;\n let py = from.y + (to.y - from.y) * fractionalEdge;\n ctx.lineTo(px, py);\n ctx.stroke();\n }\n }\n\n public defined() : boolean {\n if (this.V.length == 0) return false;\n for(let v of this.V) {\n if (!v.defined()) return false;\n }\n return true;\n }\n\n public drawFace(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if(this.faceColor != null && this.defined() && this.V.length > 2) {\n let ctx : CanvasRenderingContext2D = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.beginPath();\n ctx.fillStyle = this.faceColor;\n let firstPoint = this.V[0];\n let rest = this.V.slice(1);\n ctx.moveTo(firstPoint.x, firstPoint.y);\n for(let vertex of rest)\n ctx.lineTo(vertex.x, vertex.y);\n ctx.closePath();\n // Animate the fill via the dedicated faceAlpha field so\n // outline-then-fill animations can run the edge trace to\n // completion at drawProgress = 1 first, then independently\n // tick faceAlpha from 0 to 1 for the fade-in. Default\n // faceAlpha = 1 preserves the fully-opaque behaviour for\n // every consumer that doesn't animate.\n let a = this.faceAlpha;\n if (a < 1) {\n if (a <= 0) return; // fully transparent — skip\n ctx.save();\n ctx.globalAlpha = a;\n ctx.fill();\n ctx.restore();\n } else {\n ctx.fill();\n }\n }\n }\n\n public drawName(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.nameColor != null && this.name != null && this.defined()) {\n let x : number = 0;\n let y : number = 0;\n for(let v of this.V) {\n x += v.x;\n y += v.y;\n }\n let n : number = this.V.length;\n x = x / n;\n y = y / n;\n let ctx : CanvasRenderingContext2D = c.getContext(\"2d\") as CanvasRenderingContext2D;\n let [w, h] = this._getTextMetrics(ctx, this._name);\n ctx.beginPath();\n ctx.fillStyle = this.nameColor;\n ctx.fillText(this._name, x - w/2., y + h/4.);\n }\n }\n\n public drawVertex(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.vertexColor != null && this.defined() ) {\n for(let v of this.V) {\n v.drawVertex(c, this.vertexColor);\n }\n }\n }\n\n public rotate(pivot: PointElement, ac: number, as: number): void {\n }\n\n public translate(dx: number, dy: number): void {\n }\n\n public update(): void {\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tRegularPolygonElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PolygonElement} from \"./PolygonElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport class RegularPolygonElement extends PolygonElement {\n\n private _cos: number;\n private _sin: number;\n private _P: PlaneElement;\n\n constructor(A: PointElement, B: PointElement, plane: PlaneElement, n: number, d: number = 1) {\n super();\n this._P = plane;\n const theta = Math.PI * d * (n - 2) / n;\n this._cos = Math.cos(theta);\n this._sin = Math.sin(theta);\n this.V = new Array(n);\n this.V[0] = A;\n this.V[1] = B;\n for (let i = 2; i < n; i++) {\n this.V[i] = new PointElement({ AP: plane });\n }\n }\n\n update(): void {\n for (let i = 2; i < this.V.length; i++) {\n this.V[i].to(this.V[i - 2]);\n this.V[i].rotate(this.V[i - 1], this._cos, this._sin, this._P);\n }\n }\n\n translate(dx: number, dy: number): void {\n for (let i = 2; i < this.V.length; i++) {\n this.V[i].translate(dx, dy);\n }\n }\n\n rotate(pivot: PointElement, ac: number, as: number): void {\n for (let i = 2; i < this.V.length; i++) {\n this.V[i].rotate(pivot, ac, as, this._P);\n }\n }\n}\n","/*----------------------------------------------------------------------+\n| Polyhedron construction classes — extracted from Constructions.ts |\n+----------------------------------------------------------------------*/\n\nimport {Construction, AllConstructions,\n PolyhedraConstructions as PolyhedraConstructionsEnum,\n GeomElementsForUpdate} from \"../Constructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {Layoff} from \"../point/Layoff\";\nimport {PolygonElement} from \"../polygon/PolygonElement\";\nimport {PyramidElement} from \"./PyramidElement\";\nimport {PrismElement} from \"./PrismElement\";\n\n// polyhedron — tetrahedron — points A, B, C, D\n// (Java: Slate.java polyhedron case 0 — PolygonElement(A,B,C) + Pyramid(base,D))\nexport class TetrahedronConstruction extends Construction {\n constructionMethod: AllConstructions = PolyhedraConstructionsEnum.tetrahedron;\n signature = { points: 4, elements: 0, integers: 0 };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let base = new PolygonElement([P[0], P[1], P[2]]);\n let g = new PyramidElement(base, P[3]);\n return [[base, g], g];\n }\n}\n\n// polyhedron — parallelepiped — points A, B, C, D\n// (Java: Slate.java polyhedron case 1 — Layoff(B,A,C,A,C) + PolygonElement(B,A,C,fourth) + Prism(base,A,D))\nexport class ParallelepipedConstruction extends Construction {\n constructionMethod: AllConstructions = PolyhedraConstructionsEnum.parallelepiped;\n signature = { points: 4, elements: 0, integers: 0 };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let fourth = new Layoff(P[1], P[0], P[2], P[0], P[2]);\n let base = new PolygonElement([P[1], P[0], P[2], fourth]);\n let g = new PrismElement(base, P[0], P[3]);\n return [[fourth, base, g], g];\n }\n}\n\n// polyhedron — prism — polygon A, points B, C\n// (Java: Prism.java — 41 lines, line-for-line port)\nexport class PrismConstruction extends Construction {\n constructionMethod: AllConstructions = PolyhedraConstructionsEnum.prism;\n signature = { points: 2, elements: 1, integers: 0, elementTypes: [PolygonElement] };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new PrismElement(E[0] as PolygonElement, P[0], P[1]);\n return [[g], g];\n }\n}\n\n// polyhedron — pyramid — polygon A, point B\n// (Java: Pyramid.java — 11 lines, line-for-line port)\nexport class PyramidConstruction extends Construction {\n constructionMethod: AllConstructions = PolyhedraConstructionsEnum.pyramid;\n signature = { points: 1, elements: 1, integers: 0, elementTypes: [PolygonElement] };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n const g = new PyramidElement(E[0] as PolygonElement, P[0]);\n return [[g], g];\n }\n}\n\nexport const polyhedronConstructions: Construction[] = [\n new TetrahedronConstruction(),\n new ParallelepipedConstruction(),\n new PrismConstruction(),\n new PyramidConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tPolyhedronElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {GeomElement} from \"../GeomElement\";\nimport {PolygonElement} from \"../polygon/PolygonElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {SlateCanvas} from \"../../Slate\";\n\nexport class PolyhedronElement extends GeomElement {\n\n public P: PolygonElement[]; // array of face polygons\n\n constructor() {\n super();\n this.dimension = 2;\n this.P = [];\n }\n\n public defined(): boolean {\n for (let i = 0; i < this.P.length; ++i) {\n if (!this.P[i].defined()) return false;\n }\n return true;\n }\n\n public drawName(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.nameColor != null && this.name != null && this.defined()) {\n let x = 0, y = 0, ct = 0;\n for (let j = 0; j < this.P.length; ++j) {\n for (let i = 0; i < this.P[j].V.length; ++i) {\n x += this.P[j].V[i].x;\n y += this.P[j].V[i].y;\n ++ct;\n }\n }\n x /= ct;\n y /= ct;\n this.drawString(Math.round(x), Math.round(y), c);\n }\n }\n\n public drawVertex(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.vertexColor != null && this.defined()) {\n for (let j = 0; j < this.P.length; ++j) {\n for (let i = 0; i < this.P[j].V.length; ++i) {\n this.P[j].V[i].drawVertex(c, this.vertexColor);\n }\n }\n }\n }\n\n public drawEdge(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.edgeColor != null && this.defined()) {\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.strokeStyle = this.edgeColor;\n for (let j = 0; j < this.P.length; ++j) {\n for (let i = 0; i < this.P[j].V.length; ++i) {\n let a = this.P[j].V[i];\n let b = this.P[j].V[(i + 1) % this.P[j].V.length];\n ctx.beginPath();\n ctx.moveTo(a.x, a.y);\n ctx.lineTo(b.x, b.y);\n ctx.stroke();\n }\n }\n }\n }\n\n public drawFace(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.faceColor != null && this.defined()) {\n for (let j = 0; j < this.P.length; ++j) {\n // Pass the polyhedron's faceColor to each face polygon,\n // matching Java's P[j].drawFace(g, faceColor)\n let savedColor = this.P[j].faceColor;\n this.P[j].faceColor = this.faceColor;\n this.P[j].drawFace(c);\n this.P[j].faceColor = savedColor;\n }\n }\n }\n\n public update(): void {}\n public translate(dx: number, dy: number): void {}\n public rotate(pivot: PointElement, ac: number, as: number): void {}\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPrismElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PolyhedronElement} from \"./PolyhedronElement\";\nimport {PolygonElement} from \"../polygon/PolygonElement\";\nimport {PointElement} from \"../point/PointElement\";\n\nexport class PrismElement extends PolyhedronElement {\n\n // The base is given as well as a line segment CD for the sides to be\n // parallel to.\n\n private _C: PointElement;\n private _D: PointElement;\n\n constructor(Base: PolygonElement, C: PointElement, D: PointElement) {\n super();\n this.dimension = 2;\n this._C = C;\n this._D = D;\n let baseN = Base.V.length;\n let n = 2 + baseN;\n this.P = new Array(n);\n this.P[0] = Base;\n // create the top — vertices translated by (D-C) from base\n let topVerts : PointElement[] = new Array(baseN);\n for (let j = 0; j < baseN; ++j) {\n topVerts[j] = new PointElement();\n topVerts[j].to(Base.V[j]).plus(D).minus(C);\n }\n this.P[1] = new PolygonElement(topVerts);\n // create the sides — quadrilaterals connecting base and top edges\n for (let i = 2; i < n; ++i) {\n this.P[i] = new PolygonElement([\n Base.V[i - 2],\n Base.V[(i - 1) % baseN],\n this.P[1].V[(i - 1) % baseN],\n this.P[1].V[i - 2]\n ]);\n }\n }\n\n public translate(dx: number, dy: number) {\n for (let i = 0; i < this.P[1].V.length; ++i) {\n this.P[1].V[i].translate(dx, dy);\n }\n }\n\n public rotate(pivot: PointElement, ac: number, as: number) {\n for (let i = 0; i < this.P[1].V.length; ++i) {\n this.P[1].V[i].rotate(pivot, ac, as);\n }\n }\n\n public update() {\n for (let j = 0; j < this.P[1].V.length; ++j) {\n this.P[1].V[j].to(this.P[0].V[j]).plus(this._D).minus(this._C);\n }\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tPyramidElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {PolyhedronElement} from \"./PolyhedronElement\";\nimport {PolygonElement} from \"../polygon/PolygonElement\";\nimport {PointElement} from \"../point/PointElement\";\n\nexport class PyramidElement extends PolyhedronElement {\n\n constructor(Base: PolygonElement, Apex: PointElement) {\n super();\n this.dimension = 2;\n let n = 1 + Base.V.length;\n this.P = new Array(n);\n this.P[0] = Base;\n for (let i = 1; i < n; ++i) {\n this.P[i] = new PolygonElement([Apex, Base.V[i - 1], Base.V[i % Base.V.length]]);\n }\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tAngleMarkerElement.ts |\n| Part of the geomlib port of David E. Joyce's Geometry Applet. |\n| TypeScript: 2026, Nelson Brown, brownnrl@gmail.com |\n+----------------------------------------------------------------------*/\n\nimport {SectorElement} from \"./SectorElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\n// A small sector drawn at a vertex to mark the interior angle between\n// two arms. Unlike a plain `sector;sector` (whose radius is the\n// vertex-to-arm distance, so it swings with arm length), an angle\n// marker computes its OWN fixed radius — a sensible px default,\n// clamped to a fraction of the shorter arm so it never overshoots.\n// It also auto-orients to the interior arc, removing the per-marker\n// arm-order sign-check the old midpoint-chain pattern needed (#91).\n//\n// The vertex (_Center) and the two arm points are real slate elements\n// (drags follow them automatically). _A / _B are INTERNAL points,\n// recomputed each update() at the marker radius along each arm — they\n// are never registered on the slate. The inherited SectorElement\n// drawEdge / drawFace then render the wedge, with drawProgress,\n// emphasisAmount, and faceAlpha all working unchanged.\nexport const DEFAULT_ANGLE_MARKER_RADIUS_PX = 22;\nexport const ANGLE_MARKER_MAX_ARM_FRACTION = 0.45;\nexport const ANGLE_MARKER_RING_STEP = 9;\n\nexport class AngleMarkerElement extends SectorElement {\n\n private _arm1 : PointElement;\n private _arm2 : PointElement;\n private _radiusOverride : number;\n\n // Concentric-ring index for same-vertex markers. 0.8.1 will assign\n // this automatically so overlapping markers nest; for now it\n // defaults to 0 and can be set by hand. Each step bumps the radius\n // by ANGLE_MARKER_RING_STEP.\n public ringIndex : number = 0;\n\n // Draw the major (reflex, > 180°) arc instead of the interior\n // minor one. Default false — interior is the faithful Euclidean\n // case (his angles live in 0..180°). Set via the\n // `angleMarkerReflex` construction for the rare reflex marking\n // (e.g. a III.20-style central angle).\n public reflex : boolean = false;\n\n constructor(vertex: PointElement, arm1: PointElement, arm2: PointElement,\n plane: PlaneElement, radiusOverride?: number, reflex?: boolean) {\n super();\n this.dimension = 2;\n this._Center = vertex;\n this._arm1 = arm1;\n this._arm2 = arm2;\n this._P = plane;\n this._radiusOverride = radiusOverride != null ? radiusOverride : null;\n this.reflex = reflex === true;\n // Internal arc endpoints — placed in update().\n this._A = new PointElement();\n this._B = new PointElement();\n }\n\n // The vertex this marker sits at — used to group same-vertex\n // markers for auto radius-stepping (#103).\n get vertex() : PointElement { return this._Center; }\n\n // Whether the author pinned an explicit radius (opts the marker out\n // of auto radius-stepping).\n get hasRadiusOverride() : boolean { return this._radiusOverride != null; }\n\n // The interior angle magnitude (radians) between the two arms,\n // computed directly from the arm points so it's available before\n // update() places _A/_B. Used to order a same-vertex group\n // (smallest angle innermost).\n spanRadians() : number {\n return Math.abs(this._Center.angle(this._arm1, this._arm2, this._P));\n }\n\n // update() orders _A/_B so the inherited minor angle is negative\n // (interior, drawn with the default anticlockwise=true). A reflex\n // marker draws the MAJOR arc between the same two rays — same\n // endpoints, opposite side — which is the magnitude 2π−|minor| with\n // the anticlockwise flag flipped (see _anticlockwise).\n protected _arcAngle(): number {\n const minor = this._Center.angle(this._A, this._B, this._P);\n return this.reflex ? (2 * Math.PI - Math.abs(minor)) : minor;\n }\n\n protected _anticlockwise(): boolean {\n return !this.reflex;\n }\n\n // Angle markers flash their whole wedge during a transition (the\n // emphasis bump), not just the edge.\n protected _flashFace(): boolean {\n return true;\n }\n\n radius() : number {\n const a1 = this._Center.distance(this._arm1);\n const a2 = this._Center.distance(this._arm2);\n const shorter = Math.min(a1, a2);\n const base = this._radiusOverride != null\n ? this._radiusOverride\n : DEFAULT_ANGLE_MARKER_RADIUS_PX;\n const clamped = Math.min(base, shorter * ANGLE_MARKER_MAX_ARM_FRACTION);\n return clamped + this.ringIndex * ANGLE_MARKER_RING_STEP;\n }\n\n // Place an internal endpoint at distance r from the vertex along\n // the direction of `arm`.\n private _place(target: PointElement, arm: PointElement, r: number) : void {\n const dx = arm.x - this._Center.x;\n const dy = arm.y - this._Center.y;\n const dz = arm.z - this._Center.z;\n const len = Math.sqrt(dx*dx + dy*dy + dz*dz);\n if (len === 0) {\n target.x = this._Center.x;\n target.y = this._Center.y;\n target.z = this._Center.z;\n return;\n }\n target.x = this._Center.x + dx / len * r;\n target.y = this._Center.y + dy / len * r;\n target.z = this._Center.z + dz / len * r;\n }\n\n update() : void {\n const r = this.radius();\n this._place(this._A, this._arm1, r);\n this._place(this._B, this._arm2, r);\n // Auto-interior: PointElement.angle is signed (−π..π) and atan2\n // already returns the short way, so the magnitude is the\n // interior angle; only the rendered sweep direction matters.\n // The empirically-interior case (matching the old sign-checks)\n // is angle(_A, _B) < 0 — if it's positive, swap the arms.\n const ang = this._Center.angle(this._A, this._B, this._P);\n if (ang > 0) {\n this._place(this._A, this._arm2, r);\n this._place(this._B, this._arm1, r);\n }\n }\n}\n","/*----------------------------------------------------------------------+\n| Title:\tArcElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2026, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {SectorElement} from \"./SectorElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\n/**\n * Port of geom_applet/source/Arc.java — an arc through three points.\n *\n * Given points A, M, B (with M on the arc between A and B), draws the\n * arc of the unique circle passing through all three. The circle's\n * center is recomputed on every update() as circumcenter(A, M, B) and\n * stored in the inherited _Center field; SectorElement.drawEdge then\n * sweeps the arc from A to B using the inherited angle math.\n *\n * _Center is an internal bare PointElement, not registered on the\n * slate. Arc.update() writes into it directly, so it stays in sync\n * with A, M, B without needing a separate elementsForUpdate entry.\n *\n * translate / rotate are overridden so that grabbing and moving the\n * arc (either via a drag or via a global pivot rotation) perturbs\n * only the inherited _Center; A, M, B are independent slate elements\n * and are moved by their own handlers. This mirrors Java Arc.java\n * exactly — see geom_applet/source/Arc.java lines 19-23.\n */\nexport class ArcElement extends SectorElement {\n\n _M : PointElement; // the \"through\" point on the arc between A and B\n\n constructor(A: PointElement, M: PointElement, B: PointElement, P: PlaneElement) {\n super();\n this.dimension = 2;\n this._Center = new PointElement();\n this._A = A;\n this._M = M;\n this._B = B;\n this._P = P;\n }\n\n update(): void {\n // Java Arc.update() explicitly calls P.update() first. The TS\n // slate already updates elements in dependency order, so this\n // is arguably redundant — but we keep it for parity with Java\n // in case some emergent behavior depends on it.\n this._P.update();\n this._Center.toCircumcenter(this._A, this._M, this._B);\n }\n\n translate(dx: number, dy: number): void {\n this._Center.translate(dx, dy);\n }\n\n rotate(pivot: PointElement, ac: number, as: number): void {\n this._Center.rotate(pivot, ac, as);\n }\n}\n","// Animations targeting SectorElement (and its ArcElement subclass).\n// See ../Animations.ts for the abstract base + registry mechanics.\n\nimport {Animation, AllAnimations, IAnimationStep, registerAnimation} from \"../Animations\";\nimport {GeomElement} from \"../GeomElement\";\nimport {Slate} from \"../../Slate\";\nimport {SectorElement} from \"./SectorElement\";\n\n// Same sweep rate as Circle.compass so an angle arc feels like the\n// same instrument; a typical quarter-turn marker (~π/2) sweeps in\n// ~500 ms. Min duration keeps a narrow angle from blinking past.\nconst DEFAULT_SWEEP_RATE_RAD_PER_MS = 0.003;\nconst MIN_SWEEP_MS = 250;\nconst DEFAULT_SECTOR_FILL_MS = 500;\n\n// A.Sector.sweep — the arc grows from the A arm toward the B arm by\n// driving drawProgress. Args: none. Duration = |arcAngle| / rate.\n//\n// Two-step when the sector has a face (sweep then face fade-in,\n// mirroring Circle.compass); a face-less sector skips the fill step\n// entirely (#81 pattern) — which is the common case for zero-color\n// angle markers that render gold only while animating.\nexport class SectorSweepAnimation extends Animation {\n public animationMethod = AllAnimations.SECTOR_SWEEP;\n public name = \"Sector.sweep\";\n public elementType = SectorElement;\n public defaultRate = DEFAULT_SWEEP_RATE_RAD_PER_MS;\n public defaultDurationMs = DEFAULT_SECTOR_FILL_MS;\n\n public build(target: GeomElement, slate: Slate, args: any): IAnimationStep[] {\n const sector = target as SectorElement;\n // arcSpan() reflects what's actually drawn (the major arc for a\n // reflex marker), so the duration matches the visible sweep.\n const arcAngle = sector.arcSpan();\n const sweepMs = Math.max(MIN_SWEEP_MS, arcAngle / this.defaultRate);\n const fullRestore = () => {\n sector.faceAlpha = 1;\n sector.drawProgress = 1;\n sector.visible = true;\n };\n const sweep: IAnimationStep = {\n durationMs: sweepMs,\n setup: () => {\n sector.faceAlpha = 0;\n sector.drawProgress = 0;\n },\n tick: (progress) => { sector.drawProgress = progress; },\n finalise: () => { sector.drawProgress = 1; },\n };\n if (sector.faceColor == null) {\n sweep.finalise = fullRestore;\n return [sweep];\n }\n const fillMs = Math.min(sweepMs / 2, this.defaultDurationMs);\n return [\n sweep,\n {\n durationMs: fillMs,\n tick: (progress) => { sector.faceAlpha = progress; },\n finalise: fullRestore,\n },\n ];\n }\n}\n\nregisterAnimation(new SectorSweepAnimation());\n","/*----------------------------------------------------------------------+\n| Sector construction classes — extracted from Constructions.ts |\n+----------------------------------------------------------------------*/\n\nimport {Construction, ConstructionSignature, SortedParams, AllConstructions,\n SectorConstructions as SectorConstructionsEnum,\n GeomElementsForUpdate} from \"../Constructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {SectorElement} from \"./SectorElement\";\nimport {ArcElement} from \"./ArcElement\";\nimport {AngleMarkerElement} from \"./AngleMarkerElement\";\n\n// sector — points A, B, C [, plane D = screen]\n// 2D: 3 points, 0 elements — uses screen plane\n// 3D: 3 points, 1 PlaneElement — uses explicit plane\n// (Java: Slate.java sector case 0 — new SectorElement(A,B,C,plane))\nexport class SectorConstruction extends Construction {\n constructionMethod: AllConstructions = SectorConstructionsEnum.sector;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new SectorElement({O:P[0], A:P[1], B:P[2], P: plane});\n return [[g], g];\n }\n}\n\n// sector — arc — points A, M, B [, plane D = screen]\n// 2D: 3 points, 0 elements — uses screen plane\n// 3D: 3 points, 1 PlaneElement — uses explicit plane\n// (Java: Slate.java sector case 1 — new ArcElement(A,M,B,plane))\nexport class ArcConstruction extends Construction {\n constructionMethod: AllConstructions = SectorConstructionsEnum.arc;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0\n && (sp.E.length === 0 || (sp.E.length === 1 && sp.E[0] instanceof PlaneElement));\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let plane = E.length > 0 ? E[0] as PlaneElement : screen;\n let g = new ArcElement(P[0], P[1], P[2], plane);\n return [[g], g];\n }\n}\n\n// angleMarker — vertex V, arm points P1, P2 [, int radiusPx]\n// Marks the interior angle P1-V-P2 with a small fixed-radius sector\n// (radius computed by the element, not the arm length). The optional\n// integer overrides the default px radius. 2D screen-plane only for\n// v1. (#91)\nexport class AngleMarkerConstruction extends Construction {\n constructionMethod: AllConstructions = SectorConstructionsEnum.angleMarker;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0 && sp.E.length === 0;\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new AngleMarkerElement(P[0], P[1], P[2], screen);\n return [[g], g];\n }\n}\n\n// angleMarker with an explicit px radius override.\nexport class AngleMarkerRadiusConstruction extends Construction {\n constructionMethod: AllConstructions = SectorConstructionsEnum.angleMarker;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 1 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 1 && sp.E.length === 0;\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new AngleMarkerElement(P[0], P[1], P[2], screen, N[0]);\n return [[g], g];\n }\n}\n\n// angleMarkerReflex — same as angleMarker but draws the major (reflex,\n// > 180°) arc. Rare; Euclid avoids reflex angles, so this is for the\n// occasional teaching case (a III.20-style central angle). (#91)\nexport class AngleMarkerReflexConstruction extends Construction {\n constructionMethod: AllConstructions = SectorConstructionsEnum.angleMarkerReflex;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 0 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 0 && sp.E.length === 0;\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new AngleMarkerElement(P[0], P[1], P[2], screen, undefined, true);\n return [[g], g];\n }\n}\n\nexport class AngleMarkerReflexRadiusConstruction extends Construction {\n constructionMethod: AllConstructions = SectorConstructionsEnum.angleMarkerReflex;\n signature: ConstructionSignature = { points: 3, elements: 0, integers: 1 };\n public validateSignature(cm: AllConstructions, sp: SortedParams): boolean {\n if (cm !== this.constructionMethod) return false;\n return sp.P.length === 3 && sp.N.length === 1 && sp.E.length === 0;\n }\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new AngleMarkerElement(P[0], P[1], P[2], screen, N[0], true);\n return [[g], g];\n }\n}\n\nexport const sectorConstructions: Construction[] = [\n new SectorConstruction(),\n new ArcConstruction(),\n new AngleMarkerConstruction(),\n new AngleMarkerRadiusConstruction(),\n new AngleMarkerReflexConstruction(),\n new AngleMarkerReflexRadiusConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tSectorElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2019, Nelson Brown, brownnrl@gmail.com |\n| https://www.nelsonbrown.net/ |\n+----------------------------------------------------------------------*/\n\nimport {GeomElement} from \"../GeomElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {Midpoint} from \"../point/Midpoint\";\nimport {SlateCanvas} from \"../../Slate\";\n\nexport interface ISectorElementConstruction {\n O: PointElement;\n A: PointElement;\n B: PointElement;\n P: PlaneElement;\n}\n\nexport class SectorElement extends GeomElement {\n\n _Center : PointElement;\n _A : PointElement;\n _B : PointElement;\n // A and B are two points on a circle with the given center\n\n _P : PlaneElement; // plane of the circle\n\n _angle : number = null;\n\n // Face fill alpha — drives drawFace's globalAlpha independent of\n // drawProgress (which drives the arc sweep). Default 1 keeps every\n // existing render path identical. Mirrors Circle/Polygon (#86).\n private _faceAlpha : number = 1;\n\n set faceAlpha(value: number) {\n this._faceAlpha = value < 0 ? 0 : (value > 1 ? 1 : value);\n }\n get faceAlpha(): number { return this._faceAlpha; }\n\n constructor(isec?: ISectorElementConstruction) {\n super();\n this.dimension = 2;\n if(isec != null) {\n this._Center = isec.O;\n this._A = isec.A;\n this._B = isec.B;\n this._P = isec.P;\n }\n }\n\n radius() : number {\n return this._Center.distance(this._A);\n }\n\n defined() {\n return this._A.defined() && this._B.defined() && this._Center.defined();\n }\n\n\n // Here, we differ from the original implementation.\n // Since A and B are on the circle, we find the midpoint M between them.\n // Then we calculate a radius distance along the line from Center M\n // as the \"through\" point.\n\n _updateThroughPoint() : void {\n let r = this.radius();\n if(r == 0) { // degenerate circle\n return;\n }\n this._angle = Math.atan2(this._B.y - this._A.y, this._B.x - this._A.x) -\n Math.atan2(this._Center.y - this._A.y, this._Center.x - this._A.x);\n let x = this._Center.x + Math.cos(this._angle/2) * r;\n let y = this._Center.y + Math.sin(this._angle/2) * r;\n }\n\n drawEdge(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n // Pick the highlight color BEFORE the null bail, matching the\n // other element types (#81 / #86) — a zero-color sector can\n // still render in the highlight stroke while emphasized or\n // slide-highlighted, which is what lets invisible angle\n // markers light up on demand.\n const color = (this.emphasized || this.shouldHighlight)\n ? this.edgeHighlightColor\n : this.edgeColor;\n if (color == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.strokeStyle = color;\n {\n const baseW = this.shouldHighlight ? 3 : 1;\n ctx.lineWidth = (baseW + this.emphasisAmount * (6 - baseW)) * GeomElement.styleScale;\n }\n ctx.beginPath();\n let r = this.radius();\n let startAngle = Math.atan2(\n this._A.y - this._Center.y,\n this._A.x - this._Center.x);\n let arcAngle = this._arcAngle();\n // Partial sweep for slide-transition animation: the arc grows\n // from the A arm toward the B arm as drawProgress goes 0 → 1.\n // Default progress = 1 reproduces the full arc bit-for-bit.\n let endAngle = startAngle + arcAngle * this.drawProgress;\n ctx.arc(this._Center.x, this._Center.y, r, startAngle, endAngle, this._anticlockwise());\n ctx.stroke();\n }\n\n // The signed arc to sweep from the A arm to the B arm, in radians.\n // Default is the minor signed angle (−π..π). AngleMarkerElement\n // overrides this to optionally sweep the major (reflex) arc.\n protected _arcAngle(): number {\n return this._Center.angle(this._A, this._B, this._P);\n }\n\n // Sweep direction passed to ctx.arc. Fixed true for plain sectors /\n // arcs (their authors order _A/_B for that). AngleMarkerElement\n // flips it to draw the major arc between the same two rays for a\n // reflex marker.\n protected _anticlockwise(): boolean {\n return true;\n }\n\n // Magnitude of the swept arc — used by A.Sector.sweep to size the\n // animation duration to what's actually drawn (so a reflex marker\n // doesn't sweep a big arc in a tiny time).\n public arcSpan(): number {\n return Math.abs(this._arcAngle());\n }\n\n // Trace the closed wedge path (arc + the two radii back to centre)\n // into the current ctx path. Shared by the face fill and the flash\n // overlay so they cover exactly the same region.\n protected _traceWedge(ctx: CanvasRenderingContext2D, r: number): void {\n let startAngle = Math.atan2(\n this._A.y - this._Center.y,\n this._A.x - this._Center.x);\n let arcAngle = this._arcAngle();\n let endAngle = startAngle + arcAngle;\n ctx.beginPath();\n ctx.arc(this._Center.x, this._Center.y, r, startAngle, endAngle, this._anticlockwise());\n ctx.moveTo(this._Center.x, this._Center.y);\n if(arcAngle <= 180.) {\n ctx.lineTo(this._A.x, this._A.y);\n ctx.lineTo(this._B.x, this._B.y);\n } else {\n ctx.lineTo(this._B.x, this._B.y);\n ctx.lineTo(this._A.x, this._A.y);\n }\n ctx.lineTo(this._Center.x, this._Center.y);\n }\n\n // Whether the whole wedge should flash (fill with the highlight\n // color) while emphasised. False for plain sectors/arcs — only\n // angle markers light up their fill during a slide transition.\n protected _flashFace(): boolean {\n return false;\n }\n\n drawFace(c: SlateCanvas): void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.faceColor == null || !this.defined()) return;\n // Face is independent of the edge sweep — always the full\n // sector wedge, with alpha driven by the dedicated faceAlpha\n // field (mirrors Circle/Polygon, #86). Default 1 preserves\n // the fully-opaque behaviour for every non-animating consumer.\n let a = this.faceAlpha;\n if (a <= 0) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n let r = this.radius();\n ctx.fillStyle = this.faceColor;\n this._traceWedge(ctx, r);\n if (a < 1) {\n ctx.save();\n ctx.globalAlpha = a;\n ctx.fill();\n ctx.restore();\n } else {\n ctx.fill();\n }\n // Transition flash: while emphasised (the animator bumps\n // emphasisAmount to 1 during a sweep and fades it 1 → 0\n // afterward), light the ENTIRE wedge with the highlight color,\n // fading with the emphasis. Edge-only emphasis (stroke width /\n // gold) already happens in drawEdge; this fills the area too.\n if (this._flashFace() && this.emphasisAmount > 0) {\n ctx.save();\n ctx.fillStyle = this.faceHighlightColor;\n ctx.globalAlpha = 0.55 * this.emphasisAmount;\n this._traceWedge(ctx, r);\n ctx.fill();\n ctx.restore();\n }\n }\n\n drawName(c: SlateCanvas): void {\n }\n\n drawVertex(c: SlateCanvas): void {}\n\n rotate(pivot: PointElement, ac: number, as: number): void {}\n\n translate(dx: number, dy: number): void {}\n\n update(): void {\n this._updateThroughPoint();\n }\n\n}\n","/*----------------------------------------------------------------------+\n| Sphere construction classes — extracted from Constructions.ts |\n+----------------------------------------------------------------------*/\n\nimport {Construction, AllConstructions,\n SphereConstructions as SphereConstructionsEnum,\n GeomElementsForUpdate} from \"../Constructions\";\nimport {GeomElement} from \"../GeomElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\nimport {PointElement} from \"../point/PointElement\";\nimport {SphereElement} from \"./SphereElement\";\n\n// sphere — radius — points A, B\n// (Java: Slate.java sphere case 0 — new SphereElement(A, A, B))\nexport class SphereRadiusConstruction extends Construction {\n constructionMethod: AllConstructions = SphereConstructionsEnum.radius;\n signature = { points: 2, elements: 0, integers: 0 };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new SphereElement({Center: P[0], B: P[1]});\n return [[g], g];\n }\n}\n\n// sphere — radius (3-point) — points A, B, C — center A, radius |BC|\n// (Java: Slate.java sphere case 0, choice 1 — new SphereElement(A,B,C))\nexport class SphereRadius3PointConstruction extends Construction {\n constructionMethod: AllConstructions = SphereConstructionsEnum.radius;\n signature = { points: 3, elements: 0, integers: 0 };\n construct(screen: PlaneElement, P: PointElement[], E: GeomElement[], N: number[]): [GeomElementsForUpdate, GeomElement] {\n let g = new SphereElement({Center: P[0], A: P[1], B: P[2]});\n return [[g], g];\n }\n}\n\nexport const sphereConstructions: Construction[] = [\n new SphereRadius3PointConstruction(),\n new SphereRadiusConstruction(),\n];\n","/*----------------------------------------------------------------------+\n| Title:\tSphereElement.ts |\n| A port of the software Geometry Applet by |\n| Author: David E. Joyce |\n| Department of Mathematics and Computer Science |\n| Clark University |\n| Worcester, MA 01610-1477 |\n| U.S.A. |\n| |\n| http://aleph0.clarku.edu/~djoyce/home.html |\n| djoyce@clarku.edu |\n| |\n| Date: February, 1996. Version 2.0.0 May, 1997. |\n| TypeScript Port: 2024, Nelson Brown, brownnrl@gmail.com |\n+----------------------------------------------------------------------*/\n\n\nimport {GeomElement, Align} from \"../GeomElement\"\nimport {SlateCanvas} from \"../../Slate\";\nimport {PointElement} from \"../point/PointElement\";\nimport {PlaneElement} from \"../plane/PlaneElement\";\n\nexport interface ISphereElementConstruction {\n Center? : PointElement;\n A? : PointElement; // radius is AB\n B? : PointElement; // A assumed to be Center unless provided\n}\n\nexport class SphereElement extends GeomElement {\n\n protected _Center : PointElement;\n protected _A : PointElement; // radius is AB\n protected _B : PointElement;\n\n get Center() : PointElement { return this._Center; }\n\n constructor(ip? : ISphereElementConstruction) {\n super();\n this.dimension = 2;\n this._Center = ip && ip.Center || new PointElement();\n this._A = ip && ip.A || this._Center;\n this._B = ip && ip.B || new PointElement();\n }\n\n public drawName(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if(this.nameColor != null && this.name != null && this.defined()) {\n this.drawString(Math.round(this._Center.x), Math.round(this._Center.y), c, Align.CENTRAL);\n }\n }\n\n public defined() : boolean {\n return true;\n }\n\n public drawEdge(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.edgeColor == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.save();\n ctx.strokeStyle = this.edgeColor;\n let r = this.radius();\n ctx.beginPath();\n // ellipse() takes (centerX, centerY, radiusX, radiusY, ...)\n ctx.ellipse(\n this._Center.x,\n this._Center.y,\n r,\n r,\n 0,\n 0,\n 2*Math.PI);\n ctx.stroke();\n ctx.restore();\n }\n\n public drawFace(c: SlateCanvas) : void {\n if (!this.visible && !this.shouldHighlight && this.emphasisAmount <= 0) return;\n if (this.faceColor == null || !this.defined()) return;\n let ctx = c.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.save();\n ctx.fillStyle = this.faceColor;\n let r = this.radius();\n ctx.beginPath();\n ctx.ellipse(\n this._Center.x,\n this._Center.y,\n r,\n r,\n 0,\n 0,\n 2*Math.PI);\n ctx.fill();\n ctx.restore();\n }\n\n public radius() : number { return this._A.distance(this._B); }\n public radius2() : number { return this._A.distance2(this._B); }\n\n public drawVertex() {}\n public update(): void {}\n public translate(dx: number, dy: number): void {}\n public rotate(pivot: PointElement, ac: number, as : number, plane?: PlaneElement) : void {\n }\n\n}\n","import {GeomElement, Align as align} from \"./elements/GeomElement\"\nimport {AllConstructions, E as e} from \"./elements/Constructions\"\nimport {AllAnimations, A} from \"./elements/Animations\"\n// Per-type animation modules — imported for side effects so each\n// Animation subclass registers with the registry at module load. Adding\n// a new animation file is a one-line `import \"./elements/.../X\"` here.\nimport \"./elements/point/PointAnimations\";\nimport \"./elements/line/LineAnimations\";\nimport \"./elements/circle/CircleAnimations\";\nimport \"./elements/polygon/PolygonAnimations\";\nimport \"./elements/sector/SectorAnimations\";\nimport \"./elements/group/GroupAnimations\";\nimport {PointElement} from \"./elements/point/PointElement\";\nimport {Slate} from \"./Slate\";\nimport {PlaneSlider} from \"./elements/point/PlaneSlider\";\nimport {AngleMarkerElement} from \"./elements/sector/AngleMarkerElement\";\nimport {colors, randomColor, lighten, darken, parseColor, anglePalette} from \"./Colors\";\nimport {createControls, createDiagnosticBadge} from \"./SlateControls\";\nimport {IDiagnostic, DiagnosticSeverity, worstSeverity} from \"./Diagnostics\";\n\nexport type IndexAllConstructions = AllConstructions;\nexport {align as Align};\nexport {e as E};\nexport {AllAnimations, A};\n\n// Build marker — bumped when behaviour-affecting changes ship so consumers\n// (e.g. the test pages used to investigate #55) can confirm which bundle\n// they're actually running.\nexport const BUILD_MARKER = \"pointer-events-refactor-v1 (Slate.ts #55)\";\n\nexport let slates : Slate[] = [];\n\n// #130 — highlight a named element across MORE THAN ONE canvas at once.\n// A proposition drawn as several figures that share element names (e.g.\n// I.26's two case triangles, both labelled ABC/DEF) wants a single prose\n// reference to light the element in EVERY canvas it appears in, not just\n// one. This sets `emphasized` on each matching element — alias-aware, via\n// `slate.lookupElement` (so a ref spelled \"CBA\" still matches \"ABC\") —\n// across all live slates, or only those whose canvas id is listed in\n// `opts.canvasids` (scope correctly on a page with unrelated figures).\n// Each touched slate is redrawn, which fires that canvas's\n// `geomlib:highlight` event (#108) so the page lights every prose span.\n// Returns the number of canvases the element was found in.\nexport function highlightByName(name: string, on: boolean = true,\n opts?: { canvasids?: string[] }): number {\n const ids = opts && opts.canvasids;\n let hits = 0;\n for (const slate of slates) {\n if (ids != null) {\n const id = (slate.canvas as any) && (slate.canvas as any).id;\n if (ids.indexOf(id) === -1) continue;\n }\n const el = slate.lookupElement(name);\n if (el == null) continue;\n el.emphasized = on;\n slate.update();\n hits++;\n }\n return hits;\n}\n\n// #154 — check a deck's names at load, not only when a slide runs.\n//\n// Every name in a slide set and every animation target is resolved once\n// here, so a stale reference reports the moment the figure is built.\n// Without this the diagnostic only fires if a viewer actually advances\n// to the offending slide — which is precisely the case that goes\n// unnoticed, and would leave a build-time checker seeing a clean page.\n//\n// Reporting is deduped per slate, so a name the walk later hits again\n// does not report twice.\nfunction validateSlides(slate: Slate, slides: ISlide[]): void {\n for (let n = 0; n < slides.length; n++) {\n const slide = slides[n];\n for (const field of [\"visible\", \"highlighted\"]) {\n const names = (slide as any)[field] as string[] | undefined;\n if (names == null) continue;\n for (const name of names) {\n if (slate.lookupElement(name) != null) continue;\n slate.reportDiagnostic({\n code: \"unknown-slide-name\",\n key: field + \":\" + name,\n message: \"slide \" + (n + 1) + \" lists '\" + name +\n \"' in \" + field + \", but no element or alias resolves to it \\u2014 \" +\n \"the name is ignored. Check for a typo, or for a target left \" +\n \"behind by a figure change.\",\n detail: { slide: n + 1, field: field, name: name },\n });\n }\n }\n const anims = slide.transition && slide.transition.animations;\n if (anims == null) continue;\n for (const entry of anims) {\n if (entry.elem == null) continue;\n if (slate.lookupElement(entry.elem) != null) continue;\n slate.reportDiagnostic({\n code: \"unknown-element\",\n key: String(entry.elem),\n message: \"slide \" + (n + 1) + \" animates '\" + entry.elem +\n \"', but no element or alias resolves to it \\u2014 the step \" +\n \"is skipped. Check for a typo, or for a target left behind \" +\n \"by a figure change.\",\n detail: { slide: n + 1, elem: entry.elem },\n });\n }\n }\n}\n\nexport interface ISlateDiagnostics {\n canvasid: string | null;\n index: number;\n severity: DiagnosticSeverity | null;\n entries: IDiagnostic[];\n}\n\n/**\n * Every diagnostic on the page, in one call (#154).\n *\n * Exists so a consumer — a static-site generator checking decks at build\n * time, or a human in a console — can ask \"did anything on this page go\n * wrong?\" without reimplementing geomlib's own name-resolution rules.\n * Only slates that actually reported something are listed.\n *\n * `opts.canvasids` scopes the query, mirroring highlightByName's idiom.\n */\nexport function diagnostics(opts?: { canvasids?: string[] }): {\n severity: DiagnosticSeverity | null;\n count: number;\n slates: ISlateDiagnostics[];\n init: IDiagnostic[];\n} {\n const ids = opts && opts.canvasids;\n let worst: DiagnosticSeverity | null = null;\n let count = 0;\n const out: ISlateDiagnostics[] = [];\n for (let i = 0; i < slates.length; i++) {\n const slate = slates[i];\n const id = ((slate.canvas as any) && (slate.canvas as any).id) || null;\n if (ids != null && (id == null || ids.indexOf(id) === -1)) continue;\n const entries = slate.diagnostics;\n if (entries.length === 0) continue;\n worst = worstSeverity(worst, slate.diagnosticSeverity);\n count += entries.length;\n out.push({ canvasid: id, index: i, severity: slate.diagnosticSeverity, entries });\n }\n for (const d of initDiagnostics) {\n worst = worstSeverity(worst, d.severity);\n count++;\n }\n return { severity: worst, count, slates: out, init: initDiagnostics.slice() };\n}\n\nexport interface IConstructionInfo {\n name: string;\n construction: IndexAllConstructions;\n params: any[];\n nameColor?: string | number;\n vertexColor?: string | number;\n edgeColor?: string | number;\n faceColor?: string | number;\n}\n\n// Marginal-reference shape for slides. The `ref` is a symbolic label\n// such as \"I.Post.3\" or \"C.N.1\"; URL resolution happens via the\n// consumer-supplied resolveJustification callback so the data here\n// doesn't go stale if a referenced page moves on the consumer site.\nexport interface ISlideJust {\n ref: string;\n // 0.14.0+ — what this step CLAIMS, rendered ahead of the citation as\n // \"claim — ref\" (#146). Without it the chip can say which proposition\n // licenses a step but never what the step asserts, so a slide carrying\n // several reasoning steps had to be split one-per-sub-slide just to\n // keep each statement next to its own citation. Plain text; omit it and\n // the panel renders exactly as before.\n claim?: string;\n}\n\n// One step in the slideshow / presentation walk-through. The DSL is\n// declarative: each slide describes its full effective state, and the\n// Presentation controller computes the transitions between them.\n//\n// - visible inherits from the previous slide if omitted, so authors\n// only re-specify on state change.\n// - highlighted defaults to [] (clears between slides), so a\n// highlight only persists when re-specified on the next slide.\n// - Draggable elements (e.draggable === true) are auto-unioned into\n// the visible set by the Presentation controller; authors don't\n// need to list free construction points per slide.\n// - Highlighted elements are auto-unioned into visible — you can't\n// highlight what isn't drawn.\n// Per-element animation choice on one slide. Cascade order = the\n// array order. An element revealed by the slide but not listed here\n// pops in instantly. See A.* / AllAnimations for valid name values.\nexport interface ISlideAnimation {\n elem: string;\n name: AllAnimations | string;\n args?: any;\n durationMs?: number;\n}\n\nexport interface ISlideTransition {\n mode?: \"cascade\" | \"parallel\";\n animations?: ISlideAnimation[];\n}\n\nexport interface ISlide {\n text: string;\n visible?: string[];\n highlighted?: string[];\n justifications?: ISlideJust[];\n transition?: ISlideTransition;\n}\n\n// Slate-level animation tuning. No \"default animations\" — animations\n// are strictly opt-in per slide via slide.transition.animations. A\n// slate that never sets animationConfig keeps the 0.5.0 instant\n// behaviour everywhere.\nexport interface IAnimationConfig {\n // Per-animation rate overrides, keyed by animation name. Lets a\n // consumer dial all \"Line.straightEdgeConnect\" animations 30%\n // slower without touching individual slides.\n rates?: { [animationName: string]: number };\n // Per-animation duration overrides.\n durations?: { [animationName: string]: number };\n // Pause between cascaded steps; default 0.\n cascadeGapMs?: number;\n // Global multiplier; 1.0 default; 0 = jump-to-final.\n speedMultiplier?: number;\n // Default reads prefers-reduced-motion CSS media query at init().\n reducedMotion?: boolean;\n}\n\nexport interface IInitialization {\n background : string;\n title : string;\n align? : align;\n canvasid? : string;\n pivot?: string;\n font?: string;\n fontsize?: number;\n // Authored logical coordinate size (#71). Optional — normally inferred\n // from the canvas's CSS style px / width-height attribute. Set it to\n // pin the coordinate space when neither is declared, or to override.\n width?: number;\n height?: number;\n elements: (IConstructionInfo | string)[];\n // Secondary element names that resolve to a canonical element.\n // Lets prose name an element under any of the conventional\n // letter-permutations (e.g. \"circle BCD\" ≡ \"circle CDB\") without\n // forcing the canvas to carry an invisible duplicate per alias.\n // Resolved by Slate.lookupElement after a direct-name miss.\n aliases?: {[from: string]: string};\n // Draggable element names excluded from the slideshow's\n // every-slide auto-union (#89). Use for draggables the proof\n // introduces mid-walk (\"Take an arbitrary point F\") so they stay\n // hidden until a slide's visible set includes them. They remain\n // fully draggable whenever shown. No effect outside presentation\n // mode.\n deferDraggables?: string[];\n // 0.9.0+ — element names that start hidden in the static figure\n // (visible = false). Revealed by a slide's visible set, or when the\n // element is highlighted / its {NAME} ref is hovered. clearVisibility\n // (presentation exit) restores to this baseline. (#100)\n initiallyHidden?: string[];\n // 0.9.0+ — show angle markers (E.Sector.angleMarker /\n // angleMarkerReflex) in the static figure. Default false: markers\n // are hidden initially (Euclid's source diagram draws no angle arcs)\n // and appear during the slide walk or on hover. (#100)\n showAngles?: boolean;\n // 0.14.0+ — draw highlighted / mid-animation elements last within each\n // draw pass, so a neighbour declared later in `elements` can't paint\n // over the gold stroke where it crosses. Promotion is within a pass, so\n // a promoted face still stays under every edge. Default true; set false\n // to keep the strict declaration order. (#140)\n highlightOnTop?: boolean;\n // Optional slideshow walk-through. When provided + non-empty,\n // SlateControls renders a \"▶ Present\" button that opens the\n // Presentation overlay. Stays empty (no button, no behaviour\n // change) for consumers that don't opt in.\n slides?: ISlide[];\n // Consumer lookup that maps a justification ref (\"I.Post.3\") to\n // a URL string. Returning null/undefined renders the ref as\n // plain text. Sync; the lektor site wires this to a page-emitted\n // window.eucrefs map.\n resolveJustification?: (ref: string) => string | null | undefined;\n // Slide-transition animation config. Optional; without it, the\n // slideshow keeps the 0.5.0 instant behaviour. Animations are\n // also strictly per-slide opt-in — even with animationConfig set,\n // a slide without transition.animations pops in instantly.\n animationConfig?: IAnimationConfig;\n}\n\n// Map Java element class names to E object keys\nconst typeMap: {[key: string]: string} = {\n \"point\": \"Point\", \"line\": \"Line\", \"circle\": \"Circle\",\n \"polygon\": \"Polygon\", \"sector\": \"Sector\", \"plane\": \"Plane\",\n \"sphere\": \"Sphere\", \"polyhedron\": \"Polyhedra\"\n};\n\n// Parse a Java applet param value string into an IConstructionInfo.\n// Format: \"name;type;construction;arg1,arg2,...[;nameColor[;vertexColor[;edgeColor[;faceColor]]]]\"\n// Example: \"M;point;midpoint;A,B;0;0\" → { name: \"M\", construction: E.Point.midpoint, params: [\"A\",\"B\"], nameColor: \"0\", vertexColor: \"0\" }\nexport function parseParam(value: string): IConstructionInfo {\n let fields = value.split(\";\");\n if (fields.length < 4) {\n throw new Error(`parseParam: expected at least 4 semicolon-separated fields, got ${fields.length}: \"${value}\"`);\n }\n\n let name = fields[0];\n let type = fields[1];\n let construction = fields[2];\n let data = fields[3];\n\n // Look up the construction enum value\n let typeKey = typeMap[type];\n if (typeKey == null) {\n throw new Error(`parseParam: unknown element type \"${type}\" in \"${value}\"`);\n }\n let enumObj = (e as any)[typeKey];\n // Handle Java names that differ from TS enum keys\n let enumKey = construction === \"3points\" ? \"threePoints\" : construction;\n let constructionEnum = enumObj[enumKey];\n if (constructionEnum == null) {\n throw new Error(`parseParam: unknown construction \"${type};${construction}\" in \"${value}\"`);\n }\n\n // Parse params: split on comma, convert numeric strings to numbers\n let params: any[] = data.split(\",\").map(s => {\n let n = Number(s);\n return (s !== \"\" && !isNaN(n)) ? n : s;\n });\n\n // Parse optional color fields (positions 4-7)\n let result: IConstructionInfo = { name, construction: constructionEnum, params };\n if (fields.length > 4 && fields[4] !== undefined) result.nameColor = fields[4];\n if (fields.length > 5 && fields[5] !== undefined) result.vertexColor = fields[5];\n if (fields.length > 6 && fields[6] !== undefined) result.edgeColor = fields[6];\n if (fields.length > 7 && fields[7] !== undefined) result.faceColor = fields[7];\n\n return result;\n}\n\n// The construction's authored coordinate extent (logical px). Element\n// coords are authored in this space; the figure is fit-scaled from here to\n// the (responsive) display. Read before the bitmap is resized. (#71)\nfunction authoredLogicalSize(i: IInitialization, canvas: HTMLCanvasElement) : [number, number] {\n const c = canvas as any;\n const px = (s: any) => {\n const m = /^\\s*(\\d+(?:\\.\\d+)?)\\s*px\\s*$/.exec(typeof s === \"string\" ? s : \"\");\n return m ? parseFloat(m[1]) : 0;\n };\n const style = c.style || {};\n const attr = (n: string) => (typeof c.getAttribute === \"function\"\n ? parseInt(c.getAttribute(n) || \"0\", 10) || 0 : 0);\n const w = (i.width || 0) || px(style.width) || attr(\"width\") || c.clientWidth || canvas.width;\n const h = (i.height || 0) || px(style.height) || attr(\"height\") || c.clientHeight || canvas.height;\n return [w, h];\n}\n\n// Size the canvas BITMAP to its CSS display size × devicePixelRatio so it\n// renders crisp on HiDPI / retina (#71). The construction coordinate space\n// stays in CSS px (clientWidth/Height); drawElements scales the context by\n// dpr. Headless / no window → dpr 1, so node rendering is unchanged.\n// see https://stackoverflow.com/questions/4938346/canvas-width-and-height-in-html5\nfunction resizeCanvasToDisplaySize(canvas: HTMLCanvasElement) : void {\n const dpr = (typeof window !== \"undefined\" && window.devicePixelRatio) || 1;\n const width = Math.round(canvas.clientWidth * dpr);\n const height = Math.round(canvas.clientHeight * dpr);\n\n if (canvas.width != width || canvas.height != height) {\n canvas.width = width;\n canvas.height = height;\n }\n}\n\n/**\n * If init() fails partway, the canvas stays blank and the user sees\n * nothing — the <noscript> tag won't fire because JS *is* running, it\n * just errored. This helper looks for a <noscript> sibling of the\n * canvas (the conventional location for the static-image fallback,\n * e.g. <noscript><img src=\"propI4.gif\"/></noscript>), reparses its\n * contents, inserts them as a visible sibling, and hides the canvas.\n *\n * Safe no-op if `canvas` is null, has no noscript sibling, or any\n * DOM operation throws. Exported so consumers can call it directly\n * if they have their own error-handling path.\n */\nexport function revealNoscriptFallback(canvas: HTMLCanvasElement | null): void {\n if (!canvas) return;\n try {\n // Scan up to ~5 element siblings forward — the <noscript> is\n // usually the immediate next, but the document may have other\n // markup interleaved.\n let sibling = canvas.nextElementSibling;\n let attempts = 0;\n while (sibling && attempts++ < 5 && sibling.tagName !== \"NOSCRIPT\") {\n sibling = sibling.nextElementSibling;\n }\n if (!sibling || sibling.tagName !== \"NOSCRIPT\") return;\n\n // With JS enabled, <noscript>'s contents are a single text node\n // holding the raw markup. Reparse via a wrapper div.\n let html = sibling.innerHTML;\n if (!html) return;\n let wrapper = document.createElement(\"div\");\n wrapper.innerHTML = html;\n sibling.parentNode?.insertBefore(wrapper, sibling);\n canvas.style.display = \"none\";\n } catch (_) {\n // Swallow: this is an emergency fallback. If we can't reveal it,\n // the user is no worse off than before this helper existed.\n }\n}\n\n// #154 — a slate-less record of init() failures. init() throws before any\n// Slate exists in the common case (a wrong canvasid makes `new Slate(null)`\n// throw), so these can't live on a slate and are collected here instead.\nexport let initDiagnostics : IDiagnostic[] = [];\n\n/**\n * Mark a failed init on the page, next to where the diagram would have been.\n *\n * Deliberately modest. On the most common failure — a canvasid that matches\n * nothing — there is no canvas to badge, and a marker floating at some\n * arbitrary spot is worse than none; the console error plus the revealed\n * <noscript> image is the indication. So: badge when there is an anchor,\n * stay silent when there isn't.\n *\n * The whole body swallows its own exceptions, matching\n * revealNoscriptFallback. init()'s catch re-throws the original error, and\n * a throw from in here would replace it.\n */\nexport function markInitFailure(canvas: HTMLCanvasElement | null, canvasid: string): void {\n try {\n if (typeof document === \"undefined\") return;\n const anchor = canvas ||\n (document.getElementById(canvasid) as HTMLCanvasElement | null);\n if (!anchor) return;\n const host = anchor.parentElement;\n if (!host) return;\n const badge = createDiagnosticBadge(\"error\");\n // Static, not absolute: createControls is the last statement of\n // initInner, so on failure the positioned .geomlib-wrapper almost\n // never exists and there is no containing block to anchor to. An\n // inline-block sibling just before the canvas lands where the\n // diagram's top-left would have been.\n badge.style.position = \"static\";\n badge.style.display = \"inline-block\";\n badge.style.verticalAlign = \"top\";\n host.insertBefore(badge, anchor);\n } catch (_) { /* never let the badge replace the real error */ }\n}\n\nexport function init(i : IInitialization) {\n let canvasid : string = i.canvasid != null ? i.canvasid : \"canvasid\";\n let canvas = document.getElementById(canvasid) as HTMLCanvasElement;\n try {\n initInner(i, canvas);\n } catch (err) {\n // Blank canvas + console error = silent failure from the\n // visitor's point of view. Reveal the conventional <noscript>\n // static-image fallback so they at least see the diagram, then\n // re-throw so callers / test harnesses can detect the failure.\n console.error(\"[geomlib] init failed:\", err);\n initDiagnostics.push({\n severity: \"error\", code: \"init-failed\",\n message: \"init failed: \" + String(err),\n detail: { canvasid: canvasid }, at: Date.now(), count: 1,\n });\n // Badge BEFORE revealing the fallback: revealNoscriptFallback sets\n // canvas.style.display = \"none\", so inserting first puts the mark\n // above the static image rather than beside a hidden canvas.\n markInitFailure(canvas, canvasid);\n revealNoscriptFallback(canvas);\n throw err;\n }\n}\n\nfunction initInner(i: IInitialization, canvas: HTMLCanvasElement) {\n // Java defaults to CENTRAL (0) — dynamic placement based on\n // position relative to canvas center. Override with align param.\n let defaultAlign : align = i.align != null ? i.align : align.CENTRAL;\n\n // Capture the authored LOGICAL coordinate size (#71) before\n // resizeCanvasToDisplaySize overwrites the bitmap: explicit config →\n // CSS style px → width/height attribute → clientWidth. The first three\n // are the uncapped authored size (so a figure stays its logical size\n // even when CSS shrinks the display on a narrow column); clientWidth is\n // the last-resort legacy behaviour.\n const [logicalW, logicalH] = authoredLogicalSize(i, canvas);\n resizeCanvasToDisplaySize(canvas);\n let slate : Slate = new Slate(canvas);\n slate.setLogicalSize(logicalW, logicalH);\n slate.recomputeFitScale();\n slates.push(slate);\n\n // Set font — Java defaults: Font(\"TimesRoman\", Font.ITALIC, 18)\n let fontName = i.font != null ? i.font : \"Times New Roman\";\n let fontSize = i.fontsize != null ? i.fontsize : 18;\n GeomElement.setFont(fontName, fontSize);\n // Parse background through parseColor so HSB triples like \"35,19,100\"\n // are converted to valid CSS rgb() strings for ctx.fillStyle.\n slate.bgcolor = parseColor(i.background, \"#ffffff\", \"#ffffff\");\n // Cycles the angle-marker palette in construction order (#91) so\n // concurrent markers get distinct colors.\n let angleMarkerCount = 0;\n for(let raw of i.elements) {\n let param: IConstructionInfo = typeof raw === \"string\" ? parseParam(raw) : raw;\n let element = slate.createElement(param.construction, param.params, param.name);\n\n element.align = defaultAlign;\n\n // Angle markers default to a translucent palette fill + solid\n // colored edge instead of the dim2 lighten-bg face / black edge.\n // The rgba face is set directly (it wouldn't survive parseColor)\n // unless the author supplies an explicit faceColor param.\n if (element instanceof AngleMarkerElement) {\n const swatch = anglePalette[angleMarkerCount % anglePalette.length];\n angleMarkerCount++;\n element.nameColor = parseColor(param.nameColor, null, slate.bgcolor);\n element.vertexColor = parseColor(param.vertexColor, null, slate.bgcolor);\n element.edgeColor = parseColor(param.edgeColor, swatch.edge, slate.bgcolor);\n if (param.faceColor != null) {\n element.faceColor = parseColor(param.faceColor, swatch.edge, slate.bgcolor);\n } else {\n element.faceColor = swatch.face;\n }\n continue;\n }\n\n // Name string\n let defaultNameColor = element instanceof PointElement ? \"black\" : null;\n element.nameColor = parseColor(param.nameColor, defaultNameColor, slate.bgcolor);\n\n let defaultVertexColor = element.draggable ?\n ((element instanceof PlaneSlider) ?\n 'red' : 'orange')\n : 'black';\n element.vertexColor = parseColor(param.vertexColor, defaultVertexColor, slate.bgcolor);\n\n element.edgeColor = parseColor(param.edgeColor, \"black\", slate.bgcolor);\n\n let lighterColor = lighten(slate.bgcolor);\n let defaultFaceColor = element.dimension == 2 ? lighterColor : null;\n element.faceColor = parseColor(param.faceColor, defaultFaceColor, slate.bgcolor);\n }\n\n if (i.aliases != null) {\n slate.addAliases(i.aliases);\n }\n\n if (i.deferDraggables != null) {\n slate.deferDraggables(i.deferDraggables);\n }\n\n // #140 — opt out of highlight/animation z-order promotion. Default is\n // on, so only an explicit `false` changes anything.\n if (i.highlightOnTop != null) {\n slate.highlightOnTop = i.highlightOnTop;\n }\n\n // Angle markers are hidden in the static figure by default (Euclid's\n // diagram draws no angle arcs); init({ showAngles: true }) reveals\n // them. Plus any explicit initiallyHidden names. clearVisibility\n // restores to this baseline. (#100)\n if (!i.showAngles) {\n for (let elem of slate.elements) {\n if (elem instanceof AngleMarkerElement && elem.name != null) {\n slate.setInitiallyHidden(elem.name);\n }\n }\n }\n if (i.initiallyHidden != null) {\n for (let name of i.initiallyHidden) slate.setInitiallyHidden(name);\n }\n\n // Same-vertex angle markers auto-nest: group by shared vertex and\n // step each one's radius into a concentric ring (smallest interior\n // angle innermost), with distinct palette colors within the group,\n // so they don't overlap. Author radiusPx overrides opt out of the\n // ring-stepping. Runs before update() places the arc endpoints. (#103)\n {\n const byVertex = new Map<PointElement, AngleMarkerElement[]>();\n for (let elem of slate.elements) {\n if (elem instanceof AngleMarkerElement) {\n let g = byVertex.get(elem.vertex);\n if (g == null) { g = []; byVertex.set(elem.vertex, g); }\n g.push(elem);\n }\n }\n byVertex.forEach((group: AngleMarkerElement[]) => {\n if (group.length <= 1) return;\n // Smallest angle innermost so a tight wedge nests inside a\n // wider one sharing the vertex.\n group.sort((a, b) => a.spanRadians() - b.spanRadians());\n let ring = 0;\n group.forEach((m, idx) => {\n // Distinct color per group member (de-clash by group\n // position). Author param-color overrides are left alone.\n const isDefault = anglePalette.some(p => p.face === m.faceColor);\n if (isDefault) {\n const sw = anglePalette[idx % anglePalette.length];\n m.edgeColor = sw.edge;\n m.faceColor = sw.face;\n }\n // Pinned-radius markers keep their explicit radius (ring\n // 0); only auto-radius markers step outward, consecutively.\n if (!m.hasRadiusOverride) { m.ringIndex = ring; ring++; }\n });\n });\n }\n\n if (i.slides != null && i.slides.length > 0) {\n slate.slides = i.slides;\n validateSlides(slate, i.slides);\n }\n\n if (i.resolveJustification != null) {\n slate.resolveJustification = i.resolveJustification;\n }\n\n if (i.animationConfig != null) {\n slate.animationConfig = i.animationConfig;\n }\n\n if(i.pivot != null) {\n slate.setPivot(i.pivot);\n }\n\n slate.update();\n slate.updateCoordinates(0);\n\n // Add UI controls (reset, maximize, present) if running in browser\n if (canvas && canvas.parentElement) {\n createControls(slate, canvas, i);\n }\n}\n\n","// Pure-data helpers for the slideshow presentation mode (issue #75).\n// Lives in its own module so SlideTest can exercise the state-machine\n// rules without any DOM, while SlateControls.ts owns the overlay.\n\nimport {Slate} from \"./Slate\";\nimport {ISlide} from \"./index\";\n\n\n// #151 — resolve slide-set names through the alias table, and report the\n// ones that resolve to nothing.\n//\n// Aliases worked for prose `{NAME}` refs and `lookupElement`, but a slide's\n// `visible` / `highlighted` arrays were passed through verbatim and both\n// consumers compare against the element's own `name`. An alias placed in a\n// slide set therefore matched nothing and was **silently** ignored: no\n// error, no warning, the element just never lit. An audit of the lektor\n// decks found 33 such inert names across 17 canvases, spanning propositions\n// I.8 to I.47.\n//\n// The asymmetry was the trap: an author who wrote `aliases: { FC: \"CF\" }`\n// and watched `{FC}` light from the prose had every reason to expect \"FC\" to\n// work in a slide set too.\n\n/**\n * Map slide-set names onto the element names the renderers actually compare\n * against, following one alias hop via `lookupElement`.\n *\n * Returns the canonical set plus every name that resolved to no element.\n * An unmatched name is kept in the set as authored — dropping it would\n * change nothing on screen (nothing matches it either way) and keeping it\n * makes the returned set a faithful record of what the slide asked for.\n */\nexport function canonicaliseSlideNames(\n slate: Slate,\n names: string[],\n): { canonical: Set<string>, unmatched: string[] } {\n const canonical = new Set<string>();\n const unmatched: string[] = [];\n for (const name of names || []) {\n const elem = slate.lookupElement(name);\n if (elem != null && elem.name != null) {\n canonical.add(elem.name);\n } else {\n canonical.add(name);\n unmatched.push(name);\n }\n }\n return { canonical, unmatched };\n}\n\n// Compute the visible + highlighted name sets for slide `index` given:\n// - visible inherits from the previous slide if omitted;\n// \"hide all at start\" applies when no earlier slide ever declared\n// visible (initial state is the empty set).\n// - highlighted clears each slide (defaults to []).\n// - Every draggable element on the slate is auto-unioned into\n// visible — free construction points always stay interactive —\n// EXCEPT names in slate.deferredDraggables (#89): draggables the\n// proof introduces mid-walk follow visible sets like any other\n// element.\n// - Every highlighted name is auto-unioned into visible — you can't\n// highlight what isn't drawn.\n// - Names are resolved through the alias table (#151), so a slide set may\n// spell an element any way the prose does. A name matching no element\n// is reported once per slate via console.warn — that also surfaces\n// stale targets left behind when a figure is refactored.\nexport function computeSlideState(\n slate: Slate,\n slides: ISlide[],\n index: number,\n): { visible: Set<string>, highlighted: Set<string> } {\n // Walk back to find the most recent explicit `visible` array.\n let baseVisible: string[] = [];\n let baseIndex = index;\n for (let i = index; i >= 0; i--) {\n if (slides[i].visible != null) {\n baseVisible = slides[i].visible;\n baseIndex = i;\n break;\n }\n }\n // #151 — resolve aliases before the renderers compare against e.name.\n const v = canonicaliseSlideNames(slate, baseVisible);\n const visible = v.canonical;\n reportUnmatched(slate, v.unmatched, baseIndex, \"visible\");\n\n const slide = slides[index];\n const h = canonicaliseSlideNames(slate, slide.highlighted || []);\n const highlighted = h.canonical;\n reportUnmatched(slate, h.unmatched, index, \"highlighted\");\n\n for (const e of slate.elements) {\n if (e.draggable && e.name != null\n && !slate.deferredDraggables.has(e.name)) {\n visible.add(e.name);\n }\n }\n highlighted.forEach(name => visible.add(name));\n\n return { visible, highlighted };\n}\n\n// Shared wording for an unmatched slide-set name, so `visible`,\n// `highlighted` and an animation's `elem:` all read the same in the console.\nfunction reportUnmatched(\n slate: Slate,\n unmatched: string[],\n slideIndex: number,\n field: string,\n): void {\n for (const name of unmatched) {\n // #154 — reported through the slate so the canvas can badge it;\n // reportDiagnostic owns the dedupe that warnOnce used to do.\n slate.reportDiagnostic({\n code: \"unknown-slide-name\",\n key: field + \":\" + name,\n message: \"slide \" + (slideIndex + 1) + \" lists '\" + name +\n \"' in \" + field + \", but no element or alias resolves to it — \" +\n \"the name is ignored. Check for a typo, or for a target left \" +\n \"behind by a figure change.\",\n detail: { slide: slideIndex + 1, field: field, name: name },\n });\n }\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// startup\n// Load entry module and return exports\n// This entry module is referenced by other modules so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(8156);\n"],"names":["randomColor","c","HSVtoRGB","Math","random","r","g","b","brighter","col","rgb","parseRGB","FACTOR","threshold","ceil","min","floor","darker","m","match","parseInt","colors","hex","replace","test","n","parts","split","length","h","s","isNaN","v","i","f","p","q","t","round","val","dfault","bgcolor","str","String","lower","toLowerCase","cssColors","anglePalette","edge","face","dedupeKeyOf","input","sev","severity","k","key","message","code","worstSeverity","a","SEVERITY_RANK","log","d","diagnostic","count","warning","error","_entries","_byKey","_worst","report","now","existing","this","rec","at","detail","push","slice","clear","DiagnosticLog","isPromoted","e","shouldHighlight","emphasized","drawProgress","promotedDrawOrder","elements","promoted","rest","concat","canvas","_aliases","Map","_highlightOnTop","_slides","_resolveJustification","_animationConfig","_animator","_ephemerals","_centringBounds","_viewOffsetX","_viewOffsetY","_viewScale","_logicalWidth","_logicalHeight","_lastHighlightedKey","_diagnostics","_diagnosticListeners","_htmlCanvas","inTest","_itsNumSlate","_deferredDraggables","Set","_initiallyHidden","Slate","numSlate","_elements","TypeError","_canvas","screen_origin","FixedPoint","x","y","z","name","screen_x","screen_y","screen","PlaneElement","A","B","C","nameColor","isScreen","_screen","_pick","vertexColor","vertexHighlightColor","faceColor","faceHighlightColor","slate","cnv","addEventListener","style","touchAction","activePointerId","ev","pointerId","setPointerCapture","_","_getCanvasPosition","clientX","clientY","_onMouseDown","_onMouseDrag","endPointer","_onMouseUp","releasePointerCapture","getBoundingClientRect","F","left","top","movePick","value","_bgcolor","lookupElement","elem","canonical","get","addAlias","from","to","set","addAliases","aliases","deferDraggables","names","add","addEphemeral","addElement","indexOf","removeEphemeral","splice","clearEphemerals","_dpr","window","devicePixelRatio","width","height","setLogicalSize","w","clientWidth","clientHeight","recomputeFitScale","sx","displayWidth","logicalWidth","sy","displayHeight","logicalHeight","setViewOffset","clearViewOffset","visibleBounds","_bounds","figureBounds","_paintsInk","visible","PointElement","edgeColor","captureCentringBounds","inked","clearCentringBounds","visibleOnly","accept","minX","Infinity","maxX","minY","maxY","startsWith","PolygonElement","V","CircleElement","radius","Center","LineElement","namesFor","forEach","target","_ensureAnimator","SlateAnimator","animateTo","targetVisible","targetHighlighted","slideAnimations","mode","run","setVisibleNames","has","setInitiallyHidden","clearVisibility","convertParams","params","keepLineElements","P","E","N","param","findConstruction","cm","sp","constructions","validateSignature","createElement","keepLines","some","constructionMethod","keepsLineElements","cName","getConstructionName","construct","gs","preexists","reset","update","drawElements","ctx","getContext","dpr","tx","ty","GeomElement","styleScale","setTransform","clearRect","fillStyle","fillRect","order","drawFace","drawEdge","drawVertex","drawName","_dispatchHighlightChange","sort","join","dispatchEvent","CustomEvent","highlighted","map","bubbles","reportDiagnostic","Date","console","fn","warn","_dispatchDiagnostic","_notifyDiagnosticListeners","entries","clearDiagnostics","onDiagnosticsChanged","listener","l","diagnosticEventDetail","updateCoordinates","defined","translateCoordinates","dx","dy","translate","closestVisiblePoint","tolerance","screenDist2","sortedDistanceElements","filter","adcp","bdcp","bestDistPoint","sqrt","_getPick","currentPoint","setPivot","pointName","trim","piv","planeName","pivot","_AP","picki","ox","oy","loX","hiX","loY","hiY","abs","draggable","drag","AP","rotateCoordinates","pick","oldP","difference","newx","newy","S","T","olds","dot","oldt","den","news","newt","ac","as","rotate","HAS_RAF","requestAnimationFrame","NOW","performance","groups","resolveCurrent","cascadeIndex","rafId","lastFrameMs","fadingOut","fadeStartMs","cancel","config","animationConfig","speedMul","speedMultiplier","reduced","reducedMotion","entry","animation","findAnimation","elementType","constructor","resolvedSteps","build","args","step","durationMs","resolveDuration","durations","elapsedMs","started","finalised","steps","currentIndex","animatedTargets","willBeVisible","willBeHighlighted","setup","finalise","Promise","resolve","_kickoff","_scheduleFrame","_clearAnimatedEmphasis","cancelAnimationFrame","_startGroupIndex","_startStep","idx","stepIdx","_frame","setTimeout","nowMs","cascadeGap","cascadeGapMs","rawDt","dt","_tickCascade","_tickParallel","_allFinalised","fadeElapsed","fp","ea","emphasisAmount","_tickStep","finishedAtMs","total","tick","stepDefault","slideOverride","configOverride","parentElement","SlateControls","init","isCoarsePointer","matchMedia","matches","BTN_SIZE","BTN_GAP","BTN_MARGIN","CONTROLS_STYLE_ID","trackWindowResize","callback","handler","removeEventListener","escapeAction","state","presenting","maximized","CAPTION_NAME","CAPTION_RE","RegExp","parseCaptionTokens","text","out","re","source","lastIndex","exec","index","kind","piped","display","justsUseStackedLayout","justs","j","claim","_maximized","_savedStyles","_stopTrackingResize","_badge","_badgeSeverity","_stopDiagnostics","_maximizedOnKey","_presenting","_presentationIndex","_presentationOverlay","_presentationCaption","_presentationJusts","_presentationCounter","_presentationOnKey","_stickyRefSpan","_stickyRefElem","_slate","_config","_wrapper","createWrapper","createButtons","addKeyboardShortcuts","resizeAndRedraw","updateBadge","diagnosticSeverity","paintDiagnosticBadge","createDiagnosticBadge","position","zIndex","appendChild","document","getElementById","id","textContent","head","documentElement","ensureControlsStyle","wrapper","className","insertBefore","setAttribute","outline","buttons","draw","drawResetIcon","action","onReset","title","drawMaximizeIcon","onMaximize","slides","drawPresentIcon","onPresent","btn","right","padding","border","cursor","background","borderRadius","iconCanvas","stopPropagation","focus","_maxBtn","_maxIconCanvas","preventDefault","minimize","maximize","wrapperPosition","wrapperTop","wrapperLeft","wrapperWidth","wrapperHeight","wrapperZIndex","wrapperBackground","canvasStyleWidth","canvasStyleHeight","canvasAttrWidth","canvasAttrHeight","updateMaximizeIcon","bindMaximizedKeys","exitPresent","unbindMaximizedKeys","_applyCentring","centringBounds","cx","cy","viewScale","size","pad","strokeStyle","lineWidth","ax","ay","bx","by","beginPath","moveTo","lineTo","stroke","closePath","fill","drawMinimizeIcon","buildPresentationOverlay","bindPresentationKeys","showSlide","unbindPresentationKeys","clearStickyRef","removePresentationOverlay","animator","overlay","bottom","margin","maxWidth","color","borderTop","boxShadow","fontFamily","boxSizing","textAlign","caption","fontSize","lineHeight","marginBottom","opacity","minHeight","nav","gap","alignItems","justifyContent","prevBtn","makePresentationButton","counter","minWidth","nextBtn","exitBtn","marginLeft","parentNode","removeChild","clamped","max","computeSlideState","slide","transition","animations","renderCaptionText","innerHTML","resolveJustification","justifications","stacked","host","sep","dash","ref","url","href","rel","span","tok","buildCaptionRef","createTextNode","label","fontWeight","fontStyle","borderBottom","wasThis","setStickyRef","classList","remove","arc","PI","endAngle","cos","sin","a1","a2","px","badge","BADGE_TOOLTIP","icon","firstChild","tagName","drawErrorIcon","drawWarningIcon","barW","lineCap","leftX","rightX","topY","bottomY","animationsByName","animationsByEnum","AllAnimations","Point","appear","POINT_APPEAR","intersect","POINT_INTERSECT","POINT_SLIDE","Line","straightEdgeConnect","LINE_STRAIGHT_EDGE_CONNECT","straightEdgeExtend","LINE_STRAIGHT_EDGE_EXTEND","compassTransfer","LINE_COMPASS_TRANSFER","Circle","compass","CIRCLE_COMPASS","compassExplicit","CIRCLE_COMPASS_EXPLICIT","CIRCLE_COMPASS_TRANSFER","Polygon","POLYGON_OUTLINE","outlineAndFill","POLYGON_OUTLINE_AND_FILL","superpose","POLYGON_SUPERPOSE","equilateralBuild","POLYGON_EQUILATERAL_BUILD","Sector","sweep","SECTOR_SWEEP","Group","cloneAside","GROUP_CLONE_ASIDE","instant","INSTANT","Animation","animationMethod","InstantAnimation","registerAnimation","ConstructionTypes","PointConstructions","LineConstructions","CircleConstructions","PolygonConstructions","SectorConstructions","PlaneConstructions","SphereConstructions","PolyhedraConstructions","Plane","Sphere","Polyhedra","sig","signature","points","integers","elementTypes","Construction","pointConstructions","lineConstructions","circleConstructions","sectorConstructions","polygonConstructions","planeConstructions","sphereConstructions","polyhedronConstructions","Align","_nameColor","_vertexColor","_edgeColor","_faceColor","_nameHighlightColor","_vertexHighlightColor","_edgeHighlightColor","_faceHighlightColor","_shouldHighlight","_visible","_emphasisAmount","_drawProgress","_pixelTolerance","setFont","fontName","_fontName","_fontSize","fontString","_getTextMetrics","txt","textMetrics","measureText","actualBoundingBoxAscent","actualBoundingBoxDescent","drawString","ix","iy","overrideAlign","font","_name","_align","LEFT","fillText","RIGHT","ABOVE","BELOW","cw","ch","tox","toy","_draggable","_dimension","defaultRate","defaultDurationMs","circle","explicitStart","startAngle","atan2","sweepMs","fullRestore","faceAlpha","drawStartAngle","progress","CircleCompassAnimation","circ","s0","s1","distance","plane","D","side","mx","my","len","hypot","equilateralApex","TC","u1x","u1y","M","TP","u2x","u2y","tri","prodM","prodN","circC","circT","circEp","circEc","transitory","circles","keepNames","Array","isArray","keepCircles","isKept","traceMs","lineStep","ln","ms","sweepStep","step1","reveal","clearScaffold","CircleCompassTransferAnimation","CircleRadiusCenterConstruction","CircleRadius3PointConstruction","invert","InvertCircleElement","InvertCircleConstruction","intersection","SphereElement","SphereIntersectionElement","SphereIntersectionConstruction","ice","_drawStartAngle","_faceAlpha","dimension","distance2","_drawCircleArc","arcStart","arcEnd","r2","radius2","amp2","ellipse","rcos","rsin","majorx","majory","factor","minorx","minory","majorR","minorR","rotation","edgeHighlightColor","baseW","save","globalAlpha","restore","toCircumcenter","CircumcircleElement","_C","_D","d2","minus","times","plus","_S","_T","PerpendicularPlane","t2","snapshotElement","el","bare","src","ghost","pts","pt","snapshotSources","sources","ghosts","snap","applyVary","vary","LineSlider","sz","_A","_B","boundsOf","sideFromSign","include","autoPlace","nm","resolveSources","_autoPlaceStep","_legacyStep","variants","prefer","targetOffX","targetOffY","baseOffX","baseOffY","placed","copies","drive","centreP","pow","splitP","edx","edy","W","H","snaps","variant","bbox","viewOffsetX","viewOffsetY","fb","figW","figH","figCx","figCy","slotFor","bb","bw","bh","ccx","ccy","inner","outer","DEFAULT","taken","assigned","slot","cloned","slideCopy","temp","GroupCloneAsideAnimation","ibe","costheta","sintheta","toCircle","Bichord","toLine","Chord","traceLine","rate","LineStraightEdgeConnectAnimation","LineStraightEdgeExtendAnimation","connect","LineConnectConstruction","angleBisector","ad","AngleDividerElement","AngleBisectorLineConstruction","angleDivider","AngleDividerLineConstruction","foot","fo","Foot","LineFootConstruction","PlaneFootElement","PlaneFootLineConstruction","chord","ChordConstruction","bichord","wrapPointAsLine","es","BichordConstruction","perpendicular","PointPerpendicular1Construction","LinePerpendicular1Construction","PointPerpendicular2Construction","LinePerpendicular2Construction","PointPerpendicular3Construction","LinePerpendicular3Construction","PointPerpendicular4Construction","LinePerpendicular4Construction","PointPerpendicular5Construction","LinePerpendicular5Construction","cutoff","lo","Layoff","LineCutoffConstruction","extend","LineExtendConstruction","parallel","LineParallelConstruction","similar","g2","sim","SimilarElement","SimilarLineConstruction","proportion","prop","ProportionElement","ProportionLineConstruction","meanProportional","mp","MeanProportionalElement","MeanProportionalLineConstruction","path","PolylineElement","PolylineConstruction","ile","endX","endY","ipe","_P","_E","_F","toPlane","Bs","Bt","Perpendicular","toCross","PlanePerpendicularLine","ps","edgeCount","fullEdges","frac","U","ParallelPlane","ippe","lxy","threePoints","Plane3PointsConstruction","PerpendicularPlaneConstruction","PlaneParallelConstruction","ambient","AmbientPlanePointConstruction","AmbientPlaneCircleConstruction","ip","st","_n","theta","angle","_x","_y","_z","toIntersection","_newP","_initx","_inity","_initz","uptoPlane","toSphere","CircleSlider","_M","Ex","Ey","Fx","Fy","BFx","BFy","DEx","DEy","numx","numy","rB2","length2","C2","HarmonicElement","Intersection","toInvertPoint","InvertPointElement","segment","_segment","S0","S1","T0","T1","U0","U1","_S0","_S1","_T0","_T1","_U0","_U1","Midpoint","toIntersectionPL","PlaneIntersection","Qval","xVal","yVal","zVal","PlaneSlider","PointAppearAnimation","slider","toNum","toName","toElement","tz","apply","dz","tgt","denom","PointSlideAnimation","free","FreePointConstruction","midpoint","MidPointConstruction","IntersectionConstruction","PlaneIntersectionConstruction","first","FirstPointConstruction","last","LastPointConstruction","center","CircleCenterConstruction","SphereCenterConstruction","lineSlider","createSlider","LineSliderConstruction","circleSlider","CircleSliderConstruction","circumcircle","CircumcircleConstruction","circumcenter","CircumcenterConstruction","FootPointConstruction","PlaneFootPointConstruction","_createLayoff","LayoffConstruction","CutoffConstruction","ExtendConstruction","parallelogram","ParallelogramConstruction","SimilarPointConstruction","PointPerpendicularConstruction","ProportionPointConstruction","InvertPointConstruction","MeanProportionalPointConstruction","planeSlider","PlaneSliderConstruction","sphereSlider","SphereSliderElement","SphereSliderConstruction","AngleBisectorPointConstruction","AngleDividerPointConstruction","fixed","FixedPointConstruction","lineSegmentSlider","LineSliderSegmentConstruction","harmonic","HarmonicPointConstruction","vertex","VertexConstruction","product","cross","triple","u","BmA","CmA","BC","B2","area","Bx","Cx","By","Cy","Bz","Cz","Cs","Ct","d0","d1","AmA","DmA","Ax","Ay","Dx","Dy","toSimilar","Q","co","si","ss","tt","z1","x1","y1","baseR","V0","V1","_V0","_V1","_parentA","_parentB","_Q","dist2","ApplicationElement","vertices","sides","_vertices","_sides","_onCircle","_onLine","CurvedTriangleElement","_delta","a0","_traceBoundary","DEFAULT_POLYGON_EDGE_RATE_PX_PER_MS","perimeter","poly","PolygonOutlineAnimation","outlineMs","PolygonOutlineAndFillAnimation","ontoName","onto","ghostPts","setGhost","coords","translated","rotated","estDist","translateMs","estTheta","_sideAngleDelta","rotateMs","gp","PolygonSuperposeAnimation","circAB","circBA","firstSetup","fillMs","PolygonEquilateralBuildAnimation","PolyConstruction","square","RegularPolygonElement","SquarePolygonConstruction","triangle","TrianglePolygonConstruction","quadrilateral","QuadrilateralPolygonConstruction","pentagon","PentagonPolygonConstruction","hexagon","HexagonPolygonConstruction","equilateralTriangle","EquilateralTriangleConstruction","ParallelogramPolygonConstruction","regularPolygon","RegularPolygonConstruction","starPolygon","StarPolygonConstruction","SimilarPolygonConstruction","application","ApplicationPolygonConstruction","octagon","OctagonPolygonConstruction","PolyhedronElement","isCarrier","FacePolygonConstruction","curvedTriangle","every","CurvedTriangleConstruction","sum","totalProgress","fractionalEdge","py","firstPoint","_cos","_sin","tetrahedron","base","PyramidElement","TetrahedronConstruction","parallelepiped","fourth","PrismElement","ParallelepipedConstruction","prism","PrismConstruction","pyramid","PyramidConstruction","ct","savedColor","Base","baseN","topVerts","Apex","DEFAULT_ANGLE_MARKER_RADIUS_PX","ANGLE_MARKER_MAX_ARM_FRACTION","ANGLE_MARKER_RING_STEP","arm1","arm2","radiusOverride","reflex","ringIndex","_Center","_arm1","_arm2","_radiusOverride","spanRadians","_arcAngle","minor","_anticlockwise","_flashFace","shorter","_place","arm","SectorElement","AngleMarkerElement","ArcElement","sector","arcAngle","arcSpan","SectorSweepAnimation","O","SectorConstruction","ArcConstruction","angleMarker","AngleMarkerConstruction","AngleMarkerRadiusConstruction","angleMarkerReflex","undefined","AngleMarkerReflexConstruction","AngleMarkerReflexRadiusConstruction","isec","_angle","_updateThroughPoint","_traceWedge","SphereRadiusConstruction","SphereRadius3PointConstruction","CENTRAL","on","opts","ids","canvasids","hits","slates","worst","diagnostics","canvasid","initDiagnostics","defaultAlign","align","parseFloat","attr","getAttribute","authoredLogicalSize","logicalW","logicalH","resizeCanvasToDisplaySize","fontsize","parseColor","angleMarkerCount","raw","parseParam","element","construction","swatch","defaultNameColor","defaultVertexColor","lighterColor","lighten","defaultFaceColor","highlightOnTop","showAngles","initiallyHidden","byVertex","group","ring","sw","hasRadiusOverride","field","anims","validateSlides","createControls","initInner","err","markInitFailure","revealNoscriptFallback","BUILD_MARKER","typeMap","fields","Error","type","data","typeKey","constructionEnum","result","Number","sibling","nextElementSibling","attempts","html","anchor","verticalAlign","canonicaliseSlideNames","unmatched","reportUnmatched","slideIndex","baseVisible","baseIndex","deferredDraggables","__webpack_module_cache__","__webpack_exports__","__webpack_require__","moduleId","cachedModule","exports","module","__webpack_modules__","call"],"sourceRoot":""}