taggedjs 2.3.30 → 2.4.10

package/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.js","mappings":";;;;;;;;;AAAU;;;;;;;;;;;;;;;ACAH;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B;AAC9B,8CAA8C;AAC9C;;;;;;;;;;;;;;;;;;;;;;;;;;;AC7C+C;AACR;AACsC;AACF;AACN;AACR;AACI;AACd;AAC5C;AACA;AACP;AACO;AACA;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA,iBAAiB;AACjB,oBAAoB;AACpB,oBAAoB;AACpB;AACA,oCAAoC;AACpC;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,4DAAgB;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,mBAAmB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oEAAoE,4BAA4B;AAChG;AACA,aAAa;AACb;AACA;AACA,yEAAyE,4BAA4B;AACrG;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,UAAU;AAC9B;AACA,KAAK;AACL;AACA,0GAA0G;AAC1G,gCAAgC;AAChC;AACA,qBAAqB;AACrB;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA,sBAAsB,kFAAmB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2EAA2E,EAAE,eAAe,EAAE,OAAO;AACrG;AACA;AACA;AACA,SAAS;AACT,8BAA8B,sEAAiB;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE;AACnE;AACA;AACA;AACA,eAAe,gEAAU;AACzB,gBAAgB,SAAS;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,0EAAe;AACnD,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,sBAAsB;AAC5C,SAAS;AACT;AACA;AACA;AACA,kBAAkB,sBAAsB;AACxC;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8EAA8E,gBAAgB;AAC9F;AACA,gBAAgB,gBAAgB,EAAE,uEAAkB;AACpD;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,yEAAmB;AAC/B,2EAA2E,gBAAgB;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,mBAAmB,oDAAW;AAC9B;AACA,4BAA4B,mEAAa;AACzC;AACA;AACA;AACA,2CAA2C,YAAY;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D;AAC1D,uBAAuB,2DAAc;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,8DAAiB;AACzB;AACA;AACA,wBAAwB;AACxB;AACA;;;;;;;;;;;;;;;;;;ACxV4C;AAC6B;AAClE;AACP;AACA;AACA;AACA;AACA;AACA,sBAAsB,+EAA+E;AACrG;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,kDAAkD;AAClD,4CAA4C;AAC5C,6BAA6B,yDAAS,SAAS;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa,0DAAa;AAC1B,4CAA4C,yDAAS;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,0DAAa;AACzB;AACA;AACA,YAAY,2DAAc;AAC1B;AACA,mBAAmB,yDAAS;AAC5B;AACA,YAAY,uDAAU;AACtB;AACA;AACA,eAAe,yDAAS;AACxB,KAAK;AACL;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;AC9D+E;AACpC;AACQ;AACM;AAClD;AACP;AACA;AACA,mBAAmB;AACnB;AACA;AACA;AACA;AACA,mBAAmB,+EAA+E;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,uCAAuC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,2DAAe;AACvB;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,2DAAe;AACvB;AACA,0BAA0B,oDAAM;AAChC;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,0DAAc;AAClB,sCAAsC,gEAAU;AAChD;AACA,QAAQ,sEAAgB;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;AC7EoC;AAC7B,2BAA2B,6CAAO;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACb6C;AACkB;AAC/D;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,4EAAgB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,0DAAa;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA,wBAAwB;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;;;;;;;;;;;;;;;;AC5CA;AAC+D;AACxD;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C;AAC/C,aAAa;AACb;AACA,+BAA+B;AAC/B;AACA,IAAI,4EAAgB;AACpB;AACA;AACA;AACA,+CAA+C;AAC/C;AACA,YAAY,4EAAgB;AAC5B;AACA,SAAS;AACT;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;AC1CyE;AACtB;AAC6B;AACzE;AACP;AACA;AACA;AACA;AACA,qBAAqB,uDAAU;AAC/B,4BAA4B,KAAK,4BAA4B,sBAAsB;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,0DAAa;AACxC,6BAA6B,0DAAa;AAC1C;AACA;AACA,iBAAiB,gEAAU;AAC3B,gBAAgB,sEAAgB;AAChC;AACA;AACA;AACA;AACA,oCAAoC,2DAAc;AAClD;AACA,0BAA0B;AAC1B;AACA;AACA,QAAQ,sEAAgB;AACxB;AACA;AACA;AACA;AACA,gDAAgD;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,IAAI,2EAAqB;AACzB;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;AC5DO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,gBAAgB;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,iBAAiB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;AC7FO;AACP;AACA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;;;;;;;;;;;;;;;ACjBO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;;;;;;;;;;;;;;;ACfO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;;;;;;;;;;;;;;;;;AChBO;AACP;AACA,gDAAgD;AAChD;AACA;AACA,yBAAyB;AACzB;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;ACnB2C;AACI;AACgB;AAC/D;AACA;AACA;AACO;AACP,sCAAsC;AACtC,wDAAM;AACN;AACA;AACA;AACA,wCAAwC;AACxC,KAAK;AACL,CAAC;AACD;AACA;AACA,0BAA0B,4DAAa;AACvC;AACA;AACA,iCAAiC;AACjC;AACA,8CAA8C;AAC9C,KAAK;AACL;AACA;AACA,qBAAqB,oDAAM;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,4EAAgB;AACpB;AACA;AACA;AACA;AACA;AACA,YAAY,4EAAgB;AAC5B,SAAS;AACT;AACA;;;;;;;;;;;;;;;;;;AClD4C;AACrC;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,4BAA4B,wBAAwB;AACpD;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,0BAA0B;AAC1B;AACA;AACA,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B;AAC9B;AACA,qCAAqC;AACrC,yCAAyC;AACzC;AACA,SAAS;AACT;AACA,sBAAsB;AACtB;AACA;AACA;AACA,oBAAoB,yDAAS;AAC7B,gCAAgC;AAChC;AACO;AACP;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;;;;;;;;;;;;;;;ACpFkC;AAC3B;AACP,eAAe,2CAAG;AAClB;;;;;;;;;;;;;;;ACHO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACjB+D;AAC/D;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,4EAAgB;AACxB,sCAAsC;AACtC,KAAK;AACL;;;;;;;;;;;;;;;;AClB4D;AACrD;AACP;AACA,iBAAiB,iCAAiC;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,mCAAmC,EAAE,yEAAmB;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,eAAe,EAAE,yEAAmB;AAChE;AACA;AACA;AACA;AACA,wBAAwB,sDAAsD;AAC9E;AACA;AACA,aAAa;AACb;AACA,KAAK;AACL,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;ACxCgE;AACN;AACkB;AACjB;AAC3D;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,uDAAuD,EAAE,yFAA2B;AACpG;AACA;AACA;AACA,IAAI,6EAAqB;AACzB;AACA,aAAa;AACb;AACA;AACA;AACA,QAAQ,6EAAqB;AAC7B;AACA;AACA;AACA,KAAK;AACL;AACO;AACP,mBAAmB,uEAAsB;AACzC,0CAA0C,oDAAY,EAAE,sDAAc;AACtE;AACA;;;;;;;;;;;;;;;;;;;;;;;;ACjC6C;AACS;AACe;AACX;AACO;AACI;AAC9D;AACP,+BAA+B,WAAW,MAAM;AAChD;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA,mCAAmC,sDAAc,aAAa,sDAAc;AAC5E,iBAAiB,UAAU;AAC3B;AACA;AACA,sBAAsB,2DAAc,2BAA2B,uDAAU;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2EAA2E,gBAAgB;AAC3F,aAAa;AACb;AACO;AACP,EAAE,gBAAgB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,kFAAmB;AAC/B;AACA;AACA,QAAQ,kFAAmB;AAC3B,sBAAsB,WAAW;AACjC;AACA,SAAS;AACT;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA,oEAAoE;AACpE;AACA;AACA;AACA,qDAAqD;AACrD;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA,kCAAkC;AAClC;AACA,QAAQ,8EAAiB;AACzB;AACA;AACA,WAAW,mEAAgB;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;;;;;;;;;;;;;;;ACzGA;AACO,sGAAsG,WAAW,GAAG;AAC3H,eAAe,GAAG;AACX;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,GAAG;AACnD,KAAK;AACL,aAAa;AACb;;;;;;;;;;;;;;;;;;AChBO;AACP;AACA;AACO;AACP;AACA;AACO;AACP,+EAA+E;AAC/E;AACO;AACP;AACA;;;;;;;;;;;;;;;ACXO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,KAAK;AACL;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;AC5B2C;AAC3C;AACA;AACO;AACP;AACA;AACA,wDAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;;;;;ACf0C;AAC3C;AACA,IAAI,oDAAM;AACV;AACO;AACP,SAAS,oDAAM;AACf,QAAQ,oDAAM;AACd,oBAAoB;AACpB;AACA;AACA,wDAAM;AACN;AACA;AACA,CAAC;;;;;;;;;;;;;;;;;;ACbiD;AACD;AACoB;AACrE,wBAAwB;AACxB,kBAAkB;AAClB;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,+DAAc;AAC7B;AACA;AACA,yDAAyD;AACzD;AACA,8DAA8D,UAAU;AACxE;AACA;AACA;AACA;AACA,iCAAiC,8CAA8C;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,8DAAiB;AACzB;AACA;AACA;AACA,+BAA+B,kFAAmB;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,+DAAc;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACxH8C;AACkC;AACzE;AACP,QAAQ,2DAAc;AACtB,+BAA+B,uDAAY;AAC3C;AACA;AACA;AACA;AACA,mBAAmB,uDAAY;AAC/B;AACA;AACA,gBAAgB;AAChB;AACA,QAAQ,0DAAa;AACrB;AACA;AACA;AACA;AACA,mBAAmB,uDAAY;AAC/B;AACA,QAAQ,8DAAiB;AACzB,sBAAsB;AACtB;AACA,eAAe,uDAAY;AAC3B;;;;;;;;;;;;;;;;ACzB+D;AACxD;AACP;AACA;AACA,8CAA8C;AAC9C;AACA,gBAAgB;AAChB;AACA;AACA;AACA,kBAAkB,4EAAsB;AACxC,2BAA2B;AAC3B;;;;;;;;;;;;;;;;;;;ACZ4D;AACjB;AACoB;AACf;AACzC;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uIAAuI,MAAM;AAC7I;AACA;AACA;AACA,mCAAmC,yDAAU;AAC7C;AACA;AACA;AACA;AACA,sBAAsB,oDAAM;AAC5B;AACA;AACA;AACA;AACA,gBAAgB,yEAAiB;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,4EAAgB;AACpB;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;AC5C6E;AACJ;AACrB;AACJ;AACF;AACuB;AACrE;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,gCAAgC;AACjC;AACA,QAAQ,2DAAc;AACtB;AACA;AACA,QAAQ,0DAAa;AACrB;AACA;AACA,QAAQ,uDAAU;AAClB;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,iEAAe;AAClC;AACA,YAAY,0FAAuB;AACnC;AACA;AACA,IAAI,kFAAmB;AACvB;AACA;AACO;AACP;AACA;AACA;AACA;AACA,aAAa,0DAAa;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,sBAAsB;AACxC;AACA,KAAK;AACL;AACO;AACP;AACA;AACA;AACA;AACA,yBAAyB,yDAAU;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB,SAAS;AACT,sBAAsB,uDAAY;AAClC,iBAAiB;AACjB;AACA;AACA;;;;;;;;;;;;;;;;;;;ACxF8C;AACH;AACuB;AACE;AAC7D;AACP;AACA;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,+EAAe;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,gCAAgC,uDAAY,GAAG;AAC/C,QAAQ,iFAAkB;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,oDAAe;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC;AACnC;AACA;AACA;AACA,gDAAgD,kDAAkD;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACnGyD;AAClD;AACP;AACA,EAAE,uBAAuB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA,sFAAsF;AACtF,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,sEAAgB;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;;;;;;;;;;;;;;;;AChDuD;AACQ;AACxD;AACP;AACA,sEAAsE,yDAAS;AAC/E;AACA;AACA;AACA;AACA,yBAAyB,yDAAS;AAClC,KAAK;AACL;AACA;AACA;AACA,gCAAgC,4BAA4B;AAC5D;AACA,oBAAoB;AACpB;AACA;AACA;AACA,6BAA6B,yDAAS;AACtC,YAAY,4EAAgB;AAC5B;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,sBAAsB,KAAK;AAC3B;AACA;AACA;AACA,KAAK;AACL;AACA;;;;;;;;;;;;;;;;;AC3C4C;AACD;AAC3C;AACA,oDAAM;AACN;AACA;AACA;AACA;AACA;AACA,mBAAmB,oDAAM;AACzB;AACA;AACA;AACO;AACP;AACA;AACA;AACA,6BAA6B,yDAAS;AACtC;AACA;AACA;AACA;AACA,uBAAuB,oDAAM;AAC7B;AACA;AACA;AACA,mBAAmB,yDAAS;AAC5B,SAAS;AACT;AACA,KAAK;AACL;AACA;AACA,eAAe,uCAAuC;AACtD,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,oDAAM;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,iCAAiC,yDAAS,qBAAqB;AAC/D;AACA;AACA;AACA,oCAAoC;AACpC;AACA,kDAAkD,kBAAkB,EAAE,YAAY;AAClF,wBAAwB,IAAI;AAC5B;AACA;AACA;AACA,wDAAM;AACN;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA,uBAAuB,oDAAM;AAC7B;AACA;AACA;AACA,CAAC;AACD;AACA,mBAAmB,oDAAM;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACpF4D;AAC5D;AACO;AACP;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,yEAAiB;AACjC;AACA;;;;;;;;;;;;;;;AChBO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;ACfwD;AACL;AACF;AACjD;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,qEAAoB;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,8DAAS;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,gEAAU;AAClB;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;ACtC4C;AACC;AACoB;AACjE;AACO;AACP;AACA,QAAQ,0DAAa;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,yDAAS;AACvC;AACA;AACA,qDAAqD;AACrD;AACA;AACA;AACA,gBAAgB,8EAAiB;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;AChD+D;AAC/D,0EAA0E,IAAI;AACvE;AACP;AACA;AACA,+CAA+C,IAAI;AACnD;AACA,0BAA0B,cAAc;AACxC;AACA;AACA;AACA,QAAQ,4EAAgB;AACxB;AACA;AACA;;;;;;;;;;;;;;;;;;;ACd8C;AACH;AAC3C;AACA,oDAAM;AACN;AACA;AACA;AACA,wDAAM;AACN;AACA;AACA;AACA;AACA,uBAAuB,oDAAM;AAC7B;AACA;AACA;AACA,8DAA8D,gBAAgB,MAAM,oBAAoB;AACxG;AACA;AACA;AACA;AACA;AACA,kCAAkC,uDAAkB;AACpD;AACA;AACA;AACA;AACA,+BAA+B;AAC/B,qCAAqC;AACrC,4EAA4E;AAC5E;AACA;AACA,CAAC;AACM;AACP;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA,6CAA6C;AAC7C;AACA;AACA;AACA;AACA;AACA,iCAAiC,iDAAiD;AAClF;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA,mBAAmB,oDAAM;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,kBAAkB,uDAAkB;AACpC;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,mBAAmB,oDAAM;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;AClH+C;AACJ;AAC3C;AACO;AACP,mBAAmB,oDAAM;AACzB;AACA;AACA;AACA;AACA,uBAAuB,4DAAa;AACpC;AACA;AACA,uBAAuB,4DAAa;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,4DAAa;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACxC+C;AACJ;AAC3C;AACO;AACP,mBAAmB,oDAAM;AACzB;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA,uBAAuB,4DAAa;AACpC;AACA,uBAAuB,4DAAa;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,4DAAa;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;ACnCA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;ACZ4E;AACjC;AACe;AACZ;AACkB;AACpB;AACI;AACG;AAC5C;AACP;AACA;AACA;AACO;AACP;AACA,0BAA0B,0DAAa,WAAW,uDAAU;AAC5D;AACA;AACA;AACA;AACA,gBAAgB,4BAA4B;AAC5C;AACA,8BAA8B,mEAAe;AAC7C;AACA;AACA;AACA;AACA;AACA,KAAK,GAAG;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,8DAAiB;AACzB,iBAAiB;AACjB;AACA;AACA,QAAQ,uDAAU;AAClB,iBAAiB,kBAAkB,uDAAY;AAC/C;AACA;AACA;AACA;AACA,iBAAiB,kBAAkB,uDAAY;AAC/C;AACA;AACA,0BAA0B,uDAAY;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,oDAAM;AAChC,wCAAwC;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,gEAAU;AACpC,4BAA4B,yDAAS,SAAS;AAC9C;AACA;AACA,6BAA6B,yDAAU;AACvC;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA;AACA;AACA,wBAAwB,6EAAc;AACtC;AACA;AACA;AACA;AACA,iBAAiB;AACjB,aAAa;AACb;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;AC9HoD;AACU;AAChB;AAC9C;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,sFAAsF,SAAS;AAC/F;AACA;AACA;AACA,mEAAmE,kBAAkB;AACrF;AACA,YAAY,MAAM;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,cAAc;AACrC,aAAa;AACb;AACO;AACP,wBAAwB,uDAAY,GAAG;AACvC,2BAA2B,6DAAc;AACzC;AACA,IAAI,2DAAe;AACnB;AACA;AACA;AACA;AACA,IAAI,0DAAc;AAClB,aAAa;AACb;;;;;;;;;;;;;;;;;;;AC/CA,wDAAwD;AACb;AAC3C;AACO;AACP,IAAI,oDAAM;AACV;AACA;AACO;AACP,IAAI,oDAAM;AACV;AACA;AACO;AACP,IAAI,oDAAM;AACV;AACA;AACO;AACP,IAAI,oDAAM;AACV;;;;;;;;;;;;;;;;;;;;ACjBuE;AACvB;AAC6B;AACpB;AACM;AACxD;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,sEAAgB;AACxB,QAAQ,0FAAuB;AAC/B;AACA,sBAAsB,sBAAsB;AAC5C,SAAS;AACT;AACA;AACA;AACA;AACA,wCAAwC,yDAAU;AAClD;AACA;AACA,2BAA2B,oFAAoB;AAC/C;AACA,oBAAoB;AACpB;AACA;AACA,gDAAgD;AAChD;AACA;AACA;AACA;AACA,mBAAmB,4EAAgB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;AACA;AACA;AACA;AACA,YAAY,sEAAgB;AAC5B,6DAA6D;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,kBAAkB,sBAAsB;AACxC,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;AClI4F;AACZ;AAC5B;AAC+B;AACd;AACE;AACM;AAC1B;AACkB;AAC9D;AACP;AACA,wBAAwB,2DAAc;AACtC;AACA,IAAI,oFAAoB;AACxB;AACA;AACA;AACA;AACA;AACA,YAAY,0FAAuB;AACnC;AACA,0BAA0B,sBAAsB;AAChD,aAAa;AACb;AACA;AACA,QAAQ,gGAA0B;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,uDAAU;AAClB,QAAQ,iEAAe,8CAA8C;AACrE;AACA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA;AACA,sBAAsB,kFAAmB;AACzC;AACA;AACA;AACA,QAAQ,0DAAa;AACrB;AACA,QAAQ,yEAAU;AAClB;AACA;AACA;AACA,QAAQ,8DAAiB;AACzB;AACA;AACA;AACA,IAAI,kFAAmB;AACvB;AACA;AACA;AACA;AACA,+BAA+B,gEAAU;AACzC;AACA;AACA;AACA,QAAQ,iFAAkB;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,yEAAU;AACzB;AACA,WAAW,kFAAmB;AAC9B;;;;;;;;;;;;;;;;AC/E2C;AAC3C;AACO;AACP,yBAAyB,wDAAM;AAC/B;AACA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;SClBA;SACA;;SAEA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;SACA;;SAEA;SACA;;SAEA;SACA;SACA;;;;;UCtBA;UACA;UACA;UACA;UACA,yCAAyC,wCAAwC;UACjF;UACA;UACA;;;;;UCPA;;;;;UCAA;UACA;UACA;UACA,uDAAuD,iBAAiB;UACxE;UACA,gDAAgD,aAAa;UAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACNA,YAAY,YAAY;AACkB;AACK;AACzB;AACC;AACE;AACC;AACG;AACE;AACE;AACE;AACnC;AACqC;AACrC;AAC0C;AACR;AACY;AACH;AAC3C;AACA;AACwC;AACH;AACM;AACE;AACpB;AACG;AACE;AAC9B;AACO;AACP,cAAc;AACd;AACA","sources":["webpack://taggedjs/./ts/ElementTargetEvent.interface.ts","webpack://taggedjs/./ts/Subject.ts","webpack://taggedjs/./ts/Tag.class.ts","webpack://taggedjs/./ts/TagSupport.class.ts","webpack://taggedjs/./ts/TemplaterResult.class.ts","webpack://taggedjs/./ts/ValueSubject.ts","webpack://taggedjs/./ts/alterProps.function.ts","webpack://taggedjs/./ts/bindSubjectCallback.function.ts","webpack://taggedjs/./ts/checkDestroyPrevious.function.ts","webpack://taggedjs/./ts/deepFunctions.ts","webpack://taggedjs/./ts/destroyTag.function.ts","webpack://taggedjs/./ts/elementDestroyCheck.function.ts","webpack://taggedjs/./ts/elementInitCheck.ts","webpack://taggedjs/./ts/errors.ts","webpack://taggedjs/./ts/getCallback.ts","webpack://taggedjs/./ts/hasTagSupportChanged.function.ts","webpack://taggedjs/./ts/html.ts","webpack://taggedjs/./ts/inputAttribute.ts","webpack://taggedjs/./ts/interpolateAttributes.ts","webpack://taggedjs/./ts/interpolateContentTemplates.ts","webpack://taggedjs/./ts/interpolateElement.ts","webpack://taggedjs/./ts/interpolateTemplate.ts","webpack://taggedjs/./ts/interpolations.ts","webpack://taggedjs/./ts/isInstance.ts","webpack://taggedjs/./ts/isLikeTags.function.ts","webpack://taggedjs/./ts/onDestroy.ts","webpack://taggedjs/./ts/onInit.ts","webpack://taggedjs/./ts/processAttribute.function.ts","webpack://taggedjs/./ts/processNewValue.function.ts","webpack://taggedjs/./ts/processRegularValue.function.ts","webpack://taggedjs/./ts/processSubjectComponent.function.ts","webpack://taggedjs/./ts/processSubjectValue.function.ts","webpack://taggedjs/./ts/processTagArray.ts","webpack://taggedjs/./ts/processTagResult.function.ts","webpack://taggedjs/./ts/provider.utils.ts","webpack://taggedjs/./ts/providers.ts","webpack://taggedjs/./ts/redrawTag.function.ts","webpack://taggedjs/./ts/render.ts","webpack://taggedjs/./ts/renderExistingTag.function.ts","webpack://taggedjs/./ts/renderTagSupport.function.ts","webpack://taggedjs/./ts/scanTextAreaValue.function.ts","webpack://taggedjs/./ts/set.function.ts","webpack://taggedjs/./ts/setLet.function.ts","webpack://taggedjs/./ts/setProp.function.ts","webpack://taggedjs/./ts/setUse.function.ts","webpack://taggedjs/./ts/tag.ts","webpack://taggedjs/./ts/tagElement.ts","webpack://taggedjs/./ts/tagRunner.ts","webpack://taggedjs/./ts/updateExistingTagComponent.function.ts","webpack://taggedjs/./ts/updateExistingValue.function.ts","webpack://taggedjs/./ts/watch.function.ts","webpack://taggedjs/webpack/bootstrap","webpack://taggedjs/webpack/runtime/define property getters","webpack://taggedjs/webpack/runtime/hasOwnProperty shorthand","webpack://taggedjs/webpack/runtime/make namespace object","webpack://taggedjs/./ts/index.ts"],"sourcesContent":["export {};\n","export class Subject {\n    value;\n    isSubject = true;\n    subscribers = [];\n    // unsubcount = 0 // 🔬 testing\n    constructor(value) {\n        this.value = value;\n    }\n    subscribe(callback) {\n        this.subscribers.push(callback);\n        SubjectClass.globalSubs.push(callback); // 🔬 testing\n        const countSubject = SubjectClass.globalSubCount$;\n        SubjectClass.globalSubCount$.set(countSubject.value + 1);\n        const unsubscribe = () => {\n            unsubscribe.unsubscribe();\n        };\n        // Return a function to unsubscribe from the BehaviorSubject\n        unsubscribe.unsubscribe = () => {\n            removeSubFromArray(this.subscribers, callback);\n            removeSubFromArray(SubjectClass.globalSubs, callback); // 🔬 testing\n            SubjectClass.globalSubCount$.set(countSubject.value - 1);\n            // any double unsubscribes will be ignored\n            unsubscribe.unsubscribe = () => undefined;\n        };\n        return unsubscribe;\n    }\n    set(value) {\n        this.value = value;\n        // Notify all subscribers with the new value\n        this.subscribers.forEach((callback) => {\n            callback.value = value;\n            callback(value);\n        });\n    }\n    next = this.set;\n}\nfunction removeSubFromArray(subscribers, callback) {\n    const index = subscribers.indexOf(callback);\n    if (index !== -1) {\n        subscribers.splice(index, 1);\n    }\n}\nconst SubjectClass = Subject;\nSubjectClass.globalSubs = []; // 🔬 for testing\nSubjectClass.globalSubCount$ = new Subject(); // for ease of debugging\nSubjectClass.globalSubCount$.set(0);\n","import { runBeforeDestroy } from './tagRunner';\nimport { buildClones } from './render';\nimport { interpolateElement, interpolateString } from './interpolateElement';\nimport { afterElmBuild, subscribeToTemplate } from './interpolateTemplate';\nimport { elementDestroyCheck } from './elementDestroyCheck.function';\nimport { processNewValue } from './processNewValue.function';\nimport { isSubjectInstance, isTagComponent } from './isInstance';\nimport { isLikeTags } from './isLikeTags.function';\nexport const variablePrefix = '__tagvar';\nexport const escapeVariable = '--' + variablePrefix + '--';\nconst prefixSearch = new RegExp(variablePrefix, 'g');\nexport const escapeSearch = new RegExp(escapeVariable, 'g');\nexport class ArrayValueNeverSet {\n    isArrayValueNeverSet = true;\n}\nexport class Tag {\n    strings;\n    values;\n    isTag = true;\n    hasLiveElements = false;\n    clones = []; // elements on document. Needed at destroy process to know what to destroy\n    cloneSubs = []; // subscriptions created by clones\n    childTags = []; // tags on me\n    tagSupport;\n    lastTemplateString = undefined; // used to compare templates for updates\n    // only present when a child of a tag\n    ownerTag;\n    // insertBefore?: Element\n    appElement; // only seen on this.getAppElement().appElement\n    // present only when an array. Populated by this.key()\n    arrayValue = new ArrayValueNeverSet();\n    constructor(strings, values) {\n        this.strings = strings;\n        this.values = values;\n    }\n    /** Used for array, such as array.map(), calls aka array.map(x => html``.key(x)) */\n    key(arrayValue) {\n        this.arrayValue = arrayValue;\n        return this;\n    }\n    destroy(options = {\n        stagger: 0,\n        byParent: false, // Only destroy clones of direct children\n    }) {\n        if (!this.hasLiveElements) {\n            throw new Error('destroying wrong tag');\n        }\n        const tagSupport = this.tagSupport;\n        const global = tagSupport.templater.global;\n        // removing is considered rendering. Prevents after event processing of this tag even tho possibly deleted\n        // ++this.tagSupport.templater.global.renderCount\n        // the isComponent check maybe able to be removed\n        const isComponent = tagSupport ? true : false;\n        if (isComponent) {\n            runBeforeDestroy(tagSupport, this);\n        }\n        const childTags = options.byParent ? [] : getChildTagsToDestroy(this.childTags);\n        // signify that no further event rendering should take place by making logic think a render occurred during event\n        // childTags.forEach(child => ++child.tagSupport.templater.global.renderCount)\n        // signify immediately child has been deleted (looked for during event processing)\n        childTags.forEach(child => {\n            const subGlobal = child.tagSupport.templater.global;\n            delete subGlobal.newest;\n            subGlobal.deleted = true;\n        });\n        delete global.oldest;\n        delete global.newest;\n        global.deleted = true;\n        this.hasLiveElements = false;\n        delete tagSupport.subject.tag;\n        this.destroySubscriptions();\n        let mainPromise;\n        if (this.ownerTag) {\n            this.ownerTag.childTags = this.ownerTag.childTags.filter(child => child !== this);\n        }\n        if (!options.byParent) {\n            const { stagger, promise } = this.destroyClones(options);\n            options.stagger = stagger;\n            if (promise) {\n                mainPromise = promise;\n            }\n        }\n        else {\n            this.destroyClones();\n        }\n        if (mainPromise) {\n            mainPromise = mainPromise.then(async () => {\n                const promises = childTags.map(kid => kid.destroy({ stagger: 0, byParent: true }));\n                return Promise.all(promises);\n            });\n        }\n        else {\n            mainPromise = Promise.all(childTags.map(kid => kid.destroy({ stagger: 0, byParent: true })));\n        }\n        return mainPromise.then(() => options.stagger);\n    }\n    destroySubscriptions() {\n        this.cloneSubs.forEach(cloneSub => cloneSub.unsubscribe());\n        this.cloneSubs.length = 0;\n    }\n    destroyClones({ stagger } = {\n        stagger: 0,\n    }) {\n        //const promises = this.clones.reverse().map(\n        const promises = this.clones.map(clone => this.checkCloneRemoval(clone, stagger)).filter(x => x); // only return promises\n        this.clones.length = 0; // tag maybe used for something else\n        if (promises.length) {\n            return { promise: Promise.all(promises), stagger };\n        }\n        return { stagger };\n    }\n    checkCloneRemoval(clone, stagger) {\n        let promise;\n        const customElm = clone;\n        if (customElm.ondestroy) {\n            promise = elementDestroyCheck(customElm, stagger);\n        }\n        const next = () => {\n            clone.parentNode?.removeChild(clone);\n            const ownerTag = this.ownerTag;\n            if (ownerTag) {\n                // Sometimes my clones were first registered to my owner, remove them from owner\n                ownerTag.clones = ownerTag.clones.filter(compareClone => compareClone !== clone);\n            }\n        };\n        if (promise instanceof Promise) {\n            return promise.then(next);\n        }\n        else {\n            next();\n        }\n        return promise;\n    }\n    getTemplate() {\n        const string = this.strings.map((string, index) => {\n            const safeString = string.replace(prefixSearch, escapeVariable);\n            const endString = safeString + (this.values.length > index ? `{${variablePrefix}${index}}` : '');\n            // const trimString = index === 0 || index === this.strings.length-1 ? endString.trim() : endString\n            const trimString = endString.replace(/>\\s*/g, '>').replace(/\\s*</g, '<');\n            return trimString;\n        }).join('');\n        const interpolation = interpolateString(string);\n        this.lastTemplateString = interpolation.string;\n        return {\n            interpolation,\n            // string,\n            string: interpolation.string,\n            strings: this.strings,\n            values: this.values,\n            context: this.tagSupport.templater.global.context || {},\n        };\n    }\n    isLikeTag(tag) {\n        return isLikeTags(this, tag);\n        const { string } = tag.getTemplate();\n        // TODO: most likely remove?\n        if (!this.lastTemplateString) {\n            throw new Error('no template here');\n        }\n        const stringMatched = string === this.lastTemplateString;\n        if (!stringMatched || tag.values.length !== this.values.length) {\n            return false;\n        }\n        const allVarsMatch = tag.values.every((value, index) => {\n            const compareTo = this.values[index];\n            const isFunctions = value instanceof Function && compareTo instanceof Function;\n            if (isFunctions) {\n                const stringMatch = value.toString() === compareTo.toString();\n                if (stringMatch) {\n                    return true;\n                }\n                return false;\n            }\n            return true;\n        });\n        if (allVarsMatch) {\n            return true;\n        }\n        return false;\n    }\n    updateByTag(tag) {\n        if (!this.tagSupport.templater.global.oldest) {\n            throw new Error('no oldest here');\n        }\n        if (!this.hasLiveElements) {\n            throw new Error('trying to update a tag with no elements on stage');\n        }\n        this.tagSupport.templater.global.newest = tag;\n        if (!this.tagSupport.templater.global.context) {\n            throw new Error('issue back here');\n        }\n        this.updateConfig(tag.strings, tag.values);\n    }\n    updateConfig(strings, values) {\n        this.strings = strings;\n        this.updateValues(values);\n    }\n    update() {\n        return this.updateContext(this.tagSupport.templater.global.context);\n    }\n    updateValues(values) {\n        this.values = values;\n        return this.updateContext(this.tagSupport.templater.global.context);\n    }\n    updateContext(context) {\n        this.strings.map((_string, index) => {\n            const variableName = variablePrefix + index;\n            const hasValue = this.values.length > index;\n            const value = this.values[index];\n            // is something already there?\n            const exists = variableName in context;\n            if (exists) {\n                return updateContextItem(context, variableName, value);\n            }\n            if (!hasValue) {\n                return;\n            }\n            // 🆕 First time values below\n            context[variableName] = processNewValue(hasValue, value, this);\n        });\n        return context;\n    }\n    getAppElement() {\n        let tag = this;\n        while (tag.ownerTag) {\n            tag = tag.ownerTag;\n        }\n        return tag;\n    }\n    /** Used during HMR only where static content itself could have been edited */\n    rebuild() {\n        // const insertBefore = this.insertBefore\n        const insertBefore = this.tagSupport.templater.global.insertBefore;\n        if (!insertBefore) {\n            const err = new Error('Cannot rebuild. Previous insertBefore element is not defined on tag');\n            err.tag = this;\n            throw err;\n        }\n        this.buildBeforeElement(insertBefore, {\n            forceElement: true,\n            counts: { added: 0, removed: 0 }, test: false,\n        });\n    }\n    buildBeforeElement(insertBefore, options = {\n        forceElement: false,\n        counts: { added: 0, removed: 0 },\n        test: false\n    }) {\n        if (!insertBefore.parentNode) {\n            throw new Error('no parent before removing clones');\n        }\n        this.tagSupport.templater.global.oldest = this;\n        this.tagSupport.templater.global.newest = this;\n        this.tagSupport.subject.tag = this;\n        this.hasLiveElements = true;\n        // remove old clones\n        if (this.clones.length) {\n            this.clones.forEach(clone => this.checkCloneRemoval(clone, 0));\n        }\n        // this.insertBefore = insertBefore\n        this.tagSupport.templater.global.insertBefore = insertBefore;\n        // const context = this.tagSupport.memory.context // this.update()\n        const context = this.update();\n        const template = this.getTemplate();\n        if (!insertBefore.parentNode) {\n            throw new Error('no parent before building tag');\n        }\n        const elementContainer = document.createElement('div');\n        elementContainer.id = 'tag-temp-holder';\n        // render content with a first child that we can know is our first element\n        elementContainer.innerHTML = `<template id=\"temp-template-tag-wrap\">${template.string}</template>`;\n        // Search/replace innerHTML variables but don't interpolate tag components just yet\n        const { tagComponents } = interpolateElement(elementContainer, context, template, this, // ownerTag,\n        {\n            forceElement: options.forceElement,\n            counts: options.counts\n        }, options.test);\n        if (!insertBefore.parentNode) {\n            throw new Error('no parent building tag');\n        }\n        afterInterpolateElement(elementContainer, insertBefore, this, // ownerTag\n        context, options);\n        // this.clones.push(...clones)\n        // Any tag components that were found should be processed AFTER the owner processes its elements. Avoid double processing of elements attributes like (oninit)=${}\n        let isForceElement = options.forceElement;\n        tagComponents.forEach(tagComponent => {\n            // const preClones = this.clones.map(clone => clone)\n            subscribeToTemplate(tagComponent.insertBefore, // temporary,\n            tagComponent.subject, tagComponent.ownerTag, options.counts, { isForceElement });\n            if (!insertBefore.parentNode) {\n                throw new Error('no parent building tag components');\n            }\n            afterInterpolateElement(elementContainer, insertBefore, this, context, options);\n            // remove component clones from ownerTag as they will belong to the components they live on\n            /*\n            if( preClones.length ) {\n              this.clones = this.clones.filter(cloneFilter => !preClones.find(clone => clone === cloneFilter))\n            }\n            */\n        });\n    }\n}\nfunction afterInterpolateElement(container, insertBefore, ownerTag, \n// preClones: Clones,\ncontext, options) {\n    const clones = buildClones(container, insertBefore);\n    ownerTag.clones.push(...clones);\n    clones.forEach(clone => afterElmBuild(clone, options, context, ownerTag));\n    return clones;\n}\nfunction getChildTagsToDestroy(childTags, allTags = []) {\n    for (let index = childTags.length - 1; index >= 0; --index) {\n        const cTag = childTags[index];\n        if (allTags.find(x => x === cTag)) {\n            // TODO: Lets find why a child tag is attached twice to owner\n            throw new Error('child tag registered twice for delete');\n        }\n        allTags.push(cTag);\n        childTags.splice(index, 1);\n        getChildTagsToDestroy(cTag.childTags, allTags);\n    }\n    return allTags;\n}\nfunction updateContextItem(context, variableName, value) {\n    const subject = context[variableName];\n    const tag = subject.tag;\n    if (tag) {\n        const oldWrap = tag.tagSupport.templater.wrapper; // tag versus component\n        if (oldWrap && isTagComponent(value)) {\n            const oldValueFn = oldWrap.original;\n            const newValueFn = value.wrapper?.original;\n            const fnMatched = oldValueFn === newValueFn;\n            if (fnMatched) {\n                const newTemp = value;\n                newTemp.global = tag.tagSupport.templater.global;\n            }\n        }\n    }\n    // return updateExistingValue(subject, value, this)\n    if (isSubjectInstance(value)) {\n        return;\n    }\n    subject.set(value); // listeners will evaluate updated values to possibly update display(s)\n    return;\n}\n","import { deepClone } from './deepFunctions';\nimport { isTagArray, isTagComponent, isTagInstance } from './isInstance';\nexport class BaseTagSupport {\n    templater;\n    subject;\n    isApp = true;\n    propsConfig;\n    memory = {\n        // context: {}, // populated after reading interpolated.values array converted to an object {variable0, variable:1}\n        state: {\n            newest: [],\n        },\n    };\n    constructor(templater, subject) {\n        this.templater = templater;\n        this.subject = subject;\n        const children = this.templater.children; // children tags passed in as arguments\n        const props = this.templater.props; // natural props\n        const latestCloned = deepClone(props); // alterProps(props, templater)\n        this.propsConfig = {\n            latest: props,\n            latestCloned, // assume its HTML children and then detect\n            clonedProps: latestCloned, // maybe duplicate\n            lastClonedKidValues: children.value.map(kid => {\n                const cloneValues = cloneValueArray(kid.values);\n                return cloneValues;\n            })\n        };\n        // if the latest props are not HTML children, then clone the props for later render cycles to compare\n        if (!isTagInstance(props)) {\n            this.propsConfig.latestCloned = deepClone(latestCloned);\n            this.propsConfig.clonedProps = this.propsConfig.latestCloned;\n        }\n    }\n}\nfunction cloneValueArray(values) {\n    return values.map((value) => {\n        const tag = value;\n        if (isTagInstance(tag)) {\n            return cloneValueArray(tag.values);\n        }\n        if (isTagComponent(tag)) {\n            const tagComponent = tag;\n            return deepClone(tagComponent.props);\n        }\n        if (isTagArray(tag)) {\n            return cloneValueArray(tag);\n        }\n        return deepClone(value);\n    });\n}\nexport class TagSupport extends BaseTagSupport {\n    ownerTagSupport;\n    templater;\n    subject;\n    isApp = false;\n    constructor(ownerTagSupport, templater, subject) {\n        super(templater, subject);\n        this.ownerTagSupport = ownerTagSupport;\n        this.templater = templater;\n        this.subject = subject;\n    }\n}\n","import { runAfterRender, runBeforeRedraw, runBeforeRender } from './tagRunner';\nimport { setUse } from './setUse.function';\nimport { isLikeTags } from './isLikeTags.function';\nimport { destroyTagMemory } from './destroyTag.function';\nexport class TemplaterResult {\n    props;\n    children;\n    isTag = false; // when true, is basic tag non-component\n    tagged;\n    wrapper;\n    global = {\n        newestTemplater: this,\n        context: {}, // populated after reading interpolated.values array converted to an object {variable0, variable:1}\n        providers: [],\n        /** Indicator of re-rending. Saves from double rending something already rendered */\n        renderCount: 0,\n        deleted: false\n    };\n    tagSupport;\n    constructor(props, children) {\n        this.props = props;\n        this.children = children;\n    }\n    /*\n    redraw?: (\n      force?: boolean, // force children to redraw\n    ) => Tag\n    */\n    isTemplater = true;\n}\nexport function renderWithSupport(tagSupport, existingTag, subject, ownerTag) {\n    const wrapTagSupport = tagSupport; // this.tagSupport\n    // const wrapTagSupport = existingTag?.tagSupport.templater.global.newest?.tagSupport || tagSupport\n    // this.tagSupport = wrapTagSupport\n    /* BEFORE RENDER */\n    // signify to other operations that a rendering has occurred so they do not need to render again\n    // ++wrapTagSupport.memory.renderCount\n    const runtimeOwnerTag = existingTag?.ownerTag || ownerTag;\n    if (existingTag) {\n        // wrapTagSupport.templater.props = existingTag.tagSupport.templater.global.newest?.tagSupport.templater.props || wrapTagSupport.templater.props\n        wrapTagSupport.memory.state.newest = [...existingTag.tagSupport.memory.state.newest];\n        // ??? - new\n        wrapTagSupport.templater.global = existingTag.tagSupport.templater.global;\n        runBeforeRedraw(wrapTagSupport, existingTag);\n    }\n    else {\n        if (!wrapTagSupport) {\n            throw new Error('63521');\n        }\n        // first time render\n        runBeforeRender(wrapTagSupport, runtimeOwnerTag);\n        // TODO: Logic below most likely could live within providers.ts inside the runBeforeRender function\n        const providers = setUse.memory.providerConfig;\n        providers.ownerTag = runtimeOwnerTag;\n    }\n    /* END: BEFORE RENDER */\n    const templater = wrapTagSupport.templater;\n    const retag = templater.wrapper(wrapTagSupport, subject);\n    /* AFTER */\n    runAfterRender(wrapTagSupport, retag);\n    const isLikeTag = !existingTag || isLikeTags(existingTag, retag);\n    if (!isLikeTag) {\n        destroyTagMemory(existingTag, subject);\n        delete templater.global.oldest;\n        delete templater.global.newest;\n        delete subject.tag;\n        templater.global.insertBefore = existingTag.tagSupport.templater.global.insertBefore;\n    }\n    retag.ownerTag = runtimeOwnerTag;\n    wrapTagSupport.templater.global.newest = retag;\n    if (wrapTagSupport.templater.global.oldest && !wrapTagSupport.templater.global.oldest.hasLiveElements) {\n        throw new Error('56513540');\n    }\n    if (wrapTagSupport.templater.global.oldest && !wrapTagSupport.templater.global.oldest.hasLiveElements) {\n        throw new Error('5555 - 10');\n    }\n    return retag;\n}\n","import { Subject } from './Subject';\nexport class ValueSubject extends Subject {\n    value;\n    constructor(value) {\n        super(value);\n        this.value = value;\n    }\n    subscribe(callback) {\n        const unsubscribe = super.subscribe(callback);\n        // Call the callback immediately with the current value\n        callback(this.value);\n        return unsubscribe;\n    }\n}\n","import { isTagInstance } from './isInstance';\nimport { renderTagSupport } from './renderTagSupport.function';\n/* Used to rewrite props that are functions. When they are called it should cause parent rendering */\nexport function alterProps(props, templater, ownerSupport) {\n    function callback(toCall, callWith) {\n        const renderCount = templater.global.renderCount;\n        const callbackResult = toCall(...callWith);\n        if (templater.global.renderCount > renderCount) {\n            throw new Error('already rendered');\n        }\n        const lastestOwner = ownerSupport.templater.global.newest;\n        const newOwner = renderTagSupport(lastestOwner.tagSupport, // ??? newestOwner.tagSupport, // ??? ownerSupport,\n        true);\n        if (newOwner.tagSupport.templater.global.newest != newOwner) {\n            throw new Error('newest assignment issue?');\n        }\n        return callbackResult;\n    }\n    const isPropTag = isTagInstance(props);\n    const watchProps = isPropTag ? 0 : props;\n    const newProps = resetFunctionProps(watchProps, callback);\n    return newProps;\n}\nfunction resetFunctionProps(props, callback) {\n    if (typeof (props) !== 'object') {\n        return props;\n    }\n    const newProps = props;\n    // BELOW: Do not clone because if first argument is object, the memory ref back is lost\n    // const newProps = {...props} \n    Object.entries(newProps).forEach(([name, value]) => {\n        if (value instanceof Function) {\n            const original = newProps[name].original;\n            if (original) {\n                return; // already previously converted\n            }\n            newProps[name] = (...args) => {\n                return callback(value, args);\n            };\n            newProps[name].original = value;\n            return;\n        }\n    });\n    return newProps;\n}\n","/** File largely responsible for reacting to element events, such as onclick */\nimport { renderTagSupport } from \"./renderTagSupport.function\";\nexport function bindSubjectCallback(value, tag) {\n    // Is this children? No override needed\n    if (value.isChildOverride) {\n        return value;\n    }\n    if (!tag.ownerTag && !tag.tagSupport.templater.global.isApp) {\n        throw new Error('no ownerTag issue here');\n    }\n    const subjectFunction = (element, args) => runTagCallback(value, tag, element, args);\n    // link back to original. Mostly used for <div oninit ondestroy> animations\n    subjectFunction.tagFunction = value;\n    return subjectFunction;\n}\nexport function runTagCallback(value, tag, bindTo, args) {\n    const tagSupport = tag.tagSupport;\n    const renderCount = tagSupport.templater.global.renderCount;\n    const method = value.bind(bindTo);\n    const callbackResult = method(...args);\n    const sameRenderCount = renderCount === tagSupport.templater.global.renderCount;\n    // already rendered OR tag was deleted before event processing\n    if (!sameRenderCount || tagSupport.templater.global.deleted) {\n        if (callbackResult instanceof Promise) {\n            return callbackResult.then(() => {\n                return 'promise-no-data-ever'; // tag was deleted during event processing\n            });\n        }\n        return 'no-data-ever'; // already rendered\n    }\n    renderTagSupport(tagSupport, true);\n    if (callbackResult instanceof Promise) {\n        return callbackResult.then(() => {\n            if (tagSupport.templater.global.deleted) {\n                return 'promise-no-data-ever'; // tag was deleted during event processing\n            }\n            renderTagSupport(tagSupport, true);\n            return 'promise-no-data-ever';\n        });\n    }\n    // Caller always expects a Promise\n    return 'no-data-ever';\n}\n","import { isTagArray, isTagComponent, isTagInstance } from './isInstance';\nimport { isLikeTags } from './isLikeTags.function';\nimport { destroyTagMemory, destroyTagSupportPast } from './destroyTag.function';\nexport function checkDestroyPrevious(subject, // existing.value is the old value\nnewValue) {\n    const existingSubArray = subject;\n    const wasArray = existingSubArray.lastArray;\n    // no longer an array\n    if (wasArray && !isTagArray(newValue)) {\n        wasArray.forEach(({ tag }) => destroyArrayTag(tag, { added: 0, removed: 0 }));\n        delete subject.lastArray;\n        return 1;\n    }\n    const tagSubject = subject;\n    const existingTag = tagSubject.tag;\n    // no longer tag or component?\n    if (existingTag) {\n        const isValueTag = isTagInstance(newValue);\n        const isSubjectTag = isTagInstance(subject.value);\n        if (isSubjectTag && isValueTag) {\n            const newTag = newValue;\n            if (!isLikeTags(newTag, existingTag)) {\n                destroyTagMemory(existingTag, tagSubject);\n                return 2;\n            }\n            return false;\n        }\n        const isValueTagComponent = isTagComponent(newValue);\n        if (isValueTagComponent) {\n            return false; // its still a tag component\n        }\n        // destroy old component, value is not a component\n        destroyTagMemory(existingTag, tagSubject);\n        return 3;\n    }\n    const displaySubject = subject;\n    const hasLastValue = 'lastValue' in displaySubject;\n    const lastValue = displaySubject.lastValue; // TODO: we maybe able to use displaySubject.value and remove concept of lastValue\n    // was simple value but now something bigger\n    if (hasLastValue && lastValue !== newValue) {\n        destroySimpleValue(displaySubject.template, displaySubject);\n        return 4;\n    }\n    return false;\n}\nexport function destroyArrayTag(tag, counts) {\n    destroyTagSupportPast(tag.tagSupport);\n    tag.destroy({\n        stagger: counts.removed++,\n    });\n}\nfunction destroySimpleValue(template, subject) {\n    const clone = subject.clone;\n    const parent = clone.parentNode;\n    // put the template back down\n    parent.insertBefore(template, clone);\n    parent.removeChild(clone);\n    delete subject.clone;\n    delete subject.lastValue;\n    // subject.template = template\n}\n","export function deepClone(obj) {\n    return makeDeepClone(obj, new WeakMap());\n}\nfunction makeDeepClone(obj, visited) {\n    // If obj is a primitive type or null, return it directly\n    if (obj === null || typeof obj !== 'object') {\n        return obj;\n    }\n    // If obj is already visited, return the cloned reference\n    if (visited.has(obj)) {\n        return visited.get(obj);\n    }\n    // Handle special cases like Date and RegExp\n    if (obj instanceof Date) {\n        return new Date(obj);\n    }\n    if (obj instanceof RegExp) {\n        return new RegExp(obj);\n    }\n    // Create an empty object or array with the same prototype\n    const clone = Array.isArray(obj) ? [] : Object.create(Object.getPrototypeOf(obj));\n    // Register the cloned object to avoid cyclic references\n    visited.set(obj, clone);\n    // Clone each property or element of the object or array\n    if (Array.isArray(obj)) {\n        for (let i = 0; i < obj.length; i++) {\n            clone[i] = makeDeepClone(obj[i], visited);\n        }\n    }\n    else {\n        for (const key in obj) {\n            if (obj.hasOwnProperty(key)) {\n                clone[key] = makeDeepClone(obj[key], visited);\n            }\n        }\n    }\n    return clone;\n}\nexport function deepEqual(obj1, obj2) {\n    return isDeepEqual(obj1, obj2, new WeakMap());\n}\nfunction isDeepEqual(obj1, obj2, visited) {\n    if (obj1 === obj2 || isSameFunctions(obj1, obj2)) {\n        return true;\n    }\n    if (typeof obj1 !== 'object' ||\n        typeof obj2 !== 'object' ||\n        obj1 === null ||\n        obj2 === null) {\n        return false;\n    }\n    const keys1 = Object.keys(obj1);\n    const keys2 = Object.keys(obj2);\n    if (keys1.length !== keys2.length) {\n        return false;\n    }\n    // If obj is already visited, return the cloned reference\n    if (visited.has(obj1)) {\n        return true;\n    }\n    // Register the cloned object to avoid cyclic references\n    visited.set(obj1, 0);\n    for (const key of keys1) {\n        const keyFound = keys2.includes(key);\n        if (!keyFound || !isDeepEqual(obj1[key], obj2[key], visited)) {\n            /*\n            if(isSameFunctions(obj1[key], obj2[key])) {\n              continue\n            }\n            */\n            return false;\n        }\n    }\n    // Check if obj1 and obj2 are both arrays\n    if (Array.isArray(obj1) && Array.isArray(obj2)) {\n        if (obj1.length !== obj2.length) {\n            return false;\n        }\n        for (let i = 0; i < obj1.length; i++) {\n            if (!isDeepEqual(obj1[i], obj2[i], visited)) {\n                return false;\n            }\n        }\n    }\n    else if (Array.isArray(obj1) || Array.isArray(obj2)) {\n        // One is an array, and the other is not\n        return false;\n    }\n    return true;\n}\nfunction isSameFunctions(fn0, fn1) {\n    const bothFunction = fn0 instanceof Function && fn1 instanceof Function;\n    return bothFunction && fn0.toString() === fn1.toString();\n}\n","export function destroyTagMemory(tag, subject) {\n    const oldTagSupport = tag.tagSupport;\n    if (subject != tag.tagSupport.subject) {\n        throw new Error('fff - subjects do not match');\n    }\n    delete subject.tag;\n    delete tag.tagSupport.subject.tag; // TODO: this line maybe not needed\n    // must destroy oldest which is tag with elements on stage\n    const oldest = tag.tagSupport.templater.global.oldest;\n    oldest.destroy();\n    destroyTagSupportPast(oldTagSupport);\n    // ???\n    tag.tagSupport.templater.global.context = {};\n}\nexport function destroyTagSupportPast(oldTagSupport) {\n    delete oldTagSupport.templater.global.oldest;\n    delete oldTagSupport.templater.global.newest;\n}\n","export function elementDestroyCheck(nextSibling, stagger) {\n    const onDestroyDoubleWrap = nextSibling.ondestroy;\n    if (!onDestroyDoubleWrap) {\n        return;\n    }\n    const onDestroyWrap = onDestroyDoubleWrap.tagFunction;\n    if (!onDestroyWrap) {\n        return;\n    }\n    const onDestroy = onDestroyWrap.tagFunction;\n    if (!onDestroy) {\n        return;\n    }\n    const event = { target: nextSibling, stagger };\n    return onDestroy(event);\n}\n","export function elementInitCheck(nextSibling, counts) {\n    const onInitDoubleWrap = nextSibling.oninit;\n    if (!onInitDoubleWrap) {\n        return counts.added;\n    }\n    const onInitWrap = onInitDoubleWrap.tagFunction;\n    if (!onInitWrap) {\n        return counts.added;\n    }\n    const onInit = onInitWrap.tagFunction;\n    if (!onInit) {\n        return counts.added;\n    }\n    const event = { target: nextSibling, stagger: counts.added };\n    onInit(event);\n    return ++counts.added;\n}\n","export class TagError extends Error {\n    details;\n    constructor(message, errorCode, details = {}) {\n        super(message);\n        this.name = TagError.name;\n        this.details = { ...details, errorCode };\n    }\n}\nexport class ArrayNoKeyError extends TagError {\n    constructor(message, details) {\n        super(message, 'array-no-key-error', details);\n        this.name = ArrayNoKeyError.name;\n    }\n}\nexport class StateMismatchError extends TagError {\n    constructor(message, details) {\n        super(message, 'state-mismatch-error', details);\n        this.name = StateMismatchError.name;\n    }\n}\n","import { setUse } from \"./setUse.function\";\nimport { getStateValue } from \"./set.function\";\nimport { renderTagSupport } from \"./renderTagSupport.function\";\nlet innerCallback = (callback) => () => {\n    throw new Error('The real callback function was called and that should never occur');\n};\nexport const getCallback = () => innerCallback;\nconst originalGetter = innerCallback; // getCallback\nsetUse({\n    beforeRender: (tagSupport) => initMemory(tagSupport),\n    beforeRedraw: (tagSupport) => initMemory(tagSupport),\n    afterRender: (_tagSupport) => {\n        innerCallback = originalGetter; // prevent crossing callbacks with another tag\n    },\n});\nfunction updateState(stateFrom, stateTo) {\n    stateFrom.forEach((state, index) => {\n        const fromValue = getStateValue(state);\n        const callback = stateTo[index].callback;\n        if (callback) {\n            callback(fromValue); // set the value\n        }\n        stateTo[index].lastValue = fromValue; // record the value\n    });\n}\nfunction initMemory(tagSupport) {\n    const oldState = setUse.memory.stateConfig.array;\n    innerCallback = (callback) => {\n        const trigger = (...args) => triggerStateUpdate(tagSupport, callback, oldState, ...args);\n        return trigger;\n    };\n}\nfunction triggerStateUpdate(tagSupport, callback, oldState, ...args) {\n    const state = tagSupport.memory.state;\n    const newest = state.newest;\n    // ensure that the oldest has the latest values first\n    updateState(newest, oldState);\n    // run the callback\n    const promise = callback(...args);\n    // send the oldest state changes into the newest\n    updateState(oldState, newest);\n    renderTagSupport(tagSupport, false);\n    // TODO: turn back on below\n    if (promise instanceof Promise) {\n        promise.finally(() => {\n            // send the oldest state changes into the newest\n            updateState(oldState, newest);\n            renderTagSupport(tagSupport, false);\n        });\n    }\n}\n","import { deepEqual } from \"./deepFunctions\";\nexport function hasTagSupportChanged(oldTagSupport, newTagSupport, newTemplater) {\n    const sameSupport = oldTagSupport === newTagSupport;\n    const samePropConfig = oldTagSupport.propsConfig === newTagSupport.propsConfig;\n    // const sameProps = oldTagSupport.propsConfig.latest === newTagSupport.propsConfig.latest\n    if (sameSupport) {\n        throw new Error('sameSupport - 22');\n    }\n    if (samePropConfig) {\n        throw new Error('samePropConfig - 22');\n    }\n    if (newTagSupport.templater.isTag || oldTagSupport.templater.isTag || newTemplater.isTag) {\n        throw new Error('trying to compare a basic tag');\n    }\n    const latestProps = newTemplater.props; // newTagSupport.propsConfig.latest\n    const pastCloneProps = oldTagSupport.propsConfig.latestCloned;\n    const propsChanged = hasPropChanges(latestProps, pastCloneProps);\n    // if no changes detected, no need to continue to rendering further tags\n    if (propsChanged) {\n        return propsChanged;\n    }\n    const kidsChanged = hasKidsChanged(oldTagSupport, newTagSupport);\n    // we already know props didn't change and if kids didn't either, than don't render\n    return kidsChanged;\n}\nexport function hasPropChanges(props, // natural props\npastCloneProps) {\n    /*\n    const isCommonEqual = props === undefined && props === compareToProps\n    if(isCommonEqual) {\n      return false\n    }\n    */\n    let castedProps = props;\n    let castedPastProps = pastCloneProps;\n    // check all prop functions match\n    if (typeof (props) === 'object') {\n        if (!pastCloneProps) {\n            return 3;\n        }\n        castedProps = { ...props };\n        castedPastProps = { ...(pastCloneProps || {}) };\n        const allFunctionsMatch = Object.entries(castedProps).every(([key, value]) => {\n            /*if(!(key in (castedPastProps as any))) {\n              return false\n            }*/\n            let compare = castedPastProps[key];\n            if (!(value instanceof Function)) {\n                return 4; // this will be checked in deepEqual\n            }\n            if (!(compare instanceof Function)) {\n                return false; // its a function now but was not before\n            }\n            // ensure we are comparing apples to apples as function get wrapped\n            if (compare.original) {\n                compare = compare.original;\n            }\n            const original = value.original;\n            if (original) {\n                value = value.original;\n            }\n            if (value.toString() !== compare.toString()) {\n                return false; // both are function but not the same\n            }\n            delete castedProps[key]; // its a function and not needed to be compared\n            delete castedPastProps[key]; // its a function and not needed to be compared\n            return 5;\n        });\n        if (!allFunctionsMatch) {\n            return 6; // a change has been detected by function comparisons\n        }\n    }\n    // ???\n    const isEqual = deepEqual(castedPastProps, castedProps);\n    return isEqual ? false : 7; // if equal then no changes\n}\nexport function hasKidsChanged(oldTagSupport, newTagSupport) {\n    const oldCloneKidValues = oldTagSupport.propsConfig.lastClonedKidValues;\n    const newClonedKidValues = newTagSupport.propsConfig.lastClonedKidValues;\n    const everySame = oldCloneKidValues.every((set, index) => {\n        const x = newClonedKidValues[index];\n        return set.every((item, index) => item === x[index]);\n    });\n    return everySame ? false : 9;\n}\n","import { Tag } from \"./Tag.class\";\nexport function html(strings, ...values) {\n    return new Tag(strings, values);\n}\n","export function inputAttribute(name, value, element) {\n    const names = name.split('.');\n    // style.position = \"absolute\"\n    if (names[0] === 'style') {\n        element.style[names[1]] = value;\n    }\n    // Example: class.width-full = \"true\"\n    if (names[0] === 'class') {\n        names.shift();\n        if (value) {\n            names.forEach(name => element.classList.add(name));\n        }\n        else {\n            names.forEach(name => element.classList.remove(name));\n        }\n        return;\n    }\n}\n","import { processAttribute } from \"./processAttribute.function\";\nfunction howToSetAttribute(element, name, value) {\n    element.setAttribute(name, value);\n}\nfunction howToSetInputValue(element, name, value) {\n    element[name] = value;\n}\nexport function interpolateAttributes(child, scope, ownerTag) {\n    const attrNames = child.getAttributeNames();\n    let howToSet = howToSetAttribute;\n    attrNames.forEach(attrName => {\n        if (child.nodeName === 'INPUT' && attrName === 'value') {\n            howToSet = howToSetInputValue;\n        }\n        const value = child.getAttribute(attrName);\n        processAttribute(attrName, value, child, scope, ownerTag, howToSet);\n        howToSet = howToSetAttribute; // put back\n    });\n}\n","import { interpolateTemplate } from \"./interpolateTemplate\";\nexport function interpolateContentTemplates(element, context, tag, options, children) {\n    if (!children || element.tagName === 'TEMPLATE') {\n        return { clones: [], tagComponents: [] }; // done\n    }\n    // counting for animation stagger computing\n    const counts = options.counts;\n    const clones = [];\n    const tagComponents = [];\n    const childArray = new Array(...children);\n    childArray.forEach(child => {\n        const { clones: nextClones, tagComponent } = interpolateTemplate(child, context, tag, counts, options);\n        clones.push(...nextClones);\n        if (tagComponent) {\n            tagComponents.push(tagComponent);\n            return;\n        }\n        if (child.children) {\n            const nextKids = new Array(...child.children);\n            nextKids.forEach((subChild, index) => {\n                // IF <template end /> its a variable to be processed\n                if (isRenderEndTemplate(subChild)) {\n                    const { tagComponent } = interpolateTemplate(subChild, context, tag, counts, options);\n                    if (tagComponent) {\n                        tagComponents.push(tagComponent);\n                    }\n                }\n                const { clones: nextClones, tagComponents: nextTagComponent } = interpolateContentTemplates(subChild, context, tag, options, subChild.children);\n                clones.push(...nextClones);\n                tagComponents.push(...nextTagComponent);\n            });\n        }\n    });\n    return { clones, tagComponents };\n}\nfunction isRenderEndTemplate(child) {\n    const isTemplate = child.tagName === 'TEMPLATE';\n    return isTemplate &&\n        child.getAttribute('interpolate') !== undefined &&\n        child.getAttribute('end') !== undefined;\n}\n","import { interpolateAttributes } from \"./interpolateAttributes\";\nimport { interpolateToTemplates } from \"./interpolations\";\nimport { interpolateContentTemplates } from \"./interpolateContentTemplates\";\nimport { escapeSearch, variablePrefix } from \"./Tag.class\";\n/** Review elements within an element */\nexport function interpolateElement(container, context, // variables used to evaluate\ninterpolatedTemplates, tagOwner, options, test = false) {\n    const clones = [];\n    const tagComponents = [];\n    const result = interpolatedTemplates.interpolation;\n    const template = container.children[0];\n    const children = template.content.children;\n    if (result.keys.length) {\n        const { clones: nextClones, tagComponents: nextTagComponents } = interpolateContentTemplates(container, context, tagOwner, options, children);\n        clones.push(...nextClones);\n        tagComponents.push(...nextTagComponents);\n    }\n    interpolateAttributes(container, context, tagOwner);\n    processChildrenAttributes(children, context, tagOwner);\n    return { clones, tagComponents };\n}\nfunction processChildrenAttributes(children, context, ownerTag) {\n    new Array(...children).forEach(child => {\n        interpolateAttributes(child, context, ownerTag);\n        if (child.children) {\n            processChildrenAttributes(child.children, context, ownerTag);\n        }\n    });\n}\nexport function interpolateString(string) {\n    const result = interpolateToTemplates(string);\n    result.string = result.string.replace(escapeSearch, variablePrefix);\n    return result;\n}\n","import { variablePrefix } from \"./Tag.class\";\nimport { elementInitCheck } from \"./elementInitCheck\";\nimport { processSubjectValue } from \"./processSubjectValue.function\";\nimport { isTagArray, isTagComponent } from \"./isInstance\";\nimport { scanTextAreaValue } from \"./scanTextAreaValue.function\";\nimport { updateExistingValue } from \"./updateExistingValue.function\";\nexport function interpolateTemplate(insertBefore, // <template end interpolate /> (will be removed)\ncontext, // variable scope of {`__tagvar${index}`:'x'}\nownerTag, // Tag class\ncounts, // used for animation stagger computing\noptions) {\n    // TODO: THe clones array is useless here\n    const clones = [];\n    if (!insertBefore.hasAttribute('end')) {\n        return { clones }; // only care about <template end>\n    }\n    const variableName = insertBefore.getAttribute('id');\n    if (variableName?.substring(0, variablePrefix.length) !== variablePrefix) {\n        return { clones }; // ignore, not a tagVar\n    }\n    const existingSubject = context[variableName];\n    const isDynamic = isTagComponent(existingSubject.value) || isTagArray(existingSubject.value);\n    // process dynamics later\n    if (isDynamic) {\n        return {\n            clones,\n            tagComponent: {\n                variableName,\n                ownerTag,\n                subject: existingSubject,\n                insertBefore\n            }\n        };\n    }\n    let isForceElement = options.forceElement;\n    subscribeToTemplate(insertBefore, existingSubject, ownerTag, counts, { isForceElement });\n    return { clones };\n}\nexport function subscribeToTemplate(insertBefore, subject, ownerTag, counts, // used for animation stagger computing\n{ isForceElement }) {\n    let called = false;\n    const callback = (value) => {\n        // const orgInsert = insertBefore\n        const clone = subject.clone;\n        if (clone && clone.parentNode) {\n            insertBefore = clone;\n        }\n        if (called) {\n            updateExistingValue(subject, value, ownerTag, insertBefore);\n            return;\n        }\n        processSubjectValue(value, subject, insertBefore, ownerTag, {\n            counts: { ...counts },\n            forceElement: isForceElement,\n        });\n        if (isForceElement) {\n            isForceElement = false; // only can happen once\n        }\n        // ownerTag.clones.push(...clones)\n        // ownerTag.clones.push(...nextClones)\n        // clones.push(...nextClones)\n        called = true;\n    };\n    const sub = subject.subscribe(callback);\n    ownerTag.cloneSubs.push(sub);\n}\n// Function to update the value of x\nexport function updateBetweenTemplates(value, lastFirstChild) {\n    const parent = lastFirstChild.parentNode;\n    // mimic React skipping to display EXCEPT for true does display on page\n    if (value === undefined || value === false || value === null) { // || value === true\n        value = '';\n    }\n    // Insert the new value (never use innerHTML here)\n    const textNode = document.createTextNode(value); // never innerHTML\n    parent.insertBefore(textNode, lastFirstChild);\n    /* remove existing nodes */\n    parent.removeChild(lastFirstChild);\n    return textNode;\n}\nexport function afterElmBuild(elm, options, context, ownerTag) {\n    if (!elm.getAttribute) {\n        return;\n    }\n    const tagName = elm.nodeName; // elm.tagName\n    if (tagName === 'TEXTAREA') {\n        scanTextAreaValue(elm, context, ownerTag);\n    }\n    let diff = options.counts.added;\n    diff = elementInitCheck(elm, options.counts) - diff;\n    if (elm.children) {\n        /*\n        const subCounts = {\n          added: options.counts.added, // - diff,\n          removed: options.counts.removed,\n        }\n        */\n        new Array(...elm.children).forEach((child, index) => {\n            const subOptions = {\n                ...options,\n                counts: options.counts,\n            };\n            return afterElmBuild(child, subOptions, context, ownerTag);\n        });\n    }\n}\n","// support arrow functions in attributes\nexport const interpolateReplace = /(?:<[^>]*?(?:(?:\\s+\\w+(?:\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^>\\s]+)))*\\s*)\\/?>)|({__tagvar[^}]+})/g;\n/** replaces ${x} with <template id=\"x-start\"></template><template id=\"x-end\"></template> */\nexport function interpolateToTemplates(template) {\n    const keys = [];\n    const string = template.replace(interpolateReplace, (match, expression) => {\n        if (match.startsWith('<')) {\n            // If the match is an HTML tag, don't replace\n            return match;\n        }\n        const noBraces = expression.substring(1, expression.length - 1);\n        const id = noBraces;\n        keys.push(id);\n        return `<template interpolate end id=\"${id}\"></template>`;\n    });\n    return { string, keys };\n}\n","export function isTagComponent(value) {\n    return value?.isTemplater === true;\n}\nexport function isTagInstance(tag) {\n    return tag?.isTag === true;\n}\nexport function isSubjectInstance(subject) {\n    return (subject?.isSubject === true || subject?.subscribe) ? true : false; // subject?.isSubject === true || \n}\nexport function isTagArray(value) {\n    return value instanceof Array && value.every(x => isTagInstance(x));\n}\n","export function isLikeTags(tag0, tag1) {\n    if (tag0.strings.length !== tag1.strings.length) {\n        return false;\n    }\n    const everyStringMatched = tag0.strings.every((string, index) => tag1.strings[index] === string);\n    if (!everyStringMatched) {\n        return false;\n    }\n    const valuesLengthsMatch = tag0.values.length === tag1.values.length;\n    if (!valuesLengthsMatch) {\n        return false;\n    }\n    const allVarsMatch = tag1.values.every((value, index) => {\n        const compareTo = tag0.values[index];\n        const isFunctions = value instanceof Function && compareTo instanceof Function;\n        if (isFunctions) {\n            const stringMatch = value.toString() === compareTo.toString();\n            if (stringMatch) {\n                return true;\n            }\n            return false;\n        }\n        return true; // deepEqual(value, compareTo)\n    });\n    if (allVarsMatch) {\n        return true;\n    }\n    return false;\n}\n","import { setUse } from \"./setUse.function\";\n/** When undefined, it means a tag is being built for the first time so do run destroy(s) */\nlet destroyCurrentTagSupport;\nexport function onDestroy(callback) {\n    destroyCurrentTagSupport.templater.global.destroyCallback = callback;\n}\nsetUse({\n    beforeRender: tagSupport => destroyCurrentTagSupport = tagSupport,\n    beforeRedraw: tagSupport => destroyCurrentTagSupport = tagSupport,\n    beforeDestroy: (tagSupport, tag) => {\n        const callback = tagSupport.templater.global.destroyCallback;\n        if (callback) {\n            callback();\n        }\n    }\n});\n","import { setUse } from \"./setUse.function\";\nfunction setCurrentTagSupport(support) {\n    setUse.memory.initCurrentSupport = support;\n}\nexport function onInit(callback) {\n    if (!setUse.memory.initCurrentSupport.memory.init) {\n        setUse.memory.initCurrentSupport.memory.init = callback;\n        callback(); // fire init\n    }\n}\nsetUse({\n    beforeRender: tagSupport => setCurrentTagSupport(tagSupport),\n    beforeRedraw: tagSupport => setCurrentTagSupport(tagSupport),\n});\n","import { inputAttribute } from './inputAttribute';\nimport { isSubjectInstance } from './isInstance';\nimport { bindSubjectCallback } from './bindSubjectCallback.function';\nconst startRegX = /^\\s*{__tagvar/;\nconst endRegX = /}\\s*$/;\nfunction isTagVar(value) {\n    return value && value.search(startRegX) >= 0 && value.search(endRegX) >= 0;\n}\nexport function processAttribute(attrName, value, child, scope, ownerTag, howToSet) {\n    if (isTagVar(value)) {\n        return processScopedNameValueAttr(attrName, value, child, scope, ownerTag, howToSet);\n    }\n    if (isTagVar(attrName)) {\n        const contextValueSubject = getContextValueByVarString(scope, attrName);\n        let lastValue;\n        // the above callback gets called immediately since its a ValueSubject()\n        const sub = contextValueSubject.subscribe((value) => {\n            processNameOnlyAttr(value, lastValue, child, ownerTag, howToSet);\n            lastValue = value;\n        });\n        ownerTag.cloneSubs.push(sub); // this is where unsubscribe is picked up\n        child.removeAttribute(attrName);\n        return;\n    }\n    // Non dynamic\n    const isSpecial = isSpecialAttr(attrName);\n    if (isSpecial) {\n        return inputAttribute(attrName, value, child);\n    }\n}\nfunction processScopedNameValueAttr(attrName, value, // {__tagVarN}\nchild, scope, ownerTag, howToSet) {\n    // get the code inside the brackets like \"variable0\" or \"{variable0}\"\n    const result = getContextValueByVarString(scope, value);\n    return processNameValueAttr(attrName, result, child, ownerTag, howToSet);\n}\nfunction getContextValueByVarString(scope, value) {\n    const code = value.replace('{', '').split('').reverse().join('').replace('}', '').split('').reverse().join('');\n    return scope[code];\n}\nfunction processNameOnlyAttr(attrValue, lastValue, child, ownerTag, howToSet) {\n    if (lastValue && lastValue != attrValue) {\n        if (typeof (lastValue) === 'string') {\n            child.removeAttribute(lastValue);\n        }\n        else if (lastValue instanceof Object) {\n            Object.entries(lastValue).forEach(([name]) => child.removeAttribute(name));\n        }\n    }\n    if (typeof (attrValue) === 'string') {\n        if (!attrValue.length) {\n            return;\n        }\n        processNameValueAttr(attrValue, '', child, ownerTag, howToSet);\n        return;\n    }\n    if (attrValue instanceof Object) {\n        Object.entries(attrValue).forEach(([name, value]) => processNameValueAttr(name, value, child, ownerTag, howToSet));\n        return;\n    }\n}\nfunction processNameValueAttr(attrName, result, child, ownerTag, howToSet) {\n    const isSpecial = isSpecialAttr(attrName);\n    // attach as callback?\n    if (result instanceof Function) {\n        const action = function (...args) {\n            const result2 = result(child, args);\n            return result2;\n        };\n        child[attrName].action = action;\n        // child.addEventListener(attrName, action)\n    }\n    // Most every variable comes in here since everything is made a ValueSubject\n    if (isSubjectInstance(result)) {\n        child.removeAttribute(attrName);\n        const callback = (newAttrValue) => {\n            if (newAttrValue instanceof Function) {\n                newAttrValue = bindSubjectCallback(newAttrValue, ownerTag);\n            }\n            return processAttributeSubjectValue(newAttrValue, child, attrName, isSpecial, howToSet);\n        };\n        // 🗞️ Subscribe. Above callback called immediately since its a ValueSubject()\n        const sub = result.subscribe(callback);\n        // Record subscription for later unsubscribe when element destroyed\n        ownerTag.cloneSubs.push(sub);\n        return;\n    }\n    howToSet(child, attrName, result);\n    // child.setAttribute(attrName, result.value)\n    return;\n}\nfunction processAttributeSubjectValue(newAttrValue, child, attrName, isSpecial, howToSet) {\n    if (newAttrValue instanceof Function) {\n        const fun = function (...args) {\n            return newAttrValue(child, args);\n        };\n        // access to original function\n        fun.tagFunction = newAttrValue;\n        child[attrName] = fun;\n        return;\n    }\n    if (isSpecial) {\n        inputAttribute(attrName, newAttrValue, child);\n        return;\n    }\n    if (newAttrValue) {\n        howToSet(child, attrName, newAttrValue);\n        return;\n    }\n    const isDeadValue = newAttrValue === undefined || newAttrValue === false || newAttrValue === null;\n    if (isDeadValue) {\n        child.removeAttribute(attrName);\n        return;\n    }\n    // value is 0\n    howToSet(child, attrName, newAttrValue);\n}\n/** Looking for (class | style) followed by a period */\nfunction isSpecialAttr(attrName) {\n    return attrName.search(/^(class|style)(\\.)/) >= 0;\n}\n","import { ValueSubject } from './ValueSubject';\nimport { isSubjectInstance, isTagComponent, isTagInstance } from './isInstance';\nexport function processNewValue(hasValue, value, ownerTag) {\n    if (isTagComponent(value)) {\n        const tagSubject = new ValueSubject(value);\n        return tagSubject;\n    }\n    if (value instanceof Function) {\n        // return getSubjectFunction(value, ownerTag)\n        return new ValueSubject(value);\n    }\n    if (!hasValue) {\n        return; // more strings than values, stop here\n    }\n    if (isTagInstance(value)) {\n        value.ownerTag = ownerTag;\n        if (ownerTag.childTags.find(x => x === value)) {\n            throw new Error('about to reattach tag already present - 2');\n        }\n        return new ValueSubject(value);\n    }\n    if (isSubjectInstance(value)) {\n        return value; // its already a value subject\n    }\n    return new ValueSubject(value);\n}\n","import { updateBetweenTemplates } from './interpolateTemplate';\nexport function processRegularValue(value, subject, // could be tag via subject.tag\ntemplate) {\n    subject.template = template;\n    const before = subject.clone || template; // Either the template is on the doc OR its the first element we last put on doc\n    if (subject.lastValue === value) {\n        return; // no need to update display, its the same\n    }\n    subject.lastValue = value;\n    // Processing of regular values\n    const clone = updateBetweenTemplates(value, before);\n    subject.clone = clone; // remember single element put down, for future updates\n}\n","import { renderWithSupport } from './TemplaterResult.class';\nimport { setUse } from './setUse.function';\nimport { processTagResult } from './processTagResult.function';\nimport { TagSupport } from './TagSupport.class';\nexport function processSubjectComponent(templater, subject, template, ownerTag, options) {\n    // Check if function component is wrapped in a tag() call\n    // TODO: This below check not needed in production mode\n    if (templater.tagged !== true) {\n        let name = templater.wrapper.original.name || templater.wrapper.original.constructor?.name;\n        if (name === 'Function') {\n            name = undefined;\n        }\n        const label = name || templater.wrapper.original.toString().substring(0, 120);\n        const error = new Error(`Not a tag component. Wrap your function with tag(). Example tag(props => html\\`\\`) on component:\\n\\n${label}\\n\\n`);\n        throw error;\n    }\n    if (!templater.tagSupport) {\n        templater.tagSupport = new TagSupport(ownerTag.tagSupport, templater, subject);\n    }\n    // templater.oldest = subject.tag?.tagSupport.oldest || templater.oldest\n    templater.global.insertBefore = template;\n    let retag = subject.tag;\n    const providers = setUse.memory.providerConfig;\n    providers.ownerTag = ownerTag;\n    const isRedraw = !retag || options.forceElement;\n    if (isRedraw) {\n        const preClones = ownerTag.clones.map(clone => clone);\n        retag = renderWithSupport(templater.tagSupport, subject.tag, subject, ownerTag);\n        if (retag.tagSupport.templater.global.newest != retag) {\n            throw new Error('mismatch result newest');\n        }\n        templater.global.newest = retag;\n        if (ownerTag.clones.length > preClones.length) {\n            const myClones = ownerTag.clones.filter(fClone => !preClones.find(clone => clone === fClone));\n            retag.clones.push(...myClones);\n        }\n        if (ownerTag.childTags.find(x => x === retag)) {\n            throw new Error('about to reattach tag already present');\n        }\n        ownerTag.childTags.push(retag);\n    }\n    processTagResult(retag, subject, // The element set here will be removed from document. Also result.tag will be added in here\n    template, // <template end interpolate /> (will be removed)\n    options);\n}\n","import { processSubjectComponent } from './processSubjectComponent.function';\nimport { isTagArray, isTagComponent, isTagInstance } from './isInstance';\nimport { processTagArray } from './processTagArray';\nimport { TagSupport } from './TagSupport.class';\nimport { ValueSubject } from './ValueSubject';\nimport { processRegularValue } from './processRegularValue.function';\nvar ValueTypes;\n(function (ValueTypes) {\n    ValueTypes[\"tag\"] = \"tag\";\n    ValueTypes[\"tagArray\"] = \"tag-array\";\n    ValueTypes[\"tagComponent\"] = \"tag-component\";\n    ValueTypes[\"value\"] = \"value\";\n})(ValueTypes || (ValueTypes = {}));\nfunction getValueType(value) {\n    if (isTagComponent(value)) {\n        return ValueTypes.tagComponent;\n    }\n    if (isTagInstance(value)) {\n        return ValueTypes.tag;\n    }\n    if (isTagArray(value)) {\n        return ValueTypes.tagArray;\n    }\n    return ValueTypes.value;\n}\nexport function processSubjectValue(value, subject, // could be tag via result.tag\ntemplate, // <template end interpolate /> (will be removed)\nownerTag, // owner\noptions) {\n    const valueType = getValueType(value);\n    switch (valueType) {\n        case ValueTypes.tag:\n            processTag(value, subject, template, ownerTag);\n            return;\n        case ValueTypes.tagArray:\n            return processTagArray(subject, value, template, ownerTag, options);\n        case ValueTypes.tagComponent:\n            processSubjectComponent(value, subject, template, ownerTag, options);\n            return;\n    }\n    processRegularValue(value, subject, template);\n}\n/** Could be a regular tag or a component. Both are Tag.class */\nexport function processTag(tag, subject, // could be tag via result.tag\ninsertBefore, // <template end interpolate /> (will be removed)\nownerTag) {\n    // first time seeing this tag?\n    if (!tag.tagSupport) {\n        if (!isTagInstance(tag)) {\n            throw new Error('issue non-tag here');\n        }\n        applyFakeTemplater(tag, ownerTag, subject);\n        if (ownerTag.childTags.find(x => x === tag)) {\n            throw new Error('about to reattach tag already present - 5');\n        }\n        ownerTag.childTags.push(tag);\n    }\n    tag.ownerTag = ownerTag;\n    subject.template = insertBefore;\n    tag.buildBeforeElement(insertBefore, {\n        counts: { added: 0, removed: 0 },\n        forceElement: true, test: false,\n    });\n}\nexport function applyFakeTemplater(tag, ownerTag, subject) {\n    if (!ownerTag) {\n        throw new Error('no owner error');\n    }\n    const fakeTemplater = getFakeTemplater();\n    tag.tagSupport = new TagSupport(ownerTag.tagSupport, fakeTemplater, // the template is provided via html`` call\n    subject);\n    fakeTemplater.global.oldest = tag;\n    fakeTemplater.global.newest = tag;\n    fakeTemplater.tagSupport = tag.tagSupport;\n    // asking me to render will cause my parent to render\n    tag.ownerTag = ownerTag;\n}\nfunction getFakeTemplater() {\n    return {\n        global: {\n            renderCount: 0,\n            providers: [],\n            context: {},\n        },\n        children: new ValueSubject([]), // no children\n        props: {},\n        isTag: true,\n    };\n}\n","import { ValueSubject } from './ValueSubject';\nimport { ArrayNoKeyError } from './errors';\nimport { destroyArrayTag } from './checkDestroyPrevious.function';\nimport { applyFakeTemplater } from './processSubjectValue.function';\nexport function processTagArray(subject, value, // arry of Tag classes\ntemplate, // <template end interpolate />\nownerTag, options) {\n    const clones = ownerTag.clones; // []\n    let lastArray = subject.lastArray = subject.lastArray || [];\n    subject.template = template;\n    let removed = 0;\n    /** 🗑️ remove previous items first */\n    lastArray = subject.lastArray = subject.lastArray.filter((item, index) => {\n        const newLength = value.length - 1;\n        const at = index - removed;\n        const lessLength = newLength < at;\n        const subTag = value[index - removed];\n        const subArrayValue = subTag?.arrayValue;\n        const destroyItem = lessLength || !areLikeValues(subArrayValue, item.tag.arrayValue);\n        if (destroyItem) {\n            const last = lastArray[index];\n            const tag = last.tag;\n            destroyArrayTag(tag, options.counts);\n            last.deleted = true;\n            ++removed;\n            ++options.counts.removed;\n            return false;\n        }\n        return true;\n    });\n    // const masterBefore = template || (template as any).clone\n    const before = template || subject.value.insertBefore || template.clone;\n    value.forEach((subTag, index) => {\n        const previous = lastArray[index];\n        const previousSupport = previous?.tag.tagSupport;\n        const fakeSubject = new ValueSubject({});\n        applyFakeTemplater(subTag, ownerTag, fakeSubject);\n        if (previousSupport) {\n            subTag.tagSupport.templater.global = previousSupport.templater.global;\n            previousSupport.templater.global.newest = subTag;\n        }\n        // check for html``.key()\n        const keyNotSet = subTag.arrayValue;\n        if (keyNotSet?.isArrayValueNeverSet) {\n            const details = {\n                template: subTag.getTemplate().string,\n                array: value,\n                ownerTagContent: ownerTag.lastTemplateString,\n            };\n            const message = 'Use html`...`.key(item) instead of html`...` to template an Array';\n            console.error(message, details);\n            const err = new ArrayNoKeyError(message, details);\n            throw err;\n        }\n        const couldBeSame = lastArray.length > index;\n        if (couldBeSame) {\n            const isSame = areLikeValues(previous.tag.arrayValue, subTag.arrayValue);\n            if (isSame) {\n                subTag.tagSupport = subTag.tagSupport || previous.tag.tagSupport;\n                const oldest = previous.tag.tagSupport.templater.global.oldest;\n                oldest.updateByTag(subTag);\n                return [];\n            }\n            processAddTagArrayItem(before, subTag, index, options, lastArray, true);\n            throw new Error('item should be back');\n            // return [] // removed: item should have been previously deleted and will be added back\n        }\n        processAddTagArrayItem(before, subTag, index, options, lastArray, true);\n        ownerTag.childTags.push(subTag);\n    });\n    return clones;\n}\nfunction processAddTagArrayItem(before, subTag, index, options, lastArray, test) {\n    const lastValue = {\n        tag: subTag, index\n    };\n    // Added to previous array\n    lastArray.push(lastValue);\n    const counts = {\n        added: options.counts.added + index,\n        removed: options.counts.removed,\n    };\n    const lastFirstChild = before; // tag.clones[0] // insertBefore.lastFirstChild    \n    if (!lastFirstChild.parentNode) {\n        throw new Error('issue adding array item');\n    }\n    subTag.buildBeforeElement(lastFirstChild, { counts, forceElement: options.forceElement, test });\n}\n/** compare two values. If both values are arrays then the items will be compared */\nfunction areLikeValues(valueA, valueB) {\n    if (valueA === valueB) {\n        return true;\n    }\n    const bothArrays = valueA instanceof Array && valueB instanceof Array;\n    const matchLengths = bothArrays && valueA.length == valueB.length;\n    if (matchLengths) {\n        return valueA.every((item, index) => item == valueB[index]);\n    }\n    return false;\n}\n","import { destroyTagMemory } from './destroyTag.function';\nexport function processTagResult(tag, subject, // used for recording past and current value\ninsertBefore, // <template end interpolate />\n{ counts, forceElement, }) {\n    if (!insertBefore.parentNode) {\n        throw new Error('before here processTagResult');\n    }\n    // *if appears we already have seen\n    const subjectTag = subject;\n    const existingTag = subjectTag.tag;\n    const previousTag = existingTag?.tagSupport.templater.global.oldest || undefined; // || tag.tagSupport.oldest // subjectTag.tag\n    const justUpdate = previousTag; // && !forceElement\n    if (previousTag) {\n        if (justUpdate) {\n            const areLike = previousTag.isLikeTag(tag);\n            // are we just updating an if we already had?\n            if (areLike) {\n                // components\n                if (subject instanceof Function) {\n                    const newTag = subject(previousTag.tagSupport);\n                    previousTag.updateByTag(newTag);\n                    if (!newTag.tagSupport.templater.global.oldest) {\n                        throw new Error('maybe 0');\n                    }\n                    subjectTag.tag = newTag;\n                    if (!newTag.hasLiveElements) {\n                        throw new Error('44444 - 2');\n                    }\n                    return;\n                }\n                previousTag.updateByTag(tag);\n                if (!tag.tagSupport.templater.global.oldest) {\n                    throw new Error('maybe 1');\n                }\n                subjectTag.tag = tag;\n                if (!tag.hasLiveElements) {\n                    throw new Error('44444 - 3');\n                }\n                return;\n            }\n            destroyTagMemory(previousTag, subject);\n            throw new Error('585 - think we never get here');\n        }\n    }\n    tag.buildBeforeElement(insertBefore, {\n        counts,\n        forceElement, test: false,\n    });\n}\n","import { deepClone, deepEqual } from './deepFunctions';\nimport { renderTagSupport } from './renderTagSupport.function';\nexport function providersChangeCheck(tag) {\n    const global = tag.tagSupport.templater.global;\n    const providersWithChanges = global.providers.filter(provider => !deepEqual(provider.instance, provider.clone));\n    // reset clones\n    providersWithChanges.forEach(provider => {\n        const appElement = tag.getAppElement();\n        handleProviderChanges(appElement, provider);\n        provider.clone = deepClone(provider.instance);\n    });\n}\nfunction handleProviderChanges(appElement, provider) {\n    const tagsWithProvider = getTagsWithProvider(appElement, provider);\n    tagsWithProvider.forEach(({ tag, renderCount, provider }) => {\n        if (tag.tagSupport.templater.global.deleted) {\n            return; // i was deleted after another tag processed\n        }\n        const notRendered = renderCount === tag.tagSupport.templater.global.renderCount;\n        if (notRendered) {\n            provider.clone = deepClone(provider.instance);\n            renderTagSupport(tag.tagSupport, false);\n        }\n    });\n}\nfunction getTagsWithProvider(tag, provider, memory = []) {\n    const global = tag.tagSupport.templater.global;\n    const compare = global.providers;\n    const hasProvider = compare.find(xProvider => xProvider.constructMethod === provider.constructMethod);\n    if (hasProvider) {\n        memory.push({\n            tag,\n            renderCount: global.renderCount,\n            provider: hasProvider,\n        });\n    }\n    tag.childTags.forEach(child => getTagsWithProvider(child, provider, memory));\n    memory.forEach(({ tag }) => {\n        if (tag.tagSupport.templater.global.deleted) {\n            throw new Error('do not get here - 0');\n        }\n    });\n    return memory;\n}\n","import { deepClone } from './deepFunctions';\nimport { setUse } from './setUse.function';\n// TODO: rename\nsetUse.memory.providerConfig = {\n    providers: [],\n    //currentTagSupport: undefined as TagSupport | undefined,\n    ownerTag: undefined,\n};\nfunction get(constructMethod) {\n    const config = setUse.memory.providerConfig;\n    const providers = config.providers;\n    return providers.find(provider => provider.constructMethod === constructMethod);\n}\nexport const providers = {\n    create: (constructMethod) => {\n        const existing = get(constructMethod);\n        if (existing) {\n            existing.clone = deepClone(existing.instance);\n            return existing.instance;\n        }\n        // Providers with provider requirements just need to use providers.create() and providers.inject()\n        const instance = constructMethod.constructor ? new constructMethod() : constructMethod();\n        const config = setUse.memory.providerConfig;\n        config.providers.push({\n            constructMethod,\n            instance,\n            clone: deepClone(instance)\n        });\n        return instance;\n    },\n    /**\n     * @template T\n     * @param {(new (...args: any[]) => T) | () => T} constructor\n     * @returns {T}\n     */\n    inject: (constructor) => {\n        const oldValue = get(constructor);\n        if (oldValue) {\n            return oldValue.instance;\n        }\n        const config = setUse.memory.providerConfig;\n        let owner = {\n            ownerTag: config.ownerTag\n        };\n        while (owner.ownerTag) {\n            const ownerProviders = owner.ownerTag.tagSupport.templater.global.providers;\n            const provider = ownerProviders.find(provider => {\n                if (provider.constructMethod === constructor) {\n                    return true;\n                }\n            });\n            if (provider) {\n                provider.clone = deepClone(provider.instance); // keep a copy of the latest before any change occur\n                config.providers.push(provider);\n                return provider.instance;\n            }\n            owner = owner.ownerTag; // cause reloop\n        }\n        const msg = `Could not inject provider: ${constructor.name} ${constructor}`;\n        console.warn(`${msg}. Available providers`, config.providers);\n        throw new Error(msg);\n    }\n};\nsetUse({\n    beforeRender: (tagSupport, ownerTag) => {\n        run(tagSupport, ownerTag);\n    },\n    beforeRedraw: (tagSupport, tag) => {\n        run(tagSupport, tag.ownerTag);\n    },\n    afterRender: (tagSupport) => {\n        const config = setUse.memory.providerConfig;\n        tagSupport.templater.global.providers = [...config.providers];\n        config.providers.length = 0;\n    }\n});\nfunction run(tagSupport, ownerTag) {\n    const config = setUse.memory.providerConfig;\n    // config.currentTagSupport = tagSupport\n    config.ownerTag = ownerTag;\n    if (tagSupport.templater.global.providers.length) {\n        config.providers.length = 0;\n        config.providers.push(...tagSupport.templater.global.providers);\n    }\n}\n","import { renderWithSupport } from \"./TemplaterResult.class\";\n/** for components */\nexport function redrawTag(subject, templater, ownerTag) {\n    const existingTag = subject.tag || templater.global.newest || templater.global.oldest;\n    if (!templater.global.oldest) {\n        throw new Error('issue before event redraw');\n    }\n    const tagSupport = templater.tagSupport; // || existingTag?.tagSupport\n    if (!templater.tagSupport) {\n        throw new Error('need tag support');\n    }\n    if (!tagSupport.templater.global.oldest) {\n        throw new Error('33333');\n    }\n    let retag = renderWithSupport(tagSupport, existingTag, subject, ownerTag);\n    return retag;\n}\n","export function buildClones(temporary, insertBefore) {\n    const clones = [];\n    const template = temporary.children[0];\n    let nextSibling = template.content.firstChild;\n    while (nextSibling) {\n        const nextNextSibling = nextSibling.nextSibling;\n        buildSibling(nextSibling, insertBefore);\n        clones.push(nextSibling);\n        nextSibling = nextNextSibling;\n    }\n    return clones;\n}\nfunction buildSibling(nextSibling, insertBefore) {\n    const parentNode = insertBefore.parentNode;\n    parentNode.insertBefore(nextSibling, insertBefore);\n}\n","import { providersChangeCheck } from './provider.utils';\nimport { isLikeTags } from './isLikeTags.function';\nimport { redrawTag } from './redrawTag.function';\n/** Returns true when rendering owner is not needed. Returns false when rendering owner should occur */\nexport function renderExistingTag(oldestTag, // existing tag already there\nnewTemplater, tagSupport, subject) {\n    if (subject.tag) {\n        newTemplater.global = subject.tag.tagSupport.templater.global;\n    }\n    if (!oldestTag.hasLiveElements) {\n        throw new Error('1080');\n    }\n    const preRenderCount = tagSupport.templater.global.renderCount;\n    providersChangeCheck(oldestTag);\n    // When the providers were checked, a render to myself occurred and I do not need to re-render again\n    const latestTag = tagSupport.templater.global.newest;\n    if (preRenderCount !== tagSupport.templater.global.renderCount) {\n        oldestTag.updateByTag(latestTag);\n        return latestTag;\n    }\n    const oldTemplater = tagSupport.templater || newTemplater;\n    const redraw = redrawTag(subject, newTemplater, oldestTag.ownerTag);\n    const oldest = tagSupport.templater.global.oldest || oldestTag;\n    redraw.tagSupport.templater.global.oldest = oldest;\n    if (redraw != redraw.tagSupport.templater.global.newest) {\n        throw new Error('newest mismatched 22');\n    }\n    if (!redraw.tagSupport.templater.global.oldest) {\n        throw new Error('8888888 - 0');\n    }\n    if (!oldTemplater.global.oldest) {\n        throw new Error('8888888');\n    }\n    // ??? - add to ensure setProps causes lower redraw\n    if (isLikeTags(latestTag, redraw)) {\n        oldest.updateByTag(redraw);\n    }\n    return redraw;\n}\n","import { deepEqual } from './deepFunctions';\nimport { isTagInstance } from './isInstance';\nimport { renderExistingTag } from './renderExistingTag.function';\n/** Main function used by all other callers to render/update display of a tag component */\nexport function renderTagSupport(tagSupport, renderUp) {\n    const global = tagSupport.templater.global;\n    if (isTagInstance(tagSupport.templater)) {\n        const newTag = global.newest;\n        const ownerTag = newTag.ownerTag;\n        ++global.renderCount;\n        return renderTagSupport(ownerTag.tagSupport, true);\n    }\n    // const oldTagSetup = this\n    const subject = tagSupport.subject;\n    const templater = tagSupport.templater; // oldTagSetup.templater // templater\n    const subjectTag = subject.tag;\n    const newest = subjectTag?.tagSupport.templater.global.newest;\n    let ownerTag;\n    let selfPropChange = false;\n    if (renderUp && newest) {\n        ownerTag = newest.ownerTag;\n        if (ownerTag) {\n            const nowProps = templater.props;\n            const latestProps = newest.tagSupport.propsConfig.latestCloned;\n            selfPropChange = !deepEqual(nowProps, latestProps);\n        }\n    }\n    const useTagSupport = global.newest?.tagSupport; // oldTagSetup\n    if (!templater.global.oldest) {\n        throw new Error('already causing trouble');\n    }\n    const tag = renderExistingTag(templater.global.oldest, templater, useTagSupport, subject);\n    /*\n    const tag = exit.redraw\n  \n    if(exit.remit) {\n      return tag\n    }\n    */\n    // Have owner re-render\n    // ??? - recently removed. As causes some sort of owner newest disconnect during prop testing\n    // ??? - restored with condition - must render parent if I modified my props\n    if (ownerTag && selfPropChange) {\n        const ownerTagSupport = ownerTag.tagSupport;\n        renderTagSupport(ownerTagSupport, true);\n        return tag;\n    }\n    return tag;\n}\n","import { processAttribute } from './processAttribute.function';\nconst search = new RegExp('\\\\s*<template interpolate end id=\"__tagvar(\\\\d{1,4})\"([^>]*)></template>(\\\\s*)');\nexport function scanTextAreaValue(textarea, context, ownerTag) {\n    const value = textarea.value;\n    if (value.search(search) >= 0) {\n        const match = value.match(/__tagvar(\\d{1,4})/);\n        const token = match ? match[0] : '';\n        const dynamic = '{' + token + '}';\n        textarea.value = '';\n        textarea.setAttribute('text-var-value', dynamic);\n        const howToSet = (_elm, _name, value) => textarea.value = value;\n        processAttribute('text-var-value', dynamic, // realValue, // context[token].value,\n        textarea, context, ownerTag, howToSet);\n    }\n}\n","import { StateMismatchError } from './errors';\nimport { setUse } from './setUse.function';\n// TODO: rename\nsetUse.memory.stateConfig = {\n    array: [], // state memory on the first render\n    // rearray: [] as StateConfigArray, // state memory to be used before the next render\n};\nsetUse({\n    beforeRender: (tagSupport) => initState(tagSupport),\n    beforeRedraw: (tagSupport) => initState(tagSupport),\n    afterRender: (tagSupport) => {\n        const state = tagSupport.memory.state;\n        const config = setUse.memory.stateConfig;\n        const rearray = config.rearray;\n        if (rearray.length) {\n            if (rearray.length !== config.array.length) {\n                const message = `States lengths has changed ${rearray.length} !== ${config.array.length}. Typically occurs when a function is intended to be wrapped with a tag() call`;\n                const details = {\n                    oldStates: config.array,\n                    newStates: config.rearray,\n                    component: tagSupport.templater?.wrapper.original,\n                };\n                const error = new StateMismatchError(message, details);\n                console.warn(message, details);\n                throw error;\n            }\n        }\n        delete config.rearray; // clean up any previous runs\n        state.newest = config.array; // [...config.array]\n        state.newest.forEach(item => item.lastValue = getStateValue(item)); // set last values\n        config.array = [];\n    }\n});\nexport function getStateValue(\n// state: StateConfig,\nstate) {\n    const callback = state.callback;\n    if (!callback) {\n        return state.defaultValue;\n    }\n    const oldState = callback(StateEchoBack); // get value and set to undefined\n    const [oldValue] = oldState;\n    const [checkValue] = callback(oldValue); // set back to original value\n    if (checkValue !== StateEchoBack) {\n        const message = 'State property not used correctly. Second item in array is not setting value as expected.\\n\\n' +\n            'For \"let\" state use `let name = state(default)(x => [name, name = x])`\\n\\n' +\n            'For \"const\" state use `const name = state(default)()`\\n\\n' +\n            'Problem state:\\n' + (callback ? callback.toString() : JSON.stringify(state)) + '\\n';\n        console.error(message, { state, callback, oldState, oldValue, checkValue });\n        throw new Error(message);\n    }\n    // state.lastValue = oldValue\n    return oldValue;\n}\nexport class StateEchoBack {\n}\nfunction initState(tagSupport) {\n    const state = tagSupport.memory.state;\n    const config = setUse.memory.stateConfig;\n    // TODO: This guard may no longer be needed\n    if (config.rearray) {\n        const message = 'last state not cleared. Possibly in the middle of rendering one component and another is trying to render';\n        console.error(message, {\n            config,\n            component: tagSupport.templater?.wrapper.original,\n            wasInMiddleOf: config.tagSupport?.templater.wrapper.original,\n            state,\n            expectedClearArray: config.rearray,\n        });\n        throw new StateMismatchError(message, {\n            config,\n            component: tagSupport.templater?.wrapper.original,\n            state,\n            expectedClearArray: config.rearray,\n        });\n    }\n    // TODO: this maybe redundant and not needed\n    config.rearray = []; // .length = 0\n    if (state?.newest.length) {\n        state.newest.map(state => getStateValue(state));\n        config.rearray.push(...state.newest);\n    }\n    config.tagSupport = tagSupport;\n}\n/** Used for variables that need to remain the same variable during render passes */\nexport function set(defaultValue) {\n    const config = setUse.memory.stateConfig;\n    let getSetMethod;\n    const rearray = config.rearray;\n    const restate = rearray[config.array.length];\n    if (restate) {\n        let oldValue = getStateValue(restate);\n        getSetMethod = ((x) => [oldValue, oldValue = x]);\n        const push = {\n            get: () => getStateValue(push),\n            callback: getSetMethod,\n            lastValue: oldValue,\n            defaultValue: restate.defaultValue,\n        };\n        config.array.push(push);\n        return oldValue;\n    }\n    // State first time run\n    const defaultFn = defaultValue instanceof Function ? defaultValue : () => defaultValue;\n    let initValue = defaultFn();\n    getSetMethod = ((x) => [initValue, initValue = x]);\n    const push = {\n        get: () => getStateValue(push),\n        callback: getSetMethod,\n        lastValue: initValue,\n        defaultValue: initValue,\n    };\n    config.array.push(push);\n    return initValue;\n}\n","import { getStateValue } from './set.function';\nimport { setUse } from './setUse.function';\n/** Used for variables that need to remain the same variable during render passes */\nexport function setLet(defaultValue) {\n    const config = setUse.memory.stateConfig;\n    const rearray = config.rearray;\n    let getSetMethod;\n    const restate = rearray[config.array.length];\n    if (restate) {\n        let oldValue = getStateValue(restate);\n        getSetMethod = ((x) => [oldValue, oldValue = x]);\n        const push = {\n            get: () => getStateValue(push),\n            callback: getSetMethod,\n            lastValue: oldValue,\n            defaultValue: restate.defaultValue,\n        };\n        config.array.push(push);\n        return makeStateResult(oldValue, push);\n    }\n    // State first time run\n    const defaultFn = defaultValue instanceof Function ? defaultValue : () => defaultValue;\n    let initValue = defaultFn();\n    getSetMethod = ((x) => [initValue, initValue = x]);\n    const push = {\n        get: () => getStateValue(push),\n        callback: getSetMethod,\n        lastValue: initValue,\n        defaultValue: initValue,\n    };\n    config.array.push(push);\n    return makeStateResult(initValue, push);\n}\nfunction makeStateResult(initValue, push) {\n    // return initValue\n    const result = (y) => {\n        push.callback = y || (x => [initValue, initValue = x]);\n        return initValue;\n    };\n    return result;\n}\n","import { getStateValue } from './set.function';\nimport { setUse } from './setUse.function';\n/** Used for variables that need to remain the same variable during render passes */\nexport function setProp(getSet) {\n    const config = setUse.memory.stateConfig;\n    const rearray = config.rearray;\n    const [propValue] = getSet(undefined);\n    getSet(propValue); // restore original value instead of undefined\n    const restate = rearray[config.array.length];\n    if (restate) {\n        let watchValue = restate.watch;\n        let oldValue = getStateValue(restate);\n        const push = {\n            get: () => getStateValue(push),\n            callback: getSet,\n            lastValue: oldValue,\n            watch: restate.watch,\n        };\n        // has the prop value changed?\n        if (propValue != watchValue) {\n            push.watch = propValue;\n            oldValue = push.lastValue = propValue;\n        }\n        config.array.push(push);\n        getSet(oldValue);\n        return oldValue;\n    }\n    const push = {\n        get: () => getStateValue(push),\n        callback: getSet,\n        lastValue: propValue,\n        watch: propValue,\n    };\n    config.array.push(push);\n    return propValue;\n}\n","const tagUse = [];\nexport function setUse(use) {\n    // must provide defaults\n    const useMe = {\n        beforeRender: use.beforeRender || (() => undefined),\n        beforeRedraw: use.beforeRedraw || (() => undefined),\n        afterRender: use.afterRender || (() => undefined),\n        beforeDestroy: use.beforeDestroy || (() => undefined),\n    };\n    setUse.tagUse.push(useMe);\n}\nsetUse.tagUse = tagUse;\nsetUse.memory = {};\n","import { isSubjectInstance, isTagArray, isTagInstance } from './isInstance';\nimport { setUse } from './setUse.function';\nimport { TemplaterResult } from './TemplaterResult.class';\nimport { ValueSubject } from './ValueSubject';\nimport { runTagCallback } from './bindSubjectCallback.function';\nimport { deepClone } from './deepFunctions';\nimport { TagSupport } from './TagSupport.class';\nimport { alterProps } from './alterProps.function';\nexport const tags = [];\nlet tagCount = 0;\n/** Wraps a tag component in a state manager and always push children to last argument as an array */\n// export function tag<T>(a: T): T;\nexport function tag(tagComponent) {\n    const result = (function tagWrapper(props, children) {\n        const isPropTag = isTagInstance(props) || isTagArray(props);\n        if (isPropTag) {\n            children = props;\n            props = undefined;\n        }\n        const { childSubject, madeSubject } = kidsToTagArraySubject(children);\n        childSubject.isChildSubject = true;\n        const templater = new TemplaterResult(props, childSubject);\n        const innerTagWrap = getTagWrap(templater, madeSubject);\n        innerTagWrap.original = tagComponent;\n        templater.tagged = true;\n        templater.wrapper = innerTagWrap;\n        return templater;\n    }); // we override the function provided and pretend original is what's returned\n    updateResult(result, tagComponent);\n    // group tags together and have hmr pickup\n    updateComponent(tagComponent);\n    tags.push(tagComponent);\n    return result;\n}\nfunction kidsToTagArraySubject(children) {\n    if (isSubjectInstance(children)) {\n        return { childSubject: children, madeSubject: false };\n    }\n    const kidArray = children;\n    if (isTagArray(kidArray)) {\n        return { childSubject: new ValueSubject(children), madeSubject: true };\n    }\n    const kid = children;\n    if (kid) {\n        kid.arrayValue = 0;\n        return { childSubject: new ValueSubject([kid]), madeSubject: true };\n    }\n    return {\n        childSubject: new ValueSubject([]),\n        madeSubject: true\n    };\n}\nfunction updateResult(result, tagComponent) {\n    result.isTag = true;\n    result.original = tagComponent;\n}\nfunction updateComponent(tagComponent) {\n    tagComponent.tags = tags;\n    tagComponent.setUse = setUse;\n    tagComponent.tagIndex = tagCount++; // needed for things like HMR\n}\n/** creates/returns a function that when called then calls the original component function */\nfunction getTagWrap(templater, madeSubject) {\n    const innerTagWrap = function (oldTagSetup, subject) {\n        const global = oldTagSetup.templater.global;\n        global.newestTemplater = templater;\n        ++global.renderCount;\n        templater.global = global;\n        const childSubject = templater.children;\n        const lastArray = global.oldest?.tagSupport.templater.children.lastArray;\n        if (lastArray) {\n            childSubject.lastArray = lastArray;\n        }\n        const originalFunction = innerTagWrap.original;\n        // const oldTagSetup = templater.tagSupport\n        const oldest = templater.global.oldest;\n        if (oldest && !oldest.hasLiveElements) {\n            throw new Error('issue already 22');\n        }\n        // ???\n        let props = templater.props;\n        // let props = oldTagSetup.propsConfig.latest\n        const ownerTagSupport = oldTagSetup.ownerTagSupport;\n        const oldTemplater = ownerTagSupport?.templater;\n        const oldLatest = oldTemplater?.global.newest;\n        const newestOwnerTemplater = oldLatest?.tagSupport.templater;\n        if (oldLatest && !newestOwnerTemplater) {\n            throw new Error('what to do here?');\n        }\n        // ???\n        let castedProps = alterProps(props, newestOwnerTemplater, oldTagSetup.ownerTagSupport);\n        const clonedProps = deepClone(props); // castedProps\n        // CALL ORIGINAL COMPONENT FUNCTION\n        const tag = originalFunction(castedProps, childSubject);\n        tag.tagSupport = new TagSupport(oldTagSetup.ownerTagSupport, templater, subject);\n        tag.tagSupport.propsConfig = {\n            latest: props, // castedProps\n            latestCloned: clonedProps,\n            clonedProps: clonedProps,\n            lastClonedKidValues: tag.tagSupport.propsConfig.lastClonedKidValues,\n        };\n        tag.tagSupport.memory = oldTagSetup.memory; // state handover\n        if (madeSubject) {\n            childSubject.value.forEach(kid => {\n                kid.values.forEach((value, index) => {\n                    if (!(value instanceof Function)) {\n                        return;\n                    }\n                    const valuesValue = kid.values[index];\n                    if (valuesValue.isChildOverride) {\n                        return; // already overwritten\n                    }\n                    // all functions need to report to me\n                    kid.values[index] = function (...args) {\n                        const ownerTag = tag.ownerTag;\n                        runTagCallback(value, // callback\n                        ownerTag, this, // bindTo\n                        args);\n                    };\n                    valuesValue.isChildOverride = true;\n                });\n            });\n        }\n        return tag;\n    };\n    return innerTagWrap;\n}\n","import { BaseTagSupport } from './TagSupport.class';\nimport { runAfterRender, runBeforeRender } from './tagRunner';\nimport { ValueSubject } from './ValueSubject';\nconst appElements = [];\nexport function tagElement(app, // (...args: unknown[]) => TemplaterResult,\nelement, props) {\n    const appElmIndex = appElements.findIndex(appElm => appElm.element === element);\n    if (appElmIndex >= 0) {\n        appElements[appElmIndex].tag.destroy();\n        appElements.splice(appElmIndex, 1);\n        // an element already had an app on it\n        console.warn('Found and destroyed app element already rendered to element', { element });\n    }\n    // Create the app which returns [props, runOneTimeFunction]\n    const wrapper = app(props);\n    // have a function setup and call the tagWrapper with (props, {update, async, on})\n    const result = applyTagUpdater(wrapper);\n    const { tag } = result;\n    // TODO: is the below needed?\n    tag.appElement = element;\n    tag.tagSupport.templater.global.isApp = true;\n    const templateElm = document.createElement('template');\n    templateElm.setAttribute('id', 'app-tag-' + appElements.length);\n    templateElm.setAttribute('app-tag-detail', appElements.length.toString());\n    element.appendChild(templateElm);\n    tag.buildBeforeElement(templateElm);\n    wrapper.global.oldest = tag;\n    wrapper.global.newest = tag;\n    if (!tag.hasLiveElements) {\n        throw new Error('x');\n    }\n    ;\n    element.setUse = app.original.setUse;\n    appElements.push({ element, tag });\n    return { tag, tags: app.original.tags };\n}\nexport function applyTagUpdater(wrapper) {\n    const subject = new ValueSubject({});\n    const tagSupport = new BaseTagSupport(wrapper, subject);\n    wrapper.tagSupport = tagSupport;\n    runBeforeRender(tagSupport, undefined);\n    // Call the apps function for our tag templater\n    const tag = wrapper.wrapper(tagSupport, subject);\n    // wrapper.global.oldest = tag\n    // wrapper.global.newest = tag\n    runAfterRender(tagSupport, tag);\n    return { tag, tagSupport };\n}\n","// TODO: This should be more like `new TaggedJs().use({})`\nimport { setUse } from './setUse.function';\n// Life cycle 1\nexport function runBeforeRender(tagSupport, tagOwner) {\n    setUse.tagUse.forEach(tagUse => tagUse.beforeRender(tagSupport, tagOwner));\n}\n// Life cycle 2\nexport function runAfterRender(tagSupport, tag) {\n    setUse.tagUse.forEach(tagUse => tagUse.afterRender(tagSupport, tag));\n}\n// Life cycle 3\nexport function runBeforeRedraw(tagSupport, tag) {\n    setUse.tagUse.forEach(tagUse => tagUse.beforeRedraw(tagSupport, tag));\n}\n// Life cycle 4 - end of life\nexport function runBeforeDestroy(tagSupport, tag) {\n    setUse.tagUse.forEach(tagUse => tagUse.beforeDestroy(tagSupport, tag));\n}\n","import { hasTagSupportChanged } from './hasTagSupportChanged.function';\nimport { TagSupport } from './TagSupport.class';\nimport { processSubjectComponent } from './processSubjectComponent.function';\nimport { destroyTagMemory } from './destroyTag.function';\nimport { renderTagSupport } from './renderTagSupport.function';\nexport function updateExistingTagComponent(ownerTag, tempResult, subject, insertBefore) {\n    let existingTag = subject.tag;\n    /*\n    if(existingTag && !existingTag.hasLiveElements) {\n      throw new Error('issue already began')\n    }\n    */\n    const oldWrapper = existingTag.tagSupport.templater.wrapper;\n    const newWrapper = tempResult.wrapper;\n    let isSameTag = false;\n    if (tempResult.global.oldest && !tempResult.global.oldest.hasLiveElements) {\n        throw new Error('88893434');\n    }\n    if (oldWrapper && newWrapper) {\n        const oldFunction = oldWrapper.original;\n        const newFunction = newWrapper.original;\n        isSameTag = oldFunction === newFunction;\n    }\n    const oldTagSupport = existingTag.tagSupport;\n    const oldGlobal = oldTagSupport.templater.global;\n    const globalInsert = oldGlobal.insertBefore;\n    const oldInsertBefore = globalInsert?.parentNode ? globalInsert : insertBefore;\n    if (!oldInsertBefore.parentNode) {\n        throw new Error('stop here no parent node update existing tag');\n    }\n    if (!isSameTag) {\n        destroyTagMemory(oldTagSupport.templater.global.oldest, subject);\n        processSubjectComponent(tempResult, subject, oldInsertBefore, ownerTag, {\n            forceElement: false,\n            counts: { added: 0, removed: 0 },\n        });\n        return;\n    }\n    else {\n        if (!tempResult.tagSupport) {\n            tempResult.tagSupport = new TagSupport(oldTagSupport.ownerTagSupport, tempResult, subject);\n        }\n        const newTagSupport = tempResult.tagSupport;\n        const hasChanged = hasTagSupportChanged(oldTagSupport, newTagSupport, tempResult);\n        if (!hasChanged) {\n            return; // its the same tag component\n        }\n    }\n    const oldestTag = tempResult.global.oldest; // oldTagSupport.oldest as Tag // existingTag\n    const previous = tempResult.global.newest;\n    if (!previous || !oldestTag) {\n        throw new Error('how no previous or oldest nor newest?');\n    }\n    const newTag = renderTagSupport(tempResult.tagSupport, false);\n    existingTag = subject.tag;\n    const newOldest = newTag.tagSupport.templater.global.oldest;\n    const hasOldest = newOldest ? true : false;\n    if (!hasOldest) {\n        return buildNewTag(newTag, oldInsertBefore, oldTagSupport, subject);\n    }\n    if (newOldest && tempResult.children.value.length) {\n        const oldKidsSub = newOldest.tagSupport.templater.children;\n        oldKidsSub.set(tempResult.children.value);\n    }\n    // const newTag = tempResult.newest as Tag\n    if (previous && !oldestTag) {\n        throw new Error('bad elders');\n    }\n    // detect if both the function is the same and the return is the same\n    const isLikeTag = isSameTag && previous.isLikeTag(newTag);\n    if (previous && !oldestTag) {\n        throw new Error('bad elders');\n    }\n    let oldest = oldTagSupport.templater.global.oldest;\n    if (isLikeTag) {\n        if (!newTag.tagSupport.templater.global.oldest) {\n            throw new Error('maybe 6');\n        }\n        subject.tag = newTag;\n        /*\n        if(!newTag.hasLiveElements) {\n          throw new Error('44444 - 6')\n        }\n        */\n        oldestTag.updateByTag(newTag); // the oldest tag has element references\n    }\n    else {\n        // Although function looked the same it returned a different html result\n        if (isSameTag && existingTag) {\n            destroyTagMemory(existingTag, subject);\n            newTag.tagSupport.templater.global.context = {}; // do not share previous outputs\n        }\n        oldest = undefined;\n        // ??? - new remove\n        // subject.tag = newTag\n    }\n    if (!oldest) {\n        buildNewTag(newTag, oldTagSupport.templater.global.insertBefore, oldTagSupport, subject);\n    }\n    oldTagSupport.templater.global.newest = newTag;\n    return;\n}\nfunction checkStateChanged(state) {\n    return !state.newest.every(state => {\n        const lastValue = state.lastValue;\n        const nowValue = state.get();\n        const matched = lastValue === nowValue;\n        if (matched) {\n            return true;\n        }\n        return false;\n    });\n}\nfunction buildNewTag(newTag, oldInsertBefore, oldTagSupport, subject) {\n    newTag.buildBeforeElement(oldInsertBefore, {\n        forceElement: true,\n        counts: { added: 0, removed: 0 }, test: false,\n    });\n    newTag.tagSupport.templater.global.oldest = newTag;\n    newTag.tagSupport.templater.global.newest = newTag;\n    oldTagSupport.templater.global.oldest = newTag;\n    oldTagSupport.templater.global.newest = newTag;\n    if (!newTag.tagSupport.templater.global.oldest) {\n        throw new Error('maybe 5');\n    }\n    subject.tag = newTag;\n    if (!newTag.hasLiveElements) {\n        throw new Error('44444 - 5');\n    }\n    return;\n}\n","import { isSubjectInstance, isTagArray, isTagComponent, isTagInstance } from './isInstance';\nimport { applyFakeTemplater, processTag } from './processSubjectValue.function';\nimport { processTagArray } from './processTagArray';\nimport { updateExistingTagComponent } from './updateExistingTagComponent.function';\nimport { processRegularValue } from './processRegularValue.function';\nimport { checkDestroyPrevious } from './checkDestroyPrevious.function';\nimport { processSubjectComponent } from './processSubjectComponent.function';\nimport { isLikeTags } from './isLikeTags.function';\nimport { bindSubjectCallback } from './bindSubjectCallback.function';\nexport function updateExistingValue(subject, value, ownerTag, insertBefore) {\n    const subjectSubTag = subject;\n    const isComponent = isTagComponent(value);\n    const oldInsertBefore = subject.template || subjectSubTag.tag?.tagSupport.templater.global.insertBefore || subject.clone;\n    checkDestroyPrevious(subject, value);\n    // handle already seen tag components\n    if (isComponent) {\n        const templater = value;\n        // When was something before component\n        if (!subjectSubTag.tag) {\n            processSubjectComponent(templater, subject, oldInsertBefore, ownerTag, {\n                forceElement: true,\n                counts: { added: 0, removed: 0 },\n            });\n            return subjectSubTag;\n        }\n        updateExistingTagComponent(ownerTag, templater, // latest value\n        subjectSubTag, insertBefore);\n        return subjectSubTag;\n    }\n    // was component but no longer\n    const subjectTag = subjectSubTag.tag;\n    if (subjectTag) {\n        handleStillTag(subjectTag, subject, value, ownerTag);\n        return subjectSubTag;\n    }\n    // its another tag array\n    if (isTagArray(value)) {\n        processTagArray(subject, value, oldInsertBefore, ownerTag, { counts: {\n                added: 0,\n                removed: 0,\n            } });\n        return subject;\n    }\n    // now its a function\n    if (value instanceof Function) {\n        // const newSubject = getSubjectFunction(value, ownerTag)\n        const bound = bindSubjectCallback(value, ownerTag);\n        subject.set(bound);\n        return subject;\n    }\n    if (isTagInstance(value)) {\n        subjectSubTag.template = oldInsertBefore;\n        processTag(value, subjectSubTag, subjectSubTag.template, ownerTag);\n        return subjectSubTag;\n    }\n    // we have been given a subject\n    if (isSubjectInstance(value)) {\n        return value;\n    }\n    // This will cause all other values to render\n    processRegularValue(value, subject, oldInsertBefore);\n    return subjectSubTag;\n}\nfunction handleStillTag(existingTag, subject, value, ownerTag) {\n    // TODO: We shouldn't need both of these\n    const isSameTag = value && isLikeTags(existingTag, value);\n    const isSameTag2 = value && value.getTemplate && existingTag.isLikeTag(value);\n    const tag = value;\n    if (!tag.tagSupport) {\n        applyFakeTemplater(tag, ownerTag, subject);\n    }\n    if (isSameTag) {\n        existingTag.updateByTag(tag);\n        return;\n    }\n    if (isSameTag || isSameTag2) {\n        return processTag(value, subject, subject.template, ownerTag);\n    }\n    return processRegularValue(value, subject, subject.template);\n}\n","import { setLet } from './setLet.function';\n/** When an item in watch array changes, callback function will be triggered */\nexport function watch(currentValues, callback) {\n    let previousValues = setLet(undefined)(x => [previousValues, previousValues = x]);\n    if (previousValues === undefined) {\n        callback(currentValues, previousValues);\n        // const result = {currentValues, previousValues}\n        previousValues = currentValues;\n        return currentValues;\n    }\n    const allExact = currentValues.every((item, index) => item === previousValues[index]);\n    if (allExact) {\n        return currentValues;\n    }\n    callback(currentValues, previousValues);\n    previousValues.length = 0;\n    previousValues.push(...currentValues);\n    return currentValues;\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","// import { redrawTag } from \"./redrawTag.function\"\nimport { tagElement } from \"./tagElement\";\nexport * from \"./ElementTargetEvent.interface\";\nexport * from \"./tag\";\nexport * from \"./html\";\nexport * from \"./errors\";\nexport * from \"./Subject\";\nexport * from \"./isInstance\";\nexport * from \"./ValueSubject\";\nexport * from \"./watch.function\";\nexport * from \"./TagSupport.class\";\n// export * from \"./redrawTag.function\"\nexport * from \"./interpolateElement\";\n// TODO: export *\nexport { tagElement } from \"./tagElement\";\nexport { Tag } from \"./Tag.class\";\nexport { runBeforeRender } from \"./tagRunner\";\nexport { setUse } from \"./setUse.function\";\n/* hooks */\n// TODO: export *\nexport { providers } from \"./providers\";\nexport { set } from \"./set.function\";\nexport { setLet } from \"./setLet.function\";\nexport { setProp } from \"./setProp.function\";\nexport * from \"./onInit\";\nexport * from \"./onDestroy\";\nexport * from \"./getCallback\";\n/* end: hooks */\nexport const hmr = {\n    tagElement,\n    // redrawTag\n};\n"],"names":[],"sourceRoot":""}

