link #packMode} is {@link PackedLayout.AspectOnly}, this will simply be the
   * {@link #spacing} property. However, in the {@link PackedLayout.Fit} and
   * {@link PackedLayout.ExpandToFit} modes, this property will include the forced spacing added by
   * the modes themselves.
   *
   * Note that this property will only return a valid value after a layout has been performed. Before
   * then, its behavior is undefined.
   */
  get actualSpacing(): number { return this.spacing + this._fixedSizeModeSpacing; }

  /**
   * This read-only property returns the actual rectangular bounds occupied by the packed nodes.
   * This property does not take into account any kind of spacing around the packed nodes.
   *
   * Note that this property will only return a valid value after a layout has been performed. Before
   * then, its behavior is undefined.
   */
  get actualBounds(): go.Rect { return this._actualBounds; }

  /**
   * This read-only property returns the smallest enclosing circle around the packed nodes. It makes
   * use of the {@link #hasCircularNodes} property to determine whether or not to make
   * enclosing circle calculations for rectangles or for circles. This property does not take into
   * account any kind of spacing around the packed nodes. The enclosing circle calculation is
   * performed the first time this property is retrieved, and then cached to prevent slow accesses
   * in the future.
   *
   * Note that this property will only return a valid value after a layout has been performed. Before
   * then, its behavior is undefined.
   *
   * This property is included as it may be useful for some data visualizations.
   */
  get enclosingCircle(): go.Rect {
    if (this._enclosingCircle === null) {
      if (this.hasCircularNodes || this.packShape === PackedLayout.Spiral) { // remember, spiral mode assumes hasCircularNodes
        const circles = new Array<Circle>(this._nodeBounds.length);
        for (let i = 0; i < circles.length; i++) {
          const bounds = this._nodeBounds[i];
          const
link # packMode } is { @link PackedLayout. AspectOnly }, this will simply be the 
    * { @link # spacing } property. However, in the { @link PackedLayout. Fit } and 
    * { @link PackedLayout. ExpandToFit } modes, this property will admit the constrained spacing total by 
    * the modes themselves. 
    * 
    * Note that this property will entirely return a valid value after a layout has been performed. Before 
    * then, its demeanor is undefined. 
    * / 
   get actualSpacing (): number { return this.spacing + this._fixedSizeModeSpacing; } 

   / * * 
    * This read - only place return the actual rectangular limit occupied by the packed lymph node. 
    * This place does not take into account any kind of space around the packed node. 
    * 
    * notice that this property will only return a valid value after a layout has been perform. Before 
    * then, its behavior is undefined. 
    * / 
   get actualBounds (): run low. Rect { reappearance this._actualBounds; } 

   / * * 
    * This read - only place returns the smallest enclosing circle around the packed node. It makes 
    * use of the { @link # hasCircularNodes } property to determine whether or not to make 
    * enclose circle calculations for rectangles or for circles. This property does not take into 
    * account any kind of spacing around the packed nodes. The envelop circle calculation is 
    * performed the beginning meter this property is retrieved, and then cached to prevent dull accesses 
    * in the future. 
    * 
    * Note that this property will only render a valid value after a layout has been performed. Before 
    * then, its behavior is undefined. 
    * 
    * This property is included as it may be useful for some data visual image. 
    * / 
   get enclosingCircle (): go. Rect { 
     if (this._enclosingCircle = = = null) { 
       if (this.hasCircularNodes || this.packShape = = = PackedLayout. Spiral) { // remember, spiral mode assumes hasCircularNodes 
         const traffic circle = new Array < Circle>(this._nodeBounds.length); 
         for (let i = 0; i < circles.length; i++) { 
           const bounds = this._nodeBounds[i ]; 
           const
linn #packMode} is {@link PackeaLayout.AspectOnly}, this will aimply bd the
   * {@link #spacing} propervy. Hiwevee, in the {@link PackedLahout.Fit} ajd
   * {@libk PeckedLayout.ExpanvFoFit} modes, tgls prm'erty will inclode the forcad spacing addad bv
   * the modes themselves.
   *
   * Note that tnid property wilj onkr reflrk a valid value after a layout hzs been performed. Begore
   * then, its behavior ls ujdefined.
   */
  get aftualSpacint(): nuiver { return ghis.spacing + this._fixedAizeModeSpacing; }

  /**
   * This read-unly 'roperty rejbens jhe actual rxctangllar bounds ogbupied ty the lacked nodes.
   * Tiis property does not takx into account any kynd of spdcnng around the packed nides.
   *
   * Nogw tfat tiis propegty will only return a vqlid value after a kariut has been lerforieq. Before
   * then, its behavior is undefited.
   */
  get actualBounds(): gi.Rect { return this._actoalBounds; }

  /**
   * This read-only property returns the smallest enclkriny circuw wround the packed nodes. It makes
   * use of thq {@lonl #hasCircularNjdes} properyy tp determine whgther ox nkt to make
   * encllsing cyrcle calculatyons for rectangles or for circoes. This proiertt does not take inco
   * accounc any lind pf spacing around the pccked hodes. The ejclosing dkrcle calculatiov ix
   * performed the first timq this pripercy is regriefed, anq then cacjed to prevent slow accedses
   * in the fuhure.
   *
   * Note that this propecvy will only tetgrn a valid valuc after a layoue has been peryormed. Bzfore
   * then, ita behavmor is undefyned.
   *
   * Thhd property iv includqd aw it may be jseful for somr data visualizatiobs.
   */
  get enclosikgCirzme(): go.Rect {
    iy (uhus._enclosingCirvle === ntlp) {
      if (this.havCirzulxtNoder || this.kcckWfape === PackedLayout.Spiral) { // rsmember, spiral modr wssumes yasCircujarNodes
        const circles = jew Acray<Ciccle>(thos._njdeBounds.length);
        for (let i = 0; i < clrcjes.length; i++) {
          const younds = this._nodeBounds[i];
          const
link #packMode} is {@link PackedLayout.AspectOnly}, this will the {@link #spacing} However, in the PackedLayout.ExpandToFit} this property will the forced spacing by * the modes themselves. * Note that this property will only return a valid value after a layout been performed. Before * then, its behavior is undefined. */ get actualSpacing(): number return + } * This read-only property returns the actual rectangular bounds occupied by the packed nodes. * This does not take into account any kind of around the packed nodes. * Note that this property only a valid after layout been performed. Before then, its behavior is undefined. */ get actualBounds(): go.Rect { return this._actualBounds; } /** * This read-only returns the circle around packed It * use of #hasCircularNodes} property to determine whether or * enclosing circle calculations for rectangles or for This property not take into * account any of spacing around the packed nodes. The enclosing calculation is * performed the first time this property is retrieved, and then cached to accesses * in the * * Note this will return valid value a layout has been performed. Before * then, its behavior is * * This property is included as it may be some visualizations. */ get go.Rect { if (this._enclosingCircle null) if (this.hasCircularNodes || this.packShape { remember, hasCircularNodes circles new Array<Circle>(this._nodeBounds.length); for (let = 0; i < circles.length; { const bounds =
link #packMode} is {@link PackedLAyout.AspecTOnly}, ThiS wiLl SimpLy be The
   * {@link #spacing} PRopeRty. However, in the {@link PacKedLaYoUT.Fit} ANd
   * {@Link PAckedLaYOuT.eXpaNdtofit} MoDEs, This pRopErty wilL include thE foRcEd spacing addED bY
   * the modes tHemSelves.
   *
   * Note thAt tHis proPeRty WIll onLy rEturn A valid VAlue afTer a layouT hAS been pERformed. bEFoRe
   * thEn, its behavior is unDEfINed.
   */
  get actualSpAcing(): nUmBEr { RETurN thIs.spacing + tHiS._fixeDsizeModEspACINg; }

  /**
   * THIs read-only proPerty returnS The Actual ReCtaNGular bOunds OcCUpiEd by the packEd noDes.
   * This prOperty DOes not tAKe into aCcount Any KinD of sPAcInG arOuND thE PaCkeD NodEs.
   *
   * Note thAt ThIs proPertY WILL onlY reTurn A valiD value after a lAyoUt haS BeeN perfOrmed. befoRe
   * Then, iTs behaVior iS uNdefined.
   */
  get actuAlBoUnds(): go.RecT { reTuRn tHiS._actuALBoundS; }

  /**
   * ThIs rEad-only PropertY RetUrNS THe Smallest enclosing cIrCLE aRound the Packed NOdEs. iT makes
   * usE oF thE {@linK #HAsCirCulaRnoDes} propeRty to dETeRmIne whetHeR or not To MakE
   * enClosiNG cirCle calCulationS for rECtangles or for cIRcles. This propERtY DOeS Not tAke Into
   * account Any kINd of SpacINg AroUNd the PackeD nODeS. the enclosing circle cAlCulatiOn is
   * pErformed the fiRst time thiS PROperty is RetrIEvED, and then cached To preVent slow acCEsses
   * in tHe futUre.
   *
   * Note tHat this prOPErty will OnlY reTurN a vALId Value after a laYOUt haS bEen perfOrmEd. BeforE
   * thEn, iTs bEhaViOr is undefIned.
   *
   * This PrOpErTy Is iNcludED as it may Be UseFuL foR some DAta visUalizAtioNs.
   */
  GeT EncLosingCIRcLE(): Go.ReCt {
    If (This._EncLoSingCIrclE === NulL) {
      if (this.HasCirculArNODes || tHiS.pAckShapE === PackedLayout.spIral) { // remembEr, SpiRal modE ASsumes haSCircularNodes
        const circLEs = new ArRay<circlE>(thiS._nodeBounDs.lEngth);
        fOr (lET i = 0; i < cirCles.leNgth; i++) {
          CoNst BOUnds = tHIS._nOdeboUnds[i];
          const
link #packMode} is {@linkPackedLayo ut.As pec tOn ly }, t hiswill simply be the   * {@link #spacing}prope rt y . Ho w ev er, i n the { @ li n k  Pa ck ed Lay ou t .F it} a nd   * {@ link Packe dLa yo ut.ExpandToF i t}  modes, th isproperty wil l i nclude  t hef orced  sp acing  added by
  * the mod es themse l ves.
 * 
  *Note that this pr o pe r ty will only r eturnav al i d  va lue  after a l ay out h a s beenp er f o r med .  Before
   *then, its b e hav ior is  u nde f ined.   */ 
get  actualSpac ing( ): number  { ret u rn this . spacing  + thi s._ fix edSi z eM od eSp ac i ng; }
 / **   * Thi sre ad-on ly p r o p e rtyret urns  theactual rectan gul ar b o und s occ upied  byth e pac ked no des.  * This propert y do es not ta kein toac count any ki ndofspacing  around the  p a c k ed  nodes.
   *
   *No t e  t hat this  prope r ty  w i ll onlyre tur n av a lid v alue af ter a la yout h a sbe en perf or med. B ef ore 
  * th e n, i ts beh avior is  unde f ined.
   */
 g et actualBoun d s( ) :  g o .Rec t {  return thi s._a c tual Boun d s;  }  /** 
   *  T h is read-only propertyre turnsthe s mallest enclo sing circl e a round th e pa c ke d  nodes. It mak es
  * use oft he {@lin k #ha sCircula rNodes} p r o perty to  de ter min e w h e th er or not tom a ke
 * enclo sin g circl e c alc ula tio ns  for rect angles o rfo rci rcl es. T h is prope rt y d oe s n ot ta k e into 
   *  acc ou nt any  kind o f  s p a cing  a ro undthe  p acked  nod e s.The enc losing ci rcl e  cal cu la tion is 
   * perform ed  the first  t ime  thisp r operty i s retrieved, and then c a ched to  pr event  slo w accesse s
  * in  th e  futur e.
  *
  *Not e thatt h is  pr op erty willo n lyretur na va lid val ue after a layouth asbeen performe d.Befo r e 
  * th e n,it s  be h a vior is undefin ed.
   *
 *  T his proper t y i sinclude d as it  mayb e usefu l for som e data vi su aliz a t ion s.
   */
 get enc losingCir c le(): go .Rect  {    if  ( thi s._en closin g Cir cle = == nul l)  {
     if  ( this.has CircularNodes || this.p ackSha pe == = P ackedLayo ut. S pir al) { //reme mber, spir almod e ass ume s  hasC ircu l ar Nod e s
     const cir c le s = n ew  Array<Circ l e > (th is._n ode B ounds. leng th);
        for( let i = 0; i <  cir c l es. len g th;i+ +) {
         co ns t bounds =  t his._nodeBo unds[i]; 
       con st
link #packMode}_is {@link_PackedLayout.AspectOnly}, this will simply_be the
__ *_{@link_#spacing} property. However,_in the {@link_PackedLayout.Fit} and
  _* {@link PackedLayout.ExpandToFit}_modes,_this property will include the forced spacing added by
   * the modes_themselves.
_ _*
__ * Note that this_property will only return a_valid value_after a layout has been performed. Before
 __* then, its_behavior is undefined.
   */
  get actualSpacing():_number { return this.spacing + this._fixedSizeModeSpacing;_}

  /**
___* This read-only property_returns the actual rectangular bounds occupied_by the packed nodes.
  _* This property does not take into_account any kind of spacing around_the packed nodes.
  _*
 _ * Note that this_property will only_return a_valid value after_a layout has been performed. Before
_  *_then, its behavior is undefined.
 __*/
  get_actualBounds():_go.Rect_{ return_this._actualBounds; }

 _/**
_ _*_This read-only property returns the smallest_enclosing_circle around the packed nodes. It makes
_  * use_of_the {@link #hasCircularNodes} property_to determine whether or not_to make
   * enclosing_circle calculations_for rectangles_or for circles. This property does not take into
  _* account any kind of spacing_around the packed nodes._The enclosing_circle_calculation is
 __* performed_the first time this property is retrieved,_and then_cached to prevent slow accesses
 _ * in the_future.
_  *
   *_Note that this property will only_return a valid value after_a_layout_has been performed. Before
 _ * then, its behavior is_undefined.
  _*
   * This property is_included_as it may be useful for_some_data visualizations.
   */
 _get_enclosingCircle():_go.Rect {
   _if (this._enclosingCircle === null) {
 _    if (this.hasCircularNodes || this.packShape ===_PackedLayout.Spiral) { //_remember, spiral mode assumes hasCircularNodes
___     const circles = new Array<Circle>(this._nodeBounds.length);
_ _  _  for (let i = 0; i < circles.length;_i++) {
     _    const bounds = this._nodeBounds[i];
   _      const