{"version":3,"sources":["../core/types/variable/VariableMetadata.ts","../core/types/variable/TypeGuards.ts","../core/types/variable/AdvancedTypeDetection.ts","../core/types/variable/LegacyCompatibility.ts","../core/types/variable.ts"],"names":[],"mappings":";;;AAeO,IAAM,sBAAA,GAAN,MAAM,sBAAsB,CAAA;AAAA;AAAA;AAAA;AAAA,EAIjC,OAAO,YAAA,CACL,MACA,EAAA,gBAAA,EACA,aACA,WACgB,EAAA;AAChB,IAAO,OAAA;AAAA,MACL,SAAW,EAAA,KAAA;AAAA,MACX,MAAA;AAAA,MACA,WAAA;AAAA,MACA,gBAAA;AAAA,MACA;AAAA,KACF;AAAA;AACF;AAAA;AAAA;AAAA;AAAA,EAMA,OAAO,aACL,CAAA,IAAA,EACA,UACkB,EAAA;AAClB,IAAI,IAAA,CAAC,IAAQ,IAAA,CAAC,UAAY,EAAA;AACxB,MAAA,OAAO,EAAC;AAAA;AAEV,IAAA,IAAI,CAAC,IAAM,EAAA;AACT,MAAA,OAAO,cAAc,EAAC;AAAA;AAExB,IAAA,IAAI,CAAC,UAAY,EAAA;AACf,MAAO,OAAA,IAAA;AAAA;AAGT,IAAO,OAAA;AAAA,MACL,GAAG,IAAA;AAAA,MACH,GAAG;AAAA,KACL;AAAA;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,iBAAiB,QAAqC,EAAA;AAE3D,IAAA,IAAI,QAAS,CAAA,eAAA,IAAmB,OAAO,QAAA,CAAS,kBAAkB,WAAa,EAAA;AAC7E,MAAA,OAAO,OAAO,QAAA,CAAS,aAAkB,KAAA,QAAA,IAAY,SAAS,aAAiB,IAAA,CAAA;AAAA;AAGjF,IAAA,IAAI,QAAS,CAAA,UAAA,IAAc,CAAC,QAAA,CAAS,UAAY,EAAA;AAC/C,MAAO,OAAA,KAAA;AAAA;AAGT,IAAO,OAAA,IAAA;AAAA;AACT;AAAA;AAAA;AAAA,EAKA,OAAO,kBAAkB,MAAgC,EAAA;AACvD,IAAM,MAAA,KAAA,GAAkB,CAAC,MAAA,CAAO,SAAS,CAAA;AAEzC,IAAA,IAAI,OAAO,MAAQ,EAAA;AACjB,MAAA,KAAA,CAAM,IAAK,CAAA,CAAA,OAAA,EAAU,MAAO,CAAA,MAAM,CAAE,CAAA,CAAA;AAAA;AAGtC,IAAA,IAAI,OAAO,WAAa,EAAA;AACtB,MAAA,KAAA,CAAM,IAAK,CAAA,CAAA,QAAA,EAAW,MAAO,CAAA,WAAW,CAAE,CAAA,CAAA;AAAA;AAG5C,IAAA,IAAI,OAAO,gBAAkB,EAAA;AAC3B,MAAA,KAAA,CAAM,KAAK,cAAc,CAAA;AAAA;AAG3B,IAAA,IAAI,OAAO,WAAa,EAAA;AACtB,MAAA,KAAA,CAAM,KAAK,WAAW,CAAA;AAAA;AAGxB,IAAO,OAAA,KAAA,CAAM,KAAK,GAAG,CAAA;AAAA;AACvB;AAAA;AAAA;AAAA,EAKA,OAAO,kBAAkB,QAAsC,EAAA;AAC7D,IAAO,OAAA,OAAA,CAAQ,UAAU,SAAS,CAAA;AAAA;AACpC;AAAA;AAAA;AAAA,EAKA,OAAO,mBAAmB,QAAsC,EAAA;AAC9D,IAAO,OAAA,OAAA,CAAQ,UAAU,UAAU,CAAA;AAAA;AACrC;AAAA;AAAA;AAAA,EAKA,OAAO,wBAAwB,QAAsC,EAAA;AACnE,IAAO,OAAA,OAAA,CAAQ,UAAU,eAAe,CAAA;AAAA;AAC1C;AAAA;AAAA;AAAA,EAKA,OAAO,oBACL,CAAA,UAAA,EACA,kBACkB,EAAA;AAClB,IAAA,MAAM,cAAmC,GAAA;AAAA,MACvC,UAAY,EAAA,IAAA;AAAA,MACZ;AAAA,KACF;AAEA,IAAO,OAAA,IAAA,CAAK,aAAc,CAAA,cAAA,EAAgB,kBAAkB,CAAA;AAAA;AAC9D;AAAA;AAAA;AAAA,EAKA,OAAO,sBACL,CAAA,aAAA,EACA,kBACkB,EAAA;AAClB,IAAA,MAAM,gBAAqC,GAAA;AAAA,MACzC,eAAiB,EAAA,IAAA;AAAA,MACjB;AAAA,KACF;AAEA,IAAO,OAAA,IAAA,CAAK,aAAc,CAAA,gBAAA,EAAkB,kBAAkB,CAAA;AAAA;AAChE;AAAA;AAAA;AAAA,EAKA,OAAO,sBACL,kBACkB,EAAA;AAClB,IAAA,MAAM,eAAoC,GAAA;AAAA,MACxC,SAAW,EAAA;AAAA,KACb;AAEA,IAAO,OAAA,IAAA,CAAK,aAAc,CAAA,eAAA,EAAiB,kBAAkB,CAAA;AAAA;AAEjE,CAAA;AAnJmC,MAAA,CAAA,sBAAA,EAAA,uBAAA,CAAA;AAA5B,IAAM,qBAAN,GAAA;AA4JA,IAAM,sBAAA,GAAN,MAAM,sBAAsB,CAAA;AAAA;AAAA;AAAA;AAAA,EAIjC,OAAO,kBACL,CAAA,WAAA,EACA,gBAA4B,GAAA,KAAA,EAC5B,cAAuB,KACP,EAAA;AAChB,IAAA,OAAO,qBAAsB,CAAA,YAAA;AAAA,MAC3B,QAAA;AAAA,MACA,gBAAA;AAAA,MACA,WAAA;AAAA,MACA;AAAA,KACF;AAAA;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,oBACL,CAAA,WAAA,GAAuB,KACP,EAAA;AAChB,IAAA,OAAO,qBAAsB,CAAA,YAAA;AAAA,MAC3B,UAAA;AAAA,MACA,IAAA;AAAA;AAAA,MACA,WAAA;AAAA,MACA;AAAA,KACF;AAAA;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,iBAAA,CACL,gBAA4B,GAAA,KAAA,EAC5B,cAAuB,KACP,EAAA;AAChB,IAAA,OAAO,qBAAsB,CAAA,YAAA;AAAA,MAC3B,OAAA;AAAA,MACA,gBAAA;AAAA,MACA,WAAA;AAAA,MACA;AAAA,KACF;AAAA;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,kBAAA,CACL,gBAA4B,GAAA,KAAA,EAC5B,cAAuB,IACP,EAAA;AAChB,IAAA,OAAO,qBAAsB,CAAA,YAAA;AAAA,MAC3B,QAAA;AAAA,MACA,gBAAA;AAAA,MACA;AAAA,KACF;AAAA;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,mBACL,CAAA,WAAA,GAAuB,KACP,EAAA;AAChB,IAAA,OAAO,qBAAsB,CAAA,YAAA;AAAA,MAC3B,SAAA;AAAA,MACA,IAAA;AAAA;AAAA,MACA;AAAA,KACF;AAAA;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,gBACL,CAAA,WAAA,GAAuB,IACP,EAAA;AAChB,IAAA,OAAO,qBAAsB,CAAA,YAAA;AAAA,MAC3B,MAAA;AAAA,MACA,IAAA;AAAA;AAAA,MACA;AAAA,KACF;AAAA;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,gBACL,CAAA,gBAAA,GAA4B,KACZ,EAAA;AAChB,IAAA,OAAO,qBAAsB,CAAA,YAAA;AAAA,MAC3B,MAAA;AAAA,MACA,gBAAA;AAAA,MACA,KAAA;AAAA;AAAA,MACA;AAAA,KACF;AAAA;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,qBAAwC,GAAA;AAC7C,IAAA,OAAO,qBAAsB,CAAA,YAAA;AAAA,MAC3B,WAAA;AAAA,MACA,KAAA;AAAA;AAAA,MACA;AAAA,KACF;AAAA;AAEJ,CAAA;AA9GmC,MAAA,CAAA,sBAAA,EAAA,uBAAA,CAAA;AAA5B,IAAM,qBAAN,GAAA;;;ACvIA,SAAS,aAAa,QAAoD,EAAA;AAC/E,EAAA,OAAO,SAAS,IAAS,KAAA,aAAA;AAC3B;AAFgB,MAAA,CAAA,YAAA,EAAA,cAAA,CAAA;AAOT,SAAS,mBAAmB,QAA0D,EAAA;AAC3F,EAAA,OAAO,SAAS,IAAS,KAAA,mBAAA;AAC3B;AAFgB,MAAA,CAAA,kBAAA,EAAA,oBAAA,CAAA;AAOT,SAAS,WAAW,QAAkD,EAAA;AAC3E,EAAA,OAAO,SAAS,IAAS,KAAA,UAAA;AAC3B;AAFgB,MAAA,CAAA,UAAA,EAAA,YAAA,CAAA;AAOT,SAAS,cAAc,QAAqD,EAAA;AACjF,EAAA,OAAO,SAAS,IAAS,KAAA,cAAA;AAC3B;AAFgB,MAAA,CAAA,aAAA,EAAA,eAAA,CAAA;AAOT,SAAS,iBAAiB,QAAwD,EAAA;AACvF,EAAA,OAAO,SAAS,IAAS,KAAA,iBAAA;AAC3B;AAFgB,MAAA,CAAA,gBAAA,EAAA,kBAAA,CAAA;AAOT,SAAS,SAAS,QAAgD,EAAA;AACvE,EAAA,OAAO,SAAS,IAAS,KAAA,QAAA;AAC3B;AAFgB,MAAA,CAAA,QAAA,EAAA,UAAA,CAAA;AAOT,SAAS,QAAQ,QAA+C,EAAA;AACrE,EAAA,OAAO,SAAS,IAAS,KAAA,OAAA;AAC3B;AAFgB,MAAA,CAAA,OAAA,EAAA,SAAA,CAAA;AAOT,SAAS,WAAW,QAAkD,EAAA;AAC3E,EAAA,OAAO,SAAS,IAAS,KAAA,UAAA;AAC3B;AAFgB,MAAA,CAAA,UAAA,EAAA,YAAA,CAAA;AAOT,SAAS,gBAAgB,QAAuD,EAAA;AACrF,EAAA,OAAO,SAAS,IAAS,KAAA,gBAAA;AAC3B;AAFgB,MAAA,CAAA,eAAA,EAAA,iBAAA,CAAA;AAOT,SAAS,OAAO,QAA8C,EAAA;AACnE,EAAA,OAAO,SAAS,IAAS,KAAA,MAAA;AAC3B;AAFgB,MAAA,CAAA,MAAA,EAAA,QAAA,CAAA;AAOT,SAAS,WAAW,QAAkD,EAAA;AAC3E,EAAA,OAAO,SAAS,IAAS,KAAA,UAAA;AAC3B;AAFgB,MAAA,CAAA,UAAA,EAAA,YAAA,CAAA;AAOT,SAAS,aAAa,QAAoD,EAAA;AAC/E,EAAA,OAAO,SAAS,IAAS,KAAA,YAAA;AAC3B;AAFgB,MAAA,CAAA,YAAA,EAAA,cAAA,CAAA;AAOT,SAAS,gBAAgB,QAAuD,EAAA;AACrF,EAAA,OAAO,SAAS,IAAS,KAAA,gBAAA;AAC3B;AAFgB,MAAA,CAAA,eAAA,EAAA,iBAAA,CAAA;AAOT,SAAS,0BAA0B,QAAyD,EAAA;AACjG,EAAA,OAAO,SAAS,IAAS,KAAA,YAAA;AAC3B;AAFgB,MAAA,CAAA,yBAAA,EAAA,2BAAA,CAAA;AAOT,SAAS,YAAY,QAAmD,EAAA;AAC7E,EAAA,OAAO,SAAS,IAAS,KAAA,WAAA;AAC3B;AAFgB,MAAA,CAAA,WAAA,EAAA,aAAA,CAAA;AAYT,SAAS,WAAW,QAAkD,EAAA;AAC3E,EAAA,OAAO,aAAa,QAAQ,CAAA,IACrB,kBAAmB,CAAA,QAAQ,KAC3B,UAAW,CAAA,QAAQ,CACnB,IAAA,aAAA,CAAc,QAAQ,CACtB,IAAA,gBAAA,CAAiB,QAAQ,CAAA,IACzB,gBAAgB,QAAQ,CAAA;AACjC;AAPgB,MAAA,CAAA,UAAA,EAAA,YAAA,CAAA;AAYT,SAAS,aAAa,QAAoD,EAAA;AAC/E,EAAA,OAAO,SAAS,QAAQ,CAAA,IAAK,QAAQ,QAAQ,CAAA,IAAK,0BAA0B,QAAQ,CAAA;AACtF;AAFgB,MAAA,CAAA,YAAA,EAAA,cAAA,CAAA;AAOT,SAAS,WAAW,QAAkD,EAAA;AAC3E,EAAA,OAAO,aAAc,CAAA,QAAQ,CACtB,IAAA,gBAAA,CAAiB,QAAQ,CAAA,IACzB,UAAW,CAAA,QAAQ,CACnB,IAAA,eAAA,CAAgB,QAAQ,CAAA,IACxB,WAAW,QAAQ,CAAA;AAC5B;AANgB,MAAA,CAAA,UAAA,EAAA,YAAA,CAAA;AAeT,IAAM,mBAAA,GAAN,MAAM,mBAAmB,CAAA;AAAA;AAAA;AAAA;AAAA,EA0B9B,OAAO,OAAQ,CAAA,QAAA,EAAoB,IAA0C,EAAA;AAC3E,IAAA,OAAO,SAAS,IAAS,KAAA,IAAA;AAAA;AAC3B;AAAA;AAAA;AAAA,EAKA,OAAO,iBAAiB,QAAiD,EAAA;AACvE,IAAM,MAAA,KAAA,GAAqC,CAAC,QAAA,CAAS,IAAI,CAAA;AAGzD,IAAI,IAAA,IAAA,CAAK,UAAW,CAAA,QAAQ,CAAG,EAAA;AAC7B,MAAA,KAAA,CAAM,KAAK,aAAa,CAAA;AAAA;AAG1B,IAAI,IAAA,IAAA,CAAK,YAAa,CAAA,QAAQ,CAAG,EAAA;AAC/B,MAAA,KAAA,CAAM,KAAK,QAAQ,CAAA;AAAA;AAGrB,IAAI,IAAA,IAAA,CAAK,UAAW,CAAA,QAAQ,CAAG,EAAA;AAC7B,MAAA,KAAA,CAAM,KAAK,UAAU,CAAA;AAAA;AAGvB,IAAO,OAAA,KAAA;AAAA;AACT;AAAA;AAAA;AAAA,EAKA,OAAO,YACL,CAAA,QAAA,EACA,YACS,EAAA;AACT,IAAA,OAAO,SAAS,IAAS,KAAA,YAAA;AAAA;AAC3B;AAAA;AAAA;AAAA,EAKA,OAAO,SACL,CAAA,QAAA,EACA,KACS,EAAA;AACT,IAAO,OAAA,KAAA,CAAM,QAAS,CAAA,QAAA,CAAS,IAAI,CAAA;AAAA;AACrC;AAAA;AAAA;AAAA,EAKA,OAAO,YACL,CAAA,SAAA,EACA,KACK,EAAA;AACL,IAAO,OAAA,SAAA,CAAU,OAAO,KAAK,CAAA;AAAA;AAC/B;AAAA;AAAA;AAAA,EAKA,OAAO,UACL,CAAA,SAAA,EACA,KACe,EAAA;AACf,IAAO,OAAA,SAAA,CAAU,KAAK,KAAK,CAAA;AAAA;AAC7B;AAAA;AAAA;AAAA,EAKA,OAAO,WACL,CAAA,SAAA,EACA,IACQ,EAAA;AACR,IAAA,OAAO,UAAU,MAAO,CAAA,CAAA,CAAA,KAAK,CAAE,CAAA,IAAA,KAAS,IAAI,CAAE,CAAA,MAAA;AAAA;AAChD;AAAA;AAAA;AAAA,EAKA,OAAO,YAAY,SAAmE,EAAA;AACpF,IAAM,MAAA,MAAA,uBAAa,GAA2C,EAAA;AAE9D,IAAA,KAAA,MAAW,YAAY,SAAW,EAAA;AAChC,MAAA,MAAM,WAAW,MAAO,CAAA,GAAA,CAAI,QAAS,CAAA,IAAI,KAAK,EAAC;AAC/C,MAAA,QAAA,CAAS,KAAK,QAAQ,CAAA;AACtB,MAAO,MAAA,CAAA,GAAA,CAAI,QAAS,CAAA,IAAA,EAAM,QAAQ,CAAA;AAAA;AAGpC,IAAO,OAAA,MAAA;AAAA;AAEX,CAAA;AApHgC,MAAA,CAAA,mBAAA,EAAA,oBAAA,CAAA;AAAA;AAAnB,mBAAA,CAEJ,YAAe,GAAA,YAAA;AAFX,mBAAA,CAGJ,kBAAqB,GAAA,kBAAA;AAHjB,mBAAA,CAIJ,UAAa,GAAA,UAAA;AAJT,mBAAA,CAKJ,aAAgB,GAAA,aAAA;AALZ,mBAAA,CAMJ,gBAAmB,GAAA,gBAAA;AANf,mBAAA,CAOJ,QAAW,GAAA,QAAA;AAPP,mBAAA,CAQJ,OAAU,GAAA,OAAA;AARN,mBAAA,CASJ,UAAa,GAAA,UAAA;AATT,mBAAA,CAUJ,eAAkB,GAAA,eAAA;AAVd,mBAAA,CAWJ,MAAS,GAAA,MAAA;AAXL,mBAAA,CAYJ,UAAa,GAAA,UAAA;AAZT,mBAAA,CAaJ,YAAe,GAAA,YAAA;AAbX,mBAAA,CAcJ,eAAkB,GAAA,eAAA;AAdd,mBAAA,CAeJ,iBAAoB,GAAA,yBAAA;AAfhB,mBAAA,CAgBJ,WAAc,GAAA,WAAA;AAAA;AAhBV,mBAAA,CAmBJ,UAAa,GAAA,UAAA;AAnBT,mBAAA,CAoBJ,YAAe,GAAA,YAAA;AApBX,mBAAA,CAqBJ,UAAa,GAAA,UAAA;AArBf,IAAM,kBAAN,GAAA;AA6HA,IAAM,eAAA,GAAN,MAAM,eAAe,CAAA;AAAA;AAAA;AAAA;AAAA,EAI1B,OAAO,cAAc,QAA6B,EAAA;AAChD,IAAA,MAAM,OAAO,QAAS,CAAA,IAAA;AACtB,IAAO,OAAA,IAAA,KAAS,aACT,IAAA,IAAA,KAAS,mBACT,IAAA,IAAA,KAAS,cACT,IAAS,KAAA,cAAA,IACT,IAAS,KAAA,iBAAA,IACT,IAAS,KAAA,gBAAA;AAAA;AAClB;AAAA;AAAA;AAAA,EAKA,OAAO,cAAc,QAA6B,EAAA;AAChD,IAAA,MAAM,OAAO,QAAS,CAAA,IAAA;AACtB,IAAA,OAAO,SAAS,QACT,IAAA,IAAA,KAAS,OACT,IAAA,IAAA,KAAS,cACT,IAAS,KAAA,WAAA;AAAA;AAClB;AAAA;AAAA;AAAA,EAKA,OAAO,cAAc,QAA6B,EAAA;AAChD,IAAA,MAAM,OAAO,QAAS,CAAA,IAAA;AACtB,IAAA,OAAO,SAAS,UACT,IAAA,IAAA,KAAS,YACT,IAAA,IAAA,KAAS,oBACT,IAAS,KAAA,MAAA;AAAA;AAClB;AAAA;AAAA;AAAA,EAKA,OAAO,uBAAuB,QAA6B,EAAA;AACzD,IAAO,OAAA,UAAA,CAAW,QAAQ,CAAA,IACnB,eAAgB,CAAA,QAAQ,KACvB,UAAW,CAAA,QAAQ,CAAK,IAAA,QAAA,CAAS,QAAU,EAAA,SAAA;AAAA;AAEvD,CAAA;AA5C4B,MAAA,CAAA,eAAA,EAAA,gBAAA,CAAA;AAArB,IAAM,cAAN,GAAA;;;AC5RA,IAAM,sBAAA,GAAN,MAAM,sBAAsB,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMjC,OAAO,iBAAiB,QAA+C,EAAA;AACrE,IAAI,IAAA,UAAA,CAAW,QAAQ,CAAG,EAAA;AACxB,MAAA,OAAQ,QAA8B,CAAA,YAAA;AAAA;AAExC,IAAA,OAAO,QAAS,CAAA,IAAA;AAAA;AAClB;AAAA;AAAA;AAAA;AAAA,EAMA,OAAO,qBAAqB,QAA6B,EAAA;AACvD,IAAI,IAAA,YAAA,CAAa,QAAQ,CAAA,EAAU,OAAA,IAAA;AACnC,IAAI,IAAA,UAAA,CAAW,QAAQ,CAAG,EAAA;AACxB,MAAA,MAAM,QAAW,GAAA,QAAA;AACjB,MAAA,OAAO,QAAS,CAAA,YAAA,KAAiB,YAC1B,IAAA,QAAA,CAAS,UAAU,YAAiB,KAAA,YAAA;AAAA;AAE7C,IAAO,OAAA,KAAA;AAAA;AACT;AAAA;AAAA;AAAA;AAAA,EAMA,OAAO,sBAAsB,QAA6B,EAAA;AAExD,IAAI,IAAA,QAAA,CAAS,UAAU,SAAW,EAAA;AAChC,MAAO,OAAA,IAAA;AAAA;AAIT,IAAA,QAAQ,SAAS,IAAM;AAAA,MACrB,KAAK,QAAA;AAAA,MACL,KAAK,OAAA;AACH,QAAA,OAAQ,SAAiB,SAAa,IAAA,KAAA;AAAA,MAExC,KAAK,UAAA;AACH,QAAO,OAAA,KAAA,CAAM,OAAQ,CAAA,QAAA,CAAS,KAAK,CAAA;AAAA;AAAA,MAErC,KAAK,UAAA;AACH,QAAA,OAAO,IAAK,CAAA,qBAAA,CAAsB,IAAK,CAAA,uBAAA,CAAwB,QAAQ,CAAC,CAAA;AAAA,MAE1E,KAAK,gBAAA;AACH,QAAO,OAAA,IAAA;AAAA;AAAA,MAET;AACE,QAAO,OAAA,KAAA;AAAA;AACX;AACF;AAAA;AAAA;AAAA;AAAA,EAMA,OAAO,kBAAA,CAAmB,QAAoB,EAAA,QAAA,GAAmB,EAAc,EAAA;AAC7E,IAAA,IAAI,OAAU,GAAA,QAAA;AACd,IAAA,IAAI,KAAQ,GAAA,CAAA;AACZ,IAAM,MAAA,IAAA,uBAAW,GAAY,EAAA;AAE7B,IAAA,OAAO,UAAW,CAAA,OAAO,CAAK,IAAA,KAAA,GAAQ,QAAU,EAAA;AAC9C,MAAA,MAAM,QAAW,GAAA,OAAA;AACjB,MAAM,MAAA,GAAA,GAAM,GAAG,QAAS,CAAA,YAAA,CAAa,IAAI,CAAI,CAAA,EAAA,QAAA,CAAS,aAAa,YAAY,CAAA,CAAA;AAG/E,MAAI,IAAA,IAAA,CAAK,GAAI,CAAA,GAAG,CAAG,EAAA;AACjB,QAAA;AAAA;AAEF,MAAA,IAAA,CAAK,IAAI,GAAG,CAAA;AAIZ,MAAA;AAAA;AAGF,IAAO,OAAA,OAAA;AAAA;AACT;AAAA;AAAA;AAAA,EAKA,OAAO,wBAAwB,QAA8B,EAAA;AAC3D,IAAI,IAAA,CAAC,UAAW,CAAA,QAAQ,CAAG,EAAA;AACzB,MAAO,OAAA,QAAA;AAAA;AAGT,IAAA,MAAM,QAAW,GAAA,QAAA;AAGjB,IAAO,OAAA;AAAA,MACL,MAAM,QAAS,CAAA,YAAA;AAAA,MACf,MAAM,QAAS,CAAA,IAAA;AAAA,MACf,OAAO,QAAS,CAAA,KAAA;AAAA,MAChB,QAAQ,QAAS,CAAA,MAAA;AAAA,MACjB,WAAW,QAAS,CAAA,SAAA;AAAA,MACpB,YAAY,QAAS,CAAA,UAAA;AAAA,MACrB,UAAU,QAAS,CAAA;AAAA,KACrB;AAAA;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,kBACL,CAAA,QAAA,EACA,OACS,EAAA;AACT,IAAM,MAAA,aAAA,GAAgB,IAAK,CAAA,gBAAA,CAAiB,QAAQ,CAAA;AAEpD,IAAA,IAAI,mBAAmB,MAAQ,EAAA;AAC7B,MAAO,OAAA,OAAA,CAAQ,KAAK,aAAa,CAAA;AAAA;AAGnC,IAAI,IAAA,KAAA,CAAM,OAAQ,CAAA,OAAO,CAAG,EAAA;AAC1B,MAAO,OAAA,OAAA,CAAQ,SAAS,aAAa,CAAA;AAAA;AAGvC,IAAA,OAAO,aAAkB,KAAA,OAAA;AAAA;AAC3B;AAAA;AAAA;AAAA,EAKA,OAAO,0BAA0B,QAA6B,EAAA;AAC5D,IAAM,MAAA,aAAA,GAAgB,IAAK,CAAA,gBAAA,CAAiB,QAAQ,CAAA;AAEpD,IACE,OAAA,aAAA,KAAkB,UAClB,IAAA,aAAA,KAAkB,YAClB,IAAA,aAAA,KAAkB,oBAClB,aAAkB,KAAA,UAAA,IAClB,IAAK,CAAA,qBAAA,CAAsB,QAAQ,CAAA;AAAA;AAEvC;AAAA;AAAA;AAAA;AAAA,EAMA,OAAO,sBAAsB,QAA4B,EAAA;AACvD,IAAM,MAAA,aAAA,GAAgB,IAAK,CAAA,gBAAA,CAAiB,QAAQ,CAAA;AAEpD,IAAA,QAAQ,aAAe;AAAA,MACrB,KAAK,WAAA;AAAA,MACL,KAAK,aAAA;AACH,QAAO,OAAA,CAAA;AAAA;AAAA,MAET,KAAK,mBAAA;AAAA,MACL,KAAK,cAAA;AAAA,MACL,KAAK,iBAAA;AACH,QAAO,OAAA,CAAA;AAAA;AAAA,MAET,KAAK,QAAA;AAAA,MACL,KAAK,OAAA;AACH,QAAO,OAAA,QAAA,CAAS,YAAY,CAAI,GAAA,CAAA;AAAA;AAAA,MAElC,KAAK,gBAAA;AAAA,MACL,KAAK,UAAA;AACH,QAAO,OAAA,CAAA;AAAA;AAAA,MAET,KAAK,UAAA;AAAA,MACL,KAAK,YAAA;AACH,QAAO,OAAA,CAAA;AAAA;AAAA,MAET,KAAK,gBAAA;AACH,QAAO,OAAA,CAAA;AAAA;AAAA,MAET,KAAK,UAAA;AAEH,QAAM,MAAA,QAAA,GAAW,IAAK,CAAA,uBAAA,CAAwB,QAAQ,CAAA;AACtD,QAAO,OAAA,IAAA,CAAK,qBAAsB,CAAA,QAAQ,CAAI,GAAA,CAAA;AAAA;AAAA,MAEhD;AACE,QAAO,OAAA,CAAA;AAAA;AACX;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,kBAAkB,QAA6B,EAAA;AACpD,IAAM,MAAA,aAAA,GAAgB,IAAK,CAAA,gBAAA,CAAiB,QAAQ,CAAA;AAEpD,IACE,OAAA,aAAA,KAAkB,UAClB,IAAA,aAAA,KAAkB,gBACjB,IAAA,aAAA,KAAkB,YAAgB,IAAA,QAAA,CAAS,IAAS,KAAA,UAAA,IACrD,IAAK,CAAA,qBAAA,CAAsB,QAAQ,CAAA;AAAA;AAEvC;AAAA;AAAA;AAAA,EAKA,OAAO,iBAAiB,QAA6B,EAAA;AACnD,IAAA,QAAQ,SAAS,IAAM;AAAA,MACrB,KAAK,mBAAA;AACH,QAAO,OAAA,QAAA,CAAS,oBAAoB,MAAS,GAAA,CAAA;AAAA,MAE/C,KAAK,UAAA;AACH,QAAO,OAAA,IAAA;AAAA;AAAA,MAET,KAAK,UAAA;AACH,QAAA,OAAO,IAAK,CAAA,gBAAA,CAAiB,IAAK,CAAA,uBAAA,CAAwB,QAAQ,CAAC,CAAA;AAAA,MAErE;AACE,QAAA,OAAO,SAAS,MAAO,CAAA,gBAAA;AAAA;AAC3B;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,wBAAwB,QAA8B,EAAA;AAC3D,IAAA,MAAM,eAAyB,EAAC;AAEhC,IAAA,QAAQ,SAAS,IAAM;AAAA,MACrB,KAAK,mBAAA;AAEH,QAAS,QAAA,CAAA,mBAAA,CAAoB,QAAQ,CAAS,KAAA,KAAA;AAC5C,UAAA,MAAM,OAAU,GAAA,KAAA,CAAM,UAAW,CAAA,KAAA,CAAM,4BAA4B,CAAA;AACnE,UAAA,IAAI,OAAS,EAAA;AACX,YAAa,YAAA,CAAA,IAAA,CAAK,GAAG,OAAQ,CAAA,GAAA,CAAI,OAAK,CAAE,CAAA,SAAA,CAAU,CAAC,CAAC,CAAC,CAAA;AAAA;AACvD,SACD,CAAA;AACD,QAAA;AAAA,MAEF,KAAK,UAAA;AACH,QAAI,IAAA,OAAO,QAAS,CAAA,KAAA,KAAU,QAAU,EAAA;AAEtC,UAAA,MAAM,OAAU,GAAA,QAAA,CAAS,KAAM,CAAA,KAAA,CAAM,kBAAkB,CAAA;AACvD,UAAA,IAAI,OAAS,EAAA;AACX,YAAA,OAAA,CAAQ,QAAQ,CAAS,KAAA,KAAA;AACvB,cAAM,MAAA,OAAA,GAAU,KAAM,CAAA,KAAA,CAAM,CAAG,EAAA,EAAE,CAAE,CAAA,IAAA,EAAO,CAAA,KAAA,CAAM,GAAG,CAAA,CAAE,CAAC,CAAA;AACtD,cAAA,IAAI,OAAW,IAAA,CAAC,YAAa,CAAA,QAAA,CAAS,OAAO,CAAG,EAAA;AAC9C,gBAAA,YAAA,CAAa,KAAK,OAAO,CAAA;AAAA;AAC3B,aACD,CAAA;AAAA;AACH;AAEF,QAAA;AAAA,MAEF,KAAK,UAAA;AAEH,QAAA;AAAA,MAEF;AAEE,QAAA,IAAI,SAAS,MAAO,CAAA,gBAAA,IAAoB,OAAO,QAAA,CAAS,UAAU,QAAU,EAAA;AAC1E,UAAA,MAAM,OAAU,GAAA,QAAA,CAAS,KAAM,CAAA,KAAA,CAAM,4BAA4B,CAAA;AACjE,UAAA,IAAI,OAAS,EAAA;AACX,YAAa,YAAA,CAAA,IAAA,CAAK,GAAG,OAAQ,CAAA,GAAA,CAAI,OAAK,CAAE,CAAA,SAAA,CAAU,CAAC,CAAC,CAAC,CAAA;AAAA;AACvD;AACF;AAGJ,IAAA,OAAO,CAAC,GAAG,IAAI,GAAA,CAAI,YAAY,CAAC,CAAA;AAAA;AAClC;AAAA;AAAA;AAAA,EAKA,OAAO,qBACL,CAAA,QAAA,EACA,cACA,OAAuB,mBAAA,IAAI,KAClB,EAAA;AACT,IAAA,IAAI,OAAQ,CAAA,GAAA,CAAI,QAAS,CAAA,IAAI,CAAG,EAAA;AAC9B,MAAO,OAAA,IAAA;AAAA;AAGT,IAAQ,OAAA,CAAA,GAAA,CAAI,SAAS,IAAI,CAAA;AACzB,IAAM,MAAA,YAAA,GAAe,IAAK,CAAA,uBAAA,CAAwB,QAAQ,CAAA;AAE1D,IAAA,KAAA,IAAS,CAAI,GAAA,CAAA,EAAG,CAAI,GAAA,YAAA,CAAa,QAAQ,CAAK,EAAA,EAAA;AAC5C,MAAM,MAAA,OAAA,GAAU,aAAa,CAAC,CAAA;AAC9B,MAAM,MAAA,WAAA,GAAc,YAAa,CAAA,GAAA,CAAI,OAAO,CAAA;AAC5C,MAAA,IAAI,eAAe,IAAK,CAAA,qBAAA,CAAsB,WAAa,EAAA,YAAA,EAAc,OAAO,CAAG,EAAA;AACjF,QAAO,OAAA,IAAA;AAAA;AACT;AAGF,IAAQ,OAAA,CAAA,MAAA,CAAO,SAAS,IAAI,CAAA;AAC5B,IAAO,OAAA,KAAA;AAAA;AACT;AAAA;AAAA;AAAA,EAKA,OAAO,eAAe,QAA6B,EAAA;AACjD,IAAM,MAAA,aAAA,GAAgB,IAAK,CAAA,gBAAA,CAAiB,QAAQ,CAAA;AAEpD,IAAA,QAAQ,aAAe;AAAA,MACrB,KAAK,aAAA;AAAA,MACL,KAAK,mBAAA;AAAA,MACL,KAAK,cAAA;AAAA,MACL,KAAK,iBAAA;AAAA,MACL,KAAK,gBAAA;AAAA,MACL,KAAK,WAAA;AACH,QAAO,OAAA,IAAA;AAAA,MAET,KAAK,QAAA;AAAA,MACL,KAAK,OAAA;AACH,QAAO,OAAA,CAAC,IAAK,CAAA,qBAAA,CAAsB,QAAQ,CAAA;AAAA,MAE7C,KAAK,MAAA;AACH,QAAO,OAAA,IAAA;AAAA;AAAA,MAET,KAAK,UAAA;AAAA,MACL,KAAK,YAAA;AAAA,MACL,KAAK,gBAAA;AAAA,MACL,KAAK,UAAA;AACH,QAAO,OAAA,KAAA;AAAA;AAAA,MAET,KAAK,UAAA;AACH,QAAA,OAAO,IAAK,CAAA,cAAA,CAAe,IAAK,CAAA,uBAAA,CAAwB,QAAQ,CAAC,CAAA;AAAA,MAEnE;AACE,QAAO,OAAA,KAAA;AAAA;AACX;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,mBAAmB,QAA4B,EAAA;AACpD,IAAA,IAAI,KAAQ,GAAA,CAAA;AACZ,IAAM,MAAA,aAAA,GAAgB,IAAK,CAAA,gBAAA,CAAiB,QAAQ,CAAA;AAGpD,IAAA,QAAQ,aAAe;AAAA,MACrB,KAAK,WAAA;AAAA,MACL,KAAK,aAAA;AACH,QAAS,KAAA,IAAA,CAAA;AACT,QAAA;AAAA,MACF,KAAK,mBAAA;AACH,QAAS,KAAA,IAAA,CAAA,GAAK,QAAiB,CAAA,mBAAA,EAAqB,MAAU,IAAA,CAAA;AAC9D,QAAA;AAAA,MACF,KAAK,UAAA;AACH,QAAS,KAAA,IAAA,CAAA;AACT,QAAA,IAAI,KAAM,CAAA,OAAA,CAAQ,QAAS,CAAA,KAAK,GAAY,KAAA,IAAA,CAAA;AAC5C,QAAA;AAAA,MACF,KAAK,QAAA;AAAA,MACL,KAAK,OAAA;AACH,QAAS,KAAA,IAAA,CAAA;AACT,QAAI,IAAA,QAAA,CAAS,WAAoB,KAAA,IAAA,CAAA;AACjC,QAAA;AAAA,MACF,KAAK,YAAA;AAAA,MACL,KAAK,UAAA;AACH,QAAS,KAAA,IAAA,CAAA;AACT,QAAA;AAAA,MACF,KAAK,gBAAA;AACH,QAAS,KAAA,IAAA,CAAA;AACT,QAAA;AAAA,MACF;AACE,QAAS,KAAA,IAAA,CAAA;AAAA;AAIb,IAAA,IAAI,IAAK,CAAA,gBAAA,CAAiB,QAAQ,CAAA,EAAY,KAAA,IAAA,CAAA;AAC9C,IAAA,IAAI,IAAK,CAAA,qBAAA,CAAsB,QAAQ,CAAA,EAAY,KAAA,IAAA,CAAA;AACnD,IAAI,IAAA,QAAA,CAAS,QAAU,EAAA,UAAA,EAAqB,KAAA,IAAA,CAAA;AAE5C,IAAM,MAAA,YAAA,GAAe,IAAK,CAAA,uBAAA,CAAwB,QAAQ,CAAA;AAC1D,IAAA,KAAA,IAAS,aAAa,MAAS,GAAA,GAAA;AAE/B,IAAO,OAAA,IAAA,CAAK,MAAM,KAAK,CAAA;AAAA;AAE3B,CAAA;AAtXmC,MAAA,CAAA,sBAAA,EAAA,uBAAA,CAAA;AAA5B,IAAM,qBAAN,GAAA;;;ACcA,IAAM,wBAAA,GAAN,MAAM,wBAAwB,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMnC,OAAO,iBAAiB,QAAoC,EAAA;AAC1D,IAAO,OAAA;AAAA,MACL,IAAM,EAAA,IAAA,CAAK,eAAgB,CAAA,QAAA,CAAS,IAAI,CAAA;AAAA,MACxC,MAAM,QAAS,CAAA,IAAA;AAAA,MACf,KAAA,EAAO,IAAK,CAAA,kBAAA,CAAmB,QAAQ,CAAA;AAAA,MACvC,UAAU,QAAS,CAAA;AAAA,KACrB;AAAA;AACF;AAAA;AAAA;AAAA;AAAA,EAMA,OAAO,kBACL,CAAA,MAAA,EACA,MACU,EAAA;AACV,IAAA,MAAM,gBAAgC,MAAU,IAAA;AAAA,MAC9C,SAAW,EAAA,KAAA;AAAA,MACX,MAAQ,EAAA,WAAA;AAAA,MACR,gBAAkB,EAAA,KAAA;AAAA,MAClB,WAAa,EAAA;AAAA,KACf;AAEA,IAAA,MAAM,OAAU,GAAA,IAAA,CAAK,iBAAkB,CAAA,MAAA,CAAO,IAAI,CAAA;AAClD,IAAA,MAAM,YAAe,GAAA;AAAA,MACnB,MAAM,MAAO,CAAA,IAAA;AAAA,MACb,SAAA,EAAW,KAAK,GAAI,EAAA;AAAA,MACpB,UAAA,EAAY,KAAK,GAAI,EAAA;AAAA,MACrB,MAAQ,EAAA,aAAA;AAAA,MACR,UAAU,MAAO,CAAA;AAAA,KACnB;AAGA,IAAA,QAAQ,OAAS;AAAA,MACf,KAAK,aAAA;AACH,QAAO,OAAA;AAAA,UACL,IAAM,EAAA,aAAA;AAAA,UACN,KAAA,EAAO,MAAO,CAAA,MAAA,CAAO,KAAK,CAAA;AAAA,UAC1B,GAAG;AAAA,SACL;AAAA,MAEF,KAAK,QAAA;AACH,QAAO,OAAA;AAAA,UACL,IAAM,EAAA,QAAA;AAAA,UACN,KAAA,EAAO,MAAO,CAAA,KAAA,IAAS,EAAC;AAAA,UACxB,SAAW,EAAA,KAAA;AAAA,UACX,GAAG;AAAA,SACL;AAAA,MAEF,KAAK,OAAA;AACH,QAAO,OAAA;AAAA,UACL,IAAM,EAAA,OAAA;AAAA,UACN,KAAA,EAAO,MAAM,OAAQ,CAAA,MAAA,CAAO,KAAK,CAAI,GAAA,MAAA,CAAO,QAAQ,EAAC;AAAA,UACrD,SAAW,EAAA,KAAA;AAAA,UACX,GAAG;AAAA,SACL;AAAA,MAEF,KAAK,gBAAA;AACH,QAAO,OAAA;AAAA,UACL,IAAM,EAAA,gBAAA;AAAA,UACN,KAAA,EAAO,MAAO,CAAA,MAAA,CAAO,KAAK,CAAA;AAAA,UAC1B,OAAA,EAAS,MAAO,CAAA,QAAA,EAAU,OAAW,IAAA,EAAA;AAAA,UACrC,GAAG;AAAA,SACL;AAAA,MAEF,KAAK,MAAA;AACH,QAAO,OAAA;AAAA,UACL,IAAM,EAAA,MAAA;AAAA,UACN,KAAO,EAAA;AAAA,YACL,cAAc,MAAO,CAAA,KAAA,EAAO,YAAgB,IAAA,MAAA,CAAO,OAAO,KAAK,CAAA;AAAA,YAC/D,cAAc,MAAO,CAAA,KAAA,EAAO,YAAgB,IAAA,MAAA,CAAO,OAAO,KAAK,CAAA;AAAA,YAC/D,KAAA,EAAO,MAAO,CAAA,KAAA,EAAO,KAAS,IAAA,KAAA;AAAA,YAC9B,UAAA,EAAY,MAAO,CAAA,KAAA,EAAO,UAAc,IAAA;AAAA,WAC1C;AAAA,UACA,GAAG;AAAA,SACL;AAAA,MAEF,KAAK,UAAA;AACH,QAAO,OAAA;AAAA,UACL,IAAM,EAAA,UAAA;AAAA,UACN,OAAO,MAAO,CAAA,KAAA;AAAA,UACd,YAAA,EAAc,MAAO,CAAA,QAAA,EAAU,YAAgB,IAAA,aAAA;AAAA,UAC/C,YAAc,EAAA;AAAA,YACZ,IAAA,EAAM,MAAO,CAAA,QAAA,EAAU,UAAc,IAAA,EAAA;AAAA,YACrC,QAAA,EAAU,MAAO,CAAA,QAAA,EAAU,QAAY,IAAA,KAAA;AAAA,YACvC,cAAc,MAAO,CAAA;AAAA,WACvB;AAAA,UACA,GAAG;AAAA,SACL;AAAA,MAEF,KAAK,YAAA;AACH,QAAO,OAAA;AAAA,UACL,IAAM,EAAA,YAAA;AAAA,UACN,KAAO,EAAA;AAAA,YACL,IAAA,EAAM,MAAO,CAAA,KAAA,EAAO,IAAQ,IAAA,SAAA;AAAA,YAC5B,UAAU,MAAO,CAAA,KAAA,EAAO,eAAmB,IAAA,MAAA,CAAO,OAAO,YAAgB,IAAA,EAAA;AAAA,YACzE,QAAA,EAAU,OAAO,KAAO,EAAA;AAAA,WAC1B;AAAA,UACA,UAAY,EAAA,MAAA,CAAO,KAAO,EAAA,UAAA,IAAc,EAAC;AAAA,UACzC,GAAG;AAAA,SACL;AAAA,MAEF;AAEE,QAAO,OAAA;AAAA,UACL,IAAM,EAAA,aAAA;AAAA,UACN,KAAA,EAAO,MAAO,CAAA,MAAA,CAAO,KAAK,CAAA;AAAA,UAC1B,GAAG;AAAA,SACL;AAAA;AACJ;AACF;AAAA;AAAA;AAAA;AAAA,EAMA,OAAe,gBAAgB,IAAyC,EAAA;AACtE,IAAA,QAAQ,IAAM;AAAA,MACZ,KAAK,aAAA;AAAA,MACL,KAAK,mBAAA;AAAA,MACL,KAAK,UAAA;AAAA,MACL,KAAK,cAAA;AAAA,MACL,KAAK,iBAAA;AACH,QAAO,OAAA,MAAA;AAAA,MAET,KAAK,QAAA;AAAA,MACL,KAAK,OAAA;AAAA,MACL,KAAK,UAAA;AAAA,MACL,KAAK,gBAAA;AAAA,MACL,KAAK,WAAA;AACH,QAAO,OAAA,MAAA;AAAA,MAET,KAAK,MAAA;AACH,QAAO,OAAA,MAAA;AAAA,MAET,KAAK,gBAAA;AACH,QAAO,OAAA,SAAA;AAAA,MAET,KAAK,UAAA;AACH,QAAO,OAAA,QAAA;AAAA,MAET,KAAK,YAAA;AACH,QAAO,OAAA,YAAA;AAAA,MAET;AACE,QAAO,OAAA,MAAA;AAAA;AACX;AACF;AAAA;AAAA;AAAA,EAKA,OAAe,kBAAkB,UAA+C,EAAA;AAC9E,IAAQ,QAAA,UAAA,CAAW,aAAe;AAAA,MAChC,KAAK,MAAA;AACH,QAAO,OAAA,aAAA;AAAA,MACT,KAAK,MAAA;AACH,QAAO,OAAA,QAAA;AAAA;AAAA,MACT,KAAK,MAAA;AACH,QAAO,OAAA,MAAA;AAAA,MACT,KAAK,SAAA;AACH,QAAO,OAAA,gBAAA;AAAA,MACT,KAAK,QAAA;AACH,QAAO,OAAA,UAAA;AAAA,MACT,KAAK,YAAA;AACH,QAAO,OAAA,YAAA;AAAA,MACT;AACE,QAAO,OAAA,aAAA;AAAA;AACX;AACF;AAAA;AAAA;AAAA;AAAA,EAMA,OAAe,mBAAmB,QAAyB,EAAA;AACzD,IAAA,QAAQ,SAAS,IAAM;AAAA,MACrB,KAAK,aAAA;AAAA,MACL,KAAK,mBAAA;AAAA,MACL,KAAK,UAAA;AAAA,MACL,KAAK,cAAA;AAAA,MACL,KAAK,iBAAA;AAAA,MACL,KAAK,gBAAA;AACH,QAAA,OAAO,QAAS,CAAA,KAAA;AAAA,MAElB,KAAK,QAAA;AAAA,MACL,KAAK,OAAA;AAAA,MACL,KAAK,UAAA;AAAA,MACL,KAAK,WAAA;AACH,QAAA,OAAO,QAAS,CAAA,KAAA;AAAA,MAElB,KAAK,MAAA;AACH,QAAA,OAAO,QAAS,CAAA,KAAA;AAAA,MAElB,KAAK,UAAA;AACH,QAAA,OAAO,QAAS,CAAA,KAAA;AAAA,MAElB,KAAK,YAAA;AACH,QAAO,OAAA;AAAA,UACL,IAAA,EAAM,SAAS,KAAM,CAAA,IAAA;AAAA,UACrB,YAAY,QAAS,CAAA,UAAA;AAAA,UACrB,GAAI,QAAS,CAAA,KAAA,CAAM,SAAS,SACxB,GAAA,EAAE,iBAAiB,QAAS,CAAA,KAAA,CAAM,UAClC,GAAA,EAAE,cAAc,QAAS,CAAA,KAAA,CAAM,UAAU,QAAU,EAAA,QAAA,CAAS,MAAM,QAAS;AAAA,SACjF;AAAA,MAEF,KAAK,gBAAA;AACH,QAAA,OAAO,QAAS,CAAA,KAAA;AAAA,MAElB;AACE,QAAA,OAAO,QAAS,CAAA,KAAA;AAAA;AACpB;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,cAAc,QAAwB,EAAA;AAC3C,IAAA,OAAO,UAAU,QACV,IAAA,OAAO,QAAS,CAAA,IAAA,KAAS,YACzB,CAAC,MAAA,EAAQ,MAAQ,EAAA,MAAA,EAAQ,WAAW,QAAU,EAAA,YAAY,CAAE,CAAA,QAAA,CAAS,SAAS,IAAI,CAAA;AAAA;AAC3F;AAAA;AAAA;AAAA,EAKA,OAAO,sBACL,CAAA,eAAA,EACA,aACY,EAAA;AACZ,IAAA,OAAO,eAAgB,CAAA,GAAA;AAAA,MAAI,CACzB,MAAA,KAAA,IAAA,CAAK,kBAAmB,CAAA,MAAA,EAAQ,aAAa;AAAA,KAC/C;AAAA;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,sBAAsB,SAAyC,EAAA;AACpE,IAAA,OAAO,UAAU,GAAI,CAAA,CAAA,QAAA,KAAY,IAAK,CAAA,gBAAA,CAAiB,QAAQ,CAAC,CAAA;AAAA;AAClE;AAAA;AAAA;AAAA,EAKA,OAAO,kBAAA,CACL,QACA,EAAA,SAAA,EACA,WACsC,EAAA;AACtC,IAAA,MAAM,SAAmB,EAAC;AAG1B,IAAI,IAAA,QAAA,CAAS,IAAS,KAAA,WAAA,CAAY,IAAM,EAAA;AACtC,MAAA,MAAA,CAAO,KAAK,CAAkB,eAAA,EAAA,QAAA,CAAS,IAAI,CAAO,IAAA,EAAA,WAAA,CAAY,IAAI,CAAE,CAAA,CAAA;AAAA;AAItE,IAAM,MAAA,aAAA,GAAgB,IAAK,CAAA,kBAAA,CAAmB,QAAQ,CAAA;AACtD,IAAM,MAAA,gBAAA,GAAmB,IAAK,CAAA,kBAAA,CAAmB,WAAW,CAAA;AAE5D,IAAA,IAAI,KAAK,SAAU,CAAA,aAAa,MAAM,IAAK,CAAA,SAAA,CAAU,gBAAgB,CAAG,EAAA;AACtE,MAAA,MAAA,CAAO,KAAK,2CAA2C,CAAA;AAAA;AAIzD,IAAA,MAAM,kBAAqB,GAAA,IAAA,CAAK,eAAgB,CAAA,QAAA,CAAS,IAAI,CAAA;AAC7D,IAAI,IAAA,SAAA,CAAU,SAAS,kBAAoB,EAAA;AACzC,MAAO,MAAA,CAAA,IAAA,CAAK,uBAAuB,QAAS,CAAA,IAAI,OAAO,SAAU,CAAA,IAAI,CAAc,WAAA,EAAA,kBAAkB,CAAG,CAAA,CAAA,CAAA;AAAA;AAG1G,IAAO,OAAA;AAAA,MACL,KAAA,EAAO,OAAO,MAAW,KAAA,CAAA;AAAA,MACzB;AAAA,KACF;AAAA;AACF;AAAA;AAAA;AAAA,EAKA,OAAO,sBACL,eAMA,EAAA;AACA,IAAA,MAAM,MAAS,GAAA;AAAA,MACb,OAAO,eAAgB,CAAA,MAAA;AAAA,MACvB,QAAQ,EAAC;AAAA,MACT,kBAAkB,EAAC;AAAA,MACnB,UAAU;AAAC,KACb;AAEA,IAAA,eAAA,CAAgB,QAAQ,CAAY,QAAA,KAAA;AAElC,MAAO,MAAA,CAAA,MAAA,CAAO,SAAS,IAAI,CAAA,GAAA,CAAK,OAAO,MAAO,CAAA,QAAA,CAAS,IAAI,CAAA,IAAK,CAAK,IAAA,CAAA;AAGrE,MAAI,IAAA,QAAA,CAAS,UAAU,SAAW,EAAA;AAChC,QAAO,MAAA,CAAA,gBAAA,CAAiB,IAAK,CAAA,QAAA,CAAS,IAAI,CAAA;AAAA;AAI5C,MAAA,IAAI,CAAC,IAAA,CAAK,iBAAkB,CAAA,QAAA,CAAS,IAAI,CAAG,EAAA;AAC1C,QAAO,MAAA,CAAA,QAAA,CAAS,KAAK,CAAwB,qBAAA,EAAA,QAAA,CAAS,IAAI,CAAiB,cAAA,EAAA,QAAA,CAAS,IAAI,CAAE,CAAA,CAAA;AAAA;AAG5F,MAAI,IAAA,QAAA,CAAS,SAAS,OAAO,QAAA,CAAS,UAAU,QAAY,IAAA,cAAA,IAAkB,SAAS,KAAO,EAAA;AAC5F,QAAA,MAAA,CAAO,QAAS,CAAA,IAAA,CAAK,CAAY,SAAA,EAAA,QAAA,CAAS,IAAI,CAAmC,iCAAA,CAAA,CAAA;AAAA;AACnF,KACD,CAAA;AAED,IAAO,OAAA,MAAA;AAAA;AACT;AAAA;AAAA;AAAA,EAKA,OAAO,oBACL,cAC2B,EAAA;AAC3B,IAAA,MAAM,QAAQ,cAAe,CAAA,KAAA;AAG7B,IAAI,IAAA,cAAA,CAAe,SAAS,MAAQ,EAAA;AAClC,MAAA,IAAI,OAAO,KAAU,KAAA,QAAA,IAAY,OAAO,KAAU,KAAA,SAAA,IAAa,UAAU,IAAM,EAAA;AAC7E,QAAO,OAAA,WAAA;AAAA,OACE,MAAA,IAAA,KAAA,CAAM,OAAQ,CAAA,KAAK,CAAG,EAAA;AAC/B,QAAO,OAAA,OAAA;AAAA,OACE,MAAA,IAAA,OAAO,KAAU,KAAA,QAAA,IAAY,UAAU,IAAM,EAAA;AACtD,QAAO,OAAA,QAAA;AAAA;AACT;AAIF,IAAI,IAAA,cAAA,CAAe,SAAS,MAAQ,EAAA;AAClC,MAAI,IAAA,OAAO,UAAU,QAAU,EAAA;AAC7B,QAAA,IAAI,MAAM,QAAS,CAAA,IAAI,KAAK,KAAM,CAAA,QAAA,CAAS,IAAI,CAAG,EAAA;AAChD,UAAO,OAAA,UAAA;AAAA,SACT,MAAA,IAAW,cAAe,CAAA,QAAA,EAAU,gBAAkB,EAAA;AACpD,UAAO,OAAA,mBAAA;AAAA,SACT,MAAA,IAAW,cAAe,CAAA,QAAA,EAAU,QAAU,EAAA;AAC5C,UAAO,OAAA,cAAA,CAAe,QAAS,CAAA,WAAA,GAAc,iBAAoB,GAAA,cAAA;AAAA;AACnE;AACF;AAIF,IAAO,OAAA,IAAA,CAAK,iBAAkB,CAAA,cAAA,CAAe,IAAI,CAAA;AAAA;AAErD,CAAA;AAvWqC,MAAA,CAAA,wBAAA,EAAA,yBAAA,CAAA;AAA9B,IAAM,uBAAN,GAAA;;;AC6CA,SAAS,iBAAiB,QAAyB,EAAA;AACxD,EAAO,OAAA,uBAAA,CAAwB,iBAAiB,QAAQ,CAAA;AAC1D;AAFgB,MAAA,CAAA,gBAAA,EAAA,kBAAA,CAAA;AAOT,SAAS,cAAc,QAA6B,EAAA;AACzD,EAAO,OAAA,uBAAA,CAAwB,cAAc,QAAQ,CAAA;AACvD;AAFgB,MAAA,CAAA,aAAA,EAAA,eAAA,CAAA;AAOT,SAAS,qBAAqB,QAA6B,EAAA;AAChE,EAAO,OAAA,qBAAA,CAAsB,qBAAqB,QAAQ,CAAA;AAC5D;AAFgB,MAAA,CAAA,oBAAA,EAAA,sBAAA,CAAA;AAOT,SAAS,iBAAiB,QAAoB,EAAA;AACnD,EAAO,OAAA,qBAAA,CAAsB,iBAAiB,QAAQ,CAAA;AACxD;AAFgB,MAAA,CAAA,gBAAA,EAAA,kBAAA,CAAA","file":"chunk-VKEM6RSR.mjs","sourcesContent":["/**\n * Variable Metadata Management\n * \n * Types and utilities for managing variable metadata and source information.\n */\n\nimport { VariableSource, VariableMetadata } from './VariableTypes';\n\n// =========================================================================\n// METADATA UTILITY FUNCTIONS\n// =========================================================================\n\n/**\n * Utility class for managing variable metadata\n */\nexport class VariableMetadataUtils {\n  /**\n   * Create consistent variable source metadata\n   */\n  static createSource(\n    syntax: 'quoted' | 'template' | 'array' | 'object' | 'command' | 'code' | 'path' | 'reference',\n    hasInterpolation: boolean,\n    isMultiLine: boolean,\n    wrapperType?: 'singleQuote' | 'doubleQuote' | 'backtick' | 'brackets'\n  ): VariableSource {\n    return {\n      directive: 'var',\n      syntax,\n      wrapperType,\n      hasInterpolation,\n      isMultiLine\n    };\n  }\n\n  /**\n   * Merge metadata objects with proper precedence\n   * Additional metadata takes precedence over base metadata\n   */\n  static mergeMetadata(\n    base?: VariableMetadata,\n    additional?: VariableMetadata\n  ): VariableMetadata {\n    if (!base && !additional) {\n      return {};\n    }\n    if (!base) {\n      return additional || {};\n    }\n    if (!additional) {\n      return base;\n    }\n    \n    return {\n      ...base,\n      ...additional\n    };\n  }\n\n  /**\n   * Validate metadata consistency\n   */\n  static validateMetadata(metadata: VariableMetadata): boolean {\n    // Basic validation - can be extended\n    if (metadata.isPipelineInput && typeof metadata.pipelineStage !== 'undefined') {\n      return typeof metadata.pipelineStage === 'number' && metadata.pipelineStage >= 0;\n    }\n    \n    if (metadata.isImported && !metadata.importPath) {\n      return false;\n    }\n    \n    return true;\n  }\n\n  /**\n   * Extract source information for debugging\n   */\n  static extractSourceInfo(source: VariableSource): string {\n    const parts: string[] = [source.directive];\n    \n    if (source.syntax) {\n      parts.push(`syntax:${source.syntax}`);\n    }\n    \n    if (source.wrapperType) {\n      parts.push(`wrapper:${source.wrapperType}`);\n    }\n    \n    if (source.hasInterpolation) {\n      parts.push('interpolated');\n    }\n    \n    if (source.isMultiLine) {\n      parts.push('multiline');\n    }\n    \n    return parts.join(' ');\n  }\n\n  /**\n   * Check if metadata indicates a complex variable\n   */\n  static isComplexVariable(metadata?: VariableMetadata): boolean {\n    return Boolean(metadata?.isComplex);\n  }\n\n  /**\n   * Check if metadata indicates an imported variable\n   */\n  static isImportedVariable(metadata?: VariableMetadata): boolean {\n    return Boolean(metadata?.isImported);\n  }\n\n  /**\n   * Check if metadata indicates a pipeline input variable\n   */\n  static isPipelineInputVariable(metadata?: VariableMetadata): boolean {\n    return Boolean(metadata?.isPipelineInput);\n  }\n\n  /**\n   * Create metadata for imported variables\n   */\n  static createImportMetadata(\n    importPath: string,\n    additionalMetadata?: VariableMetadata\n  ): VariableMetadata {\n    const importMetadata: VariableMetadata = {\n      isImported: true,\n      importPath\n    };\n    \n    return this.mergeMetadata(importMetadata, additionalMetadata);\n  }\n\n  /**\n   * Create metadata for pipeline input variables\n   */\n  static createPipelineMetadata(\n    pipelineStage?: number,\n    additionalMetadata?: VariableMetadata\n  ): VariableMetadata {\n    const pipelineMetadata: VariableMetadata = {\n      isPipelineInput: true,\n      pipelineStage\n    };\n    \n    return this.mergeMetadata(pipelineMetadata, additionalMetadata);\n  }\n\n  /**\n   * Create metadata for complex variables\n   */\n  static createComplexMetadata(\n    additionalMetadata?: VariableMetadata\n  ): VariableMetadata {\n    const complexMetadata: VariableMetadata = {\n      isComplex: true\n    };\n    \n    return this.mergeMetadata(complexMetadata, additionalMetadata);\n  }\n}\n\n// =========================================================================\n// SOURCE CREATION HELPERS\n// =========================================================================\n\n/**\n * Helper functions for creating common variable source configurations\n */\nexport class VariableSourceHelpers {\n  /**\n   * Create source for quoted text variables\n   */\n  static createQuotedSource(\n    wrapperType: 'singleQuote' | 'doubleQuote',\n    hasInterpolation: boolean = false,\n    isMultiLine: boolean = false\n  ): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'quoted',\n      hasInterpolation,\n      isMultiLine,\n      wrapperType\n    );\n  }\n\n  /**\n   * Create source for template variables\n   */\n  static createTemplateSource(\n    isMultiLine: boolean = false\n  ): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'template',\n      true, // Templates always have interpolation\n      isMultiLine,\n      'backtick'\n    );\n  }\n\n  /**\n   * Create source for array variables\n   */\n  static createArraySource(\n    hasInterpolation: boolean = false,\n    isMultiLine: boolean = false\n  ): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'array',\n      hasInterpolation,\n      isMultiLine,\n      'brackets'\n    );\n  }\n\n  /**\n   * Create source for object variables\n   */\n  static createObjectSource(\n    hasInterpolation: boolean = false,\n    isMultiLine: boolean = true // Objects are typically multiline\n  ): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'object',\n      hasInterpolation,\n      isMultiLine\n    );\n  }\n\n  /**\n   * Create source for command variables\n   */\n  static createCommandSource(\n    isMultiLine: boolean = false\n  ): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'command',\n      true, // Commands typically have interpolation\n      isMultiLine\n    );\n  }\n\n  /**\n   * Create source for code variables\n   */\n  static createCodeSource(\n    isMultiLine: boolean = true // Code is typically multiline\n  ): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'code',\n      true, // Code may have interpolation\n      isMultiLine\n    );\n  }\n\n  /**\n   * Create source for path variables\n   */\n  static createPathSource(\n    hasInterpolation: boolean = false\n  ): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'path',\n      hasInterpolation,\n      false, // Paths are typically single line\n      'brackets'\n    );\n  }\n\n  /**\n   * Create source for reference variables\n   */\n  static createReferenceSource(): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'reference',\n      false, // References don't have interpolation\n      false\n    );\n  }\n}","/**\n * Variable Type Guards\n * \n * Runtime type checking and TypeScript type narrowing functions for all variable types.\n */\n\nimport {\n  Variable,\n  VariableTypeDiscriminator,\n  SimpleTextVariable,\n  InterpolatedTextVariable,\n  TemplateVariable,\n  FileContentVariable,\n  SectionContentVariable,\n  ObjectVariable,\n  ArrayVariable,\n  ComputedVariable,\n  CommandResultVariable,\n  PathVariable,\n  ImportedVariable,\n  ExecutableVariable,\n  PipelineInputVariable,\n  PrimitiveVariable,\n  TextLikeVariable,\n  StructuredVariable,\n  ExternalVariable,\n  StructuredValueVariable\n} from './VariableTypes';\n\n// =========================================================================\n// INDIVIDUAL TYPE GUARDS\n// =========================================================================\n\n/**\n * Type guard for SimpleTextVariable\n */\nexport function isSimpleText(variable: Variable): variable is SimpleTextVariable {\n  return variable.type === 'simple-text';\n}\n\n/**\n * Type guard for InterpolatedTextVariable\n */\nexport function isInterpolatedText(variable: Variable): variable is InterpolatedTextVariable {\n  return variable.type === 'interpolated-text';\n}\n\n/**\n * Type guard for TemplateVariable\n */\nexport function isTemplate(variable: Variable): variable is TemplateVariable {\n  return variable.type === 'template';\n}\n\n/**\n * Type guard for FileContentVariable\n */\nexport function isFileContent(variable: Variable): variable is FileContentVariable {\n  return variable.type === 'file-content';\n}\n\n/**\n * Type guard for SectionContentVariable\n */\nexport function isSectionContent(variable: Variable): variable is SectionContentVariable {\n  return variable.type === 'section-content';\n}\n\n/**\n * Type guard for ObjectVariable\n */\nexport function isObject(variable: Variable): variable is ObjectVariable {\n  return variable.type === 'object';\n}\n\n/**\n * Type guard for ArrayVariable\n */\nexport function isArray(variable: Variable): variable is ArrayVariable {\n  return variable.type === 'array';\n}\n\n/**\n * Type guard for ComputedVariable\n */\nexport function isComputed(variable: Variable): variable is ComputedVariable {\n  return variable.type === 'computed';\n}\n\n/**\n * Type guard for CommandResultVariable\n */\nexport function isCommandResult(variable: Variable): variable is CommandResultVariable {\n  return variable.type === 'command-result';\n}\n\n/**\n * Type guard for PathVariable\n */\nexport function isPath(variable: Variable): variable is PathVariable {\n  return variable.type === 'path';\n}\n\n/**\n * Type guard for ImportedVariable\n */\nexport function isImported(variable: Variable): variable is ImportedVariable {\n  return variable.type === 'imported';\n}\n\n/**\n * Type guard for ExecutableVariable\n */\nexport function isExecutable(variable: Variable): variable is ExecutableVariable {\n  return variable.type === 'executable';\n}\n\n/**\n * Type guard for PipelineInputVariable\n */\nexport function isPipelineInput(variable: Variable): variable is PipelineInputVariable {\n  return variable.type === 'pipeline-input';\n}\n\n/**\n * Type guard for StructuredValueVariable\n */\nexport function isStructuredValueVariable(variable: Variable): variable is StructuredValueVariable {\n  return variable.type === 'structured';\n}\n\n/**\n * Type guard for PrimitiveVariable\n */\nexport function isPrimitive(variable: Variable): variable is PrimitiveVariable {\n  return variable.type === 'primitive';\n}\n\n\n// =========================================================================\n// COMPOSITE TYPE GUARDS\n// =========================================================================\n\n/**\n * Check if variable contains text-like content\n */\nexport function isTextLike(variable: Variable): variable is TextLikeVariable {\n  return isSimpleText(variable) || \n         isInterpolatedText(variable) || \n         isTemplate(variable) || \n         isFileContent(variable) || \n         isSectionContent(variable) ||\n         isCommandResult(variable);\n}\n\n/**\n * Check if variable contains structured data\n */\nexport function isStructured(variable: Variable): variable is StructuredVariable {\n  return isObject(variable) || isArray(variable) || isStructuredValueVariable(variable);\n}\n\n/**\n * Check if variable was created from external content\n */\nexport function isExternal(variable: Variable): variable is ExternalVariable {\n  return isFileContent(variable) || \n         isSectionContent(variable) || \n         isImported(variable) || \n         isCommandResult(variable) ||\n         isComputed(variable);\n}\n\n// =========================================================================\n// UTILITY TYPE GUARDS\n// =========================================================================\n\n/**\n * Type guard class for organized access to all type checking functions\n */\nexport class VariableTypeGuards {\n  // Individual type guards\n  static isSimpleText = isSimpleText;\n  static isInterpolatedText = isInterpolatedText;\n  static isTemplate = isTemplate;\n  static isFileContent = isFileContent;\n  static isSectionContent = isSectionContent;\n  static isObject = isObject;\n  static isArray = isArray;\n  static isComputed = isComputed;\n  static isCommandResult = isCommandResult;\n  static isPath = isPath;\n  static isImported = isImported;\n  static isExecutable = isExecutable;\n  static isPipelineInput = isPipelineInput;\n  static isStructuredValue = isStructuredValueVariable;\n  static isPrimitive = isPrimitive;\n\n  // Composite type guards\n  static isTextLike = isTextLike;\n  static isStructured = isStructured;\n  static isExternal = isExternal;\n\n  /**\n   * Check if variable has a specific type discriminator\n   */\n  static hasType(variable: Variable, type: VariableTypeDiscriminator): boolean {\n    return variable.type === type;\n  }\n\n  /**\n   * Get all type discriminators that match the variable\n   */\n  static getMatchingTypes(variable: Variable): VariableTypeDiscriminator[] {\n    const types: VariableTypeDiscriminator[] = [variable.type];\n    \n    // Add composite type categories\n    if (this.isTextLike(variable)) {\n      types.push('simple-text'); // Representing text-like category\n    }\n    \n    if (this.isStructured(variable)) {\n      types.push('object'); // Representing structured category\n    }\n    \n    if (this.isExternal(variable)) {\n      types.push('imported'); // Representing external category\n    }\n    \n    return types;\n  }\n\n  /**\n   * Validate that a variable matches expected type\n   */\n  static validateType(\n    variable: Variable, \n    expectedType: VariableTypeDiscriminator\n  ): boolean {\n    return variable.type === expectedType;\n  }\n\n  /**\n   * Check if variable is of any of the specified types\n   */\n  static isAnyType(\n    variable: Variable, \n    types: VariableTypeDiscriminator[]\n  ): boolean {\n    return types.includes(variable.type);\n  }\n\n  /**\n   * Filter variables by type\n   */\n  static filterByType<T extends Variable>(\n    variables: Variable[],\n    guard: (variable: Variable) => variable is T\n  ): T[] {\n    return variables.filter(guard);\n  }\n\n  /**\n   * Find first variable of specified type\n   */\n  static findByType<T extends Variable>(\n    variables: Variable[],\n    guard: (variable: Variable) => variable is T\n  ): T | undefined {\n    return variables.find(guard);\n  }\n\n  /**\n   * Count variables by type\n   */\n  static countByType(\n    variables: Variable[],\n    type: VariableTypeDiscriminator\n  ): number {\n    return variables.filter(v => v.type === type).length;\n  }\n\n  /**\n   * Group variables by their types\n   */\n  static groupByType(variables: Variable[]): Map<VariableTypeDiscriminator, Variable[]> {\n    const groups = new Map<VariableTypeDiscriminator, Variable[]>();\n    \n    for (const variable of variables) {\n      const existing = groups.get(variable.type) || [];\n      existing.push(variable);\n      groups.set(variable.type, existing);\n    }\n    \n    return groups;\n  }\n}\n\n// =========================================================================\n// PERFORMANCE OPTIMIZED TYPE CHECKING\n// =========================================================================\n\n/**\n * Fast type checking utilities for performance-critical paths\n */\nexport class FastTypeGuards {\n  /**\n   * Fast check for text types (most common)\n   */\n  static isAnyTextType(variable: Variable): boolean {\n    const type = variable.type;\n    return type === 'simple-text' || \n           type === 'interpolated-text' || \n           type === 'template' ||\n           type === 'file-content' ||\n           type === 'section-content' ||\n           type === 'command-result';\n  }\n\n  /**\n   * Fast check for data types\n   */\n  static isAnyDataType(variable: Variable): boolean {\n    const type = variable.type;\n    return type === 'object' || \n           type === 'array' || \n           type === 'computed' || \n           type === 'primitive';\n  }\n\n  /**\n   * Fast check for complex types that might need special handling\n   */\n  static isComplexType(variable: Variable): boolean {\n    const type = variable.type;\n    return type === 'imported' || \n           type === 'executable' || \n           type === 'pipeline-input' ||\n           type === 'path';\n  }\n\n  /**\n   * Check if variable type requires lazy evaluation\n   */\n  static requiresLazyEvaluation(variable: Variable): boolean {\n    return isTemplate(variable) || \n           isPipelineInput(variable) ||\n           (isImported(variable) && variable.metadata?.isComplex);\n  }\n}\n","/**\n * Advanced Type Detection\n * \n * Specialized type detection logic for complex scenarios including imported variables,\n * executable detection, and effective type resolution.\n */\n\nimport {\n  Variable,\n  VariableTypeDiscriminator,\n  ImportedVariable\n} from './VariableTypes';\nimport { isImported, isExecutable } from './TypeGuards';\n\n// =========================================================================\n// ADVANCED TYPE DETECTION CLASS\n// =========================================================================\n\n/**\n * Advanced type detection utilities for complex variable scenarios\n */\nexport class AdvancedTypeDetection {\n  \n  /**\n   * Get the effective type of a variable, considering imported variables\n   * This resolves the \"real\" type by looking through import wrappers\n   */\n  static getEffectiveType(variable: Variable): VariableTypeDiscriminator {\n    if (isImported(variable)) {\n      return (variable as ImportedVariable).originalType;\n    }\n    return variable.type;\n  }\n\n  /**\n   * Check if variable is an executable, including imported executables\n   * This handles the complex case where an executable might be imported\n   */\n  static isExecutableVariable(variable: Variable): boolean {\n    if (isExecutable(variable)) return true;\n    if (isImported(variable)) {\n      const imported = variable as ImportedVariable;\n      return imported.originalType === 'executable' || \n             imported.metadata?.originalType === 'executable';\n    }\n    return false;\n  }\n\n  /**\n   * Detect if variable contains nested directive complexity\n   * This is used to determine if a variable needs special handling\n   */\n  static detectComplexVariable(variable: Variable): boolean {\n    // Check metadata first\n    if (variable.metadata?.isComplex) {\n      return true;\n    }\n\n    // Type-specific complexity detection\n    switch (variable.type) {\n      case 'object':\n      case 'array':\n        return (variable as any).isComplex || false;\n      \n      case 'template':\n        return Array.isArray(variable.value); // Lazy-evaluated templates are complex\n      \n      case 'imported':\n        return this.detectComplexVariable(this.resolveImportedVariable(variable));\n      \n      case 'pipeline-input':\n        return true; // Pipeline inputs are inherently complex\n      \n      default:\n        return false;\n    }\n  }\n\n  /**\n   * Follow import chains to resolve the original variable\n   * This handles nested imports and circular references\n   */\n  static resolveImportChain(variable: Variable, maxDepth: number = 10): Variable {\n    let current = variable;\n    let depth = 0;\n    const seen = new Set<string>();\n\n    while (isImported(current) && depth < maxDepth) {\n      const imported = current as ImportedVariable;\n      const key = `${imported.importSource.path}:${imported.importSource.variableName}`;\n      \n      // Prevent circular references\n      if (seen.has(key)) {\n        break;\n      }\n      seen.add(key);\n\n      // In a real implementation, this would resolve the import\n      // For now, we'll break the chain\n      break;\n    }\n\n    return current;\n  }\n\n  /**\n   * Resolve an imported variable to its underlying type\n   */\n  static resolveImportedVariable(variable: Variable): Variable {\n    if (!isImported(variable)) {\n      return variable;\n    }\n\n    const imported = variable as ImportedVariable;\n    \n    // Create a synthetic variable representing the imported content\n    return {\n      type: imported.originalType,\n      name: imported.name,\n      value: imported.value,\n      source: imported.source,\n      createdAt: imported.createdAt,\n      modifiedAt: imported.modifiedAt,\n      metadata: imported.metadata\n    } as Variable;\n  }\n\n  /**\n   * Detect if variable type matches a pattern\n   */\n  static matchesTypePattern(\n    variable: Variable, \n    pattern: VariableTypeDiscriminator | VariableTypeDiscriminator[] | RegExp\n  ): boolean {\n    const effectiveType = this.getEffectiveType(variable);\n\n    if (pattern instanceof RegExp) {\n      return pattern.test(effectiveType);\n    }\n\n    if (Array.isArray(pattern)) {\n      return pattern.includes(effectiveType);\n    }\n\n    return effectiveType === pattern;\n  }\n\n  /**\n   * Check if variable requires special evaluation handling\n   */\n  static requiresSpecialEvaluation(variable: Variable): boolean {\n    const effectiveType = this.getEffectiveType(variable);\n    \n    return (\n      effectiveType === 'template' ||\n      effectiveType === 'executable' ||\n      effectiveType === 'pipeline-input' ||\n      effectiveType === 'computed' ||\n      this.detectComplexVariable(variable)\n    );\n  }\n\n  /**\n   * Determine evaluation priority for variable resolution\n   * Lower numbers = higher priority\n   */\n  static getEvaluationPriority(variable: Variable): number {\n    const effectiveType = this.getEffectiveType(variable);\n    \n    switch (effectiveType) {\n      case 'primitive':\n      case 'simple-text':\n        return 1; // Highest priority - simple values\n\n      case 'interpolated-text':\n      case 'file-content':\n      case 'section-content':\n        return 2; // Medium-high priority - needs resolution but straightforward\n\n      case 'object':\n      case 'array':\n        return variable.isComplex ? 4 : 3; // Priority based on complexity\n\n      case 'command-result':\n      case 'computed':\n        return 5; // Lower priority - requires execution\n\n      case 'template':\n      case 'executable':\n        return 6; // Low priority - complex evaluation\n\n      case 'pipeline-input':\n        return 7; // Lowest priority - pipeline dependency\n\n      case 'imported':\n        // Recursively determine priority of imported content\n        const resolved = this.resolveImportedVariable(variable);\n        return this.getEvaluationPriority(resolved) + 1; // Slightly lower than original\n\n      default:\n        return 5; // Default medium priority\n    }\n  }\n\n  /**\n   * Check if variable has lazy evaluation semantics\n   */\n  static hasLazyEvaluation(variable: Variable): boolean {\n    const effectiveType = this.getEffectiveType(variable);\n    \n    return (\n      effectiveType === 'template' ||\n      effectiveType === 'pipeline-input' ||\n      (effectiveType === 'executable' && variable.type !== 'imported') ||\n      this.detectComplexVariable(variable)\n    );\n  }\n\n  /**\n   * Detect if variable contains interpolation points\n   */\n  static hasInterpolation(variable: Variable): boolean {\n    switch (variable.type) {\n      case 'interpolated-text':\n        return variable.interpolationPoints.length > 0;\n      \n      case 'template':\n        return true; // Templates always have interpolation\n      \n      case 'imported':\n        return this.hasInterpolation(this.resolveImportedVariable(variable));\n      \n      default:\n        return variable.source.hasInterpolation;\n    }\n  }\n\n  /**\n   * Get variable dependencies for evaluation ordering\n   */\n  static getVariableDependencies(variable: Variable): string[] {\n    const dependencies: string[] = [];\n\n    switch (variable.type) {\n      case 'interpolated-text':\n        // Extract variable names from interpolation points\n        variable.interpolationPoints.forEach(point => {\n          const matches = point.expression.match(/@([a-zA-Z_][a-zA-Z0-9_]*)/g);\n          if (matches) {\n            dependencies.push(...matches.map(m => m.substring(1)));\n          }\n        });\n        break;\n\n      case 'template':\n        if (typeof variable.value === 'string') {\n          // Extract dependencies from template string\n          const matches = variable.value.match(/\\{\\{([^}]+)\\}\\}/g);\n          if (matches) {\n            matches.forEach(match => {\n              const varName = match.slice(2, -2).trim().split('.')[0];\n              if (varName && !dependencies.includes(varName)) {\n                dependencies.push(varName);\n              }\n            });\n          }\n        }\n        break;\n\n      case 'imported':\n        // Dependencies are resolved at import time\n        break;\n\n      default:\n        // For other types, check source interpolation flag\n        if (variable.source.hasInterpolation && typeof variable.value === 'string') {\n          const matches = variable.value.match(/@([a-zA-Z_][a-zA-Z0-9_]*)/g);\n          if (matches) {\n            dependencies.push(...matches.map(m => m.substring(1)));\n          }\n        }\n    }\n\n    return [...new Set(dependencies)]; // Remove duplicates\n  }\n\n  /**\n   * Check if variable creates a circular dependency\n   */\n  static hasCircularDependency(\n    variable: Variable,\n    allVariables: Map<string, Variable>,\n    visited: Set<string> = new Set()\n  ): boolean {\n    if (visited.has(variable.name)) {\n      return true; // Circular dependency detected\n    }\n\n    visited.add(variable.name);\n    const dependencies = this.getVariableDependencies(variable);\n\n    for (let i = 0; i < dependencies.length; i++) {\n      const depName = dependencies[i];\n      const depVariable = allVariables.get(depName);\n      if (depVariable && this.hasCircularDependency(depVariable, allVariables, visited)) {\n        return true;\n      }\n    }\n\n    visited.delete(variable.name);\n    return false;\n  }\n\n  /**\n   * Determine if variable can be safely serialized\n   */\n  static isSerializable(variable: Variable): boolean {\n    const effectiveType = this.getEffectiveType(variable);\n    \n    switch (effectiveType) {\n      case 'simple-text':\n      case 'interpolated-text':\n      case 'file-content':\n      case 'section-content':\n      case 'command-result':\n      case 'primitive':\n        return true;\n\n      case 'object':\n      case 'array':\n        return !this.detectComplexVariable(variable);\n\n      case 'path':\n        return true; // Path metadata is serializable\n\n      case 'template':\n      case 'executable':\n      case 'pipeline-input':\n      case 'computed':\n        return false; // These require execution context\n\n      case 'imported':\n        return this.isSerializable(this.resolveImportedVariable(variable));\n\n      default:\n        return false;\n    }\n  }\n\n  /**\n   * Get variable complexity score for performance optimization\n   */\n  static getComplexityScore(variable: Variable): number {\n    let score = 0;\n    const effectiveType = this.getEffectiveType(variable);\n\n    // Base complexity by type\n    switch (effectiveType) {\n      case 'primitive':\n      case 'simple-text':\n        score += 1;\n        break;\n      case 'interpolated-text':\n        score += 2 + (variable as any).interpolationPoints?.length || 0;\n        break;\n      case 'template':\n        score += 3;\n        if (Array.isArray(variable.value)) score += 2; // Lazy evaluation\n        break;\n      case 'object':\n      case 'array':\n        score += 2;\n        if (variable.isComplex) score += 3;\n        break;\n      case 'executable':\n      case 'computed':\n        score += 5;\n        break;\n      case 'pipeline-input':\n        score += 4;\n        break;\n      default:\n        score += 2;\n    }\n\n    // Additional complexity factors\n    if (this.hasInterpolation(variable)) score += 1;\n    if (this.detectComplexVariable(variable)) score += 2;\n    if (variable.metadata?.isImported) score += 1;\n    \n    const dependencies = this.getVariableDependencies(variable);\n    score += dependencies.length * 0.5;\n\n    return Math.round(score);\n  }\n}","/**\n * Legacy Compatibility System\n * \n * Conversion between old and new variable systems during the transition period.\n * This module handles bidirectional conversion while preserving semantics.\n */\n\nimport {\n  Variable,\n  VariableTypeDiscriminator,\n  VariableSource,\n  VariableMetadata\n} from './VariableTypes';\n\n// =========================================================================\n// LEGACY TYPES (for compatibility)\n// =========================================================================\n\n/**\n * Legacy variable type structure\n */\ninterface LegacyVariable {\n  type: string;\n  name: string;\n  value: any;\n  metadata?: any;\n}\n\n// =========================================================================\n// LEGACY CONVERSION CLASS\n// =========================================================================\n\n/**\n * Handles conversion between new and legacy variable systems\n */\nexport class LegacyVariableConverter {\n\n  /**\n   * Convert a new variable to legacy format\n   * This ensures backward compatibility during transition\n   */\n  static toLegacyVariable(variable: Variable): LegacyVariable {\n    return {\n      type: this.mapToLegacyType(variable.type),\n      name: variable.name,\n      value: this.extractLegacyValue(variable),\n      metadata: variable.metadata\n    };\n  }\n\n  /**\n   * Convert a legacy variable to new format\n   * This allows importing old variable definitions\n   */\n  static fromLegacyVariable(\n    legacy: LegacyVariable,\n    source?: VariableSource\n  ): Variable {\n    const defaultSource: VariableSource = source || {\n      directive: 'var',\n      syntax: 'reference',\n      hasInterpolation: false,\n      isMultiLine: false\n    };\n\n    const newType = this.mapFromLegacyType(legacy.type);\n    const baseVariable = {\n      name: legacy.name,\n      createdAt: Date.now(),\n      modifiedAt: Date.now(),\n      source: defaultSource,\n      metadata: legacy.metadata\n    };\n\n    // Create appropriate variable type based on legacy type\n    switch (newType) {\n      case 'simple-text':\n        return {\n          type: 'simple-text',\n          value: String(legacy.value),\n          ...baseVariable\n        };\n\n      case 'object':\n        return {\n          type: 'object',\n          value: legacy.value || {},\n          isComplex: false,\n          ...baseVariable\n        };\n\n      case 'array':\n        return {\n          type: 'array',\n          value: Array.isArray(legacy.value) ? legacy.value : [],\n          isComplex: false,\n          ...baseVariable\n        };\n\n      case 'command-result':\n        return {\n          type: 'command-result',\n          value: String(legacy.value),\n          command: legacy.metadata?.command || '',\n          ...baseVariable\n        };\n\n      case 'path':\n        return {\n          type: 'path',\n          value: {\n            resolvedPath: legacy.value?.resolvedPath || String(legacy.value),\n            originalPath: legacy.value?.originalPath || String(legacy.value),\n            isURL: legacy.value?.isURL || false,\n            isAbsolute: legacy.value?.isAbsolute || false\n          },\n          ...baseVariable\n        };\n\n      case 'imported':\n        return {\n          type: 'imported',\n          value: legacy.value,\n          originalType: legacy.metadata?.originalType || 'simple-text',\n          importSource: {\n            path: legacy.metadata?.importPath || '',\n            isModule: legacy.metadata?.isModule || false,\n            variableName: legacy.name\n          },\n          ...baseVariable\n        };\n\n      case 'executable':\n        return {\n          type: 'executable',\n          value: {\n            type: legacy.value?.type || 'command',\n            template: legacy.value?.commandTemplate || legacy.value?.codeTemplate || '',\n            language: legacy.value?.language\n          },\n          paramNames: legacy.value?.paramNames || [],\n          ...baseVariable\n        };\n\n      default:\n        // Fallback to simple text\n        return {\n          type: 'simple-text',\n          value: String(legacy.value),\n          ...baseVariable\n        };\n    }\n  }\n\n  /**\n   * Map new variable types to legacy types\n   * This preserves the old type hierarchy during transition\n   */\n  private static mapToLegacyType(type: VariableTypeDiscriminator): string {\n    switch (type) {\n      case 'simple-text':\n      case 'interpolated-text':\n      case 'template':\n      case 'file-content':\n      case 'section-content':\n        return 'text';\n      \n      case 'object':\n      case 'array':\n      case 'computed':\n      case 'pipeline-input':\n      case 'primitive':\n        return 'data';\n      \n      case 'path':\n        return 'path';\n      \n      case 'command-result':\n        return 'command';\n      \n      case 'imported':\n        return 'import';\n      \n      case 'executable':\n        return 'executable';\n      \n      default:\n        return 'data'; // Fallback\n    }\n  }\n\n  /**\n   * Map legacy types to new variable types\n   */\n  private static mapFromLegacyType(legacyType: string): VariableTypeDiscriminator {\n    switch (legacyType.toLowerCase()) {\n      case 'text':\n        return 'simple-text';\n      case 'data':\n        return 'object'; // Default data type\n      case 'path':\n        return 'path';\n      case 'command':\n        return 'command-result';\n      case 'import':\n        return 'imported';\n      case 'executable':\n        return 'executable';\n      default:\n        return 'simple-text'; // Fallback\n    }\n  }\n\n  /**\n   * Extract value in legacy format\n   * This ensures the value structure matches legacy expectations\n   */\n  private static extractLegacyValue(variable: Variable): any {\n    switch (variable.type) {\n      case 'simple-text':\n      case 'interpolated-text':\n      case 'template':\n      case 'file-content':\n      case 'section-content':\n      case 'command-result':\n        return variable.value;\n      \n      case 'object':\n      case 'array':\n      case 'computed':\n      case 'primitive':\n        return variable.value;\n      \n      case 'path':\n        return variable.value;\n      \n      case 'imported':\n        return variable.value;\n      \n      case 'executable':\n        return {\n          type: variable.value.type,\n          paramNames: variable.paramNames,\n          ...(variable.value.type === 'command' \n            ? { commandTemplate: variable.value.template }\n            : { codeTemplate: variable.value.template, language: variable.value.language })\n        };\n      \n      case 'pipeline-input':\n        return variable.value;\n      \n      default:\n        return variable.value;\n    }\n  }\n\n  /**\n   * Check if a variable has legacy type information\n   */\n  static hasLegacyType(variable: any): boolean {\n    return 'type' in variable && \n           typeof variable.type === 'string' && \n           ['text', 'data', 'path', 'command', 'import', 'executable'].includes(variable.type);\n  }\n\n  /**\n   * Migrate a collection of legacy variables\n   */\n  static migrateLegacyVariables(\n    legacyVariables: LegacyVariable[],\n    defaultSource?: VariableSource\n  ): Variable[] {\n    return legacyVariables.map(legacy => \n      this.fromLegacyVariable(legacy, defaultSource)\n    );\n  }\n\n  /**\n   * Convert a collection of new variables to legacy format\n   */\n  static convertToLegacyFormat(variables: Variable[]): LegacyVariable[] {\n    return variables.map(variable => this.toLegacyVariable(variable));\n  }\n\n  /**\n   * Validate that conversion is lossless\n   */\n  static validateConversion(\n    original: Variable, \n    converted: LegacyVariable, \n    reconverted: Variable\n  ): { valid: boolean; issues: string[] } {\n    const issues: string[] = [];\n\n    // Check name preservation\n    if (original.name !== reconverted.name) {\n      issues.push(`Name mismatch: ${original.name} -> ${reconverted.name}`);\n    }\n\n    // Check value preservation (basic check)\n    const originalValue = this.extractLegacyValue(original);\n    const reconvertedValue = this.extractLegacyValue(reconverted);\n    \n    if (JSON.stringify(originalValue) !== JSON.stringify(reconvertedValue)) {\n      issues.push('Value structure changed during conversion');\n    }\n\n    // Check type mapping\n    const expectedLegacyType = this.mapToLegacyType(original.type);\n    if (converted.type !== expectedLegacyType) {\n      issues.push(`Type mapping error: ${original.type} -> ${converted.type} (expected ${expectedLegacyType})`);\n    }\n\n    return {\n      valid: issues.length === 0,\n      issues\n    };\n  }\n\n  /**\n   * Create a migration report for a set of variables\n   */\n  static createMigrationReport(\n    legacyVariables: LegacyVariable[]\n  ): {\n    total: number;\n    byType: Record<string, number>;\n    complexVariables: string[];\n    warnings: string[];\n  } {\n    const report = {\n      total: legacyVariables.length,\n      byType: {} as Record<string, number>,\n      complexVariables: [] as string[],\n      warnings: [] as string[]\n    };\n\n    legacyVariables.forEach(variable => {\n      // Count by type\n      report.byType[variable.type] = (report.byType[variable.type] || 0) + 1;\n\n      // Check for complex cases\n      if (variable.metadata?.isComplex) {\n        report.complexVariables.push(variable.name);\n      }\n\n      // Check for potential issues\n      if (!this.mapFromLegacyType(variable.type)) {\n        report.warnings.push(`Unknown legacy type: ${variable.type} for variable ${variable.name}`);\n      }\n\n      if (variable.value && typeof variable.value === 'object' && 'originalType' in variable.value) {\n        report.warnings.push(`Variable ${variable.name} may have nested type information`);\n      }\n    });\n\n    return report;\n  }\n\n  /**\n   * Attempt automatic type refinement during conversion\n   */\n  static refineTypeFromValue(\n    legacyVariable: LegacyVariable\n  ): VariableTypeDiscriminator {\n    const value = legacyVariable.value;\n    \n    // If legacy type is 'data', try to be more specific\n    if (legacyVariable.type === 'data') {\n      if (typeof value === 'number' || typeof value === 'boolean' || value === null) {\n        return 'primitive';\n      } else if (Array.isArray(value)) {\n        return 'array';\n      } else if (typeof value === 'object' && value !== null) {\n        return 'object';\n      }\n    }\n\n    // If legacy type is 'text', check for special cases\n    if (legacyVariable.type === 'text') {\n      if (typeof value === 'string') {\n        if (value.includes('{{') && value.includes('}}')) {\n          return 'template';\n        } else if (legacyVariable.metadata?.hasInterpolation) {\n          return 'interpolated-text';\n        } else if (legacyVariable.metadata?.filePath) {\n          return legacyVariable.metadata.sectionName ? 'section-content' : 'file-content';\n        }\n      }\n    }\n\n    // Fall back to standard mapping\n    return this.mapFromLegacyType(legacyVariable.type);\n  }\n}","/**\n * Variable System Module\n * \n * Unified export of the refactored variable system components.\n * This module provides the complete variable system API while maintaining\n * backward compatibility with the previous monolithic structure.\n */\n\n// =========================================================================\n// TYPE DEFINITIONS\n// =========================================================================\n\nexport * from './variable/VariableTypes';\n\n// =========================================================================\n// METADATA SYSTEM\n// =========================================================================\n\nexport * from './variable/VariableMetadata';\n\n// =========================================================================\n// TYPE GUARDS\n// =========================================================================\n\nexport * from './variable/TypeGuards';\n\n// =========================================================================\n// FACTORY FUNCTIONS\n// =========================================================================\n\nexport * from './variable/VariableFactories';\n\n// =========================================================================\n// ADVANCED TYPE DETECTION\n// =========================================================================\n\nexport * from './variable/AdvancedTypeDetection';\n\n// =========================================================================\n// LEGACY COMPATIBILITY\n// =========================================================================\n\nexport * from './variable/LegacyCompatibility';\n\n// =========================================================================\n// CONVENIENT RE-EXPORTS\n// =========================================================================\n\n// Re-export the main Variable type for easy access\nexport type { Variable } from './variable/VariableTypes';\n\n// Re-export the discriminator type\nexport type { VariableTypeDiscriminator } from './variable/VariableTypes';\n\n// Re-export commonly used factory methods\nexport { VariableFactory } from './variable/VariableFactories';\n\n// Re-export commonly used type guards\nexport { VariableTypeGuards } from './variable/TypeGuards';\n\n// Re-export advanced detection\nexport { AdvancedTypeDetection } from './variable/AdvancedTypeDetection';\n\n// Re-export legacy converter\nexport { LegacyVariableConverter } from './variable/LegacyCompatibility';\n\n// Re-export metadata utilities\nexport { VariableMetadataUtils, VariableSourceHelpers } from './variable/VariableMetadata';\n\n// =========================================================================\n// BACKWARD COMPATIBILITY FUNCTIONS\n// =========================================================================\n\nimport { Variable } from './variable/VariableTypes';\nimport { LegacyVariableConverter } from './variable/LegacyCompatibility';\nimport { AdvancedTypeDetection } from './variable/AdvancedTypeDetection';\n\n/**\n * Convert a new variable to legacy format (backward compatibility)\n */\nexport function toLegacyVariable(variable: Variable): any {\n  return LegacyVariableConverter.toLegacyVariable(variable);\n}\n\n/**\n * Check for legacy variable types in imported variables (backward compatibility)\n */\nexport function hasLegacyType(variable: Variable): boolean {\n  return LegacyVariableConverter.hasLegacyType(variable);\n}\n\n/**\n * Check if variable is an executable, including imported executables (backward compatibility)\n */\nexport function isExecutableVariable(variable: Variable): boolean {\n  return AdvancedTypeDetection.isExecutableVariable(variable);\n}\n\n/**\n * Get the effective type of a variable, considering imported variables (backward compatibility)\n */\nexport function getEffectiveType(variable: Variable) {\n  return AdvancedTypeDetection.getEffectiveType(variable);\n}"]}