package/index.js

@@ -1 +1 @@
-var t={d:(e,r)=>{for(var n in r)t.o(r,n)&&!t.o(e,n)&&Object.defineProperty(e,n,{enumerable:!0,get:r[n]})},o:(t,e)=>Object.prototype.hasOwnProperty.call(t,e)},e={};function r(t,e,r,n){return e.renderWithSupport(t,r,n)}function n(t){const e={beforeRender:t.beforeRender||(()=>{}),beforeRedraw:t.beforeRedraw||(()=>{}),afterRender:t.afterRender||(()=>{}),beforeDestroy:t.beforeDestroy||(()=>{})};n.tagUse.push(e)}function o(t,e){n.tagUse.forEach((r=>r.beforeRender(t,e)))}function a(t,e){n.tagUse.forEach((r=>r.afterRender(t,e)))}function s(t,e){n.tagUse.forEach((r=>r.beforeRedraw(t,e)))}function i(t){return u(t,new WeakMap)}function u(t,e){if(null===t||"object"!=typeof t)return t;if(e.has(t))return e.get(t);if(t instanceof Date)return new Date(t);if(t instanceof RegExp)return new RegExp(t);const r=Array.isArray(t)?[]:Object.create(Object.getPrototypeOf(t));if(e.set(t,r),Array.isArray(t))for(let n=0;n<t.length;n++)r[n]=u(t[n],e);else for(const n in t)t.hasOwnProperty(n)&&(r[n]=u(t[n],e));return r}function c(t,e){return l(t,e,new WeakMap)}function l(t,e,r){if(t===e||(o=e,(n=t)instanceof Function&&o instanceof Function&&n.toString()===o.toString()))return!0;var n,o;if("object"!=typeof t||"object"!=typeof e||null===t||null===e)return!1;const a=Object.keys(t),s=Object.keys(e);if(a.length!==s.length)return!1;if(r.has(t))return!0;r.set(t,0);for(const n of a)if(!s.includes(n)||!l(t[n],e[n],r))return!1;if(Array.isArray(t)&&Array.isArray(e)){if(t.length!==e.length)return!1;for(let n=0;n<t.length;n++)if(!l(t[n],e[n],r))return!1}else if(Array.isArray(t)||Array.isArray(e))return!1;return!0}function p(t){t.tagSupport.memory.providers.filter((t=>!c(t.instance,t.clone))).forEach((e=>{!function(t,e){g(t,e).forEach((({tag:t,renderCount:e,provider:r})=>{e===t.tagSupport.memory.renderCount&&(r.clone=i(r.instance),t.tagSupport.render())}))}(t.getAppElement(),e),e.clone=i(e.instance)}))}function g(t,e,r=[]){const n=t.tagSupport.memory.providers.find((t=>t.constructMethod===e.constructMethod));return n&&r.push({tag:t,renderCount:t.tagSupport.memory.renderCount,provider:n}),t.children.forEach((t=>g(t,e,r))),r}t.d(e,{W9:()=>z,ei:()=>X,B7:()=>E,vw:()=>yt,PC:()=>K,uX:()=>v,Ot:()=>x,eQ:()=>zt,cF:()=>Yt,qy:()=>wt,xH:()=>Pt,u2:()=>it,zl:()=>ct,_4:()=>y,iO:()=>w,mn:()=>m,Yn:()=>h,Ly:()=>_t,sA:()=>Kt,MG:()=>Jt,r5:()=>Ut,iz:()=>r,vJ:()=>o,hZ:()=>Et,Un:()=>At,Ie:()=>Wt,AI:()=>n,Tc:()=>O,Hf:()=>f,TY:()=>Mt,_A:()=>F,wB:()=>Rt}),n.tagUse=[],n.memory={};const d=[];function f(t,e,r){const n=d.findIndex((t=>t.element===e));n>=0&&(d[n].tag.destroy(),d.splice(n,1),console.warn("Found and destroyed app element already rendered to element",{element:e}));const i=function(t){const e=t.tagSupport;o(e,void 0);const r=t.wrapper();return a(e,r),{tag:r,tagSupport:e}}(t(r)),{tag:u,tagSupport:c}=i;u.appElement=e,u.tagSupport.oldest=u,function(t,e){let r=e;t.mutatingRender=()=>{const n=t.memory.renderCount;if(p(e),n!==t.memory.renderCount)return r;s(e.tagSupport,e);const o=t.templater,i=r=o.wrapper();return i.tagSupport.memory=t.memory,t.propsConfig={...i.tagSupport.propsConfig},e.tagSupport.newest=i,a(e.tagSupport,e),t.oldest.updateByTag(i),t.newest=i,r}}(u.tagSupport,u);const l=document.createElement("template");return l.setAttribute("tag-detail","app-template-placeholder"),e.appendChild(l),u.buildBeforeElement(l),e.setUse=t.original.setUse,d.push({element:e,tag:u}),{tag:u,tags:t.original.tags}}function m(t){return!0===t?.isTemplater}function h(t){return!0===t?.isTag}function y(t){return!(!0!==t?.isSubject&&!t?.subscribe)}function w(t){return t instanceof Array&&t.every((t=>h(t)))}function b(t,e){if(t===e)throw new Error("someting here");const r=t.propsConfig.latest;if(function(t,e,r){if(void 0===t&&t===r)return!1;let n=t,o=e;if("object"==typeof t){if(!e)return!0;if(n={...t},o={...e||{}},!Object.entries(n).every((([t,e])=>{let r=o[t];return!(e instanceof Function)||r instanceof Function&&(r.original&&(r=r.original),e.original&&(e=e.original),e.toString()===r.toString()&&(delete n[t],delete o[t],!0))})))return!0}return!c(e,t)}(e.propsConfig.latest,t.propsConfig.latestCloned,r))return!0;const n=function(t,e){const r=t.propsConfig.lastClonedKidValues,n=e.propsConfig.lastClonedKidValues,o=r.every(((t,e)=>{const r=n[e];return t.every(((t,e)=>t===r[e]))}));return!o}(t,e);return n}class v{templater;children;propsConfig;memory={context:{},state:{newest:[]},providers:[],renderCount:0};constructor(t,e,r){this.templater=t,this.children=e;const n=T(r,t);this.propsConfig={latest:r,latestCloned:n,clonedProps:n,lastClonedKidValues:e.value.map((t=>S(t.values)))},h(r)||(this.propsConfig.latestCloned=i(n),this.propsConfig.clonedProps=this.propsConfig.latestCloned)}oldest;newest;mutatingRender(){const t='Tag function "render()" was called in sync but can only be called async';throw console.error(t,{tagSupport:this}),new Error(t)}render(){return++this.memory.renderCount,this.mutatingRender()}renderExistingTag(t,e){const r=this.memory.renderCount;if(p(t),r!==this.memory.renderCount)return!0;const n=b(t.tagSupport,e.tagSupport);return this.newest=this.templater.redraw(),!n}}function S(t){return t.map((t=>{const e=t;return h(e)?S(e.values):m(e)?i(e.tagSupport.propsConfig.latestCloned):w(e)?S(e):i(t)}))}class C{tagged;wrapper;newest;oldest;tagSupport;constructor(t,e){this.tagSupport=new v(this,e,t)}redraw;isTemplater=!0;forceRenderTemplate(t,e){const r=this.wrapper();return a(t,r),this.oldest=r,t.oldest=r,this.oldest=r,this.newest=r,r.ownerTag=e,r}renderWithSupport(t,e,r){++t.memory.renderCount;const i=e?.ownerTag||r;e?(t.propsConfig={...e.tagSupport.propsConfig},s(t,e)):(o(t,i),n.memory.providerConfig.ownerTag=i);const u=this,c=u.wrapper();a(t,c),u.newest=c,c.ownerTag=i;const l=t.oldest=t.oldest||c;return t.newest=c,l.tagSupport.templater=u,l.tagSupport.memory=c.tagSupport.memory,e&&e.isLikeTag(c)?(e.updateByTag(c),{remit:!1,retag:c}):{remit:!0,retag:c}}}function T(t,e){const r=function(t,e){if("object"!=typeof t)return t;const r=t;return Object.entries(r).forEach((([t,n])=>{if(n instanceof Function){const o=r[t].original;return o?(r[t]=(...t)=>e(n,t),void(r[t].original=o)):(r[t]=(...t)=>e(n,t),void(r[t].original=n))}})),r}(h(t)?0:t,(function(t,r){const n=t(...r),o=e.newest?.ownerTag?.tagSupport;return o&&o.render(),n}));return r}class E{isSubject=!0;subscribers=[];value;subscribe(t){this.subscribers.push(t),R.globalSubs.push(t),R.globalSubCount$.set(R.globalSubCount$.value+1);const e=()=>{e.unsubscribe()};return e.unsubscribe=()=>{A(this.subscribers,t),A(R.globalSubs,t),R.globalSubCount$.set(R.globalSubCount$.value-1),e.unsubscribe=()=>{}},e}set(t){this.value=t,this.subscribers.forEach((e=>{e.value=t,e(t)}))}next=this.set}function A(t,e){const r=t.indexOf(e);-1!==r&&t.splice(r,1)}const R=E;R.globalSubs=[],R.globalSubCount$=new E,R.globalSubCount$.set(0);class x extends E{value;constructor(t){super(),this.value=t}subscribe(t){const e=super.subscribe(t);return t(this.value),e}}function V(t,e){if(t.isChildOverride)return t;const r=(r,n)=>j(t,e,r,n);return r.tagFunction=t,r}function j(t,e,r,n){const o=e.tagSupport,a=(o&&o.memory.renderCount,t.bind(r)(...n));return o.memory.renderCount,o.render(),a instanceof Promise?a.then((()=>(o.render(),"no-data-ever"))):"no-data-ever"}let k=0;const F=[];function O(t){const e=function(e,r){(h(e)||w(e))&&(r=e,e=void 0);const{childSubject:n,madeSubject:o}=function(t){if(y(t))return{childSubject:t,madeSubject:!1};if(w(t))return{childSubject:new x(t),madeSubject:!0};const e=t;return e?(e.arrayValue=0,{childSubject:new x([e]),madeSubject:!0}):{childSubject:new x([]),madeSubject:!0}}(r);n.isChildSubject=!0;const a=new C(e,n);function s(){const t=s.original,e=a.tagSupport,r=a.oldest;let u=e.propsConfig.latest,c=T(u,a);const l=t(c,n);e.mutatingRender===v.prototype.mutatingRender&&(e.oldest=l,e.mutatingRender=()=>{if(e.renderExistingTag(l,a))return l;if(l.ownerTag){const t=l.ownerTag.tagSupport.render();return l.ownerTag.tagSupport.newest=t,l}return l}),l.tagSupport=new v(a,e.children);const p=i(c);return l.tagSupport.propsConfig={latest:u,latestCloned:p,clonedProps:p,lastClonedKidValues:l.tagSupport.propsConfig.lastClonedKidValues},l.tagSupport.memory=e.memory,l.tagSupport.mutatingRender=e.mutatingRender,e.newest=l,e.propsConfig={...l.tagSupport.propsConfig},r&&(r.tagSupport.propsConfig={...l.tagSupport.propsConfig}),o&&n.value.forEach((t=>{t.values.forEach(((e,r)=>{e instanceof Function&&(t.values[r].isChildOverride||(t.values[r]=function(...t){j(e,l.ownerTag,this,t)},t.values[r].isChildOverride=!0))}))})),l}return s.original=t,a.tagged=!0,a.wrapper=s,a};return function(t,e){t.isTag=!0,t.original=e}(e,t),function(t){t.tags=F,t.setUse=n,t.tagIndex=++k}(t),F.push(t),e}function B(t,e){e.parentNode.insertBefore(t,e)}function P(t,e,r){const n=t.split(".");if("style"===n[0]&&(r.style[n[1]]=e),"class"===n[0])return n.shift(),void(e?n.forEach((t=>r.classList.add(t))):n.forEach((t=>r.classList.remove(t))))}function N(t,e,r){const n=t.getAttributeNames();"TEXTAREA"!==t.nodeName||n.includes("value")||$("textVarValue",t.getAttribute("textVarValue"),t,e,r,((e,r)=>t.value=r));const o=(e,r)=>{t.setAttribute(e,r)};n.forEach((n=>{$(n,t.getAttribute(n),t,e,r,o)}))}function _(t){return t.search(/^(class|style)(\.)/)>=0}function $(t,e,r,n,o,a){if(U(e))return function(t,e,r,n,o,a){return W(t,I(n,e),r,o,a)}(t,e,r,n,o,a);if(U(t)){let e;const s=I(n,t).subscribe((t=>{!function(t,e,r,n,o){if(e&&e!=t&&("string"==typeof e?r.removeAttribute(e):e instanceof Object&&Object.entries(e).forEach((([t])=>r.removeAttribute(t)))),"string"!=typeof t)t instanceof Object&&Object.entries(t).forEach((([t,e])=>W(t,e,r,n,o)));else{if(!t.length)return;W(t,"",r,n,o)}}(t,e,r,o,a),e=t}));return o.cloneSubs.push(s),void r.removeAttribute(t)}return _(t)?P(t,e,r):void 0}new class{};const M=/^\s*{__tagvar/,L=/}\s*$/;function U(t){return t&&t.search(M)>=0&&t.search(L)>=0}function I(t,e){return t[e.replace("{","").split("").reverse().join("").replace("}","").split("").reverse().join("")]}function W(t,e,r,n,o){const a=_(t);if(e instanceof Function){const n=function(...t){return e(r,t)};r[t].action=n}if(y(e)){r.removeAttribute(t);const s=e=>function(t,e,r,n,o){if(t instanceof Function)return e[r]=function(...r){return t(e,r)},void(e[r].tagFunction=t);if(n)return void P(r,t,e);if(t)return void o(r,t);void 0===t||!1===t||null===t?e.removeAttribute(r):o(r,t)}(e,r,t,a,o),i=e.subscribe(s);n.cloneSubs.push(i)}else o(t,e)}const D=/(?:<[^>]*?(?:(?:\s+\w+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^>\s]+)))*\s*)\/?>)|({__tagvar[^}]+})/g;function J(t,e,r,{counts:n,forceElement:o}){const a=e,s=a.tag;if(s&&!o&&s.isLikeTag(t)){if(e instanceof Function){const t=e(s.tagSupport);return s.updateByTag(t),[]}return s.updateByTag(t),[]}const i=t.buildBeforeElement(r,{counts:n,forceElement:o});return a.tag=t,i}function H(t,e,r,a,i){if(!0!==t.tagged){let e=t.wrapper.original.name||t.wrapper.original.constructor?.name;"Function"===e&&(e=void 0);const r=e||t.wrapper.original.toString().substring(0,120);throw new Error(`Not a tag component. Wrap your function with tag(). Example tag(props => html\`\`) on component:\n\n${r}\n\n`)}const u=t,c=t.tagSupport;let l=u.newest;return n.memory.providerConfig.ownerTag=a,(!l||i.forceElement)&&(l?s(c,l):o(c,a),l=u.forceRenderTemplate(c,a),u.newest=l),a.children.push(l),c.templater=l.tagSupport.templater,J(l,e,r,i)}class K extends Error{details;constructor(t,e,r={}){super(t),this.name=K.name,this.details={...r,errorCode:e}}}class z extends K{constructor(t,e){super(t,"array-no-key-error",e),this.name=z.name}}class X extends K{constructor(t,e){super(t,"state-mismatch-error",e),this.name=X.name}}function G(t,e,r,n,o){const a=[];t.lastArray=t.lastArray||[],t.template=r;let s=0;t.lastArray=t.lastArray.filter(((r,n)=>{const a=e.length-1<n-s,i=e[n-s],u=i?.arrayValue;return!(a||!Y(u,r.tag.arrayValue))||(t.lastArray[n].tag.destroy({stagger:o.counts.removed,byParent:!1}),++s,++o.counts.removed,!1)}));const i=r||r.clone;return e.forEach(((r,s)=>{const u=t.lastArray[s],c=r.tagSupport||u?.tag.tagSupport;r.tagSupport=c||new v({},new x([])),c?c.newest=r:(r.tagSupport.mutatingRender=()=>(n.tagSupport.render(),r),n.children.push(r)),r.ownerTag=n;const l=r.arrayValue;if(l?.isArrayValueNeverSet){const t={template:r.getTemplate().string,array:e,ownerTagContent:n.lastTemplateString},o="Use html`...`.key(item) instead of html`...` to template an Array";throw console.error(o,t),new z(o,t)}if(t.lastArray.length>s)return Y(u.tag.arrayValue,r.arrayValue)?(r.tagSupport=r.tagSupport||u.tag.tagSupport,u.tag.updateByTag(r),[]):[];const p=function(t,e,r,n,o){r.lastArray.push({tag:e,index:n});const a={added:o.counts.added+n,removed:o.counts.removed},s=t;return e.buildBeforeElement(s,{counts:a,forceElement:o.forceElement})}(i,r,t,s,o);a.push(...p)})),a}function Y(t,e){return t===e||!!(t instanceof Array&&e instanceof Array&&t.length==e.length)&&t.every(((t,r)=>t==e[r]))}function q(t,e,r,n){const o=e.clone||r,a=rt(t,o);e.clone=a;const s=[],i=n.clones.indexOf(o);return i>=0&&!n.clones.includes(a)&&!o.parentNode&&(n.clones.splice(i,1),n.clones.push(a),s.push(a)),s}var Z;function Q(t,e,r,n,o){return t.tagSupport||(t.tagSupport=new v({},new x([])),t.tagSupport.mutatingRender=()=>{n.tagSupport.render()},t.tagSupport.oldest=t.tagSupport.oldest||t,n.children.push(t),t.ownerTag=n),e.template=r,J(t,e,r,o)}function tt(t,e,r,n){const o=e.tag,a=e.clone||r;a.parentNode.insertBefore(r,a);const s=rt(t,a);e.clone=s,delete e.tag;const i=n.counts.removed;return o.destroy({stagger:i}).then((t=>n.counts.removed=i+t))}function et(t,e,r,n,o){const a=[];if(!t.hasAttribute("end"))return a;const s=t.getAttribute("id");if(s?.substring(0,gt.length)!==gt)return a;const i=e[s];let u=o.forceElement;const c=i.subscribe((e=>{const{clones:o}=function(t,e,r,n,o){const a=function(t){return m(t)?Z.tagComponent:h(t)?Z.tag:w(t)?Z.tagArray:Z.value}(t),s=e,i=s.clone;if(a!==Z.value&&i){const t=i.parentNode;t.insertBefore(r,i),t.removeChild(i),delete s.clone}switch(a){case Z.tag:return{clones:Q(t,e,r,n,o)};case Z.tagArray:return{clones:G(e,t,r,n,o)};case Z.tagComponent:return{clones:H(t,e,r,n,o)}}return e.tag?{clones:[],promise:tt(t,e,r,o)}:{clones:q(t,e,r,n)}}(e,i,t,r,{counts:{added:n.added,removed:n.removed},forceElement:u});u&&(u=!1),o.push(...o)}));return r.cloneSubs.push(c),a}function rt(t,e){const r=e.parentNode;void 0!==t&&!1!==t&&null!==t||(t="");const n=document.createTextNode(t);return r.insertBefore(n,e),r.removeChild(e),n}function nt(t,e){if(!t.getAttribute)return;let r=e.counts.added;e.forceElement||(r=function(t,e){const r=t.oninit;if(!r)return e.added;const n=r.tagFunction;if(!n)return e.added;const o=n.tagFunction;return o?(o({target:t,stagger:e.added}),++e.added):e.added}(t,e.counts)-r),t.children&&(e.counts.added,e.counts.removed,new Array(...t.children).forEach(((t,r)=>nt(t,{...e,counts:e.counts}))))}!function(t){t.tag="tag",t.tagArray="tag-array",t.tagComponent="tag-component",t.value="value"}(Z||(Z={}));const ot=new RegExp('\\s*<template interpolate end id="__tagvar(\\d{1,4})"([^>]*)></template>(\\s*)');function at(t,e,r,n,o){if(!o||"TEMPLATE"===t.tagName)return[];const a=n.counts,s=[],i=new Array(...o);return"TEXTAREA"===t.tagName&&st(t),i.forEach(((t,o)=>{const i=et(t,e,r,a,n);"TEXTAREA"===t.tagName&&st(t),s.push(...i),t.children&&new Array(...t.children).forEach(((t,o)=>{(function(t){return"TEMPLATE"===t.tagName&&void 0!==t.getAttribute("interpolate")&&void 0!==t.getAttribute("end")})(t)&&et(t,e,r,a,n);const i=at(t,e,r,n,t.children);s.push(...i)}))})),s}function st(t){const e=t.value;if(e.search(ot)>=0){const r=e.match(/__tagvar(\d{1,4})/),n="{"+(r?r[0]:"")+"}";t.value="",t.setAttribute("textVarValue",n)}}function it(t,e,r,n,o){const a=[],s=r.interpolation,i=t.children[0].content.children;if(s.keys.length){const r=at(t,e,n,o,i);a.push(...r)}return N(t,e,n),ut(i,e,n),a}function ut(t,e,r){new Array(...t).forEach((t=>{N(t,e,r),t.children&&ut(t.children,e,r)}))}function ct(t){const e=function(t){const e=[];return{string:t.replace(D,((t,r)=>{if(t.startsWith("<"))return t;const n=r.substring(1,r.length-1);return e.push(n),`<template interpolate end id="${n}"></template>`})),keys:e}}(t);return e.string=e.string.replace(mt,gt),e}function lt(t,e,n){t.redraw=()=>{const o=e.tag,a=t.tagSupport.newest,s=o?.tagSupport||t.tagSupport,{remit:i,retag:u}=r(s,t,a,n);if(i)return e.set(t),u}}function pt(t,e){delete e.tag,delete e.tagSupport,t.destroy()}const gt="__tagvar",dt="--"+gt+"--",ft=new RegExp(gt,"g"),mt=new RegExp(dt,"g");class ht{isArrayValueNeverSet=!0}class yt{strings;values;isTag=!0;clones=[];cloneSubs=[];children=[];tagSupport;ownerTag;insertBefore;appElement;arrayValue=new ht;constructor(t,e){this.strings=t,this.values=e}key(t){return this.arrayValue=t,this}async destroy(t={stagger:0,byParent:!1}){!!this.tagSupport&&function(t,e){n.tagUse.forEach((r=>r.beforeDestroy(t,e)))}(this.tagSupport,this),this.destroySubscriptions();const e=this.children.map((e=>e.destroy({...t,byParent:!0})));return this.ownerTag&&(this.ownerTag.children=this.ownerTag.children.filter((t=>t!==this))),t.byParent||(t.stagger=await this.destroyClones(t)),await Promise.all(e),t.stagger}destroySubscriptions(){this.cloneSubs.forEach((t=>t.unsubscribe())),this.cloneSubs.length=0}async destroyClones({stagger:t}={stagger:0}){let e=!1;const r=this.clones.reverse().map(((r,n)=>{let o;r.ondestroy&&(o=function(t,e){const r=t.ondestroy;if(!r)return;const n=r.tagFunction;if(!n)return;const o=n.tagFunction;return o?o({target:t,stagger:e}):void 0}(r,t));const a=()=>{r.parentNode?.removeChild(r);const t=this.ownerTag;t&&(t.clones=t.clones.filter((t=>t!==r)))};return o instanceof Promise?(e=!0,o.then(a)):a(),o}));return e&&await Promise.all(r),t}updateByTag(t){this.updateConfig(t.strings,t.values),this.tagSupport.templater=t.tagSupport.templater,this.tagSupport.propsConfig={...t.tagSupport.propsConfig},this.tagSupport.newest=t}lastTemplateString=void 0;updateConfig(t,e){this.strings=t,this.updateValues(e)}getTemplate(){const t=ct(this.strings.map(((t,e)=>(t.replace(ft,dt)+(this.values.length>e?`{${gt}${e}}`:"")).replace(/>\s*/g,">").replace(/\s*</g,"<"))).join(""));return this.lastTemplateString=t.string,{interpolation:t,string:t.string,strings:this.strings,values:this.values,context:this.tagSupport?.memory.context||{}}}isLikeTag(t){const{string:e}=t.getTemplate();if(!this.lastTemplateString)throw new Error("no template here");return e===this.lastTemplateString&&t.values.length===this.values.length&&!!t.values.every(((t,e)=>{const r=this.values[e];return!(t instanceof Function&&r instanceof Function)||!(t.toString()!==r.toString())}))}update(){return this.updateContext(this.tagSupport.memory.context)}updateValues(t){return this.values=t,this.updateContext(this.tagSupport.memory.context)}updateContext(t){return this.strings.map(((e,r)=>{const n=gt+r,o=this.values.length>r,u=this.values[r];if(n in t)return function(t,e,r){const n=t.value,o=e,u=t,c=t;if(u.lastArray){if(u.isChildSubject&&(e=e.value),w(e))return void G(t,e,u.template,r,{counts:{added:0,removed:0}});t.lastArray.forEach((({tag:t})=>t.destroy())),delete t.lastArray}if(m(o))return function(t,e,r,n){let o=r.tag;if(!o)return lt(e,r,t),void e.redraw();const a=o.tagSupport.templater.wrapper,s=e.wrapper;let u=!1;a&&s&&(u=a.original===s.original);const c=e.tagSupport.propsConfig.latest,l=o.tagSupport;if(l.propsConfig.latest=c,u){const t=n?.tagSupport;let r=t.props;if(h(t.props)||(r=i(t.props)),o&&!b(l,e.tagSupport))return}else pt(o,r);lt(e,r,t),l.templater=e;const p=e.redraw();r.value.tag=l.newest=p,l.propsConfig={...e.tagSupport.propsConfig},u||(r.tag=p,r.tagSupport=e.tagSupport)}(r,o,c,n);const l=c.tag;if(l){w(e)&&(pt(l,c),delete c.tag);const n=l.tagSupport.templater.wrapper,i=e?.wrapper,u=n&&i&&n?.original===i?.original,p=e&&l.lastTemplateString===e.lastTemplateString,g=e&&e.getTemplate&&l.isLikeTag(e);if(p||g)return void Q(e,t,t.template,r,{counts:{added:0,removed:0}});if(u)return function(t,e,r){const n=e.tagSupport,o=n.oldest,i=n.newest;s(o.tagSupport,i||o);const u=t.wrapper();t.newest=u,n.newest=u,a(o.tagSupport,o),e.updateByTag(u),r.set(t)}(e,l,c);if(c.tag){pt(l,c);const n=l.insertBefore;return h(o)?void Q(e,t,n,r,{counts:{added:0,removed:0}}):void q(e,t,n,r)}throw new Error("existing value ignored")}e instanceof Function?c.set(V(e,r)):y(e)?c.set(e.value):c.set(e)}(t[n],u,this);!function(t,e,r,n,o){if(m(e))lt(e,r[n]=new x(e),o);else if(e instanceof Function)r[n]=function(t,e){return new x(V(t,e))}(e,o);else if(t)h(e)?(e.ownerTag=o,o.children.push(e),r[n]=new x(e)):y(e)?r[n]=e:r[n]=new x(e)}(o,u,t,n,this)})),t}getAppElement(){let t=this;for(;t.ownerTag;)t=t.ownerTag;return t}rebuild(){const t=this.insertBefore;if(!t){const t=new Error("Cannot rebuild. Previous insertBefore element is not defined on tag");throw t.tag=this,t}this.buildBeforeElement(t,{forceElement:!0,counts:{added:0,removed:0}})}buildBeforeElement(t,e={forceElement:!1,counts:{added:0,removed:0}}){this.insertBefore=t;const r=this.update(),n=this.getTemplate(),o=document.createElement("div");o.id="tag-temp-holder",o.innerHTML=`<template tag-wrap="22">${n.string}</template>`;const a=it(o,r,n,this,{forceElement:e.forceElement,counts:e.counts});this.clones.length=0;const s=function(t,e){const r=[];let n=t.children[0].content.firstChild;for(;n;){const t=n.nextSibling;B(n,e),r.push(n),n=t}return r}(o,t);return this.clones.push(...s),a.length&&(this.clones=this.clones.filter((t=>!a.find((e=>e===t))))),this.clones.forEach((t=>nt(t,e))),this.clones}}function wt(t,...e){return new yt(t,e)}function bt(t,e){return r=>(e.callback=r||(e=>[t,t=e]),t)}n.memory.stateConfig={array:[],rearray:[]};const vt=[];function St(t){const e=t.callback;if(!e)return t.defaultValue;const r=e(Ct),[n]=r,[o]=e(n);if(o!==Ct){const a='State property not used correctly. Second item in array is not setting value as expected.\n\nFor "let" state use `let name = state(default)(x => [name, name = x])`\n\nFor "const" state use `const name = state(default)()`\n\nProblem state:\n'+(e?e.toString():JSON.stringify(t))+"\n";throw console.error(a,{state:t,callback:e,oldState:r,oldValue:n,checkValue:o}),new Error(a)}return n}n({beforeRender:t=>Tt(t),beforeRedraw:t=>Tt(t),afterRender:t=>{const e=t.memory.state,r=n.memory.stateConfig;if(r.rearray.length&&r.rearray.length!==r.array.length){const e=`States lengths mismatched ${r.rearray.length} !== ${r.array.length}`;throw new X(e,{oldStates:r.array,newStates:r.rearray,component:t.templater?.wrapper.original})}r.rearray=[],e.newest=[...r.array],r.array=[],vt.forEach((t=>t())),vt.length=0}});class Ct{}function Tt(t){const e=t.memory.state,r=n.memory.stateConfig;if(r.rearray.length){const n="last array not cleared";throw console.error(n,{config:r,component:t.templater?.wrapper.original,state:e,expectedClearArray:r.rearray}),new X(n,{config:r,component:t.templater?.wrapper.original,state:e,expectedClearArray:r.rearray})}r.rearray=[],e?.newest.length&&r.rearray.push(...e.newest)}function Et(t){const e=n.memory.stateConfig;let r;const o=e.rearray[e.array.length];if(o){let t=St(o);r=e=>[t,t=e];const n={callback:r,lastValue:t,defaultValue:o.defaultValue};return e.array.push(n),t}let a=(t instanceof Function?t:()=>t)();r=t=>[a,a=t];const s={callback:r,lastValue:a,defaultValue:a};return e.array.push(s),a}function At(t){const e=n.memory.stateConfig;let r;const o=e.rearray[e.array.length];if(o){let t=St(o);r=e=>[t,t=e];const n={callback:r,lastValue:t,defaultValue:o.defaultValue};return e.array.push(n),bt(t,n)}let a=(t instanceof Function?t:()=>t)();r=t=>[a,a=t];const s={callback:r,lastValue:a,defaultValue:a};return e.array.push(s),bt(a,s)}function Rt(t,e){let r=At(void 0)((t=>[r,r=t]));return void 0===r?(e(t,r),r=t,t):(t.every(((t,e)=>t===r[e]))||(e(t,r),r=t),t)}const xt={},Vt={};function jt(t){const{id:e,observer:r,tag:n}=t;r.disconnect(),n.destroy(),delete xt[e]}function kt(t){return"__tagTemplate_"+function(t){let e=t.toString().replace(/\s+/g,"_").replace(/[^\w\d]/g,"_");return/^[a-zA-Z]/.test(e)||(e="fn_"+e),e}(t)}function Ft(t){const e=t.getAttribute("props");if(!e)return{element:t};try{const r=JSON.parse(e),n=t.getAttribute("events");n&&n.split(",").map((t=>t.trim())).map((t=>{r[t]=e=>o(t,{detail:{[t]:e}})}));const o=function(e,r){const n=new CustomEvent(e,r);t.dispatchEvent(n)};return r}catch(r){throw console.warn("Failed to parse props on element",{element:t,propsString:e}),r}}function Ot(t,e,r){const n=e.gateway;if(n)return n.updateTag(),n;const o=Ft(e);try{const{tag:n}=f(r,e,o);return function(t,e,r,n){const o=new MutationObserver((t=>{if(function(t){const{element:e}=t;if(!document.body.contains(e))return jt(t),!1}(s))for(const e of t)"attributes"===e.type&&a()}));function a(){const t=r.tagSupport.templater,n=t.tagSupport.propsConfig.latest,o=Ft(e);t.tagSupport.propsConfig.latest=o,JSON.stringify(n)===JSON.stringify(o)||(t.tagSupport.propsConfig.latest=o)}_t(n);const s={id:t,tag:r,observer:o,component:n,element:e,updateTag:a};return xt[t]=xt[t]||[],xt[t].push(s),e.gateway=s,o.observe(e,{attributes:!0}),s}(t,e,n,r)}catch(t){throw console.warn("Failed to render component to element",{component:r,element:e,props:o}),t}}class Bt extends HTMLElement{gateway;constructor(){super(),setTimeout((()=>this.gateway=function(t){const e=t.id||t.getAttribute("id");if(!e){const r="Cannot check a tag on element with no id attribute";throw console.warn(r,{id:e,element:t}),new Error(r)}const r=Vt[e];if(!r){const r=`Cannot find a tag registered by id of ${e}`;throw console.warn(r,{id:e,element:t}),new Error(r)}return Ot(e,t,r)}(this)),0)}disconnectedCallback(){jt(this.gateway)}}function Pt(){customElements.define("tag-element",Bt)}let Nt=!1;function _t(t){if(!Nt){try{Pt()}catch(t){throw t}Nt=!0}const e=kt(t);return Vt[e]=t,e}const $t={},Mt=function(t){const e=kt(t);if($t[e])return $t[e];let r,n=0;function o(){const n=function(t,e){return function(t,e,r){return e.forEach((e=>Ot(t,e,r))),e}(t,document.querySelectorAll("#"+t),e)}(e,t);return n.length?(r&&clearInterval(r),delete $t[e],n.length):n.length}return o()?{id:e}:(r=setInterval((()=>{if(n+=5,n>=2e3)throw clearInterval(r),new Error(`TaggedJs Element ${e} not found`);o()}),5),$t[e]={id:e},$t[e])};function Lt(t){return n.memory.providerConfig.providers.find((e=>e.constructMethod===t))}n.memory.providerConfig={providers:[],ownerTag:void 0};const Ut={create:t=>{const e=Lt(t);if(e)return e.clone=i(e.instance),e.instance;const r=t.constructor?new t:t();return n.memory.providerConfig.providers.push({constructMethod:t,instance:r,clone:i(r)}),r},inject:t=>{const e=Lt(t);if(e)return e.instance;const r=n.memory.providerConfig;let o={ownerTag:r.ownerTag};for(;o.ownerTag;){const e=o.ownerTag.tagSupport.memory.providers.find((e=>{if(e.constructMethod===t)return!0}));if(e)return e.clone=i(e.instance),r.providers.push(e),e.instance;o=o.ownerTag}const a=`Could not inject provider: ${t.name} ${t}`;throw console.warn(`${a}. Available providers`,r.providers),new Error(a)}};function It(t,e){const r=n.memory.providerConfig;r.ownerTag=e,t.memory.providers.length&&(r.providers.length=0,r.providers.push(...t.memory.providers))}function Wt(t){const e=n.memory.stateConfig,[r]=t(void 0);t(r);const o=e.rearray[e.array.length];if(o){let n=o.watch,a=St(o);const s={callback:t,lastValue:a,watch:o.watch};return r!=n&&(s.watch=r,a=s.lastValue=r),e.array.push(s),t(a),a}const a={callback:t,lastValue:r,watch:r};return e.array.push(a),r}function Dt(t){n.memory.initCurrentSupport=t}function Jt(t){n.memory.initCurrentSupport.memory.init||(n.memory.initCurrentSupport.memory.init=t,t())}let Ht;function Kt(t){Ht.memory.destroyCallback=t}n({beforeRender:(t,e)=>{It(t,e)},beforeRedraw:(t,e)=>{It(t,e.ownerTag)},afterRender:t=>{const e=n.memory.providerConfig;t.memory.providers=[...e.providers],e.providers.length=0}}),n({beforeRender:t=>Dt(t),beforeRedraw:t=>Dt(t)}),n({beforeRender:t=>Ht=t,beforeRedraw:t=>Ht=t,beforeDestroy:(t,e)=>{const r=t.memory.destroyCallback;r&&r()}});let zt=()=>t=>()=>{throw new Error("The real callback function was called and that should never occur")};function Xt(t,e){t.forEach(((t,r)=>{const n=St(t),o=e[r].callback;o&&o(n),e[r].lastValue=n}))}function Gt(t){zt=()=>{const e=n.memory.stateConfig.array;return r=>(...n)=>function(t,e,r,...n){const o=t.memory.state.newest;Xt(o,r);const a=e(...n);Xt(r,o),t.render(),a instanceof Promise&&a.finally((()=>{Xt(r,o),t.render()}))}(t,r,e,...n)}}n({beforeRender:t=>Gt(t),beforeRedraw:t=>Gt(t)});const Yt={tagElement:f,redrawTag:r};var qt=e.W9,Zt=e.ei,Qt=e.B7,te=e.vw,ee=e.PC,re=e.uX,ne=e.Ot,oe=e.eQ,ae=e.cF,se=e.qy,ie=e.xH,ue=e.u2,ce=e.zl,le=e._4,pe=e.iO,ge=e.mn,de=e.Yn,fe=e.Ly,me=e.sA,he=e.MG,ye=e.r5,we=e.iz,be=e.vJ,ve=e.hZ,Se=e.Un,Ce=e.Ie,Te=e.AI,Ee=e.Tc,Ae=e.Hf,Re=e.TY,xe=e._A,Ve=e.wB;export{qt as ArrayNoKeyError,Zt as StateMismatchError,Qt as Subject,te as Tag,ee as TagError,re as TagSupport,ne as ValueSubject,oe as getCallback,ae as hmr,se as html,ie as initWebComponents,ue as interpolateElement,ce as interpolateString,le as isSubjectInstance,pe as isTagArray,ge as isTagComponent,de as isTagInstance,fe as loadTagGateway,me as onDestroy,he as onInit,ye as providers,we as redrawTag,be as runBeforeRender,ve as set,Se as setLet,Ce as setProp,Te as setUse,Ee as tag,Ae as tagElement,Re as tagGateway,xe as tags,Ve as watch};
+var t={d:(e,r)=>{for(var n in r)t.o(r,n)&&!t.o(e,n)&&Object.defineProperty(e,n,{enumerable:!0,get:r[n]})},o:(t,e)=>Object.prototype.hasOwnProperty.call(t,e)},e={};function r(t,e,r,n){return e.renderWithSupport(t,r,n)}function n(t){const e={beforeRender:t.beforeRender||(()=>{}),beforeRedraw:t.beforeRedraw||(()=>{}),afterRender:t.afterRender||(()=>{}),beforeDestroy:t.beforeDestroy||(()=>{})};n.tagUse.push(e)}function o(t,e){n.tagUse.forEach((r=>r.beforeRender(t,e)))}function a(t,e){n.tagUse.forEach((r=>r.afterRender(t,e)))}function s(t,e){n.tagUse.forEach((r=>r.beforeRedraw(t,e)))}function i(t){return u(t,new WeakMap)}function u(t,e){if(null===t||"object"!=typeof t)return t;if(e.has(t))return e.get(t);if(t instanceof Date)return new Date(t);if(t instanceof RegExp)return new RegExp(t);const r=Array.isArray(t)?[]:Object.create(Object.getPrototypeOf(t));if(e.set(t,r),Array.isArray(t))for(let n=0;n<t.length;n++)r[n]=u(t[n],e);else for(const n in t)t.hasOwnProperty(n)&&(r[n]=u(t[n],e));return r}function c(t,e){return l(t,e,new WeakMap)}function l(t,e,r){if(t===e||(o=e,(n=t)instanceof Function&&o instanceof Function&&n.toString()===o.toString()))return!0;var n,o;if("object"!=typeof t||"object"!=typeof e||null===t||null===e)return!1;const a=Object.keys(t),s=Object.keys(e);if(a.length!==s.length)return!1;if(r.has(t))return!0;r.set(t,0);for(const n of a)if(!s.includes(n)||!l(t[n],e[n],r))return!1;if(Array.isArray(t)&&Array.isArray(e)){if(t.length!==e.length)return!1;for(let n=0;n<t.length;n++)if(!l(t[n],e[n],r))return!1}else if(Array.isArray(t)||Array.isArray(e))return!1;return!0}function p(t,e){if(t===e)throw new Error("something here");const r=t.propsConfig.latest;if(function(t,e,r){if(void 0===t&&t===r)return!1;let n=t,o=e;if("object"==typeof t){if(!e)return!0;if(n={...t},o={...e||{}},!Object.entries(n).every((([t,e])=>{let r=o[t];return!(e instanceof Function)||r instanceof Function&&(r.original&&(r=r.original),e.original&&(e=e.original),e.toString()===r.toString()&&(delete n[t],delete o[t],!0))})))return!0}return!c(e,t)}(e.propsConfig.latest,t.propsConfig.latestCloned,r))return!0;const n=function(t,e){const r=t.propsConfig.lastClonedKidValues,n=e.propsConfig.lastClonedKidValues,o=r.every(((t,e)=>{const r=n[e];return t.every(((t,e)=>t===r[e]))}));return!o}(t,e);return n}function g(t){t.tagSupport.memory.providers.filter((t=>!c(t.instance,t.clone))).forEach((e=>{!function(t,e){d(t,e).forEach((({tag:t,renderCount:e,provider:r})=>{e===t.tagSupport.memory.renderCount&&(r.clone=i(r.instance),t.tagSupport.render())}))}(t.getAppElement(),e),e.clone=i(e.instance)}))}function d(t,e,r=[]){const n=t.tagSupport.memory.providers.find((t=>t.constructMethod===e.constructMethod));return n&&r.push({tag:t,renderCount:t.tagSupport.memory.renderCount,provider:n}),t.children.forEach((t=>d(t,e,r))),r}function f(t,e,r){const n=r.memory.renderCount;if(g(t),n!==r.memory.renderCount)return!0;const o=p(t.tagSupport,e.tagSupport),a=r.templater;return r.newest=a.redraw(),e.newest=r.newest,!o}t.d(e,{W9:()=>C,ei:()=>E,B7:()=>O,vw:()=>Tt,PC:()=>S,uX:()=>x,Ot:()=>$,eQ:()=>Ut,cF:()=>Wt,qy:()=>jt,u2:()=>ht,zl:()=>yt,_4:()=>b,iO:()=>v,mn:()=>y,Yn:()=>w,sA:()=>$t,MG:()=>Pt,r5:()=>Ft,iz:()=>r,vJ:()=>o,hZ:()=>R,Un:()=>Vt,Ie:()=>Bt,AI:()=>n,Tc:()=>I,Hf:()=>m,_A:()=>M,wB:()=>Rt}),n.tagUse=[],n.memory={};const h=[];function m(t,e,r){const n=h.findIndex((t=>t.element===e));n>=0&&(h[n].tag.destroy(),h.splice(n,1),console.warn("Found and destroyed app element already rendered to element",{element:e}));const s=function(t){const e=t.tagSupport;o(e,void 0);const r=t.wrapper(e);return a(e,r),{tag:r,tagSupport:e}}(t(r)),{tag:i,tagSupport:u}=s;i.appElement=e,i.tagSupport.oldest=i,function(t,e){t.templater.redraw=()=>{const r=e,{retag:n}=t.templater.renderWithSupport(t,r,{});return e.updateByTag(n),n},t.mutatingRender=()=>(f(e,t.templater,t),e)}(i.tagSupport,i);const c=document.createElement("template");return c.setAttribute("id","app-tag-"+h.length),c.setAttribute("app-tag-detail",h.length.toString()),e.appendChild(c),i.buildBeforeElement(c),e.setUse=t.original.setUse,h.push({element:e,tag:i}),{tag:i,tags:t.original.tags}}function y(t){return!0===t?.isTemplater}function w(t){return!0===t?.isTag}function b(t){return!(!0!==t?.isSubject&&!t?.subscribe)}function v(t){return t instanceof Array&&t.every((t=>w(t)))}class S extends Error{details;constructor(t,e,r={}){super(t),this.name=S.name,this.details={...r,errorCode:e}}}class C extends S{constructor(t,e){super(t,"array-no-key-error",e),this.name=C.name}}class E extends S{constructor(t,e){super(t,"state-mismatch-error",e),this.name=E.name}}function T(t,e){return r=>(e.callback=r||(e=>[t,t=e]),t)}function A(t){const e=t.callback;if(!e)return t.defaultValue;const r=e(j),[n]=r,[o]=e(n);if(o!==j){const a='State property not used correctly. Second item in array is not setting value as expected.\n\nFor "let" state use `let name = state(default)(x => [name, name = x])`\n\nFor "const" state use `const name = state(default)()`\n\nProblem state:\n'+(e?e.toString():JSON.stringify(t))+"\n";throw console.error(a,{state:t,callback:e,oldState:r,oldValue:n,checkValue:o}),new Error(a)}return n}n.memory.stateConfig={array:[],rearray:[]},n({beforeRender:t=>V(t),beforeRedraw:t=>V(t),afterRender:t=>{const e=t.memory.state,r=n.memory.stateConfig;if(r.rearray.length&&r.rearray.length!==r.array.length){const e=`States lengths mismatched ${r.rearray.length} !== ${r.array.length}`;throw new E(e,{oldStates:r.array,newStates:r.rearray,component:t.templater?.wrapper.original})}r.rearray=[],e.newest=[...r.array],r.array=[]}});class j{}function V(t){const e=t.memory.state,r=n.memory.stateConfig;if(r.rearray.length){const n="last array not cleared";throw console.error(n,{config:r,component:t.templater?.wrapper.original,state:e,expectedClearArray:r.rearray}),new E(n,{config:r,component:t.templater?.wrapper.original,state:e,expectedClearArray:r.rearray})}r.rearray=[],e?.newest.length&&r.rearray.push(...e.newest)}function R(t){const e=n.memory.stateConfig;let r;const o=e.rearray[e.array.length];if(o){let t=A(o);r=e=>[t,t=e];const n={callback:r,lastValue:t,defaultValue:o.defaultValue};return e.array.push(n),t}let a=(t instanceof Function?t:()=>t)();r=t=>[a,a=t];const s={callback:r,lastValue:a,defaultValue:a};return e.array.push(s),a}class x{templater;children;propsConfig;memory={context:{},state:{newest:[]},providers:[],renderCount:0};updateState(){this.memory.state.newest.forEach((t=>{t.lastValue=A(t)}))}constructor(t,e,r){this.templater=t,this.children=e;const n=B(r,t);this.propsConfig={latest:r,latestCloned:n,clonedProps:n,lastClonedKidValues:e.value.map((t=>F(t.values)))},w(r)||(this.propsConfig.latestCloned=i(n),this.propsConfig.clonedProps=this.propsConfig.latestCloned)}oldest;newest;mutatingRender(){const t='Tag function "render()" was called in sync but can only be called async';throw console.error(t,{tagSupport:this}),new Error(t)}render(){return++this.memory.renderCount,this.mutatingRender()}}function F(t){return t.map((t=>{const e=t;return w(e)?F(e.values):y(e)?i(e.tagSupport.propsConfig.latestCloned):v(e)?F(e):i(t)}))}class k{tagged;wrapper;insertBefore;newest;oldest;tagSupport;constructor(t,e){this.tagSupport=new x(this,e,t)}redraw;isTemplater=!0;renderWithSupport(t,e,r){++t.memory.renderCount;const i=e?.ownerTag||r;e?(t.propsConfig={...e.tagSupport.propsConfig},s(t,e)):(o(t,i),n.memory.providerConfig.ownerTag=i);const u=this.wrapper(t);return a(t,u),this.newest=u,u.ownerTag=i,t.newest=u,{remit:!0,retag:u}}}function B(t,e){const r=function(t,r){if("object"!=typeof t)return t;const n=t;return Object.entries(n).forEach((([t,r])=>{if(r instanceof Function){if(n[t].original)return;return n[t]=(...t)=>function(t,r){const n=t(...r),o=e.newest,a=o?.ownerTag?.tagSupport;return a.render(),n}(r,t),void(n[t].original=r)}})),n}(w(t)?0:t);return r}class O{value;isSubject=!0;subscribers=[];constructor(t){this.value=t}subscribe(t){this.subscribers.push(t),N.globalSubs.push(t);const e=N.globalSubCount$;N.globalSubCount$.set(e.value+1);const r=()=>{r.unsubscribe()};return r.unsubscribe=()=>{P(this.subscribers,t),P(N.globalSubs,t),N.globalSubCount$.set(e.value-1),r.unsubscribe=()=>{}},r}set(t){this.value=t,this.subscribers.forEach((e=>{e.value=t,e(t)}))}next=this.set}function P(t,e){const r=t.indexOf(e);-1!==r&&t.splice(r,1)}const N=O;N.globalSubs=[],N.globalSubCount$=new O,N.globalSubCount$.set(0);class $ extends O{value;constructor(t){super(t),this.value=t}subscribe(t){const e=super.subscribe(t);return t(this.value),e}}function U(t,e){if(t.isChildOverride)return t;const r=(r,n)=>_(t,e,r,n);return r.tagFunction=t,r}function _(t,e,r,n){const o=e.tagSupport,a=o?o.memory.renderCount:0,s=t.bind(r)(...n),i=a===o.memory.renderCount;if(!o||i)return o.render(),s instanceof Promise?s.then((()=>(o.render(),"promise-no-data-ever"))):"no-data-ever"}const M=[];let W=0;function I(t){const e=function(e,r){(w(e)||v(e))&&(r=e,e=void 0);const{childSubject:n,madeSubject:o}=function(t){if(b(t))return{childSubject:t,madeSubject:!1};if(v(t))return{childSubject:new $(t),madeSubject:!0};const e=t;return e?(e.arrayValue=0,{childSubject:new $([e]),madeSubject:!0}):{childSubject:new $([]),madeSubject:!0}}(r);n.isChildSubject=!0;const a=new k(e,n),s=t=>{const e=s.original,r=a.oldest;let u=t.propsConfig.latest,c=B(u,a);const l=e(c,n);t.mutatingRender===x.prototype.mutatingRender&&(t.oldest=l,a.oldest=l,t.mutatingRender=()=>{if(f(a.oldest,a,t))return l;if(l.ownerTag){const t=l.ownerTag.tagSupport.render();return l.ownerTag.tagSupport.newest=t,l}return l}),l.tagSupport=new x(a,t.children);const p=i(c);return l.tagSupport.propsConfig={latest:u,latestCloned:p,clonedProps:p,lastClonedKidValues:l.tagSupport.propsConfig.lastClonedKidValues},l.tagSupport.memory=t.memory,l.tagSupport.mutatingRender=t.mutatingRender,t.newest=l,t.propsConfig={...l.tagSupport.propsConfig},r&&(r.tagSupport.propsConfig={...l.tagSupport.propsConfig}),o&&n.value.forEach((t=>{t.values.forEach(((e,r)=>{e instanceof Function&&(t.values[r].isChildOverride||(t.values[r]=function(...t){_(e,l.ownerTag,this,t)},t.values[r].isChildOverride=!0))}))})),l};return s.original=t,a.tagged=!0,a.wrapper=s,a};return function(t,e){t.isTag=!0,t.original=e}(e,t),function(t){t.tags=M,t.setUse=n,t.tagIndex=W++}(t),M.push(t),e}function L(t,e){e.parentNode.insertBefore(t,e)}function D(t,e,r){const n=t.split(".");if("style"===n[0]&&(r.style[n[1]]=e),"class"===n[0])return n.shift(),void(e?n.forEach((t=>r.classList.add(t))):n.forEach((t=>r.classList.remove(t))))}new class{};const K=/^\s*{__tagvar/,z=/}\s*$/;function H(t){return t&&t.search(K)>=0&&t.search(z)>=0}function J(t,e,r,n,o,a){if(H(e))return function(t,e,r,n,o,a){return q(t,X(n,e),r,o,a)}(t,e,r,n,o,a);if(H(t)){let e;const s=X(n,t).subscribe((t=>{!function(t,e,r,n,o){if(e&&e!=t&&("string"==typeof e?r.removeAttribute(e):e instanceof Object&&Object.entries(e).forEach((([t])=>r.removeAttribute(t)))),"string"!=typeof t)t instanceof Object&&Object.entries(t).forEach((([t,e])=>q(t,e,r,n,o)));else{if(!t.length)return;q(t,"",r,n,o)}}(t,e,r,o,a),e=t}));return o.cloneSubs.push(s),void r.removeAttribute(t)}return G(t)?D(t,e,r):void 0}function X(t,e){return t[e.replace("{","").split("").reverse().join("").replace("}","").split("").reverse().join("")]}function q(t,e,r,n,o){const a=G(t);if(e instanceof Function){const n=function(...t){return e(r,t)};r[t].action=n}if(b(e)){r.removeAttribute(t);const s=e=>function(t,e,r,n,o){if(t instanceof Function)return e[r]=function(...r){return t(e,r)},void(e[r].tagFunction=t);if(n)return void D(r,t,e);if(t)return void o(e,r,t);void 0===t||!1===t||null===t?e.removeAttribute(r):o(e,r,t)}(e,r,t,a,o),i=e.subscribe(s);n.cloneSubs.push(i)}else o(r,t,e)}function G(t){return t.search(/^(class|style)(\.)/)>=0}function Q(t,e,r){t.setAttribute(e,r)}function Y(t,e,r){t[e]=r}function Z(t,e,r){const n=t.getAttributeNames();let o=Q;n.forEach((n=>{"INPUT"===t.nodeName&&"value"===n&&(o=Y),J(n,t.getAttribute(n),t,e,r,o),o=Q}))}const tt=/(?:<[^>]*?(?:(?:\s+\w+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^>\s]+)))*\s*)\/?>)|({__tagvar[^}]+})/g;function et(t,e,r,{counts:n,forceElement:o}){const a=e,s=a.tag;if(s&&!o&&s.isLikeTag(t)){if(e instanceof Function){const t=e(s.tagSupport);return s.updateByTag(t),[]}return s.updateByTag(t),[]}const i=t.buildBeforeElement(r,{counts:n,forceElement:o});return a.tag=a.tag||t,i}function rt(t,e){const r=t.lastArray;if(r&&!v(e))return r.forEach((({tag:t})=>ot(t,{added:0,removed:0}))),delete t.lastArray,1;const n=t,o=n.tag;if(o){const r=w(e);return w(t.value)&&r?(s=o,((a=e).strings.length!==s.strings.length||!a.strings.every(((t,e)=>s.strings[e]===t))||a.values.length!==s.values.length)&&(nt(o,n),2)):!y(e)&&(nt(o,n),3)}var a,s;const i=t,u="lastValue"in i,c=i.lastValue;return!(!u||c===e)&&(function(t,e){const r=e.clone,n=r.parentNode;n.insertBefore(t,r),n.removeChild(r),delete e.clone,delete e.lastValue}(i.template,i),4)}function nt(t,e){delete e.tag,delete e.tagSupport,t.destroy()}function ot(t,e){t.children.forEach((t=>t.destroy({stagger:e.removed++}))),t.destroy({stagger:e.removed})}function at(t,e,r,n,o){const a=n.clones;t.lastArray=t.lastArray||[],t.template=r;let s=0;t.lastArray=t.lastArray.filter(((r,n)=>{const a=e.length-1<n-s,i=e[n-s],u=i?.arrayValue;return!(a||!st(u,r.tag.arrayValue))||(ot(t.lastArray[n].tag,o.counts),++s,!1)}));const i=r||r.clone;return e.forEach(((r,s)=>{const u=t.lastArray[s],c=r.tagSupport||u?.tag.tagSupport;r.tagSupport=c||new x({},new $([])),c?c.newest=r:(r.tagSupport.mutatingRender=()=>(n.tagSupport.render(),r),n.children.push(r)),r.ownerTag=n;const l=r.arrayValue;if(l?.isArrayValueNeverSet){const t={template:r.getTemplate().string,array:e,ownerTagContent:n.lastTemplateString},o="Use html`...`.key(item) instead of html`...` to template an Array";throw console.error(o,t),new C(o,t)}if(t.lastArray.length>s)return st(u.tag.arrayValue,r.arrayValue)?(r.tagSupport=r.tagSupport||u.tag.tagSupport,u.tag.updateByTag(r),[]):[];const p=function(t,e,r,n,o){const a={tag:e,index:n};r.lastArray.push(a);const s={added:o.counts.added+n,removed:o.counts.removed},i=t;return e.buildBeforeElement(i,{counts:s,forceElement:o.forceElement})}(i,r,t,s,o);a.push(...p)})),a}function st(t,e){return t===e||!!(t instanceof Array&&e instanceof Array&&t.length==e.length)&&t.every(((t,r)=>t==e[r]))}function it(t,e,r){e.template=r;const n=e.clone||r;e.lastValue=t;const o=function(t,e){const r=e.parentNode;void 0!==t&&!1!==t&&null!==t||(t="");const n=document.createTextNode(t);return r.insertBefore(n,e),r.removeChild(e),n}(t,n);return e.clone=o,[]}var ut;function ct(t,e,r,n,o){return t.tagSupport||(t.tagSupport=new x({},new $([])),t.tagSupport.mutatingRender=()=>{n.tagSupport.render()},t.tagSupport.oldest=t.tagSupport.oldest||t,n.children.push(t),t.ownerTag=n),e.template=r,et(t,e,r,o)}!function(t){t.tag="tag",t.tagArray="tag-array",t.tagComponent="tag-component",t.value="value"}(ut||(ut={}));const lt=new RegExp('\\s*<template interpolate end id="__tagvar(\\d{1,4})"([^>]*)></template>(\\s*)');function pt(t,e,r,n,o){const a=[];if(!t.hasAttribute("end"))return{clones:a};const s=t.getAttribute("id");if(s?.substring(0,bt.length)!==bt)return{clones:a};const i=e[s];return y(i.value)?{clones:a,tagComponent:{ownerTag:r,subject:i,insertBefore:t}}:(gt(t,i,r,a,n,{isForceElement:o.forceElement}),{clones:a})}function gt(t,e,r,a,i,{isForceElement:u}){const c=e.subscribe((c=>{const l=e.clone;l&&(t=l);const p=function(t,e,r,a,i){const u=function(t){return y(t)?ut.tagComponent:w(t)?ut.tag:v(t)?ut.tagArray:ut.value}(t);switch(u){case ut.tag:return ct(t,e,r,a,i);case ut.tagArray:return at(e,t,r,a,i);case ut.tagComponent:return function(t,e,r,a,i){if(!0!==t.tagged){let e=t.wrapper.original.name||t.wrapper.original.constructor?.name;"Function"===e&&(e=void 0);const r=e||t.wrapper.original.toString().substring(0,120);throw new Error(`Not a tag component. Wrap your function with tag(). Example tag(props => html\`\`) on component:\n\n${r}\n\n`)}const u=t;u.insertBefore=r;const c=t.tagSupport;let l=u.newest;return n.memory.providerConfig.ownerTag=a,(!l||i.forceElement)&&(l?s(c,u.oldest):o(c,a),l=u.renderWithSupport(c,e.tag,a).retag,u.newest=l),a.children.push(l),c.templater=l.tagSupport.templater,et(l,e,r,i)}(t,e,r,a,i)}return it(t,e,r)}(c,e,t,r,{counts:{...i},forceElement:u});u&&(u=!1),a.push(...p)}));return r.cloneSubs.push(c),a}function dt(t,e,r,n){if(!t.getAttribute)return;"TEXTAREA"===t.nodeName&&function(t,e,r){const n=t.value;if(n.search(lt)>=0){const o=n.match(/__tagvar(\d{1,4})/),a="{"+(o?o[0]:"")+"}";t.value="",t.setAttribute("text-var-value",a);const s=(e,r,n)=>t.value=n;J("text-var-value",a,t,e,r,s)}}(t,r,n);let o=e.counts.added;e.forceElement||(o=function(t,e){const r=t.oninit;if(!r)return e.added;const n=r.tagFunction;if(!n)return e.added;const o=n.tagFunction;return o?(o({target:t,stagger:e.added}),++e.added):e.added}(t,e.counts)-o),t.children&&(e.counts.added,e.counts.removed,new Array(...t.children).forEach(((t,o)=>dt(t,{...e,counts:e.counts},r,n))))}function ft(t,e,r,n,o){if(!o||"TEMPLATE"===t.tagName)return{clones:[],tagComponents:[]};const a=n.counts,s=[],i=[];return new Array(...o).forEach((t=>{const{clones:o,tagComponent:u}=pt(t,e,r,a,n);s.push(...o),u?i.push(u):t.children&&new Array(...t.children).forEach(((t,o)=>{if(function(t){return"TEMPLATE"===t.tagName&&void 0!==t.getAttribute("interpolate")&&void 0!==t.getAttribute("end")}(t)){const{tagComponent:o}=pt(t,e,r,a,n);o&&i.push(o)}const{clones:u,tagComponents:c}=ft(t,e,r,n,t.children);s.push(...u),i.push(...c)}))})),{clones:s,tagComponents:i}}function ht(t,e,r,n,o){const a=[],s=[],i=r.interpolation,u=t.children[0].content.children;if(i.keys.length){const{clones:r,tagComponents:i}=ft(t,e,n,o,u);a.push(...r),s.push(...i)}return Z(t,e,n),mt(u,e,n),{clones:a,tagComponents:s}}function mt(t,e,r){new Array(...t).forEach((t=>{Z(t,e,r),t.children&&mt(t.children,e,r)}))}function yt(t){const e=function(t){const e=[];return{string:t.replace(tt,((t,r)=>{if(t.startsWith("<"))return t;const n=r.substring(1,r.length-1);return e.push(n),`<template interpolate end id="${n}"></template>`})),keys:e}}(t);return e.string=e.string.replace(Ct,bt),e}function wt(t,e,r){t.redraw=()=>{const n=e.tag,o=n?.tagSupport||t.tagSupport,{retag:a}=t.renderWithSupport(o,n,r);return e.set(t),a}}const bt="__tagvar",vt="--"+bt+"--",St=new RegExp(bt,"g"),Ct=new RegExp(vt,"g");class Et{isArrayValueNeverSet=!0}class Tt{strings;values;isTag=!0;clones=[];cloneSubs=[];children=[];tagSupport;ownerTag;appElement;arrayValue=new Et;constructor(t,e){this.strings=t,this.values=e}key(t){return this.arrayValue=t,this}async destroy(t={stagger:0,byParent:!1}){!!this.tagSupport&&function(t,e){n.tagUse.forEach((r=>r.beforeDestroy(t,e)))}(this.tagSupport,this),this.destroySubscriptions();const e=this.children.map((e=>e.destroy({...t,byParent:!0})));return this.children.length=0,this.ownerTag&&(this.ownerTag.children=this.ownerTag.children.filter((t=>t!==this))),t.byParent||(t.stagger=await this.destroyClones(t)),await Promise.all(e),t.stagger}destroySubscriptions(){this.cloneSubs.forEach((t=>t.unsubscribe())),this.cloneSubs.length=0}async destroyClones({stagger:t}={stagger:0}){let e=!1;const r=this.clones.reverse().map(((r,n)=>{let o;r.ondestroy&&(o=function(t,e){const r=t.ondestroy;if(!r)return;const n=r.tagFunction;if(!n)return;const o=n.tagFunction;return o?o({target:t,stagger:e}):void 0}(r,t));const a=()=>{r.parentNode?.removeChild(r);const t=this.ownerTag;t&&(t.clones=t.clones.filter((t=>t!==r)))};return o instanceof Promise?(e=!0,o.then(a)):a(),o}));return this.clones.length=0,e&&await Promise.all(r),t}updateByTag(t){this.updateConfig(t.strings,t.values),this.tagSupport.templater=t.tagSupport.templater,this.tagSupport.propsConfig={...t.tagSupport.propsConfig},this.tagSupport.newest=t,this.tagSupport.templater.newest=t}lastTemplateString=void 0;updateConfig(t,e){this.strings=t,this.updateValues(e)}getTemplate(){const t=yt(this.strings.map(((t,e)=>(t.replace(St,vt)+(this.values.length>e?`{${bt}${e}}`:"")).replace(/>\s*/g,">").replace(/\s*</g,"<"))).join(""));return this.lastTemplateString=t.string,{interpolation:t,string:t.string,strings:this.strings,values:this.values,context:this.tagSupport?.memory.context||{}}}isLikeTag(t){const{string:e}=t.getTemplate();if(!this.lastTemplateString)throw new Error("no template here");return e===this.lastTemplateString&&t.values.length===this.values.length&&!!t.values.every(((t,e)=>{const r=this.values[e];return!(t instanceof Function&&r instanceof Function)||!(t.toString()!==r.toString())}))}update(){return this.updateContext(this.tagSupport.memory.context)}updateValues(t){return this.values=t,this.updateContext(this.tagSupport.memory.context)}updateContext(t){const e=[];return this.strings.map(((r,n)=>{const o=bt+n,u=this.values.length>n,c=this.values[n],l=o in t;if(e.push(o),l)return function(t,e,r){const n=t.value,o=t,u=t,c=o.isChildSubject,l=y(e);if(c&&(e=e.value),rt(t,e),l)return function(t,e,r,n){let o=r.tag;if(!o)return wt(e,r,t),void e.redraw();const a=o.tagSupport.templater.wrapper,s=e.wrapper;let u=!1;a&&s&&(u=a.original===s.original);const c=e.tagSupport.propsConfig.latest,l=o.tagSupport;if(l.propsConfig.latest=c,u){const t=n?.tagSupport;let r=t.props;if(w(t.props)||(r=i(t.props)),o&&!p(l,e.tagSupport))return}else nt(o,r);wt(e,r,t),l.templater=e;const g=e.redraw();o.isLikeTag(g)||(o.destroy(),r.tagSupport=g.tagSupport,r.tag=g,l.oldest=g),l.newest=g,l.propsConfig={...e.tagSupport.propsConfig}}(r,e,u,n);const g=u.tag;if(g)!function(t,e,r,n){const o=t.tagSupport.templater.wrapper,i=r?.wrapper,u=o&&i&&o?.original===i?.original,c=r&&t.lastTemplateString===r.lastTemplateString,l=r&&r.getTemplate&&t.isLikeTag(r);c||l?ct(r,e,e.template,n,{counts:{added:0,removed:0}}):u?function(t,e,r){const n=e.tagSupport,o=n.oldest;n.newest,s(o.tagSupport,o);const i=t.wrapper(n);t.newest=i,n.newest=i,a(o.tagSupport,o),e.updateByTag(i),r.set(t)}(r,t,e):it(r,e,e.template)}(g,t,e,r);else if(v(e)){const n=at(t,e,o.template||u.tag?.tagSupport.templater.insertBefore,r,{counts:{added:0,removed:0}});r.clones.push(...n)}else e instanceof Function?u.set(U(e,r)):b(e)?u.set(e.value):u.set(e)}(t[o],c,this);!function(t,e,r,n,o){if(y(e))wt(e,r[n]=new $(e),o);else if(e instanceof Function)r[n]=function(t,e){return new $(U(t,e))}(e,o);else if(t)w(e)?(e.ownerTag=o,o.children.push(e),r[n]=new $(e)):b(e)?r[n]=e:r[n]=new $(e)}(u,c,t,o,this)})),Object.entries(t).forEach((([t,r])=>{e.includes(t)||rt(r,void 0)})),t}getAppElement(){let t=this;for(;t.ownerTag;)t=t.ownerTag;return t}rebuild(){const t=this.tagSupport.templater.insertBefore;if(!t){const t=new Error("Cannot rebuild. Previous insertBefore element is not defined on tag");throw t.tag=this,t}this.buildBeforeElement(t,{forceElement:!0,counts:{added:0,removed:0}})}buildBeforeElement(t,e={forceElement:!1,counts:{added:0,removed:0}}){this.tagSupport.templater.insertBefore=t;const r=this.update(),n=this.getTemplate(),o=document.createElement("div");o.id="tag-temp-holder",o.innerHTML=`<template id="temp-template-tag-wrap">${n.string}</template>`;const{clones:a,tagComponents:s}=ht(o,r,n,this,{forceElement:e.forceElement,counts:e.counts});this.clones.length=0,At(o,t,this,a),this.clones.forEach((t=>dt(t,e,r,this)));let i=e.forceElement;return s.forEach((r=>{gt(r.insertBefore,r.subject,r.ownerTag,a,e.counts,{isForceElement:i}),At(o,t,this,a)})),a}}function At(t,e,r,n,o,a){const s=function(t,e){const r=[];let n=t.children[0].content.firstChild;for(;n;){const t=n.nextSibling;L(n,e),r.push(n),n=t}return r}(t,e);r.clones.push(...s),n.length&&(r.clones=r.clones.filter((t=>!n.find((e=>e===t)))))}function jt(t,...e){return new Tt(t,e)}function Vt(t){const e=n.memory.stateConfig;let r;const o=e.rearray[e.array.length];if(o){let t=A(o);r=e=>[t,t=e];const n={callback:r,lastValue:t,defaultValue:o.defaultValue};return e.array.push(n),T(t,n)}let a=(t instanceof Function?t:()=>t)();r=t=>[a,a=t];const s={callback:r,lastValue:a,defaultValue:a};return e.array.push(s),T(a,s)}function Rt(t,e){let r=Vt(void 0)((t=>[r,r=t]));return void 0===r?(e(t,r),r=t,t):(t.every(((t,e)=>t===r[e]))||(e(t,r),r=t),t)}function xt(t){return n.memory.providerConfig.providers.find((e=>e.constructMethod===t))}n.memory.providerConfig={providers:[],ownerTag:void 0};const Ft={create:t=>{const e=xt(t);if(e)return e.clone=i(e.instance),e.instance;const r=t.constructor?new t:t();return n.memory.providerConfig.providers.push({constructMethod:t,instance:r,clone:i(r)}),r},inject:t=>{const e=xt(t);if(e)return e.instance;const r=n.memory.providerConfig;let o={ownerTag:r.ownerTag};for(;o.ownerTag;){const e=o.ownerTag.tagSupport.memory.providers.find((e=>{if(e.constructMethod===t)return!0}));if(e)return e.clone=i(e.instance),r.providers.push(e),e.instance;o=o.ownerTag}const a=`Could not inject provider: ${t.name} ${t}`;throw console.warn(`${a}. Available providers`,r.providers),new Error(a)}};function kt(t,e){const r=n.memory.providerConfig;r.ownerTag=e,t.memory.providers.length&&(r.providers.length=0,r.providers.push(...t.memory.providers))}function Bt(t){const e=n.memory.stateConfig,[r]=t(void 0);t(r);const o=e.rearray[e.array.length];if(o){let n=o.watch,a=A(o);const s={callback:t,lastValue:a,watch:o.watch};return r!=n&&(s.watch=r,a=s.lastValue=r),e.array.push(s),t(a),a}const a={callback:t,lastValue:r,watch:r};return e.array.push(a),r}function Ot(t){n.memory.initCurrentSupport=t}function Pt(t){n.memory.initCurrentSupport.memory.init||(n.memory.initCurrentSupport.memory.init=t,t())}let Nt;function $t(t){Nt.memory.destroyCallback=t}n({beforeRender:(t,e)=>{kt(t,e)},beforeRedraw:(t,e)=>{kt(t,e.ownerTag)},afterRender:t=>{const e=n.memory.providerConfig;t.memory.providers=[...e.providers],e.providers.length=0}}),n({beforeRender:t=>Ot(t),beforeRedraw:t=>Ot(t)}),n({beforeRender:t=>Nt=t,beforeRedraw:t=>Nt=t,beforeDestroy:(t,e)=>{const r=t.memory.destroyCallback;r&&r()}});let Ut=()=>t=>()=>{throw new Error("The real callback function was called and that should never occur")};function _t(t,e){t.forEach(((t,r)=>{const n=A(t),o=e[r].callback;o&&o(n),e[r].lastValue=n}))}function Mt(t){Ut=()=>{const e=n.memory.stateConfig.array;return r=>(...n)=>function(t,e,r,...n){const o=t.memory.state.newest;_t(o,r);const a=e(...n);_t(r,o),t.render(),a instanceof Promise&&a.finally((()=>{_t(r,o),t.render()}))}(t,r,e,...n)}}n({beforeRender:t=>Mt(t),beforeRedraw:t=>Mt(t)});const Wt={tagElement:m,redrawTag:r};var It=e.W9,Lt=e.ei,Dt=e.B7,Kt=e.vw,zt=e.PC,Ht=e.uX,Jt=e.Ot,Xt=e.eQ,qt=e.cF,Gt=e.qy,Qt=e.u2,Yt=e.zl,Zt=e._4,te=e.iO,ee=e.mn,re=e.Yn,ne=e.sA,oe=e.MG,ae=e.r5,se=e.iz,ie=e.vJ,ue=e.hZ,ce=e.Un,le=e.Ie,pe=e.AI,ge=e.Tc,de=e.Hf,fe=e._A,he=e.wB;export{It as ArrayNoKeyError,Lt as StateMismatchError,Dt as Subject,Kt as Tag,zt as TagError,Ht as TagSupport,Jt as ValueSubject,Xt as getCallback,qt as hmr,Gt as html,Qt as interpolateElement,Yt as interpolateString,Zt as isSubjectInstance,te as isTagArray,ee as isTagComponent,re as isTagInstance,ne as onDestroy,oe as onInit,ae as providers,se as redrawTag,ie as runBeforeRender,ue as set,ce as setLet,le as setProp,pe as setUse,ge as tag,de as tagElement,fe as tags,he as watch};

