{"version":3,"file":"npm.grafana.xxxxxxxxxxxxxxxxxxxx.js","mappings":";;;;;;;;;;;;;;AAAyC;AAClC;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,qDAAU;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACpBO;AACA;AACA;AACA;AACP;;;;;;;;;;;;;;;;;;;;ACJqD;AACgD;AAC7C;AACX;AACtC,+BAA+B,iFAAiF;AACvH;AACA,mDAAmD,iGAAiG,IAAI;AACxJ;AACA,0BAA0B,6DAAqB;AAC/C;AACA;AACA;AACA;AACA;AACA,gCAAgC,+CAAO;AACvC,sDAAsD,iEAAoB,yBAAyB,gEAAmB;AACtH;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB,sBAAsB,0DAAiB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,8CAAM,iBAAiB,iDAAS;AACjF;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,qDAAiB;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACpD8D;AACvD;AACA;AACP;AACA;AACA,YAAY,gDAAQ;AACpB,mBAAmB,6DAAqB;AACxC;AACA;AACA,KAAK;AACL;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;ACZqD;AACoG;AACjG;AACX;AACA;AACE;AAC/C;AACO,mCAAmC,iFAAiF;AAC3H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,2CAA2C;AACvD,gCAAgC,2FAA2F,IAAI;AAC/H;AACA;AACA;AACA;AACA,wBAAwB,6DAAqB,+BAA+B,iJAAiJ;AAC7N;AACA;AACA,uDAAuD,4BAA4B,wDAAoB,0DAA0D,iEAAoB,yBAAyB,gEAAmB;AACjO;AACA;AACA;AACA;AACA,uDAAuD,GAAG,+CAAO,WAAW,IAAI,cAAc,+BAA+B,gBAAgB,IAAI;AACjJ,sBAAsB,0DAAiB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,8CAAM,iBAAiB,iDAAS;AACjF;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,qDAAiB;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,+CAAO;AACf;AACA;AACA;AACA;AACA,gCAAgC,gDAAQ,iBAAiB,+CAAO;AAChE,gBAAgB,6DAAqB;AACrC;AACA;AACA;AACA;AACA,8BAA8B,IAAI;AAClC;AACA;AACA,YAAY,uBAAuB;AACnC,WAAW,yDAAiB;AAC5B;AACA;;;;;;;;;;;;;;;;;;;;;;;AC1FsC;AACS;AACQ;AACZ;AACgB;AAChB;AACI;AACiC;AACzE,0BAA0B,8CAAU;AACpC;AACP;AACA,YAAY,2BAA2B,EAAE,6FAAgC,GAAG,mCAAmC;AAC/G,sBAAsB,4DAAmB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iGAAiG,cAAc,oEAAuB,UAAU,wDAAiB,UAAU,wDAAiB,UAAU,wEAAyB,UAAU,4DAAmB;AAC5P;AACA;;;;;;;;;;;;;;ACzBO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;;;;;;;;;;;;;;;;;;;;;;ACVqD;AACiE;AAC9D;AACX;AACM;AAC5C,6BAA6B,iFAAiF;AACrH;AACA;AACA;AACA,+FAA+F,4DAAwB;AACvH,6BAA6B,gEAAgE,IAAI;AACjG;AACA,wBAAwB,6DAAqB;AAC7C;AACA,sBAAsB,0DAAiB;AACvC;AACA;AACA,wEAAwE,mDAAe;AACvF,6BAA6B,+CAAO;AACpC,sDAAsD,iEAAoB,yBAAyB,gEAAmB;AACtH;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,8CAAM,iBAAiB,iDAAS;AACjF;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,qDAAiB;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;ACxDqD;AACgD;AAC7C;AACX;AACtC,qCAAqC,iFAAiF;AAC7H;AACA;AACA,wCAAwC,yDAAyD,IAAI;AACrG;AACA,wBAAwB,6DAAqB;AAC7C;AACA,sBAAsB,0DAAiB;AACvC,uDAAuD,cAAc;AACrE;AACA;AACA;AACA;AACA,yFAAyF,iEAAoB,yBAAyB,gEAAmB,aAAa,+CAAO,yBAAyB;AACtM;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,8CAAM,iBAAiB,iDAAS;AACjF;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,qDAAiB;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;AC/CmD;AAC5C,6BAA6B,wBAAwB;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD;AACzD;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,GAAG,kDAAO;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,8BAA8B;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,mDAAQ;AACjC,4CAA4C,4HAA4H,UAAU;AAClL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;AC5EqD;AAC9C;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,0DAAiB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;AC5CkD;AACiD;AACzD;AACnC,4CAA4C,oCAAoC;AACvF,6BAA6B,mDAAU;AACvC;AACA;AACA;AACA,YAAY,qDAAiB,iBAAiB,oDAAgB;AAC9D;AACA;AACA;AACA,yBAAyB,mDAAe;AACxC,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA;AACA,qEAAqE,WAAW,uCAAuC,mBAAmB;AAC1I;AACA;AACA,2BAA2B,GAAG;AAC9B;AACA,aAAa;AACb;AACA;AACA;AACA,yBAAyB,sDAAkB;AAC3C;AACA;AACA;AACA,aAAa;AACb;AACA,KAAK;AACL;AACA,aAAa;AACb;AACA;AACA;AACA,uBAAuB,0DAAiB;AACxC;AACA;;;;;;;;;;;;;;;AC1CuC;AAChC;AACP;AACA,eAAe,mDAAQ;AACvB,KAAK;AACL;AACA;;;;;;;;;;;;;;;ACNO;AACA;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACNO;AACP;;;;;;;;;;;;;;;;ACD0D;AACI;AACvD;AACP;AACA,gCAAgC,sEAAuB;AACvD,8BAA8B,kEAAqB;AACnD;AACA;AACA;AACA;AACA,qCAAqC,UAAU;AAC/C;AACA;AACA,oCAAoC,UAAU;AAC9C;AACA;AACA,oCAAoC,UAAU;AAC9C;AACA;AACA,qCAAqC,UAAU;AAC/C;AACA;AACA;;;;;;;;;;;;;;ACtBA;AACO;AACP;AACA,aAAa,qBAAM;AACnB,UAAU,qBAAM;AAChB;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;ACRsC;AAC2D;AACrC;AACI;AACG;AACY;AACf;AACzD;AACP,6BAA6B,6EAA0B;AACvD,2BAA2B,yEAAwB;AACnD,QAAQ,kEAA4B;AACpC;AACA;AACA;AACA;AACA;AACA,kBAAkB,uDAAe;AACjC,uBAAuB,iEAAoB;AAC3C,gBAAgB,mDAAa;AAC7B,6BAA6B,6EAA0B;AACvD,iBAAiB,kDAAY;AAC7B;AACA,IAAI,4DAAoB;AACxB,IAAI,sEAAyB;AAC7B,IAAI,mFAA+B;AACnC;AACA;AACA;;;;;;;;;;;;;;;AC3B8C;AACvC,kCAAkC,sDAAa;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACRO;AACP;AACA;AACA;AACA;AACA;AACA,4CAA4C,wBAAwB;AACpE;AACA;AACA,uDAAuD,yBAAyB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,8CAA8C,6BAA6B;AAC3E;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,wDAAwD,6BAA6B;AACrF;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;;;;;;;;;;;;;ACjDO;AACP;AACA;AACA;;;;;;;;;;;;;;;;;;ACHgC;AACzB;AACP;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,kDAAkD;AAC5C;AACA;AACP,WAAW,wCAAI;AACf,WAAW,wCAAI;AACf,UAAU,wCAAI;AACd;AACA,UAAU,wCAAI;AACd;AACO;AACP;;;;;;;;;;;;;;;;;AClB8D;AAC9B;AACiE;AAC1F,iDAAiD,sEAAuB,wBAAwB,8DAA0B;AACjI,2BAA2B,yDAAqB;AAChD,8BAA8B,uDAAmB;AACjD;AACA,mCAAmC,uDAAmB;AACtD;AACA,8CAA8C,sBAAsB;AACpE;AACA,kBAAkB,wCAAI;AACtB;AACA,mCAAmC,uDAAmB;AACtD;AACA,6CAA6C,sBAAsB;AACnE;AACA,kBAAkB,wCAAI;AACtB;AACA,mCAAmC,uDAAmB;AACtD;AACA,6CAA6C,sBAAsB;AACnE;AACA,kBAAkB,wCAAI;AACtB;AACA,mCAAmC,uDAAmB;AACtD;AACA,8CAA8C,sBAAsB;AACpE;AACA,kBAAkB,wCAAI;AACtB;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACjCgD;AACc;AACvD,qBAAqB,yDAAqB;AAC1C;AACP,qBAAqB,2EAAoB;AACzC;AACA;AACA;;;;;;;;;;;;;;;ACPsC;AAC/B;AACP;AACA;AACA,0EAA0E,kDAAU,2BAA2B;AAC/G;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,SAAS;AACT;AACA;AACA;;;;;;;;;;;;;;;;ACvCkD;AACb;AAC9B;AACP;AACA;AACA;AACA,qBAAqB,6CAAO;AAC5B,SAAS;AACT;AACA,8CAA8C,8DAAW;AACzD,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AC3BO;AACP;;;;;;;;;;;;;;;ACD+C;AACxC;AACP;AACA,kGAAkG,4BAA4B;AAC9H,2CAA2C,uDAAY;AACvD,iFAAiF,4BAA4B;AAC7G;AACA;AACA,8BAA8B,uDAAY;AAC1C;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;AClB+C;AACG;AAC3C;AACP,WAAW,uDAAY,CAAC,2DAAuB;AAC/C;AACO;AACP;AACA;AACA,8BAA8B,uDAAY,EAAE,2DAAuB;AACnE;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACO;AACP,WAAW,2DAAuB,IAAI,uDAAY;AAClD;AACA;;;;;;;;;;;;;;;;;ACtB2D;AACgB;AACpE;AACA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,wFAA6B;AACjC,IAAI,wEAAqB;AACzB;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;ACpBA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACO;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACP;;;;;;;;;;;;;;;ACtB8C;AACvC,4BAA4B,sDAAa;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACTA;AACA;AACO;AACP;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,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;ACjEO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,8CAA8C;AACxC;AACP;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACfgD;AACJ;AACrC;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C,kBAAkB;AAC9D;AACA;AACA,iDAAiD,mBAAmB;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;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,4DAA4D,eAAe;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,eAAe;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,yDAAa;AACzC;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,8CAA8C,uBAAuB;AACrE;AACA;AACA,kDAAkD,uBAAuB;AACzE;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,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,qDAAiB;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AC3JO;AACP;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACJwE;AACjE;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,aAAa;AACtD,0CAA0C,sBAAsB,4CAA4C;AAC5G,WAAW;AACX;AACO;AACP;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,qDAAiB;AAClC,iBAAiB,qDAAiB;AAClC,iBAAiB,qDAAiB;AAClC,iBAAiB,qDAAiB;AAClC,2BAA2B,8DAA0B;AACrD;AACA,qDAAqD,WAAW,yFAAyF;AACzJ;AACA,iBAAiB,qDAAiB;AAClC,qDAAqD,WAAW,4EAA4E;AAC5I;AACA;AACA,KAAK;AACL;AACA;AACA;;;;;;;;;;;;;;AC7CO,gDAAgD;AACvD;;;;;;;;;;;;;;;;ACDkD;AAC3C,uBAAuB,2DAAuB;AAC9C;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACPO;AACP;AACA;AACO;AACP;AACA;AACO;AACP;AACA;AACA;;;;;;;;;;;;;;;ACTmD;AACnD;AACA;AACO;AACP;AACA;AACA;AACA;AACA,QAAQ,6CAAQ;AAChB,eAAe,6CAAQ;AACvB;AACA,qBAAqB,4CAAO;AAC5B,qBAAqB,4CAAO;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,YAAY;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,6CAAQ;AAC9B,sBAAsB,6CAAQ;AAC9B;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACvDO;AACP;AACA;AACO;AACP,gEAAgE,KAAK;AACrE;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACP;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACtDgC;AACzB;AACP;AACA;AACA,YAAY,6CAAQ;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,wCAAwC;AAC/C,sEAAsE;AACtE;AACO,uCAAuC;AAC9C;AACA;AACA,iBAAiB,6CAAQ;AACzB;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACvBO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,4BAA4B;AACtB;AACA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AClBO;AACP;;;;;;;;;;;;;;ACDO;AACP,YAAY,oBAAoB;AAChC,uBAAuB;AACvB,wBAAwB;AACxB;AACA;AACA;AACA;AACA,oBAAoB,4BAA4B;AAChD;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACtCO;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AC9EA;AACO;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;ACN+C;AACxC;AACP,WAAW,uDAAY,aAAa,uDAAY,uBAAuB,uDAAY,mBAAmB,QAAQ;AAC9G;AACA;;;;;;;;;;;;;;ACJA;AACO;AACP;;;;;;;;;;;;;;;;;;;;;ACFmN;AAC5M,4CAA4C;AACnD;AACA,YAAY,wEAAyB;AACrC,YAAY,oEAAqB;AACjC,YAAY,uEAAwB;AACpC,YAAY,qEAAsB;AAClC,YAAY,kEAAmB;AAC/B;AACA;AACA;AACA,qCAAqC,yEAA0B;AAC/D;AACA;AACA,kCAAkC,qEAAsB;AACxD;AACA,SAAS;AACT;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpBA,cAAc,SAAI,IAAI,SAAI;AAC1B;AACA;AACA;AACA;AACA,6DAA6D,cAAc;AAC3E;AACA;AACA;AACA;AACA;AACuN;AACxK;AACO;AACqB;AACK;AACzC;AACF;AACU;AACA;AACmB;AAC3D;AACP;AACA;AACA,2BAA2B,wEAAoB;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,uDAAc;AAC1C;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,uDAAkB,oBAAoB,sEAAsB,qBAAqB,+EAAsB,0BAA0B,0EAA0B,uCAAuC,wEAAwB,+GAA+G,uEAAuB,uEAAuE,wFAAuB,GAAG;AACle;AACA;AACA,yCAAyC,qBAAqB,wCAAwC,EAAE,qEAAqB;AAC7H;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA,2LAA2L,EAAE,oFAA4B;AACzN;AACA;AACA,SAAS;AACT,2CAA2C;AAC3C;AACA,yDAAyD,yBAAyB;AAClF;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,YAAY,uBAAuB;AACnC;AACA,QAAQ,gDAAW;AACnB,QAAQ,4DAAc,GAAG,uCAAuC;AAChE;AACA;AACA,+BAA+B,6DAAQ;AACvC;AACA,iCAAiC,8CAAM;AACvC;AACA;AACA;AACA,4BAA4B,oCAAoC;AAChE;AACA;AACA,QAAQ,8DAAS;AACjB;AACA;AACA,QAAQ,4DAAO;AACf;AACA;AACA;AACA,+CAA+C,uIAAuI,MAAM,WAAW;AACvM;AACA;AACA;;;;;;;;;;;;;;ACjGO;AACP;;;;;;;;;;;;;;;;ACDgE;AACtB;AACnC;AACP,uBAAuB,uDAAc;AACrC;AACA;AACA;AACA,WAAW,kEAAQ;AACnB;AACA;;;;;;;;;;;;;;;;;;;;ACTiJ;AACtE;AACpE,qCAAqC,mEAAmB;AAC/D,4BAA4B;AAC5B;AACA;AACA;AACA,uBAAuB,uDAAO;AAC9B,+BAA+B,wEAAwB;AACvD;AACA;AACA;AACA,qDAAqD;AACrD;AACA;AACA,mIAAmI,0EAA0B;AAC7J,cAAc,wEAAwB;AACtC,QAAQ,4DAAY;AACpB,iCAAiC,YAAY,4LAA4L;AACzO;AACA;AACA;AACA;AACA;AACA,kCAAkC,wDAAQ;AAC1C,gCAAgC,2BAA2B,EAAE,uFAA8B;AAC3F;AACA;AACA;AACA;AACA,2GAA2G,mBAAmB;AAC9H;AACA,uCAAuC,wDAAQ;AAC/C,gCAAgC,2BAA2B,EAAE,uFAA8B;AAC3F;AACA;AACA;AACA;AACA;AACA,8HAA8H,8EAA0B;AACxJ,6BAA6B;AAC7B,yBAAyB;AACzB;AACA;AACA,iDAAiD,OAAO;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,gDAAgD,wDAAQ,QAAQ,wDAAQ,QAAQ,wDAAQ;AACxF;AACA;;;;;;;;;;;;;;;;;;;;AC3DO;AACA;AACA;AACA;AACA;AACA;AACA;AACP;;;;;;;;;;;;;;;;;;;;;ACPoH;AACpB;AACtB;AACD;AAClE;AACP;AACA;AACA;AACA;AACA;AACA,QAAQ,gEAAY;AACpB;AACA;AACA,sBAAsB,qEAAuB;AAC7C;AACA,8BAA8B,8DAAU,UAAU,kEAAc;AAChE,gBAAgB,gBAAgB;AAChC,0EAA0E,gDAAY,GAAG,oDAAgB;AACzG,6BAA6B,KAAK,IAAI,QAAQ;AAC9C;AACA,aAAa,2DAAO;AACpB;AACA,sBAAsB,qEAAuB;AAC7C;AACA,aAAa,4DAAQ,uBAAuB,2DAAO;AACnD;AACA,mBAAmB,oDAAgB,EAAE,EAAE,iBAAiB;AACxD;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA,0BAA0B,4DAAQ;AAClC,8BAA8B,6DAAe,SAAS,uDAAmB;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,uFAA0B;AAClD;AACA;AACA,aAAa;AACb;AACO;AACP,QAAQ,2DAAO;AACf;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;;;;;;;;;;;;;;;;ACzD0D;AACjB;AAClC;AACP;AACA,iCAAiC,kDAAc;AAC/C,mHAAmH,oEAAoB;AACvI;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;ACTkE;AACd;AAC0B;AACvE,oCAAoC,mEAAmB;AAC9D;AACA;AACA;AACA,uBAAuB,uDAAO;AAC9B;AACA;AACA;AACA,QAAQ,iEAAe;AACvB,QAAQ,2FAA4B;AACpC;AACA;AACA;;;;;;;;;;;;;;;ACf4D;AACrD;AACP;AACA;AACA;AACA,oBAAoB,2BAA2B,EAAE,yEAAuB;AACxE;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACpBiD;AACyB;AACtB;AAC7C;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,+DAAW;AACvB,uBAAuB,2DAAuB,EAAE,EAAE,cAAc;AAChE,mBAAmB,0DAAsB;AACzC;AACA;AACA,yCAAyC,iEAAe;AACxD;AACA;AACA,8CAA8C,mBAAmB;AACjE;AACA,KAAK;AACL;AACA;;;;;;;;;;;;;;;AC5B8C;AACvC;AACP;AACA;AACA,0BAA0B,uDAAmB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACdO;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD;AAC7D;;;;;;;;;;;;;;;ACfoF;AAC7E;AACP,wFAAwF,yDAAqB;AAC7G,kHAAkH,4DAAwB;AAC1I;AACA;AACA;AACA;AACA,mEAAmE,4CAAQ,gBAAgB,4CAAQ;AACnG,+BAA+B,yDAAqB,CAAC,GAAG,SAAS,OAAO,4DAAwB,CAAC,GAAG,SAAS;AAC7G;AACA;AACA;;;;;;;;;;;;;;;;;;ACZ8C;AACM;AACoL;AAC5J;AACrE;AACP;AACA;AACA,uCAAuC,iDAAa;AACpD;AACA;AACA,kCAAkC,iDAAa;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,mDAAe;AACpC;AACA;AACA;AACA;AACA,wFAAwF,oDAAgB;AACxG,iCAAiC,mDAAe;AAChD;AACA;AACA;AACA;AACA;AACA;AACA,gGAAgG,yDAAqB;AACrH,qCAAqC,+DAA2B;AAChE;AACA,+BAA+B,yFAA2B;AAC1D;AACA,0BAA0B,oDAAgB;AAC1C;AACA;AACA;AACA;AACA,gDAAgD,qDAAiB;AACjE,iCAAiC,oDAAgB;AACjD;AACA,mCAAmC,8CAAU;AAC7C;AACA;AACA;AACA;AACA,4CAA4C,4DAAQ;AACpD;AACA;AACA,+BAA+B,yFAA2B;AAC1D;AACA;AACA,qBAAqB,iEAAe;AACpC;AACA;AACA,KAAK;AACL,QAAQ,sDAAkB;AAC1B;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;AChEoE;AAC7D;AACP;AACA,gBAAgB,iFAAuB;AACvC;AACA;AACA;;;;;;;;;;;;;;ACNO;AACP;;;;;;;;;;;;;;;;;;;;;ACDA,iBAAiB,SAAI,IAAI,SAAI;AAC7B,4BAA4B,+DAA+D,iBAAiB;AAC5G;AACA,oCAAoC,MAAM,+BAA+B,YAAY;AACrF,mCAAmC,MAAM,mCAAmC,YAAY;AACxF,gCAAgC;AAChC;AACA,KAAK;AACL;AAC8E;AAC1B;AAC+B;AAC/B;AAC7C,2CAA2C,0DAAU;AACrD,yCAAyC,mEAAmB;AACnE;AACA;AACA;AACA,uBAAuB,uDAAO;AAC9B;AACA;AACA,aAAa,+EAA4B;AACzC;AACA;AACA;AACA,QAAQ,kEAAe;AACvB;AACA,oBAAoB,mBAAmB,QAAQ,iEAAoB;AACnE;AACA,gBAAgB,iEAAsB;AACtC;AACA,SAAS;AACT;AACA;AACA;;;;;;;;;;;;;;;;;;;;;AClC+D;AACA;AAChB;AACyB;AACd;AACsC;AACzF;AACP;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,0CAA0C,wDAAY;AACtD;AACA;AACA;AACA,0BAA0B,iFAA8B;AACxD,+CAA+C,+CAAO,CAAC,gFAAyB,EAAE,kDAAc,4CAA4C,6DAAa;AACzJ,kEAAkE,EAAE,6EAA0B,mBAAmB,kBAAkB,8DAAU,8BAA8B;AAC3K,QAAQ,+CAAO,CAAC,gFAAyB,wCAAwC,kDAAc;AAC/F;AACA;AACA;AACA,SAAS;AACT;AACA,KAAK;AACL;AACA,cAAc,mEAAgB;AAC9B;AACA,KAAK;AACL;AACA;AACA;;;;;;;;;;;;;;;AClCO;AACA;AACP;;;;;;;;;;;;;;;;;;;;;ACF4D;AAC5D,2CAA2C,GAAG,UAAU,GAAG,OAAO,IAAI;AACtE;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,sEAAsE;AAC7E;AACA;AACA;AACA;AACA;AACA,YAAY,2DAAO;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,YAAY;AACZ;AACA,6IAA6I;AAC7I;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;AACO;AACP,YAAY,qKAAqK;AACjL;AACA,yCAAyC,mDAAmD;AAC5F;AACA;AACA;AACA,sKAAsK;AACtK;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,6DAAa;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;AC7HsD;AACP;AACS;AAC+D;AACvH,kCAAkC;AAC3B;AACP,2BAA2B,oDAAI;AAC/B;AACA;AACA;AACA,gBAAgB,wDAAY;AAC5B;AACA;AACA;AACA,8BAA8B,iFAA8B;AAC5D,2CAA2C,0EAAuB;AAClE;AACA,wEAAwE,EAAE,2EAAwB,wBAAwB,kCAAkC,8DAAU,IAAI;AAC1K,oBAAoB,oDAAI;AACxB;AACA,8BAA8B,iEAAc;AAC5C,qBAAqB;AACrB;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA,KAAK;AACL;AACA,cAAc,iEAAc;AAC5B;AACA,KAAK;AACL;AACA;;;;;;;;;;;;;;;;;;;;;;;ACnC6I;AACjG;AAC4B;AACe;AACY;AAC5F,qCAAqC,mEAAmB;AAC/D;AACA;AACA;AACA,uBAAuB,uDAAO;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,oEAAoB,IAAI,eAAe,kBAAkB;AAC5F;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,mEAAmB,IAAI,eAAe,kBAAkB;AACvF;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,2DAAO;AAC/B;AACA;AACA,gBAAgB,gGAAyB;AACzC;AACA;AACA;AACA;AACA;AACA,YAAY,uFAAkB;AAC9B;AACA,6BAA6B,4FAAuB;AACpD;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,4DAA4D;AAC5D,uEAAuE,6BAA6B,uEAAuE;AAC3K;AACA,oEAAoE,cAAc;AAClF,4BAA4B,oEAAoB;AAChD;AACA;AACA,+IAA+I,qDAAa;AAC5J,6BAA6B,4FAAuB;AACpD;AACA,2BAA2B,0DAAS;AACpC,aAAa;AACb;AACA,yDAAyD,2CAA2C,gDAAgD,qFAAqF,iBAAiB,YAAY,IAAI;AAC1Q,4BAA4B,mEAAmB;AAC/C;AACA,iBAAiB;AACjB;AACA;AACA;AACA,gBAAgB,gBAAgB;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uGAAuG;AACvG;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,mCAAmC,0EAAyB;AAC5D;AACA,oBAAoB,gCAAgC;AACpD;AACA;AACA;AACA;AACA,kCAAkC,mEAAmB;AACrD,mCAAmC,mEAAmB,IAAI,eAAe,kBAAkB;AAC3F;AACA,kCAAkC,oEAAoB;AACtD,mCAAmC,oEAAoB,IAAI,eAAe,kBAAkB;AAC5F;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;AC3GiE;AACvB;AAC+C;AAClB;AACoB;AACpF;AACP;AACA,6BAA6B,gDAAQ,iCAAiC,mEAAoB;AAC1F,iCAAiC,2EAAqB;AACtD;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,QAAQ,6DAAU,CAAC,0DAAW;AAC9B;AACA;AACA,QAAQ,0DAAO,CAAC,0DAAW,EAAE,yEAAqB;AAClD;AACA;AACA,8BAA8B,0DAAO,CAAC,0DAAW;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,QAAQ,oDAAI,mBAAmB,iFAA2B;AAC1D;AACA;AACA,SAAS;AACT;AACA;AACA,6CAA6C,6DAAc;AAC3D;;;;;;;;;;;;;;;;;;;;ACzCiE;AACvB;AAC+C;AAClB;AACoB;AACpF;AACP;AACA,6BAA6B,gDAAQ,iCAAiC,mEAAoB;AAC1F,iCAAiC,2EAAqB;AACtD;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,QAAQ,6DAAU,CAAC,0DAAW;AAC9B;AACA;AACA,QAAQ,0DAAO,CAAC,0DAAW,EAAE,yEAAqB;AAClD;AACA;AACA,8BAA8B,0DAAO,CAAC,0DAAW;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,QAAQ,oDAAI,mBAAmB,iFAA2B;AAC1D;AACA;AACA,SAAS;AACT;AACA;AACA,6CAA6C,6DAAc;AAC3D;;;;;;;;;;;;;;;;ACzCwE;AACL;AAC5D;AACP,8HAA8H,iFAAyB,GAAG,4EAAuB;AACjL;AACA;;;;;;;;;;;;;;;ACL0C;AACnC;AACP;AACA;AACA,4BAA4B,oDAAI;AAChC,oMAAoM,OAAO,oDAAI,cAAc;AAC7N;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;ACZO;AACA,oDAAoD;AACpD,gDAAgD;AAChD,uCAAuC;AAC9C;AACA;AACA;AACO;AACA;AACA;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;ACdiH;AAC7B;AAC7C;AAC+C;AAC/E,mCAAmC,sDAAsD,IAAI;AACpG;AACA,gBAAgB,2DAAO;AACvB,0CAA0C,oDAAI;AAC9C;AACA,oFAAoF,8DAAU;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA,gBAAgB,2DAAO;AACvB,kDAAkD,sEAAuB;AACzE;AACA;AACA;AACA,+DAA+D,sEAAuB;AACtF;AACA;AACO,iCAAiC,qCAAqC;AAC7E,oCAAoC,qBAAqB,IAAI,2BAA2B;AACxF;AACA;AACA;AACA;AACA,sCAAsC,oDAAI;AAC1C;AACA,sCAAsC,2DAAuB,gCAAgC,6DAAyB;AACtH;AACA;AACA;AACA;AACA,2DAA2D,yBAAyB,cAAc,2DAAO,IAAI;AAC7G;AACA;AACA,uFAAuF,WAAW,oDAAS,IAAI;AAC/G;AACA,kBAAkB,oDAAI;AACtB;AACA;AACA;AACA;AACO;AACP;AACA,0DAA0D,iBAAiB;AAC3E;AACA,oEAAoE,cAAc,oDAAI,4IAA4I,oDAAI,6GAA6G,MAAM,4CAA4C;AACrY,WAAW;AACX,kCAAkC,oDAAI;AACtC,SAAS,2DAAO;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,uCAAuC,qCAAqC;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,6DAAS;AAC3E,6DAA6D,6DAAS;AACtE;AACA;AACA,0FAA0F,sBAAsB,oDAAS,IAAI;AAC7H;AACA;AACA,YAAY,oDAAI;AAChB;AACA;AACA;AACA,4EAA4E,6BAA6B;AACzG;AACA;AACA;AACA;AACA;AACA,uHAAuH,oDAAI;AAC3H;AACA,QAAQ,oDAAI,eAAe,4EAA4B;AACvD;AACA;AACA,SAAS;AACT;AACA;AACA;;;;;;;;;;;;;;;;;;;ACvGO;AACA;AACA;AACA;AACA;AACA;AACP;;;;;;;;;;;;;;;;ACNgD;AACI;AAC7C;AACP,2BAA2B,0DAAU;AACrC;AACA,4BAA4B,MAAM,6DAAyB,EAAE;AAC7D,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;;;;;;;;;;;;;;;;;ACf4D;AACO;AACsB;AACzF;AACA;AACA;AACA;AACA;AACO;AACP,2BAA2B,0DAAU;AACrC;AACA;AACA,kBAAkB,mEAA+B;AACjD;AACA,SAAS;AACT;AACA;AACA;AACA,kBAAkB,iEAA6B;AAC/C;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,sBAAsB,+BAA+B;AACrD;AACA;AACA;AACA,6BAA6B,wDAAY;AACzC;AACA,0BAA0B,8DAAU;AACpC;AACA;AACA;AACA,iCAAiC,6CAA6C;AAC9E;AACA,SAAS;AACT;AACA;AACA;AACA,+BAA+B,6CAA6C;AAC5E;AACA,SAAS;AACT;AACA;AACA,+BAA+B,6CAA6C;AAC5E;AACA,SAAS;AACT;AACA;AACA,+BAA+B,6CAA6C;AAC5E;AACA,SAAS;AACT;AACA;AACA;AACA,wBAAwB,+BAA+B;AACvD;AACA;AACA;AACA,0BAA0B,8DAAkB;AAC5C,6BAA6B,wDAAY;AACzC,+EAA+E;AAC/E,0BAA0B,8DAAU;AACpC;AACA,6BAA6B,+CAA+C;AAC5E;AACA;AACA;AACA;AACA;AACA,+BAA+B,+CAA+C;AAC9E;AACA;AACA,SAAS;AACT;AACA;AACA,+BAA+B,+CAA+C;AAC9E;AACA;AACA,SAAS;AACT;AACA;AACA;;;;;;;;;;;;;;;;;;;AC3FwE;AACF;AACtE;AACO,wCAAwC,mEAAmB;AAClE;AACA;AACA;AACA,uBAAuB,uDAAO;AAC9B;AACA;AACA,kCAAkC,mFAAmB,CAAC,oDAAI;AAC1D;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;ACzBgD;AACgC;AACX;AACf;AAC/C;AACP,2BAA2B,0DAAU;AACrC,IAAI,wFAA8B;AAClC,0BAA0B,6EAAc;AACxC,gCAAgC,MAAM,+DAA2B,EAAE;AACnE;AACA,KAAK;AACL;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;ACbsL;AAClC;AACzF;AACA;AACa;AACtB;AAClD;AACO;AACP,YAAY,cAAc;AAC1B,wBAAwB,wEAAmB;AAC3C,gCAAgC,wEAAmB;AACnD,sCAAsC,qFAAyB;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8IAA8I,iEAAuB;AACrK;AACA;AACA;AACA;AACA;AACA,0BAA0B,2DAAO;AACjC;AACA,yBAAyB,8DAAU;AACnC,QAAQ,6DAAa;AACrB,kBAAkB,iEAAiB;AACnC;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,sBAAsB,2DAAO;AAC7B;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,mCAAmC,0DAAU;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,2DAAO;AACjC,mEAAmE;AACnE;AACA;AACA,2BAA2B,0BAA0B,+BAA+B,IAAI;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,6DAAa;AACjC,8BAA8B,gEAAgB;AAC9C;AACA;AACA;AACA,kCAAkC,2DAAO;AACzC,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,uEAAuE;AACnF;AACA;AACA;AACA,IAAI,6DAAa;AACjB,cAAc,+DAAe;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,kDAAkD,2JAA2J,EAAE,yEAAqB;AACpO;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA,oCAAoC,gEAAwB;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,IAAI,6DAAa;AACjB,cAAc,kEAAkB;AAChC;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,mEAA+B;AACvD;AACA;AACA,wBAAwB,iEAA6B;AACrD;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AClLA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;ACZqG;AACrG;AACO,kCAAkC,mEAAmB;AAC5D;AACA;AACA;AACA,uBAAuB,uDAAO;AAC9B;AACA;AACA;AACA;AACA;AACA,+BAA+B,kEAAkB;AACjD,wIAAwI,6DAAa;AACrJ,0EAA0E,6DAAa;AACvF,aAAa,eAAe,kBAAkB;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;ACvBkE;AAChB;AACoB;AAC/D,uCAAuC,mEAAmB;AACjE;AACA;AACA;AACA,uBAAuB,uDAAO;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,2DAAc;AACrC;AACA,mBAAmB,+EAAwB;AAC3C;AACA;AACA;;;;;;;;;;;;;;;ACvBuE;AAChE;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,iBAAiB;AACjB,aAAa,IAAI,uGAAuG;AACxH,SAAS;AACT;AACA;AACA;AACA,SAAS,6CAAK;AACd,SAAS,6CAAK;AACd,SAAS,6CAAK;AACd,SAAS,6CAAK;AACd,SAAS,6CAAK;AACd,UAAU,8CAAM;AAChB;AACA;;;;;;;;;;;;;;;;;;AC5BmF;AAChC;AACG;AACkB;AACxE;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,6DAAK;AACb,oBAAoB,qEAAqE;AACzF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI,uGAAuG;AACpH;AACA;AACA;AACA,QAAQ,6DAAK;AACb,oBAAoB,6CAA6C;AACjE;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI,uGAAuG;AACpH;AACA;AACA;AACA,QAAQ,6DAAK;AACb,oBAAoB,+CAA+C;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI,uGAAuG;AACpH;AACA;AACA;AACA,QAAQ,6DAAK;AACb,oBAAoB,oIAAoI;AACxJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI,uGAAuG;AACpH;AACA;AACA;AACA,QAAQ,6DAAK;AACb,oBAAoB,wFAAwF;AAC5G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI,uGAAuG;AACpH;AACA;AACA;AACA,QAAQ,8DAAM;AACd,oBAAoB,mFAAmF;AACvG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI,uGAAuG;AACpH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,+CAAO,CAAC,gFAAyB,EAAE,kDAAc,4CAA4C,6DAAa;AAClJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,cAAc,IAAI,SAAS;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACnIwC;AACW;AAC5C;AACP,uBAAuB,kDAAQ;AAC/B,YAAY,gBAAgB;AAC5B,YAAY,mCAAmC;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,6DAAa;AACzE,wEAAwE,6DAAa;AACrF,mBAAmB,gDAAgD,6DAAa,EAAE,EAAE,yDAAyD,6DAAa,CAAC;AAC3J,gFAAgF,6DAAa;AAC7F,4EAA4E,6DAAa;AACzF;AACA,oEAAoE,6DAAa;AACjF,8BAA8B,kBAAkB;AAChD,+BAA+B,mBAAmB;AAClD,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AClCO;AACP;AACA;AACA;AACA;AACA,+BAA+B,6FAA6F,+FAA+F;AAC3N;AACA;AACA;;;;;;;;;;;;;;;ACRgD;AAChD;AACA;AACO,0BAA0B,kCAAkC,IAAI;AACvE;AACA;AACA,YAAY,8DAAU;AACtB;AACA;AACA;AACA;AACA,gDAAgD,mBAAmB,cAAc,aAAa,IAAI;AAClG;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;AChBsD;AAC/C;AACP;AACA;AACA,oCAAoC,oDAAI,gNAAgN,8DAAU;AAClQ;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;ACRA,iBAAiB,SAAI,IAAI,SAAI;AAC7B,4BAA4B,+DAA+D,iBAAiB;AAC5G;AACA,oCAAoC,MAAM,+BAA+B,YAAY;AACrF,mCAAmC,MAAM,mCAAmC,YAAY;AACxF,gCAAgC;AAChC;AACA,KAAK;AACL;AACA,cAAc,SAAI,IAAI,SAAI;AAC1B;AACA;AACA;AACA;AACA,6DAA6D,cAAc;AAC3E;AACA;AACA;AACA;AACA;AACwH;AAC9B;AACgB;AAC1G;AACA,+BAA+B;AAC/B;AACA;AACA;AACA;AACO,6BAA6B,6DAAa;AACjD;AACA;AACA;AACA;AACA;AACA,uBAAuB,uDAAO;AAC9B;AACA;AACA;AACA,6BAA6B,uEAAmB;AAChD;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,oGAAoG,mBAAmB;AACvH;AACA;AACA;AACA,gDAAgD,oEAAgB;AAChE,4BAA4B,8BAA8B;AAC1D,yGAAyG,IAAI,UAAU;AACvH;AACA;AACA;AACA;AACA;AACA,sDAAsD,qEAAqE,oCAAoC,wDAAwD,gBAAgB,sBAAsB,IAAI,mBAAmB,iCAAiC,IAAI,4DAA4D,+FAA+F;AACpd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF,mBAAmB;AACpG;AACA;AACA,8CAA8C,oDAAI;AAClD;AACA,qBAAqB;AACrB;AACA;AACA,qBAAqB;AACrB,iBAAiB;AACjB;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,oBAAoB,qCAAqC,EAAE,mGAAyB;AACpF,YAAY,mHAAqB,GAAG,oCAAoC,IAAI,0BAA0B;AACtG,wBAAwB,sBAAsB;AAC9C;AACA;AACA,wBAAwB,qBAAqB;AAC7C;AACA;AACA;AACA;;;;;;;;;;;;;;ACzHA;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;;;;;;;;;;;;;;;;;;ACzByE;AACzE;AACA;AACA;AACA,aAAa,UAAU;AACvB;AACO;AACP,WAAW,oDAAI;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP,QAAQ,4DAAQ;AAChB;AACA;AACA;AACA;AACA;AACA,SAAS,2DAAO,cAAc,8DAAU;AACxC;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;ACrC0C;AACnC;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,oDAAI,qFAAqF,MAAM,4BAA4B,MAAM;AAC/I;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;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;AACO;AACP;AACA;AACA;AACA;AACO;AACA;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;AC1E4C;AACrC;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,qDAAe;AAC3C;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;;;;;;;;;;;;;;;;;AC/CuD;AACoD;AAChD;AACpD;AACP;AACA;AACA;AACA;AACA,2BAA2B,yHAA+B,UAAU,kCAAkC;AACtG;AACA,QAAQ,wEAAc;AACtB,yBAAyB,MAAM,iEAAgB,UAAU;AACzD;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACjB2F;AAC/B;AAC5D;AACO;AACP;AACA;AACA,gBAAgB,aAAa;AAC7B;AACA,oBAAoB,oBAAoB;AACxC;AACA,kCAAkC,qGAAS;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,gEAAa;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,uDAAI,+BAA+B,UAAU;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,iBAAiB;AACjB;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACzD8C;AACmF;AAC1H;AACP;AACA;AACA,QAAQ,gEAAa;AACrB,6BAA6B,oEAAiB;AAC9C;AACA;AACA;AACA,iBAAiB,kEAAe,EAAE,mEAAgB,EAAE,qEAAkB;AACtE;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,wDAAQ;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACtCgG;AAC/B;AAC1D,qCAAqC,0GAA6B;AACzE,2BAA2B;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,yEAAkB;AAChD;AACA;AACA;AACA,oBAAoB,uDAAI;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;AC1BA,cAAc,SAAI,IAAI,SAAI;AAC1B;AACA;AACA;AACA;AACA,6DAA6D,cAAc;AAC3E;AACA;AACA;AACA;AACA;AAC4E;AACV;AACyD;AACpH,oDAAoD;AAC3D,YAAY,yDAAyD;AACrE;AACA;AACA,gBAAgB,sFAAoB,iBAAiB,2EAAsB;AAC3E;AACA;AACA,qEAAqE,oBAAoB,2BAA2B;AACpH;AACA,qCAAqC,+FAAwC,qJAAqJ;AAClO;AACA;AACA,qEAAqE,oBAAoB,2BAA2B;AACpH;AACA,qCAAqC,6FAAsC,+IAA+I;AAC1N;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC9BoD;AACY;AACU;AACS;AACE;AACwE;AAC/E;AACM;AAC5B;AACoB;AACM;AAClC;AACkP;AAClS;AACA;AACA;AACO,qCAAqC,sEAAmB;AAC/D,4BAA4B;AAC5B;AACA;AACA;AACA,uBAAuB,0DAAO;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,kFAAiB;AACxC;AACA;AACA,uBAAuB,4DAAsB;AAC7C;AACA;AACA,uBAAuB,qFAAoB;AAC3C;AACA;AACA,uBAAuB,sEAAgC;AACvD;AACA;AACA;AACA,uBAAuB,mGAAkC;AACzD;AACA;AACA,YAAY,8DAAO;AACnB,uBAAuB,yDAAmB;AAC1C;AACA;AACA,uBAAuB,2DAAqB;AAC5C;AACA;AACA,uBAAuB,yDAAmB;AAC1C;AACA;AACA,uBAAuB,2DAAqB;AAC5C;AACA;AACA,uBAAuB,yFAAwB;AAC/C;AACA,mBAAmB,+DAAyB;AAC5C,mBAAmB,kEAA4B;AAC/C,mBAAmB,gEAA0B;AAC7C,mBAAmB,mEAA6B,IAAI,0DAAO;AAC3D;AACA,yBAAyB,yEAAe,SAAS,gFAAsB;AACvE,6BAA6B,2EAAiB;AAC9C;AACA;AACA;AACA;AACA,kCAAkC,6DAAmB;AACrD;AACA,iBAAiB;AACjB,aAAa;AACb;AACA,kFAAkF,qFAA2B,KAAK,8FAA+B,KAAK,6EAAkB,KAAK,kEAAiB,GAAG,eAAe;AAChN;AACA;AACA,iBAAiB;AACjB;AACA,SAAS;AACT;AACA,uFAAuF,2EAAyB;AAChH;AACA,SAAS;AACT,gBAAgB,uFAAuF;AACvG,QAAQ,yFAAwB;AAChC,+FAA+F,gGAA8B;AAC7H;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT,0BAA0B,sDAAK,EAAE,wDAAO;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;ACrGoD;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,MAAM,8DAAc,QAAQ;AACrD;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;ACvCgE;AACzD,6CAA6C;AACpD;AACA;AACA,gDAAgD,0EAAgB,sBAAsB,0EAAgB;AACtG;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO;AACA;AACA;AACP;AACO;AACA;AACP;AACO;AACA;AACP;AACO;AACA;AACA;AACA;AACP","sources":["webpack:///./node_modules/@grafana/faro-core/dist/esm/api/ItemBuffer.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/api/const.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/api/events/initialize.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/api/exceptions/const.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/api/exceptions/initialize.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/api/initialize.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/api/logs/const.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/api/logs/initialize.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/api/measurements/initialize.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/api/meta/initialize.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/api/traces/initialize.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/api/userActionLifecycleHandler.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/api/utils.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/config/const.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/consts.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/extensions/baseExtension.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/globalObject/globalObject.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/initialize.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/instrumentations/base.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/instrumentations/initialize.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/instrumentations/registerInitial.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/internalLogger/const.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/internalLogger/createInternalLogger.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/internalLogger/initialize.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/metas/initialize.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/metas/registerInitial.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/sdk/const.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/sdk/faroGlobalObject.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/sdk/internalFaroGlobalObject.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/sdk/registerFaro.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/semantic.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/transports/base.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/transports/batchExecutor.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/transports/const.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/transports/initialize.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/transports/registerInitial.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/transports/utils.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/unpatchedConsole/const.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/unpatchedConsole/initialize.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/utils/date.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/utils/deepEqual.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/utils/is.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/utils/json.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/utils/logLevels.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/utils/noop.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/utils/promiseBuffer.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/utils/reactive.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/utils/shortId.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/utils/sourceMaps.js","webpack:///./node_modules/@grafana/faro-core/dist/esm/version.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/config/getWebInstrumentations.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/config/makeCoreConfig.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/consts.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/initialize.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/console/instrumentation.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/errors/const.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/errors/getErrorDetails.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/errors/getValueAndTypeFromMessage.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/errors/instrumentation.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/errors/registerOnerror.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/errors/registerOnunhandledrejection.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/errors/stackFrames/buildStackFrame.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/errors/stackFrames/const.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/errors/stackFrames/getDataFromSafariExtensions.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/errors/stackFrames/getStackFramesFromError.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/errors/stackFrames/parseStacktrace.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/instrumentationConstants.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/performance/instrumentation.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/performance/navigation.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/performance/performanceConstants.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/performance/performanceUtils.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/performance/resource.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/session/instrumentation.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/session/sessionManager/PersistentSessionsManager.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/session/sessionManager/VolatileSessionManager.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/session/sessionManager/getSessionManagerByConfig.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/session/sessionManager/sampling.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/session/sessionManager/sessionConstants.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/session/sessionManager/sessionManagerUtils.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/userActions/const.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/userActions/domMutationMonitor.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/userActions/httpRequestMonitor.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/userActions/instrumentation.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/userActions/performanceEntriesMonitor.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/userActions/processUserActionEventHandler.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/userActions/util.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/view/instrumentation.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/webVitals/instrumentation.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/webVitals/webVitalsBasic.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/instrumentations/webVitals/webVitalsWithAttribution.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/metas/browser/meta.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/metas/k6/meta.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/metas/page/meta.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/metas/session/createSession.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/transports/fetch/transport.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/utils/throttle.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/utils/url.js","webpack:///./node_modules/@grafana/faro-web-sdk/dist/esm/utils/webStorage.js","webpack:///./node_modules/@grafana/faro-web-tracing/dist/esm/faroMetaAttributesSpanProcessor.js","webpack:///./node_modules/@grafana/faro-web-tracing/dist/esm/faroTraceExporter.js","webpack:///./node_modules/@grafana/faro-web-tracing/dist/esm/faroTraceExporter.utils.js","webpack:///./node_modules/@grafana/faro-web-tracing/dist/esm/faroUserActionSpanProcessor.js","webpack:///./node_modules/@grafana/faro-web-tracing/dist/esm/faroXhrInstrumentation.js","webpack:///./node_modules/@grafana/faro-web-tracing/dist/esm/getDefaultOTELInstrumentations.js","webpack:///./node_modules/@grafana/faro-web-tracing/dist/esm/instrumentation.js","webpack:///./node_modules/@grafana/faro-web-tracing/dist/esm/instrumentationUtils.js","webpack:///./node_modules/@grafana/faro-web-tracing/dist/esm/sampler.js","webpack:///./node_modules/@grafana/faro-web-tracing/dist/esm/semconv.js"],"sourcesContent":["import { isFunction } from '../utils/is';\nexport class ItemBuffer {\n constructor() {\n this.buffer = [];\n }\n addItem(item) {\n this.buffer.push(item);\n }\n flushBuffer(cb) {\n if (isFunction(cb)) {\n for (const item of this.buffer) {\n cb(item);\n }\n }\n this.buffer.length = 0;\n }\n size() {\n return this.buffer.length;\n }\n}\n//# sourceMappingURL=ItemBuffer.js.map","export const USER_ACTION_START = 'user-action-start';\nexport const USER_ACTION_END = 'user-action-end';\nexport const USER_ACTION_CANCEL = 'user-action-cancel';\nexport const USER_ACTION_HALT = 'user-action-halt';\n//# sourceMappingURL=const.js.map","import { TransportItemType } from '../../transports';\nimport { deepEqual, getCurrentTimestamp, isEmpty, isNull, stringifyObjectValues } from '../../utils';\nimport { timestampToIsoString } from '../../utils/date';\nimport { USER_ACTION_START } from '../const';\nexport function initializeEventsAPI({ internalLogger, config, metas, transports, tracesApi, actionBuffer, getMessage, }) {\n let lastPayload = null;\n const pushEvent = (name, attributes, domain, { skipDedupe, spanContext, timestampOverwriteMs, customPayloadTransformer = (payload) => payload } = {}) => {\n try {\n const attrs = stringifyObjectValues(attributes);\n const item = {\n meta: metas.value,\n payload: customPayloadTransformer({\n name,\n domain: domain !== null && domain !== void 0 ? domain : config.eventDomain,\n attributes: isEmpty(attrs) ? undefined : attrs,\n timestamp: timestampOverwriteMs ? timestampToIsoString(timestampOverwriteMs) : getCurrentTimestamp(),\n trace: spanContext\n ? {\n trace_id: spanContext.traceId,\n span_id: spanContext.spanId,\n }\n : tracesApi.getTraceContext(),\n }),\n type: TransportItemType.EVENT,\n };\n const testingPayload = {\n name: item.payload.name,\n attributes: item.payload.attributes,\n domain: item.payload.domain,\n };\n if (!skipDedupe && config.dedupe && !isNull(lastPayload) && deepEqual(testingPayload, lastPayload)) {\n internalLogger.debug('Skipping event push because it is the same as the last one\\n', item.payload);\n return;\n }\n lastPayload = testingPayload;\n internalLogger.debug('Pushing event\\n', item);\n const msg = getMessage();\n if (msg && msg.type === USER_ACTION_START) {\n actionBuffer.addItem(item);\n }\n else {\n transports.execute(item);\n }\n }\n catch (err) {\n internalLogger.error('Error pushing event', err);\n }\n };\n return {\n pushEvent,\n };\n}\n//# sourceMappingURL=initialize.js.map","import { isObject, stringifyExternalJson } from '../../utils';\nexport const defaultExceptionType = 'Error';\nexport const defaultErrorArgsSerializer = (args) => {\n return args\n .map((arg) => {\n if (isObject(arg)) {\n return stringifyExternalJson(arg);\n }\n return String(arg);\n })\n .join(' ');\n};\n//# sourceMappingURL=const.js.map","import { TransportItemType } from '../../transports';\nimport { deepEqual, getCurrentTimestamp, isArray, isEmpty, isError, isNull, isObject, stringifyExternalJson, stringifyObjectValues, } from '../../utils';\nimport { timestampToIsoString } from '../../utils/date';\nimport { USER_ACTION_START } from '../const';\nimport { shouldIgnoreEvent } from '../utils';\nimport { defaultExceptionType } from './const';\nlet stacktraceParser;\nexport function initializeExceptionsAPI({ internalLogger, config, metas, transports, tracesApi, actionBuffer, getMessage, }) {\n var _a;\n internalLogger.debug('Initializing exceptions API');\n let lastPayload = null;\n stacktraceParser = (_a = config.parseStacktrace) !== null && _a !== void 0 ? _a : stacktraceParser;\n const changeStacktraceParser = (newStacktraceParser) => {\n internalLogger.debug('Changing stacktrace parser');\n stacktraceParser = newStacktraceParser !== null && newStacktraceParser !== void 0 ? newStacktraceParser : stacktraceParser;\n };\n const getStacktraceParser = () => stacktraceParser;\n const { ignoreErrors = [], preserveOriginalError } = config;\n const pushError = (error, { skipDedupe, stackFrames, type, context, spanContext, timestampOverwriteMs, originalError } = {}) => {\n if (isErrorIgnored(ignoreErrors, originalError !== null && originalError !== void 0 ? originalError : error)) {\n return;\n }\n try {\n const ctx = stringifyObjectValues(Object.assign(Object.assign({}, parseCause(originalError !== null && originalError !== void 0 ? originalError : error)), (context !== null && context !== void 0 ? context : {})));\n const item = {\n meta: metas.value,\n payload: Object.assign(Object.assign({ type: type || error.name || defaultExceptionType, value: error.message, timestamp: timestampOverwriteMs ? timestampToIsoString(timestampOverwriteMs) : getCurrentTimestamp(), trace: spanContext\n ? {\n trace_id: spanContext.traceId,\n span_id: spanContext.spanId,\n }\n : tracesApi.getTraceContext() }, (isEmpty(ctx) ? {} : { context: ctx })), (preserveOriginalError ? { originalError } : {})),\n type: TransportItemType.EXCEPTION,\n };\n stackFrames = stackFrames !== null && stackFrames !== void 0 ? stackFrames : (error.stack ? stacktraceParser === null || stacktraceParser === void 0 ? void 0 : stacktraceParser(error).frames : undefined);\n if (stackFrames === null || stackFrames === void 0 ? void 0 : stackFrames.length) {\n item.payload.stacktrace = {\n frames: stackFrames,\n };\n }\n const testingPayload = {\n type: item.payload.type,\n value: item.payload.value,\n stackTrace: item.payload.stacktrace,\n context: item.payload.context,\n };\n if (!skipDedupe && config.dedupe && !isNull(lastPayload) && deepEqual(testingPayload, lastPayload)) {\n internalLogger.debug('Skipping error push because it is the same as the last one\\n', item.payload);\n return;\n }\n lastPayload = testingPayload;\n internalLogger.debug('Pushing exception\\n', item);\n const msg = getMessage();\n if (msg && msg.type === USER_ACTION_START) {\n actionBuffer.addItem(item);\n }\n else {\n transports.execute(item);\n }\n }\n catch (err) {\n internalLogger.error('Error pushing event', err);\n }\n };\n changeStacktraceParser(config.parseStacktrace);\n return {\n changeStacktraceParser,\n getStacktraceParser,\n pushError,\n };\n}\nfunction parseCause(error) {\n let cause = error.cause;\n if (isError(cause)) {\n cause = error.cause.toString();\n // typeof operator on null returns \"object\". This is a well-known quirk in JavaScript and is considered a bug that cannot be fixed due to backward compatibility issues.\n // MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof#typeof_null\n }\n else if (cause !== null && (isObject(error.cause) || isArray(error.cause))) {\n cause = stringifyExternalJson(error.cause);\n }\n else if (cause != null) {\n cause = error.cause.toString();\n }\n return cause == null ? {} : { cause };\n}\nfunction isErrorIgnored(ignoreErrors, error) {\n const { message, name, stack } = error;\n return shouldIgnoreEvent(ignoreErrors, message + ' ' + name + ' ' + stack);\n}\n//# sourceMappingURL=initialize.js.map","import { Observable } from '../utils';\nimport { initializeEventsAPI } from './events';\nimport { initializeExceptionsAPI } from './exceptions';\nimport { initializeLogsAPI } from './logs';\nimport { initializeMeasurementsAPI } from './measurements';\nimport { initializeMetaAPI } from './meta';\nimport { initializeTracesAPI } from './traces';\nimport { createUserActionLifecycleHandler } from './userActionLifecycleHandler';\nexport const apiMessageBus = new Observable();\nexport function initializeAPI(unpatchedConsole, internalLogger, config, metas, transports) {\n internalLogger.debug('Initializing API');\n const { actionBuffer, getMessage } = createUserActionLifecycleHandler({ apiMessageBus, transports, config });\n const tracesApi = initializeTracesAPI(unpatchedConsole, internalLogger, config, metas, transports);\n const props = {\n unpatchedConsole,\n internalLogger,\n config,\n metas,\n transports,\n tracesApi,\n actionBuffer,\n getMessage,\n };\n return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, tracesApi), initializeExceptionsAPI(props)), initializeMetaAPI(props)), initializeLogsAPI(props)), initializeMeasurementsAPI(props)), initializeEventsAPI(props));\n}\n//# sourceMappingURL=initialize.js.map","export const defaultLogArgsSerializer = (args) => args\n .map((arg) => {\n try {\n return String(arg);\n }\n catch (err) {\n return '';\n }\n})\n .join(' ');\n//# sourceMappingURL=const.js.map","import { TransportItemType } from '../../transports';\nimport { deepEqual, defaultLogLevel, getCurrentTimestamp, isEmpty, isNull, stringifyObjectValues } from '../../utils';\nimport { timestampToIsoString } from '../../utils/date';\nimport { USER_ACTION_START } from '../const';\nimport { defaultLogArgsSerializer } from './const';\nexport function initializeLogsAPI({ internalLogger, config, metas, transports, tracesApi, actionBuffer, getMessage, }) {\n var _a;\n internalLogger.debug('Initializing logs API');\n let lastPayload = null;\n const logArgsSerializer = (_a = config.logArgsSerializer) !== null && _a !== void 0 ? _a : defaultLogArgsSerializer;\n const pushLog = (args, { context, level, skipDedupe, spanContext, timestampOverwriteMs } = {}) => {\n try {\n const ctx = stringifyObjectValues(context);\n const item = {\n type: TransportItemType.LOG,\n payload: {\n message: logArgsSerializer(args),\n level: level !== null && level !== void 0 ? level : defaultLogLevel,\n context: isEmpty(ctx) ? undefined : ctx,\n timestamp: timestampOverwriteMs ? timestampToIsoString(timestampOverwriteMs) : getCurrentTimestamp(),\n trace: spanContext\n ? {\n trace_id: spanContext.traceId,\n span_id: spanContext.spanId,\n }\n : tracesApi.getTraceContext(),\n },\n meta: metas.value,\n };\n const testingPayload = {\n message: item.payload.message,\n level: item.payload.level,\n context: item.payload.context,\n };\n if (!skipDedupe && config.dedupe && !isNull(lastPayload) && deepEqual(testingPayload, lastPayload)) {\n internalLogger.debug('Skipping log push because it is the same as the last one\\n', item.payload);\n return;\n }\n lastPayload = testingPayload;\n internalLogger.debug('Pushing log\\n', item);\n const msg = getMessage();\n if (msg && msg.type === USER_ACTION_START) {\n actionBuffer.addItem(item);\n }\n else {\n transports.execute(item);\n }\n }\n catch (err) {\n internalLogger.error('Error pushing log\\n', err);\n }\n };\n return {\n pushLog,\n };\n}\n//# sourceMappingURL=initialize.js.map","import { TransportItemType } from '../../transports';\nimport { deepEqual, getCurrentTimestamp, isEmpty, isNull, stringifyObjectValues } from '../../utils';\nimport { timestampToIsoString } from '../../utils/date';\nimport { USER_ACTION_START } from '../const';\nexport function initializeMeasurementsAPI({ internalLogger, config, metas, transports, tracesApi, actionBuffer, getMessage, }) {\n internalLogger.debug('Initializing measurements API');\n let lastPayload = null;\n const pushMeasurement = (payload, { skipDedupe, context, spanContext, timestampOverwriteMs } = {}) => {\n try {\n const ctx = stringifyObjectValues(context);\n const item = {\n type: TransportItemType.MEASUREMENT,\n payload: Object.assign(Object.assign({}, payload), { trace: spanContext\n ? {\n trace_id: spanContext.traceId,\n span_id: spanContext.spanId,\n }\n : tracesApi.getTraceContext(), timestamp: timestampOverwriteMs ? timestampToIsoString(timestampOverwriteMs) : getCurrentTimestamp(), context: isEmpty(ctx) ? undefined : ctx }),\n meta: metas.value,\n };\n const testingPayload = {\n type: item.payload.type,\n values: item.payload.values,\n context: item.payload.context,\n };\n if (!skipDedupe && config.dedupe && !isNull(lastPayload) && deepEqual(testingPayload, lastPayload)) {\n internalLogger.debug('Skipping measurement push because it is the same as the last one\\n', item.payload);\n return;\n }\n lastPayload = testingPayload;\n internalLogger.debug('Pushing measurement\\n', item);\n const msg = getMessage();\n if (msg && msg.type === USER_ACTION_START) {\n actionBuffer.addItem(item);\n }\n else {\n transports.execute(item);\n }\n }\n catch (err) {\n internalLogger.error('Error pushing measurement\\n', err);\n }\n };\n return {\n pushMeasurement,\n };\n}\n//# sourceMappingURL=initialize.js.map","import { isEmpty, isString } from '../../utils/is';\nexport function initializeMetaAPI({ internalLogger, metas, }) {\n internalLogger.debug('Initializing meta API');\n let metaSession = undefined;\n let metaUser = undefined;\n let metaView = undefined;\n let metaPage = undefined;\n const setUser = (user) => {\n if (metaUser) {\n metas.remove(metaUser);\n }\n metaUser = {\n user,\n };\n metas.add(metaUser);\n };\n const setSession = (session, options) => {\n var _a;\n const newOverrides = options === null || options === void 0 ? void 0 : options.overrides;\n const overrides = newOverrides\n ? {\n overrides: Object.assign(Object.assign({}, (_a = metaSession === null || metaSession === void 0 ? void 0 : metaSession.session) === null || _a === void 0 ? void 0 : _a.overrides), newOverrides),\n }\n : {};\n if (metaSession) {\n metas.remove(metaSession);\n }\n metaSession = {\n session: Object.assign(Object.assign({}, (isEmpty(session) ? undefined : session)), overrides),\n };\n metas.add(metaSession);\n };\n const getSession = () => metas.value.session;\n const setView = (view, options) => {\n var _a;\n if (options === null || options === void 0 ? void 0 : options.overrides) {\n setSession(getSession(), { overrides: options.overrides });\n }\n if (((_a = metaView === null || metaView === void 0 ? void 0 : metaView.view) === null || _a === void 0 ? void 0 : _a.name) === (view === null || view === void 0 ? void 0 : view.name)) {\n return;\n }\n const previousView = metaView;\n metaView = {\n view,\n };\n metas.add(metaView);\n if (previousView) {\n metas.remove(previousView);\n }\n };\n const getView = () => metas.value.view;\n const setPage = (page) => {\n var _a;\n const pageMeta = isString(page)\n ? Object.assign(Object.assign({}, ((_a = metaPage === null || metaPage === void 0 ? void 0 : metaPage.page) !== null && _a !== void 0 ? _a : getPage())), { id: page }) : page;\n if (metaPage) {\n metas.remove(metaPage);\n }\n metaPage = {\n page: pageMeta,\n };\n metas.add(metaPage);\n };\n const getPage = () => metas.value.page;\n return {\n setUser,\n resetUser: setUser,\n setSession,\n resetSession: setSession,\n getSession,\n setView,\n getView,\n setPage,\n getPage,\n };\n}\n//# sourceMappingURL=initialize.js.map","import { TransportItemType } from '../../transports';\nexport function initializeTracesAPI(_unpatchedConsole, internalLogger, _config, metas, transports) {\n internalLogger.debug('Initializing traces API');\n let otel = undefined;\n const initOTEL = (trace, context) => {\n internalLogger.debug('Initializing OpenTelemetry');\n otel = {\n trace,\n context,\n };\n };\n const getTraceContext = () => {\n const ctx = otel === null || otel === void 0 ? void 0 : otel.trace.getSpanContext(otel.context.active());\n return !ctx\n ? undefined\n : {\n trace_id: ctx.traceId,\n span_id: ctx.spanId,\n };\n };\n const pushTraces = (payload) => {\n try {\n const item = {\n type: TransportItemType.TRACE,\n payload,\n meta: metas.value,\n };\n internalLogger.debug('Pushing trace\\n', item);\n transports.execute(item);\n }\n catch (err) {\n internalLogger.error('Error pushing trace\\n', err);\n }\n };\n const getOTEL = () => otel;\n const isOTELInitialized = () => !!otel;\n return {\n getOTEL,\n getTraceContext,\n initOTEL,\n isOTELInitialized,\n pushTraces,\n };\n}\n//# sourceMappingURL=initialize.js.map","import { TransportItemType } from '../transports';\nimport { USER_ACTION_CANCEL, USER_ACTION_END, USER_ACTION_HALT, USER_ACTION_START } from './const';\nimport { ItemBuffer } from './ItemBuffer';\nexport function createUserActionLifecycleHandler({ apiMessageBus, transports, config, }) {\n const actionBuffer = new ItemBuffer();\n const trackUserActionsExcludeItem = config.trackUserActionsExcludeItem;\n let message;\n apiMessageBus.subscribe((msg) => {\n if (USER_ACTION_START === msg.type || USER_ACTION_HALT === msg.type) {\n message = msg;\n return;\n }\n if (msg.type === USER_ACTION_END) {\n const { id, name } = msg;\n actionBuffer.flushBuffer((item) => {\n if (isExcludeFromUserAction(item, trackUserActionsExcludeItem)) {\n transports.execute(item);\n return;\n }\n const userActionItem = Object.assign(Object.assign({}, item), { payload: Object.assign(Object.assign({}, item.payload), { action: {\n parentId: id,\n name,\n } }) });\n transports.execute(userActionItem);\n });\n message = undefined;\n return;\n }\n if (msg.type === USER_ACTION_CANCEL) {\n message = undefined;\n actionBuffer.flushBuffer((item) => {\n transports.execute(item);\n });\n }\n });\n const getMessage = () => message;\n return { actionBuffer, getMessage };\n}\nfunction isExcludeFromUserAction(item, trackUserActionsExcludeItem) {\n return ((trackUserActionsExcludeItem === null || trackUserActionsExcludeItem === void 0 ? void 0 : trackUserActionsExcludeItem(item)) ||\n (item.type === TransportItemType.MEASUREMENT && item.payload.type === 'web-vitals'));\n}\n//# sourceMappingURL=userActionLifecycleHandler.js.map","import { isString } from '../utils/is';\nexport function shouldIgnoreEvent(patterns, msg) {\n return patterns.some((pattern) => {\n return isString(pattern) ? msg.includes(pattern) : !!msg.match(pattern);\n });\n}\n//# sourceMappingURL=utils.js.map","export const defaultGlobalObjectKey = 'faro';\nexport const defaultBatchingConfig = {\n enabled: true,\n sendTimeout: 250,\n itemLimit: 50,\n};\n//# sourceMappingURL=const.js.map","export const unknownString = 'unknown';\n//# sourceMappingURL=consts.js.map","import { defaultInternalLogger } from '../internalLogger';\nimport { defaultUnpatchedConsole } from '../unpatchedConsole';\nexport class BaseExtension {\n constructor() {\n this.unpatchedConsole = defaultUnpatchedConsole;\n this.internalLogger = defaultInternalLogger;\n this.config = {};\n this.metas = {};\n }\n logDebug(...args) {\n this.internalLogger.debug(`${this.name}\\n`, ...args);\n }\n logInfo(...args) {\n this.internalLogger.info(`${this.name}\\n`, ...args);\n }\n logWarn(...args) {\n this.internalLogger.warn(`${this.name}\\n`, ...args);\n }\n logError(...args) {\n this.internalLogger.error(`${this.name}\\n`, ...args);\n }\n}\n//# sourceMappingURL=baseExtension.js.map","// This does not uses isUndefined method because it will throw an error in non-browser environments\nexport const globalObject = (typeof globalThis !== 'undefined'\n ? globalThis\n : typeof global !== 'undefined'\n ? global\n : typeof self !== 'undefined'\n ? self\n : undefined);\n//# sourceMappingURL=globalObject.js.map","import { initializeAPI } from './api';\nimport { initializeInstrumentations, registerInitialInstrumentations } from './instrumentations';\nimport { initializeInternalLogger } from './internalLogger';\nimport { initializeMetas, registerInitialMetas } from './metas';\nimport { isInternalFaroOnGlobalObject, registerFaro } from './sdk';\nimport { initializeTransports, registerInitialTransports } from './transports';\nimport { initializeUnpatchedConsole } from './unpatchedConsole';\nexport function initializeFaro(config) {\n const unpatchedConsole = initializeUnpatchedConsole(config);\n const internalLogger = initializeInternalLogger(unpatchedConsole, config);\n if (isInternalFaroOnGlobalObject() && !config.isolate) {\n internalLogger.error('Faro is already registered. Either add instrumentations, transports etc. to the global faro instance or use the \"isolate\" property');\n return undefined;\n }\n internalLogger.debug('Initializing');\n // Initializing the APIs\n const metas = initializeMetas(unpatchedConsole, internalLogger, config);\n const transports = initializeTransports(unpatchedConsole, internalLogger, config, metas);\n const api = initializeAPI(unpatchedConsole, internalLogger, config, metas, transports);\n const instrumentations = initializeInstrumentations(unpatchedConsole, internalLogger, config, metas, transports, api);\n const faro = registerFaro(unpatchedConsole, internalLogger, config, metas, transports, api, instrumentations);\n // make sure Faro is initialized before registering default metas, instrumentations, transports etc.\n registerInitialMetas(faro);\n registerInitialTransports(faro);\n registerInitialInstrumentations(faro);\n return faro;\n}\n//# sourceMappingURL=initialize.js.map","import { BaseExtension } from '../extensions';\nexport class BaseInstrumentation extends BaseExtension {\n constructor() {\n super(...arguments);\n this.api = {};\n this.transports = {};\n }\n}\n//# sourceMappingURL=base.js.map","export function initializeInstrumentations(unpatchedConsole, internalLogger, config, metas, transports, api) {\n internalLogger.debug('Initializing instrumentations');\n const instrumentations = [];\n const add = (...newInstrumentations) => {\n internalLogger.debug('Adding instrumentations');\n newInstrumentations.forEach((newInstrumentation) => {\n internalLogger.debug(`Adding \"${newInstrumentation.name}\" instrumentation`);\n const exists = instrumentations.some((existingInstrumentation) => existingInstrumentation.name === newInstrumentation.name);\n if (exists) {\n internalLogger.warn(`Instrumentation ${newInstrumentation.name} is already added`);\n return;\n }\n newInstrumentation.unpatchedConsole = unpatchedConsole;\n newInstrumentation.internalLogger = internalLogger;\n newInstrumentation.config = config;\n newInstrumentation.metas = metas;\n newInstrumentation.transports = transports;\n newInstrumentation.api = api;\n instrumentations.push(newInstrumentation);\n newInstrumentation.initialize();\n });\n };\n const remove = (...instrumentationsToRemove) => {\n internalLogger.debug('Removing instrumentations');\n instrumentationsToRemove.forEach((instrumentationToRemove) => {\n var _a, _b;\n internalLogger.debug(`Removing \"${instrumentationToRemove.name}\" instrumentation`);\n const existingInstrumentationIndex = instrumentations.reduce((acc, existingInstrumentation, existingTransportIndex) => {\n if (acc === null && existingInstrumentation.name === instrumentationToRemove.name) {\n return existingTransportIndex;\n }\n return null;\n }, null);\n if (!existingInstrumentationIndex) {\n internalLogger.warn(`Instrumentation \"${instrumentationToRemove.name}\" is not added`);\n return;\n }\n (_b = (_a = instrumentations[existingInstrumentationIndex]).destroy) === null || _b === void 0 ? void 0 : _b.call(_a);\n instrumentations.splice(existingInstrumentationIndex, 1);\n });\n };\n return {\n add,\n get instrumentations() {\n return [...instrumentations];\n },\n remove,\n };\n}\n//# sourceMappingURL=initialize.js.map","export function registerInitialInstrumentations(faro) {\n faro.instrumentations.add(...faro.config.instrumentations);\n}\n//# sourceMappingURL=registerInitial.js.map","import { noop } from '../utils';\nexport var InternalLoggerLevel;\n(function (InternalLoggerLevel) {\n InternalLoggerLevel[InternalLoggerLevel[\"OFF\"] = 0] = \"OFF\";\n InternalLoggerLevel[InternalLoggerLevel[\"ERROR\"] = 1] = \"ERROR\";\n InternalLoggerLevel[InternalLoggerLevel[\"WARN\"] = 2] = \"WARN\";\n InternalLoggerLevel[InternalLoggerLevel[\"INFO\"] = 3] = \"INFO\";\n InternalLoggerLevel[InternalLoggerLevel[\"VERBOSE\"] = 4] = \"VERBOSE\";\n})(InternalLoggerLevel || (InternalLoggerLevel = {}));\nexport const defaultInternalLoggerPrefix = 'Faro';\nexport const defaultInternalLogger = {\n debug: noop,\n error: noop,\n info: noop,\n prefix: defaultInternalLoggerPrefix,\n warn: noop,\n};\nexport const defaultInternalLoggerLevel = InternalLoggerLevel.ERROR;\n//# sourceMappingURL=const.js.map","import { defaultUnpatchedConsole } from '../unpatchedConsole';\nimport { noop } from '../utils';\nimport { defaultInternalLogger, defaultInternalLoggerLevel, InternalLoggerLevel } from './const';\nexport function createInternalLogger(unpatchedConsole = defaultUnpatchedConsole, internalLoggerLevel = defaultInternalLoggerLevel) {\n const internalLogger = defaultInternalLogger;\n if (internalLoggerLevel > InternalLoggerLevel.OFF) {\n internalLogger.error =\n internalLoggerLevel >= InternalLoggerLevel.ERROR\n ? function (...args) {\n unpatchedConsole.error(`${internalLogger.prefix}\\n`, ...args);\n }\n : noop;\n internalLogger.warn =\n internalLoggerLevel >= InternalLoggerLevel.WARN\n ? function (...args) {\n unpatchedConsole.warn(`${internalLogger.prefix}\\n`, ...args);\n }\n : noop;\n internalLogger.info =\n internalLoggerLevel >= InternalLoggerLevel.INFO\n ? function (...args) {\n unpatchedConsole.info(`${internalLogger.prefix}\\n`, ...args);\n }\n : noop;\n internalLogger.debug =\n internalLoggerLevel >= InternalLoggerLevel.VERBOSE\n ? function (...args) {\n unpatchedConsole.debug(`${internalLogger.prefix}\\n`, ...args);\n }\n : noop;\n }\n return internalLogger;\n}\n//# sourceMappingURL=createInternalLogger.js.map","import { defaultInternalLogger } from './const';\nimport { createInternalLogger } from './createInternalLogger';\nexport let internalLogger = defaultInternalLogger;\nexport function initializeInternalLogger(unpatchedConsole, config) {\n internalLogger = createInternalLogger(unpatchedConsole, config.internalLoggerLevel);\n return internalLogger;\n}\n//# sourceMappingURL=initialize.js.map","import { isFunction } from '../utils';\nexport function initializeMetas(_unpatchedConsole, internalLogger, _config) {\n let items = [];\n let listeners = [];\n const getValue = () => items.reduce((acc, item) => Object.assign(acc, isFunction(item) ? item() : item), {});\n const notifyListeners = () => {\n if (listeners.length) {\n const value = getValue();\n listeners.forEach((listener) => listener(value));\n }\n };\n const add = (...newItems) => {\n internalLogger.debug('Adding metas\\n', newItems);\n items.push(...newItems);\n notifyListeners();\n };\n const remove = (...itemsToRemove) => {\n internalLogger.debug('Removing metas\\n', itemsToRemove);\n items = items.filter((currentItem) => !itemsToRemove.includes(currentItem));\n notifyListeners();\n };\n const addListener = (listener) => {\n internalLogger.debug('Adding metas listener\\n', listener);\n listeners.push(listener);\n };\n const removeListener = (listener) => {\n internalLogger.debug('Removing metas listener\\n', listener);\n listeners = listeners.filter((currentListener) => currentListener !== listener);\n };\n return {\n add,\n remove,\n addListener,\n removeListener,\n get value() {\n return getValue();\n },\n };\n}\n//# sourceMappingURL=initialize.js.map","import { getBundleId } from '../utils/sourceMaps';\nimport { VERSION } from '../version';\nexport function registerInitialMetas(faro) {\n var _a, _b;\n const initial = {\n sdk: {\n version: VERSION,\n },\n app: {\n bundleId: faro.config.app.name && getBundleId(faro.config.app.name),\n },\n };\n const session = (_a = faro.config.sessionTracking) === null || _a === void 0 ? void 0 : _a.session;\n if (session) {\n faro.api.setSession(session);\n }\n if (faro.config.app) {\n initial.app = Object.assign(Object.assign({}, faro.config.app), initial.app);\n }\n if (faro.config.user) {\n initial.user = faro.config.user;\n }\n if (faro.config.view) {\n initial.view = faro.config.view;\n }\n faro.metas.add(initial, ...((_b = faro.config.metas) !== null && _b !== void 0 ? _b : []));\n}\n//# sourceMappingURL=registerInitial.js.map","export const internalGlobalObjectKey = '_faroInternal';\n//# sourceMappingURL=const.js.map","import { globalObject } from '../globalObject';\nexport function setFaroOnGlobalObject(faro) {\n if (!faro.config.preventGlobalExposure) {\n faro.internalLogger.debug(`Registering public faro reference in the global scope using \"${faro.config.globalObjectKey}\" key`);\n if (faro.config.globalObjectKey in globalObject) {\n faro.internalLogger.warn(`Skipping global registration due to key \"${faro.config.globalObjectKey}\" being used already. Please set \"globalObjectKey\" to something else or set \"preventGlobalExposure\" to \"true\"`);\n return;\n }\n Object.defineProperty(globalObject, faro.config.globalObjectKey, {\n configurable: false,\n writable: false,\n value: faro,\n });\n }\n else {\n faro.internalLogger.debug('Skipping registering public Faro instance in the global scope');\n }\n}\n//# sourceMappingURL=faroGlobalObject.js.map","import { globalObject } from '../globalObject';\nimport { internalGlobalObjectKey } from './const';\nexport function getInternalFromGlobalObject() {\n return globalObject[internalGlobalObjectKey];\n}\nexport function setInternalFaroOnGlobalObject(faro) {\n if (!faro.config.isolate) {\n faro.internalLogger.debug('Registering internal Faro instance on global object');\n Object.defineProperty(globalObject, internalGlobalObjectKey, {\n configurable: false,\n enumerable: false,\n writable: false,\n value: faro,\n });\n }\n else {\n faro.internalLogger.debug('Skipping registering internal Faro instance on global object');\n }\n}\nexport function isInternalFaroOnGlobalObject() {\n return internalGlobalObjectKey in globalObject;\n}\n//# sourceMappingURL=internalFaroGlobalObject.js.map","import { setFaroOnGlobalObject } from './faroGlobalObject';\nimport { setInternalFaroOnGlobalObject } from './internalFaroGlobalObject';\nexport let faro = {};\nexport function registerFaro(unpatchedConsole, internalLogger, config, metas, transports, api, instrumentations) {\n internalLogger.debug('Initializing Faro');\n faro = {\n api,\n config,\n instrumentations,\n internalLogger,\n metas,\n pause: transports.pause,\n transports,\n unpatchedConsole,\n unpause: transports.unpause,\n };\n setInternalFaroOnGlobalObject(faro);\n setFaroOnGlobalObject(faro);\n return faro;\n}\n//# sourceMappingURL=registerFaro.js.map","/**\n * @deprecated The conventions object will be removed in a future version\n */\nexport const Conventions = {\n /**\n * @deprecated The event names object will be removed in a future version\n */\n EventNames: {\n CLICK: 'click',\n NAVIGATION: 'navigation',\n SESSION_START: 'session_start',\n VIEW_CHANGED: 'view_changed',\n },\n};\nexport const EVENT_CLICK = 'click';\nexport const EVENT_NAVIGATION = 'navigation';\nexport const EVENT_VIEW_CHANGED = 'view_changed';\nexport const EVENT_SESSION_START = 'session_start';\nexport const EVENT_SESSION_RESUME = 'session_resume';\nexport const EVENT_SESSION_EXTEND = 'session_extend';\nexport const EVENT_OVERRIDES_SERVICE_NAME = 'service_name_override';\nexport const EVENT_ROUTE_CHANGE = 'route_change';\n//# sourceMappingURL=semantic.js.map","import { BaseExtension } from '../extensions';\nexport class BaseTransport extends BaseExtension {\n isBatched() {\n return false;\n }\n getIgnoreUrls() {\n return [];\n }\n}\n//# sourceMappingURL=base.js.map","const DEFAULT_SEND_TIMEOUT_MS = 250;\nconst DEFAULT_BATCH_ITEM_LIMIT = 50;\nexport class BatchExecutor {\n constructor(sendFn, options) {\n var _a, _b;\n this.signalBuffer = [];\n this.itemLimit = (_a = options === null || options === void 0 ? void 0 : options.itemLimit) !== null && _a !== void 0 ? _a : DEFAULT_BATCH_ITEM_LIMIT;\n this.sendTimeout = (_b = options === null || options === void 0 ? void 0 : options.sendTimeout) !== null && _b !== void 0 ? _b : DEFAULT_SEND_TIMEOUT_MS;\n this.paused = (options === null || options === void 0 ? void 0 : options.paused) || false;\n this.sendFn = sendFn;\n this.flushInterval = -1;\n if (!this.paused) {\n this.start();\n }\n // Send batched/buffered data when user navigates to new page, switches or closes the tab, minimizes or closes the browser.\n // If on mobile, it also sends data if user switches from the browser to a different app.\n document.addEventListener('visibilitychange', () => {\n if (document.visibilityState === 'hidden') {\n this.flush();\n }\n });\n }\n addItem(item) {\n if (this.paused) {\n return;\n }\n this.signalBuffer.push(item);\n if (this.signalBuffer.length >= this.itemLimit) {\n this.flush();\n }\n }\n start() {\n this.paused = false;\n if (this.sendTimeout > 0) {\n this.flushInterval = window.setInterval(() => this.flush(), this.sendTimeout);\n }\n }\n pause() {\n this.paused = true;\n clearInterval(this.flushInterval);\n }\n groupItems(items) {\n const itemMap = new Map();\n items.forEach((item) => {\n const metaKey = JSON.stringify(item.meta);\n let currentItems = itemMap.get(metaKey);\n if (currentItems === undefined) {\n currentItems = [item];\n }\n else {\n currentItems = [...currentItems, item];\n }\n itemMap.set(metaKey, currentItems);\n });\n return Array.from(itemMap.values());\n }\n flush() {\n if (this.paused || this.signalBuffer.length === 0) {\n return;\n }\n const itemGroups = this.groupItems(this.signalBuffer);\n itemGroups.forEach(this.sendFn);\n this.signalBuffer = [];\n }\n}\n//# sourceMappingURL=batchExecutor.js.map","export var TransportItemType;\n(function (TransportItemType) {\n TransportItemType[\"EXCEPTION\"] = \"exception\";\n TransportItemType[\"LOG\"] = \"log\";\n TransportItemType[\"MEASUREMENT\"] = \"measurement\";\n TransportItemType[\"TRACE\"] = \"trace\";\n TransportItemType[\"EVENT\"] = \"event\";\n})(TransportItemType || (TransportItemType = {}));\nexport const transportItemTypeToBodyKey = {\n [TransportItemType.EXCEPTION]: 'exceptions',\n [TransportItemType.LOG]: 'logs',\n [TransportItemType.MEASUREMENT]: 'measurements',\n [TransportItemType.TRACE]: 'traces',\n [TransportItemType.EVENT]: 'events',\n};\n//# sourceMappingURL=const.js.map","import { BatchExecutor } from './batchExecutor';\nimport { TransportItemType } from './const';\nexport function initializeTransports(unpatchedConsole, internalLogger, config, metas) {\n var _a;\n internalLogger.debug('Initializing transports');\n const transports = [];\n let paused = config.paused;\n let beforeSendHooks = [];\n const add = (...newTransports) => {\n internalLogger.debug('Adding transports');\n newTransports.forEach((newTransport) => {\n internalLogger.debug(`Adding \"${newTransport.name}\" transport`);\n const exists = transports.some((existingTransport) => existingTransport === newTransport);\n if (exists) {\n internalLogger.warn(`Transport ${newTransport.name} is already added`);\n return;\n }\n newTransport.unpatchedConsole = unpatchedConsole;\n newTransport.internalLogger = internalLogger;\n newTransport.config = config;\n newTransport.metas = metas;\n transports.push(newTransport);\n });\n };\n const addBeforeSendHooks = (...newBeforeSendHooks) => {\n internalLogger.debug('Adding beforeSendHooks\\n', beforeSendHooks);\n newBeforeSendHooks.forEach((beforeSendHook) => {\n if (beforeSendHook) {\n beforeSendHooks.push(beforeSendHook);\n }\n });\n };\n const applyBeforeSendHooks = (items) => {\n let filteredItems = items;\n for (const hook of beforeSendHooks) {\n const modified = filteredItems.map(hook).filter(Boolean);\n if (modified.length === 0) {\n return [];\n }\n filteredItems = sanitizeItems(modified, config);\n }\n return filteredItems;\n };\n const batchedSend = (items) => {\n const filteredItems = applyBeforeSendHooks(items);\n if (filteredItems.length === 0) {\n return;\n }\n for (const transport of transports) {\n internalLogger.debug(`Transporting item using ${transport.name}\\n`, filteredItems);\n if (transport.isBatched()) {\n transport.send(filteredItems);\n }\n }\n };\n const instantSend = (item) => {\n var _a, _b;\n // prevent all beforeSend hooks being executed twice if batching is enabled.\n if (((_a = config.batching) === null || _a === void 0 ? void 0 : _a.enabled) && transports.every((transport) => transport.isBatched())) {\n return;\n }\n const [filteredItem] = applyBeforeSendHooks([item]);\n if (filteredItem === undefined) {\n return;\n }\n for (const transport of transports) {\n internalLogger.debug(`Transporting item using ${transport.name}\\n`, filteredItem);\n if (!transport.isBatched()) {\n transport.send(filteredItem);\n }\n else if (!((_b = config.batching) === null || _b === void 0 ? void 0 : _b.enabled)) {\n transport.send([filteredItem]);\n }\n }\n };\n let batchExecutor;\n if ((_a = config.batching) === null || _a === void 0 ? void 0 : _a.enabled) {\n batchExecutor = new BatchExecutor(batchedSend, {\n sendTimeout: config.batching.sendTimeout,\n itemLimit: config.batching.itemLimit,\n paused,\n });\n }\n // Send a signal to the appropriate transports\n //\n // 1. If SDK is paused, early return\n // 2. If batching is not enabled send the signal to all transports\n // instantly.\n // 3i. If batching is enabled, enqueue the signal\n // 3ii. Send the signal instantly to all un-batched transports\n const execute = (item) => {\n var _a;\n if (paused) {\n return;\n }\n if ((_a = config.batching) === null || _a === void 0 ? void 0 : _a.enabled) {\n batchExecutor === null || batchExecutor === void 0 ? void 0 : batchExecutor.addItem(item);\n }\n instantSend(item);\n };\n const getBeforeSendHooks = () => [...beforeSendHooks];\n const isPaused = () => paused;\n const pause = () => {\n internalLogger.debug('Pausing transports');\n batchExecutor === null || batchExecutor === void 0 ? void 0 : batchExecutor.pause();\n paused = true;\n };\n const remove = (...transportsToRemove) => {\n internalLogger.debug('Removing transports');\n transportsToRemove.forEach((transportToRemove) => {\n internalLogger.debug(`Removing \"${transportToRemove.name}\" transport`);\n const existingTransportIndex = transports.indexOf(transportToRemove);\n if (existingTransportIndex === -1) {\n internalLogger.warn(`Transport \"${transportToRemove.name}\" is not added`);\n return;\n }\n transports.splice(existingTransportIndex, 1);\n });\n };\n const removeBeforeSendHooks = (...beforeSendHooksToRemove) => {\n beforeSendHooks.filter((beforeSendHook) => !beforeSendHooksToRemove.includes(beforeSendHook));\n };\n const unpause = () => {\n internalLogger.debug('Unpausing transports');\n batchExecutor === null || batchExecutor === void 0 ? void 0 : batchExecutor.start();\n paused = false;\n };\n return {\n add,\n addBeforeSendHooks,\n getBeforeSendHooks,\n execute,\n isPaused,\n pause,\n remove,\n removeBeforeSendHooks,\n get transports() {\n return [...transports];\n },\n unpause,\n };\n}\n/**\n * Removes the `payload.originalError` property from the provided `TransportItem[]` parameter.\n */\nfunction sanitizeItems(filteredItems, config) {\n if (config.preserveOriginalError) {\n for (const item of filteredItems) {\n if (item.type === TransportItemType.EXCEPTION) {\n delete item.payload.originalError;\n }\n }\n }\n return filteredItems;\n}\n//# sourceMappingURL=initialize.js.map","export function registerInitialTransports(faro) {\n faro.transports.add(...faro.config.transports);\n faro.transports.addBeforeSendHooks(faro.config.beforeSend);\n}\n//# sourceMappingURL=registerInitial.js.map","import { TransportItemType, transportItemTypeToBodyKey } from './const';\nexport function mergeResourceSpans(traces, resourceSpans) {\n var _a, _b;\n if (resourceSpans === undefined) {\n return traces;\n }\n if (traces === undefined) {\n return {\n resourceSpans,\n };\n }\n const currentResource = (_a = traces.resourceSpans) === null || _a === void 0 ? void 0 : _a[0];\n if (currentResource === undefined) {\n return traces;\n }\n const currentSpans = (currentResource === null || currentResource === void 0 ? void 0 : currentResource.scopeSpans) || [];\n const newSpans = ((_b = resourceSpans === null || resourceSpans === void 0 ? void 0 : resourceSpans[0]) === null || _b === void 0 ? void 0 : _b.scopeSpans) || [];\n return Object.assign(Object.assign({}, traces), { resourceSpans: [\n Object.assign(Object.assign({}, currentResource), { scopeSpans: [...currentSpans, ...newSpans] }),\n ] });\n}\nexport function getTransportBody(item) {\n let body = {\n meta: {},\n };\n if (item[0] !== undefined) {\n body.meta = item[0].meta;\n }\n item.forEach((currentItem) => {\n switch (currentItem.type) {\n case TransportItemType.LOG:\n case TransportItemType.EVENT:\n case TransportItemType.EXCEPTION:\n case TransportItemType.MEASUREMENT:\n const bk = transportItemTypeToBodyKey[currentItem.type];\n const signals = body[bk];\n body = Object.assign(Object.assign({}, body), { [bk]: signals === undefined ? [currentItem.payload] : [...signals, currentItem.payload] });\n break;\n case TransportItemType.TRACE:\n body = Object.assign(Object.assign({}, body), { traces: mergeResourceSpans(body.traces, currentItem.payload.resourceSpans) });\n break;\n }\n });\n return body;\n}\n//# sourceMappingURL=utils.js.map","export const defaultUnpatchedConsole = Object.assign({}, console);\n//# sourceMappingURL=const.js.map","import { defaultUnpatchedConsole } from './const';\nexport let unpatchedConsole = defaultUnpatchedConsole;\nexport function initializeUnpatchedConsole(config) {\n var _a;\n unpatchedConsole = (_a = config.unpatchedConsole) !== null && _a !== void 0 ? _a : unpatchedConsole;\n return unpatchedConsole;\n}\n//# sourceMappingURL=initialize.js.map","export function dateNow() {\n return Date.now();\n}\nexport function getCurrentTimestamp() {\n return new Date().toISOString();\n}\nexport function timestampToIsoString(value) {\n return new Date(value).toISOString();\n}\n//# sourceMappingURL=date.js.map","import { isArray, isObject, isTypeof } from './is';\n// This function was inspired by fast-deep-equal\n// fast-deep-equal has issues with Rollup and also it checks for some edge cases that we don't need\nexport function deepEqual(a, b) {\n if (a === b) {\n return true;\n }\n // Using isTypeOf instead of isNumber as isNumber also checks against NaN\n if (isTypeof(a, 'number') && isNaN(a)) {\n return isTypeof(b, 'number') && isNaN(b);\n }\n const aIsArray = isArray(a);\n const bIsArray = isArray(b);\n if (aIsArray !== bIsArray) {\n return false;\n }\n if (aIsArray && bIsArray) {\n const length = a.length;\n if (length !== b.length) {\n return false;\n }\n for (let idx = length; idx-- !== 0;) {\n if (!deepEqual(a[idx], b[idx])) {\n return false;\n }\n }\n return true;\n }\n const aIsObject = isObject(a);\n const bIsObject = isObject(b);\n if (aIsObject !== bIsObject) {\n return false;\n }\n if (a && b && aIsObject && bIsObject) {\n const aKeys = Object.keys(a);\n const bKeys = Object.keys(b);\n const aLength = aKeys.length;\n const bLength = bKeys.length;\n if (aLength !== bLength) {\n return false;\n }\n for (let aKey of aKeys) {\n if (!bKeys.includes(aKey)) {\n return false;\n }\n }\n for (let aKey of aKeys) {\n if (!deepEqual(a[aKey], b[aKey])) {\n return false;\n }\n }\n return true;\n }\n return false;\n}\n//# sourceMappingURL=deepEqual.js.map","export function isTypeof(value, type) {\n return typeof value === type;\n}\nexport function isToString(value, type) {\n return Object.prototype.toString.call(value) === `[object ${type}]`;\n}\nexport function isInstanceOf(value, reference) {\n try {\n return value instanceof reference;\n }\n catch (err) {\n return false;\n }\n}\nexport const isUndefined = ((value) => isTypeof(value, 'undefined'));\nexport const isNull = ((value) => isTypeof(value, 'null'));\nexport const isString = ((value) => isTypeof(value, 'string'));\nexport const isNumber = ((value) => (isTypeof(value, 'number') && !isNaN(value)) || isTypeof(value, 'bigint'));\nexport const isInt = ((value) => isNumber(value) && Number.isInteger(value));\nexport const isBoolean = ((value) => isTypeof(value, 'boolean'));\nexport const isSymbol = ((value) => isTypeof(value, 'symbol'));\nexport const isObject = ((value) => !isNull(value) && isTypeof(value, 'object'));\nexport const isFunction = ((value) => isTypeof(value, 'function'));\nexport const isArray = ((value) => isToString(value, 'Array'));\nexport const isRegExp = ((value) => isToString(value, 'RegExp'));\nexport const isThenable = ((value) => isFunction(value === null || value === void 0 ? void 0 : value.then));\nexport const isPrimitive = ((value) => !isObject(value) && !isFunction(value));\nexport const isEventDefined = typeof Event !== 'undefined';\nexport const isEvent = ((value) => isEventDefined && isInstanceOf(value, Event));\nexport const isErrorDefined = typeof Error !== 'undefined';\nexport const isError = ((value) => isErrorDefined && isInstanceOf(value, Error));\nexport const isErrorEvent = ((value) => isToString(value, 'ErrorEvent'));\nexport const isDomError = ((value) => isToString(value, 'DOMError'));\nexport const isDomException = ((value) => isToString(value, 'DOMException'));\nexport const isElementDefined = typeof Element !== 'undefined';\nexport const isElement = ((value) => isElementDefined && isInstanceOf(value, Element));\nexport const isMapDefined = typeof Map !== 'undefined';\nexport const isMap = ((value) => isMapDefined && isInstanceOf(value, Map));\nexport const isSyntheticEvent = ((value) => isObject(value) &&\n 'nativeEvent' in value &&\n 'preventDefault' in value &&\n 'stopPropagation' in value);\nexport function isEmpty(value) {\n if (value == null) {\n return true;\n }\n if (isArray(value) || isString(value)) {\n return value.length === 0;\n }\n if (isObject(value)) {\n return Object.keys(value).length === 0;\n }\n return false;\n}\n//# sourceMappingURL=is.js.map","import { isObject } from './is';\nexport function getCircularDependencyReplacer() {\n const valueSeen = new WeakSet();\n return function (_key, value) {\n if (isObject(value) && value !== null) {\n if (valueSeen.has(value)) {\n return null;\n }\n valueSeen.add(value);\n }\n return value;\n };\n}\nexport function stringifyExternalJson(json = {}) {\n return JSON.stringify(json !== null && json !== void 0 ? json : {}, getCircularDependencyReplacer());\n}\nexport function stringifyObjectValues(obj = {}) {\n const o = {};\n for (const [key, value] of Object.entries(obj)) {\n o[key] = isObject(value) && value !== null ? stringifyExternalJson(value) : String(value);\n }\n return o;\n}\n//# sourceMappingURL=json.js.map","export var LogLevel;\n(function (LogLevel) {\n LogLevel[\"TRACE\"] = \"trace\";\n LogLevel[\"DEBUG\"] = \"debug\";\n LogLevel[\"INFO\"] = \"info\";\n LogLevel[\"LOG\"] = \"log\";\n LogLevel[\"WARN\"] = \"warn\";\n LogLevel[\"ERROR\"] = \"error\";\n})(LogLevel || (LogLevel = {}));\nexport const defaultLogLevel = LogLevel.LOG;\nexport const allLogLevels = [\n LogLevel.TRACE,\n LogLevel.DEBUG,\n LogLevel.INFO,\n LogLevel.LOG,\n LogLevel.WARN,\n LogLevel.ERROR,\n];\n//# sourceMappingURL=logLevels.js.map","export function noop() { }\n//# sourceMappingURL=noop.js.map","export function createPromiseBuffer(options) {\n const { size, concurrency } = options;\n const buffer = []; // pending, not-yet-started tasks\n let inProgress = 0; // counter for tasks currently in progress\n const work = () => {\n // if there's space for a task and buffer is not empty,\n // take one task from buffer and run it\n if (inProgress < concurrency && buffer.length) {\n const { producer, resolve, reject } = buffer.shift();\n inProgress++;\n producer().then((result) => {\n inProgress--;\n work();\n resolve(result);\n }, (reason) => {\n inProgress--;\n work();\n reject(reason);\n });\n }\n };\n const add = (promiseProducer) => {\n if (buffer.length + inProgress >= size) {\n throw new Error('Task buffer full');\n }\n return new Promise((resolve, reject) => {\n buffer.push({\n producer: promiseProducer,\n resolve,\n reject,\n });\n work();\n });\n };\n return {\n add,\n };\n}\n//# sourceMappingURL=promiseBuffer.js.map","export class Observable {\n constructor() {\n this.subscribers = [];\n }\n subscribe(subscriber) {\n this.subscribers.push(subscriber);\n return {\n unsubscribe: () => this.unsubscribe(subscriber),\n };\n }\n unsubscribe(subscriber) {\n this.subscribers = this.subscribers.filter((sub) => sub !== subscriber);\n }\n notify(value) {\n this.subscribers.forEach((subscriber) => subscriber(value));\n }\n first() {\n const result = new Observable();\n const internalSubscriber = (data) => {\n result.notify(data);\n subscription.unsubscribe();\n };\n const subscription = this.subscribe(internalSubscriber);\n const resultUnsubscribeFn = result.unsubscribe.bind(result);\n return this.withUnsubscribeOverride(result, resultUnsubscribeFn, internalSubscriber);\n }\n takeWhile(predicate) {\n const result = new Observable();\n const internalSubscriber = (value) => {\n if (predicate(value)) {\n result.notify(value);\n }\n else {\n result.unsubscribe(internalSubscriber);\n }\n };\n this.subscribe(internalSubscriber);\n const resultUnsubscribeFn = result.unsubscribe.bind(result);\n return this.withUnsubscribeOverride(result, resultUnsubscribeFn, internalSubscriber);\n }\n filter(predicate) {\n const result = new Observable();\n const internalSubscriber = (value) => {\n if (predicate(value)) {\n result.notify(value);\n }\n };\n this.subscribe(internalSubscriber);\n const resultUnsubscribeFn = result.unsubscribe.bind(result);\n return this.withUnsubscribeOverride(result, resultUnsubscribeFn, internalSubscriber);\n }\n merge(...observables) {\n const mergerObservable = new Observable();\n const subscriptions = [];\n observables.forEach((observable) => {\n const subscription = observable.subscribe((value) => {\n mergerObservable.notify(value);\n });\n subscriptions.push(subscription);\n });\n const originalUnsubscribeAll = mergerObservable.unsubscribeAll.bind(mergerObservable);\n mergerObservable.unsubscribe = () => {\n subscriptions.forEach((subscription) => subscription.unsubscribe());\n originalUnsubscribeAll();\n };\n return mergerObservable;\n }\n withUnsubscribeOverride(observable, resultUnsubscribeFn, internalSubscriber) {\n observable.unsubscribe = (subscriber) => {\n resultUnsubscribeFn(subscriber);\n this.unsubscribe(internalSubscriber);\n };\n return observable;\n }\n unsubscribeAll() {\n this.subscribers = [];\n }\n}\n//# sourceMappingURL=reactive.js.map","const alphabet = 'abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ0123456789';\nexport function genShortID(length = 10) {\n return Array.from(Array(length))\n .map(() => alphabet[Math.floor(Math.random() * alphabet.length)])\n .join('');\n}\n//# sourceMappingURL=shortId.js.map","import { globalObject } from '../globalObject';\nexport function getBundleId(appName) {\n return globalObject === null || globalObject === void 0 ? void 0 : globalObject[`__faroBundleId_${appName}`];\n}\n//# sourceMappingURL=sourceMaps.js.map","// auto-generated by bin/genVersion.ts\nexport const VERSION = '1.18.2';\n//# sourceMappingURL=version.js.map","import { ConsoleInstrumentation, ErrorsInstrumentation, PerformanceInstrumentation, SessionInstrumentation, UserActionInstrumentation, ViewInstrumentation, WebVitalsInstrumentation, } from '../instrumentations';\nexport function getWebInstrumentations(options = {}) {\n const instrumentations = [\n new UserActionInstrumentation(),\n new ErrorsInstrumentation(),\n new WebVitalsInstrumentation(),\n new SessionInstrumentation(),\n new ViewInstrumentation(),\n ];\n if (options.enablePerformanceInstrumentation !== false) {\n // unshift to ensure that initialization starts before the other instrumentations\n instrumentations.unshift(new PerformanceInstrumentation());\n }\n if (options.captureConsole !== false) {\n instrumentations.push(new ConsoleInstrumentation({\n disabledLevels: options.captureConsoleDisabledLevels,\n }));\n }\n return instrumentations;\n}\n//# sourceMappingURL=getWebInstrumentations.js.map","var __rest = (this && this.__rest) || function (s, e) {\n var t = {};\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n t[p] = s[p];\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n t[p[i]] = s[p[i]];\n }\n return t;\n};\nimport { createInternalLogger, defaultBatchingConfig, defaultGlobalObjectKey, defaultInternalLoggerLevel, defaultLogArgsSerializer, defaultUnpatchedConsole, isBoolean, isEmpty, isObject, } from '@grafana/faro-core';\nimport { defaultEventDomain } from '../consts';\nimport { parseStacktrace } from '../instrumentations';\nimport { defaultSessionTrackingConfig } from '../instrumentations/session';\nimport { userActionDataAttribute } from '../instrumentations/userActions/const';\nimport { browserMeta } from '../metas';\nimport { k6Meta } from '../metas/k6';\nimport { createPageMeta } from '../metas/page';\nimport { FetchTransport } from '../transports';\nimport { getWebInstrumentations } from './getWebInstrumentations';\nexport function makeCoreConfig(browserConfig) {\n var _a;\n const transports = [];\n const internalLogger = createInternalLogger(browserConfig.unpatchedConsole, browserConfig.internalLoggerLevel);\n if (browserConfig.transports) {\n if (browserConfig.url || browserConfig.apiKey) {\n internalLogger.error('if \"transports\" is defined, \"url\" and \"apiKey\" should not be defined');\n }\n transports.push(...browserConfig.transports);\n }\n else if (browserConfig.url) {\n transports.push(new FetchTransport({\n url: browserConfig.url,\n apiKey: browserConfig.apiKey,\n }));\n }\n else {\n internalLogger.error('either \"url\" or \"transports\" must be defined');\n }\n const { \n // properties with default values\n dedupe = true, eventDomain = defaultEventDomain, globalObjectKey = defaultGlobalObjectKey, instrumentations = getWebInstrumentations(), internalLoggerLevel = defaultInternalLoggerLevel, isolate = false, logArgsSerializer = defaultLogArgsSerializer, metas = createDefaultMetas(browserConfig), paused = false, preventGlobalExposure = false, unpatchedConsole = defaultUnpatchedConsole, trackUserActionsPreview = false, trackUserActionsDataAttributeName = userActionDataAttribute } = browserConfig, \n // Properties without default values or which aren't used to create derived config\n restProperties = __rest(browserConfig, [\"dedupe\", \"eventDomain\", \"globalObjectKey\", \"instrumentations\", \"internalLoggerLevel\", \"isolate\", \"logArgsSerializer\", \"metas\", \"paused\", \"preventGlobalExposure\", \"unpatchedConsole\", \"trackUserActionsPreview\", \"trackUserActionsDataAttributeName\"]);\n return Object.assign(Object.assign({}, restProperties), { batching: Object.assign(Object.assign({}, defaultBatchingConfig), browserConfig.batching), dedupe: dedupe, globalObjectKey, instrumentations: getFilteredInstrumentations(instrumentations, browserConfig), internalLoggerLevel,\n isolate,\n logArgsSerializer,\n metas,\n parseStacktrace,\n paused,\n preventGlobalExposure,\n transports,\n unpatchedConsole,\n eventDomain, \n // ignore cloud collector urls by default. These are URLs ending with /collect or /collect/ followed by alphanumeric characters.\n ignoreUrls: ((_a = browserConfig.ignoreUrls) !== null && _a !== void 0 ? _a : []).concat([/\\/collect(?:\\/[\\w]*)?$/]), sessionTracking: Object.assign(Object.assign(Object.assign({}, defaultSessionTrackingConfig), browserConfig.sessionTracking), crateSessionMeta({\n trackGeolocation: browserConfig.trackGeolocation,\n sessionTracking: browserConfig.sessionTracking,\n })), trackUserActionsPreview,\n trackUserActionsDataAttributeName });\n}\nfunction getFilteredInstrumentations(instrumentations, { trackUserActionsPreview }) {\n return instrumentations.filter((instr) => {\n if (instr.name === '@grafana/faro-web-sdk:instrumentation-user-action' && !trackUserActionsPreview) {\n return false;\n }\n return true;\n });\n}\nfunction createDefaultMetas(browserConfig) {\n var _a, _b;\n const { page, generatePageId } = (_a = browserConfig === null || browserConfig === void 0 ? void 0 : browserConfig.pageTracking) !== null && _a !== void 0 ? _a : {};\n const initialMetas = [\n browserMeta,\n createPageMeta({ generatePageId, initialPageMeta: page }),\n ...((_b = browserConfig.metas) !== null && _b !== void 0 ? _b : []),\n ];\n const isK6BrowserSession = isObject(window.k6);\n if (isK6BrowserSession) {\n return [...initialMetas, k6Meta];\n }\n return initialMetas;\n}\nfunction crateSessionMeta({ trackGeolocation, sessionTracking, }) {\n var _a;\n const overrides = {};\n if (isBoolean(trackGeolocation)) {\n overrides.geoLocationTrackingEnabled = trackGeolocation;\n }\n if (isEmpty(overrides)) {\n return {};\n }\n return {\n session: Object.assign(Object.assign({}, ((_a = sessionTracking === null || sessionTracking === void 0 ? void 0 : sessionTracking.session) !== null && _a !== void 0 ? _a : {})), { overrides }),\n };\n}\n//# sourceMappingURL=makeCoreConfig.js.map","export const defaultEventDomain = 'browser';\n//# sourceMappingURL=consts.js.map","import { initializeFaro as coreInit } from '@grafana/faro-core';\nimport { makeCoreConfig } from './config';\nexport function initializeFaro(config) {\n const coreConfig = makeCoreConfig(config);\n if (!coreConfig) {\n return undefined;\n }\n return coreInit(coreConfig);\n}\n//# sourceMappingURL=initialize.js.map","import { allLogLevels, BaseInstrumentation, defaultErrorArgsSerializer, defaultLogArgsSerializer, LogLevel, VERSION, } from '@grafana/faro-core';\nimport { getDetailsFromConsoleErrorArgs } from '../errors/getErrorDetails';\nexport class ConsoleInstrumentation extends BaseInstrumentation {\n constructor(options = {}) {\n super();\n this.options = options;\n this.name = '@grafana/faro-web-sdk:instrumentation-console';\n this.version = VERSION;\n this.errorSerializer = defaultLogArgsSerializer;\n }\n initialize() {\n var _a, _b, _c, _d;\n this.options = Object.assign(Object.assign({}, this.options), this.config.consoleInstrumentation);\n const serializeErrors = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.serializeErrors) || !!((_b = this.options) === null || _b === void 0 ? void 0 : _b.errorSerializer);\n this.errorSerializer = serializeErrors\n ? ((_d = (_c = this.options) === null || _c === void 0 ? void 0 : _c.errorSerializer) !== null && _d !== void 0 ? _d : defaultErrorArgsSerializer)\n : defaultLogArgsSerializer;\n allLogLevels\n .filter((level) => { var _a, _b; return !((_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.disabledLevels) !== null && _b !== void 0 ? _b : ConsoleInstrumentation.defaultDisabledLevels).includes(level); })\n .forEach((level) => {\n /* eslint-disable-next-line no-console */\n console[level] = (...args) => {\n var _a, _b;\n try {\n if (level === LogLevel.ERROR && !((_a = this.options) === null || _a === void 0 ? void 0 : _a.consoleErrorAsLog)) {\n const { value, type, stackFrames } = getDetailsFromConsoleErrorArgs(args, this.errorSerializer);\n if (value && !type && !stackFrames) {\n this.api.pushError(new Error(ConsoleInstrumentation.consoleErrorPrefix + value));\n return;\n }\n this.api.pushError(new Error(ConsoleInstrumentation.consoleErrorPrefix + value), { type, stackFrames });\n }\n else if (level === LogLevel.ERROR && ((_b = this.options) === null || _b === void 0 ? void 0 : _b.consoleErrorAsLog)) {\n const { value, type, stackFrames } = getDetailsFromConsoleErrorArgs(args, this.errorSerializer);\n this.api.pushLog(value ? [ConsoleInstrumentation.consoleErrorPrefix + value] : args, {\n level,\n context: {\n value: value !== null && value !== void 0 ? value : '',\n type: type !== null && type !== void 0 ? type : '',\n stackFrames: (stackFrames === null || stackFrames === void 0 ? void 0 : stackFrames.length) ? defaultErrorArgsSerializer(stackFrames) : '',\n },\n });\n }\n else {\n this.api.pushLog(args, { level });\n }\n }\n catch (err) {\n this.logError(err);\n }\n finally {\n this.unpatchedConsole[level](...args);\n }\n };\n });\n }\n}\nConsoleInstrumentation.defaultDisabledLevels = [LogLevel.DEBUG, LogLevel.TRACE, LogLevel.LOG];\nConsoleInstrumentation.consoleErrorPrefix = 'console.error: ';\n//# sourceMappingURL=instrumentation.js.map","export const primitiveUnhandledValue = 'Non-Error promise rejection captured with value:';\nexport const primitiveUnhandledType = 'UnhandledRejection';\nexport const domErrorType = 'DOMError';\nexport const domExceptionType = 'DOMException';\nexport const objectEventValue = 'Non-Error exception captured with keys:';\nexport const unknownSymbolString = '?';\nexport const valueTypeRegex = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n//# sourceMappingURL=const.js.map","import { isDomError, isDomException, isError, isErrorEvent, isEvent, isObject, isString } from '@grafana/faro-core';\nimport { domErrorType, domExceptionType, objectEventValue, unknownSymbolString } from './const';\nimport { getValueAndTypeFromMessage } from './getValueAndTypeFromMessage';\nimport { buildStackFrame, getStackFramesFromError } from './stackFrames';\nexport function getErrorDetails(evt) {\n let value;\n let type;\n let stackFrames = [];\n let isDomErrorRes;\n let isEventRes;\n if (isErrorEvent(evt) && evt.error) {\n value = evt.error.message;\n type = evt.error.name;\n stackFrames = getStackFramesFromError(evt.error);\n }\n else if ((isDomErrorRes = isDomError(evt)) || isDomException(evt)) {\n const { name, message } = evt;\n type = name !== null && name !== void 0 ? name : (isDomErrorRes ? domErrorType : domExceptionType);\n value = message ? `${type}: ${message}` : type;\n }\n else if (isError(evt)) {\n value = evt.message;\n stackFrames = getStackFramesFromError(evt);\n }\n else if (isObject(evt) || (isEventRes = isEvent(evt))) {\n type = isEventRes ? evt.constructor.name : undefined;\n value = `${objectEventValue} ${Object.keys(evt)}`;\n }\n return [value, type, stackFrames];\n}\nexport function getDetailsFromErrorArgs(args) {\n const [evt, source, lineno, colno, error] = args;\n let value;\n let type;\n let stackFrames = [];\n const eventIsString = isString(evt);\n const initialStackFrame = buildStackFrame(source, unknownSymbolString, lineno, colno);\n if (error || !eventIsString) {\n [value, type, stackFrames] = getErrorDetails((error !== null && error !== void 0 ? error : evt));\n if (stackFrames.length === 0) {\n stackFrames = [initialStackFrame];\n }\n }\n else if (eventIsString) {\n [value, type] = getValueAndTypeFromMessage(evt);\n stackFrames = [initialStackFrame];\n }\n return { value, type, stackFrames };\n}\nexport function getDetailsFromConsoleErrorArgs(args, serializer) {\n if (isError(args[0])) {\n return getDetailsFromErrorArgs(args);\n }\n else {\n return { value: serializer(args) };\n }\n}\n//# sourceMappingURL=getErrorDetails.js.map","import { defaultExceptionType } from '@grafana/faro-core';\nimport { valueTypeRegex } from './const';\nexport function getValueAndTypeFromMessage(message) {\n var _a, _b;\n const groups = message.match(valueTypeRegex);\n const type = (_a = groups === null || groups === void 0 ? void 0 : groups[1]) !== null && _a !== void 0 ? _a : defaultExceptionType;\n const value = (_b = groups === null || groups === void 0 ? void 0 : groups[2]) !== null && _b !== void 0 ? _b : message;\n return [value, type];\n}\n//# sourceMappingURL=getValueAndTypeFromMessage.js.map","import { BaseInstrumentation, VERSION } from '@grafana/faro-core';\nimport { registerOnerror } from './registerOnerror';\nimport { registerOnunhandledrejection } from './registerOnunhandledrejection';\nexport class ErrorsInstrumentation extends BaseInstrumentation {\n constructor() {\n super(...arguments);\n this.name = '@grafana/faro-web-sdk:instrumentation-errors';\n this.version = VERSION;\n }\n initialize() {\n this.logDebug('Initializing');\n registerOnerror(this.api);\n registerOnunhandledrejection(this.api);\n }\n}\n//# sourceMappingURL=instrumentation.js.map","import { getDetailsFromErrorArgs } from './getErrorDetails';\nexport function registerOnerror(api) {\n const oldOnerror = window.onerror;\n window.onerror = (...args) => {\n try {\n const { value, type, stackFrames } = getDetailsFromErrorArgs(args);\n const originalError = args[4];\n if (value) {\n const options = { type, stackFrames };\n if (originalError != null) {\n options.originalError = originalError;\n }\n api.pushError(new Error(value), options);\n }\n }\n finally {\n oldOnerror === null || oldOnerror === void 0 ? void 0 : oldOnerror.apply(window, args);\n }\n };\n}\n//# sourceMappingURL=registerOnerror.js.map","import { isPrimitive } from '@grafana/faro-core';\nimport { primitiveUnhandledType, primitiveUnhandledValue } from './const';\nimport { getErrorDetails } from './getErrorDetails';\nexport function registerOnunhandledrejection(api) {\n window.addEventListener('unhandledrejection', (evt) => {\n var _a, _b;\n let error = evt;\n if (error.reason) {\n error = evt.reason;\n }\n else if ((_a = evt.detail) === null || _a === void 0 ? void 0 : _a.reason) {\n error = (_b = evt.detail) === null || _b === void 0 ? void 0 : _b.reason;\n }\n let value;\n let type;\n let stackFrames = [];\n if (isPrimitive(error)) {\n value = `${primitiveUnhandledValue} ${String(error)}`;\n type = primitiveUnhandledType;\n }\n else {\n [value, type, stackFrames] = getErrorDetails(error);\n }\n if (value) {\n api.pushError(new Error(value), { type, stackFrames });\n }\n });\n}\n//# sourceMappingURL=registerOnunhandledrejection.js.map","import { unknownSymbolString } from './const';\nexport function buildStackFrame(filename, func, lineno, colno) {\n const stackFrame = {\n filename: filename || document.location.href,\n function: func || unknownSymbolString,\n };\n if (lineno !== undefined) {\n stackFrame.lineno = lineno;\n }\n if (colno !== undefined) {\n stackFrame.colno = colno;\n }\n return stackFrame;\n}\n//# sourceMappingURL=buildStackFrame.js.map","export const newLineString = '\\n';\nexport const evalString = 'eval';\nexport const unknownSymbolString = '?';\nexport const atString = '@';\nexport const webkitLineRegex = /^\\s*at (?:(.*\\).*?|.*?) ?\\((?:address at )?)?((?:file|https?|blob|chrome-extension|address|native|eval|webpack||[-a-z]+:|.*bundle|\\/)?.*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nexport const webkitEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\nexport const webkitEvalString = 'eval';\nexport const webkitAddressAtString = 'address at ';\nexport const webkitAddressAtStringLength = webkitAddressAtString.length;\nexport const firefoxLineRegex = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|safari-extension|safari-web-extension|capacitor)?:\\/.*?|\\[native code]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nexport const firefoxEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nexport const firefoxEvalString = ' > eval';\nexport const safariExtensionString = 'safari-extension';\nexport const safariWebExtensionString = 'safari-web-extension';\nexport const reactMinifiedRegex = /Minified React error #\\d+;/i;\n//# sourceMappingURL=const.js.map","import { atString, safariExtensionString, safariWebExtensionString } from './const';\nexport function getDataFromSafariExtensions(func, filename) {\n const isSafariExtension = func === null || func === void 0 ? void 0 : func.includes(safariExtensionString);\n const isSafariWebExtension = !isSafariExtension && (func === null || func === void 0 ? void 0 : func.includes(safariWebExtensionString));\n if (!isSafariExtension && !isSafariWebExtension) {\n return [func, filename];\n }\n return [\n (func === null || func === void 0 ? void 0 : func.includes(atString)) ? func.split(atString)[0] : func,\n isSafariExtension ? `${safariExtensionString}:${filename}` : `${safariWebExtensionString}:${filename}`,\n ];\n}\n//# sourceMappingURL=getDataFromSafariExtensions.js.map","import { isNumber } from '@grafana/faro-core';\nimport { buildStackFrame } from './buildStackFrame';\nimport { evalString, firefoxEvalRegex, firefoxEvalString, firefoxLineRegex, newLineString, reactMinifiedRegex, webkitAddressAtString, webkitAddressAtStringLength, webkitEvalRegex, webkitEvalString, webkitLineRegex, } from './const';\nimport { getDataFromSafariExtensions } from './getDataFromSafariExtensions';\nexport function getStackFramesFromError(error) {\n let lines = [];\n if (error.stacktrace) {\n lines = error.stacktrace.split(newLineString).filter((_line, idx) => idx % 2 === 0);\n }\n else if (error.stack) {\n lines = error.stack.split(newLineString);\n }\n const stackFrames = lines.reduce((acc, line, idx) => {\n let parts;\n let func;\n let filename;\n let lineno;\n let colno;\n if ((parts = webkitLineRegex.exec(line))) {\n func = parts[1];\n filename = parts[2];\n lineno = parts[3];\n colno = parts[4];\n if (filename === null || filename === void 0 ? void 0 : filename.startsWith(webkitEvalString)) {\n const submatch = webkitEvalRegex.exec(filename);\n if (submatch) {\n filename = submatch[1];\n lineno = submatch[2];\n colno = submatch[3];\n }\n }\n filename = (filename === null || filename === void 0 ? void 0 : filename.startsWith(webkitAddressAtString))\n ? filename.substring(webkitAddressAtStringLength)\n : filename;\n [func, filename] = getDataFromSafariExtensions(func, filename);\n }\n else if ((parts = firefoxLineRegex.exec(line))) {\n func = parts[1];\n filename = parts[3];\n lineno = parts[4];\n colno = parts[5];\n if (!!filename && filename.includes(firefoxEvalString)) {\n const submatch = firefoxEvalRegex.exec(filename);\n if (submatch) {\n func = func || evalString;\n filename = submatch[1];\n lineno = submatch[2];\n }\n }\n else if (idx === 0 && !colno && isNumber(error.columnNumber)) {\n colno = String(error.columnNumber + 1);\n }\n [func, filename] = getDataFromSafariExtensions(func, filename);\n }\n if (filename || func) {\n acc.push(buildStackFrame(filename, func, lineno ? Number(lineno) : undefined, colno ? Number(colno) : undefined));\n }\n return acc;\n }, []);\n if (reactMinifiedRegex.test(error.message)) {\n return stackFrames.slice(1);\n }\n return stackFrames;\n}\n//# sourceMappingURL=getStackFramesFromError.js.map","import { getStackFramesFromError } from './getStackFramesFromError';\nexport function parseStacktrace(error) {\n return {\n frames: getStackFramesFromError(error),\n };\n}\n//# sourceMappingURL=parseStacktrace.js.map","export const NAVIGATION_ID_STORAGE_KEY = 'com.grafana.faro.lastNavigationId';\n//# sourceMappingURL=instrumentationConstants.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { BaseInstrumentation, Observable, VERSION } from '@grafana/faro-core';\nimport { getNavigationTimings } from './navigation';\nimport { onDocumentReady, performanceObserverSupported } from './performanceUtils';\nimport { observeResourceTimings } from './resource';\nexport const performanceEntriesSubscription = new Observable();\nexport class PerformanceInstrumentation extends BaseInstrumentation {\n constructor() {\n super(...arguments);\n this.name = '@grafana/faro-web-sdk:instrumentation-performance';\n this.version = VERSION;\n }\n initialize() {\n if (!performanceObserverSupported()) {\n this.logDebug('performance observer not supported. Disable performance instrumentation.');\n return;\n }\n onDocumentReady(() => __awaiter(this, void 0, void 0, function* () {\n const pushEvent = this.api.pushEvent;\n const { faroNavigationId } = yield getNavigationTimings(pushEvent);\n if (faroNavigationId != null) {\n observeResourceTimings(faroNavigationId, pushEvent, performanceEntriesSubscription);\n }\n }));\n }\n}\n//# sourceMappingURL=instrumentation.js.map","import { genShortID, unknownString } from '@grafana/faro-core';\nimport { getItem, setItem, webStorageType } from '../../utils';\nimport { isUrlIgnored } from '../../utils/url';\nimport { NAVIGATION_ID_STORAGE_KEY } from '../instrumentationConstants';\nimport { NAVIGATION_ENTRY } from './performanceConstants';\nimport { createFaroNavigationTiming, getSpanContextFromServerTiming } from './performanceUtils';\nexport function getNavigationTimings(pushEvent) {\n let faroNavigationEntryResolve;\n const faroNavigationEntryPromise = new Promise((resolve) => {\n faroNavigationEntryResolve = resolve;\n });\n const observer = new PerformanceObserver((observedEntries) => {\n var _a;\n const [navigationEntryRaw] = observedEntries.getEntries();\n if (navigationEntryRaw == null || isUrlIgnored(navigationEntryRaw.name)) {\n return;\n }\n const navEntryJson = navigationEntryRaw.toJSON();\n let spanContext = getSpanContextFromServerTiming(navEntryJson === null || navEntryJson === void 0 ? void 0 : navEntryJson.serverTiming);\n const faroPreviousNavigationId = (_a = getItem(NAVIGATION_ID_STORAGE_KEY, webStorageType.session)) !== null && _a !== void 0 ? _a : unknownString;\n const faroNavigationEntry = Object.assign(Object.assign({}, createFaroNavigationTiming(navEntryJson)), { faroNavigationId: genShortID(), faroPreviousNavigationId });\n setItem(NAVIGATION_ID_STORAGE_KEY, faroNavigationEntry.faroNavigationId, webStorageType.session);\n pushEvent('faro.performance.navigation', faroNavigationEntry, undefined, {\n spanContext,\n timestampOverwriteMs: performance.timeOrigin + navEntryJson.startTime,\n });\n faroNavigationEntryResolve(faroNavigationEntry);\n });\n observer.observe({\n type: NAVIGATION_ENTRY,\n buffered: true,\n });\n return faroNavigationEntryPromise;\n}\n//# sourceMappingURL=navigation.js.map","export const NAVIGATION_ENTRY = 'navigation';\nexport const RESOURCE_ENTRY = 'resource';\n//# sourceMappingURL=performanceConstants.js.map","import { isArray, unknownString } from '@grafana/faro-core';\nconst w3cTraceparentFormat = /^00-[a-f0-9]{32}-[a-f0-9]{16}-[0-9]{1,2}$/;\n// Extract traceparent from serverTiming, if present\nexport function getSpanContextFromServerTiming(serverTimings = []) {\n for (const serverEntry of serverTimings) {\n if (serverEntry.name === 'traceparent') {\n if (!w3cTraceparentFormat.test(serverEntry.description)) {\n continue;\n }\n const [, traceId, spanId] = serverEntry.description.split('-');\n if (traceId != null && spanId != null) {\n return { traceId, spanId };\n }\n break;\n }\n }\n return undefined;\n}\nexport function performanceObserverSupported() {\n return 'PerformanceObserver' in window;\n}\nexport function onDocumentReady(handleReady) {\n if (document.readyState === 'complete') {\n handleReady();\n }\n else {\n const readyStateCompleteHandler = () => {\n if (document.readyState === 'complete') {\n handleReady();\n document.removeEventListener('readystatechange', readyStateCompleteHandler);\n }\n };\n document.addEventListener('readystatechange', readyStateCompleteHandler);\n }\n}\nexport function includePerformanceEntry(performanceEntryJSON, allowProps = {}) {\n for (const [allowPropKey, allowPropValue] of Object.entries(allowProps)) {\n const perfEntryPropVal = performanceEntryJSON[allowPropKey];\n if (perfEntryPropVal == null) {\n return false;\n }\n if (isArray(allowPropValue)) {\n return allowPropValue.includes(perfEntryPropVal);\n }\n return perfEntryPropVal === allowPropValue;\n }\n // empty object allows all\n return true;\n}\nexport function createFaroResourceTiming(resourceEntryRaw) {\n const { connectEnd, connectStart, decodedBodySize, domainLookupEnd, domainLookupStart, duration, encodedBodySize, fetchStart, initiatorType, name, nextHopProtocol, redirectEnd, redirectStart, \n // @ts-expect-error the renderBlockingStatus property is not available in all browsers\n renderBlockingStatus: rbs, requestStart, responseEnd, responseStart, responseStatus, secureConnectionStart, transferSize, workerStart, } = resourceEntryRaw;\n return {\n name: name,\n duration: toFaroPerformanceTimingString(duration),\n tcpHandshakeTime: toFaroPerformanceTimingString(connectEnd - connectStart),\n dnsLookupTime: toFaroPerformanceTimingString(domainLookupEnd - domainLookupStart),\n tlsNegotiationTime: toFaroPerformanceTimingString(connectEnd - secureConnectionStart),\n responseStatus: toFaroPerformanceTimingString(responseStatus),\n redirectTime: toFaroPerformanceTimingString(redirectEnd - redirectStart),\n requestTime: toFaroPerformanceTimingString(responseStart - requestStart),\n responseTime: toFaroPerformanceTimingString(responseEnd - responseStart),\n fetchTime: toFaroPerformanceTimingString(responseEnd - fetchStart),\n serviceWorkerTime: toFaroPerformanceTimingString(fetchStart - workerStart),\n decodedBodySize: toFaroPerformanceTimingString(decodedBodySize),\n encodedBodySize: toFaroPerformanceTimingString(encodedBodySize),\n cacheHitStatus: getCacheType(),\n renderBlockingStatus: toFaroPerformanceTimingString(rbs),\n protocol: nextHopProtocol,\n initiatorType: initiatorType,\n visibilityState: document.visibilityState,\n ttfb: toFaroPerformanceTimingString(responseStart - requestStart),\n transferSize: toFaroPerformanceTimingString(transferSize),\n // TODO: add in future iteration, ideally after nested objects are supported by the collector.\n // serverTiming: resourceEntryRaw.serverTiming,\n };\n function getCacheType() {\n let cacheType = 'fullLoad';\n if (transferSize === 0) {\n if (decodedBodySize > 0) {\n cacheType = 'cache';\n }\n }\n else {\n if (responseStatus != null) {\n if (responseStatus === 304) {\n cacheType = 'conditionalFetch';\n }\n }\n else if (encodedBodySize > 0 && transferSize < encodedBodySize) {\n cacheType = 'conditionalFetch';\n }\n }\n return cacheType;\n }\n}\nexport function createFaroNavigationTiming(navigationEntryRaw) {\n const { activationStart, domComplete, domContentLoadedEventEnd, domContentLoadedEventStart, domInteractive, fetchStart, loadEventEnd, loadEventStart, responseStart, type, } = navigationEntryRaw;\n const parserStart = getDocumentParsingTime();\n return Object.assign(Object.assign({}, createFaroResourceTiming(navigationEntryRaw)), { pageLoadTime: toFaroPerformanceTimingString(domComplete - fetchStart), documentParsingTime: toFaroPerformanceTimingString(parserStart ? domInteractive - parserStart : null), domProcessingTime: toFaroPerformanceTimingString(domComplete - domInteractive), domContentLoadHandlerTime: toFaroPerformanceTimingString(domContentLoadedEventEnd - domContentLoadedEventStart), onLoadTime: toFaroPerformanceTimingString(loadEventEnd - loadEventStart), \n // For navigation entries we can calculate the TTFB based on activationStart. We overwrite the TTFB value coming with the resource entry.\n // For more accuracy on prerendered pages page we calculate relative top the activationStart instead of the start of the navigation.\n // clamp to 0 if activationStart occurs after first byte is received.\n ttfb: toFaroPerformanceTimingString(Math.max(responseStart - (activationStart !== null && activationStart !== void 0 ? activationStart : 0), 0)), type: type });\n}\nfunction getDocumentParsingTime() {\n var _a;\n if (((_a = performance.timing) === null || _a === void 0 ? void 0 : _a.domLoading) != null) {\n // the browser is about to start parsing the first received bytes of the HTML document.\n // This property is deprecated but there isn't a really good alternative atm.\n // For now we stick with domLoading and keep researching a better alternative.\n return performance.timing.domLoading - performance.timeOrigin;\n }\n return null;\n}\nfunction toFaroPerformanceTimingString(v) {\n if (v == null) {\n return unknownString;\n }\n if (typeof v === 'number') {\n return Math.round(v > 0 ? v : 0).toString();\n }\n return v.toString();\n}\n//# sourceMappingURL=performanceUtils.js.map","import { faro, genShortID } from '@grafana/faro-core';\nimport { isUrlIgnored } from '../../utils/url';\nimport { RESOURCE_ENTRY } from './performanceConstants';\nimport { createFaroResourceTiming, getSpanContextFromServerTiming, includePerformanceEntry } from './performanceUtils';\nconst DEFAULT_TRACK_RESOURCES = { initiatorType: ['xmlhttprequest', 'fetch'] };\nexport function observeResourceTimings(faroNavigationId, pushEvent, observable) {\n const trackResources = faro.config.trackResources;\n const observer = new PerformanceObserver((observedEntries) => {\n const entries = observedEntries.getEntries();\n for (const resourceEntryRaw of entries) {\n if (isUrlIgnored(resourceEntryRaw.name)) {\n return;\n }\n const resourceEntryJson = resourceEntryRaw.toJSON();\n let spanContext = getSpanContextFromServerTiming(resourceEntryJson === null || resourceEntryJson === void 0 ? void 0 : resourceEntryJson.serverTiming);\n if ((trackResources == null && includePerformanceEntry(resourceEntryJson, DEFAULT_TRACK_RESOURCES)) ||\n trackResources) {\n const faroResourceEntry = Object.assign(Object.assign({}, createFaroResourceTiming(resourceEntryJson)), { faroNavigationId, faroResourceId: genShortID() });\n if (faro.config.trackUserActionsPreview) {\n observable === null || observable === void 0 ? void 0 : observable.notify({\n type: RESOURCE_ENTRY,\n });\n }\n pushEvent('faro.performance.resource', faroResourceEntry, undefined, {\n spanContext,\n timestampOverwriteMs: performance.timeOrigin + resourceEntryJson.startTime,\n });\n }\n }\n });\n observer.observe({\n type: RESOURCE_ENTRY,\n buffered: true,\n });\n}\n//# sourceMappingURL=resource.js.map","import { BaseInstrumentation, dateNow, EVENT_SESSION_EXTEND, EVENT_SESSION_RESUME, EVENT_SESSION_START, VERSION, } from '@grafana/faro-core';\nimport { createSession } from '../../metas';\nimport { getSessionManagerByConfig, isSampled } from './sessionManager';\nimport { PersistentSessionsManager } from './sessionManager/PersistentSessionsManager';\nimport { createUserSessionObject, isUserSessionValid } from './sessionManager/sessionManagerUtils';\nexport class SessionInstrumentation extends BaseInstrumentation {\n constructor() {\n super(...arguments);\n this.name = '@grafana/faro-web-sdk:instrumentation-session';\n this.version = VERSION;\n }\n sendSessionStartEvent(meta) {\n var _a, _b;\n const session = meta.session;\n if (session && session.id !== ((_a = this.notifiedSession) === null || _a === void 0 ? void 0 : _a.id)) {\n if (this.notifiedSession && this.notifiedSession.id === ((_b = session.attributes) === null || _b === void 0 ? void 0 : _b['previousSession'])) {\n this.api.pushEvent(EVENT_SESSION_EXTEND, {}, undefined, { skipDedupe: true });\n this.notifiedSession = session;\n return;\n }\n this.notifiedSession = session;\n // no need to add attributes and session id, they are included as part of meta\n // automatically\n this.api.pushEvent(EVENT_SESSION_START, {}, undefined, { skipDedupe: true });\n }\n }\n createInitialSession(SessionManager, sessionsConfig) {\n var _a, _b, _c, _d, _e, _f;\n let storedUserSession = SessionManager.fetchUserSession();\n if (sessionsConfig.persistent && sessionsConfig.maxSessionPersistenceTime && storedUserSession) {\n const now = dateNow();\n const shouldClearPersistentSession = storedUserSession.lastActivity < now - sessionsConfig.maxSessionPersistenceTime;\n if (shouldClearPersistentSession) {\n PersistentSessionsManager.removeUserSession();\n storedUserSession = null;\n }\n }\n let lifecycleType;\n let initialSession;\n if (isUserSessionValid(storedUserSession)) {\n const sessionId = storedUserSession === null || storedUserSession === void 0 ? void 0 : storedUserSession.sessionId;\n initialSession = createUserSessionObject({\n sessionId,\n isSampled: storedUserSession.isSampled || false,\n started: storedUserSession === null || storedUserSession === void 0 ? void 0 : storedUserSession.started,\n });\n const storedUserSessionMeta = storedUserSession === null || storedUserSession === void 0 ? void 0 : storedUserSession.sessionMeta;\n // For resumed sessions we want to merge the previous overrides with the configured ones.\n // If the same key is present in both, the new one will override the old one.\n const overrides = Object.assign(Object.assign({}, (_a = sessionsConfig.session) === null || _a === void 0 ? void 0 : _a.overrides), storedUserSessionMeta === null || storedUserSessionMeta === void 0 ? void 0 : storedUserSessionMeta.overrides);\n initialSession.sessionMeta = Object.assign(Object.assign({}, sessionsConfig.session), { id: sessionId, attributes: Object.assign(Object.assign(Object.assign({}, (_b = sessionsConfig.session) === null || _b === void 0 ? void 0 : _b.attributes), storedUserSessionMeta === null || storedUserSessionMeta === void 0 ? void 0 : storedUserSessionMeta.attributes), { \n // For valid resumed sessions we do not want to recalculate the sampling decision on each init phase.\n isSampled: initialSession.isSampled.toString() }), overrides });\n lifecycleType = EVENT_SESSION_RESUME;\n }\n else {\n const sessionId = (_d = (_c = sessionsConfig.session) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : createSession().id;\n initialSession = createUserSessionObject({\n sessionId,\n isSampled: isSampled(),\n });\n const overrides = (_e = sessionsConfig.session) === null || _e === void 0 ? void 0 : _e.overrides;\n initialSession.sessionMeta = Object.assign({ id: sessionId, attributes: Object.assign({ isSampled: initialSession.isSampled.toString() }, (_f = sessionsConfig.session) === null || _f === void 0 ? void 0 : _f.attributes) }, (overrides ? { overrides } : {}));\n lifecycleType = EVENT_SESSION_START;\n }\n return { initialSession, lifecycleType };\n }\n registerBeforeSendHook(SessionManager) {\n var _a;\n const { updateSession } = new SessionManager();\n (_a = this.transports) === null || _a === void 0 ? void 0 : _a.addBeforeSendHooks((item) => {\n var _a, _b, _c;\n updateSession();\n const attributes = (_a = item.meta.session) === null || _a === void 0 ? void 0 : _a.attributes;\n if (attributes && (attributes === null || attributes === void 0 ? void 0 : attributes['isSampled']) === 'true') {\n let newItem = JSON.parse(JSON.stringify(item));\n const newAttributes = (_b = newItem.meta.session) === null || _b === void 0 ? void 0 : _b.attributes;\n newAttributes === null || newAttributes === void 0 ? true : delete newAttributes['isSampled'];\n if (Object.keys(newAttributes !== null && newAttributes !== void 0 ? newAttributes : {}).length === 0) {\n (_c = newItem.meta.session) === null || _c === void 0 ? true : delete _c.attributes;\n }\n return newItem;\n }\n return null;\n });\n }\n initialize() {\n this.logDebug('init session instrumentation');\n const sessionTrackingConfig = this.config.sessionTracking;\n if (sessionTrackingConfig === null || sessionTrackingConfig === void 0 ? void 0 : sessionTrackingConfig.enabled) {\n const SessionManager = getSessionManagerByConfig(sessionTrackingConfig);\n this.registerBeforeSendHook(SessionManager);\n const { initialSession, lifecycleType } = this.createInitialSession(SessionManager, sessionTrackingConfig);\n SessionManager.storeUserSession(initialSession);\n const initialSessionMeta = initialSession.sessionMeta;\n this.notifiedSession = initialSessionMeta;\n this.api.setSession(initialSessionMeta);\n if (lifecycleType === EVENT_SESSION_START) {\n this.api.pushEvent(EVENT_SESSION_START, {}, undefined, { skipDedupe: true });\n }\n if (lifecycleType === EVENT_SESSION_RESUME) {\n this.api.pushEvent(EVENT_SESSION_RESUME, {}, undefined, { skipDedupe: true });\n }\n }\n this.metas.addListener(this.sendSessionStartEvent.bind(this));\n }\n}\n//# sourceMappingURL=instrumentation.js.map","import { faro, stringifyExternalJson } from '@grafana/faro-core';\nimport { throttle } from '../../../utils';\nimport { getItem, removeItem, setItem, webStorageType } from '../../../utils/webStorage';\nimport { STORAGE_KEY, STORAGE_UPDATE_DELAY } from './sessionConstants';\nimport { getSessionMetaUpdateHandler, getUserSessionUpdater } from './sessionManagerUtils';\nexport class PersistentSessionsManager {\n constructor() {\n this.updateSession = throttle(() => this.updateUserSession(), STORAGE_UPDATE_DELAY);\n this.updateUserSession = getUserSessionUpdater({\n fetchUserSession: PersistentSessionsManager.fetchUserSession,\n storeUserSession: PersistentSessionsManager.storeUserSession,\n });\n this.init();\n }\n static removeUserSession() {\n removeItem(STORAGE_KEY, PersistentSessionsManager.storageTypeLocal);\n }\n static storeUserSession(session) {\n setItem(STORAGE_KEY, stringifyExternalJson(session), PersistentSessionsManager.storageTypeLocal);\n }\n static fetchUserSession() {\n const storedSession = getItem(STORAGE_KEY, PersistentSessionsManager.storageTypeLocal);\n if (storedSession) {\n return JSON.parse(storedSession);\n }\n return null;\n }\n init() {\n document.addEventListener('visibilitychange', () => {\n if (document.visibilityState === 'visible') {\n this.updateSession();\n }\n });\n // Users can call the setSession() method, so we need to sync this with the local storage session\n faro.metas.addListener(getSessionMetaUpdateHandler({\n fetchUserSession: PersistentSessionsManager.fetchUserSession,\n storeUserSession: PersistentSessionsManager.storeUserSession,\n }));\n }\n}\nPersistentSessionsManager.storageTypeLocal = webStorageType.local;\n//# sourceMappingURL=PersistentSessionsManager.js.map","import { faro, stringifyExternalJson } from '@grafana/faro-core';\nimport { throttle } from '../../../utils';\nimport { getItem, removeItem, setItem, webStorageType } from '../../../utils/webStorage';\nimport { STORAGE_KEY, STORAGE_UPDATE_DELAY } from './sessionConstants';\nimport { getSessionMetaUpdateHandler, getUserSessionUpdater } from './sessionManagerUtils';\nexport class VolatileSessionsManager {\n constructor() {\n this.updateSession = throttle(() => this.updateUserSession(), STORAGE_UPDATE_DELAY);\n this.updateUserSession = getUserSessionUpdater({\n fetchUserSession: VolatileSessionsManager.fetchUserSession,\n storeUserSession: VolatileSessionsManager.storeUserSession,\n });\n this.init();\n }\n static removeUserSession() {\n removeItem(STORAGE_KEY, VolatileSessionsManager.storageTypeSession);\n }\n static storeUserSession(session) {\n setItem(STORAGE_KEY, stringifyExternalJson(session), VolatileSessionsManager.storageTypeSession);\n }\n static fetchUserSession() {\n const storedSession = getItem(STORAGE_KEY, VolatileSessionsManager.storageTypeSession);\n if (storedSession) {\n return JSON.parse(storedSession);\n }\n return null;\n }\n init() {\n document.addEventListener('visibilitychange', () => {\n if (document.visibilityState === 'visible') {\n this.updateSession();\n }\n });\n // Users can call the setSession() method, so we need to sync this with the local storage session\n faro.metas.addListener(getSessionMetaUpdateHandler({\n fetchUserSession: VolatileSessionsManager.fetchUserSession,\n storeUserSession: VolatileSessionsManager.storeUserSession,\n }));\n }\n}\nVolatileSessionsManager.storageTypeSession = webStorageType.session;\n//# sourceMappingURL=VolatileSessionManager.js.map","import { PersistentSessionsManager } from './PersistentSessionsManager';\nimport { VolatileSessionsManager } from './VolatileSessionManager';\nexport function getSessionManagerByConfig(sessionTrackingConfig) {\n return (sessionTrackingConfig === null || sessionTrackingConfig === void 0 ? void 0 : sessionTrackingConfig.persistent) ? PersistentSessionsManager : VolatileSessionsManager;\n}\n//# sourceMappingURL=getSessionManagerByConfig.js.map","import { faro } from '@grafana/faro-core';\nexport function isSampled() {\n var _a, _b, _c;\n const sendAllSignals = 1;\n const sessionTracking = faro.config.sessionTracking;\n let samplingRate = (_c = (_b = (_a = sessionTracking === null || sessionTracking === void 0 ? void 0 : sessionTracking.sampler) === null || _a === void 0 ? void 0 : _a.call(sessionTracking, { metas: faro.metas.value })) !== null && _b !== void 0 ? _b : sessionTracking === null || sessionTracking === void 0 ? void 0 : sessionTracking.samplingRate) !== null && _c !== void 0 ? _c : sendAllSignals;\n if (typeof samplingRate !== 'number') {\n const sendNoSignals = 0;\n samplingRate = sendNoSignals;\n }\n return Math.random() < samplingRate;\n}\n//# sourceMappingURL=sampling.js.map","export const STORAGE_KEY = 'com.grafana.faro.session';\nexport const SESSION_EXPIRATION_TIME = 4 * 60 * 60 * 1000; // hrs\nexport const SESSION_INACTIVITY_TIME = 15 * 60 * 1000; // minutes\nexport const STORAGE_UPDATE_DELAY = 1 * 1000; // seconds\n/**\n * @deprecated MAX_SESSION_PERSISTENCE_TIME_BUFFER is not used anymore. The constant will be removed in the future\n */\nexport const MAX_SESSION_PERSISTENCE_TIME_BUFFER = 1 * 60 * 1000;\nexport const MAX_SESSION_PERSISTENCE_TIME = SESSION_INACTIVITY_TIME;\nexport const defaultSessionTrackingConfig = {\n enabled: true,\n persistent: false,\n maxSessionPersistenceTime: MAX_SESSION_PERSISTENCE_TIME,\n};\n//# sourceMappingURL=sessionConstants.js.map","import { dateNow, deepEqual, EVENT_OVERRIDES_SERVICE_NAME, faro, genShortID, isEmpty } from '@grafana/faro-core';\nimport { isLocalStorageAvailable, isSessionStorageAvailable } from '../../../utils';\nimport { isSampled } from './sampling';\nimport { SESSION_EXPIRATION_TIME, SESSION_INACTIVITY_TIME } from './sessionConstants';\nexport function createUserSessionObject({ sessionId, started, lastActivity, isSampled = true, } = {}) {\n var _a, _b;\n const now = dateNow();\n const generateSessionId = (_b = (_a = faro.config) === null || _a === void 0 ? void 0 : _a.sessionTracking) === null || _b === void 0 ? void 0 : _b.generateSessionId;\n if (sessionId == null) {\n sessionId = typeof generateSessionId === 'function' ? generateSessionId() : genShortID();\n }\n return {\n sessionId,\n lastActivity: lastActivity !== null && lastActivity !== void 0 ? lastActivity : now,\n started: started !== null && started !== void 0 ? started : now,\n isSampled: isSampled,\n };\n}\nexport function isUserSessionValid(session) {\n if (session == null) {\n return false;\n }\n const now = dateNow();\n const lifetimeValid = now - session.started < SESSION_EXPIRATION_TIME;\n if (!lifetimeValid) {\n return false;\n }\n const inactivityPeriodValid = now - session.lastActivity < SESSION_INACTIVITY_TIME;\n return inactivityPeriodValid;\n}\nexport function getUserSessionUpdater({ fetchUserSession, storeUserSession, }) {\n return function updateSession({ forceSessionExtend } = { forceSessionExtend: false }) {\n var _a, _b, _c;\n if (!fetchUserSession || !storeUserSession) {\n return;\n }\n const sessionTrackingConfig = faro.config.sessionTracking;\n const isPersistentSessions = sessionTrackingConfig === null || sessionTrackingConfig === void 0 ? void 0 : sessionTrackingConfig.persistent;\n if ((isPersistentSessions && !isLocalStorageAvailable) || (!isPersistentSessions && !isSessionStorageAvailable)) {\n return;\n }\n const sessionFromStorage = fetchUserSession();\n if (forceSessionExtend === false && isUserSessionValid(sessionFromStorage)) {\n storeUserSession(Object.assign(Object.assign({}, sessionFromStorage), { lastActivity: dateNow() }));\n }\n else {\n let newSession = addSessionMetadataToNextSession(createUserSessionObject({ isSampled: isSampled() }), sessionFromStorage);\n storeUserSession(newSession);\n (_a = faro.api) === null || _a === void 0 ? void 0 : _a.setSession(newSession.sessionMeta);\n (_b = sessionTrackingConfig === null || sessionTrackingConfig === void 0 ? void 0 : sessionTrackingConfig.onSessionChange) === null || _b === void 0 ? void 0 : _b.call(sessionTrackingConfig, (_c = sessionFromStorage === null || sessionFromStorage === void 0 ? void 0 : sessionFromStorage.sessionMeta) !== null && _c !== void 0 ? _c : null, newSession.sessionMeta);\n }\n };\n}\nexport function addSessionMetadataToNextSession(newSession, previousSession) {\n var _a, _b, _c, _d, _e, _f, _g;\n const sessionWithMeta = Object.assign(Object.assign({}, newSession), { sessionMeta: {\n id: newSession.sessionId,\n attributes: Object.assign(Object.assign(Object.assign({}, (_b = (_a = faro.config.sessionTracking) === null || _a === void 0 ? void 0 : _a.session) === null || _b === void 0 ? void 0 : _b.attributes), ((_d = (_c = faro.metas.value.session) === null || _c === void 0 ? void 0 : _c.attributes) !== null && _d !== void 0 ? _d : {})), { isSampled: newSession.isSampled.toString() }),\n } });\n const overrides = (_f = (_e = faro.metas.value.session) === null || _e === void 0 ? void 0 : _e.overrides) !== null && _f !== void 0 ? _f : (_g = previousSession === null || previousSession === void 0 ? void 0 : previousSession.sessionMeta) === null || _g === void 0 ? void 0 : _g.overrides;\n if (!isEmpty(overrides)) {\n sessionWithMeta.sessionMeta.overrides = overrides;\n }\n const previousSessionId = previousSession === null || previousSession === void 0 ? void 0 : previousSession.sessionId;\n if (previousSessionId != null) {\n sessionWithMeta.sessionMeta.attributes['previousSession'] = previousSessionId;\n }\n return sessionWithMeta;\n}\nexport function getSessionMetaUpdateHandler({ fetchUserSession, storeUserSession, }) {\n return function syncSessionIfChangedExternally(meta) {\n const session = meta.session;\n const sessionFromSessionStorage = fetchUserSession();\n let sessionId = session === null || session === void 0 ? void 0 : session.id;\n const sessionAttributes = session === null || session === void 0 ? void 0 : session.attributes;\n const sessionOverrides = session === null || session === void 0 ? void 0 : session.overrides;\n const storedSessionMeta = sessionFromSessionStorage === null || sessionFromSessionStorage === void 0 ? void 0 : sessionFromSessionStorage.sessionMeta;\n const storedSessionMetaOverrides = storedSessionMeta === null || storedSessionMeta === void 0 ? void 0 : storedSessionMeta.overrides;\n const hasSessionOverridesChanged = !!sessionOverrides && !deepEqual(sessionOverrides, storedSessionMetaOverrides);\n const hasAttributesChanged = !!sessionAttributes && !deepEqual(sessionAttributes, storedSessionMeta === null || storedSessionMeta === void 0 ? void 0 : storedSessionMeta.attributes);\n const hasSessionIdChanged = !!session && sessionId !== (sessionFromSessionStorage === null || sessionFromSessionStorage === void 0 ? void 0 : sessionFromSessionStorage.sessionId);\n if (hasSessionIdChanged || hasAttributesChanged || hasSessionOverridesChanged) {\n const userSession = addSessionMetadataToNextSession(createUserSessionObject({ sessionId, isSampled: isSampled() }), sessionFromSessionStorage);\n storeUserSession(userSession);\n sendOverrideEvent(hasSessionOverridesChanged, sessionOverrides, storedSessionMetaOverrides);\n faro.api.setSession(userSession.sessionMeta);\n }\n };\n}\nfunction sendOverrideEvent(hasSessionOverridesChanged, sessionOverrides = {}, storedSessionOverrides = {}) {\n var _a, _b, _c;\n if (!hasSessionOverridesChanged) {\n return;\n }\n const serviceName = sessionOverrides.serviceName;\n const previousServiceName = (_c = (_a = storedSessionOverrides.serviceName) !== null && _a !== void 0 ? _a : (_b = faro.metas.value.app) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : '';\n if (serviceName && serviceName !== previousServiceName) {\n faro.api.pushEvent(EVENT_OVERRIDES_SERVICE_NAME, {\n serviceName,\n previousServiceName,\n });\n }\n}\n//# sourceMappingURL=sessionManagerUtils.js.map","export const MESSAGE_TYPE_RESOURCE_ENTRY = 'resource-entry';\nexport const MESSAGE_TYPE_HTTP_REQUEST_START = 'http-request-start';\nexport const MESSAGE_TYPE_HTTP_REQUEST_END = 'http-request-end';\nexport const MESSAGE_TYPE_DOM_MUTATION = 'dom-mutation';\nexport const userActionDataAttributeParsed = 'faroUserActionName';\nexport const userActionDataAttribute = 'data-faro-user-action-name';\n//# sourceMappingURL=const.js.map","import { Observable } from '@grafana/faro-core';\nimport { MESSAGE_TYPE_DOM_MUTATION } from './const';\nexport function monitorDomMutations() {\n const observable = new Observable();\n const observer = new MutationObserver((_mutationsList, _observer) => {\n observable.notify({ type: MESSAGE_TYPE_DOM_MUTATION });\n });\n observer.observe(document, {\n attributes: true,\n childList: true,\n subtree: true,\n characterData: true,\n });\n return observable;\n}\n//# sourceMappingURL=domMutationMonitor.js.map","import { genShortID, Observable } from '@grafana/faro-core';\nimport { getUrlFromResource, isUrlIgnored } from '../../utils/url';\nimport { MESSAGE_TYPE_HTTP_REQUEST_END, MESSAGE_TYPE_HTTP_REQUEST_START } from './const';\nconst apiTypeFetch = 'fetch';\nconst apiTypeXhr = 'xhr';\n/**\n * Monitors if any http requests are in progress.\n */\nexport function monitorHttpRequests() {\n const observable = new Observable();\n function emitStartMessage(requestProps) {\n observable.notify({\n type: MESSAGE_TYPE_HTTP_REQUEST_START,\n request: requestProps,\n });\n }\n function emitEndMessage(requestProps) {\n observable.notify({\n type: MESSAGE_TYPE_HTTP_REQUEST_END,\n request: requestProps,\n });\n }\n monitorFetch({\n onRequestStart: emitStartMessage,\n onRequestEnd: emitEndMessage,\n });\n monitorXhr({\n onRequestStart: emitStartMessage,\n onRequestEnd: emitEndMessage,\n });\n return observable;\n}\nfunction monitorXhr({ onRequestStart, onRequestEnd, }) {\n const originalOpen = XMLHttpRequest.prototype.open;\n XMLHttpRequest.prototype.open = function () {\n const url = arguments[1];\n const isIgnoredUrl = isUrlIgnored(url);\n const method = arguments[0];\n const requestId = genShortID();\n // request has started to load data.\n this.addEventListener('loadstart', function () {\n if (!isIgnoredUrl) {\n onRequestStart({ url, method, requestId, apiType: apiTypeXhr });\n }\n });\n // transaction completes successfully.\n this.addEventListener('load', function () {\n if (!isIgnoredUrl) {\n onRequestEnd({ url, method, requestId, apiType: apiTypeXhr });\n }\n });\n this.addEventListener('error', function () {\n if (!isIgnoredUrl) {\n onRequestEnd({ url, method, requestId, apiType: apiTypeXhr });\n }\n });\n this.addEventListener('abort', function () {\n if (!isIgnoredUrl) {\n onRequestEnd({ url, method, requestId, apiType: apiTypeXhr });\n }\n });\n originalOpen.apply(this, arguments);\n };\n}\nfunction monitorFetch({ onRequestEnd, onRequestStart, }) {\n const originalFetch = window.fetch;\n window.fetch = function () {\n var _a, _b;\n const url = (_a = getUrlFromResource(arguments[0])) !== null && _a !== void 0 ? _a : '';\n const isIgnoredUrl = isUrlIgnored(url);\n const method = ((_b = arguments[1]) !== null && _b !== void 0 ? _b : {}).method;\n const requestId = genShortID();\n if (!isIgnoredUrl) {\n onRequestStart({ url, method, requestId, apiType: apiTypeFetch });\n }\n return originalFetch\n .apply(this, arguments)\n .then((response) => {\n if (!isIgnoredUrl) {\n onRequestEnd({ url, method, requestId, apiType: apiTypeFetch });\n }\n return response;\n })\n .catch((error) => {\n if (!isIgnoredUrl) {\n onRequestEnd({ url, method, requestId, apiType: apiTypeFetch });\n }\n throw error;\n });\n };\n}\n//# sourceMappingURL=httpRequestMonitor.js.map","import { BaseInstrumentation, faro, VERSION } from '@grafana/faro-core';\nimport { getUserEventHandler } from './processUserActionEventHandler';\nlet processUserEventHandler;\nexport class UserActionInstrumentation extends BaseInstrumentation {\n constructor() {\n super(...arguments);\n this.name = '@grafana/faro-web-sdk:instrumentation-user-action';\n this.version = VERSION;\n }\n initialize() {\n processUserEventHandler = getUserEventHandler(faro);\n window.addEventListener('pointerdown', processUserEventHandler);\n window.addEventListener('keydown', processUserEventHandler);\n }\n}\nexport function startUserAction(name, attributes) {\n processUserEventHandler === null || processUserEventHandler === void 0 ? void 0 : processUserEventHandler(createUserActionApiEvent(name, attributes));\n}\nfunction createUserActionApiEvent(name, attributes) {\n return {\n name,\n attributes,\n type: 'apiEvent',\n };\n}\n//# sourceMappingURL=instrumentation.js.map","import { Observable } from '@grafana/faro-core';\nimport { performanceEntriesSubscription } from '../performance/instrumentation';\nimport { RESOURCE_ENTRY } from '../performance/performanceConstants';\nimport { MESSAGE_TYPE_RESOURCE_ENTRY } from './const';\nexport function monitorPerformanceEntries() {\n const observable = new Observable();\n performanceEntriesSubscription.subscribe((data) => {\n if (data.type === RESOURCE_ENTRY) {\n observable.notify({ type: MESSAGE_TYPE_RESOURCE_ENTRY });\n }\n });\n return observable;\n}\n//# sourceMappingURL=performanceEntriesMonitor.js.map","import { apiMessageBus, dateNow, genShortID, Observable, stringifyObjectValues, USER_ACTION_CANCEL, USER_ACTION_END, USER_ACTION_HALT, USER_ACTION_START, } from '@grafana/faro-core';\nimport { MESSAGE_TYPE_HTTP_REQUEST_END, MESSAGE_TYPE_HTTP_REQUEST_START, userActionDataAttributeParsed as userActionDataAttribute, } from './const';\nimport { monitorDomMutations } from './domMutationMonitor';\nimport { monitorHttpRequests } from './httpRequestMonitor';\nimport { monitorPerformanceEntries } from './performanceEntriesMonitor';\nimport { convertDataAttributeName } from './util';\nconst maxFollowUpActionTimeRange = 100;\nexport function getUserEventHandler(faro) {\n const { api, config } = faro;\n const httpMonitor = monitorHttpRequests();\n const domMutationsMonitor = monitorDomMutations();\n const performanceEntriesMonitor = monitorPerformanceEntries();\n let timeoutId;\n let actionRunning = false;\n function processUserEvent(event) {\n var _a;\n let userActionName;\n const isApiEventDetected = isApiEvent(event);\n if (isApiEventDetected) {\n userActionName = event.name;\n }\n else {\n userActionName = getUserActionName(event.target, (_a = config.trackUserActionsDataAttributeName) !== null && _a !== void 0 ? _a : userActionDataAttribute);\n }\n if (actionRunning || userActionName == null) {\n return;\n }\n actionRunning = true;\n const startTime = dateNow();\n let endTime;\n const actionId = genShortID();\n apiMessageBus.notify({\n type: USER_ACTION_START,\n name: userActionName,\n startTime: startTime,\n parentId: actionId,\n });\n // Triggers if no initial action happened within the first 100ms\n timeoutId = startTimeout(timeoutId, () => {\n endTime = dateNow();\n // Listening for follow up activities stops once action is cancelled (set to false)\n actionRunning = false;\n sendUserActionCancelMessage(userActionName, actionId);\n }, maxFollowUpActionTimeRange);\n const runningRequests = new Map();\n let isHalted = false;\n let pendingActionTimeoutId;\n const allMonitorsSub = new Observable()\n .merge(httpMonitor, domMutationsMonitor, performanceEntriesMonitor)\n .takeWhile(() => actionRunning)\n .filter((msg) => {\n // If the user action is in halt state, we only keep listening to ended http requests\n if (isHalted && !(isRequestEndMessage(msg) && runningRequests.has(msg.request.requestId))) {\n return false;\n }\n return true;\n })\n .subscribe((msg) => {\n if (isRequestStartMessage(msg)) {\n // An action is on halt if it has pending items, like pending HTTP requests.\n // In this case we start a separate timeout to wait for the requests to finish\n // If in the halt state, we stop adding Faro signals to the action's buffer (see userActionLifecycleHandler.ts)\n // But we are still subscribed to\n runningRequests.set(msg.request.requestId, msg.request);\n }\n if (isRequestEndMessage(msg)) {\n runningRequests.delete(msg.request.requestId);\n }\n // A http request, a DOM mutation or a performance entry happened so we have a follow up activity and start the timeout again\n // If timeout is triggered the user action is done and we send respective messages and events\n timeoutId = startTimeout(timeoutId, () => {\n endTime = dateNow();\n const userActionParentEventProps = Object.assign({ api,\n userActionName,\n startTime, endTime: endTime, actionId,\n event }, (isApiEventDetected ? { attributes: event.attributes } : {}));\n const hasPendingRequests = runningRequests.size > 0;\n const isAllPendingRequestsResolved = isHalted && !hasPendingRequests;\n if (isAllPendingRequestsResolved) {\n clearTimeout(pendingActionTimeoutId);\n isHalted = false;\n }\n if (hasPendingRequests) {\n isHalted = true;\n apiMessageBus.notify({\n type: USER_ACTION_HALT,\n name: userActionName,\n parentId: actionId,\n reason: 'pending-requests',\n haltTime: dateNow(),\n });\n pendingActionTimeoutId = startTimeout(undefined, () => {\n unsubscribeAllMonitors(allMonitorsSub);\n endUserAction(userActionParentEventProps);\n actionRunning = false;\n isHalted = false;\n }, 1000 * 10);\n }\n else {\n unsubscribeAllMonitors(allMonitorsSub);\n endUserAction(userActionParentEventProps);\n actionRunning = false;\n isHalted = false;\n }\n }, maxFollowUpActionTimeRange);\n });\n }\n return processUserEvent;\n}\n/**\n * User action was successfully completed and we send the final event(s)\n */\nfunction endUserAction(props) {\n const { api, userActionName, startTime, endTime, actionId, event, attributes } = props;\n const duration = endTime - startTime;\n const eventType = event.type;\n // order matters, first emit the user-action-end event and afterwards push the parent event\n apiMessageBus.notify({\n type: USER_ACTION_END,\n name: userActionName,\n id: actionId,\n startTime,\n endTime,\n duration,\n eventType,\n });\n // Send the final action parent event\n api.pushEvent(userActionName, Object.assign({ userActionStartTime: startTime.toString(), userActionEndTime: endTime.toString(), userActionDuration: duration.toString(), userActionEventType: eventType }, stringifyObjectValues(attributes)), undefined, {\n timestampOverwriteMs: startTime,\n customPayloadTransformer: (payload) => {\n payload.action = {\n id: actionId,\n name: userActionName,\n };\n return payload;\n },\n });\n}\nfunction getUserActionName(element, dataAttributeName) {\n const parsedDataAttributeName = convertDataAttributeName(dataAttributeName);\n const dataset = element.dataset;\n for (const key in dataset) {\n if (key === parsedDataAttributeName) {\n return dataset[key];\n }\n }\n return undefined;\n}\nfunction startTimeout(timeoutId, cb, delay) {\n if (timeoutId) {\n clearTimeout(timeoutId);\n }\n //@ts-expect-error for some reason vscode is using the node types\n timeoutId = setTimeout(() => {\n cb();\n }, delay);\n return timeoutId;\n}\nfunction sendUserActionCancelMessage(userActionName, actionId) {\n apiMessageBus.notify({\n type: USER_ACTION_CANCEL,\n name: userActionName,\n parentId: actionId,\n });\n}\nfunction unsubscribeAllMonitors(allMonitorsSub) {\n allMonitorsSub === null || allMonitorsSub === void 0 ? void 0 : allMonitorsSub.unsubscribe();\n allMonitorsSub = undefined;\n}\nfunction isRequestStartMessage(msg) {\n return msg.type === MESSAGE_TYPE_HTTP_REQUEST_START;\n}\nfunction isRequestEndMessage(msg) {\n return msg.type === MESSAGE_TYPE_HTTP_REQUEST_END;\n}\nfunction isApiEvent(apiEvent) {\n return apiEvent.type === 'apiEvent' && typeof apiEvent.name === 'string';\n}\n//# sourceMappingURL=processUserActionEventHandler.js.map","/**\n * Parses the action attribute name by removing the 'data-' prefix and converting\n * the remaining string to camelCase.\n *\n * This is needed because the browser will remove the 'data-' prefix and the dashes from\n * data attributes and make then camelCase.\n */\nexport function convertDataAttributeName(userActionDataAttribute) {\n const withoutData = userActionDataAttribute.split('data-')[1];\n const withUpperCase = withoutData === null || withoutData === void 0 ? void 0 : withoutData.replace(/-(.)/g, (_, char) => char.toUpperCase());\n return withUpperCase === null || withUpperCase === void 0 ? void 0 : withUpperCase.replace(/-/g, '');\n}\n//# sourceMappingURL=util.js.map","import { BaseInstrumentation, EVENT_VIEW_CHANGED, unknownString, VERSION } from '@grafana/faro-core';\n// all this does is send VIEW_CHANGED event\nexport class ViewInstrumentation extends BaseInstrumentation {\n constructor() {\n super(...arguments);\n this.name = '@grafana/faro-web-sdk:instrumentation-view';\n this.version = VERSION;\n }\n sendViewChangedEvent(meta) {\n var _a, _b, _c, _d;\n const view = meta.view;\n if (view && view.name !== ((_a = this.notifiedView) === null || _a === void 0 ? void 0 : _a.name)) {\n this.api.pushEvent(EVENT_VIEW_CHANGED, {\n fromView: (_c = (_b = this.notifiedView) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : unknownString,\n toView: (_d = view.name) !== null && _d !== void 0 ? _d : unknownString,\n }, undefined, { skipDedupe: true });\n this.notifiedView = view;\n }\n }\n initialize() {\n this.metas.addListener(this.sendViewChangedEvent.bind(this));\n }\n}\n//# sourceMappingURL=instrumentation.js.map","import { BaseInstrumentation, VERSION } from '@grafana/faro-core';\nimport { WebVitalsBasic } from './webVitalsBasic';\nimport { WebVitalsWithAttribution } from './webVitalsWithAttribution';\nexport class WebVitalsInstrumentation extends BaseInstrumentation {\n constructor() {\n super(...arguments);\n this.name = '@grafana/faro-web-sdk:instrumentation-web-vitals';\n this.version = VERSION;\n }\n initialize() {\n this.logDebug('Initializing');\n const webVitals = this.intializeWebVitalsInstrumentation();\n webVitals.initialize();\n }\n intializeWebVitalsInstrumentation() {\n var _a, _b, _c;\n if (((_a = this.config) === null || _a === void 0 ? void 0 : _a.trackWebVitalsAttribution) === false ||\n ((_c = (_b = this.config) === null || _b === void 0 ? void 0 : _b.webVitalsInstrumentation) === null || _c === void 0 ? void 0 : _c.trackAttribution) === false) {\n return new WebVitalsBasic(this.api.pushMeasurement, this.config.webVitalsInstrumentation);\n }\n return new WebVitalsWithAttribution(this.api.pushMeasurement, this.config.webVitalsInstrumentation);\n }\n}\n//# sourceMappingURL=instrumentation.js.map","import { onCLS, onFCP, onFID, onINP, onLCP, onTTFB } from 'web-vitals';\nexport class WebVitalsBasic {\n constructor(pushMeasurement, webVitalConfig) {\n this.pushMeasurement = pushMeasurement;\n this.webVitalConfig = webVitalConfig;\n }\n initialize() {\n Object.entries(WebVitalsBasic.mapping).forEach(([indicator, executor]) => {\n var _a;\n executor((metric) => {\n this.pushMeasurement({\n type: 'web-vitals',\n values: {\n [indicator]: metric.value,\n },\n });\n }, { reportAllChanges: (_a = this.webVitalConfig) === null || _a === void 0 ? void 0 : _a.reportAllChanges });\n });\n }\n}\nWebVitalsBasic.mapping = {\n cls: onCLS,\n fcp: onFCP,\n fid: onFID,\n inp: onINP,\n lcp: onLCP,\n ttfb: onTTFB,\n};\n//# sourceMappingURL=webVitalsBasic.js.map","import { onCLS, onFCP, onFID, onINP, onLCP, onTTFB } from 'web-vitals/attribution';\nimport { unknownString } from '@grafana/faro-core';\nimport { getItem, webStorageType } from '../../utils';\nimport { NAVIGATION_ID_STORAGE_KEY } from '../instrumentationConstants';\n// duplicate keys saved in variables to save bundle size\n// refs: https://github.com/grafana/faro-web-sdk/pull/595#discussion_r1615833968\nconst loadStateKey = 'load_state';\nconst timeToFirstByteKey = 'time_to_first_byte';\nexport class WebVitalsWithAttribution {\n constructor(corePushMeasurement, webVitalConfig) {\n this.corePushMeasurement = corePushMeasurement;\n this.webVitalConfig = webVitalConfig;\n }\n initialize() {\n this.measureCLS();\n this.measureFCP();\n this.measureFID();\n this.measureINP();\n this.measureLCP();\n this.measureTTFB();\n }\n measureCLS() {\n var _a;\n onCLS((metric) => {\n const { loadState, largestShiftValue, largestShiftTime, largestShiftTarget } = metric.attribution;\n const values = this.buildInitialValues(metric);\n this.addIfPresent(values, 'largest_shift_value', largestShiftValue);\n this.addIfPresent(values, 'largest_shift_time', largestShiftTime);\n const context = this.buildInitialContext(metric);\n this.addIfPresent(context, loadStateKey, loadState);\n this.addIfPresent(context, 'largest_shift_target', largestShiftTarget);\n this.pushMeasurement(values, context);\n }, { reportAllChanges: (_a = this.webVitalConfig) === null || _a === void 0 ? void 0 : _a.reportAllChanges });\n }\n measureFCP() {\n var _a;\n onFCP((metric) => {\n const { firstByteToFCP, timeToFirstByte, loadState } = metric.attribution;\n const values = this.buildInitialValues(metric);\n this.addIfPresent(values, 'first_byte_to_fcp', firstByteToFCP);\n this.addIfPresent(values, timeToFirstByteKey, timeToFirstByte);\n const context = this.buildInitialContext(metric);\n this.addIfPresent(context, loadStateKey, loadState);\n this.pushMeasurement(values, context);\n }, { reportAllChanges: (_a = this.webVitalConfig) === null || _a === void 0 ? void 0 : _a.reportAllChanges });\n }\n measureFID() {\n var _a;\n onFID((metric) => {\n const { eventTime, eventTarget, eventType, loadState } = metric.attribution;\n const values = this.buildInitialValues(metric);\n this.addIfPresent(values, 'event_time', eventTime);\n const context = this.buildInitialContext(metric);\n this.addIfPresent(context, 'event_target', eventTarget);\n this.addIfPresent(context, 'event_type', eventType);\n this.addIfPresent(context, loadStateKey, loadState);\n this.pushMeasurement(values, context);\n }, { reportAllChanges: (_a = this.webVitalConfig) === null || _a === void 0 ? void 0 : _a.reportAllChanges });\n }\n measureINP() {\n var _a;\n onINP((metric) => {\n const { interactionTime, presentationDelay, inputDelay, processingDuration, nextPaintTime, loadState, interactionTarget, interactionType, } = metric.attribution;\n const values = this.buildInitialValues(metric);\n this.addIfPresent(values, 'interaction_time', interactionTime);\n this.addIfPresent(values, 'presentation_delay', presentationDelay);\n this.addIfPresent(values, 'input_delay', inputDelay);\n this.addIfPresent(values, 'processing_duration', processingDuration);\n this.addIfPresent(values, 'next_paint_time', nextPaintTime);\n const context = this.buildInitialContext(metric);\n this.addIfPresent(context, loadStateKey, loadState);\n this.addIfPresent(context, 'interaction_target', interactionTarget);\n this.addIfPresent(context, 'interaction_type', interactionType);\n this.pushMeasurement(values, context);\n }, { reportAllChanges: (_a = this.webVitalConfig) === null || _a === void 0 ? void 0 : _a.reportAllChanges });\n }\n measureLCP() {\n var _a;\n onLCP((metric) => {\n const { elementRenderDelay, resourceLoadDelay, resourceLoadDuration, timeToFirstByte, element } = metric.attribution;\n const values = this.buildInitialValues(metric);\n this.addIfPresent(values, 'element_render_delay', elementRenderDelay);\n this.addIfPresent(values, 'resource_load_delay', resourceLoadDelay);\n this.addIfPresent(values, 'resource_load_duration', resourceLoadDuration);\n this.addIfPresent(values, timeToFirstByteKey, timeToFirstByte);\n const context = this.buildInitialContext(metric);\n this.addIfPresent(context, 'element', element);\n this.pushMeasurement(values, context);\n }, { reportAllChanges: (_a = this.webVitalConfig) === null || _a === void 0 ? void 0 : _a.reportAllChanges });\n }\n measureTTFB() {\n var _a;\n onTTFB((metric) => {\n const { dnsDuration, connectionDuration, requestDuration, waitingDuration, cacheDuration } = metric.attribution;\n const values = this.buildInitialValues(metric);\n this.addIfPresent(values, 'dns_duration', dnsDuration);\n this.addIfPresent(values, 'connection_duration', connectionDuration);\n this.addIfPresent(values, 'request_duration', requestDuration);\n this.addIfPresent(values, 'waiting_duration', waitingDuration);\n this.addIfPresent(values, 'cache_duration', cacheDuration);\n const context = this.buildInitialContext(metric);\n this.pushMeasurement(values, context);\n }, { reportAllChanges: (_a = this.webVitalConfig) === null || _a === void 0 ? void 0 : _a.reportAllChanges });\n }\n buildInitialValues(metric) {\n const indicator = metric.name.toLowerCase();\n return {\n [indicator]: metric.value,\n delta: metric.delta,\n };\n }\n buildInitialContext(metric) {\n var _a;\n const navigationEntryId = (_a = getItem(NAVIGATION_ID_STORAGE_KEY, webStorageType.session)) !== null && _a !== void 0 ? _a : unknownString;\n return {\n id: metric.id,\n rating: metric.rating,\n navigation_type: metric.navigationType,\n navigation_entry_id: navigationEntryId,\n };\n }\n pushMeasurement(values, context) {\n const type = 'web-vitals';\n this.corePushMeasurement({ type, values }, { context });\n }\n addIfPresent(source, key, metric) {\n if (metric) {\n source[key] = metric;\n }\n }\n}\n//# sourceMappingURL=webVitalsWithAttribution.js.map","import { UAParser } from 'ua-parser-js';\nimport { unknownString } from '@grafana/faro-core';\nexport const browserMeta = () => {\n const parser = new UAParser();\n const { name, version } = parser.getBrowser();\n const { name: osName, version: osVersion } = parser.getOS();\n const userAgent = parser.getUA();\n const language = navigator.language;\n const mobile = navigator.userAgent.includes('Mobi');\n const brands = getBrands();\n return {\n browser: {\n name: name !== null && name !== void 0 ? name : unknownString,\n version: version !== null && version !== void 0 ? version : unknownString,\n os: `${osName !== null && osName !== void 0 ? osName : unknownString} ${osVersion !== null && osVersion !== void 0 ? osVersion : unknownString}`,\n userAgent: userAgent !== null && userAgent !== void 0 ? userAgent : unknownString,\n language: language !== null && language !== void 0 ? language : unknownString,\n mobile,\n brands: brands !== null && brands !== void 0 ? brands : unknownString,\n viewportWidth: `${window.innerWidth}`,\n viewportHeight: `${window.innerHeight}`,\n },\n };\n function getBrands() {\n if (!name || !version) {\n return undefined;\n }\n if ('userAgentData' in navigator && navigator.userAgentData) {\n // userAgentData in experimental (only Chrome supports it) thus TS does not ship the respective type declarations\n return navigator.userAgentData.brands;\n }\n return undefined;\n }\n};\n//# sourceMappingURL=meta.js.map","export const k6Meta = () => {\n const k6Properties = window.k6;\n return {\n k6: Object.assign({ \n // we only add the k6 meta if Faro is running inside a k6 environment, so this is always true\n isK6Browser: true }, ((k6Properties === null || k6Properties === void 0 ? void 0 : k6Properties.testRunId) && { testRunId: k6Properties === null || k6Properties === void 0 ? void 0 : k6Properties.testRunId })),\n };\n};\n//# sourceMappingURL=meta.js.map","import { isFunction } from '@grafana/faro-core';\nlet currentHref;\nlet pageId;\nexport function createPageMeta({ generatePageId, initialPageMeta } = {}) {\n const pageMeta = () => {\n const locationHref = location.href;\n if (isFunction(generatePageId) && currentHref !== locationHref) {\n currentHref = locationHref;\n pageId = generatePageId(location);\n }\n return {\n page: Object.assign(Object.assign({ url: locationHref }, (pageId ? { id: pageId } : {})), initialPageMeta),\n };\n };\n return pageMeta;\n}\n//# sourceMappingURL=meta.js.map","import { faro, genShortID } from '@grafana/faro-core';\nexport function createSession(attributes) {\n var _a, _b, _c, _d;\n return {\n id: (_d = (_c = (_b = (_a = faro.config) === null || _a === void 0 ? void 0 : _a.sessionTracking) === null || _b === void 0 ? void 0 : _b.generateSessionId) === null || _c === void 0 ? void 0 : _c.call(_b)) !== null && _d !== void 0 ? _d : genShortID(),\n attributes,\n };\n}\n//# sourceMappingURL=createSession.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nvar __rest = (this && this.__rest) || function (s, e) {\n var t = {};\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n t[p] = s[p];\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n t[p[i]] = s[p[i]];\n }\n return t;\n};\nimport { BaseExtension, BaseTransport, createPromiseBuffer, getTransportBody, noop, VERSION } from '@grafana/faro-core';\nimport { getSessionManagerByConfig } from '../../instrumentations/session/sessionManager';\nimport { getUserSessionUpdater } from '../../instrumentations/session/sessionManager/sessionManagerUtils';\nconst DEFAULT_BUFFER_SIZE = 30;\nconst DEFAULT_CONCURRENCY = 5; // chrome supports 10 total, firefox 17\nconst DEFAULT_RATE_LIMIT_BACKOFF_MS = 5000;\nconst BEACON_BODY_SIZE_LIMIT = 60000;\nconst TOO_MANY_REQUESTS = 429;\nconst ACCEPTED = 202;\nexport class FetchTransport extends BaseTransport {\n constructor(options) {\n var _a, _b, _c, _d;\n super();\n this.options = options;\n this.name = '@grafana/faro-web-sdk:transport-fetch';\n this.version = VERSION;\n this.disabledUntil = new Date();\n this.rateLimitBackoffMs = (_a = options.defaultRateLimitBackoffMs) !== null && _a !== void 0 ? _a : DEFAULT_RATE_LIMIT_BACKOFF_MS;\n this.getNow = (_b = options.getNow) !== null && _b !== void 0 ? _b : (() => Date.now());\n this.promiseBuffer = createPromiseBuffer({\n size: (_c = options.bufferSize) !== null && _c !== void 0 ? _c : DEFAULT_BUFFER_SIZE,\n concurrency: (_d = options.concurrency) !== null && _d !== void 0 ? _d : DEFAULT_CONCURRENCY,\n });\n }\n send(items) {\n return __awaiter(this, void 0, void 0, function* () {\n try {\n if (this.disabledUntil > new Date(this.getNow())) {\n this.logWarn(`Dropping transport item due to too many requests. Backoff until ${this.disabledUntil}`);\n return Promise.resolve();\n }\n yield this.promiseBuffer.add(() => {\n const body = JSON.stringify(getTransportBody(items));\n const { url, requestOptions, apiKey } = this.options;\n const _a = requestOptions !== null && requestOptions !== void 0 ? requestOptions : {}, { headers } = _a, restOfRequestOptions = __rest(_a, [\"headers\"]);\n let sessionId;\n const sessionMeta = this.metas.value.session;\n if (sessionMeta != null) {\n sessionId = sessionMeta.id;\n }\n return fetch(url, Object.assign({ method: 'POST', headers: Object.assign(Object.assign(Object.assign({ 'Content-Type': 'application/json' }, (headers !== null && headers !== void 0 ? headers : {})), (apiKey ? { 'x-api-key': apiKey } : {})), (sessionId ? { 'x-faro-session-id': sessionId } : {})), body, keepalive: body.length <= BEACON_BODY_SIZE_LIMIT }, (restOfRequestOptions !== null && restOfRequestOptions !== void 0 ? restOfRequestOptions : {})))\n .then((response) => __awaiter(this, void 0, void 0, function* () {\n if (response.status === ACCEPTED) {\n const sessionExpired = response.headers.get('X-Faro-Session-Status') === 'invalid';\n if (sessionExpired) {\n this.extendFaroSession(this.config, this.logDebug);\n }\n }\n if (response.status === TOO_MANY_REQUESTS) {\n this.disabledUntil = this.getRetryAfterDate(response);\n this.logWarn(`Too many requests, backing off until ${this.disabledUntil}`);\n }\n // read the body so the connection can be closed\n response.text().catch(noop);\n return response;\n }))\n .catch((err) => {\n this.logError('Failed sending payload to the receiver\\n', JSON.parse(body), err);\n });\n });\n }\n catch (err) {\n this.logError(err);\n }\n });\n }\n getIgnoreUrls() {\n var _a;\n return [this.options.url].concat((_a = this.config.ignoreUrls) !== null && _a !== void 0 ? _a : []);\n }\n isBatched() {\n return true;\n }\n getRetryAfterDate(response) {\n const now = this.getNow();\n const retryAfterHeader = response.headers.get('Retry-After');\n if (retryAfterHeader) {\n const delay = Number(retryAfterHeader);\n if (!isNaN(delay)) {\n return new Date(delay * 1000 + now);\n }\n const date = Date.parse(retryAfterHeader);\n if (!isNaN(date)) {\n return new Date(date);\n }\n }\n return new Date(now + this.rateLimitBackoffMs);\n }\n extendFaroSession(config, logDebug) {\n const SessionExpiredString = `Session expired`;\n const sessionTrackingConfig = config.sessionTracking;\n if (sessionTrackingConfig === null || sessionTrackingConfig === void 0 ? void 0 : sessionTrackingConfig.enabled) {\n const { fetchUserSession, storeUserSession } = getSessionManagerByConfig(sessionTrackingConfig);\n getUserSessionUpdater({ fetchUserSession, storeUserSession })({ forceSessionExtend: true });\n logDebug(`${SessionExpiredString} created new session.`);\n }\n else {\n logDebug(`${SessionExpiredString}.`);\n }\n }\n}\n//# sourceMappingURL=transport.js.map","/**\n * Tail based throttle which caches the args of the last call and updates\n */\nexport function throttle(callback, delay) {\n let pause = false;\n let lastPending;\n const timeoutBehavior = () => {\n if (lastPending == null) {\n pause = false;\n return;\n }\n callback(...lastPending);\n lastPending = null;\n setTimeout(timeoutBehavior, delay);\n };\n return (...args) => {\n if (pause) {\n lastPending = args;\n return;\n }\n callback(...args);\n pause = true;\n setTimeout(timeoutBehavior, delay);\n };\n}\n//# sourceMappingURL=throttle.js.map","import { faro, isEmpty, isFunction, isString } from '@grafana/faro-core';\n/**\n * Retrieves a list of URLs to be ignored by aggregating the ignore URLs from all transports.\n *\n * @returns {string[]} An array of URLs to be ignored.\n */\nexport function getIgnoreUrls() {\n return faro.transports.transports.flatMap((transport) => transport.getIgnoreUrls());\n}\n/**\n * Checks if the given URL should be ignored based on a list of ignored URLs.\n *\n * @param url - The URL to check.\n * @returns `true` if the URL is in the list of ignored URLs, `false` otherwise.\n */\nexport function isUrlIgnored(url = '') {\n return getIgnoreUrls().some((ignoredUrl) => url && url.match(ignoredUrl) != null);\n}\n/**\n * Extracts a URL string from the given resource.\n *\n * @param resource - The input resource which can be a string, a URL object, or an object with a `toString` method.\n * @returns The URL as a string if the resource is a valid URL-like object, or `undefined` if the resource is not valid.\n *\n */\nexport function getUrlFromResource(resource) {\n if (isString(resource)) {\n return resource;\n }\n if (resource instanceof URL) {\n return resource.href;\n }\n if (!isEmpty(resource) && isFunction(resource === null || resource === void 0 ? void 0 : resource.toString)) {\n return resource.toString();\n }\n return undefined;\n}\n//# sourceMappingURL=url.js.map","import { faro } from '@grafana/faro-core';\nexport const webStorageType = {\n session: 'sessionStorage',\n local: 'localStorage',\n};\n/**\n * Check if selected web storage mechanism is available.\n * @param type storage mechanism to test availability for.\n * @returns\n */\nexport function isWebStorageAvailable(type) {\n var _a;\n try {\n let storage;\n storage = window[type];\n const testItem = '__faro_storage_test__';\n storage.setItem(testItem, testItem);\n storage.removeItem(testItem);\n return true;\n }\n catch (error) {\n // the above can throw\n (_a = faro.internalLogger) === null || _a === void 0 ? void 0 : _a.info(`Web storage of type ${type} is not available. Reason: ${error}`);\n return false;\n }\n}\n/**\n * Get item from SessionStorage or LocalStorage.\n * @param key: the item key.\n * @param webStorageMechanism: wether the item shall be received form local storage or session storage. Defaults to local storage.\n */\nexport function getItem(key, webStorageMechanism) {\n if (isWebStorageTypeAvailable(webStorageMechanism)) {\n return window[webStorageMechanism].getItem(key);\n }\n return null;\n}\n/**\n * Store item in SessionStorage or LocalStorage.\n * @param key: the item key.\n * @param value: the item data.\n * @param webStorageMechanism: wether the item shall be received form local storage or session storage. Defaults to local storage.\n */\nexport function setItem(key, value, webStorageMechanism) {\n if (isWebStorageTypeAvailable(webStorageMechanism)) {\n try {\n window[webStorageMechanism].setItem(key, value);\n }\n catch (error) {\n // do nothing\n }\n }\n}\n/**\n * Remove item from SessionStorage or LocalStorage.\n * @param key: the item key.\n * @param webStorageMechanism: wether the item shall be received form local storage or session storage. Defaults to local storage.\n */\nexport function removeItem(key, webStorageMechanism) {\n if (isWebStorageTypeAvailable(webStorageMechanism)) {\n window[webStorageMechanism].removeItem(key);\n }\n}\nexport const isLocalStorageAvailable = isWebStorageAvailable(webStorageType.local);\nexport const isSessionStorageAvailable = isWebStorageAvailable(webStorageType.session);\nfunction isWebStorageTypeAvailable(webStorageMechanism) {\n if (webStorageMechanism === webStorageType.local) {\n return isLocalStorageAvailable;\n }\n if (webStorageMechanism === webStorageType.session) {\n return isSessionStorageAvailable;\n }\n return false;\n}\n//# sourceMappingURL=webStorage.js.map","import { ATTR_SESSION_ID } from './semconv';\nexport class FaroMetaAttributesSpanProcessor {\n constructor(processor, metas) {\n this.processor = processor;\n this.metas = metas;\n }\n forceFlush() {\n return this.processor.forceFlush();\n }\n onStart(span, parentContext) {\n var _a;\n const session = this.metas.value.session;\n if (session === null || session === void 0 ? void 0 : session.id) {\n span.attributes[ATTR_SESSION_ID] = session.id;\n /**\n * @deprecated will be removed in the future and has been replaced by ATTR_SESSION_ID (session.id)\n */\n span.attributes['session_id'] = session.id;\n }\n const user = (_a = this.metas.value.user) !== null && _a !== void 0 ? _a : {};\n if (user.email) {\n span.attributes['user.email'] = user.email;\n }\n if (user.id) {\n span.attributes['user.id'] = user.id;\n }\n if (user.username) {\n span.attributes['user.name'] = user.username;\n }\n if (user.fullName) {\n span.attributes['user.full_name'] = user.fullName;\n }\n if (user.roles) {\n span.attributes['user.roles'] = user.roles.split(',').map((role) => role.trim());\n }\n if (user.hash) {\n span.attributes['user.hash'] = user.hash;\n }\n this.processor.onStart(span, parentContext);\n }\n onEnd(span) {\n this.processor.onEnd(span);\n }\n shutdown() {\n return this.processor.shutdown();\n }\n}\n//# sourceMappingURL=faroMetaAttributesSpanProcessor.js.map","import { ExportResultCode } from '@opentelemetry/core';\nimport { createExportTraceServiceRequest } from '@opentelemetry/otlp-transformer/build/src/trace/internal';\nimport { sendFaroEvents } from './faroTraceExporter.utils';\nexport class FaroTraceExporter {\n constructor(config) {\n this.config = config;\n }\n export(spans, resultCallback) {\n const traceEvent = createExportTraceServiceRequest(spans, { useHex: true, useLongBits: false });\n this.config.api.pushTraces(traceEvent);\n sendFaroEvents(traceEvent.resourceSpans);\n resultCallback({ code: ExportResultCode.SUCCESS });\n }\n shutdown() {\n return Promise.resolve(undefined);\n }\n}\n//# sourceMappingURL=faroTraceExporter.js.map","import { ESpanKind } from '@opentelemetry/otlp-transformer/build/src/trace/internal-types';\nimport { faro, unknownString } from '@grafana/faro-web-sdk';\nconst DURATION_NS_KEY = 'duration_ns';\nexport function sendFaroEvents(resourceSpans = []) {\n var _a, _b;\n for (const resourceSpan of resourceSpans) {\n const { scopeSpans } = resourceSpan;\n for (const scopeSpan of scopeSpans) {\n const { scope, spans = [] } = scopeSpan;\n for (const span of spans) {\n if (span.kind !== ESpanKind.SPAN_KIND_CLIENT) {\n continue;\n }\n const spanContext = {\n traceId: span.traceId.toString(),\n spanId: span.spanId.toString(),\n };\n const faroEventAttributes = {};\n for (const attribute of span.attributes) {\n faroEventAttributes[attribute.key] = String(Object.values(attribute.value)[0]);\n }\n // Add span duration in nanoseconds\n if (!Number.isNaN(span.endTimeUnixNano) && !Number.isNaN(span.startTimeUnixNano)) {\n faroEventAttributes[DURATION_NS_KEY] = String(Number(span.endTimeUnixNano) - Number(span.startTimeUnixNano));\n }\n const index = ((_a = scope === null || scope === void 0 ? void 0 : scope.name) !== null && _a !== void 0 ? _a : '').indexOf('-');\n let eventName = unknownString;\n if (scope === null || scope === void 0 ? void 0 : scope.name) {\n if (index === -1) {\n eventName = (_b = scope.name.split('/')[1]) !== null && _b !== void 0 ? _b : scope.name;\n }\n if (index > -1) {\n eventName = scope === null || scope === void 0 ? void 0 : scope.name.substring(index + 1);\n }\n }\n faro.api.pushEvent(`faro.tracing.${eventName}`, faroEventAttributes, undefined, {\n spanContext,\n // Convert nanoseconds to milliseconds\n timestampOverwriteMs: Number(span.endTimeUnixNano) / 1000000,\n customPayloadTransformer: (payload) => {\n var _a, _b;\n if (faroEventAttributes['faro.action.user.name'] != null &&\n faroEventAttributes['faro.action.user.parentId'] != null) {\n payload.action = {\n name: faroEventAttributes['faro.action.user.name'],\n parentId: faroEventAttributes['faro.action.user.parentId'],\n };\n (_a = payload.attributes) === null || _a === void 0 ? true : delete _a['faro.action.user.name'];\n (_b = payload.attributes) === null || _b === void 0 ? true : delete _b['faro.action.user.parentId'];\n }\n return payload;\n },\n });\n }\n }\n }\n}\n//# sourceMappingURL=faroTraceExporter.utils.js.map","import { SpanKind } from '@opentelemetry/api';\nimport { apiMessageBus, USER_ACTION_CANCEL, USER_ACTION_END, USER_ACTION_HALT, USER_ACTION_START, } from '@grafana/faro-web-sdk';\nexport class FaroUserActionSpanProcessor {\n constructor(processor) {\n this.processor = processor;\n apiMessageBus.subscribe((msg) => {\n if (msg.type === USER_ACTION_START) {\n this.message = msg;\n return;\n }\n if ([USER_ACTION_END, USER_ACTION_HALT, USER_ACTION_CANCEL].includes(msg.type)) {\n this.message = undefined;\n }\n });\n }\n forceFlush() {\n return this.processor.forceFlush();\n }\n onStart(span, parentContext) {\n var _a, _b;\n if (span.kind === SpanKind.CLIENT) {\n // If the span is created when the message object is available it is created before the user action timeout has been reached so it belongs to the user-action.\n // In this case we can add the user action name and parentId to the span attributes.\n // If the span is created after the user action timeout span, the message object will be undefined which means the action has been cancelled or is ended.\n if (this.message) {\n span.attributes['faro.action.user.name'] = (_a = this.message) === null || _a === void 0 ? void 0 : _a.name;\n span.attributes['faro.action.user.parentId'] = (_b = this.message) === null || _b === void 0 ? void 0 : _b.parentId;\n }\n }\n this.processor.onStart(span, parentContext);\n }\n onEnd(span) {\n this.processor.onEnd(span);\n }\n shutdown() {\n return this.processor.shutdown();\n }\n}\n//# sourceMappingURL=faroUserActionSpanProcessor.js.map","import { XMLHttpRequestInstrumentation } from '@opentelemetry/instrumentation-xml-http-request';\nimport { faro, getUrlFromResource } from '@grafana/faro-web-sdk';\nexport class FaroXhrInstrumentation extends XMLHttpRequestInstrumentation {\n constructor(config = {}) {\n super(config);\n const self = this;\n this.parentCreateSpan = self._createSpan.bind(this);\n }\n // Patching the parent's private method to handle url type string or URL\n _patchOpen() {\n return (original) => {\n const plugin = this;\n return function patchOpen(...args) {\n try {\n const method = args[0];\n let url = getUrlFromResource(args[1]);\n plugin.parentCreateSpan(this, url, method);\n }\n catch (error) {\n faro.internalLogger.error(error);\n }\n return original.apply(this, args);\n };\n };\n }\n}\n//# sourceMappingURL=faroXhrInstrumentation.js.map","var __rest = (this && this.__rest) || function (s, e) {\n var t = {};\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n t[p] = s[p];\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n t[p[i]] = s[p[i]];\n }\n return t;\n};\nimport { FetchInstrumentation } from '@opentelemetry/instrumentation-fetch';\nimport { FaroXhrInstrumentation } from './faroXhrInstrumentation';\nimport { fetchCustomAttributeFunctionWithDefaults, xhrCustomAttributeFunctionWithDefaults, } from './instrumentationUtils';\nexport function getDefaultOTELInstrumentations(options = {}) {\n const { fetchInstrumentationOptions, xhrInstrumentationOptions } = options, sharedOptions = __rest(options, [\"fetchInstrumentationOptions\", \"xhrInstrumentationOptions\"]);\n const fetchOpts = createFetchInstrumentationOptions(fetchInstrumentationOptions, sharedOptions);\n const xhrOpts = createXhrInstrumentationOptions(xhrInstrumentationOptions, sharedOptions);\n return [new FetchInstrumentation(fetchOpts), new FaroXhrInstrumentation(xhrOpts)];\n}\nfunction createFetchInstrumentationOptions(fetchInstrumentationOptions, sharedOptions) {\n return Object.assign(Object.assign(Object.assign(Object.assign({}, sharedOptions), { ignoreNetworkEvents: true }), fetchInstrumentationOptions), { \n // always keep this function\n applyCustomAttributesOnSpan: fetchCustomAttributeFunctionWithDefaults(fetchInstrumentationOptions === null || fetchInstrumentationOptions === void 0 ? void 0 : fetchInstrumentationOptions.applyCustomAttributesOnSpan) });\n}\nfunction createXhrInstrumentationOptions(xhrInstrumentationOptions, sharedOptions) {\n return Object.assign(Object.assign(Object.assign(Object.assign({}, sharedOptions), { ignoreNetworkEvents: true }), xhrInstrumentationOptions), { \n // always keep this function\n applyCustomAttributesOnSpan: xhrCustomAttributeFunctionWithDefaults(xhrInstrumentationOptions === null || xhrInstrumentationOptions === void 0 ? void 0 : xhrInstrumentationOptions.applyCustomAttributesOnSpan) });\n}\n//# sourceMappingURL=getDefaultOTELInstrumentations.js.map","import { context, trace } from '@opentelemetry/api';\nimport { W3CTraceContextPropagator } from '@opentelemetry/core';\nimport { registerInstrumentations } from '@opentelemetry/instrumentation';\nimport { defaultResource, resourceFromAttributes } from '@opentelemetry/resources';\nimport { BatchSpanProcessor, WebTracerProvider } from '@opentelemetry/sdk-trace-web';\nimport { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, ATTR_USER_AGENT_ORIGINAL, SEMRESATTRS_DEPLOYMENT_ENVIRONMENT, } from '@opentelemetry/semantic-conventions';\nimport { BaseInstrumentation, isArray, VERSION } from '@grafana/faro-web-sdk';\nimport { FaroMetaAttributesSpanProcessor } from './faroMetaAttributesSpanProcessor';\nimport { FaroTraceExporter } from './faroTraceExporter';\nimport { FaroUserActionSpanProcessor } from './faroUserActionSpanProcessor';\nimport { getDefaultOTELInstrumentations } from './getDefaultOTELInstrumentations';\nimport { getSamplingDecision } from './sampler';\nimport { ATTR_BROWSER_BRANDS, ATTR_BROWSER_LANGUAGE, ATTR_BROWSER_MOBILE, ATTR_BROWSER_PLATFORM, ATTR_DEPLOYMENT_ENVIRONMENT_NAME, ATTR_PROCESS_RUNTIME_NAME, ATTR_PROCESS_RUNTIME_VERSION, ATTR_SERVICE_NAMESPACE, ATTR_TELEMETRY_DISTRO_NAME, ATTR_TELEMETRY_DISTRO_VERSION, } from './semconv';\n// the providing of app name here is not great\n// should delay initialization and provide the full Faro config,\n// taking app name from it\nexport class TracingInstrumentation extends BaseInstrumentation {\n constructor(options = {}) {\n super();\n this.options = options;\n this.name = '@grafana/faro-web-tracing';\n this.version = VERSION;\n }\n initialize() {\n var _a, _b, _c, _d, _e;\n const options = this.options;\n const attributes = {};\n if (this.config.app.name) {\n attributes[ATTR_SERVICE_NAME] = this.config.app.name;\n }\n if (this.config.app.namespace) {\n attributes[ATTR_SERVICE_NAMESPACE] = this.config.app.namespace;\n }\n if (this.config.app.version) {\n attributes[ATTR_SERVICE_VERSION] = this.config.app.version;\n }\n if (this.config.app.environment) {\n attributes[ATTR_DEPLOYMENT_ENVIRONMENT_NAME] = this.config.app.environment;\n /**\n * @deprecated will be removed in the future and has been replaced by ATTR_DEPLOYMENT_ENVIRONMENT_NAME (deployment.environment.name)\n */\n attributes[SEMRESATTRS_DEPLOYMENT_ENVIRONMENT] = this.config.app.environment;\n }\n const browserMeta = this.metas.value.browser;\n if (isArray(browserMeta === null || browserMeta === void 0 ? void 0 : browserMeta.brands)) {\n attributes[ATTR_BROWSER_BRANDS] = browserMeta.brands.map((entry) => entry.brand);\n }\n if (browserMeta === null || browserMeta === void 0 ? void 0 : browserMeta.language) {\n attributes[ATTR_BROWSER_LANGUAGE] = browserMeta.language;\n }\n if (typeof (browserMeta === null || browserMeta === void 0 ? void 0 : browserMeta.mobile) === 'boolean') {\n attributes[ATTR_BROWSER_MOBILE] = Boolean(browserMeta.mobile);\n }\n if (browserMeta === null || browserMeta === void 0 ? void 0 : browserMeta.os) {\n attributes[ATTR_BROWSER_PLATFORM] = browserMeta.os;\n }\n if (browserMeta === null || browserMeta === void 0 ? void 0 : browserMeta.userAgent) {\n attributes[ATTR_USER_AGENT_ORIGINAL] = browserMeta.userAgent;\n }\n attributes[ATTR_PROCESS_RUNTIME_NAME] = 'browser';\n attributes[ATTR_PROCESS_RUNTIME_VERSION] = (_a = this.metas.value.browser) === null || _a === void 0 ? void 0 : _a.userAgent;\n attributes[ATTR_TELEMETRY_DISTRO_NAME] = 'faro-web-sdk';\n attributes[ATTR_TELEMETRY_DISTRO_VERSION] = VERSION;\n Object.assign(attributes, options.resourceAttributes);\n const resource = defaultResource().merge(resourceFromAttributes(attributes));\n const provider = new WebTracerProvider({\n resource,\n sampler: {\n shouldSample: () => {\n return {\n decision: getSamplingDecision(this.api.getSession()),\n };\n },\n },\n spanProcessors: [\n (_b = options.spanProcessor) !== null && _b !== void 0 ? _b : new FaroUserActionSpanProcessor(new FaroMetaAttributesSpanProcessor(new BatchSpanProcessor(new FaroTraceExporter({ api: this.api }), {\n scheduledDelayMillis: TracingInstrumentation.SCHEDULED_BATCH_DELAY_MS,\n maxExportBatchSize: 30,\n }), this.metas)),\n ],\n });\n provider.register({\n propagator: (_c = options.propagator) !== null && _c !== void 0 ? _c : new W3CTraceContextPropagator(),\n contextManager: options.contextManager,\n });\n const { propagateTraceHeaderCorsUrls, fetchInstrumentationOptions, xhrInstrumentationOptions } = (_d = this.options.instrumentationOptions) !== null && _d !== void 0 ? _d : {};\n registerInstrumentations({\n instrumentations: (_e = options.instrumentations) !== null && _e !== void 0 ? _e : getDefaultOTELInstrumentations({\n ignoreUrls: this.getIgnoreUrls(),\n propagateTraceHeaderCorsUrls,\n fetchInstrumentationOptions,\n xhrInstrumentationOptions,\n }),\n });\n this.api.initOTEL(trace, context);\n }\n getIgnoreUrls() {\n return this.transports.transports.flatMap((transport) => transport.getIgnoreUrls());\n }\n}\nTracingInstrumentation.SCHEDULED_BATCH_DELAY_MS = 1000;\n//# sourceMappingURL=instrumentation.js.map","import { SpanStatusCode } from '@opentelemetry/api';\n/**\n * Adds HTTP status code to every span.\n *\n * The fetch instrumentation does not always set the span status to error as defined by the spec.\n * To work around that issue we manually set the span status.\n *\n * Issue: https://github.com/open-telemetry/opentelemetry-js/issues/3564\n * Spec: https://github.com/open-telemetry/opentelemetry-specification/blob/v1.20.0/specification/trace/semantic_conventions/http.md#status\n */\nexport function setSpanStatusOnFetchError(span, _request, result) {\n const httpStatusCode = result instanceof Error ? 0 : result.status;\n setSpanStatus(span, httpStatusCode);\n}\nexport function setSpanStatusOnXMLHttpRequestError(span, xhr) {\n setSpanStatus(span, xhr.status);\n}\nfunction setSpanStatus(span, httpStatusCode) {\n if (httpStatusCode == null) {\n return;\n }\n const isError = httpStatusCode === 0;\n const isClientOrServerError = httpStatusCode >= 400 && httpStatusCode < 600;\n if (isError || isClientOrServerError) {\n span.setStatus({ code: SpanStatusCode.ERROR });\n }\n}\nexport function fetchCustomAttributeFunctionWithDefaults(callback) {\n return (span, request, result) => {\n setSpanStatusOnFetchError(span, request, result);\n callback === null || callback === void 0 ? void 0 : callback(span, request, result);\n };\n}\nexport function xhrCustomAttributeFunctionWithDefaults(callback) {\n return (span, xhr) => {\n setSpanStatusOnXMLHttpRequestError(span, xhr);\n callback === null || callback === void 0 ? void 0 : callback(span, xhr);\n };\n}\n//# sourceMappingURL=instrumentationUtils.js.map","import { SamplingDecision } from '@opentelemetry/sdk-trace-web';\nexport function getSamplingDecision(sessionMeta = {}) {\n var _a;\n const isSessionSampled = ((_a = sessionMeta.attributes) === null || _a === void 0 ? void 0 : _a['isSampled']) === 'true';\n const samplingDecision = isSessionSampled ? SamplingDecision.RECORD_AND_SAMPLED : SamplingDecision.NOT_RECORD;\n return samplingDecision;\n}\n//# sourceMappingURL=sampler.js.map","/**\n Unstable SemConv\n Because the \"incubating\" entry-point may include breaking changes in minor versions,\n it is recommended that instrumentation libraries not import @opentelemetry/semantic-conventions/incubating in runtime code,\n but instead copy relevant definitions into their own code base. (This is the same recommendation as for other languages.)\n \n See: https://www.npmjs.com/package/@opentelemetry/semantic-conventions#:~:text=%7D)%3B-,Unstable%20SemConv,-Because%20the%20%22incubating\n */\nexport const ATTR_SESSION_ID = 'session.id';\nexport const ATTR_DEPLOYMENT_ENVIRONMENT_NAME = 'deployment.environment.name';\nexport const ATTR_SERVICE_NAMESPACE = 'service.namespace';\n// https://opentelemetry.io/docs/specs/semconv/resource/process/#javascript-runtimes\nexport const ATTR_PROCESS_RUNTIME_NAME = 'process.runtime.name';\nexport const ATTR_PROCESS_RUNTIME_VERSION = 'process.runtime.version';\n// https://opentelemetry.io/docs/specs/semconv/attributes-registry/telemetry/#telemetry-attributes\nexport const ATTR_TELEMETRY_DISTRO_NAME = 'telemetry.distro.name';\nexport const ATTR_TELEMETRY_DISTRO_VERSION = 'telemetry.distro.version';\n// https://opentelemetry.io/docs/specs/semconv/resource/browser/\nexport const ATTR_BROWSER_BRANDS = 'browser.brands';\nexport const ATTR_BROWSER_LANGUAGE = 'browser.language';\nexport const ATTR_BROWSER_MOBILE = 'browser.mobile';\nexport const ATTR_BROWSER_PLATFORM = 'browser.platform';\n//# sourceMappingURL=semconv.js.map"],"names":[],"sourceRoot":""}