@weasel-js/diagram 1.7.0 → 1.7.1

package/dist/{chunk-AD7TY6TK.js → chunk-4KXQABRM.js}

@@ -858,5 +858,5 @@ var tree = (graph, opts = {}) => {
 };
 
 export { COMPASS, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, DIAGRAM_TRAIT_KEY, axesFor, backEdges, bodyOutline, bodyTrait, boxForContent, buildBody, canvasMeasure, center, contentBox, createDiagramNodes, dataKeyReader, diagramNodeOf, extent, force, forceRelaxation, forestOf, graphOrder, isPinned, layered, layoutBody, layoutRowPorts, measureBody, outlinePath, outlinePolyline, packAcross, pinnedSet, portOf, portsOf, portsOnOutline, ranksOf, rayHit, seededOrder, settle, sizeToBody, translated, tree };
-//# sourceMappingURL=chunk-AD7TY6TK.js.map
-//# sourceMappingURL=chunk-AD7TY6TK.js.map
+//# sourceMappingURL=chunk-4KXQABRM.js.map
+//# sourceMappingURL=chunk-4KXQABRM.js.map

package/dist/chunk-4KXQABRM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/outline.ts","../src/onOutline.ts","../src/trait.ts","../src/ports.ts","../src/body.ts","../src/layout.ts","../src/force.ts","../src/layered.ts","../src/tree.ts"],"names":["left","right","top","bottom","center","cursor"],"mappings":";;;AA2BA,IAAM,IAAA,GAAO,GAAA;AAIb,IAAM,KAAA,GAAQ,kBAAA;AAIP,SAAS,WAAA,CAAY,SAAkB,MAAA,EAAsB;AAClE,EAAA,IAAI,OAAO,OAAA,KAAY,QAAA,EAAU,OAAO,OAAA;AACxC,EAAA,MAAM,EAAE,CAAA,EAAG,CAAA,EAAG,OAAO,CAAA,EAAG,MAAA,EAAQ,GAAE,GAAI,MAAA;AACtC,EAAA,IAAI,KAAK,CAAA,IAAK,CAAA,IAAK,CAAA,EAAG,OAAO,SAAS,CAAA,EAAG,CAAA,EAAG,IAAA,CAAK,GAAA,CAAI,GAAG,CAAC,CAAA,EAAG,KAAK,GAAA,CAAI,CAAA,EAAG,CAAC,CAAC,CAAA;AAE1E,EAAA,QAAQ,OAAA;AAAS,IACf,KAAK,MAAA;AACH,MAAA,OAAO,QAAA,CAAS,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAC,CAAA;AAAA,IAE5B,KAAK,SAAA;AACH,MAAA,OAAO,iBAAA,CAAkB;AAAA,QACvB,EAAE,CAAA,EAAG,CAAA,GAAI,CAAA,GAAI,GAAG,CAAA,EAAE;AAAA,QAClB,EAAE,CAAA,EAAG,CAAA,GAAI,GAAG,CAAA,EAAG,CAAA,GAAI,IAAI,CAAA,EAAE;AAAA,QACzB,EAAE,CAAA,EAAG,CAAA,GAAI,IAAI,CAAA,EAAG,CAAA,EAAG,IAAI,CAAA,EAAE;AAAA,QACzB,EAAE,CAAA,EAAG,CAAA,EAAG,CAAA,GAAI,IAAI,CAAA;AAAE,OACnB,CAAA;AAAA,IAEH,KAAK,eAAA,EAAiB;AAEpB,MAAA,MAAM,OAAO,IAAA,CAAK,GAAA,CAAI,CAAA,GAAI,IAAA,EAAM,IAAI,CAAC,CAAA;AACrC,MAAA,OAAO,iBAAA,CAAkB;AAAA,QACvB,EAAE,CAAA,EAAG,CAAA,GAAI,IAAA,EAAM,CAAA,EAAE;AAAA,QACjB,EAAE,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA,EAAE;AAAA,QACd,EAAE,CAAA,EAAG,CAAA,GAAI,IAAI,IAAA,EAAM,CAAA,EAAG,IAAI,CAAA,EAAE;AAAA,QAC5B,EAAE,CAAA,EAAG,CAAA,EAAG,CAAA,GAAI,CAAA;AAAE,OACf,CAAA;AAAA,IACH;AAAA,IAEA,KAAK,SAAA;AACH,MAAA,OAAO,WAAA,CAAY,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAC,CAAA;AAAA;AAEnC;AAKA,SAAS,WAAA,CAAY,CAAA,EAAW,CAAA,EAAW,CAAA,EAAW,CAAA,EAAiB;AACrE,EAAA,MAAM,CAAA,GAAI,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,CAAC,CAAA,GAAI,CAAA;AAC3B,EAAA,MAAM,IAAI,CAAA,GAAI,KAAA;AACd,EAAA,MAAM,CAAA,GAAI,IAAI,WAAA,EAAY;AAE1B,EAAA,IAAI,KAAK,CAAA,EAAG;AACV,IAAA,MAAMA,QAAO,CAAA,GAAI,CAAA;AACjB,IAAA,MAAMC,MAAAA,GAAQ,IAAI,CAAA,GAAI,CAAA;AACtB,IAAA,MAAMC,IAAAA,GAAM,CAAA;AACZ,IAAA,MAAMC,UAAS,CAAA,GAAI,CAAA;AACnB,IAAA,MAAM,IAAA,GAAO,IAAI,CAAA,GAAI,CAAA;AACrB,IAAA,OAAO,CAAA,CACJ,MAAA,CAAOH,KAAAA,EAAME,IAAG,CAAA,CAChB,MAAA,CAAOD,MAAAA,EAAOC,IAAG,CAAA,CACjB,OAAA,CAAQD,MAAAA,GAAQ,CAAA,EAAGC,IAAAA,EAAK,CAAA,GAAI,CAAA,EAAG,IAAA,GAAO,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,IAAI,CAAA,CACpD,OAAA,CAAQ,CAAA,GAAI,CAAA,EAAG,IAAA,GAAO,CAAA,EAAGD,MAAAA,GAAQ,CAAA,EAAGE,OAAAA,EAAQF,QAAOE,OAAM,CAAA,CACzD,MAAA,CAAOH,KAAAA,EAAMG,OAAM,CAAA,CACnB,OAAA,CAAQH,KAAAA,GAAO,CAAA,EAAGG,OAAAA,EAAQ,CAAA,EAAG,IAAA,GAAO,CAAA,EAAG,CAAA,EAAG,IAAI,CAAA,CAC9C,OAAA,CAAQ,CAAA,EAAG,IAAA,GAAO,CAAA,EAAGH,KAAAA,GAAO,CAAA,EAAGE,IAAAA,EAAKF,KAAAA,EAAME,IAAG,CAAA,CAC7C,KAAA,EAAM,CACN,KAAA,EAAM;AAAA,EACX;AAEA,EAAA,MAAM,MAAM,CAAA,GAAI,CAAA;AAChB,EAAA,MAAM,MAAA,GAAS,IAAI,CAAA,GAAI,CAAA;AACvB,EAAA,MAAM,IAAA,GAAO,CAAA;AACb,EAAA,MAAM,QAAQ,CAAA,GAAI,CAAA;AAClB,EAAA,MAAM,IAAA,GAAO,IAAI,CAAA,GAAI,CAAA;AACrB,EAAA,OAAO,CAAA,CACJ,MAAA,CAAO,KAAA,EAAO,GAAG,CAAA,CACjB,MAAA,CAAO,KAAA,EAAO,MAAM,CAAA,CACpB,OAAA,CAAQ,KAAA,EAAO,MAAA,GAAS,CAAA,EAAG,IAAA,GAAO,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,IAAA,EAAM,CAAA,GAAI,CAAC,CAAA,CACvD,OAAA,CAAQ,IAAA,GAAO,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,IAAA,EAAM,MAAA,GAAS,CAAA,EAAG,MAAM,MAAM,CAAA,CACvD,MAAA,CAAO,IAAA,EAAM,GAAG,CAAA,CAChB,OAAA,CAAQ,IAAA,EAAM,GAAA,GAAM,CAAA,EAAG,IAAA,GAAO,CAAA,EAAG,CAAA,EAAG,IAAA,EAAM,CAAC,CAAA,CAC3C,OAAA,CAAQ,IAAA,GAAO,CAAA,EAAG,CAAA,EAAG,KAAA,EAAO,GAAA,GAAM,CAAA,EAAG,KAAA,EAAO,GAAG,CAAA,CAC/C,KAAA,EAAM,CACN,KAAA,EAAM;AACX;AAYO,SAAS,UAAA,CAAW,SAAkB,MAAA,EAAwB;AACnE,EAAA,IAAI,OAAO,OAAA,KAAY,QAAA,EAAU,OAAO,MAAA;AACxC,EAAA,MAAM,EAAE,CAAA,EAAG,CAAA,EAAG,OAAO,CAAA,EAAG,MAAA,EAAQ,GAAE,GAAI,MAAA;AACtC,EAAA,QAAQ,OAAA;AAAS,IACf,KAAK,MAAA;AACH,MAAA,OAAO,MAAA;AAAA,IACT,KAAK,SAAA;AAEH,MAAA,OAAO,EAAE,CAAA,EAAG,CAAA,GAAI,CAAA,GAAI,GAAG,CAAA,EAAG,CAAA,GAAI,CAAA,GAAI,CAAA,EAAG,KAAA,EAAO,CAAA,GAAI,CAAA,EAAG,MAAA,EAAQ,IAAI,CAAA,EAAE;AAAA,IACnE,KAAK,eAAA,EAAiB;AACpB,MAAA,MAAM,OAAO,IAAA,CAAK,GAAA,CAAI,CAAA,GAAI,IAAA,EAAM,IAAI,CAAC,CAAA;AACrC,MAAA,OAAO,EAAE,CAAA,EAAG,CAAA,GAAI,IAAA,EAAM,GAAG,KAAA,EAAO,IAAA,CAAK,GAAA,CAAI,CAAA,GAAI,IAAA,GAAO,CAAA,EAAG,CAAC,CAAA,EAAG,QAAQ,CAAA,EAAE;AAAA,IACvE;AAAA,IACA,KAAK,SAAA,EAAW;AACd,MAAA,MAAM,CAAA,GAAI,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,CAAC,CAAA,GAAI,CAAA;AAC3B,MAAA,OAAO,CAAA,IAAK,CAAA,GACR,EAAE,CAAA,EAAG,IAAI,CAAA,EAAG,CAAA,EAAG,KAAA,EAAO,IAAA,CAAK,GAAA,CAAI,CAAA,GAAI,CAAA,GAAI,CAAA,EAAG,CAAC,CAAA,EAAG,MAAA,EAAQ,CAAA,EAAE,GACxD,EAAE,CAAA,EAAG,CAAA,EAAG,CAAA,GAAI,GAAG,KAAA,EAAO,CAAA,EAAG,MAAA,EAAQ,IAAA,CAAK,GAAA,CAAI,CAAA,GAAI,CAAA,GAAI,CAAA,EAAG,CAAC,CAAA,EAAE;AAAA,IAC9D;AAAA;AAEJ;AAUO,SAAS,aAAA,CACd,SACA,OAAA,EACmC;AACnC,EAAA,IAAI,OAAO,OAAA,KAAY,QAAA,EAAU,OAAO,OAAA;AACxC,EAAA,QAAQ,OAAA;AAAS,IACf,KAAK,MAAA;AACH,MAAA,OAAO,OAAA;AAAA,IACT,KAAK,SAAA;AACH,MAAA,OAAO,EAAE,OAAO,OAAA,CAAQ,KAAA,GAAQ,GAAG,MAAA,EAAQ,OAAA,CAAQ,SAAS,CAAA,EAAE;AAAA,IAChE,KAAK,eAAA;AACH,MAAA,OAAO,EAAE,OAAO,OAAA,CAAQ,KAAA,IAAS,IAAI,IAAA,GAAO,CAAA,CAAA,EAAI,MAAA,EAAQ,OAAA,CAAQ,MAAA,EAAO;AAAA,IACzE,KAAK,SAAA;AACH,MAAA,OAAO,EAAE,OAAO,OAAA,CAAQ,KAAA,GAAQ,QAAQ,MAAA,EAAQ,MAAA,EAAQ,QAAQ,MAAA,EAAO;AAAA;AAE7E;ACvJA,IAAM,SAAA,GAAY,IAAA;AAGX,SAAS,eAAA,CAAgB,SAAkB,MAAA,EAA0B;AAC1E,EAAA,MAAM,IAAA,GAAO,WAAA,CAAY,OAAA,EAAS,MAAM,CAAA;AACxC,EAAA,OAAO,YAAY,IAAI,CAAA;AACzB;AAEA,SAAS,YAAY,IAAA,EAAsB;AACzC,EAAA,IAAI,IAAA,CAAK,SAAS,MAAA,EAAQ;AACxB,IAAA,MAAM,EAAE,CAAA,EAAG,CAAA,EAAG,OAAO,CAAA,EAAG,MAAA,EAAQ,GAAE,GAAI,IAAA;AACtC,IAAA,OAAO,CAAC,CAAA,EAAG,CAAA,EAAG,CAAA,GAAI,GAAG,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,GAAG,CAAC,CAAA;AAAA,EACtD;AACA,EAAA,MAAM,MAAgB,EAAC;AACvB,EAAA,MAAM,EAAE,QAAA,EAAU,MAAA,EAAO,GAAI,IAAA;AAC7B,EAAA,IAAI,EAAA,GAAK,CAAA;AACT,EAAA,IAAI,EAAA,GAAK,CAAA;AACT,EAAA,IAAI,EAAA,GAAK,CAAA;AACT,EAAA,IAAI,EAAA,GAAK,CAAA;AACT,EAAA,IAAI,EAAA,GAAK,CAAA;AACT,EAAA,KAAA,MAAW,OAAO,QAAA,EAAU;AAC1B,IAAA,IAAI,QAAQ,MAAA,EAAQ;AAClB,MAAA,EAAA,GAAK,OAAO,EAAE,CAAA;AAAI,MAAA,EAAA,GAAK,MAAA,CAAO,KAAK,CAAC,CAAA;AAAI,MAAA,EAAA,IAAM,CAAA;AAC9C,MAAA,EAAA,GAAK,EAAA;AAAI,MAAA,EAAA,GAAK,EAAA;AACd,MAAA,GAAA,CAAI,IAAA,CAAK,IAAI,EAAE,CAAA;AAAA,IACjB,CAAA,MAAA,IAAW,QAAQ,MAAA,EAAQ;AACzB,MAAA,EAAA,GAAK,OAAO,EAAE,CAAA;AAAI,MAAA,EAAA,GAAK,MAAA,CAAO,KAAK,CAAC,CAAA;AAAI,MAAA,EAAA,IAAM,CAAA;AAC9C,MAAA,GAAA,CAAI,IAAA,CAAK,IAAI,EAAE,CAAA;AAAA,IACjB,CAAA,MAAA,IAAW,QAAQ,MAAA,EAAQ;AACzB,MAAA,MAAM,KAAK,MAAA,CAAO,EAAE,GAAI,EAAA,GAAK,MAAA,CAAO,KAAK,CAAC,CAAA;AAC1C,MAAA,MAAM,EAAA,GAAK,OAAO,EAAA,GAAK,CAAC,GAAI,EAAA,GAAK,MAAA,CAAO,KAAK,CAAC,CAAA;AAC9C,MAAA,MAAM,EAAA,GAAK,OAAO,EAAA,GAAK,CAAC,GAAI,EAAA,GAAK,MAAA,CAAO,KAAK,CAAC,CAAA;AAC9C,MAAA,EAAA,IAAM,CAAA;AACN,MAAA,YAAA,CAAa,EAAA,EAAI,IAAI,EAAA,EAAI,EAAA,EAAI,IAAI,EAAA,EAAI,EAAA,EAAI,EAAA,EAAI,SAAA,EAAW,GAAG,CAAA;AAC3D,MAAA,EAAA,GAAK,EAAA;AAAI,MAAA,EAAA,GAAK,EAAA;AAAA,IAChB,CAAA,MAAA,IAAW,QAAQ,MAAA,EAAQ;AAEzB,MAAA,MAAM,KAAK,MAAA,CAAO,EAAE,GAAI,EAAA,GAAK,MAAA,CAAO,KAAK,CAAC,CAAA;AAC1C,MAAA,MAAM,EAAA,GAAK,OAAO,EAAA,GAAK,CAAC,GAAI,EAAA,GAAK,MAAA,CAAO,KAAK,CAAC,CAAA;AAC9C,MAAA,EAAA,IAAM,CAAA;AACN,MAAA,YAAA;AAAA,QACE,EAAA;AAAA,QAAI,EAAA;AAAA,QACJ,EAAA,GAAM,CAAA,GAAI,CAAA,IAAM,EAAA,GAAK,EAAA,CAAA;AAAA,QAAK,EAAA,GAAM,CAAA,GAAI,CAAA,IAAM,EAAA,GAAK,EAAA,CAAA;AAAA,QAC/C,EAAA,GAAM,CAAA,GAAI,CAAA,IAAM,EAAA,GAAK,EAAA,CAAA;AAAA,QAAK,EAAA,GAAM,CAAA,GAAI,CAAA,IAAM,EAAA,GAAK,EAAA,CAAA;AAAA,QAC/C,EAAA;AAAA,QAAI,EAAA;AAAA,QAAI,SAAA;AAAA,QAAW;AAAA,OACrB;AACA,MAAA,EAAA,GAAK,EAAA;AAAI,MAAA,EAAA,GAAK,EAAA;AAAA,IAChB,CAAA,MAAA,IAAW,QAAQ,MAAA,EAAQ;AACzB,MAAA,GAAA,CAAI,IAAA,CAAK,IAAI,EAAE,CAAA;AACf,MAAA,EAAA,GAAK,EAAA;AAAI,MAAA,EAAA,GAAK,EAAA;AAAA,IAChB;AAAA,EACF;AAEA,EAAA,IAAI,IAAI,MAAA,IAAU,CAAA,KAAM,IAAI,CAAC,CAAA,KAAM,IAAI,GAAA,CAAI,MAAA,GAAS,CAAC,CAAA,IAAK,IAAI,CAAC,CAAA,KAAM,IAAI,GAAA,CAAI,MAAA,GAAS,CAAC,CAAA,CAAA,EAAI;AACzF,IAAA,GAAA,CAAI,KAAK,GAAA,CAAI,CAAC,CAAA,EAAI,GAAA,CAAI,CAAC,CAAE,CAAA;AAAA,EAC3B;AACA,EAAA,OAAO,GAAA;AACT;AASO,SAAS,MAAA,CACd,IAAA,EACAE,OAAAA,EACA,KAAA,EACiC;AACjC,EAAA,MAAM,EAAA,GAAK,KAAA,CAAM,CAAA,GAAIA,OAAAA,CAAO,CAAA;AAC5B,EAAA,MAAM,EAAA,GAAK,KAAA,CAAM,CAAA,GAAIA,OAAAA,CAAO,CAAA;AAC5B,EAAA,IAAI,EAAA,KAAO,CAAA,IAAK,EAAA,KAAO,CAAA,EAAG,OAAO,IAAA;AACjC,EAAA,IAAI,KAAA,GAAQ,CAAA,QAAA;AACZ,EAAA,IAAI,GAAA,GAAuC,IAAA;AAC3C,EAAA,KAAA,IAAS,IAAI,CAAA,EAAG,CAAA,GAAI,IAAI,IAAA,CAAK,MAAA,EAAQ,KAAK,CAAA,EAAG;AAC3C,IAAA,MAAM,KAAK,IAAA,CAAK,CAAC,GAAI,EAAA,GAAK,IAAA,CAAK,IAAI,CAAC,CAAA;AACpC,IAAA,MAAM,EAAA,GAAK,KAAK,CAAA,GAAI,CAAC,GAAI,EAAA,GAAK,IAAA,CAAK,IAAI,CAAC,CAAA;AACxC,IAAA,MAAM,KAAK,EAAA,GAAK,EAAA;AAChB,IAAA,MAAM,KAAK,EAAA,GAAK,EAAA;AAChB,IAAA,MAAM,KAAA,GAAQ,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,EAAA;AAC7B,IAAA,IAAI,UAAU,CAAA,EAAG;AAEjB,IAAA,MAAM,CAAA,GAAA,CAAA,CAAM,KAAKA,OAAAA,CAAO,CAAA,IAAK,MAAM,EAAA,GAAKA,OAAAA,CAAO,KAAK,EAAA,IAAM,KAAA;AAC1D,IAAA,MAAM,CAAA,GAAA,CAAA,CAAM,KAAKA,OAAAA,CAAO,CAAA,IAAK,MAAM,EAAA,GAAKA,OAAAA,CAAO,KAAK,EAAA,IAAM,KAAA;AAC1D,IAAA,IAAI,CAAA,GAAI,CAAA,IAAK,CAAA,GAAI,CAAA,IAAK,IAAI,CAAA,EAAG;AAC7B,IAAA,IAAI,IAAI,KAAA,EAAO;AACb,MAAA,KAAA,GAAQ,CAAA;AACR,MAAA,GAAA,GAAM,EAAE,CAAA,EAAGA,OAAAA,CAAO,CAAA,GAAI,EAAA,GAAK,GAAG,CAAA,EAAGA,OAAAA,CAAO,CAAA,GAAI,EAAA,GAAK,CAAA,EAAE;AAAA,IACrD;AAAA,EACF;AACA,EAAA,OAAO,GAAA;AACT;AAMO,SAAS,cAAA,CACd,KAAA,EACA,OAAA,EACA,MAAA,EACQ;AACR,EAAA,IAAI,MAAA,CAAO,SAAS,CAAA,IAAK,MAAA,CAAO,UAAU,CAAA,EAAG,OAAO,CAAC,GAAG,KAAK,CAAA;AAC7D,EAAA,MAAM,IAAA,GAAO,eAAA,CAAgB,OAAA,EAAS,MAAM,CAAA;AAC5C,EAAA,MAAMA,OAAAA,GAAS,EAAE,CAAA,EAAG,MAAA,CAAO,CAAA,GAAI,MAAA,CAAO,KAAA,GAAQ,CAAA,EAAG,CAAA,EAAG,MAAA,CAAO,CAAA,GAAI,MAAA,CAAO,SAAS,CAAA,EAAE;AACjF,EAAA,OAAO,KAAA,CAAM,GAAA,CAAI,CAAC,IAAA,KAAS;AACzB,IAAA,MAAM,GAAA,GAAM,MAAA,CAAO,IAAA,EAAMA,OAAAA,EAAQ,KAAK,KAAK,CAAA;AAC3C,IAAA,OAAO,QAAQ,IAAA,GAAO,IAAA,GAAO,EAAE,GAAG,IAAA,EAAM,OAAO,GAAA,EAAI;AAAA,EACrD,CAAC,CAAA;AACH;;;AC3GO,IAAM,iBAAA,GAAoB;AAgC1B,IAAM,aAAA,GAAmC,CAAC,IAAA,KAAS;AACxD,EAAA,MAAM,OAAO,IAAA,CAAK,IAAA;AAClB,EAAA,IAAI,IAAA,KAAS,IAAA,IAAQ,OAAO,IAAA,KAAS,UAAU,OAAO,IAAA;AACtD,EAAA,MAAM,KAAA,GAAS,KAAiC,iBAAiB,CAAA;AACjE,EAAA,IAAI,KAAA,KAAU,IAAA,IAAQ,OAAO,KAAA,KAAU,UAAU,OAAO,IAAA;AACxD,EAAA,IAAI,MAAA,IAAU,KAAA,IAAS,IAAA,IAAQ,KAAA,EAAO,OAAO,IAAA;AAC7C,EAAA,OAAO,KAAA;AACT;AAUO,SAAS,mBAAmB,OAAA,EAAyD;AAC1F,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAY;AAC7B,EAAA,KAAA,MAAW,SAAS,OAAA,EAAS;AAC3B,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,KAAA,CAAM,IAAI,CAAA,EAAG;AACxB,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,0CAAA,EAA6C,KAAA,CAAM,IAAI,CAAA,CAAA,CAAG,CAAA;AAAA,IAC5E;AACA,IAAA,IAAA,CAAK,GAAA,CAAI,MAAM,IAAI,CAAA;AAAA,EACrB;AACA,EAAA,OAAO,CAAC,IAAA,KAAS;AACf,IAAA,MAAM,GAAA,GAAM,cAAc,IAAI,CAAA;AAC9B,IAAA,IAAI,GAAA,KAAQ,MAAM,OAAO,GAAA;AACzB,IAAA,KAAA,MAAW,SAAS,OAAA,EAAS;AAC3B,MAAA,IAAI,CAAC,KAAA,CAAM,OAAA,CAAQ,IAAA,CAAK,IAAI,CAAA,EAAG;AAC/B,MAAA,OAAO,OAAO,MAAM,KAAA,KAAU,UAAA,GAAa,MAAM,KAAA,CAAM,IAAA,CAAK,IAAI,CAAA,GAAI,KAAA,CAAM,KAAA;AAAA,IAC5E;AACA,IAAA,OAAO,IAAA;AAAA,EACT,CAAA;AACF;AAGO,SAAS,aAAA,CACd,IAAA,EACA,IAAA,GAA0B,aAAA,EACN;AACpB,EAAA,OAAO,KAAK,IAAI,CAAA;AAClB;AAGO,SAAS,QAAA,CAAS,MAAuB,IAAA,EAAmC;AACjF,EAAA,OAAO,aAAA,CAAc,IAAA,EAAM,IAAI,CAAA,EAAG,MAAA,KAAW,IAAA;AAC/C;AC9EO,IAAM,OAAA,GAAU;AAAA,EACrB,EAAA,EAAI,EAAE,CAAA,EAAG,CAAA,EAAG,GAAG,CAAA,EAAE;AAAA,EACjB,CAAA,EAAG,EAAE,CAAA,EAAG,GAAA,EAAK,GAAG,CAAA,EAAE;AAAA,EAClB,EAAA,EAAI,EAAE,CAAA,EAAG,CAAA,EAAG,GAAG,CAAA,EAAE;AAAA,EACjB,CAAA,EAAG,EAAE,CAAA,EAAG,CAAA,EAAG,GAAG,GAAA,EAAI;AAAA,EAClB,EAAA,EAAI,EAAE,CAAA,EAAG,CAAA,EAAG,GAAG,CAAA,EAAE;AAAA,EACjB,CAAA,EAAG,EAAE,CAAA,EAAG,GAAA,EAAK,GAAG,CAAA,EAAE;AAAA,EAClB,EAAA,EAAI,EAAE,CAAA,EAAG,CAAA,EAAG,GAAG,CAAA,EAAE;AAAA,EACjB,CAAA,EAAG,EAAE,CAAA,EAAG,CAAA,EAAG,GAAG,GAAA;AAChB;AAOO,IAAM,aAAA,GAAqC,OAAO,MAAA,CAAO;AAAA,EAC9D,EAAE,EAAA,EAAI,GAAA,EAAK,EAAA,EAAI,QAAQ,CAAA,EAAE;AAAA,EACzB,EAAE,EAAA,EAAI,GAAA,EAAK,EAAA,EAAI,QAAQ,CAAA,EAAE;AAAA,EACzB,EAAE,EAAA,EAAI,GAAA,EAAK,EAAA,EAAI,QAAQ,CAAA,EAAE;AAAA,EACzB,EAAE,EAAA,EAAI,GAAA,EAAK,EAAA,EAAI,QAAQ,CAAA;AACzB,CAAC;AAoBD,SAAS,SAAS,EAAA,EAA6B;AAC7C,EAAA,MAAM,CAAA,GAAI,EAAA,CAAG,CAAA,GAAI,CAAA,GAAI,CAAA;AACrB,EAAA,MAAM,CAAA,GAAI,EAAA,CAAG,CAAA,GAAI,CAAA,GAAI,CAAA;AACrB,EAAA,MAAM,GAAA,GAAM,IAAA,CAAK,KAAA,CAAM,CAAA,EAAG,CAAC,CAAA;AAC3B,EAAA,IAAI,GAAA,KAAQ,GAAG,OAAO,IAAA;AACtB,EAAA,OAAO,EAAE,CAAA,EAAG,CAAA,GAAI,GAAA,EAAK,CAAA,EAAG,IAAI,GAAA,EAAI;AAClC;AASO,SAAS,OAAA,CACd,IAAA,EACA,IAAA,EACA,IAAA,GAA4B,EAAC,EACrB;AACR,EAAA,MAAM,KAAA,GAAQ,aAAA,CAAc,IAAA,EAAM,IAAA,CAAK,IAAI,CAAA;AAC3C,EAAA,IAAI,KAAA,KAAU,IAAA,EAAM,OAAO,EAAC;AAC5B,EAAA,MAAM,QAAA,GAAW,KAAK,QAAA,IAAa,oBAAA;AACnC,EAAA,MAAM,MAAA,GAAS,QAAA,CAAS,SAAA,CAAU,IAAI,CAAA;AACtC,EAAA,MAAM,QAAA,GAAW,QAAA,CAAS,WAAA,GAAc,IAAI,CAAA,IAAK,CAAA;AACjD,EAAA,MAAM,EAAA,GAAK,MAAA,CAAO,CAAA,GAAI,MAAA,CAAO,KAAA,GAAQ,CAAA;AACrC,EAAA,MAAM,EAAA,GAAK,MAAA,CAAO,CAAA,GAAI,MAAA,CAAO,MAAA,GAAS,CAAA;AAKtC,EAAA,MAAM,IAAA,GAAO,KAAA,CAAM,OAAA,KAAY,MAAA,IAAa,OAAO,KAAA,IAAS,CAAA,IAAK,MAAA,CAAO,MAAA,IAAU,CAAA,GAC9E,IAAA,GACA,eAAA,CAAgB,KAAA,CAAM,SAAS,MAAM,CAAA;AAEzC,EAAA,OAAA,CAAQ,KAAA,CAAM,KAAA,IAAS,aAAA,EAAe,GAAA,CAAI,CAAC,IAAA,KAAS;AAClD,IAAA,MAAM,QAAA,GAAiB;AAAA,MACrB,GAAG,MAAA,CAAO,CAAA,GAAI,IAAA,CAAK,EAAA,CAAG,IAAI,MAAA,CAAO,KAAA;AAAA,MACjC,GAAG,MAAA,CAAO,CAAA,GAAI,IAAA,CAAK,EAAA,CAAG,IAAI,MAAA,CAAO;AAAA,KACnC;AACA,IAAA,MAAM,IAAA,GAAA,CAAQ,IAAA,KAAS,IAAA,GAAO,IAAA,GAAO,MAAA,CAAO,IAAA,EAAM,EAAE,CAAA,EAAG,EAAA,EAAI,CAAA,EAAG,EAAA,EAAG,EAAG,QAAQ,CAAA,KAAM,QAAA;AAClF,IAAA,MAAM,MAAA,GAAS,KAAK,MAAA,KAAW,MAAA,GAAY,SAAS,IAAA,CAAK,EAAE,IAAI,IAAA,CAAK,MAAA;AACpE,IAAA,IAAI,aAAa,CAAA,EAAG;AAClB,MAAA,OAAO,EAAE,EAAA,EAAI,IAAA,CAAK,EAAA,EAAI,MAAA,EAAQ,IAAA,CAAK,EAAA,EAAI,KAAA,EAAO,IAAA,EAAM,MAAA,EAAQ,GAAG,MAAA,CAAO,IAAI,CAAA,EAAE;AAAA,IAC9E;AACA,IAAA,OAAO;AAAA,MACL,IAAI,IAAA,CAAK,EAAA;AAAA,MACT,QAAQ,IAAA,CAAK,EAAA;AAAA,MACb,KAAA,EAAO,YAAY,IAAA,CAAK,CAAA,EAAG,KAAK,CAAA,EAAG,EAAA,EAAI,IAAI,QAAQ,CAAA;AAAA;AAAA,MAEnD,MAAA,EAAQ,MAAA,KAAW,IAAA,GAAO,IAAA,GAAO,WAAA,CAAY,MAAA,CAAO,CAAA,EAAG,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,QAAQ,CAAA;AAAA,MAC/E,GAAG,OAAO,IAAI;AAAA,KAChB;AAAA,EACF,CAAC,CAAA;AACH;AAGO,SAAS,OACd,IAAA,EACA,IAAA,EACA,MAAA,EACA,IAAA,GAA4B,EAAC,EACX;AAClB,EAAA,OAAO,OAAA,CAAQ,IAAA,EAAM,IAAA,EAAM,IAAI,CAAA,CAAE,KAAK,CAAC,CAAA,KAAM,CAAA,CAAE,EAAA,KAAO,MAAM,CAAA;AAC9D;AAIA,SAAS,OAAO,IAAA,EAAmC;AACjD,EAAA,OAAO,IAAA,CAAK,SAAS,MAAA,GAAY,KAAK,EAAE,IAAA,EAAM,KAAK,IAAA,EAAK;AAC1D;;;AChCA,IAAM,eAAA,GAAkB,CAAA;AACxB,IAAM,WAAA,GAAc,CAAA;AAIpB,IAAM,aAAA,GAAgB,EAAA;AAKf,SAAS,cACd,GAAA,EACgB;AAChB,EAAA,OAAO,CAAC,MAAM,KAAA,KAAU;AACtB,IAAA,MAAM,IAAA,GAAO,MAAM,QAAA,IAAY,aAAA;AAC/B,IAAA,GAAA,CAAI,IAAA,GAAO,CAAA,EAAG,KAAA,CAAM,IAAA,KAAS,IAAA,GAAO,OAAA,GAAU,EAAE,CAAA,EAAG,IAAI,CAAA,GAAA,EAAM,KAAA,CAAM,UAAA,IAAc,YAAY,CAAA,CAAA;AAC7F,IAAA,OAAO,EAAE,KAAA,EAAO,GAAA,CAAI,WAAA,CAAY,IAAI,CAAA,CAAE,KAAA,EAAO,MAAA,EAAQ,IAAA,CAAK,IAAA,CAAK,IAAA,GAAO,GAAG,CAAA,EAAE;AAAA,EAC7E,CAAA;AACF;AAGA,SAAS,UAAA,CAAW,KAAU,OAAA,EAAwE;AACpG,EAAA,MAAM,IAAA,GAAO,CAAC,CAAA,EAAW,KAAA,KACvB,YAAY,MAAA,GACR,EAAE,OAAO,CAAA,CAAE,MAAA,IAAA,CAAY,OAAO,QAAA,IAAY,aAAA,IAAiB,MAAO,MAAA,EAAQ,aAAA,KAC1E,OAAA,CAAQ,CAAA,EAAG,KAAA,IAAS,EAAE,CAAA;AAE5B,EAAA,QAAQ,IAAI,IAAA;AAAM,IAChB,KAAK,OAAA;AACH,MAAA,OAAO,IAAA,CAAK,GAAA,CAAI,IAAA,EAAM,GAAA,CAAI,KAAK,CAAA;AAAA,IACjC,KAAK,OAAA,EAAS;AAEZ,MAAA,MAAM,CAAA,GAAI,IAAA,CAAK,GAAA,CAAI,KAAA,EAAO,IAAI,KAAK,CAAA;AACnC,MAAA,MAAM,CAAA,GAAI,IAAA,CAAK,GAAA,CAAI,KAAA,EAAO,IAAI,KAAK,CAAA;AACnC,MAAA,OAAO,EAAE,KAAA,EAAO,CAAA,CAAE,KAAA,GAAQ,cAAc,CAAA,GAAI,CAAA,CAAE,KAAA,EAAO,MAAA,EAAQ,KAAK,GAAA,CAAI,CAAA,CAAE,MAAA,EAAQ,CAAA,CAAE,MAAM,CAAA,EAAE;AAAA,IAC5F;AAAA,IACA,KAAK,OAAA,EAAS;AACZ,MAAA,MAAM,IAAA,GAAO,CAAC,KAAA,KAAA,CACX,KAAA,IAAS,EAAC,EAAG,MAAA,CAAO,CAAC,CAAA,EAAG,CAAA,KAAM,IAAA,CAAK,IAAI,CAAA,EAAG,CAAA,CAAE,KAAA,KAAU,MAAA,GAAY,CAAA,GAAI,IAAA,CAAK,EAAE,KAAK,CAAA,CAAE,KAAK,CAAA,EAAG,CAAC,CAAA;AAChG,MAAA,MAAM,IAAA,GAAO,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,IAAA,EAAM,MAAA,IAAU,CAAA,EAAG,GAAA,CAAI,KAAA,EAAO,MAAA,IAAU,CAAA,EAAG,CAAC,CAAA;AACtE,MAAA,OAAO;AAAA,QACL,KAAA,EAAO,KAAK,GAAA,CAAI,IAAI,IAAI,WAAA,GAAc,CAAA,GAAI,IAAA,CAAK,GAAA,CAAI,KAAK,CAAA;AAAA,QACxD,MAAA,EAAQ,GAAA,CAAI,MAAA,IAAU,IAAA,GAAO;AAAA,OAC/B;AAAA,IACF;AAAA,IACA,KAAK,MAAA;AACH,MAAA,OAAO,EAAE,KAAA,EAAO,CAAA,EAAG,MAAA,EAAQ,IAAI,MAAA,EAAO;AAAA;AAE5C;AAMO,SAAS,WAAA,CAAY,MAAgB,OAAA,EAAqC;AAC/E,EAAA,MAAM,OAAA,GAAU,KAAK,OAAA,IAAW,eAAA;AAChC,EAAA,MAAM,GAAA,GAAM,KAAK,GAAA,IAAO,WAAA;AACxB,EAAA,IAAI,KAAA,GAAQ,CAAA;AACZ,EAAA,IAAI,MAAA,GAAS,CAAA;AACb,EAAA,KAAA,MAAW,CAAC,CAAA,EAAG,GAAG,KAAK,IAAA,CAAK,IAAA,CAAK,SAAQ,EAAG;AAC1C,IAAA,MAAM,CAAA,GAAI,UAAA,CAAW,GAAA,EAAK,OAAO,CAAA;AACjC,IAAA,KAAA,GAAQ,IAAA,CAAK,GAAA,CAAI,KAAA,EAAO,CAAA,CAAE,KAAK,CAAA;AAC/B,IAAA,MAAA,IAAU,CAAA,CAAE,MAAA,IAAU,CAAA,GAAI,CAAA,GAAI,GAAA,GAAM,CAAA,CAAA;AAAA,EACtC;AAGA,EAAA,MAAM,GAAA,GAAM,aAAA,CAAc,IAAA,CAAK,OAAA,EAAS;AAAA,IACtC,KAAA,EAAO,QAAQ,OAAA,GAAU,CAAA;AAAA,IACzB,MAAA,EAAQ,SAAS,OAAA,GAAU;AAAA,GAC5B,CAAA;AACD,EAAA,OAAO,EAAE,QAAA,EAAU,GAAA,CAAI,KAAA,EAAO,SAAA,EAAW,IAAI,MAAA,EAAO;AACtD;AAOO,SAAS,UAAA,CAAiC,MAAa,KAAA,EAAyB;AACrF,EAAA,MAAM,QAAQ,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,KAAA,EAAO,MAAM,QAAQ,CAAA;AACjD,EAAA,MAAM,SAAS,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,MAAA,EAAQ,MAAM,SAAS,CAAA;AACpD,EAAA,IAAI,UAAU,IAAA,CAAK,KAAA,IAAS,MAAA,KAAW,IAAA,CAAK,QAAQ,OAAO,IAAA;AAC3D,EAAA,OAAO,EAAE,GAAG,IAAA,EAAM,KAAA,EAAO,MAAA,EAAO;AAClC;AAKO,SAAS,UAAA,CACd,IAAA,EACA,MAAA,EACA,OAAA,EACU;AACV,EAAA,MAAM,OAAA,GAAU,KAAK,OAAA,IAAW,eAAA;AAChC,EAAA,MAAM,GAAA,GAAM,KAAK,GAAA,IAAO,WAAA;AACxB,EAAA,MAAM,KAAA,GAAQ,UAAA,CAAW,IAAA,CAAK,OAAA,EAAS,MAAM,CAAA;AAC7C,EAAA,MAAM,QAAQ,IAAA,CAAK,GAAA,CAAI,MAAM,KAAA,GAAQ,OAAA,GAAU,GAAG,CAAC,CAAA;AACnD,EAAA,IAAI,CAAA,GAAI,MAAM,CAAA,GAAI,OAAA;AAClB,EAAA,OAAO,IAAA,CAAK,IAAA,CAAK,GAAA,CAAI,CAAC,KAAK,KAAA,KAAU;AACnC,IAAA,MAAM,CAAA,GAAI,UAAA,CAAW,GAAA,EAAK,OAAO,CAAA,CAAE,MAAA;AACnC,IAAA,MAAM,GAAA,GAAc,EAAE,GAAA,EAAK,KAAA,EAAO,CAAA,EAAG,KAAA,CAAM,CAAA,GAAI,OAAA,EAAS,CAAA,EAAG,KAAA,EAAO,MAAA,EAAQ,CAAA,EAAE;AAC5E,IAAA,CAAA,IAAK,CAAA,GAAI,GAAA;AACT,IAAA,OAAO,GAAA;AAAA,EACT,CAAC,CAAA;AACH;AAWO,SAAS,cAAA,CACd,GAAA,EACA,GAAA,EACA,OAAA,EACc;AACd,EAAA,MAAM,KAAA,GAAQ,CAAC,KAAA,KACb,KAAA,KAAU,SAAY,CAAA,GAAI,UAAA,CAAW,EAAE,IAAA,EAAM,OAAA,EAAS,IAAA,EAAM,KAAA,EAAM,EAAG,OAAO,CAAA,CAAE,KAAA;AAChF,EAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,IAAA,EAAM,MAAA,IAAU,CAAA,EAAG,GAAA,CAAI,KAAA,EAAO,MAAA,IAAU,CAAA,EAAG,CAAC,CAAA;AACvE,EAAA,MAAM,UAAA,GAAa,IAAI,MAAA,GAAS,KAAA;AAChC,EAAA,MAAM,MAAoB,EAAC;AAC3B,EAAA,MAAM,IAAA,GAAO,CAAC,KAAA,EAAuC,KAAA,KAAkC;AACrF,IAAA,KAAA,MAAW,CAAC,OAAO,IAAI,CAAA,IAAA,CAAM,SAAS,EAAC,EAAG,SAAQ,EAAG;AACnD,MAAA,MAAM,CAAA,GAAI,KAAA,CAAM,IAAA,CAAK,KAAK,CAAA;AAC1B,MAAA,GAAA,CAAI,IAAA,CAAK;AAAA,QACP,IAAA;AAAA,QACA,IAAA,EAAM,KAAA;AAAA,QACN,KAAA;AAAA,QACA,CAAA,EAAG,UAAU,MAAA,GAAS,GAAA,CAAI,IAAI,GAAA,CAAI,CAAA,GAAI,IAAI,KAAA,GAAQ,CAAA;AAAA,QAClD,CAAA,EAAG,GAAA,CAAI,CAAA,GAAI,KAAA,GAAQ,UAAA;AAAA,QACnB,KAAA,EAAO,CAAA;AAAA,QACP,MAAA,EAAQ;AAAA,OACT,CAAA;AAAA,IACH;AAAA,EACF,CAAA;AACA,EAAA,IAAA,CAAK,GAAA,CAAI,MAAM,MAAM,CAAA;AACrB,EAAA,IAAA,CAAK,GAAA,CAAI,OAAO,OAAO,CAAA;AACvB,EAAA,OAAO,GAAA;AACT;AAgBO,SAAS,SAAA,CAAU,IAAA,EAAgB,MAAA,EAAgB,OAAA,EAAuC;AAC/F,EAAA,MAAM,UAAU,IAAA,CAAK,OAAA;AACrB,EAAA,MAAM,OAAA,GAAsB;AAAA,IAC1B,EAAE,EAAA,EAAI,GAAA,EAAK,EAAA,EAAI,QAAQ,CAAA,EAAE;AAAA,IACzB,EAAE,EAAA,EAAI,GAAA,EAAK,EAAA,EAAI,QAAQ,CAAA,EAAE;AAAA,IACzB,EAAE,EAAA,EAAI,GAAA,EAAK,EAAA,EAAI,QAAQ,CAAA,EAAE;AAAA,IACzB,EAAE,EAAA,EAAI,GAAA,EAAK,EAAA,EAAI,QAAQ,CAAA;AAAE,GAC3B;AACA,EAAA,IAAI,OAAO,MAAA,IAAU,CAAA,SAAU,EAAE,OAAA,EAAS,OAAO,OAAA,EAAQ;AAEzD,EAAA,MAAM,WAAuB,EAAC;AAC9B,EAAA,IAAI,OAAA,GAAU,KAAA;AACd,EAAA,IAAI,QAAA,GAAW,KAAA;AACf,EAAA,KAAA,MAAW,GAAA,IAAO,UAAA,CAAW,IAAA,EAAM,MAAA,EAAQ,OAAO,CAAA,EAAG;AACnD,IAAA,IAAI,GAAA,CAAI,GAAA,CAAI,IAAA,KAAS,OAAA,EAAS;AAC9B,IAAA,KAAA,MAAW,MAAM,cAAA,CAAe,GAAA,CAAI,GAAA,EAAK,GAAA,EAAK,OAAO,CAAA,EAAG;AACtD,MAAA,IAAI,EAAA,CAAG,IAAA,KAAS,MAAA,EAAQ,OAAA,GAAU,IAAA;AAAA,WAC7B,QAAA,GAAW,IAAA;AAChB,MAAA,MAAM,CAAA,GAAA,CAAK,GAAG,CAAA,GAAI,EAAA,CAAG,SAAS,CAAA,GAAI,MAAA,CAAO,KAAK,MAAA,CAAO,MAAA;AACrD,MAAA,QAAA,CAAS,IAAA,CAAK,QAAA;AAAA,QACZ,EAAE,EAAA,EAAI,EAAA,CAAG,IAAA,CAAK,IAAI,EAAA,EAAI,EAAE,CAAA,EAAG,EAAA,CAAG,IAAA,KAAS,MAAA,GAAS,CAAA,GAAI,CAAA,EAAG,GAAE,EAAE;AAAA,QAC3D,GAAG,IAAA,CAAK;AAAA,OACT,CAAA;AAAA,IACH;AAAA,EACF;AACA,EAAA,MAAM,IAAA,GAAO,OAAA,CAAQ,MAAA,CAAO,CAAC,MAC3B,EAAE,CAAA,CAAE,EAAA,KAAO,GAAA,IAAO,OAAA,CAAA,IAAY,EAAE,CAAA,CAAE,EAAA,KAAO,OAAO,QAAA,CAAS,CAAA;AAC3D,EAAA,OAAO,EAAE,SAAS,KAAA,EAAO,CAAC,GAAG,IAAA,EAAM,GAAG,QAAQ,CAAA,EAAE;AAClD;AAEA,SAAS,QAAA,CAAS,MAAgB,IAAA,EAAoC;AACpE,EAAA,OAAO,SAAS,MAAA,GAAY,IAAA,GAAO,EAAE,GAAG,MAAM,IAAA,EAAK;AACrD;AAIO,SAAS,WAAA,CAAY,MAAgB,MAAA,EAAgB;AAC1D,EAAA,OAAO,WAAA,CAAY,IAAA,CAAK,OAAA,EAAS,MAAM,CAAA;AACzC;AA2CO,SAAS,SAAA,CACd,IAAA,EACA,EAAA,EACA,IAAA,EAC8D;AAC9D,EAAA,MAAM,OAAO,UAAA,CAAW,EAAA,EAAI,YAAY,IAAA,EAAM,IAAA,CAAK,OAAO,CAAC,CAAA;AAC3D,EAAA,MAAM,QAA8C,CAAC;AAAA,IACnD,IAAA,EAAM,WAAA;AAAA,IACN,OAAO,IAAA,CAAK,KAAA;AAAA,IACZ,IAAA;AAAA,IACA,IAAA,EAAM,KAAK,IAAA,CAAK,SAAA,CAAU,MAAM,IAAA,EAAM,IAAA,CAAK,OAAO,CAAA,EAAG,IAAI,CAAA;AAAA,IACzD,GAAI,KAAK,EAAA,KAAO,MAAA,GAAY,EAAC,GAAI,EAAE,EAAA,EAAI,IAAA,CAAK,EAAA;AAAG,GAChD,CAAA;AAED,EAAA,MAAM,IAAA,GAAO,CAAC,GAAA,EAAa,IAAA,KAAsB;AAC/C,IAAA,KAAA,CAAM,IAAA,CAAK;AAAA,MACT,IAAA,EAAM,MAAA;AAAA,MACN,OAAO,IAAA,CAAK,KAAA;AAAA,MACZ,IAAA,EAAM,EAAE,GAAG,IAAA,EAAM,GAAG,GAAA,CAAI,CAAA,EAAG,CAAA,EAAG,GAAA,CAAI,GAAG,KAAA,EAAO,GAAA,CAAI,KAAA,EAAO,MAAA,EAAQ,IAAI,MAAA,EAAO;AAAA,MAC1E,IAAA;AAAA,MACA,QAAA,EAAU,KAAA;AAAA,MACV,GAAI,KAAK,EAAA,KAAO,MAAA,GAAY,EAAC,GAAI,EAAE,MAAA,EAAQ,IAAA,CAAK,EAAA;AAAG,KACpD,CAAA;AAAA,EACH,CAAA;AAEA,EAAA,MAAM,YAAY,IAAA,CAAK,SAAA;AACvB,EAAA,KAAA,MAAW,OAAO,UAAA,CAAW,IAAA,EAAM,IAAA,EAAM,IAAA,CAAK,OAAO,CAAA,EAAG;AACtD,IAAA,MAAM,OAAO,IAAA,CAAK,GAAA,CAAI,QAAQ,GAAA,CAAI,GAAG,GAAG,GAAG,CAAA;AAC3C,IAAA,IAAI,IAAA,KAAS,IAAA,EAAM,IAAA,CAAK,GAAA,EAAK,IAAI,CAAA;AACjC,IAAA,IAAI,SAAA,KAAc,MAAA,IAAa,GAAA,CAAI,GAAA,CAAI,SAAS,OAAA,EAAS;AACzD,IAAA,KAAA,MAAW,MAAM,cAAA,CAAe,GAAA,CAAI,KAAK,GAAA,EAAK,IAAA,CAAK,OAAO,CAAA,EAAG;AAC3D,MAAA,IAAI,EAAA,CAAG,IAAA,CAAK,KAAA,KAAU,MAAA,EAAW;AACjC,MAAA,MAAM,SAAA,GAAY,SAAA,CAAU,EAAA,CAAG,IAAA,CAAK,OAAO,EAAE,CAAA;AAC7C,MAAA,IAAI,SAAA,KAAc,IAAA,EAAM,IAAA,CAAK,EAAA,EAAI,SAAS,CAAA;AAAA,IAC5C;AAAA,EACF;AACA,EAAA,OAAO,EAAE,MAAM,KAAA,EAAM;AACvB;AAGA,SAAS,QAAQ,GAAA,EAAkB;AACjC,EAAA,IAAI,GAAA,CAAI,IAAA,KAAS,OAAA,EAAS,OAAO,GAAA,CAAI,IAAA;AACrC,EAAA,IAAI,GAAA,CAAI,SAAS,OAAA,EAAS,OAAO,GAAG,GAAA,CAAI,KAAK,CAAA,EAAA,EAAK,GAAA,CAAI,KAAK,CAAA,CAAA;AAC3D,EAAA,OAAO,EAAA;AACT;;;ACvUO,IAAM,gBAAA,GAAmB;AAEzB,IAAM,gBAAA,GAAmB;AAChC,IAAM,iBAAA,GAAoB,IAAA;AAYnB,SAAS,OAAA,CAAQ,YAA6B,MAAA,EAAoB;AACvE,EAAA,QAAQ,SAAA;AAAW,IACjB,KAAK,IAAA;AACH,MAAA,OAAO,EAAE,IAAA,EAAM,GAAA,EAAK,KAAA,EAAO,GAAA,EAAK,MAAM,EAAA,EAAG;AAAA,IAC3C,KAAK,OAAA;AACH,MAAA,OAAO,EAAE,IAAA,EAAM,GAAA,EAAK,KAAA,EAAO,GAAA,EAAK,MAAM,CAAA,EAAE;AAAA,IAC1C,KAAK,MAAA;AACH,MAAA,OAAO,EAAE,IAAA,EAAM,GAAA,EAAK,KAAA,EAAO,GAAA,EAAK,MAAM,EAAA,EAAG;AAAA,IAC3C;AACE,MAAA,OAAO,EAAE,IAAA,EAAM,GAAA,EAAK,KAAA,EAAO,GAAA,EAAK,MAAM,CAAA,EAAE;AAAA;AAE9C;AAGO,SAAS,MAAA,CAAO,QAAgB,IAAA,EAAyB;AAC9D,EAAA,OAAO,IAAA,KAAS,GAAA,GAAM,MAAA,CAAO,KAAA,GAAQ,MAAA,CAAO,MAAA;AAC9C;AAGO,SAAS,MAAA,CAAO,QAAgB,IAAA,EAAyB;AAC9D,EAAA,OAAO,IAAA,KAAS,GAAA,GAAM,MAAA,CAAO,CAAA,GAAI,MAAA,CAAO,QAAQ,CAAA,GAAI,MAAA,CAAO,CAAA,GAAI,MAAA,CAAO,MAAA,GAAS,CAAA;AACjF;AAGO,SAAS,SAAA,CAAU,KAAA,EAAc,IAAA,GAAsB,EAAC,EAAgB;AAC7E,EAAA,MAAM,SAAS,IAAI,GAAA,CAAY,IAAA,CAAK,GAAA,IAAO,EAAE,CAAA;AAC7C,EAAA,KAAA,MAAW,IAAA,IAAQ,MAAM,KAAA,EAAO;AAC9B,IAAA,IAAI,IAAA,CAAK,MAAA,EAAQ,MAAA,CAAO,GAAA,CAAI,KAAK,EAAE,CAAA;AAAA,EACrC;AACA,EAAA,OAAO,MAAA;AACT;AAyBO,SAAS,MAAA,CACd,KAAA,EACA,KAAA,EACA,IAAA,GAAsB,EAAC,EACT;AACd,EAAA,MAAM,IAAA,GAAO,OAAA,CAAQ,IAAA,CAAK,SAAS,CAAA;AACnC,EAAA,MAAM,MAAA,GAAS,SAAA,CAAU,KAAA,EAAO,IAAI,CAAA;AACpC,EAAA,MAAM,SAAA,GAAY,KAAK,SAAA,IAAa,iBAAA;AAEpC,EAAA,MAAM,MAAA,uBAAa,GAAA,EAAkB;AACrC,EAAA,KAAA,MAAW,IAAA,IAAQ,MAAM,KAAA,EAAO;AAC9B,IAAA,MAAM,IAAA,GAAO,KAAA,CAAM,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA;AAC9B,IAAA,IAAI,SAAS,MAAA,EAAW;AACxB,IAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,IAAA,KAAS,CAAA,GAAI,IAAA,CAAK,IAAA,GAAO,EAAE,IAAA,CAAK,IAAA,GAAO,MAAA,CAAO,IAAA,CAAK,MAAA,EAAQ,KAAK,IAAI,CAAA,CAAA;AACvF,IAAA,MAAA,CAAO,GAAA;AAAA,MACL,IAAA,CAAK,EAAA;AAAA,MACL,IAAA,CAAK,IAAA,KAAS,GAAA,GAAM,EAAE,GAAG,IAAA,CAAK,KAAA,EAAO,CAAA,EAAG,KAAA,KAAU,EAAE,CAAA,EAAG,KAAA,EAAO,CAAA,EAAG,KAAK,KAAA;AAAM,KAC9E;AAAA,EACF;AAEA,EAAA,OAAO,UAAA,CAAW,KAAA,EAAO,MAAA,EAAQ,MAAA,EAAQ,SAAS,CAAA;AACpD;AAOO,SAAS,UAAA,CACd,KAAA,EACA,MAAA,EACA,MAAA,EACA,YAAY,iBAAA,EACE;AACd,EAAA,MAAM,MAAA,GAAS,WAAA,CAAY,KAAA,EAAO,MAAA,EAAQ,MAAM,CAAA;AAChD,EAAA,MAAM,GAAA,uBAAU,GAAA,EAAkB;AAClC,EAAA,KAAA,MAAW,IAAA,IAAQ,MAAM,KAAA,EAAO;AAC9B,IAAA,MAAM,EAAA,GAAK,MAAA,CAAO,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA;AAC7B,IAAA,IAAI,OAAO,MAAA,IAAa,MAAA,CAAO,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA,EAAG;AAC7C,IAAA,MAAM,CAAA,GAAI,EAAA,CAAG,CAAA,GAAI,MAAA,CAAO,CAAA;AACxB,IAAA,MAAM,CAAA,GAAI,EAAA,CAAG,CAAA,GAAI,MAAA,CAAO,CAAA;AACxB,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,CAAA,GAAI,IAAA,CAAK,OAAO,CAAC,CAAA,IAAK,SAAA,IAAa,IAAA,CAAK,IAAI,CAAA,GAAI,IAAA,CAAK,MAAA,CAAO,CAAC,KAAK,SAAA,EAAW;AACxF,MAAA;AAAA,IACF;AACA,IAAA,GAAA,CAAI,IAAI,IAAA,CAAK,EAAA,EAAI,EAAE,CAAA,EAAG,GAAG,CAAA;AAAA,EAC3B;AACA,EAAA,OAAO,GAAA;AACT;AAEA,SAAS,WAAA,CACP,KAAA,EACA,MAAA,EACA,MAAA,EACM;AACN,EAAA,KAAA,MAAW,IAAA,IAAQ,MAAM,KAAA,EAAO;AAC9B,IAAA,IAAI,CAAC,MAAA,CAAO,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA,EAAG;AAC1B,IAAA,MAAM,EAAA,GAAK,MAAA,CAAO,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA;AAC7B,IAAA,IAAI,EAAA,KAAO,MAAA,EAAW,OAAO,EAAE,GAAG,IAAA,CAAK,MAAA,CAAO,CAAA,GAAI,EAAA,CAAG,GAAG,CAAA,EAAG,IAAA,CAAK,MAAA,CAAO,CAAA,GAAI,GAAG,CAAA,EAAE;AAAA,EAClF;AACA,EAAA,IAAI,OAAA,GAAU,QAAA;AACd,EAAA,IAAI,OAAA,GAAU,QAAA;AACd,EAAA,IAAI,OAAA,GAAU,QAAA;AACd,EAAA,IAAI,OAAA,GAAU,QAAA;AACd,EAAA,KAAA,MAAW,IAAA,IAAQ,MAAM,KAAA,EAAO;AAC9B,IAAA,MAAM,EAAA,GAAK,MAAA,CAAO,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA;AAC7B,IAAA,IAAI,OAAO,MAAA,EAAW;AACtB,IAAA,OAAA,GAAU,IAAA,CAAK,GAAA,CAAI,OAAA,EAAS,IAAA,CAAK,OAAO,CAAC,CAAA;AACzC,IAAA,OAAA,GAAU,IAAA,CAAK,GAAA,CAAI,OAAA,EAAS,IAAA,CAAK,OAAO,CAAC,CAAA;AACzC,IAAA,OAAA,GAAU,IAAA,CAAK,GAAA,CAAI,OAAA,EAAS,EAAA,CAAG,CAAC,CAAA;AAChC,IAAA,OAAA,GAAU,IAAA,CAAK,GAAA,CAAI,OAAA,EAAS,EAAA,CAAG,CAAC,CAAA;AAAA,EAClC;AACA,EAAA,IAAI,CAAC,MAAA,CAAO,QAAA,CAAS,OAAO,CAAA,SAAU,EAAE,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,EAAE;AACnD,EAAA,OAAO,EAAE,CAAA,EAAG,OAAA,GAAU,OAAA,EAAS,CAAA,EAAG,UAAU,OAAA,EAAQ;AACtD;AASO,SAAS,UAAA,CACd,KAAA,EACA,IAAA,EACA,GAAA,EAC2C;AAC3C,EAAA,MAAM,EAAA,uBAAS,GAAA,EAAoB;AACnC,EAAA,IAAI,MAAA,GAAS,CAAA;AACb,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,EAAA,CAAG,GAAA,CAAI,IAAA,CAAK,EAAA,EAAI,MAAM,CAAA;AACtB,IAAA,MAAA,IAAU,MAAA,CAAO,IAAA,CAAK,MAAA,EAAQ,IAAI,CAAA,GAAI,GAAA;AAAA,EACxC;AACA,EAAA,OAAO,EAAE,IAAI,IAAA,EAAM,KAAA,CAAM,WAAW,CAAA,GAAI,CAAA,GAAI,SAAS,GAAA,EAAI;AAC3D;AAKO,SAAS,WAAA,CACd,KAAA,EACA,IAAA,EACA,OAAA,EACa;AACb,EAAA,OAAO,CAAC,GAAG,KAAK,EAAE,IAAA,CAAK,CAAC,GAAG,CAAA,KAAM;AAC/B,IAAA,MAAM,CAAA,GAAI,OAAO,CAAA,CAAE,MAAA,EAAQ,IAAI,CAAA,GAAI,MAAA,CAAO,CAAA,CAAE,MAAA,EAAQ,IAAI,CAAA;AACxD,IAAA,OAAO,CAAA,KAAM,IAAI,CAAA,GAAI,OAAA,CAAQ,EAAE,EAAE,CAAA,GAAI,OAAA,CAAQ,CAAA,CAAE,EAAE,CAAA;AAAA,EACnD,CAAC,CAAA;AACH;AAGO,SAAS,WAAW,KAAA,EAAsC;AAC/D,EAAA,MAAM,KAAA,uBAAY,GAAA,EAAoB;AACtC,EAAA,KAAA,CAAM,KAAA,CAAM,OAAA,CAAQ,CAAC,IAAA,EAAM,CAAA,KAAM,MAAM,GAAA,CAAI,IAAA,CAAK,EAAA,EAAI,CAAC,CAAC,CAAA;AACtD,EAAA,OAAO,CAAC,EAAA,KAAO,KAAA,CAAM,GAAA,CAAI,EAAE,KAAK,MAAA,CAAO,gBAAA;AACzC;ACrLA,IAAM,QAAA,GAAW;AAAA,EACf,UAAA,EAAY,GAAA;AAAA,EACZ,YAAA,EAAc,GAAA;AAAA,EACd,YAAA,EAAc,IAAA;AAAA,EACd,MAAA,EAAQ,IAAA;AAAA,EACR,OAAA,EAAS,IAAA;AAAA,EACT,OAAA,EAAS;AACX,CAAA;AAIA,IAAM,SAAS,IAAA,CAAK,EAAA,IAAM,CAAA,GAAI,IAAA,CAAK,KAAK,CAAC,CAAA,CAAA;AAGzC,IAAM,KAAA,GAAQ,GAAA;AAGd,SAAS,MAAA,CAAO,QAA8B,QAAA,EAA8C;AAC1F,EAAA,OAAO,CAAC,KAAA,KAAU;AAChB,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,MAAA,CAAO,QAAQ,CAAA,EAAA,EAAK;AACtC,MAAA,MAAM,CAAA,GAAI,OAAO,CAAC,CAAA;AAClB,MAAA,KAAA,IAAS,IAAI,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,MAAA,CAAO,QAAQ,CAAA,EAAA,EAAK;AAC1C,QAAA,MAAM,CAAA,GAAI,OAAO,CAAC,CAAA;AAClB,QAAA,MAAM,EAAA,GAAK,CAAA,CAAE,CAAA,GAAI,CAAA,CAAE,CAAA;AACnB,QAAA,MAAM,EAAA,GAAK,CAAA,CAAE,CAAA,GAAI,CAAA,CAAE,CAAA;AACnB,QAAA,MAAM,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,EAAA,GAAK,EAAA;AAC1B,QAAA,IAAI,OAAO,CAAA,EAAG;AACd,QAAA,MAAM,CAAA,GAAK,WAAW,KAAA,GAAS,EAAA;AAC/B,QAAA,CAAA,CAAE,MAAO,EAAA,GAAK,CAAA;AACd,QAAA,CAAA,CAAE,MAAO,EAAA,GAAK,CAAA;AACd,QAAA,CAAA,CAAE,MAAO,EAAA,GAAK,CAAA;AACd,QAAA,CAAA,CAAE,MAAO,EAAA,GAAK,CAAA;AAAA,MAChB;AAAA,IACF;AAAA,EACF,CAAA;AACF;AAGA,SAAS,KAAA,CACP,MAAA,EACA,KAAA,EACA,QAAA,EACA,QAAA,EAC4B;AAC5B,EAAA,OAAO,CAAC,KAAA,KAAU;AAChB,IAAA,KAAA,MAAW,IAAA,IAAQ,MAAM,KAAA,EAAO;AAC9B,MAAA,MAAM,CAAA,GAAI,MAAA,CAAO,GAAA,CAAI,IAAA,CAAK,IAAI,CAAA;AAC9B,MAAA,MAAM,CAAA,GAAI,MAAA,CAAO,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA;AAC5B,MAAA,IAAI,CAAA,KAAM,MAAA,IAAa,CAAA,KAAM,MAAA,IAAa,MAAM,CAAA,EAAG;AACnD,MAAA,MAAM,EAAA,GAAK,CAAA,CAAE,CAAA,GAAI,CAAA,CAAE,CAAA;AACnB,MAAA,MAAM,EAAA,GAAK,CAAA,CAAE,CAAA,GAAI,CAAA,CAAE,CAAA;AACnB,MAAA,MAAM,CAAA,GAAI,IAAA,CAAK,KAAA,CAAM,EAAA,EAAI,EAAE,CAAA;AAC3B,MAAA,IAAI,MAAM,CAAA,EAAG;AACb,MAAA,MAAM,IAAA,GAAA,CAAS,CAAA,GAAI,QAAA,IAAY,CAAA,GAAK,KAAA,GAAQ,QAAA;AAC5C,MAAA,CAAA,CAAE,MAAO,EAAA,GAAK,IAAA;AACd,MAAA,CAAA,CAAE,MAAO,EAAA,GAAK,IAAA;AACd,MAAA,CAAA,CAAE,MAAO,EAAA,GAAK,IAAA;AACd,MAAA,CAAA,CAAE,MAAO,EAAA,GAAK,IAAA;AAAA,IAChB;AAAA,EACF,CAAA;AACF;AAUA,SAAS,aAAA,CAAc,QAA8B,OAAA,EAA6C;AAChG,EAAA,OAAO,MAAM;AACX,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,MAAA,CAAO,QAAQ,CAAA,EAAA,EAAK;AACtC,MAAA,MAAM,CAAA,GAAI,OAAO,CAAC,CAAA;AAClB,MAAA,KAAA,IAAS,IAAI,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,MAAA,CAAO,QAAQ,CAAA,EAAA,EAAK;AAC1C,QAAA,MAAM,CAAA,GAAI,OAAO,CAAC,CAAA;AAClB,QAAA,MAAM,EAAA,GAAK,CAAA,CAAE,CAAA,GAAI,CAAA,CAAE,CAAA;AACnB,QAAA,MAAM,EAAA,GAAK,CAAA,CAAE,CAAA,GAAI,CAAA,CAAE,CAAA;AACnB,QAAA,MAAM,IAAA,GAAO,EAAE,EAAA,GAAK,CAAA,CAAE,KAAK,OAAA,GAAU,IAAA,CAAK,IAAI,EAAE,CAAA;AAChD,QAAA,MAAM,IAAA,GAAO,EAAE,EAAA,GAAK,CAAA,CAAE,KAAK,OAAA,GAAU,IAAA,CAAK,IAAI,EAAE,CAAA;AAChD,QAAA,IAAI,IAAA,IAAQ,CAAA,IAAK,IAAA,IAAQ,CAAA,EAAG;AAC5B,QAAA,IAAI,OAAO,IAAA,EAAM;AACf,UAAA,MAAM,QAAQ,IAAA,CAAK,IAAA,CAAK,EAAE,CAAA,IAAK,KAAK,IAAA,GAAO,GAAA;AAC3C,UAAA,CAAA,CAAE,EAAA,IAAO,IAAA;AACT,UAAA,CAAA,CAAE,EAAA,IAAO,IAAA;AAAA,QACX,CAAA,MAAO;AACL,UAAA,MAAM,QAAQ,IAAA,CAAK,IAAA,CAAK,EAAE,CAAA,IAAK,KAAK,IAAA,GAAO,GAAA;AAC3C,UAAA,CAAA,CAAE,EAAA,IAAO,IAAA;AACT,UAAA,CAAA,CAAE,EAAA,IAAO,IAAA;AAAA,QACX;AAAA,MACF;AAAA,IACF;AAAA,EACF,CAAA;AACF;AAIA,SAAS,OAAA,CAAQ,MAAA,EAA8B,EAAA,EAA8B,QAAA,EAA8C;AACzH,EAAA,OAAO,CAAC,KAAA,KAAU;AAChB,IAAA,KAAA,MAAW,QAAQ,MAAA,EAAQ;AACzB,MAAA,IAAA,CAAK,EAAA,IAAA,CAAQ,EAAA,CAAG,CAAA,GAAI,IAAA,CAAK,KAAK,QAAA,GAAW,KAAA;AACzC,MAAA,IAAA,CAAK,EAAA,IAAA,CAAQ,EAAA,CAAG,CAAA,GAAI,IAAA,CAAK,KAAK,QAAA,GAAW,KAAA;AAAA,IAC3C;AAAA,EACF,CAAA;AACF;AAsBO,SAAS,eAAA,CAAgB,KAAA,EAAc,IAAA,GAAqB,EAAC,EAAoB;AACtF,EAAA,MAAM;AAAA,IACJ,eAAe,QAAA,CAAS,YAAA;AAAA,IACxB,eAAe,QAAA,CAAS,YAAA;AAAA,IACxB,MAAA,EAAQ,iBAAiB,QAAA,CAAS,MAAA;AAAA,IAClC,OAAA,EAAS,kBAAkB,QAAA,CAAS,OAAA;AAAA,IACpC,UAAU,QAAA,CAAS;AAAA,GACrB,GAAI,IAAA;AAEJ,EAAA,MAAM,MAAA,GAAS,SAAA,CAAU,KAAA,EAAO,IAAI,CAAA;AACpC,EAAA,MAAM,MAAA,GAAsB,KAAA,CAAM,KAAA,CAAM,GAAA,CAAI,CAAC,IAAA,KAAS;AACpD,IAAA,MAAM,IAAA,GAAkB;AAAA,MACtB,IAAI,IAAA,CAAK,EAAA;AAAA,MACT,CAAA,EAAG,MAAA,CAAO,IAAA,CAAK,MAAA,EAAQ,GAAG,CAAA;AAAA,MAC1B,CAAA,EAAG,MAAA,CAAO,IAAA,CAAK,MAAA,EAAQ,GAAG,CAAA;AAAA,MAC1B,EAAA,EAAI,IAAA,CAAK,MAAA,CAAO,KAAA,GAAQ,CAAA;AAAA,MACxB,EAAA,EAAI,IAAA,CAAK,MAAA,CAAO,MAAA,GAAS;AAAA,KAC3B;AAIA,IAAA,IAAI,MAAA,CAAO,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA,EAAG;AACvB,MAAA,IAAA,CAAK,KAAK,IAAA,CAAK,CAAA;AACf,MAAA,IAAA,CAAK,KAAK,IAAA,CAAK,CAAA;AAAA,IACjB;AACA,IAAA,OAAO,IAAA;AAAA,EACT,CAAC,CAAA;AACD,EAAA,QAAA,CAAS,MAAM,CAAA;AAEf,EAAA,MAAM,IAAA,GAAO,IAAI,GAAA,CAAI,MAAA,CAAO,GAAA,CAAI,CAAC,CAAA,KAAM,CAAC,CAAA,CAAE,EAAA,EAAI,CAAC,CAAC,CAAC,CAAA;AACjD,EAAA,MAAM,QAAA,GAAW;AAAA,IACf,CAAA,EAAG,MAAA,CAAO,MAAA,CAAO,CAAC,GAAA,EAAK,CAAA,KAAM,GAAA,GAAM,CAAA,CAAE,CAAA,EAAG,CAAC,CAAA,GAAI,MAAA,CAAO,MAAA;AAAA,IACpD,CAAA,EAAG,MAAA,CAAO,MAAA,CAAO,CAAC,GAAA,EAAK,CAAA,KAAM,GAAA,GAAM,CAAA,CAAE,CAAA,EAAG,CAAC,CAAA,GAAI,MAAA,CAAO;AAAA,GACtD;AAEA,EAAA,MAAM,MAAM,gBAAA,CAA4B;AAAA,IACtC,KAAA,EAAO,MAAA;AAAA,IACP,MAAA,EAAQ;AAAA,MACN,MAAA,CAAO,QAAQ,cAAc,CAAA;AAAA,MAC7B,KAAA,CAAM,IAAA,EAAM,KAAA,EAAO,YAAA,EAAc,YAAY,CAAA;AAAA,MAC7C,OAAA,CAAQ,MAAA,EAAQ,QAAA,EAAU,eAAe,CAAA;AAAA,MACzC,aAAA,CAAc,QAAQ,OAAO;AAAA;AAC/B,GACD,CAAA;AAED,EAAA,OAAO;AAAA,IACL,MAAA;AAAA,IACA,IAAA;AAAA,IACA,MAAA;AAAA,IACA,GAAA;AAAA,IACA,MAAA,GAAS;AACP,MAAA,MAAM,MAAA,uBAAa,GAAA,EAAsC;AACzD,MAAA,KAAA,MAAW,IAAA,IAAQ,MAAM,KAAA,EAAO;AAC9B,QAAA,MAAM,IAAA,GAAO,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA;AAC7B,QAAA,MAAA,CAAO,GAAA,CAAI,KAAK,EAAA,EAAI;AAAA,UAClB,CAAA,EAAG,IAAA,CAAK,CAAA,GAAI,IAAA,CAAK,OAAO,KAAA,GAAQ,CAAA;AAAA,UAChC,CAAA,EAAG,IAAA,CAAK,CAAA,GAAI,IAAA,CAAK,OAAO,MAAA,GAAS;AAAA,SAClC,CAAA;AAAA,MACH;AACA,MAAA,OAAO,MAAA;AAAA,IACT;AAAA,GACF;AACF;AAKO,IAAM,KAAA,GAAQ,CAAC,KAAA,EAAc,IAAA,GAAqB,EAAC,KAAoB;AAC5E,EAAA,IAAI,MAAM,KAAA,CAAM,MAAA,KAAW,CAAA,EAAG,2BAAW,GAAA,EAAI;AAC7C,EAAA,MAAM,UAAA,GAAa,eAAA,CAAgB,KAAA,EAAO,IAAI,CAAA;AAC9C,EAAA,UAAA,CAAW,GAAA,CAAI,IAAA,CAAK,IAAA,CAAK,UAAA,IAAc,SAAS,UAAU,CAAA;AAC1D,EAAA,OAAO,UAAA,CAAW,OAAO,UAAA,CAAW,MAAA,IAAU,UAAA,CAAW,MAAA,EAAQ,KAAK,SAAS,CAAA;AACjF;AASA,SAAS,SAAS,MAAA,EAA2B;AAC3C,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAoB;AACrC,EAAA,MAAA,CAAO,OAAA,CAAQ,CAAC,IAAA,EAAM,CAAA,KAAM;AAC1B,IAAA,MAAM,MAAM,CAAA,EAAG,IAAA,CAAK,CAAC,CAAA,CAAA,EAAI,KAAK,CAAC,CAAA,CAAA;AAC/B,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,GAAA,CAAI,GAAG,CAAA,IAAK,CAAA;AAC7B,IAAA,IAAA,CAAK,GAAA,CAAI,GAAA,EAAK,GAAA,GAAM,CAAC,CAAA;AACrB,IAAA,IAAI,QAAQ,CAAA,IAAK,IAAA,CAAK,MAAM,IAAA,IAAQ,IAAA,CAAK,MAAM,IAAA,EAAM;AACrD,IAAA,MAAM,QAAQ,MAAA,GAAS,CAAA;AACvB,IAAA,MAAM,SAAS,KAAA,GAAQ,GAAA;AACvB,IAAA,IAAA,CAAK,CAAA,IAAK,IAAA,CAAK,GAAA,CAAI,KAAK,CAAA,GAAI,MAAA;AAC5B,IAAA,IAAA,CAAK,CAAA,IAAK,IAAA,CAAK,GAAA,CAAI,KAAK,CAAA,GAAI,MAAA;AAAA,EAC9B,CAAC,CAAA;AACH;;;ACrPO,SAAS,UAAU,KAAA,EAA2B;AACnD,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAY;AAC7B,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAY;AAC7B,EAAA,MAAM,OAAA,uBAAc,GAAA,EAAY;AAEhC,EAAA,MAAM,IAAA,GAAO,CAAC,EAAA,KAAqB;AACjC,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,EAAE,CAAA,EAAG;AAClB,IAAA,OAAA,CAAQ,IAAI,EAAE,CAAA;AACd,IAAA,KAAA,MAAW,IAAA,IAAQ,KAAA,CAAM,QAAA,CAAS,EAAE,CAAA,EAAG;AACrC,MAAA,IAAI,OAAA,CAAQ,IAAI,IAAA,CAAK,EAAE,GAAG,IAAA,CAAK,GAAA,CAAI,KAAK,EAAE,CAAA;AAAA,WACrC,IAAA,CAAK,KAAK,EAAE,CAAA;AAAA,IACnB;AACA,IAAA,OAAA,CAAQ,OAAO,EAAE,CAAA;AACjB,IAAA,IAAA,CAAK,IAAI,EAAE,CAAA;AAAA,EACb,CAAA;AAEA,EAAA,KAAA,MAAW,IAAA,IAAQ,KAAA,CAAM,KAAA,EAAO,IAAA,CAAK,KAAK,EAAE,CAAA;AAC5C,EAAA,OAAO,IAAA;AACT;AAGO,SAAS,OAAA,CAAQ,OAAc,IAAA,EAAgD;AACpF,EAAA,MAAM,KAAA,uBAAY,GAAA,EAAoB;AACtC,EAAA,MAAM,SAAA,uBAAgB,GAAA,EAAY;AAElC,EAAA,MAAM,MAAA,GAAS,CAAC,EAAA,KAAuB;AACrC,IAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,GAAA,CAAI,EAAE,CAAA;AAC1B,IAAA,IAAI,KAAA,KAAU,QAAW,OAAO,KAAA;AAGhC,IAAA,IAAI,SAAA,CAAU,GAAA,CAAI,EAAE,CAAA,EAAG,OAAO,CAAA;AAC9B,IAAA,SAAA,CAAU,IAAI,EAAE,CAAA;AAChB,IAAA,IAAI,IAAA,GAAO,CAAA;AACX,IAAA,KAAA,MAAW,IAAA,IAAQ,KAAA,CAAM,QAAA,CAAS,EAAE,CAAA,EAAG;AACrC,MAAA,IAAI,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA,EAAG;AACvB,MAAA,IAAA,GAAO,KAAK,GAAA,CAAI,IAAA,EAAM,OAAO,IAAA,CAAK,IAAI,IAAI,CAAC,CAAA;AAAA,IAC7C;AACA,IAAA,SAAA,CAAU,OAAO,EAAE,CAAA;AACnB,IAAA,KAAA,CAAM,GAAA,CAAI,IAAI,IAAI,CAAA;AAClB,IAAA,OAAO,IAAA;AAAA,EACT,CAAA;AAEA,EAAA,KAAA,MAAW,IAAA,IAAQ,KAAA,CAAM,KAAA,EAAO,MAAA,CAAO,KAAK,EAAE,CAAA;AAC9C,EAAA,OAAO,KAAA;AACT;AAKO,IAAM,OAAA,GAAoB,CAAC,KAAA,EAAO,IAAA,GAAO,EAAC,KAAM;AACrD,EAAA,MAAM,IAAA,GAAO,OAAA,CAAQ,IAAA,CAAK,SAAS,CAAA;AACnC,EAAA,MAAM,OAAA,GAAU,KAAK,OAAA,IAAW,gBAAA;AAChC,EAAA,MAAM,OAAA,GAAU,KAAK,OAAA,IAAW,gBAAA;AAChC,EAAA,MAAM,KAAA,GAAQ,WAAW,KAAK,CAAA;AAE9B,EAAA,MAAM,KAAA,GAAQ,OAAA,CAAQ,KAAA,EAAO,SAAA,CAAU,KAAK,CAAC,CAAA;AAC7C,EAAA,MAAM,MAAA,uBAAa,GAAA,EAAyB;AAC5C,EAAA,KAAA,MAAW,IAAA,IAAQ,MAAM,KAAA,EAAO;AAC9B,IAAA,MAAM,IAAA,GAAO,KAAA,CAAM,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA,IAAK,CAAA;AACnC,IAAA,MAAM,IAAA,GAAO,MAAA,CAAO,GAAA,CAAI,IAAI,CAAA;AAC5B,IAAA,IAAI,SAAS,MAAA,EAAW,MAAA,CAAO,IAAI,IAAA,EAAM,CAAC,IAAI,CAAC,CAAA;AAAA,SAC1C,IAAA,CAAK,KAAK,IAAI,CAAA;AAAA,EACrB;AAEA,EAAA,MAAM,IAAA,GAAO,CAAC,GAAG,MAAA,CAAO,IAAA,EAAM,CAAA,CAAE,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,CAAA,GAAI,CAAC,CAAA;AACpD,EAAA,MAAM,MAAA,uBAAa,GAAA,EAA2C;AAC9D,EAAA,IAAI,MAAA,GAAS,CAAA;AACb,EAAA,KAAA,MAAW,QAAQ,IAAA,EAAM;AACvB,IAAA,MAAM,GAAA,GAAM,YAAY,MAAA,CAAO,GAAA,CAAI,IAAI,CAAA,EAAI,IAAA,CAAK,OAAO,KAAK,CAAA;AAC5D,IAAA,MAAM,CAAA,GAAI,UAAA,CAAW,GAAA,EAAK,IAAA,CAAK,OAAO,OAAO,CAAA;AAC7C,IAAA,MAAA,CAAO,GAAA,CAAI,MAAM,CAAC,CAAA;AAClB,IAAA,MAAA,GAAS,IAAA,CAAK,GAAA,CAAI,MAAA,EAAQ,CAAA,CAAE,IAAI,CAAA;AAAA,EAClC;AAEA,EAAA,MAAM,KAAA,uBAAY,GAAA,EAAkB;AACpC,EAAA,IAAI,KAAA,GAAQ,CAAA;AACZ,EAAA,KAAA,MAAW,QAAQ,IAAA,EAAM;AACvB,IAAA,MAAM,GAAA,GAAM,MAAA,CAAO,GAAA,CAAI,IAAI,CAAA;AAC3B,IAAA,MAAM,CAAA,GAAI,MAAA,CAAO,GAAA,CAAI,IAAI,CAAA;AACzB,IAAA,MAAM,MAAA,GAAA,CAAU,MAAA,GAAS,CAAA,CAAE,IAAA,IAAQ,CAAA;AACnC,IAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,GAAG,GAAA,CAAI,GAAA,CAAI,CAAC,CAAA,KAAM,OAAO,CAAA,CAAE,MAAA,EAAQ,IAAA,CAAK,IAAI,CAAC,CAAC,CAAA;AACxE,IAAA,KAAA,MAAW,QAAQ,GAAA,EAAK;AACtB,MAAA,KAAA,CAAM,GAAA,CAAI,KAAK,EAAA,EAAI;AAAA,QACjB,OAAO,MAAA,GAAS,CAAA,CAAE,EAAA,CAAG,GAAA,CAAI,KAAK,EAAE,CAAA;AAAA;AAAA;AAAA,QAGhC,IAAA,EAAM,SAAS,KAAA,GAAQ,MAAA,CAAO,KAAK,MAAA,EAAQ,IAAA,CAAK,IAAI,CAAA,IAAK;AAAA,OAC1D,CAAA;AAAA,IACH;AACA,IAAA,KAAA,IAAS,KAAA,GAAQ,OAAA;AAAA,EACnB;AAEA,EAAA,OAAO,MAAA,CAAO,KAAA,EAAO,KAAA,EAAO,IAAI,CAAA;AAClC;;;ACtFO,SAAS,QAAA,CAAS,OAAc,SAAA,EAA8B;AACnE,EAAA,MAAM,KAAA,GAAQ,WAAW,KAAK,CAAA;AAC9B,EAAA,MAAM,QAAA,uBAAe,GAAA,EAAyB;AAC9C,EAAA,MAAM,KAAA,uBAAY,GAAA,EAAoB;AACtC,EAAA,MAAM,QAAqB,EAAC;AAE5B,EAAA,MAAM,KAAA,GAAQ,CAAC,IAAA,EAAiB,EAAA,KAAqB;AACnD,IAAA,KAAA,CAAM,GAAA,CAAI,IAAA,CAAK,EAAA,EAAI,EAAE,CAAA;AACrB,IAAA,MAAM,OAAoB,EAAC;AAC3B,IAAA,KAAA,MAAW,IAAA,IAAQ,KAAA,CAAM,QAAA,CAAS,IAAA,CAAK,EAAE,CAAA,EAAG;AAC1C,MAAA,IAAI,IAAA,CAAK,OAAO,IAAA,CAAK,EAAA,IAAM,MAAM,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA,EAAG;AAC/C,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,IAAA,CAAK,IAAA,CAAK,EAAE,CAAA;AAChC,MAAA,IAAI,UAAU,MAAA,EAAW;AAGzB,MAAA,KAAA,CAAM,GAAA,CAAI,KAAA,CAAM,EAAA,EAAI,EAAA,GAAK,CAAC,CAAA;AAC1B,MAAA,IAAA,CAAK,KAAK,KAAK,CAAA;AAAA,IACjB;AACA,IAAA,MAAM,OAAA,GAAU,WAAA,CAAY,IAAA,EAAM,SAAA,EAAW,KAAK,CAAA;AAClD,IAAA,QAAA,CAAS,GAAA,CAAI,IAAA,CAAK,EAAA,EAAI,OAAO,CAAA;AAC7B,IAAA,KAAA,MAAW,KAAA,IAAS,OAAA,EAAS,KAAA,CAAM,KAAA,EAAO,KAAK,CAAC,CAAA;AAAA,EAClD,CAAA;AAEA,EAAA,MAAM,UAAU,KAAA,CAAM,KAAA,CAAM,OAAO,CAAC,IAAA,KAClC,MAAM,QAAA,CAAS,IAAA,CAAK,EAAE,CAAA,CAAE,MAAM,CAAC,IAAA,KAAS,KAAK,IAAA,KAAS,IAAA,CAAK,EAAE,CAAC,CAAA;AAChE,EAAA,KAAA,MAAW,IAAA,IAAQ,WAAA,CAAY,OAAA,EAAS,SAAA,EAAW,KAAK,CAAA,EAAG;AACzD,IAAA,IAAI,KAAA,CAAM,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA,EAAG;AACxB,IAAA,KAAA,CAAM,KAAK,IAAI,CAAA;AACf,IAAA,KAAA,CAAM,MAAM,CAAC,CAAA;AAAA,EACf;AAGA,EAAA,KAAA,MAAW,IAAA,IAAQ,MAAM,KAAA,EAAO;AAC9B,IAAA,IAAI,KAAA,CAAM,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA,EAAG;AACxB,IAAA,KAAA,CAAM,KAAK,IAAI,CAAA;AACf,IAAA,KAAA,CAAM,MAAM,CAAC,CAAA;AAAA,EACf;AAEA,EAAA,OAAO,EAAE,KAAA,EAAO,QAAA,EAAU,KAAA,EAAM;AAClC;AAKO,IAAM,IAAA,GAAiB,CAAC,KAAA,EAAO,IAAA,GAAO,EAAC,KAAM;AAClD,EAAA,MAAM,IAAA,GAAO,OAAA,CAAQ,IAAA,CAAK,SAAS,CAAA;AACnC,EAAA,MAAM,OAAA,GAAU,KAAK,OAAA,IAAW,gBAAA;AAChC,EAAA,MAAM,OAAA,GAAU,KAAK,OAAA,IAAW,gBAAA;AAChC,EAAA,MAAM,EAAE,OAAO,QAAA,EAAU,KAAA,KAAU,QAAA,CAAS,KAAA,EAAO,KAAK,KAAK,CAAA;AAE7D,EAAA,MAAM,KAAA,uBAAY,GAAA,EAAoB;AACtC,EAAA,KAAA,MAAW,IAAA,IAAQ,MAAM,KAAA,EAAO;AAC9B,IAAA,MAAM,EAAA,GAAK,KAAA,CAAM,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA,IAAK,CAAA;AACjC,IAAA,KAAA,CAAM,GAAA,CAAI,EAAA,EAAI,IAAA,CAAK,GAAA,CAAI,MAAM,GAAA,CAAI,EAAE,CAAA,IAAK,CAAA,EAAG,OAAO,IAAA,CAAK,MAAA,EAAQ,IAAA,CAAK,IAAI,CAAC,CAAC,CAAA;AAAA,EAC5E;AACA,EAAA,MAAM,SAAA,uBAAgB,GAAA,EAAoB;AAC1C,EAAA,IAAI,KAAA,GAAQ,CAAA;AACZ,EAAA,KAAA,MAAW,EAAA,IAAM,CAAC,GAAG,KAAA,CAAM,IAAA,EAAM,CAAA,CAAE,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,CAAA,GAAI,CAAC,CAAA,EAAG;AACxD,IAAA,SAAA,CAAU,GAAA,CAAI,IAAI,KAAK,CAAA;AACvB,IAAA,KAAA,IAAS,KAAA,CAAM,GAAA,CAAI,EAAE,CAAA,GAAK,OAAA;AAAA,EAC5B;AAEA,EAAA,MAAM,KAAA,uBAAY,GAAA,EAAkB;AAIpC,EAAA,MAAM,QAAA,uBAAe,GAAA,EAAoB;AACzC,EAAA,MAAM,OAAA,GAAU,CAAC,IAAA,KAA4B;AAC3C,IAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA;AAClC,IAAA,IAAI,KAAA,KAAU,QAAW,OAAO,KAAA;AAChC,IAAA,MAAM,OAAO,QAAA,CAAS,GAAA,CAAI,IAAA,CAAK,EAAE,KAAK,EAAC;AACvC,IAAA,IAAI,KAAA,GAAQ,CAAA;AACZ,IAAA,KAAA,MAAW,KAAA,IAAS,IAAA,EAAM,KAAA,IAAS,OAAA,CAAQ,KAAK,CAAA;AAChD,IAAA,IAAI,KAAK,MAAA,GAAS,CAAA,EAAG,KAAA,IAAS,OAAA,IAAW,KAAK,MAAA,GAAS,CAAA,CAAA;AACvD,IAAA,MAAM,KAAA,GAAQ,KAAK,GAAA,CAAI,MAAA,CAAO,KAAK,MAAA,EAAQ,IAAA,CAAK,KAAK,CAAA,EAAG,KAAK,CAAA;AAC7D,IAAA,QAAA,CAAS,GAAA,CAAI,IAAA,CAAK,EAAA,EAAI,KAAK,CAAA;AAC3B,IAAA,OAAO,KAAA;AAAA,EACT,CAAA;AAGA,EAAA,MAAM,KAAA,GAAQ,CAAC,IAAA,EAAiB,IAAA,KAAuB;AACrD,IAAA,MAAM,OAAO,QAAA,CAAS,GAAA,CAAI,IAAA,CAAK,EAAE,KAAK,EAAC;AACvC,IAAA,MAAM,KAAA,GAAQ,QAAQ,IAAI,CAAA;AAC1B,IAAA,MAAM,QAAQ,IAAA,CAAK,MAAA,CAAO,CAAC,GAAA,EAAK,CAAA,KAAM,MAAM,OAAA,CAAQ,CAAC,CAAA,EAAG,CAAC,IACrD,IAAA,CAAK,GAAA,CAAI,GAAG,IAAA,CAAK,MAAA,GAAS,CAAC,CAAA,GAAI,OAAA;AAEnC,IAAA,IAAIC,OAAAA,GAAS,IAAA,GAAA,CAAQ,KAAA,GAAQ,KAAA,IAAS,CAAA;AACtC,IAAA,KAAA,MAAW,SAAS,IAAA,EAAM;AACxB,MAAA,KAAA,CAAM,OAAOA,OAAM,CAAA;AACnB,MAAAA,OAAAA,IAAU,OAAA,CAAQ,KAAK,CAAA,GAAI,OAAA;AAAA,IAC7B;AAEA,IAAA,MAAM,GAAA,GAAM,MAAA,CAAO,IAAA,CAAK,MAAA,EAAQ,KAAK,KAAK,CAAA;AAC1C,IAAA,MAAM,EAAA,GAAK,KAAA,CAAM,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA,IAAK,CAAA;AACjC,IAAA,KAAA,CAAM,GAAA,CAAI,KAAK,EAAA,EAAI;AAAA,MACjB,KAAA,EAAO,IAAA,GAAA,CAAQ,KAAA,GAAQ,GAAA,IAAO,CAAA;AAAA,MAC9B,IAAA,EAAM,SAAA,CAAU,GAAA,CAAI,EAAE,KAAM,KAAA,CAAM,GAAA,CAAI,EAAE,CAAA,GAAK,MAAA,CAAO,IAAA,CAAK,MAAA,EAAQ,IAAA,CAAK,IAAI,CAAA,IAAK;AAAA,KAChF,CAAA;AAAA,EACH,CAAA;AAEA,EAAA,IAAI,MAAA,GAAS,CAAA;AACb,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,KAAA,CAAM,MAAM,MAAM,CAAA;AAClB,IAAA,MAAA,IAAU,OAAA,CAAQ,IAAI,CAAA,GAAI,OAAA;AAAA,EAC5B;AAEA,EAAA,OAAO,MAAA,CAAO,KAAA,EAAO,KAAA,EAAO,IAAI,CAAA;AAClC","file":"chunk-4KXQABRM.js","sourcesContent":["/**\n * The shapes a built body can wear, as paths in the node's bounds.\n *\n * These are the flowchart vocabulary — a decision is a diamond, an I/O step a\n * parallelogram, a terminator a stadium — plus `'rect'` for everything else and\n * a `Path` escape hatch for a shape the vocabulary does not have. The path is\n * built in world coordinates from the bounds it is given, the same way the\n * kit's own `clipFromPose` factories are.\n */\nimport { PathBuilder, polygonFromPoints, rectPath, type Path } from '@weasel-js/core/math';\n\n/** An axis-aligned box. This is `PoseDescriptor.getBounds`'s return shape\n *  minus its optional `rotation`, deliberately: an outline is built in the\n *  shape's own unrotated frame, and the caller reads rotation separately\n *  through `getRotation` and applies it to the finished path. */\nexport interface Bounds {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** A named flowchart shape, or a path a consumer built themselves. */\nexport type Outline = 'rect' | 'diamond' | 'stadium' | 'parallelogram' | Path;\n\n/** How far a parallelogram's top edge leans past its bottom one, as a\n *  fraction of the box's width. The flowchart convention. */\nconst LEAN = 0.2;\n\n/** Cubic approximation of a quarter circle. A stadium's ends are two of these\n *  each, which is the same construction `ellipsePath` uses. */\nconst KAPPA = 0.5522847498307936;\n\n/** The path `outline` describes inside `bounds`. A zero-area box gives a\n *  zero-area rect rather than a degenerate polygon. */\nexport function outlinePath(outline: Outline, bounds: Bounds): Path {\n  if (typeof outline !== 'string') return outline;\n  const { x, y, width: w, height: h } = bounds;\n  if (w <= 0 || h <= 0) return rectPath(x, y, Math.max(w, 0), Math.max(h, 0));\n\n  switch (outline) {\n    case 'rect':\n      return rectPath(x, y, w, h);\n\n    case 'diamond':\n      return polygonFromPoints([\n        { x: x + w / 2, y },\n        { x: x + w, y: y + h / 2 },\n        { x: x + w / 2, y: y + h },\n        { x, y: y + h / 2 },\n      ]);\n\n    case 'parallelogram': {\n      // The lean is clamped so a narrow box cannot fold through itself.\n      const lean = Math.min(w * LEAN, w / 2);\n      return polygonFromPoints([\n        { x: x + lean, y },\n        { x: x + w, y },\n        { x: x + w - lean, y: y + h },\n        { x, y: y + h },\n      ]);\n    }\n\n    case 'stadium':\n      return stadiumPath(x, y, w, h);\n  }\n}\n\n/** A rect with semicircular ends — the Minkowski sum of a segment and a disc,\n *  which puts the flat edges along the box's *longer* axis. A tall box is a\n *  pill standing up, not an ellipse. */\nfunction stadiumPath(x: number, y: number, w: number, h: number): Path {\n  const r = Math.min(w, h) / 2;\n  const k = r * KAPPA;\n  const b = new PathBuilder();\n\n  if (w >= h) {\n    const left = x + r;\n    const right = x + w - r;\n    const top = y;\n    const bottom = y + h;\n    const midY = y + h / 2;\n    return b\n      .moveTo(left, top)\n      .lineTo(right, top)\n      .curveTo(right + k, top, x + w, midY - k, x + w, midY)\n      .curveTo(x + w, midY + k, right + k, bottom, right, bottom)\n      .lineTo(left, bottom)\n      .curveTo(left - k, bottom, x, midY + k, x, midY)\n      .curveTo(x, midY - k, left - k, top, left, top)\n      .close()\n      .build();\n  }\n\n  const top = y + r;\n  const bottom = y + h - r;\n  const left = x;\n  const right = x + w;\n  const midX = x + w / 2;\n  return b\n    .moveTo(right, top)\n    .lineTo(right, bottom)\n    .curveTo(right, bottom + k, midX + k, y + h, midX, y + h)\n    .curveTo(midX - k, y + h, left, bottom + k, left, bottom)\n    .lineTo(left, top)\n    .curveTo(left, top - k, midX - k, y, midX, y)\n    .curveTo(midX + k, y, right, top - k, right, top)\n    .close()\n    .build();\n}\n\n/**\n * The largest axis-aligned box a shape's content can occupy without leaving\n * the shape. Rows lay out in here, not in the bounds — a diamond's corners and\n * a parallelogram's lean are outside its own box, and a label placed against\n * the bounding box lands there and gets clipped away by the silhouette.\n *\n * Conservative rather than exact: the inscribed rect of a rhombus is exact,\n * and a stadium reports the flat span between its rounded ends, which gives up\n * a little height near them.\n */\nexport function contentBox(outline: Outline, bounds: Bounds): Bounds {\n  if (typeof outline !== 'string') return bounds;\n  const { x, y, width: w, height: h } = bounds;\n  switch (outline) {\n    case 'rect':\n      return bounds;\n    case 'diamond':\n      // Half the width and half the height, centered — the inscribed rect.\n      return { x: x + w / 4, y: y + h / 4, width: w / 2, height: h / 2 };\n    case 'parallelogram': {\n      const lean = Math.min(w * LEAN, w / 2);\n      return { x: x + lean, y, width: Math.max(w - lean * 2, 0), height: h };\n    }\n    case 'stadium': {\n      const r = Math.min(w, h) / 2;\n      return w >= h\n        ? { x: x + r, y, width: Math.max(w - r * 2, 0), height: h }\n        : { x, y: y + r, width: w, height: Math.max(h - r * 2, 0) };\n    }\n  }\n}\n\n/**\n * The box whose {@link contentBox} is at least `content` — the inverse, for\n * sizing a node to what its rows measured.\n *\n * The stadium case is the only inexact one: its inset depends on the height it\n * is solving for, so it assumes the wide orientation and adds one height's\n * worth of end caps.\n */\nexport function boxForContent(\n  outline: Outline,\n  content: { width: number; height: number },\n): { width: number; height: number } {\n  if (typeof outline !== 'string') return content;\n  switch (outline) {\n    case 'rect':\n      return content;\n    case 'diamond':\n      return { width: content.width * 2, height: content.height * 2 };\n    case 'parallelogram':\n      return { width: content.width / (1 - LEAN * 2), height: content.height };\n    case 'stadium':\n      return { width: content.width + content.height, height: content.height };\n  }\n}\n","/**\n * Moving a port from the node's bounding box onto the shape it is drawn as.\n *\n * A port is placed as a fraction of the node's bounds, which is what makes it\n * survive a resize. For a rect that is already on the outline; for anything\n * else it can be well outside the ink — a parallelogram's west port floats in\n * the gap beside its leaning edge, and an edge that ends there ends in empty\n * space. So the point is cast back onto the outline along the ray from the\n * node's center, which is the direction an edge leaves anyway.\n */\nimport { PATH_C, PATH_L, PATH_M, PATH_Q, PATH_Z, flattenCubic, type Path } from '@weasel-js/core/math';\nimport { outlinePath, type Bounds, type Outline } from './outline';\nimport type { Port } from './types';\n\n/** Curve flattening tolerance, in world units. Finer than a port is wide. */\nconst TOLERANCE = 0.25;\n\n/** The outline as a closed polyline: `[x0, y0, x1, y1, …]`. */\nexport function outlinePolyline(outline: Outline, bounds: Bounds): number[] {\n  const path = outlinePath(outline, bounds);\n  return flattenPath(path);\n}\n\nfunction flattenPath(path: Path): number[] {\n  if (path.kind === 'rect') {\n    const { x, y, width: w, height: h } = path;\n    return [x, y, x + w, y, x + w, y + h, x, y + h, x, y];\n  }\n  const out: number[] = [];\n  const { commands, coords } = path as { commands: Uint8Array; coords: Float32Array };\n  let ci = 0;\n  let cx = 0;\n  let cy = 0;\n  let sx = 0;\n  let sy = 0;\n  for (const cmd of commands) {\n    if (cmd === PATH_M) {\n      cx = coords[ci]!; cy = coords[ci + 1]!; ci += 2;\n      sx = cx; sy = cy;\n      out.push(cx, cy);\n    } else if (cmd === PATH_L) {\n      cx = coords[ci]!; cy = coords[ci + 1]!; ci += 2;\n      out.push(cx, cy);\n    } else if (cmd === PATH_C) {\n      const x1 = coords[ci]!, y1 = coords[ci + 1]!;\n      const x2 = coords[ci + 2]!, y2 = coords[ci + 3]!;\n      const x3 = coords[ci + 4]!, y3 = coords[ci + 5]!;\n      ci += 6;\n      flattenCubic(cx, cy, x1, y1, x2, y2, x3, y3, TOLERANCE, out);\n      cx = x3; cy = y3;\n    } else if (cmd === PATH_Q) {\n      // Elevated to a cubic rather than given its own flattener.\n      const qx = coords[ci]!, qy = coords[ci + 1]!;\n      const x3 = coords[ci + 2]!, y3 = coords[ci + 3]!;\n      ci += 4;\n      flattenCubic(\n        cx, cy,\n        cx + (2 / 3) * (qx - cx), cy + (2 / 3) * (qy - cy),\n        x3 + (2 / 3) * (qx - x3), y3 + (2 / 3) * (qy - y3),\n        x3, y3, TOLERANCE, out,\n      );\n      cx = x3; cy = y3;\n    } else if (cmd === PATH_Z) {\n      out.push(sx, sy);\n      cx = sx; cy = sy;\n    }\n  }\n  // Close it, so a ray leaving through the last edge still finds a crossing.\n  if (out.length >= 2 && (out[0] !== out[out.length - 2] || out[1] !== out[out.length - 1])) {\n    out.push(out[0]!, out[1]!);\n  }\n  return out;\n}\n\n/**\n * Where the ray from `center` through `point` last crosses `poly`, or `null`\n * when it never does.\n *\n * The *last* crossing rather than the first: a concave outline can be crossed\n * more than once, and the far side is the boundary an edge should attach to.\n */\nexport function rayHit(\n  poly: readonly number[],\n  center: { x: number; y: number },\n  point: { x: number; y: number },\n): { x: number; y: number } | null {\n  const dx = point.x - center.x;\n  const dy = point.y - center.y;\n  if (dx === 0 && dy === 0) return null;\n  let bestT = -Infinity;\n  let hit: { x: number; y: number } | null = null;\n  for (let i = 0; i + 3 < poly.length; i += 2) {\n    const ax = poly[i]!, ay = poly[i + 1]!;\n    const bx = poly[i + 2]!, by = poly[i + 3]!;\n    const ex = bx - ax;\n    const ey = by - ay;\n    const denom = dx * ey - dy * ex;\n    if (denom === 0) continue;\n    // t along the ray, u along the segment.\n    const t = ((ax - center.x) * ey - (ay - center.y) * ex) / denom;\n    const u = ((ax - center.x) * dy - (ay - center.y) * dx) / denom;\n    if (t < 0 || u < 0 || u > 1) continue;\n    if (t > bestT) {\n      bestT = t;\n      hit = { x: center.x + dx * t, y: center.y + dy * t };\n    }\n  }\n  return hit;\n}\n\n/**\n * Every port moved onto `outline`. A port the ray misses — one at the node's\n * dead center, with no direction to cast along — is left where it was.\n */\nexport function portsOnOutline(\n  ports: readonly Port[],\n  outline: Outline,\n  bounds: Bounds,\n): Port[] {\n  if (bounds.width <= 0 || bounds.height <= 0) return [...ports];\n  const poly = outlinePolyline(outline, bounds);\n  const center = { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };\n  return ports.map((port) => {\n    const hit = rayHit(poly, center, port.point);\n    return hit === null ? port : { ...port, point: hit };\n  });\n}\n","/**\n * Reading the `DiagramNode` trait off a scene node.\n *\n * Two ways to attach it, both of which this module's default reader answers:\n *\n *   - **On the node.** `data.diagram` holds the trait. One node, one answer;\n *     what a connect gesture writes when the author drags a new edge.\n *   - **By kind.** A consumer declares once which data shapes take part, and\n *     every matching node gets the trait without being stamped. This mirrors\n *     `createNodeRouting` in the kit — a predicate over `data`, first match\n *     wins — and is the shape to reach for when the participants are a class\n *     of node rather than a hand-picked set.\n *\n * A reader is a plain function, so a consumer whose data lives somewhere else\n * entirely passes their own and never touches either form.\n */\nimport type { DiagramNode } from './types';\n\n/** The key on a node's `data` the default reader looks under. */\nexport const DIAGRAM_TRAIT_KEY = 'diagram';\n\n/** All a reader looks at. Deliberately not `SceneNode`: naming `TPose` there\n *  would put it in a contravariant position for no gain, since nothing here\n *  reads a pose. */\nexport interface DiagramNodeLike {\n  id: string;\n  kind: 'leaf' | 'container';\n  data: unknown;\n}\n\n/** Answers \"is this node a diagram participant, and on what terms\" — `null`\n *  for a node that takes no part. */\nexport type DiagramNodeReader = (node: DiagramNodeLike) => DiagramNode | null;\n\n/** One class of participant, declared once for every node whose data matches.\n *  Mirrors `NodeRoutingEntry`. */\nexport interface DiagramNodeEntry {\n  /** Unique within a reader; the same vocabulary as `NodeRoutingEntry.name`. */\n  name: string;\n  matches: (data: unknown) => boolean;\n  /** The trait every matching node carries. A function when it varies with the\n   *  node's own data — a pipeline stage whose ports come from its rows. */\n  trait: DiagramNode | ((data: unknown) => DiagramNode);\n}\n\n/** The trait on the node's own `data.diagram`, or `null`.\n *\n *  An edge's trait lives under the same key, so `from` and `to` are what tells\n *  the two apart. Without that test an edge reads as a participant declaring\n *  no ports, and collects the four defaults on the degenerate pose an edge\n *  carries — four grabbable ports in the middle of nowhere. */\nexport const dataKeyReader: DiagramNodeReader = (node) => {\n  const data = node.data;\n  if (data === null || typeof data !== 'object') return null;\n  const trait = (data as Record<string, unknown>)[DIAGRAM_TRAIT_KEY];\n  if (trait === null || typeof trait !== 'object') return null;\n  if ('from' in trait && 'to' in trait) return null;\n  return trait as DiagramNode;\n};\n\n/**\n * A reader over declared kinds. A trait on the node's own data still wins, so\n * a single node can opt out of, or override, whatever its kind says.\n *\n * Throws on a duplicate `name`, for the reason `mergeContributions` does: a\n * class of node silently losing its ports is what this registry exists to make\n * loud.\n */\nexport function createDiagramNodes(entries: readonly DiagramNodeEntry[]): DiagramNodeReader {\n  const seen = new Set<string>();\n  for (const entry of entries) {\n    if (seen.has(entry.name)) {\n      throw new Error(`createDiagramNodes: duplicate entry name \"${entry.name}\"`);\n    }\n    seen.add(entry.name);\n  }\n  return (node) => {\n    const own = dataKeyReader(node);\n    if (own !== null) return own;\n    for (const entry of entries) {\n      if (!entry.matches(node.data)) continue;\n      return typeof entry.trait === 'function' ? entry.trait(node.data) : entry.trait;\n    }\n    return null;\n  };\n}\n\n/** The trait `node` carries, through `read` (default: its own `data.diagram`). */\nexport function diagramNodeOf(\n  node: DiagramNodeLike,\n  read: DiagramNodeReader = dataKeyReader,\n): DiagramNode | null {\n  return read(node);\n}\n\n/** True when layout must leave this node where it is. */\nexport function isPinned(node: DiagramNodeLike, read?: DiagramNodeReader): boolean {\n  return diagramNodeOf(node, read)?.pinned === true;\n}\n","/**\n * Where a node's ports are, in world coordinates.\n *\n * A port is placed in the node's **unrotated** bounds, then carried through\n * the pose's rotation — the same pivot every other kit reader uses, the AABB\n * center. Bounds come from the pose descriptor rather than from `pose.width`\n * and friends, so a node whose pose is a path, an ellipse or anything else a\n * consumer wired is connectable on the same terms as a rect.\n */\nimport {\n  AUTO_POSE_DESCRIPTOR,\n  rotatePoint,\n  type PoseDescriptor,\n  type Vec2,\n} from '@weasel-js/core/math';\nimport { outlinePolyline, rayHit } from './onOutline';\nimport { diagramNodeOf, type DiagramNodeLike, type DiagramNodeReader } from './trait';\nimport type { Port, PortAnchor, PortSpec } from './types';\n\n/** The eight anchors almost everything wants, named the way a compass is. */\nexport const COMPASS = {\n  nw: { u: 0, v: 0 },\n  n: { u: 0.5, v: 0 },\n  ne: { u: 1, v: 0 },\n  e: { u: 1, v: 0.5 },\n  se: { u: 1, v: 1 },\n  s: { u: 0.5, v: 1 },\n  sw: { u: 0, v: 1 },\n  w: { u: 0, v: 0.5 },\n} as const satisfies Record<string, PortAnchor>;\n\n/**\n * What a node carrying no `ports` gets: the four edge midpoints of its own\n * bounds. Every node has bounds, so every node is connectable without saying\n * anything.\n */\nexport const DEFAULT_PORTS: readonly PortSpec[] = Object.freeze([\n  { id: 'n', at: COMPASS.n },\n  { id: 'e', at: COMPASS.e },\n  { id: 's', at: COMPASS.s },\n  { id: 'w', at: COMPASS.w },\n]);\n\n/** How ports are resolved against a node: its bounds, and its trait. */\nexport interface PortsOptions<TPose> {\n  /** Reads the AABB a port is placed in, and the node's rotation. Defaults to\n   *  the kit's `AUTO_POSE_DESCRIPTOR`, which handles rect and path poses. */\n  geometry?: PoseDescriptor<TPose>;\n  /** How the `DiagramNode` trait is read off a node. */\n  read?: DiagramNodeReader;\n}\n\n/**\n * The direction the anchor implies: away from the center of the bounds.\n *\n * `(2u-1, 2v-1)` is the anchor in a box that runs -1..1, which is exactly that\n * direction — an edge midpoint gets the axis-aligned normal, a corner gets the\n * diagonal. It is deliberately not scaled by the node's aspect: this is a\n * heading a router leaves along, not a point on the outline. A port at the\n * dead center has no direction, and says so.\n */\nfunction normalOf(at: PortAnchor): Vec2 | null {\n  const x = at.u * 2 - 1;\n  const y = at.v * 2 - 1;\n  const len = Math.hypot(x, y);\n  if (len === 0) return null;\n  return { x: x / len, y: y / len };\n}\n\n/**\n * Every port on `node`, resolved against `pose`.\n *\n * Pass the pose the node is **painted** at — `effectivePose(scene, node)` —\n * not `node.pose`. A port that answers from the document pose while the node\n * is mid-drag puts an edge somewhere the user can see the node is not.\n */\nexport function portsOf<TPose>(\n  node: DiagramNodeLike,\n  pose: TPose,\n  opts: PortsOptions<TPose> = {},\n): Port[] {\n  const trait = diagramNodeOf(node, opts.read);\n  if (trait === null) return [];\n  const geometry = opts.geometry ?? (AUTO_POSE_DESCRIPTOR as PoseDescriptor<TPose>);\n  const bounds = geometry.getBounds(pose);\n  const rotation = geometry.getRotation?.(pose) ?? 0;\n  const cx = bounds.x + bounds.width / 2;\n  const cy = bounds.y + bounds.height / 2;\n  // A port is anchored in the bounds so it survives a resize, but it has to\n  // *sit* on the shape: a parallelogram's west anchor is in the gap beside its\n  // leaning edge, and an edge ending there ends in empty space. Flattened once\n  // per call, not once per port.\n  const poly = trait.outline === undefined || bounds.width <= 0 || bounds.height <= 0\n    ? null\n    : outlinePolyline(trait.outline, bounds);\n\n  return (trait.ports ?? DEFAULT_PORTS).map((spec) => {\n    const anchored: Vec2 = {\n      x: bounds.x + spec.at.u * bounds.width,\n      y: bounds.y + spec.at.v * bounds.height,\n    };\n    const flat = (poly === null ? null : rayHit(poly, { x: cx, y: cy }, anchored)) ?? anchored;\n    const normal = spec.normal === undefined ? normalOf(spec.at) : spec.normal;\n    if (rotation === 0) {\n      return { id: spec.id, nodeId: node.id, point: flat, normal, ...typeOf(spec) };\n    }\n    return {\n      id: spec.id,\n      nodeId: node.id,\n      point: rotatePoint(flat.x, flat.y, cx, cy, rotation),\n      // A direction rotates about the origin, not about the node's center.\n      normal: normal === null ? null : rotatePoint(normal.x, normal.y, 0, 0, rotation),\n      ...typeOf(spec),\n    };\n  });\n}\n\n/** One named port, or `undefined` when the node has no such port. */\nexport function portOf<TPose>(\n  node: DiagramNodeLike,\n  pose: TPose,\n  portId: string,\n  opts: PortsOptions<TPose> = {},\n): Port | undefined {\n  return portsOf(node, pose, opts).find((p) => p.id === portId);\n}\n\n/** Spread rather than assigned, so a port with no type has no `type` key at\n *  all — `exactOptionalPropertyTypes` rejects an explicit `undefined`. */\nfunction typeOf(spec: PortSpec): { type?: string } {\n  return spec.type === undefined ? {} : { type: spec.type };\n}\n","/**\n * The optional body builder: what a node looks like when it should read as a\n * flowchart box or a visual-programming operator, rather than as whatever\n * scene node it already was.\n *\n * **The body measures a floor; the author sets the rest.** Rows measure to a\n * `{ minWidth, minHeight }` and the node's pose is the max of that and what\n * the author gave it. Adding a port row can grow a node; nothing here ever\n * shrinks one back. Because the pose stays authored data, resize, align,\n * distribute, guides, snapping and undo need no special case, and a node that\n * did not come from the builder just has whatever size it already had.\n *\n * Text measurement is a seam rather than an import: measuring needs a 2D\n * context, which a geometry module has no business owning. `canvasMeasure`\n * adapts the kit's own `measureText` for a caller that has one.\n */\nimport { boxForContent, contentBox, outlinePath, type Bounds, type Outline } from './outline';\nimport { COMPASS } from './ports';\nimport type { DiagramNode, PortSpec } from './types';\n\n/** One line of body content. */\nexport type Row =\n  /** Text. `label` is the node's name; `field` is a named value. */\n  | { kind: 'label'; text: string; style?: RowTextStyle }\n  | { kind: 'field'; label: string; value: string; style?: RowTextStyle }\n  /** A row that carries ports on its own left and right edges — the\n   *  visual-programming shape, where an operator's inputs line up with the\n   *  rows they feed. */\n  | { kind: 'ports'; left?: readonly RowPort[]; right?: readonly RowPort[]; height?: number }\n  /** Reserved space a consumer paints into. */\n  | { kind: 'slot'; height: number; id?: string };\n\n/** A port declared on a row rather than on the node's perimeter. */\nexport interface RowPort {\n  id: string;\n  /** Label shown beside it, and what the row measures against. */\n  label?: string;\n  type?: string;\n}\n\n/** The subset of a text style the body measures against. Deliberately small:\n *  a full `ResolvedTextStyle` belongs to whatever paints the row. */\nexport interface RowTextStyle {\n  fontSize?: number;\n  fontFamily?: string;\n  bold?: boolean;\n}\n\n/** Measures one run of text. Returns its advance width and its line height. */\nexport type MeasureRowText = (text: string, style: RowTextStyle) => { width: number; height: number };\n\n/** A body's content: the outline it draws and the rows stacked inside it. */\nexport interface BodySpec {\n  outline: Outline;\n  rows: readonly Row[];\n  /** Space between the outline and its rows. Default 8. */\n  padding?: number;\n  /** Space between adjacent rows. Default 4. */\n  gap?: number;\n}\n\n/** What {@link buildBody} emits: the `AddNodeSpec` fields it fills in. Named\n *  structurally rather than imported so a consumer whose scene is typed\n *  differently can still spread one. */\nexport interface BodyNodeSpec<TData, TLayer extends string, TPose> {\n  kind: 'container' | 'leaf';\n  layer: TLayer;\n  pose: TPose;\n  data: TData;\n  id?: string;\n  parent?: string;\n  /** Set `false` on every leaf the builder emits: the innermost hit wins, so a\n   *  row that answers a press is a body that cannot be dragged. */\n  pickable?: boolean;\n}\n\n/** The floor a body's content puts under its node's size. */\nexport interface BodyFloor {\n  minWidth: number;\n  minHeight: number;\n}\n\n/** Where one row landed, in the same frame as the bounds it was laid out in.\n *  A `ports` row's own ports anchor to this box. */\nexport interface RowBox extends Bounds {\n  row: Row;\n  index: number;\n}\n\n/** Where one row port's label sits, in the same frame as the row box it was\n *  laid out in. Its vertical center is also where the port itself attaches, so\n *  a label and the port it names cannot drift apart. */\nexport interface RowPortBox extends Bounds {\n  port: RowPort;\n  side: 'left' | 'right';\n  /** Position within its own side, top to bottom. */\n  index: number;\n}\n\nconst DEFAULT_PADDING = 8;\nconst DEFAULT_GAP = 4;\n/** What a row is worth when nothing measures its text. Enough that a body\n *  laid out headlessly is not zero-height — a zero-height body renders as an\n *  empty page with every unit test still green. */\nconst FALLBACK_LINE = 16;\n\n/** Adapts the kit's `measureText` for a caller holding a 2D context. Pass the\n *  same context the renderer measures with, or the floor will not match what\n *  is painted. */\nexport function canvasMeasure(\n  ctx: { measureText(text: string): { width: number } ; font: string },\n): MeasureRowText {\n  return (text, style) => {\n    const size = style.fontSize ?? FALLBACK_LINE;\n    ctx.font = `${style.bold === true ? 'bold ' : ''}${size}px ${style.fontFamily ?? 'sans-serif'}`;\n    return { width: ctx.measureText(text).width, height: Math.ceil(size * 1.2) };\n  };\n}\n\n/** What each row is worth on its own, before padding and gaps. */\nfunction measureRow(row: Row, measure: MeasureRowText | undefined): { width: number; height: number } {\n  const text = (s: string, style?: RowTextStyle): { width: number; height: number } =>\n    measure === undefined\n      ? { width: s.length * (((style?.fontSize ?? FALLBACK_LINE) * 0.6)), height: FALLBACK_LINE }\n      : measure(s, style ?? {});\n\n  switch (row.kind) {\n    case 'label':\n      return text(row.text, row.style);\n    case 'field': {\n      // Label and value sit on one line with a gap between them.\n      const l = text(row.label, row.style);\n      const v = text(row.value, row.style);\n      return { width: l.width + DEFAULT_GAP * 2 + v.width, height: Math.max(l.height, v.height) };\n    }\n    case 'ports': {\n      const side = (ports: readonly RowPort[] | undefined): number =>\n        (ports ?? []).reduce((w, p) => Math.max(w, p.label === undefined ? 0 : text(p.label).width), 0);\n      const rows = Math.max(row.left?.length ?? 0, row.right?.length ?? 0, 1);\n      return {\n        width: side(row.left) + DEFAULT_GAP * 2 + side(row.right),\n        height: row.height ?? rows * FALLBACK_LINE,\n      };\n    }\n    case 'slot':\n      return { width: 0, height: row.height };\n  }\n}\n\n/**\n * The smallest box `spec`'s rows fit in. A node's pose is maxed against this,\n * never set to it.\n */\nexport function measureBody(spec: BodySpec, measure?: MeasureRowText): BodyFloor {\n  const padding = spec.padding ?? DEFAULT_PADDING;\n  const gap = spec.gap ?? DEFAULT_GAP;\n  let width = 0;\n  let height = 0;\n  for (const [i, row] of spec.rows.entries()) {\n    const m = measureRow(row, measure);\n    width = Math.max(width, m.width);\n    height += m.height + (i > 0 ? gap : 0);\n  }\n  // The rows fit the *content* box; the node's own box has to be whatever\n  // contains that, or a diamond's label lands outside the diamond.\n  const box = boxForContent(spec.outline, {\n    width: width + padding * 2,\n    height: height + padding * 2,\n  });\n  return { minWidth: box.width, minHeight: box.height };\n}\n\n/**\n * The authored size, grown to fit the body. Never shrinks: a row removed\n * leaves the node the size the author last saw it at, which is the only\n * behavior that survives a resize the author did on purpose.\n */\nexport function sizeToBody<TPose extends Bounds>(pose: TPose, floor: BodyFloor): TPose {\n  const width = Math.max(pose.width, floor.minWidth);\n  const height = Math.max(pose.height, floor.minHeight);\n  if (width === pose.width && height === pose.height) return pose;\n  return { ...pose, width, height };\n}\n\n/** Where each row sits inside `bounds`, top to bottom. Rows keep their\n *  measured heights; the leftover goes unclaimed at the bottom rather than\n *  being distributed, so a row does not move when a sibling grows. */\nexport function layoutBody(\n  spec: BodySpec,\n  bounds: Bounds,\n  measure?: MeasureRowText,\n): RowBox[] {\n  const padding = spec.padding ?? DEFAULT_PADDING;\n  const gap = spec.gap ?? DEFAULT_GAP;\n  const inner = contentBox(spec.outline, bounds);\n  const width = Math.max(inner.width - padding * 2, 0);\n  let y = inner.y + padding;\n  return spec.rows.map((row, index) => {\n    const h = measureRow(row, measure).height;\n    const box: RowBox = { row, index, x: inner.x + padding, y, width, height: h };\n    y += h + gap;\n    return box;\n  });\n}\n\n/**\n * Where each of a `ports` row's ports goes inside `box`, on the same terms\n * `layoutBody` gives one box per row.\n *\n * Both sides are cut into the same number of slots — the longer side's count —\n * so the nth input faces the nth output whichever side has more. A label box\n * is as wide as its own text and pinned to its own edge of the row; an\n * unlabeled port gets a zero-width box there, which is still where it attaches.\n */\nexport function layoutRowPorts(\n  row: Extract<Row, { kind: 'ports' }>,\n  box: Bounds,\n  measure?: MeasureRowText,\n): RowPortBox[] {\n  const width = (label: string | undefined): number =>\n    label === undefined ? 0 : measureRow({ kind: 'label', text: label }, measure).width;\n  const slots = Math.max(row.left?.length ?? 0, row.right?.length ?? 0, 1);\n  const slotHeight = box.height / slots;\n  const out: RowPortBox[] = [];\n  const side = (ports: readonly RowPort[] | undefined, which: 'left' | 'right'): void => {\n    for (const [index, port] of (ports ?? []).entries()) {\n      const w = width(port.label);\n      out.push({\n        port,\n        side: which,\n        index,\n        x: which === 'left' ? box.x : box.x + box.width - w,\n        y: box.y + index * slotHeight,\n        width: w,\n        height: slotHeight,\n      });\n    }\n  };\n  side(row.left, 'left');\n  side(row.right, 'right');\n  return out;\n}\n\n/**\n * The `DiagramNode` trait a built body implies: perimeter ports for the\n * outline, plus one port per `ports`-row entry, anchored to that row's own\n * left or right edge.\n *\n * Anchors are normalized against `bounds`, so they survive the node being\n * resized — which is the whole reason `PortAnchor` is normalized.\n *\n * **A row port on a side takes that side's compass default with it.** Both sit\n * on the same edge, and a row near the vertical middle puts one exactly on top\n * of `w` or `e` — where the later region wins the hit and the other is\n * grabbable nowhere. A body that declares where its inputs attach has said what\n * that side is for.\n */\nexport function bodyTrait(spec: BodySpec, bounds: Bounds, measure?: MeasureRowText): DiagramNode {\n  const outline = spec.outline;\n  const compass: PortSpec[] = [\n    { id: 'n', at: COMPASS.n },\n    { id: 'e', at: COMPASS.e },\n    { id: 's', at: COMPASS.s },\n    { id: 'w', at: COMPASS.w },\n  ];\n  if (bounds.height <= 0) return { outline, ports: compass };\n\n  const rowPorts: PortSpec[] = [];\n  let hasLeft = false;\n  let hasRight = false;\n  for (const box of layoutBody(spec, bounds, measure)) {\n    if (box.row.kind !== 'ports') continue;\n    for (const pb of layoutRowPorts(box.row, box, measure)) {\n      if (pb.side === 'left') hasLeft = true;\n      else hasRight = true;\n      const v = (pb.y + pb.height / 2 - bounds.y) / bounds.height;\n      rowPorts.push(withType(\n        { id: pb.port.id, at: { u: pb.side === 'left' ? 0 : 1, v } },\n        pb.port.type,\n      ));\n    }\n  }\n  const kept = compass.filter((p) =>\n    !(p.id === 'w' && hasLeft) && !(p.id === 'e' && hasRight));\n  return { outline, ports: [...kept, ...rowPorts] };\n}\n\nfunction withType(spec: PortSpec, type: string | undefined): PortSpec {\n  return type === undefined ? spec : { ...spec, type };\n}\n\n/** The outline path for a built body at `bounds` — what paints it, and what a\n *  perimeter-hugging port will eventually be placed on. */\nexport function bodyOutline(spec: BodySpec, bounds: Bounds) {\n  return outlinePath(spec.outline, bounds);\n}\n\n/** What a built body's rows are handed to, one call per row.\n *\n *  `text` is the row's content already formatted — a `label`'s own text, or a\n *  `field`'s `\"label: value\"` — so the common case needs no discrimination.\n *  Return `null` for a row the consumer paints itself; `ports` and `slot` rows\n *  arrive with `text` empty and are the usual ones to decline. */\nexport type RowNodeData<TData> = (text: string, box: RowBox) => TData | null;\n\n/** Options for {@link buildBody}: the layer and data of each node it emits.\n *  Without `measure`, rows are sized from a fallback line height rather than\n *  their text. */\nexport interface BuildBodyOptions<TData, TLayer extends string, TPose extends Bounds> {\n  layer: TLayer;\n  /** The container's id. Edges name it, so pass one for anything an edge or a\n   *  layout `pin` will refer to. */\n  id?: string;\n  measure?: MeasureRowText;\n  /** The container's own data, given the trait the builder computed and the\n   *  pose it was computed against. */\n  body: (trait: DiagramNode, pose: TPose) => TData;\n  /** One row's data, or `null` to leave that row undrawn. */\n  row: RowNodeData<TData>;\n  /** One row port's label, or `null` to leave it undrawn. Ports with no\n   *  `label` are never offered. Omit to draw none — a body whose ports are\n   *  named only for the width they claim needs nothing here. */\n  portLabel?: (text: string, box: RowPortBox) => TData | null;\n}\n\n/**\n * The scene nodes a built body is: one container carrying the trait, and one\n * leaf per row that wants drawing.\n *\n * Rows are ordinary scene nodes rather than something this package paints, so\n * the kit's own text painter draws them and text editing, styling and\n * selection work on them unchanged. The walk that places them is\n * `layoutBody` — the same one `bodyTrait` anchors its row ports against, which\n * is why a label and its ports cannot drift apart.\n *\n * The pose is `sizeToBody(at, measureBody(spec))`: the body measures a floor\n * and the authored size is grown to clear it, never shrunk.\n */\nexport function buildBody<TData, TLayer extends string, TPose extends Bounds>(\n  spec: BodySpec,\n  at: TPose,\n  opts: BuildBodyOptions<TData, TLayer, TPose>,\n): { pose: TPose; specs: BodyNodeSpec<TData, TLayer, TPose>[] } {\n  const pose = sizeToBody(at, measureBody(spec, opts.measure));\n  const specs: BodyNodeSpec<TData, TLayer, TPose>[] = [{\n    kind: 'container',\n    layer: opts.layer,\n    pose,\n    data: opts.body(bodyTrait(spec, pose, opts.measure), pose),\n    ...(opts.id === undefined ? {} : { id: opts.id }),\n  }];\n\n  const leaf = (box: Bounds, data: TData): void => {\n    specs.push({\n      kind: 'leaf',\n      layer: opts.layer,\n      pose: { ...pose, x: box.x, y: box.y, width: box.width, height: box.height },\n      data,\n      pickable: false,\n      ...(opts.id === undefined ? {} : { parent: opts.id }),\n    });\n  };\n\n  const portLabel = opts.portLabel;\n  for (const box of layoutBody(spec, pose, opts.measure)) {\n    const data = opts.row(rowText(box.row), box);\n    if (data !== null) leaf(box, data);\n    if (portLabel === undefined || box.row.kind !== 'ports') continue;\n    for (const pb of layoutRowPorts(box.row, box, opts.measure)) {\n      if (pb.port.label === undefined) continue;\n      const labelData = portLabel(pb.port.label, pb);\n      if (labelData !== null) leaf(pb, labelData);\n    }\n  }\n  return { pose, specs };\n}\n\n/** A row's content as one string: empty for a row that carries no text. */\nfunction rowText(row: Row): string {\n  if (row.kind === 'label') return row.text;\n  if (row.kind === 'field') return `${row.label}: ${row.value}`;\n  return '';\n}\n","/**\n * Layout: where the participants go.\n *\n * A layout is a pure function of the graph — no scene, no ops, no history. It\n * hands back the new top-left for every node that **moves**, and a node already\n * standing where the layout wants it is simply absent from the answer. That is\n * what makes re-running a layout free rather than destructive, and it is the\n * property the idempotence test asserts.\n *\n * Three rules keep re-layout non-destructive, and all three live here rather\n * than in each algorithm:\n *\n *   - **No RNG anywhere.** Every tiebreak falls back to the graph's own node\n *     order, which is the source's order — render order, for a scene.\n *   - **Within-rank order is seeded from where the nodes already are**, read\n *     off the cross axis, rather than from crossing-minimization. An author who\n *     dragged two boxes into an order gets that order back.\n *   - **A pin set nothing moves.** Pinned nodes are never in the result, and\n *     the rest of the layout is translated to sit around them.\n *\n * `layered` and `tree` are idempotent by construction: the second run reads the\n * order the first run produced and computes the same slots. `force` is an\n * iterative relaxation and makes no such claim — re-running it keeps relaxing.\n */\nimport type { Vec2 } from '@weasel-js/core/math';\nimport type { Graph, GraphNode } from './graph';\nimport type { Bounds } from './outline';\n\n/** Which way the ranks stack. `force` ignores it. */\nexport type LayoutDirection = 'down' | 'up' | 'right' | 'left';\n\n/** Options every layout takes. */\nexport interface LayoutOptions {\n  /** Default `'down'`. */\n  direction?: LayoutDirection;\n  /** Between neighbors within a rank, in world units. Default 48. */\n  nodeGap?: number;\n  /** Between one rank and the next. Default 96. */\n  rankGap?: number;\n  /** Ids layout must not move, on top of whatever carries `pinned: true`. */\n  pin?: Iterable<string>;\n  /** How far a node has to move to be worth moving, in world units. Default\n   *  `1e-6` — a float-noise floor, not a snapping quantum. Raise it to let a\n   *  `force` pass that has stopped doing anything useful commit nothing. */\n  tolerance?: number;\n}\n\n/** The new top-left for each node that moves. A node that is already there is\n *  absent, so an empty result means \"nothing to do\". */\nexport type LayoutResult = ReadonlyMap<string, Vec2>;\n\n/** Every layout in this package has this shape, and so does a consumer's. */\nexport type LayoutFn = (graph: Graph, opts?: LayoutOptions) => LayoutResult;\n\n/** `LayoutOptions.nodeGap`'s default, in world units. */\nexport const DEFAULT_NODE_GAP = 48;\n/** `LayoutOptions.rankGap`'s default, in world units. */\nexport const DEFAULT_RANK_GAP = 96;\nconst DEFAULT_TOLERANCE = 1e-6;\n\n/** Which world axis carries ranks, which carries within-rank order, and\n *  whether ranks grow toward positive world coordinates. */\nexport interface LayoutAxes {\n  rank: 'x' | 'y';\n  cross: 'x' | 'y';\n  /** `-1` for `'up'` and `'left'`, where the canonical frame is mirrored. */\n  sign: 1 | -1;\n}\n\n/** The axes a direction lays ranks along. Default `'down'`. */\nexport function axesFor(direction: LayoutDirection = 'down'): LayoutAxes {\n  switch (direction) {\n    case 'up':\n      return { rank: 'y', cross: 'x', sign: -1 };\n    case 'right':\n      return { rank: 'x', cross: 'y', sign: 1 };\n    case 'left':\n      return { rank: 'x', cross: 'y', sign: -1 };\n    default:\n      return { rank: 'y', cross: 'x', sign: 1 };\n  }\n}\n\n/** A node's extent along one axis. */\nexport function extent(bounds: Bounds, axis: 'x' | 'y'): number {\n  return axis === 'x' ? bounds.width : bounds.height;\n}\n\n/** A node's center along one axis — what within-rank order is seeded from. */\nexport function center(bounds: Bounds, axis: 'x' | 'y'): number {\n  return axis === 'x' ? bounds.x + bounds.width / 2 : bounds.y + bounds.height / 2;\n}\n\n/** Every id layout must leave alone. */\nexport function pinnedSet(graph: Graph, opts: LayoutOptions = {}): Set<string> {\n  const pinned = new Set<string>(opts.pin ?? []);\n  for (const node of graph.nodes) {\n    if (node.pinned) pinned.add(node.id);\n  }\n  return pinned;\n}\n\n/**\n * A placement in the canonical `(cross, rank)` frame, before it is turned into\n * world coordinates. `cross` and `rank` are the node's low corner along each.\n */\nexport interface Slot {\n  cross: number;\n  rank: number;\n}\n\n/**\n * Turn canonical slots into the positions to write.\n *\n * Three steps, in order: map the canonical frame onto the world axes the\n * direction names; translate the whole layout so it lands where the graph\n * already is; drop everything that is pinned or that would not move.\n *\n * The translation is what makes the layout non-destructive, and it is chosen so\n * that a second run lands on the same answer. With a pin, it is whatever keeps\n * the first pinned node exactly where it is. Without one, it is whatever puts\n * the layout's own bounding box where the graph's bounding box already starts —\n * which the first run then makes true, so the second run computes the same\n * translation and writes nothing.\n */\nexport function settle(\n  graph: Graph,\n  slots: ReadonlyMap<string, Slot>,\n  opts: LayoutOptions = {},\n): LayoutResult {\n  const axes = axesFor(opts.direction);\n  const pinned = pinnedSet(graph, opts);\n  const tolerance = opts.tolerance ?? DEFAULT_TOLERANCE;\n\n  const placed = new Map<string, Vec2>();\n  for (const node of graph.nodes) {\n    const slot = slots.get(node.id);\n    if (slot === undefined) continue;\n    const along = axes.sign === 1 ? slot.rank : -(slot.rank + extent(node.bounds, axes.rank));\n    placed.set(\n      node.id,\n      axes.rank === 'y' ? { x: slot.cross, y: along } : { x: along, y: slot.cross },\n    );\n  }\n\n  return translated(graph, placed, pinned, tolerance);\n}\n\n/**\n * {@link settle}'s second half, for a layout that already works in world\n * coordinates — `force` does, since the integrator moves points around rather\n * than filling slots.\n */\nexport function translated(\n  graph: Graph,\n  placed: ReadonlyMap<string, Vec2>,\n  pinned: ReadonlySet<string>,\n  tolerance = DEFAULT_TOLERANCE,\n): LayoutResult {\n  const anchor = anchorDelta(graph, placed, pinned);\n  const out = new Map<string, Vec2>();\n  for (const node of graph.nodes) {\n    const at = placed.get(node.id);\n    if (at === undefined || pinned.has(node.id)) continue;\n    const x = at.x + anchor.x;\n    const y = at.y + anchor.y;\n    if (Math.abs(x - node.bounds.x) <= tolerance && Math.abs(y - node.bounds.y) <= tolerance) {\n      continue;\n    }\n    out.set(node.id, { x, y });\n  }\n  return out;\n}\n\nfunction anchorDelta(\n  graph: Graph,\n  placed: ReadonlyMap<string, Vec2>,\n  pinned: ReadonlySet<string>,\n): Vec2 {\n  for (const node of graph.nodes) {\n    if (!pinned.has(node.id)) continue;\n    const at = placed.get(node.id);\n    if (at !== undefined) return { x: node.bounds.x - at.x, y: node.bounds.y - at.y };\n  }\n  let minCurX = Infinity;\n  let minCurY = Infinity;\n  let minNewX = Infinity;\n  let minNewY = Infinity;\n  for (const node of graph.nodes) {\n    const at = placed.get(node.id);\n    if (at === undefined) continue;\n    minCurX = Math.min(minCurX, node.bounds.x);\n    minCurY = Math.min(minCurY, node.bounds.y);\n    minNewX = Math.min(minNewX, at.x);\n    minNewY = Math.min(minNewY, at.y);\n  }\n  if (!Number.isFinite(minCurX)) return { x: 0, y: 0 };\n  return { x: minCurX - minNewX, y: minCurY - minNewY };\n}\n\n/**\n * Lay a list of nodes out along the cross axis, in the order given, and hand\n * back each one's low corner plus the total span.\n *\n * Shared by `layered`'s ranks and `tree`'s sibling rows, which pack a row the\n * same way and differ only in what decides the order.\n */\nexport function packAcross(\n  nodes: readonly GraphNode[],\n  axis: 'x' | 'y',\n  gap: number,\n): { at: Map<string, number>; span: number } {\n  const at = new Map<string, number>();\n  let cursor = 0;\n  for (const node of nodes) {\n    at.set(node.id, cursor);\n    cursor += extent(node.bounds, axis) + gap;\n  }\n  return { at, span: nodes.length === 0 ? 0 : cursor - gap };\n}\n\n/** Order within a rank: where the nodes already sit on the cross axis, with\n *  graph order breaking a tie. Never a comparison that could reverse between\n *  two runs on the same input. */\nexport function seededOrder(\n  nodes: readonly GraphNode[],\n  axis: 'x' | 'y',\n  indexOf: (id: string) => number,\n): GraphNode[] {\n  return [...nodes].sort((a, b) => {\n    const d = center(a.bounds, axis) - center(b.bounds, axis);\n    return d !== 0 ? d : indexOf(a.id) - indexOf(b.id);\n  });\n}\n\n/** Each node's position in `graph.nodes`, for tiebreaks. */\nexport function graphOrder(graph: Graph): (id: string) => number {\n  const index = new Map<string, number>();\n  graph.nodes.forEach((node, i) => index.set(node.id, i));\n  return (id) => index.get(id) ?? Number.MAX_SAFE_INTEGER;\n}\n","/**\n * `force` — relaxation, for a graph with no direction to read it in.\n *\n * Seeded from where the nodes already are rather than from a fresh random\n * scatter: an author who has arranged half a diagram gets that arrangement\n * relaxed, not replaced. There is no RNG in it at all — two coincident nodes\n * are separated along a golden-angle spiral keyed to their index, which is what\n * a random jiggle is for elsewhere.\n *\n * The integrator is the kit's own `createSimulation`, the same one\n * `useSimulation` runs a frame at a time. Only the forces are local, and they\n * are the naive O(n²) kind — right for the tens-to-hundreds of nodes an\n * edge-per-scene-node diagram is already sized for, wrong for a 10k-node graph,\n * which wants d3-force's Barnes–Hut through `useSimulation` and its own render\n * layer.\n *\n * **This is the one layout that is not idempotent.** A relaxation re-run from\n * its own output keeps relaxing; `direction` means nothing to it. Pins and the\n * `tolerance` option are what keep a second pass from scrambling a settled\n * diagram.\n */\nimport { createSimulation, type SimulationForce, type SimulationNode } from '@weasel-js/core/math';\nimport type { Graph } from './graph';\nimport {\n  center,\n  pinnedSet,\n  translated,\n  type LayoutFn,\n  type LayoutOptions,\n  type LayoutResult,\n} from './layout';\n\n/** Options for {@link force} and {@link forceRelaxation}. `direction` is\n *  ignored. */\nexport interface ForceOptions extends LayoutOptions {\n  /** Ticks to run. Default 300 — one full cooling schedule. */\n  iterations?: number;\n  /** Rest length of an edge, in world units. Default 160. */\n  linkDistance?: number;\n  /** How hard an edge pulls, 0..1. Default 0.35. */\n  linkStrength?: number;\n  /** Pairwise repulsion. Negative repels; default -3000. */\n  charge?: number;\n  /** How hard the graph is held around its own centroid. Default 0.02. */\n  gravity?: number;\n  /** Clear space kept between two boxes, in world units. Default 24. */\n  padding?: number;\n}\n\n/** One node as the relaxation sees it: a simulation point centered on the\n *  node's box. */\nexport interface ForceBody extends SimulationNode {\n  id: string;\n  /** Half the node's box, so separation can work on the shape the author sees\n   *  rather than on a point. */\n  hw: number;\n  hh: number;\n}\n\nconst DEFAULTS = {\n  iterations: 300,\n  linkDistance: 160,\n  linkStrength: 0.35,\n  charge: -3000,\n  gravity: 0.02,\n  padding: 24,\n} as const;\n\n/** The golden angle. Coincident nodes fan out along it, which spreads any\n *  number of them without two landing on the same heading. */\nconst GOLDEN = Math.PI * (3 - Math.sqrt(5));\n/** How far the first coincident node is pushed, in world units. Small enough\n *  to be invisible, large enough that the repulsion term is finite. */\nconst NUDGE = 0.5;\n\n/** Pairwise repulsion, applied to every pair once. */\nfunction charge(bodies: readonly ForceBody[], strength: number): SimulationForce<ForceBody> {\n  return (alpha) => {\n    for (let i = 0; i < bodies.length; i++) {\n      const a = bodies[i]!;\n      for (let j = i + 1; j < bodies.length; j++) {\n        const b = bodies[j]!;\n        const dx = b.x - a.x;\n        const dy = b.y - a.y;\n        const d2 = dx * dx + dy * dy;\n        if (d2 === 0) continue;\n        const w = (strength * alpha) / d2;\n        a.vx! += dx * w;\n        a.vy! += dy * w;\n        b.vx! -= dx * w;\n        b.vy! -= dy * w;\n      }\n    }\n  };\n}\n\n/** A spring per edge, pulling both ends toward `distance`. */\nfunction links(\n  bodies: ReadonlyMap<string, ForceBody>,\n  graph: Graph,\n  distance: number,\n  strength: number,\n): SimulationForce<ForceBody> {\n  return (alpha) => {\n    for (const edge of graph.edges) {\n      const a = bodies.get(edge.from);\n      const b = bodies.get(edge.to);\n      if (a === undefined || b === undefined || a === b) continue;\n      const dx = b.x - a.x;\n      const dy = b.y - a.y;\n      const d = Math.hypot(dx, dy);\n      if (d === 0) continue;\n      const pull = ((d - distance) / d) * alpha * strength;\n      a.vx! += dx * pull;\n      a.vy! += dy * pull;\n      b.vx! -= dx * pull;\n      b.vy! -= dy * pull;\n    }\n  };\n}\n\n/**\n * Push overlapping boxes apart along whichever axis they overlap least.\n *\n * Charge alone is not enough: it treats a node as a point, so two wide boxes\n * whose centers are a comfortable distance apart still cover each other. This\n * works on the box, and it is not scaled by alpha — an overlap at the end of\n * the run is exactly as wrong as one at the start.\n */\nfunction separateBoxes(bodies: readonly ForceBody[], padding: number): SimulationForce<ForceBody> {\n  return () => {\n    for (let i = 0; i < bodies.length; i++) {\n      const a = bodies[i]!;\n      for (let j = i + 1; j < bodies.length; j++) {\n        const b = bodies[j]!;\n        const dx = b.x - a.x;\n        const dy = b.y - a.y;\n        const gapX = a.hw + b.hw + padding - Math.abs(dx);\n        const gapY = a.hh + b.hh + padding - Math.abs(dy);\n        if (gapX <= 0 || gapY <= 0) continue;\n        if (gapX < gapY) {\n          const push = (Math.sign(dx) || 1) * gapX * 0.5;\n          a.vx! -= push;\n          b.vx! += push;\n        } else {\n          const push = (Math.sign(dy) || 1) * gapY * 0.5;\n          a.vy! -= push;\n          b.vy! += push;\n        }\n      }\n    }\n  };\n}\n\n/** A pull toward the seed centroid, so a component with nothing to hold it\n *  does not drift off under pure repulsion. */\nfunction gravity(bodies: readonly ForceBody[], at: { x: number; y: number }, strength: number): SimulationForce<ForceBody> {\n  return (alpha) => {\n    for (const body of bodies) {\n      body.vx! += (at.x - body.x) * strength * alpha;\n      body.vy! += (at.y - body.y) * strength * alpha;\n    }\n  };\n}\n\n/**\n * The bodies and the force list, wound up and ready to tick.\n *\n * Shared by the one-shot `force` below and the live relaxation in `live.ts`,\n * which ticks it a frame at a time. Two copies of a force list drift, and the\n * only thing that would say so is the arrangement they produce.\n */\nexport interface ForceRelaxation {\n  bodies: ForceBody[];\n  byId: Map<string, ForceBody>;\n  /** Ids the caller must not move: declared pins, held as `fx`/`fy`. */\n  pinned: ReadonlySet<string>;\n  sim: ReturnType<typeof createSimulation<ForceBody>>;\n  /** Where a body's node's top-left sits, given the body's center. */\n  placed(): Map<string, { x: number; y: number }>;\n}\n\n/** Wind up a relaxation of `graph` without ticking it: bodies seeded from\n *  where the nodes are, pins held fixed. Tick `sim` yourself and read the\n *  top-lefts from `placed()`. */\nexport function forceRelaxation(graph: Graph, opts: ForceOptions = {}): ForceRelaxation {\n  const {\n    linkDistance = DEFAULTS.linkDistance,\n    linkStrength = DEFAULTS.linkStrength,\n    charge: chargeStrength = DEFAULTS.charge,\n    gravity: gravityStrength = DEFAULTS.gravity,\n    padding = DEFAULTS.padding,\n  } = opts;\n\n  const pinned = pinnedSet(graph, opts);\n  const bodies: ForceBody[] = graph.nodes.map((node) => {\n    const body: ForceBody = {\n      id: node.id,\n      x: center(node.bounds, 'x'),\n      y: center(node.bounds, 'y'),\n      hw: node.bounds.width / 2,\n      hh: node.bounds.height / 2,\n    };\n    // A pin is the integrator's own `fx`/`fy`, not a filter applied after the\n    // fact: a pinned node has to hold its neighbors while they relax, not be\n    // put back once they have finished relaxing around where it wasn't.\n    if (pinned.has(node.id)) {\n      body.fx = body.x;\n      body.fy = body.y;\n    }\n    return body;\n  });\n  separate(bodies);\n\n  const byId = new Map(bodies.map((b) => [b.id, b]));\n  const centroid = {\n    x: bodies.reduce((sum, b) => sum + b.x, 0) / bodies.length,\n    y: bodies.reduce((sum, b) => sum + b.y, 0) / bodies.length,\n  };\n\n  const sim = createSimulation<ForceBody>({\n    nodes: bodies,\n    forces: [\n      charge(bodies, chargeStrength),\n      links(byId, graph, linkDistance, linkStrength),\n      gravity(bodies, centroid, gravityStrength),\n      separateBoxes(bodies, padding),\n    ],\n  });\n\n  return {\n    bodies,\n    byId,\n    pinned,\n    sim,\n    placed() {\n      const placed = new Map<string, { x: number; y: number }>();\n      for (const node of graph.nodes) {\n        const body = byId.get(node.id)!;\n        placed.set(node.id, {\n          x: body.x - node.bounds.width / 2,\n          y: body.y - node.bounds.height / 2,\n        });\n      }\n      return placed;\n    },\n  };\n}\n\n/** The force-directed layout. Unlike the others it is not idempotent: a\n *  re-run keeps relaxing, so pins and `tolerance` are what hold a settled\n *  diagram still. */\nexport const force = (graph: Graph, opts: ForceOptions = {}): LayoutResult => {\n  if (graph.nodes.length === 0) return new Map();\n  const relaxation = forceRelaxation(graph, opts);\n  relaxation.sim.tick(opts.iterations ?? DEFAULTS.iterations);\n  return translated(graph, relaxation.placed(), relaxation.pinned, opts.tolerance);\n};\n\n/** `ForceOptions` only widens `LayoutOptions`, so this is a `LayoutFn` — but\n *  declaring it as one would hide the extra options from every caller. */\nforce satisfies LayoutFn;\n\n/** Push coincident bodies apart, deterministically. Two nodes at exactly the\n *  same point feel no repulsion from each other and stay stacked forever. A\n *  pinned body is counted but never moved — a pin outranks this. */\nfunction separate(bodies: ForceBody[]): void {\n  const seen = new Map<string, number>();\n  bodies.forEach((body, i) => {\n    const key = `${body.x},${body.y}`;\n    const nth = seen.get(key) ?? 0;\n    seen.set(key, nth + 1);\n    if (nth === 0 || body.fx != null || body.fy != null) return;\n    const angle = GOLDEN * i;\n    const radius = NUDGE * nth;\n    body.x += Math.cos(angle) * radius;\n    body.y += Math.sin(angle) * radius;\n  });\n}\n","/**\n * `layered` — ranks running one way, nodes running across.\n *\n * The flowchart / pipeline layout: an edge points from one rank to the next, so\n * reading down the page is reading the order things happen in. Ranks come from\n * longest-path layering, which puts every node as far along as its deepest\n * predecessor allows.\n *\n * Cycles do not disqualify a graph. A depth-first walk in graph order names the\n * edges that close a cycle, layering ignores those, and they draw as edges\n * running back up the page — which is what a reader expects a loop to look\n * like. Which edges get named depends only on the node order, so it is the same\n * every run.\n *\n * This is not crossing-minimization: within a rank, nodes keep the order they\n * already have on the cross axis. An author who dragged two branches into an\n * order gets that order back, and re-running the layout is free.\n */\nimport type { Graph, GraphNode } from './graph';\nimport {\n  DEFAULT_NODE_GAP,\n  DEFAULT_RANK_GAP,\n  axesFor,\n  extent,\n  graphOrder,\n  packAcross,\n  seededOrder,\n  settle,\n  type LayoutFn,\n  type Slot,\n} from './layout';\n\n/** Edge ids that close a cycle, found by a depth-first walk in graph order. */\nexport function backEdges(graph: Graph): Set<string> {\n  const back = new Set<string>();\n  const done = new Set<string>();\n  const onStack = new Set<string>();\n\n  const walk = (id: string): void => {\n    if (done.has(id)) return;\n    onStack.add(id);\n    for (const edge of graph.outgoing(id)) {\n      if (onStack.has(edge.to)) back.add(edge.id);\n      else walk(edge.to);\n    }\n    onStack.delete(id);\n    done.add(id);\n  };\n\n  for (const node of graph.nodes) walk(node.id);\n  return back;\n}\n\n/** Longest-path rank per node: one past its deepest predecessor. */\nexport function ranksOf(graph: Graph, back: ReadonlySet<string>): Map<string, number> {\n  const ranks = new Map<string, number>();\n  const resolving = new Set<string>();\n\n  const rankOf = (id: string): number => {\n    const known = ranks.get(id);\n    if (known !== undefined) return known;\n    // Only reachable if `back` missed an edge; guarding here keeps a bad\n    // cycle-breaker from recursing forever rather than reporting a wrong rank.\n    if (resolving.has(id)) return 0;\n    resolving.add(id);\n    let rank = 0;\n    for (const edge of graph.incoming(id)) {\n      if (back.has(edge.id)) continue;\n      rank = Math.max(rank, rankOf(edge.from) + 1);\n    }\n    resolving.delete(id);\n    ranks.set(id, rank);\n    return rank;\n  };\n\n  for (const node of graph.nodes) rankOf(node.id);\n  return ranks;\n}\n\n/** The ranked layout: each edge points one rank further along `direction`.\n *  Within a rank, nodes keep their current cross-axis order, so a re-run\n *  moves nothing. */\nexport const layered: LayoutFn = (graph, opts = {}) => {\n  const axes = axesFor(opts.direction);\n  const nodeGap = opts.nodeGap ?? DEFAULT_NODE_GAP;\n  const rankGap = opts.rankGap ?? DEFAULT_RANK_GAP;\n  const order = graphOrder(graph);\n\n  const ranks = ranksOf(graph, backEdges(graph));\n  const byRank = new Map<number, GraphNode[]>();\n  for (const node of graph.nodes) {\n    const rank = ranks.get(node.id) ?? 0;\n    const list = byRank.get(rank);\n    if (list === undefined) byRank.set(rank, [node]);\n    else list.push(node);\n  }\n\n  const rows = [...byRank.keys()].sort((a, b) => a - b);\n  const packed = new Map<number, ReturnType<typeof packAcross>>();\n  let widest = 0;\n  for (const rank of rows) {\n    const row = seededOrder(byRank.get(rank)!, axes.cross, order);\n    const p = packAcross(row, axes.cross, nodeGap);\n    packed.set(rank, p);\n    widest = Math.max(widest, p.span);\n  }\n\n  const slots = new Map<string, Slot>();\n  let along = 0;\n  for (const rank of rows) {\n    const row = byRank.get(rank)!;\n    const p = packed.get(rank)!;\n    const indent = (widest - p.span) / 2;\n    const depth = Math.max(0, ...row.map((n) => extent(n.bounds, axes.rank)));\n    for (const node of row) {\n      slots.set(node.id, {\n        cross: indent + p.at.get(node.id)!,\n        // Centered in its rank's band, so a tall node does not push its\n        // neighbors' edges off the line they read along.\n        rank: along + (depth - extent(node.bounds, axes.rank)) / 2,\n      });\n    }\n    along += depth + rankGap;\n  }\n\n  return settle(graph, slots, opts);\n};\n","/**\n * `tree` — a parent centered over the block its children occupy.\n *\n * The hierarchy layout: org charts, file trees, decision trees. Depth is the\n * rank axis, so every child sits one band past its parent, and a subtree is\n * packed as a solid block so two siblings' descendants never interleave.\n *\n * A graph that is not a tree still lays out. Roots are the nodes nothing points\n * at, in graph order; a node reachable from two parents belongs to whichever\n * the depth-first walk reaches first; and anything the walk never reaches — a\n * disconnected part, or a pure cycle — becomes a root of its own. So the answer\n * is always a forest, and which forest depends only on the node order.\n *\n * The block packing is deliberately not Reingold–Tilford: it never slides a\n * deep subtree under a shallow neighbor's overhang. That costs horizontal\n * space and buys an invariant an author can rely on — a subtree's extent is a\n * rectangle, and dragging one never lands it inside another.\n */\nimport type { Graph, GraphNode } from './graph';\nimport {\n  DEFAULT_NODE_GAP,\n  DEFAULT_RANK_GAP,\n  axesFor,\n  extent,\n  graphOrder,\n  seededOrder,\n  settle,\n  type LayoutFn,\n  type Slot,\n} from './layout';\n\ninterface Forest {\n  roots: GraphNode[];\n  children: Map<string, GraphNode[]>;\n  depth: Map<string, number>;\n}\n\n/** The forest a depth-first walk in graph order finds. Exported because \"which\n *  node ended up whose child\" is the question anyone debugging a tree layout\n *  asks first. */\nexport function forestOf(graph: Graph, crossAxis: 'x' | 'y'): Forest {\n  const order = graphOrder(graph);\n  const children = new Map<string, GraphNode[]>();\n  const depth = new Map<string, number>();\n  const roots: GraphNode[] = [];\n\n  const claim = (node: GraphNode, at: number): void => {\n    depth.set(node.id, at);\n    const kids: GraphNode[] = [];\n    for (const edge of graph.outgoing(node.id)) {\n      if (edge.to === node.id || depth.has(edge.to)) continue;\n      const child = graph.node(edge.to);\n      if (child === undefined) continue;\n      // Claimed on sight rather than inside the recursion, so two siblings\n      // sharing a descendant cannot both take it.\n      depth.set(child.id, at + 1);\n      kids.push(child);\n    }\n    const ordered = seededOrder(kids, crossAxis, order);\n    children.set(node.id, ordered);\n    for (const child of ordered) claim(child, at + 1);\n  };\n\n  const rootish = graph.nodes.filter((node) =>\n    graph.incoming(node.id).every((edge) => edge.from === node.id));\n  for (const node of seededOrder(rootish, crossAxis, order)) {\n    if (depth.has(node.id)) continue;\n    roots.push(node);\n    claim(node, 0);\n  }\n  // Whatever the walk could not reach: a disconnected part, or a component\n  // every node of which is inside a cycle.\n  for (const node of graph.nodes) {\n    if (depth.has(node.id)) continue;\n    roots.push(node);\n    claim(node, 0);\n  }\n\n  return { roots, children, depth };\n}\n\n/** The hierarchy layout: each parent centered over its children's block, one\n *  rank per depth. A graph that is not a tree lays out as the forest\n *  {@link forestOf} reads from it. */\nexport const tree: LayoutFn = (graph, opts = {}) => {\n  const axes = axesFor(opts.direction);\n  const nodeGap = opts.nodeGap ?? DEFAULT_NODE_GAP;\n  const rankGap = opts.rankGap ?? DEFAULT_RANK_GAP;\n  const { roots, children, depth } = forestOf(graph, axes.cross);\n\n  const bands = new Map<number, number>();\n  for (const node of graph.nodes) {\n    const at = depth.get(node.id) ?? 0;\n    bands.set(at, Math.max(bands.get(at) ?? 0, extent(node.bounds, axes.rank)));\n  }\n  const bandStart = new Map<number, number>();\n  let along = 0;\n  for (const at of [...bands.keys()].sort((a, b) => a - b)) {\n    bandStart.set(at, along);\n    along += bands.get(at)! + rankGap;\n  }\n\n  const slots = new Map<string, Slot>();\n\n  /** How wide `node`'s whole subtree is on the cross axis: its children's\n   *  blocks side by side, or the node itself when that is wider. */\n  const measured = new Map<string, number>();\n  const measure = (node: GraphNode): number => {\n    const known = measured.get(node.id);\n    if (known !== undefined) return known;\n    const kids = children.get(node.id) ?? [];\n    let width = 0;\n    for (const child of kids) width += measure(child);\n    if (kids.length > 0) width += nodeGap * (kids.length - 1);\n    const block = Math.max(extent(node.bounds, axes.cross), width);\n    measured.set(node.id, block);\n    return block;\n  };\n\n  /** Place `node`'s subtree with its block starting at `from`. */\n  const place = (node: GraphNode, from: number): void => {\n    const kids = children.get(node.id) ?? [];\n    const block = measure(node);\n    const width = kids.reduce((sum, k) => sum + measure(k), 0)\n      + Math.max(0, kids.length - 1) * nodeGap;\n\n    let cursor = from + (block - width) / 2;\n    for (const child of kids) {\n      place(child, cursor);\n      cursor += measure(child) + nodeGap;\n    }\n\n    const own = extent(node.bounds, axes.cross);\n    const at = depth.get(node.id) ?? 0;\n    slots.set(node.id, {\n      cross: from + (block - own) / 2,\n      rank: bandStart.get(at)! + (bands.get(at)! - extent(node.bounds, axes.rank)) / 2,\n    });\n  };\n\n  let cursor = 0;\n  for (const root of roots) {\n    place(root, cursor);\n    cursor += measure(root) + nodeGap;\n  }\n\n  return settle(graph, slots, opts);\n};\n"]}

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-import { P as Port, a as PortsOptions, D as DiagramNodeLike, b as DiagramNodeReader, L as LayoutFn, c as LayoutOptions, F as ForceOptions, d as LayoutResult, G as GraphSource, e as Graph } from './layout.entry-C0twMfuH.js';
-export { B as BodyFloor, f as BodyNodeSpec, g as BodySpec, h as Bounds, i as BuildBodyOptions, j as BuildGraphOptions, C as COMPASS, k as DEFAULT_NODE_GAP, l as DEFAULT_PORTS, m as DEFAULT_RANK_GAP, n as DIAGRAM_TRAIT_KEY, o as DiagramNode, p as DiagramNodeEntry, q as ForceRelaxation, r as GraphEdge, s as GraphNode, t as GraphNodeLike, u as LayoutAxes, v as LayoutDirection, M as MeasureRowText, O as Outline, w as PortAnchor, x as PortSpec, R as Row, y as RowBox, z as RowNodeData, A as RowPort, E as RowPortBox, H as RowTextStyle, S as Slot, I as axesFor, J as backEdges, K as bodyOutline, N as bodyTrait, Q as boxForContent, T as buildBody, U as buildGraph, V as canvasMeasure, W as contentBox, X as createDiagramNodes, Y as dataKeyReader, Z as diagramNodeOf, _ as force, $ as forceRelaxation, a0 as forestOf, a1 as graphOrder, a2 as isPinned, a3 as layered, a4 as layoutBody, a5 as layoutRowPorts, a6 as measureBody, a7 as outlinePath, a8 as outlinePolyline, a9 as packAcross, aa as pinnedSet, ab as portOf, ac as portsOf, ad as portsOnOutline, ae as ranksOf, af as rayHit, ag as seededOrder, ah as settle, ai as sizeToBody, aj as translated, ak as tree } from './layout.entry-C0twMfuH.js';
+import { P as Port, a as PortsOptions, D as DiagramNodeLike, b as DiagramNodeReader, L as LayoutFn, c as LayoutOptions, F as ForceOptions, d as LayoutResult, G as GraphSource, e as Graph } from './layout.entry-BvR06k9j.js';
+export { B as BodyFloor, f as BodyNodeSpec, g as BodySpec, h as Bounds, i as BuildBodyOptions, j as BuildGraphOptions, C as COMPASS, k as DEFAULT_NODE_GAP, l as DEFAULT_PORTS, m as DEFAULT_RANK_GAP, n as DIAGRAM_TRAIT_KEY, o as DiagramNode, p as DiagramNodeEntry, q as ForceBody, r as ForceRelaxation, s as GraphEdge, t as GraphNode, u as GraphNodeLike, v as LayoutAxes, w as LayoutDirection, M as MeasureRowText, O as Outline, x as PortAnchor, y as PortSpec, R as Row, z as RowBox, A as RowNodeData, E as RowPort, H as RowPortBox, I as RowTextStyle, S as Slot, J as axesFor, K as backEdges, N as bodyOutline, Q as bodyTrait, T as boxForContent, U as buildBody, V as buildGraph, W as canvasMeasure, X as contentBox, Y as createDiagramNodes, Z as dataKeyReader, _ as diagramNodeOf, $ as force, a0 as forceRelaxation, a1 as forestOf, a2 as graphOrder, a3 as isPinned, a4 as layered, a5 as layoutBody, a6 as layoutRowPorts, a7 as measureBody, a8 as outlinePath, a9 as outlinePolyline, aa as packAcross, ab as pinnedSet, ac as portOf, ad as portsOf, ae as portsOnOutline, af as ranksOf, ag as rayHit, ah as seededOrder, ai as settle, aj as sizeToBody, ak as translated, al as tree } from './layout.entry-BvR06k9j.js';
 import { Vec2, DerivedDep, Path, SceneRegistry, PoseDescriptor, ChromeState, FillStyle, Stroke, CursorSpec, Affordance, InvocationCtx, GestureBinding, Action, Contribution, RenderLayer, EasingFn, NodeId, Scene, NodeShapeEntry } from '@weasel-js/core';
+import '@weasel-js/geom';
 import '@weasel-js/core/math';
 
 /**
@@ -95,6 +96,7 @@ declare function diagramEdgeOf(node: {
  * that leaves through its own node reads as a bug however short it is.
  */
 declare function resolveEnd<TPose>(end: EdgeEnd, dep: DerivedDep<TPose>, toward: Vec2, opts: PortsOptions<TPose>, allPorts: (d: DerivedDep<TPose>) => Port[]): Port | undefined;
+/** Options for {@link edgeDerivePath}. */
 interface EdgeRouteOptions<TPose> extends PortsOptions<TPose> {
     /** Routers by key. Defaults to {@link ROUTERS}. */
     routers?: Readonly<Record<string, Router>>;
@@ -171,6 +173,8 @@ interface PortScratch {
     /** The port resolved at press time: where it was and which way it faces. */
     port: Port;
 }
+/** Options for {@link createPortAffordance}: which ports show, and how they
+ *  are painted and hit. */
 interface PortAffordanceOptions<TPose> {
     /** Also the chrome-caps visibility id. Default {@link PORT_LAYER_ID}. */
     id?: string;
@@ -252,6 +256,7 @@ interface PendingEdge {
  * masquerading as a rule.
  */
 declare const defaultCanConnect: CanConnect;
+/** Options for {@link createConnectAction}. Only `participants` is required. */
 interface ConnectActionOptions<TPose> {
     /** Where the droppable ports come from. The same source the port affordance
      *  reads, so what is grabbable and what is landable cannot disagree. */
@@ -345,6 +350,7 @@ declare function createConnectAction<TPose>(opts: ConnectActionOptions<TPose>):
  * the two cannot be wired half-way.
  */
 
+/** The connect action's options and the port affordance's, in one bag. */
 interface DiagramContributionOptions<TPose> extends ConnectActionOptions<TPose>, PortAffordanceOptions<TPose> {
 }
 /** The bundle: the connect action and the one binding that reaches it. */
@@ -386,6 +392,8 @@ interface DiagramLabel {
 declare function diagramLabelOf(node: {
     data: unknown;
 }): DiagramLabel | null;
+/** Options for {@link labelDerivePose}. `geometry` defaults to the kit's
+ *  `AUTO_POSE_DESCRIPTOR`. */
 interface LabelPoseOptions<TPose> {
     geometry?: PoseDescriptor<TPose>;
 }
@@ -423,15 +431,28 @@ interface LiveLayoutFrame {
     result: LayoutResult;
     done: boolean;
 }
+/** One frame of a live layout, called once per frame until it reports `done`. */
 type LiveLayoutProducer<TPose> = (ctx: LiveLayoutCtx<TPose>) => LiveLayoutFrame;
+/** Options for {@link forceProducer}. */
 interface ForceProducerOptions<TPose> extends ForceOptions {
     geometry?: PoseDescriptor<TPose>;
     /** Alpha held while something is pinned, so the graph keeps answering a drag
      *  instead of freezing under it. Default 0.3. */
     dragAlpha?: number;
+    /** The run is at rest once no node moves this far in a tick, in world units.
+     *  Default 0.1. `0` never rests, leaving the run to the cooling schedule. */
+    restDistance?: number;
+    /** Consecutive ticks at rest before the run finishes. Default 5. */
+    restTicks?: number;
 }
 /**
- * A relaxation, one tick a frame, done when the simulation settles.
+ * A relaxation, one tick a frame, done when the graph stops moving.
+ *
+ * Motion ends long before alpha cools — a few dozen ticks against three
+ * hundred — so a run that waited for alpha would sit visibly still for
+ * seconds while still reporting itself running. It finishes on whichever
+ * comes first: `restTicks` ticks in a row with no node moving `restDistance`,
+ * or the cooling schedule running out. Nothing rests while a node is held.
  *
  * The forces are `forceRelaxation`'s — the same ones the one-shot `force`
  * runs, wound up once here and ticked rather than run to completion.
@@ -444,6 +465,7 @@ interface ForceProducerOptions<TPose> extends ForceOptions {
  * nodes were, and a pinned node is deliberately somewhere else.
  */
 declare function forceProducer<TPose>(graph: Graph, opts?: ForceProducerOptions<TPose>): LiveLayoutProducer<TPose>;
+/** Options for {@link easedProducer}. */
 interface EasedProducerOptions {
     layout?: LayoutOptions;
     /** Frames to arrive in. Default 24. */
@@ -459,6 +481,7 @@ interface EasedProducerOptions {
  * over.
  */
 declare function easedProducer<TPose>(graph: Graph, algorithm: LayoutFn, opts?: EasedProducerOptions): LiveLayoutProducer<TPose>;
+/** Options for {@link useLiveLayout}. Only `scene` and `source` are required. */
 interface UseLiveLayoutOptions<TPose> {
     scene: Scene<unknown, string, TPose>;
     /** Where the graph is read from. The same thunk the port affordance takes. */
@@ -467,7 +490,8 @@ interface UseLiveLayoutOptions<TPose> {
      *  continuously; anything else eases to its answer. Default `'force'`. */
     algorithm?: string | LayoutFn;
     layout?: LayoutOptions;
-    force?: ForceOptions;
+    /** The relaxation's forces, and when a live run of it counts as at rest. */
+    force?: Omit<ForceProducerOptions<TPose>, 'geometry'>;
     /** Frames an eased layout takes to arrive. Default 24. */
     frames?: number;
     easing?: EasingFn;
@@ -485,6 +509,7 @@ interface UseLiveLayoutOptions<TPose> {
     requestFrame?: (cb: (t: number) => void) => number;
     cancelFrame?: (handle: number) => void;
 }
+/** Controls for a live layout run, from {@link useLiveLayout}. */
 interface LiveLayout {
     /** Heat and run. Idempotent while running. */
     start(): void;
@@ -519,6 +544,7 @@ declare const EASED_LAYOUTS: Readonly<Record<string, LayoutFn>>;
 
 /** The layouts this package ships. A consumer's own go in the same shape. */
 declare const LAYOUTS: Readonly<Record<string, LayoutFn>>;
+/** Options for {@link applyLayout}. */
 interface ApplyLayoutOptions<TPose> {
     geometry?: PoseDescriptor<TPose>;
     /** The undo entry's name. Default `'Layout'`. */
@@ -551,6 +577,7 @@ declare function applyLayout<TPose>(scene: Scene<unknown, string, TPose>, result
 declare function layoutPoses<TPose>(scene: Scene<unknown, string, TPose>, result: LayoutResult, geometry?: PoseDescriptor<TPose>): Map<string, TPose>;
 /** The default action id. */
 declare const LAYOUT_ACTION_ID = "diagram.layout";
+/** Options for {@link createLayoutAction}. Only `source` is required. */
 interface LayoutActionOptions<TPose> {
     /** Where the graph is read from. The same thunk the port affordance takes. */
     source: GraphSource<TPose>;
@@ -642,6 +669,7 @@ declare function portLayer<TPose>(participants: ParticipantSource<TPose>, opts?:
  * editing, selection and styling work on them without a special case.
  */
 
+/** Options for {@link diagramShape} and {@link registerDiagramShape}. */
 interface DiagramShapeOptions<TPose> {
     /** Distinguishes one registration from another, and is what the disposer
      *  removes. Default `'diagram:outline'`. */

package/dist/index.js

@@ -1,6 +1,6 @@
-import { portOf, portsOf, diagramNodeOf, force, tree, layered, forceRelaxation, center, outlinePath } from './chunk-AD7TY6TK.js';
-export { COMPASS, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, DIAGRAM_TRAIT_KEY, axesFor, backEdges, bodyOutline, bodyTrait, boxForContent, buildBody, canvasMeasure, contentBox, createDiagramNodes, dataKeyReader, diagramNodeOf, force, forceRelaxation, forestOf, graphOrder, isPinned, layered, layoutBody, layoutRowPorts, measureBody, outlinePath, outlinePolyline, packAcross, pinnedSet, portOf, portsOf, portsOnOutline, ranksOf, rayHit, seededOrder, settle, sizeToBody, translated, tree } from './chunk-AD7TY6TK.js';
-import { AUTO_POSE_DESCRIPTOR, pointAlongPath, translatePoseViaDescriptor, polylineFromPoints, effectivePose, composeAffordanceLayer, usePoseRun, RECT_POSE_DESCRIPTOR, registerNodeShape } from '@weasel-js/core';
+import { portOf, portsOf, diagramNodeOf, force, tree, layered, forceRelaxation, center, outlinePath } from './chunk-4KXQABRM.js';
+export { COMPASS, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, DIAGRAM_TRAIT_KEY, axesFor, backEdges, bodyOutline, bodyTrait, boxForContent, buildBody, canvasMeasure, contentBox, createDiagramNodes, dataKeyReader, diagramNodeOf, force, forceRelaxation, forestOf, graphOrder, isPinned, layered, layoutBody, layoutRowPorts, measureBody, outlinePath, outlinePolyline, packAcross, pinnedSet, portOf, portsOf, portsOnOutline, ranksOf, rayHit, seededOrder, settle, sizeToBody, translated, tree } from './chunk-4KXQABRM.js';
+import { AUTO_POSE_DESCRIPTOR, pointAlongPath, translatePoseViaDescriptor, polylineFromPoints, effectivePose, composeAffordanceLayer, useLatest, usePoseRun, RECT_POSE_DESCRIPTOR, registerNodeShape } from '@weasel-js/core';
 import { portCurvePoints } from '@weasel-js/geom';
 import { AUTO_POSE_DESCRIPTOR as AUTO_POSE_DESCRIPTOR$1 } from '@weasel-js/core/math';
 import { useRef, useCallback, useEffect, useMemo } from 'react';
@@ -515,10 +515,16 @@ function createLayoutAction(opts) {
 // src/live.ts
 var EASE_FRAMES = 24;
 var easeInOut = (t) => t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
+var REST_DISTANCE = 0.1;
+var REST_TICKS = 5;
 function forceProducer(graph, opts = {}) {
   const geometry = opts.geometry ?? AUTO_POSE_DESCRIPTOR;
   const relaxation = forceRelaxation(graph, opts);
   const dragAlpha = opts.dragAlpha ?? 0.3;
+  const restDistance = opts.restDistance ?? REST_DISTANCE;
+  const restTicks = opts.restTicks ?? REST_TICKS;
+  const was = relaxation.bodies.map((b) => ({ x: b.x, y: b.y }));
+  let still = 0;
   return ({ pinned }) => {
     for (const node of graph.nodes) {
       const body = relaxation.byId.get(node.id);
@@ -535,7 +541,16 @@ function forceProducer(graph, opts = {}) {
     }
     relaxation.sim.alphaTarget(pinned.size > 0 ? dragAlpha : 0);
     relaxation.sim.tick();
-    return { result: relaxation.placed(), done: relaxation.sim.isSettled() };
+    let moved = 0;
+    relaxation.bodies.forEach((body, i) => {
+      const at = was[i];
+      moved = Math.max(moved, Math.hypot(body.x - at.x, body.y - at.y));
+      at.x = body.x;
+      at.y = body.y;
+    });
+    still = pinned.size === 0 && moved < restDistance ? still + 1 : 0;
+    const done = still >= restTicks || relaxation.sim.isSettled();
+    return { result: relaxation.placed(), done };
   };
 }
 function easedProducer(graph, algorithm, opts = {}) {
@@ -566,8 +581,7 @@ function shapeOf(graph) {
   return `${nodes}|${edges}`;
 }
 function useLiveLayout(opts) {
-  const optsRef = useRef(opts);
-  optsRef.current = opts;
+  const optsRef = useLatest(opts);
   const producer = useRef(null);
   const producerFrame = useRef(0);
   const shape = useRef("");
@@ -594,7 +608,7 @@ function useLiveLayout(opts) {
       ...o.frames === void 0 ? {} : { frames: o.frames },
       ...o.easing ? { easing: o.easing } : {}
     });
-  }, []);
+  }, [optsRef]);
   const step = useCallback((ctx) => {
     const o = optsRef.current;
     if (producer.current === null) return { poses: [], done: true };
@@ -610,7 +624,7 @@ function useLiveLayout(opts) {
     }
     const poses = layoutPoses(o.scene, placed, o.geometry);
     return { poses: [...poses], done };
-  }, []);
+  }, [optsRef]);
   const run = usePoseRun({
     scene: opts.scene,
     step,
@@ -631,7 +645,7 @@ function useLiveLayout(opts) {
       if (shapeOf(graph) === shape.current) return;
       build();
     });
-  }, [opts.scene, opts.reheatOnGraphChange, run, build]);
+  }, [opts.scene, opts.reheatOnGraphChange, run, build, optsRef]);
   return useMemo(() => ({
     start() {
       if (run.isRunning()) return;