package/js/Subject.d.ts

@@ -1,7 +1,7 @@
 export type Subscription = (() => void) & {
     unsubscribe: () => any;
 };
-type Subscriber = (value?: any) => any;
+export type SubjectSubscriber<T> = (value?: T) => unknown;
 export interface SubjectLike {
     subscribe?: (callback: (value?: any) => any) => any;
     isSubject?: boolean;
@@ -9,10 +9,9 @@ export interface SubjectLike {
 export declare class Subject<T> implements SubjectLike {
     value?: T | undefined;
     isSubject: boolean;
-    subscribers: Subscriber[];
+    subscribers: SubjectSubscriber<T>[];
     constructor(value?: T | undefined);
-    subscribe(callback: Subscriber): Subscription;
+    subscribe(callback: SubjectSubscriber<T>): Subscription;
     set(value: any): void;
     next: (value: any) => void;
 }
-export {};

package/js/Subject.js

@@ -40,8 +40,8 @@ function removeSubFromArray(subscribers, callback) {
         subscribers.splice(index, 1);
     }
 }
-const SubjectClass = {
-    globalSubCount$: new Subject(0), // for ease of debugging
-    globalSubs: [] // 🔬 for testing
-};
+const SubjectClass = Subject;
+SubjectClass.globalSubs = []; // 🔬 for testing
+SubjectClass.globalSubCount$ = new Subject(); // for ease of debugging
+SubjectClass.globalSubCount$.set(0);
 //# sourceMappingURL=Subject.js.map

package/js/Subject.js.map

@@ -1 +1 @@
-{"version":3,"file":"Subject.js","sourceRoot":"","sources":["../ts/Subject.ts"],"names":[],"mappings":"AAWA,MAAM,OAAO,OAAO;IAKC;IAJnB,SAAS,GAAG,IAAI,CAAA;IAChB,WAAW,GAAiB,EAAE,CAAA;IAC9B,+BAA+B;IAE/B,YAAmB,KAAS;QAAT,UAAK,GAAL,KAAK,CAAI;IAAG,CAAC;IAEhC,SAAS,CAAC,QAAoB;QAC5B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QAC/B,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA,CAAC,aAAa;QACpD,MAAM,YAAY,GAAG,YAAY,CAAC,eAAkC,CAAA;QACpE,YAAY,CAAC,eAAe,CAAC,GAAG,CAAE,YAAY,CAAC,KAAK,GAAG,CAAC,CAAE,CAAA;QAE1D,MAAM,WAAW,GAAiB,GAAG,EAAE;YACrC,WAAW,CAAC,WAAW,EAAE,CAAA;QAC3B,CAAC,CAAA;QAED,4DAA4D;QAC5D,WAAW,CAAC,WAAW,GAAG,GAAG,EAAE;YAC7B,kBAAkB,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAA;YAC9C,kBAAkB,CAAC,YAAY,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAA,CAAC,aAAa;YACnE,YAAY,CAAC,eAAe,CAAC,GAAG,CAAE,YAAY,CAAC,KAAK,GAAG,CAAC,CAAE,CAAA;YAE1D,0CAA0C;YAC1C,WAAW,CAAC,WAAW,GAAG,GAAG,EAAE,CAAC,SAAS,CAAA;QAC3C,CAAC,CAAA;QAED,OAAO,WAAW,CAAA;IACpB,CAAC;IAED,GAAG,CAAC,KAAU;QACZ,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAElB,4CAA4C;QAC5C,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,QAAa,EAAE,EAAE;YACzC,QAAQ,CAAC,KAAK,GAAG,KAAK,CAAA;YACtB,QAAQ,CAAC,KAAK,CAAC,CAAA;QACjB,CAAC,CAAC,CAAA;IACJ,CAAC;IACD,IAAI,GAAG,IAAI,CAAC,GAAG,CAAA;CAChB;AAED,SAAS,kBAAkB,CACzB,WAAyB,EACzB,QAAoB;IAEpB,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC3C,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;QACjB,WAAW,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;IAC9B,CAAC;AACH,CAAC;AAED,MAAM,YAAY,GAAG;IACnB,eAAe,EAAE,IAAI,OAAO,CAAS,CAAC,CAAC,EAAE,wBAAwB;IACjE,UAAU,EAAE,EAAkB,CAAA,iBAAiB;CAChD,CAAA"}
+{"version":3,"file":"Subject.js","sourceRoot":"","sources":["../ts/Subject.ts"],"names":[],"mappings":"AAWA,MAAM,OAAO,OAAO;IAKC;IAJnB,SAAS,GAAG,IAAI,CAAA;IAChB,WAAW,GAA2B,EAAE,CAAA;IACxC,+BAA+B;IAE/B,YAAmB,KAAS;QAAT,UAAK,GAAL,KAAK,CAAI;IAAG,CAAC;IAEhC,SAAS,CAAC,QAA8B;QACtC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QAC/B,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA,CAAC,aAAa;QACpD,MAAM,YAAY,GAAG,YAAY,CAAC,eAAkC,CAAA;QACpE,YAAY,CAAC,eAAe,CAAC,GAAG,CAAE,YAAY,CAAC,KAAK,GAAG,CAAC,CAAE,CAAA;QAE1D,MAAM,WAAW,GAAiB,GAAG,EAAE;YACrC,WAAW,CAAC,WAAW,EAAE,CAAA;QAC3B,CAAC,CAAA;QAED,4DAA4D;QAC5D,WAAW,CAAC,WAAW,GAAG,GAAG,EAAE;YAC7B,kBAAkB,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAA;YAC9C,kBAAkB,CAAC,YAAY,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAA,CAAC,aAAa;YACnE,YAAY,CAAC,eAAe,CAAC,GAAG,CAAE,YAAY,CAAC,KAAK,GAAG,CAAC,CAAE,CAAA;YAE1D,0CAA0C;YAC1C,WAAW,CAAC,WAAW,GAAG,GAAG,EAAE,CAAC,SAAS,CAAA;QAC3C,CAAC,CAAA;QAED,OAAO,WAAW,CAAA;IACpB,CAAC;IAED,GAAG,CAAC,KAAU;QACZ,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAElB,4CAA4C;QAC5C,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,QAAa,EAAE,EAAE;YACzC,QAAQ,CAAC,KAAK,GAAG,KAAK,CAAA;YACtB,QAAQ,CAAC,KAAK,CAAC,CAAA;QACjB,CAAC,CAAC,CAAA;IACJ,CAAC;IACD,IAAI,GAAG,IAAI,CAAC,GAAG,CAAA;CAChB;AAED,SAAS,kBAAkB,CACzB,WAAqC,EACrC,QAAgC;IAEhC,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC3C,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;QACjB,WAAW,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;IAC9B,CAAC;AACH,CAAC;AAED,MAAM,YAAY,GAAG,OAGpB,CAAA;AACD,YAAY,CAAC,UAAU,GAAG,EAAE,CAAA,CAAC,iBAAiB;AAC9C,YAAY,CAAC,eAAe,GAAG,IAAI,OAAO,EAAE,CAAA,CAAC,wBAAwB;AACrE,YAAY,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA"}

package/js/Tag.class.d.ts

@@ -1,19 +1,17 @@
-import { TagSupport } from "./TagSupport.class.js";
-import { Provider } from "./providers.js";
-import { Subscription } from "./Subject.js";
-import { Counts } from "./interpolateTemplate.js";
-import { State } from "./set.function.js";
-import { InterpolatedTemplates } from "./interpolations.js";
+import { TagSupport } from './TagSupport.class';
+import { Subscription } from './Subject';
+import { Counts } from './interpolateTemplate';
+import { State } from './set.function';
+import { InterpolatedTemplates } from './interpolations';
+import { InterpolateSubject } from './processSubjectValue.function';
 export declare const variablePrefix = "__tagvar";
 export declare const escapeVariable: string;
 export declare const escapeSearch: RegExp;
 export type Context = {
-    [index: string]: any;
+    [index: string]: InterpolateSubject;
 };
-export type TagMemory = Record<string, any> & {
-    context: Context;
+export type TagMemory = {
     state: State;
-    providers: Provider[];
 };
 export interface TagTemplate {
     interpolation: InterpolatedTemplates;
@@ -29,12 +27,13 @@ export declare class Tag {
     strings: string[];
     values: any[];
     isTag: boolean;
+    hasLiveElements: boolean;
     clones: (Element | Text | ChildNode)[];
     cloneSubs: Subscription[];
-    children: Tag[];
+    childTags: Tag[];
     tagSupport: TagSupport;
+    lastTemplateString: string | undefined;
     ownerTag?: Tag;
-    insertBefore?: Element;
     appElement?: Element;
     arrayValue: unknown | ArrayValueNeverSet;
     constructor(strings: string[], values: any[]);
@@ -42,19 +41,27 @@ export declare class Tag {
     key(arrayValue: unknown): this;
     destroy(options?: DestroyOptions): Promise<number>;
     destroySubscriptions(): void;
-    destroyClones({ stagger }?: DestroyOptions): Promise<number>;
+    destroyClones({ stagger }?: DestroyOptions): {
+        promise: Promise<(void | undefined)[]>;
+        stagger: number;
+    } | {
+        stagger: number;
+        promise?: undefined;
+    };
+    checkCloneRemoval(clone: Element | Text | ChildNode, stagger: number): Promise<void> | undefined;
+    getTemplate(): TagTemplate;
+    isLikeTag(tag: Tag): boolean | Boolean;
     updateByTag(tag: Tag): void;
-    lastTemplateString: string | undefined;
     updateConfig(strings: string[], values: any[]): void;
-    getTemplate(): TagTemplate;
-    isLikeTag(tag: Tag): boolean;
     update(): Context;
     updateValues(values: any[]): Context;
     updateContext(context: Context): Context;
     getAppElement(): Tag;
     /** Used during HMR only where static content itself could have been edited */
     rebuild(): void;
-    buildBeforeElement(insertBefore: Element, options?: ElementBuildOptions): (ChildNode | Element)[];
+    buildBeforeElement(insertBefore: Element | Text, options?: ElementBuildOptions & {
+        test: boolean;
+    }): void;
 }
 type DestroyOptions = {
     stagger: number;