@pucp-gidis-hiisc/esm-fua-app 1.0.0

package/dist/vendors-node_modules_openmrs_esm-framework_src_internal_ts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vendors-node_modules_openmrs_esm-framework_src_internal_ts.js","mappings":"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O,OAAO,EAAE,mBAAO,CAAC,gGAAgB;AACxC,YAAY,mBAAO,CAAC,oGAAkB;AACtC,cAAc,mBAAO,CAAC,sGAAmB;AACzC,eAAe,mBAAO,CAAC,6FAAU;AACjC,cAAc,mBAAO,CAAC,2FAAS;;;;;;;;;;;AC1I/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,mDAAmD,MAAM;AACzD;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe;AACf,aAAa;AACb;AACA,SAAS;AACT;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;;AAEA,oBAAoB,qBAAqB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,mBAAmB,mBAAO,CAAC,qGAAc;AACzC,cAAc,mBAAO,CAAC,sGAAmB;AACzC,eAAe,mBAAO,CAAC,6FAAU;AACjC;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,EAAE,mBAAO,CAAC,gGAAgB;;AAE5B;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;;AAEL;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AAC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AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;;;;;;;;;;AC9cA,cAAc,mBAAO,CAAC,sGAAmB;AACzC,QAAQ,+BAA+B,EAAE,mBAAO,CAAC,8GAAuB;AACxE,QAAQ,QAAQ,EAAE,mBAAO,CAAC,gGAAgB;;AAE1C,QAAQ,qBAAqB,EAAE,mBAAO,CAAC,kHAAyB;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,MAAM;AACN,8CAA8C,QAAQ;AACtD;;AAEA;AACA;AACA,kCAAkC,YAAY;AAC9C;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,8CAA8C,QAAQ;AACtD;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA;AACA;;AAEA;AACA,sBAAsB,WAAW,GAAG,WAAW,GAAG,WAAW;AAC7D;AACA,0BAA0B,0BAA0B;AACpD;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAM;AACN;AACA,MAAM;AACN;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA,MAAM;AACN;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA,MAAM;AACN;;AAEA;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;;AAEA;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,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;;AAEA;AACA,uDAAuD,QAAQ;AAC/D;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjSA,cAAc,mBAAO,CAAC,6FAAS;AAC/B;AACA;AACA;AACA;AACA;;;;;;;;;;;ACLA,WAAW,mBAAO,CAAC,uFAAM;AACzB,YAAY,mBAAO,CAAC,yFAAO;AAC3B,WAAW,mBAAO,CAAC,uFAAM;AACzB,YAAY,mBAAO,CAAC,yFAAO;AAC3B,WAAW,mBAAO,CAAC,uFAAM;AACzB,YAAY,mBAAO,CAAC,yFAAO;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,+CAA+C,GAAG;AAClD;AACA;AACA;;;;;;;;;;;AC/CA,eAAe,mBAAO,CAAC,sGAAmB;AAC1C,cAAc,mBAAO,CAAC,6FAAS;AAC/B,OAAO,OAAO,EAAE,mBAAO,CAAC,gGAAgB;;AAExC;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,kBAAkB,SAAS,GAAG,gBAAgB,GAAG,gBAAgB;AACjE;AACA;;;;;;;;;;;AClDA,eAAe,mBAAO,CAAC,sGAAmB;AAC1C;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;ACNA,gBAAgB,mBAAO,CAAC,iGAAW;AACnC;AACA;;;;;;;;;;;ACFA,eAAe,mBAAO,CAAC,sGAAmB;AAC1C;AACA;;AAEA;;;;;;;;;;;ACJA,cAAc,mBAAO,CAAC,6FAAS;AAC/B,WAAW,mBAAO,CAAC,uFAAM;;AAEzB;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;ACtBA,gBAAgB,mBAAO,CAAC,iGAAW;AACnC;AACA;;;;;;;;;;;ACFA,gBAAgB,mBAAO,CAAC,iGAAW;AACnC;AACA;;;;;;;;;;;ACFA,gBAAgB,mBAAO,CAAC,iGAAW;AACnC;AACA;;;;;;;;;;;ACFA,eAAe,mBAAO,CAAC,sGAAmB;;AAE1C;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;;;;;;;;;;;ACdA,gBAAgB,mBAAO,CAAC,iGAAW;AACnC;AACA;;;;;;;;;;;ACFA,gBAAgB,mBAAO,CAAC,iGAAW;AACnC;AACA;;;;;;;;;;;ACFA,eAAe,mBAAO,CAAC,sGAAmB;AAC1C;AACA;;;;;;;;;;;ACFA,eAAe,mBAAO,CAAC,sGAAmB;AAC1C;AACA;;;;;;;;;;;ACFA,gBAAgB,mBAAO,CAAC,iGAAW;AACnC;AACA;;;;;;;;;;;ACFA,OAAO,YAAY,EAAE,mBAAO,CAAC,8GAAuB;AACpD,QAAQ,QAAQ,EAAE,mBAAO,CAAC,gGAAgB;AAC1C,eAAe,mBAAO,CAAC,sGAAmB;;AAE1C;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,IAAI;AACJ;AACA;AACA;;AAEA;;;;;;;;;;;ACpCA,eAAe,mBAAO,CAAC,sGAAmB;AAC1C;AACA;;;;;;;;;;;ACFA,cAAc,mBAAO,CAAC,6FAAS;AAC/B;AACA;AACA;AACA;AACA;;;;;;;;;;;ACLA,gBAAgB,mBAAO,CAAC,iGAAW;AACnC;AACA;;;;;;;;;;;ACFA,qBAAqB,mBAAO,CAAC,6GAAiB;AAC9C;AACA;;;;;;;;;;;ACFA,cAAc,mBAAO,CAAC,oGAAkB;AACxC;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;;;;;;;;;;;ACTA,qBAAqB,mBAAO,CAAC,6GAAiB;AAC9C;AACA;;;;;;;;;;;ACFA,cAAc,mBAAO,CAAC,6FAAS;AAC/B;AACA;AACA;AACA;AACA;;;;;;;;;;;ACLA;AACA,mBAAmB,mBAAO,CAAC,+FAAe;AAC1C;AACA;AACA;AACA;AACA,uBAAuB,wJAAmD;AAC1E,UAAU,mBAAO,CAAC,qGAAkB;AACpC,sBAAsB,2JAAoD;AAC1E,uBAAuB,4JAAqD;AAC5E,SAAS,mBAAO,CAAC,uGAAmB;AACpC,SAAS,mBAAO,CAAC,uGAAmB;AACpC,SAAS,mBAAO,CAAC,uGAAmB;AACpC,OAAO,mBAAO,CAAC,mGAAiB;AAChC,QAAQ,mBAAO,CAAC,qGAAkB;AAClC,SAAS,mBAAO,CAAC,uGAAmB;AACpC,SAAS,mBAAO,CAAC,uGAAmB;AACpC,SAAS,mBAAO,CAAC,uGAAmB;AACpC,cAAc,mBAAO,CAAC,iHAAwB;AAC9C,WAAW,mBAAO,CAAC,2GAAqB;AACxC,YAAY,mBAAO,CAAC,6GAAsB;AAC1C,gBAAgB,mBAAO,CAAC,uHAA2B;AACnD,gBAAgB,mBAAO,CAAC,uHAA2B;AACnD,QAAQ,mBAAO,CAAC,qGAAkB;AAClC,SAAS,mBAAO,CAAC,uGAAmB;AACpC,MAAM,mBAAO,CAAC,iGAAgB;AAC9B,MAAM,mBAAO,CAAC,iGAAgB;AAC9B,MAAM,mBAAO,CAAC,iGAAgB;AAC9B,OAAO,mBAAO,CAAC,mGAAiB;AAChC,OAAO,mBAAO,CAAC,mGAAiB;AAChC,OAAO,mBAAO,CAAC,mGAAiB;AAChC,OAAO,mBAAO,CAAC,mGAAiB;AAChC,UAAU,mBAAO,CAAC,yGAAoB;AACtC,cAAc,mBAAO,CAAC,6GAAsB;AAC5C,SAAS,mBAAO,CAAC,mGAAiB;AAClC,aAAa,mBAAO,CAAC,+GAAuB;AAC5C,iBAAiB,mBAAO,CAAC,mHAAyB;AAClD,iBAAiB,mBAAO,CAAC,mHAAyB;AAClD,iBAAiB,mBAAO,CAAC,mHAAyB;AAClD,cAAc,mBAAO,CAAC,6GAAsB;AAC5C,cAAc,mBAAO,CAAC,iGAAgB;AACtC,WAAW,mBAAO,CAAC,qGAAkB;AACrC,OAAO,mBAAO,CAAC,6FAAc;AAC7B,OAAO,mBAAO,CAAC,6FAAc;AAC7B,cAAc,mBAAO,CAAC,2GAAqB;AAC3C,iBAAiB,mBAAO,CAAC,uGAAmB;AAC5C,UAAU,mBAAO,CAAC,mGAAiB;AACnC;;;;;;;;;;;AC/CA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACRA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;;;;;;;;;;ACtBA,QAAQ,4BAA4B,EAAE,mBAAO,CAAC,oGAAa;AAC3D,cAAc,mBAAO,CAAC,4FAAS;AAC/B;;AAEA;AACA,WAAW,UAAU;AACrB,YAAY,WAAW;AACvB,UAAU,SAAS;AACnB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA,+BAA+B,yBAAyB;AACxD,uBAAuB,yBAAyB;AAChD,uBAAuB,yBAAyB;;AAEhD,oCAAoC,8BAA8B;AAClE,4BAA4B,8BAA8B;AAC1D,4BAA4B,8BAA8B;;AAE1D;AACA;;AAEA,0CAA0C;AAC1C,CAAC,GAAG,4BAA4B;;AAEhC,+CAA+C;AAC/C,CAAC,GAAG,4BAA4B;;AAEhC;AACA;AACA;;AAEA,kCAAkC;AAClC,CAAC,QAAQ,4BAA4B;;AAErC,wCAAwC;AACxC,CAAC,QAAQ,iCAAiC;;AAE1C;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA,+BAA+B;AAC/B,CAAC,QAAQ,uBAAuB;;AAEhC;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,8BAA8B;AAC9B,CAAC,EAAE,kBAAkB;AACrB,eAAe;;AAEf,wBAAwB,iBAAiB;;AAEzC;AACA;AACA;AACA,qCAAqC;AACrC,CAAC,EAAE,uBAAuB;AAC1B,eAAe;;AAEf,yBAAyB,kBAAkB;;AAE3C;;AAEA;AACA;AACA;AACA,wCAAwC,8BAA8B;AACtE,mCAAmC,yBAAyB;;AAE5D,uCAAuC,wBAAwB;AAC/D,6BAA6B,wBAAwB;AACrD,6BAA6B,wBAAwB;AACrD,yBAAyB,kBAAkB;AAC3C,kCAAkC;AAClC;;AAEA,4CAA4C,6BAA6B;AACzE,kCAAkC,6BAA6B;AAC/D,kCAAkC,6BAA6B;AAC/D,8BAA8B,uBAAuB;AACrD,uCAAuC;AACvC;;AAEA,0BAA0B,YAAY,MAAM,mBAAmB;AAC/D,+BAA+B,YAAY,MAAM,wBAAwB;;AAEzE;AACA;AACA,yBAAyB;AACzB,oBAAoB,IAAI,EAAE,2BAA2B;AACrD,0BAA0B,IAAI,2BAA2B;AACzD,0BAA0B,IAAI,2BAA2B;AACzD;AACA;;AAEA;AACA;AACA;;AAEA,kCAAkC,iBAAiB;AACnD,wBAAwB;;AAExB,yBAAyB,iBAAiB,EAAE,mBAAmB;AAC/D,8BAA8B,iBAAiB,EAAE,wBAAwB;;AAEzE;AACA;AACA;;AAEA,kCAAkC,iBAAiB;AACnD,wBAAwB;;AAExB,yBAAyB,iBAAiB,EAAE,mBAAmB;AAC/D,8BAA8B,iBAAiB,EAAE,wBAAwB;;AAEzE;AACA,mCAAmC,YAAY,OAAO,kBAAkB;AACxE,8BAA8B,YAAY,OAAO,iBAAiB;;AAElE;AACA;AACA,uCAAuC;AACvC,CAAC,OAAO,kBAAkB,GAAG,mBAAmB;AAChD,6BAA6B;;AAE7B;AACA;AACA;AACA;AACA,oCAAoC,mBAAmB;AACvD;AACA,uBAAuB,mBAAmB;AAC1C;;AAEA,yCAAyC,wBAAwB;AACjE;AACA,4BAA4B,wBAAwB;AACpD;;AAEA;AACA;AACA;AACA;AACA;;;;;;;;;;;ACrLA;AACA,gBAAgB,mBAAO,CAAC,8FAAW;AACnC;AACA;;;;;;;;;;;ACHA,cAAc,mBAAO,CAAC,oGAAkB;AACxC;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;ACNA,gBAAgB,mBAAO,CAAC,8FAAW;AACnC;AACA;AACA;;;;;;;;;;;ACHA,eAAe,mBAAO,CAAC,sGAAmB;AAC1C,cAAc,mBAAO,CAAC,oGAAkB;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;;;;;;;;;;ACxBA,eAAe,mBAAO,CAAC,sGAAmB;AAC1C,cAAc,mBAAO,CAAC,oGAAkB;AACxC;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;;;;;;;;;;ACvBA,eAAe,mBAAO,CAAC,sGAAmB;AAC1C,cAAc,mBAAO,CAAC,oGAAkB;AACxC,WAAW,mBAAO,CAAC,kGAAiB;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,kBAAkB,sBAAsB;AACxC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,oBAAoB;AACvE;AACA,KAAK;AACL;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;;;;;;;;;;ACxDA,eAAe,mBAAO,CAAC,sGAAmB;AAC1C,mBAAmB,mBAAO,CAAC,8GAAuB;AAClD,OAAO,KAAK;AACZ,cAAc,mBAAO,CAAC,oGAAkB;AACxC,kBAAkB,mBAAO,CAAC,gHAAwB;AAClD,WAAW,mBAAO,CAAC,kGAAiB;AACpC,WAAW,mBAAO,CAAC,kGAAiB;AACpC,YAAY,mBAAO,CAAC,oGAAkB;AACtC,YAAY,mBAAO,CAAC,oGAAkB;;AAEtC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,kBAAkB,sBAAsB;AACxC;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/EA;AACA;AACA;AACA,kBAAkB,mBAAO,CAAC,mHAA2B;AACrD,gBAAgB,mBAAO,CAAC,+GAAyB;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,IAAI;AAC3B;AACA,uBAAuB,IAAI;AAC3B;AACA,qBAAqB,KAAK,IAAI,IAAI;AAClC;AACA;AACA;AACA;AACA;;;;;;;;;;;AC3CA,cAAc,mBAAO,CAAC,uGAAqB;AAC3C,QAAQ,MAAM,EAAE,mBAAO,CAAC,iHAA0B;AAClD,kBAAkB,mBAAO,CAAC,mHAA2B;AACrD,gBAAgB,mBAAO,CAAC,+GAAyB;;AAEjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC1JA,cAAc,mBAAO,CAAC,oGAAkB;;AAExC;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACPA,cAAc,mBAAO,CAAC,oGAAkB;AACxC;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA","sources":["webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-dynamic-loading/dist/dynamic-loading.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-dynamic-loading/dist/index.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-expression-evaluator/dist/extractor.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-expression-evaluator/dist/index.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-framework/src/internal.ts","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-routes/dist/constants.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-routes/dist/index.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-routes/dist/loaders/app.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-routes/dist/loaders/components.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-routes/dist/loaders/helpers.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-routes/dist/loaders/index.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-routes/dist/loaders/pages.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-routes/dist/routes.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/dist/dates/index.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/dist/index.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/dist/retry.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/dist/storage.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/dist/test-helpers.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/dist/version.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/classes/comparator.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/classes/range.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/classes/semver.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/clean.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/cmp.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/coerce.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/compare-build.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/compare-loose.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/compare.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/diff.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/eq.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/gt.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/gte.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/inc.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/lt.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/lte.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/major.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/minor.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/neq.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/parse.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/patch.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/prerelease.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/rcompare.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/rsort.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/satisfies.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/sort.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/functions/valid.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/index.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/internal/constants.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/internal/debug.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/internal/identifiers.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/internal/re.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/ranges/gtr.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/ranges/intersects.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/ranges/ltr.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/ranges/max-satisfying.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/ranges/min-satisfying.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/ranges/min-version.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/ranges/outside.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/ranges/simplify.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/ranges/subset.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/ranges/to-comparators.js","webpack://@pucp-gidis-hiisc/esm-dyaku-app/../../node_modules/@openmrs/esm-utils/node_modules/semver/ranges/valid.js"],"sourcesContent":["/** @module @category Dynamic Loading */ 'use strict';\n// hack to make the types defined in esm-globals available here\nimport { dispatchToastShown } from \"@openmrs/esm-globals\";\nimport { getCoreTranslation } from \"@openmrs/esm-translations\";\n/**\n * @internal\n *\n * Transforms an ESM module name to a valid JS identifier\n *\n * @param name the name of a module\n * @returns An opaque, equivalent JS identifier for the module\n */ export function slugify(name) {\n    return name.replace(/[\\/\\-@]/g, '_');\n}\n/**\n * Loads the named export from a named package. This might be used like:\n *\n * ```js\n * const { someComponent } = importDynamic(\"@openmrs/esm-template-app\")\n * ```\n *\n * @param jsPackage The package to load the export from.\n * @param share Indicates the name of the shared module; this is an advanced feature if the package you are loading\n *   doesn't use the default OpenMRS shared module name \"./start\".\n * @param options Additional options to control loading this script.\n * @param options.importMap The import map to use to load the script. This is useful for situations where you're\n *   loading multiple scripts at a time, since it allows the calling code to supply an importMap, saving multiple\n *   calls to `getCurrentImportMap()`.\n * @param options.maxLoadingTime A positive integer representing the maximum number of milliseconds to wait for the\n *   script to load before the promise returned from this function will be rejected. Defaults to 600,000 milliseconds,\n *   i.e., 10 minutes.\n */ export async function importDynamic(jsPackage, share = './start', options) {\n    // default to 10 minutes\n    const maxLoadingTime = !options?.maxLoadingTime || options.maxLoadingTime <= 0 ? 600000 : options.maxLoadingTime;\n    let timeout = undefined;\n    await Promise.race([\n        preloadImport(jsPackage, options?.importMap),\n        new Promise((_, reject)=>{\n            timeout = setTimeout(()=>{\n                reject(new Error(`Could not resolve requested script, ${jsPackage}, within ${humanReadableMs(maxLoadingTime)}.`));\n            }, maxLoadingTime);\n        })\n    ]);\n    timeout && clearTimeout(timeout);\n    const jsPackageSlug = slugify(jsPackage);\n    const container = window[jsPackageSlug];\n    if (!isFederatedModule(container)) {\n        const error = `The global variable ${jsPackageSlug} does not refer to a federated module`;\n        console.error(error);\n        throw new Error(error);\n    }\n    container.init(__webpack_share_scopes__.default);\n    const factory = await container.get(share);\n    const module = factory();\n    if (!(typeof module === 'object') || module === null) {\n        const error = `Container for ${jsPackage} did not return an ESM module as expected`;\n        console.error(error);\n        throw new Error(error);\n    }\n    return module;\n}\n/**\n * Utility function to convert milliseconds into human-readable strings with rather absurd\n * levels of precision.\n *\n * @param ms Number of milliseconds\n * @returns A human-readable string useful only for error logging, where we can assume English\n */ function humanReadableMs(ms) {\n    if (ms < 1000) {\n        return `${ms} milliseconds`;\n    } else if (ms < 60000) {\n        return `${Math.floor(ms / 1000)} seconds`;\n    } else if (ms < 3600000) {\n        return `${Math.floor(ms / 60000)} minutes`;\n    } else if (ms < 86400000) {\n        return `${Math.floor(ms / 3600000)} hours`;\n    } else {\n        return `${Math.floor(ms / 86400000)} days`;\n    }\n}\n/**\n * @internal\n *\n * This internal method is used to ensure that the script belonging\n * to the given package is loaded and added to the head.\n *\n * @param jsPackage The package to load\n * @param importMap The import map to use for loading this package.\n *  The main reason for specifying this is to avoid needing to call\n *  `getCurrentPageMap()` for every script when bulk loading.\n */ export async function preloadImport(jsPackage, importMap) {\n    if (typeof jsPackage !== 'string' || jsPackage.trim().length === 0) {\n        const error = 'Attempted to call importDynamic() without supplying a package to load';\n        console.error(error);\n        throw new Error(error);\n    }\n    const jsPackageSlug = slugify(jsPackage);\n    if (!window[jsPackageSlug]) {\n        const activeImportMap = importMap ?? await getCurrentImportMap();\n        if (!activeImportMap.imports.hasOwnProperty(jsPackage)) {\n            const error = `Could not find the package ${jsPackage} defined in the current importmap`;\n            console.error(error);\n            throw new Error(error);\n        }\n        let url = activeImportMap.imports[jsPackage];\n        if (url.startsWith('./')) {\n            url = window.spaBase + url.substring(1);\n        }\n        const isOverridden = !!window.localStorage.getItem(`import-map-override:${jsPackage}`);\n        try {\n            return await new Promise((resolve, reject)=>{\n                loadScript(url, resolve, reject);\n            });\n        } catch (err) {\n            if (isOverridden) {\n                dispatchToastShown({\n                    kind: 'error',\n                    title: getCoreTranslation('scriptLoadingFailed', 'Error: Script failed to load'),\n                    description: getCoreTranslation('scriptLoadingError', 'Failed to load overridden script from {{- url}}. Please check that the bundled script is available at the expected URL. Click the button below to reset all import map overrides.', {\n                        url\n                    }),\n                    actionButtonLabel: getCoreTranslation('resetOverrides', 'Reset overrides'),\n                    onActionButtonClick () {\n                        window.importMapOverrides.resetOverrides();\n                        window.location.reload();\n                    }\n                });\n            }\n            return Promise.reject(err);\n        }\n    }\n    return Promise.resolve();\n}\n/**\n * @internal\n *\n * Used to load the current import map\n *\n * @returns The current page map\n */ export async function getCurrentImportMap() {\n    return window.importMapOverrides.getCurrentPageMap();\n}\nfunction isFederatedModule(a) {\n    return typeof a === 'object' && a !== null && 'init' in a && typeof a['init'] === 'function' && 'get' in a && typeof a['get'] === 'function';\n}\n// internals to track script loading\n// basically, if we're already loading a script, we should wait until the script is loaded\n// we use a global to track this\nconst OPENMRS_SCRIPT_LOADING = Symbol('__openmrs_script_loading');\n/**\n * Appends a `<script>` to the DOM with the given URL.\n */ function loadScript(url, resolve, reject) {\n    const scriptElement = document.head.querySelector(`script[src=\"${url}\"]`);\n    let scriptLoading = window[OPENMRS_SCRIPT_LOADING];\n    if (!scriptLoading) {\n        scriptLoading = window[OPENMRS_SCRIPT_LOADING] = new Set([]);\n    }\n    if (!scriptElement) {\n        scriptLoading.add(url);\n        const element = document.createElement('script');\n        element.src = url;\n        element.type = 'text/javascript';\n        element.async = true;\n        // loadTime() displays an error if a script takes more than 5 seconds to load\n        const loadTimeout = setTimeout(()=>{\n            console.error(`The script at ${url} did not load within 5 seconds. This may indicate an issue with the imports in the script's entry-point file or with the script's bundler configuration.`);\n        }, 5000); // 5 seconds; this is arbitrary\n        let loadFn, errFn, finishScriptLoading;\n        finishScriptLoading = ()=>{\n            clearTimeout(loadTimeout);\n            scriptLoading.delete(url);\n            loadFn && element.removeEventListener('load', loadFn);\n            errFn && element.removeEventListener('error', errFn);\n        };\n        loadFn = ()=>{\n            finishScriptLoading();\n            resolve(null);\n        };\n        errFn = (ev)=>{\n            finishScriptLoading();\n            const msg = `Failed to load script from ${url}`;\n            console.error(msg, ev);\n            reject(ev.message ?? msg);\n        };\n        element.addEventListener('load', loadFn);\n        element.addEventListener('error', errFn);\n        document.head.appendChild(element);\n    } else {\n        if (scriptLoading.has(url)) {\n            let loadFn, errFn, finishScriptLoading;\n            finishScriptLoading = ()=>{\n                loadFn && scriptElement.removeEventListener('load', loadFn);\n                errFn && scriptElement.removeEventListener('error', errFn);\n            };\n            loadFn = ()=>{\n                finishScriptLoading();\n                resolve(null);\n            };\n            // this errFn does not log anything\n            errFn = (ev)=>{\n                finishScriptLoading();\n                reject(ev.message);\n            };\n            scriptElement.addEventListener('load', loadFn);\n            scriptElement.addEventListener('error', errFn);\n        } else {\n            console.warn(`Script at ${url} already loaded. Not loading it again.`);\n            resolve(null);\n        }\n    }\n}\n","export * from \"./dynamic-loading.js\";\n","/** @category Utility */ import { jsep } from \"./evaluator.js\";\nimport { globalsAsync } from \"./globals.js\";\n/**\n * `extractVariableNames()` is a companion function for `evaluate()` and `evaluateAsync()` which extracts the\n * names of all unbound identifiers used in the expression. The idea is to be able to extract all of the names\n * of variables that will need to be supplied in order to correctly process the expression.\n *\n * @example\n * ```ts\n * // variables will be ['isEmpty', 'array']\n * const variables = extractVariableNames('!isEmpty(array)')\n * ```\n *\n * An identifier is considered \"unbound\" if it is not a reference to the property of an object, is not defined\n * as a parameter to an inline arrow function, and is not a global value. E.g.,\n *\n * @example\n * ```ts\n * // variables will be ['obj']\n * const variables = extractVariableNames('obj.prop()')\n * ```\n *\n * @example\n * ```ts\n * // variables will be ['arr', 'needle']\n * const variables = extractVariableNames('arr.filter(v => v === needle)')\n * ```\n *\n @example\n * ```ts\n * // variables will be ['myVar']\n * const  variables = extractVariableNames('new String(myVar)')\n * ```\n *\n * Note that because this expression evaluator uses a restricted definition of \"global\" there are some Javascript\n * globals that will be reported as a unbound expression. This is expected because the evaluator will still fail\n * on these expressions.\n */ export function extractVariableNames(expression) {\n    if (typeof expression !== 'string' && (typeof expression !== 'object' || !expression || !('type' in expression))) {\n        throw `Unknown expression type ${expression}. Expressions must either be a string or pre-compiled string.`;\n    }\n    const context = createAsynchronousContext();\n    visitExpression(typeof expression === 'string' ? jsep(expression) : expression, context);\n    return [\n        ...context.variables\n    ];\n}\nfunction visitExpression(expression, context) {\n    switch(expression.type){\n        case 'UnaryExpression':\n            return visitUnaryExpression(expression, context);\n        case 'BinaryExpression':\n            return visitBinaryExpression(expression, context);\n        case 'ConditionalExpression':\n            return visitConditionalExpression(expression, context);\n        case 'CallExpression':\n            return visitCallExpression(expression, context);\n        case 'ArrowFunctionExpression':\n            return visitArrowFunctionExpression(expression, context);\n        case 'MemberExpression':\n            return visitMemberExpression(expression, context);\n        case 'ArrayExpression':\n            return visitArrayExpression(expression, context);\n        case 'SequenceExpression':\n            return visitSequenceExpression(expression, context);\n        case 'NewExpression':\n            return visitNewExpression(expression, context);\n        case 'Literal':\n            return visitLiteral(expression, context);\n        case 'Identifier':\n            return visitIdentifier(expression, context);\n        case 'TemplateLiteral':\n            return visitTemplateLiteral(expression, context);\n        case 'TemplateElement':\n            return visitTemplateElement(expression, context);\n        default:\n            throw `Expression evaluator does not support expression of type '${expression.type}'`;\n    }\n}\nfunction visitUnaryExpression(expression, context) {\n    return visitExpression(expression.argument, context);\n}\nfunction visitBinaryExpression(expression, context) {\n    const left = visitExpression(expression.left, context);\n    const right = visitExpression(expression.right, context);\n    return [\n        left,\n        right\n    ].filter(Boolean);\n}\nfunction visitConditionalExpression(expression, context) {\n    const consequent = visitExpression(expression.consequent, context);\n    const test = visitExpression(expression.test, context);\n    const alternate = visitExpression(expression.alternate, context);\n    return [\n        consequent,\n        test,\n        alternate\n    ].filter(Boolean);\n}\nfunction visitCallExpression(expression, context) {\n    const fn = visitExpression(expression.callee, context);\n    expression.arguments?.map(handleNullableExpression(context));\n    return fn;\n}\nfunction visitArrowFunctionExpression(expression, context) {\n    const newContext = {\n        ...context\n    };\n    newContext.isLocalExpression = true;\n    const params = expression.params?.map(handleNullableExpression(newContext)) ?? [];\n    const bodyVariables = visitExpression(expression.body, newContext) ?? [];\n    if (bodyVariables && Array.isArray(bodyVariables)) {\n        for (const v of bodyVariables){\n            if (!params.includes(v)) {\n                context.variables.add(v);\n            }\n        }\n    }\n}\nfunction visitMemberExpression(expression, context) {\n    visitExpression(expression.object, context);\n    const newContext = {\n        ...context\n    };\n    newContext.isLocalExpression = true;\n    visitExpression(expression.property, newContext);\n}\nfunction visitArrayExpression(expression, context) {\n    expression.elements?.map(handleNullableExpression(context));\n}\nfunction visitSequenceExpression(expression, context) {\n    expression.expressions?.map(handleNullableExpression(context));\n}\nfunction visitNewExpression(expression, context) {\n    expression.arguments?.map(handleNullableExpression(context));\n}\nfunction visitTemplateLiteral(expression, context) {\n    expression.expressions?.map(handleNullableExpression(context));\n    expression.quasis?.map(handleNullableExpression(context));\n}\nfunction visitTemplateElement(expression, context) {}\nfunction visitIdentifier(expression, context) {\n    if (!(expression.name in context.globals)) {\n        if (!context.isLocalExpression) {\n            context.variables.add(expression.name);\n        } else {\n            return expression.name;\n        }\n    }\n}\nfunction visitLiteral(expression, context) {}\nfunction createAsynchronousContext() {\n    return createContextInternal(globalsAsync);\n}\nfunction createContextInternal(globals_) {\n    const context = {\n        globals: {\n            ...globals_\n        },\n        isLocalExpression: false,\n        variables: new Set()\n    };\n    return context;\n}\nfunction handleNullableExpression(context) {\n    return function handleNullableExpressionInner(expression) {\n        if (expression === null) {\n            return null;\n        }\n        return visitExpression(expression, context);\n    };\n}\n","export * from \"./evaluator.js\";\nexport * from \"./extractor.js\";\n","export * from '@openmrs/esm-api';\nexport * from '@openmrs/esm-config';\nexport * from '@openmrs/esm-dynamic-loading';\nexport * from '@openmrs/esm-emr-api';\nexport * from '@openmrs/esm-error-handling';\nexport * from '@openmrs/esm-expression-evaluator';\nexport * from '@openmrs/esm-extensions';\nexport * from '@openmrs/esm-feature-flags';\nexport * from '@openmrs/esm-globals';\nexport * from '@openmrs/esm-navigation';\nexport * from '@openmrs/esm-offline';\nexport * from '@openmrs/esm-react-utils';\nexport * from '@openmrs/esm-routes';\nexport * from '@openmrs/esm-state';\nexport * from '@openmrs/esm-styleguide/src/internal';\nexport * from '@openmrs/esm-translations';\nexport * from '@openmrs/esm-utils';\n","export const localStorageRoutesPrefix = 'openmrs-routes:';\n","export * from \"./constants.js\";\nexport * from \"./loaders/index.js\";\nexport * from \"./routes.js\";\n","import { importDynamic } from \"@openmrs/esm-dynamic-loading\";\nimport { registerModuleLoad } from \"@openmrs/esm-config\";\nimport { emptyLifecycle } from \"./helpers.js\";\n/**\n * @internal\n *\n * Used internally to track which apps have had their `startupApp()` initializer called\n *\n * Values are promises to support asynchronous loading of the same app multiple times\n */ const initializedApps = new Map();\n/**\n * This function creates a loader function suitable for use in either a single-spa\n * application or parcel.\n *\n * The returned function is lazy and ensures that the appropriate module is loaded,\n * that the module's `startupApp()` is called before the component is loaded. It\n * then calls the component function, which should return either a single-spa\n * {@link LifeCycles} object or a {@link Promise} that will resolve to such an object.\n *\n * React-based pages or extensions should generally use the framework's\n * `getAsyncLifecycle()` or `getSyncLifecycle()` functions.\n *\n * @param routesAppName The app name of the routes.json file defining the component to load\n *\n * @param fullComponentName The name of the component to load. Note that this can optionally\n * include the appName to load the component from (in the format `${appName}#${componentName}`),\n * or omitted to implicitly use routesAppName\n *\n */ export function getLoader(routesAppName, fullComponentName) {\n    return async ()=>{\n        const poundIndex = fullComponentName.indexOf('#');\n        const isNamespaced = poundIndex >= 0;\n        const appName = isNamespaced ? fullComponentName.substring(0, poundIndex) : routesAppName;\n        const componentName = isNamespaced ? fullComponentName.substring(poundIndex + 1) : fullComponentName;\n        const module = await importDynamic(appName);\n        if (module && Object.hasOwn(module, componentName) && typeof module[componentName] === 'function') {\n            return initializeApp(appName, module).then(()=>module[componentName]());\n        } else {\n            if (!module) {\n                console.warn(`Unknown app ${appName} for ${fullComponentName} defined in ${routesAppName}'s routes.json`);\n            } else if (module && Object.hasOwn(module, componentName)) {\n                console.warn(`The export ${fullComponentName}, defined in ${routesAppName}'s routes.json, is not a function`);\n            } else {\n                console.warn(`${appName} does not define a component called \"${componentName}\", referenced in ${routesAppName}'s routes.json. This cannot be loaded.`);\n            }\n        }\n        return emptyLifecycle;\n    };\n}\n/**\n * This function can be used to manually initialize an application without waiting for the\n * framework to load it. This can sometimes be helpful if the framework doesn't load code\n * at the point you think is appropriate.\n *\n * This will ensure that the module is available and that it's `startupApp()` function (if\n * any) will be called. Note that these are only guaranteed to be complete once the Promise\n * returned from the function completes.\n *\n * @param appName The name of the app to initialize\n * @param module The loaded code module, if available; if this parameter is omitted, this\n *   function will load it.\n * @returns a Promise which completes once the app has been loaded and initialized\n */ export async function initializeApp(appName, module) {\n    if (!(appName in initializedApps)) {\n        let _module = module ?? await importDynamic(appName);\n        await (initializedApps[appName] = new Promise((resolve, reject)=>{\n            if (Object.hasOwn(_module, 'startupApp')) {\n                const startup = _module['startupApp'];\n                if (typeof startup === 'function') {\n                    return Promise.resolve(startup()).then(()=>{\n                        registerModuleLoad(appName);\n                        resolve(null);\n                    }).catch(reject);\n                }\n            }\n            registerModuleLoad(appName);\n            resolve(null);\n        }));\n    } else {\n        await initializedApps[appName];\n    }\n}\n","import { attach, registerExtension, registerModal, registerWorkspace, registerWorkspaceGroup } from \"@openmrs/esm-extensions\";\nimport { getLoader } from \"./app.js\";\nimport { registerFeatureFlag } from \"@openmrs/esm-feature-flags\";\n/**\n * This function registers an extension definition with the framework and will\n * attach the extension to any configured slots.\n *\n * @param appName The name of the app containing this extension\n * @param extension An object that describes the extension, derived from `routes.json`\n */ export function tryRegisterExtension(appName, extension) {\n    const name = extension.name;\n    if (!name) {\n        console.error(`An extension definition in ${appName} is missing an name and thus cannot be\nregistered. To fix this, ensure that you define the \"name\" field inside the\nextension definition.`, extension);\n        return;\n    }\n    if (extension.slots && extension.slot) {\n        console.warn(`The extension ${name} from ${appName} declares both a 'slots' property and\na 'slot' property. Only the 'slots' property will be honored.`);\n    }\n    const slots = extension.slots ? extension.slots : extension.slot ? [\n        extension.slot\n    ] : [];\n    if (!extension.component && !extension.load) {\n        console.error(`The extension ${name} from ${appName} is missing a 'component' entry and thus cannot be registered.\nTo fix this, ensure that you define a 'component' field inside the extension definition.`, extension);\n        return;\n    }\n    let loader = undefined;\n    if (extension.component) {\n        loader = getLoader(appName, extension.component);\n    } else if (extension.load) {\n        if (typeof extension.load !== 'function') {\n            console.error(`The extension ${name} from ${appName} declares a 'load' property that is not a function. This is not\nsupported, so the extension will not be loaded.`);\n            return;\n        }\n        loader = extension.load;\n    }\n    if (loader) {\n        registerExtension({\n            name,\n            load: loader,\n            meta: extension.meta || {},\n            order: extension.order,\n            moduleName: appName,\n            privileges: extension.privileges,\n            online: extension.online ?? true,\n            offline: extension.offline ?? false,\n            featureFlag: extension.featureFlag\n        });\n    }\n    for (const slot of slots){\n        attach(slot, name);\n    }\n}\n/**\n * This function registers a modal definition with the framework so that it can be launched.\n *\n * @param appName The name of the app defining this modal\n * @param modal An object that describes the modal, derived from `routes.json`\n */ export function tryRegisterModal(appName, modal) {\n    const name = modal.name;\n    if (!name) {\n        console.error(`A modal definition in ${appName} is missing an name and thus cannot be\nregistered. To fix this, ensure that you define the \"name\" field inside the\nmodal definition.`, modal);\n        return;\n    }\n    if (!modal.component && !modal.load) {\n        console.error(`The modal ${name} from ${appName} is missing a 'component' entry and thus cannot be registered.\nTo fix this, ensure that you define a 'component' field inside the modal definition.`, modal);\n        return;\n    }\n    let loader = undefined;\n    if (modal.component) {\n        loader = getLoader(appName, modal.component);\n    } else if (modal.load) {\n        if (typeof modal.load !== 'function') {\n            console.error(`The modal ${name} from ${appName} declares a 'load' property that is not a function. This is not\nsupported, so the modal will not be loaded.`);\n            return;\n        }\n        loader = modal.load;\n    }\n    if (loader) {\n        registerModal({\n            name,\n            load: loader,\n            moduleName: appName\n        });\n    }\n}\n/**\n * This function registers a workspace definition with the framework so that it can be launched.\n *\n * @param appName The name of the app defining this workspace\n * @param workspace An object that describes the workspace, derived from `routes.json`\n */ export function tryRegisterWorkspace(appName, workspace) {\n    const name = workspace.name;\n    if (!name) {\n        console.error(`A workspace definition in ${appName} is missing a name and thus cannot be registered.\nTo fix this, ensure that you define the \"name\" field inside the workspace definition.`, workspace);\n        return;\n    }\n    const title = workspace.title;\n    if (!title) {\n        console.error(`A workspace definition in ${appName} is missing a title and thus cannot be registered.\nTo fix this, ensure that you define the \"title\" field inside the workspace definition.`, workspace);\n        return;\n    }\n    if (!workspace.component && !workspace.load) {\n        console.error(`The workspace ${name} from ${appName} is missing a 'component' entry and thus cannot be registered.\nTo fix this, ensure that you define a 'component' field inside the workspace definition.`, workspace);\n        return;\n    }\n    let loader = undefined;\n    if (workspace.component) {\n        loader = getLoader(appName, workspace.component);\n    } else if (workspace.load) {\n        if (typeof workspace.load !== 'function') {\n            console.error(`The workspace ${name} from ${appName} declares a 'load' property that is not a function. This is not\nsupported, so the workspace will not be loaded.`);\n            return;\n        }\n        loader = workspace.load;\n    }\n    if (loader) {\n        registerWorkspace({\n            name,\n            title,\n            load: loader,\n            moduleName: appName,\n            type: workspace.type,\n            canHide: workspace.canHide,\n            canMaximize: workspace.canMaximize,\n            width: workspace.width,\n            preferredWindowSize: workspace.preferredWindowSize,\n            groups: workspace.groups\n        });\n    }\n    for (const group of workspace.groups || []){\n        registerWorkspaceGroup({\n            name: group,\n            members: [\n                name\n            ]\n        });\n    }\n}\n/**\n * This function registers a workspace group definition with the framework so that it can be launched.\n *\n * @param appName The name of the app defining this workspace\n * @param workspace An object that describes the workspace, derived from `routes.json`\n */ export function tryRegisterWorkspaceGroup(appName, workspaceGroup) {\n    const name = workspaceGroup.name;\n    if (!name) {\n        console.error(`A workspace group definition in ${appName} is missing a name and thus cannot be registered.\nTo fix this, ensure that you define the \"name\" field inside the workspace definition.`, workspaceGroup);\n        return;\n    }\n    registerWorkspaceGroup({\n        name,\n        members: workspaceGroup.members ?? []\n    });\n}\n/**\n * This function registers a feature flag definition with the framework.\n *\n * @param appName The name of the app defining this feature flag\n * @param featureFlag An object that describes the feature flag, derived from `routes.json`\n */ export function tryRegisterFeatureFlag(appName, featureFlag) {\n    const name = featureFlag.flagName;\n    if (!name) {\n        console.error(`A feature flag definition in ${appName} is missing a name and thus cannot be registered.\nTo fix this, ensure that you define the \"name\" field inside the feature flag definition.`, featureFlag);\n        return;\n    }\n    const label = featureFlag.label;\n    if (!label) {\n        console.error(`A feature flag definition in ${appName} is missing a description and thus cannot be registered.\nTo fix this, ensure that you define the \"label\" field inside the feature flag definition.`, featureFlag);\n        return;\n    }\n    const description = featureFlag.description;\n    if (!description) {\n        console.error(`A feature flag definition in ${appName} is missing a description and thus cannot be registered.\nTo fix this, ensure that you define the \"description\" field inside the feature flag definition.`, featureFlag);\n        return;\n    }\n    registerFeatureFlag(featureFlag.flagName, featureFlag.label, featureFlag.description);\n}\n","export const emptyLifecycle = {\n    bootstrap () {\n        return Promise.resolve();\n    },\n    mount () {\n        return Promise.resolve();\n    },\n    unmount () {\n        return Promise.resolve();\n    }\n};\nexport function routeRegex(regex, location) {\n    const result = regex.test(location.pathname.replace(window.getOpenmrsSpaBase(), ''));\n    return result;\n}\n","export { initializeApp } from \"./app.js\";\nexport { registerApp, finishRegisteringAllApps } from \"./pages.js\";\nexport { tryRegisterExtension } from \"./components.js\";\n","import { pathToActiveWhen, registerApplication } from \"single-spa\";\nimport { registerModuleWithConfigSystem } from \"@openmrs/esm-config\";\nimport { getFeatureFlag } from \"@openmrs/esm-feature-flags\";\nimport { routeRegex } from \"./helpers.js\";\nimport { getLoader } from \"./app.js\";\nimport { tryRegisterExtension, tryRegisterFeatureFlag, tryRegisterModal, tryRegisterWorkspace, tryRegisterWorkspaceGroup } from \"./components.js\";\n// this is the global holder of all pages registered in the app\nconst pages = [];\n/**\n * This takes a page's route definitions and returns a single-spa\n * activityFn which returns true when the page matches the current\n * route and false if it does not.\n *\n * @param route A string or regexp that matches the location when the\n * page should be displayed, a boolean constant, or an array of such\n * strings, regexps, and booleans\n * @returns An activityFn suitable to use for a single-spa application\n */ function getActivityFn(route) {\n    if (Array.isArray(route)) {\n        const activators = route.map(getActivityFn);\n        return (location)=>activators.some((activator)=>activator(location));\n    } else if (typeof route === 'string') {\n        return pathToActiveWhen(window.getOpenmrsSpaBase() + route);\n    } else if (route instanceof RegExp) {\n        return (location)=>routeRegex(route, location);\n    } else {\n        return ()=>route;\n    }\n}\n/**\n * For pages, we also add support for rendered them based on online and offline mode as well as\n * any feature flags.\n *\n * By default, we assume that all pages should be rendered when online, but only rendered\n * offline if specifically configured to do so.\n *\n * @param activityFn A standard single-spa activityFn such as that returned by {@link getActivityFn()}\n * @param pageDefinition The RegisteredPageDefinition object for this page\n * @returns An activityFn suitable to use for a single-spa application\n */ function wrapPageActivityFn(activityFn, { online, offline, featureFlag }) {\n    if (window.offlineEnabled) {\n        return (location)=>{\n            // basically, if the page should only work online and we're offline or if the\n            // page should only work offline and we're online, defaulting to always rendering\n            // the page\n            if (!(navigator.onLine && (online ?? true) || !navigator.onLine && (offline ?? false))) {\n                return false;\n            }\n            if (featureFlag) {\n                if (!getFeatureFlag(featureFlag)) {\n                    return false;\n                }\n            }\n            return activityFn(location);\n        };\n    } else {\n        return activityFn;\n    }\n}\n/**\n * This is the main entry-point for registering an app with the app shell.\n * Each app has a name and should have a `routes.json` file that defines it's\n * associated routes.\n *\n * @param appName The name of the application, e.g. `@openmrs/esm-my-app`\n * @param routes A Javascript object that corresponds to the app's  routes.json`\n * definition.\n */ export function registerApp(appName, routes) {\n    if (appName && routes && typeof routes === 'object') {\n        registerModuleWithConfigSystem(appName);\n        const availableExtensions = routes.extensions ?? [];\n        const availableModals = routes.modals ?? [];\n        const availableWorkspaces = routes.workspaces ?? [];\n        const availableWorkspaceGroups = routes.workspaceGroups ?? [];\n        const availableFeatureFlags = routes.featureFlags ?? [];\n        routes.pages?.forEach((p)=>{\n            if (p && typeof p === 'object' && Object.hasOwn(p, 'component') && (Object.hasOwn(p, 'route') || Object.hasOwn(p, 'routeRegex') || Object.hasOwn(p, 'routes'))) {\n                pages.push({\n                    ...p,\n                    order: p.order ?? Number.MAX_SAFE_INTEGER,\n                    appName\n                });\n            } else {\n                console.warn(`A page for ${appName} could not be registered as it does not appear to have the required properties`, p);\n            }\n        });\n        availableExtensions.forEach((ext)=>{\n            if (ext && typeof ext === 'object' && Object.hasOwn(ext, 'name') && Object.hasOwn(ext, 'component')) {\n                tryRegisterExtension(appName, ext);\n            } else {\n                console.warn(`An extension for ${appName} could not be registered as it does not appear to have the required properties`, ext);\n            }\n        });\n        availableModals.forEach((modal)=>{\n            if (modal && typeof modal === 'object' && Object.hasOwn(modal, 'name') && Object.hasOwn(modal, 'component')) {\n                tryRegisterModal(appName, modal);\n            } else {\n                console.warn(`A modal for ${appName} could not be registered as it does not appear to have the required properties`, modal);\n            }\n        });\n        availableWorkspaces.forEach((workspace)=>{\n            if (workspace && typeof workspace === 'object' && Object.hasOwn(workspace, 'name') && Object.hasOwn(workspace, 'component')) {\n                tryRegisterWorkspace(appName, workspace);\n            } else {\n                console.warn(`A workspace for ${appName} could not be registered as it does not appear to have the required properties`, workspace);\n            }\n        });\n        availableWorkspaceGroups.forEach((workspaceGroup)=>{\n            if (workspaceGroup && typeof workspaceGroup === 'object' && Object.hasOwn(workspaceGroup, 'name')) {\n                tryRegisterWorkspaceGroup(appName, workspaceGroup);\n            } else {\n                console.warn(`A workspace group for ${appName} could not be registered as it does not appear to have the required properties`, workspaceGroup);\n            }\n        });\n        availableFeatureFlags.forEach((featureFlag)=>{\n            if (featureFlag && typeof featureFlag === 'object' && Object.hasOwn(featureFlag, 'flagName')) {\n                tryRegisterFeatureFlag(appName, featureFlag);\n            } else {\n                console.warn(`A feature flag for ${appName} could not be registered as it does not appear to have the required properties`, featureFlag);\n            }\n        });\n    }\n}\n/**\n * This is called by the app shell once all route entries have been processed.\n * This actually registers the pages with the application. This function is\n * necessary to ensure that pages are rendered in the DOM according to their\n * order definition, especially because certain pages _must_ be first in the DOM.\n *\n * Each page is rendered into a div with an appropriate name.\n */ export function finishRegisteringAllApps() {\n    pages.sort((a, b)=>{\n        let sort = a.order - b.order;\n        if (sort != 0) {\n            return sort;\n        }\n        return a.appName.localeCompare(b.appName, 'en');\n    });\n    // Create a div for each page. This ensures their DOM order.\n    // If we don't do this, Single-SPA 5 will create the DOM element only once\n    // the page becomes active, which makes it impossible to guarantee order.\n    let appIndices = new Map();\n    for (let page of pages){\n        if (!appIndices.has(page.appName)) {\n            appIndices.set(page.appName, 0);\n        } else {\n            appIndices.set(page.appName, appIndices.get(page.appName) + 1);\n        }\n        const index = appIndices.get(page.appName);\n        const name = `${page.appName}-page-${index}`;\n        const div = document.createElement('div');\n        div.id = `single-spa-application:${name}`;\n        document.body.appendChild(div);\n        tryRegisterPage(name, page);\n    }\n}\n/**\n * This function converts each page definition into a single-spa application\n * if that's possible. After this point, pages are rendered using single-spa's\n * routing logic.\n *\n * @param appName The name of the app containing this page\n * @param page An object that describes the page, derived from `routes.json`\n */ function tryRegisterPage(appName, page) {\n    const route = typeof page.route !== 'undefined' ? page.route : typeof page.routeRegex !== 'undefined' ? new RegExp(page.routeRegex) : false;\n    if (route === false) {\n        console.warn(`A registered page definition is missing a route and thus cannot be registered.\nTo fix this, ensure that you define the \"route\" (or alternatively the \"routeRegex\") field inside the extension definition.`, appName);\n        return;\n    }\n    if (!page.component) {\n        console.warn(`A registered page definition is missing a component and thus cannot be registered.\nTo fix this, ensure that you define the \"component\" field inside the page definition.`, appName);\n        return;\n    }\n    const activityFn = wrapPageActivityFn(getActivityFn(route), page);\n    const loader = getLoader(page.appName, page.component);\n    registerApplication(appName, loader, activityFn);\n}\n","/** @module @category Routes Utilities */ import { canAccessStorage } from \"@openmrs/esm-utils\";\nimport { localStorageRoutesPrefix } from \"./constants.js\";\nconst isEnabled = canAccessStorage();\n/**\n * Used to add a route override to local storage. These are read as the routes registry\n * is assembled, so the app must be reloaded for new overrides to take effect.\n *\n * @internal\n * @param moduleName The name of the module the routes are for\n * @param routes Either an {@link OpenmrsAppRoutes} object, a string that represents a JSON\n *  version of an {@link OpenmrsAppRoutes} object or a string or URL that resolves to a\n *  JSON document that represents an {@link OpenmrsAppRoutes} object\n */ export function addRoutesOverride(moduleName, routes) {\n    if (!isEnabled) {\n        return;\n    }\n    if (typeof routes === 'string') {\n        if (routes.startsWith('http')) {\n            return addRouteOverrideInternal(moduleName, routes);\n        } else {\n            try {\n                const maybeRoutes = JSON.parse(routes);\n                if (isOpenmrsAppRoutes(maybeRoutes)) {\n                    return addRouteOverrideInternal(moduleName, maybeRoutes);\n                } else {\n                    console.error(`The supplied routes for ${moduleName} is not a valid OpenmrsAppRoutes object`, routes);\n                }\n            } catch (e) {\n                console.error(`Could not add routes override for ${moduleName}: `, e);\n            }\n        }\n    } else if (routes instanceof URL) {\n        return addRouteOverrideInternal(moduleName, routes.toString());\n    } else if (isOpenmrsAppRoutes(routes)) {\n        return addRouteOverrideInternal(moduleName, routes);\n    }\n    console.error(`Override for ${moduleName} is not in a valid format. Expected either a Javascript Object, a JSON string of a Javascript object, or a URL`, routes);\n}\n/**\n * Used to remove an existing routes override from local storage. These are read as the routes registry\n * is assembled, so the app must be reloaded for removed override to be removed.\n *\n * @internal\n * @param moduleName The module to remove the overrides for\n */ export function removeRoutesOverride(moduleName) {\n    if (!isEnabled) {\n        return;\n    }\n    const key = localStorageRoutesPrefix + moduleName;\n    localStorage.removeItem(key);\n}\n/**\n * Used to remove all existing routes overrides from local storage. These are read as the routes registry\n * is assembled, so the app must be reloaded for the removed overrides to appear to be removed.\n *\n * @internal\n */ export function resetAllRoutesOverrides() {\n    if (!isEnabled) {\n        return;\n    }\n    const localStorage1 = window.localStorage;\n    for(let i = 0; i < localStorage1.length; i++){\n        const key = localStorage1.key(i);\n        if (key?.startsWith(localStorageRoutesPrefix)) {\n            localStorage1.removeItem(key);\n        }\n    }\n}\nfunction addRouteOverrideInternal(moduleName, routes) {\n    const key = localStorageRoutesPrefix + moduleName;\n    localStorage.setItem(key, JSON.stringify(routes));\n}\n/**\n * Simple type-predicate to ensure that the value can be treated as an OpenmrsAppRoutes\n * object.\n *\n * @internal\n * @param routes the object to check to see if it is an OpenmrsAppRoutes object\n * @returns true if the routes value is an OpenmrsAppRoutes\n */ export function isOpenmrsAppRoutes(routes) {\n    if (routes && typeof routes === 'object') {\n        const hasOwnProperty = Object.prototype.hasOwnProperty;\n        // we cast maybeRoutes as OpenmrsAppRoutes mainly so we can refer to the properties it should\n        // have without repeated casts\n        const maybeRoutes = routes;\n        if (hasOwnProperty.call(routes, 'pages')) {\n            if (!Boolean(maybeRoutes.pages) || !Array.isArray(maybeRoutes.pages)) {\n                return false;\n            }\n        }\n        if (hasOwnProperty.call(routes, 'extensions')) {\n            if (!Boolean(maybeRoutes.extensions) || !Array.isArray(maybeRoutes.extensions)) {\n                return false;\n            }\n        }\n        if (hasOwnProperty.call(routes, 'workspaces')) {\n            if (!Boolean(maybeRoutes.workspaces) || !Array.isArray(maybeRoutes.workspaces)) {\n                return false;\n            }\n        }\n        if (hasOwnProperty.call(routes, 'modals')) {\n            if (!Boolean(maybeRoutes.modals) || !Array.isArray(maybeRoutes.modals)) {\n                return false;\n            }\n        }\n        // Notice that we're essentially testing for things that cannot be treated as an OpenmrsAppRoutes\n        // object. This is because a completely empty object is a valid OpenmrsAppRoutes object.\n        return true;\n    }\n    return false;\n}\n/**\n * Simple type-predicate to ensure that the value can be treated as an OpenmrsRoutes\n * object.\n *\n * @internal\n * @param routes the object to check to see if it is an OpenmrsRoutes object\n * @returns true if the routes value is an OpenmrsRoutes\n */ export function isOpenmrsRoutes(routes) {\n    if (routes && typeof routes === 'object') {\n        const maybeRoutes = routes;\n        return Object.entries(maybeRoutes).every(([key, value])=>typeof key === 'string' && isOpenmrsAppRoutes(value));\n    }\n    return false;\n}\n","export * from \"./date-util.js\";\n","export * from \"./age-helpers.js\";\nexport * from \"./dates/index.js\";\nexport * from \"./get-locale.js\";\nexport * from \"./is-online.js\";\nexport * from \"./patient-helpers.js\";\nexport * from \"./shallowEqual.js\";\nexport * from \"./storage.js\";\nexport * from \"./test-helpers.js\";\nexport * from \"./version.js\";\nexport * from \"./retry.js\";\n","/** @module @category Utility */ /**\n * Options for configuring the behavior of the {@link retry} function.\n */ /**\n * Executes the specified function and retries executing on failure with a custom backoff strategy\n * defined by the options.\n *\n * If not configured otherwise, this function uses the following default options:\n * * Retries 5 times beyond the initial attempt.\n * * Uses an exponential backoff starting with an initial delay of 1000ms.\n * @param fn The function to be executed and retried on failure.\n * @param options Additional options which configure the retry behavior.\n * @returns The result of successfully executing `fn`.\n * @throws Rethrows the final error of running `fn` when the function stops retrying.\n */ export async function retry(fn, options = {}) {\n    let { shouldRetry, getDelay, onError } = options;\n    shouldRetry = shouldRetry ?? ((attempt)=>limitAttempts(attempt, 5));\n    getDelay = getDelay ?? ((attempt)=>getExponentialDelay(attempt, 1000));\n    let attempt = 0;\n    let lastError = undefined;\n    do {\n        try {\n            await delay(getDelay(attempt));\n            return await fn();\n        } catch (e) {\n            onError?.(e, attempt);\n            lastError = e;\n        }\n    }while (shouldRetry(attempt++))\n    // If we reach this fn errored and shouldn't retry anymore. Simply rethrow the final error as\n    // a means of ending the retry process without a result.\n    throw lastError;\n}\nfunction limitAttempts(attempt, maxAttempts) {\n    return attempt <= maxAttempts;\n}\nfunction getExponentialDelay(attempt, startingDelay, initialDelay = false) {\n    const exponent = initialDelay ? attempt + 1 : attempt;\n    return startingDelay * Math.pow(2, exponent);\n}\nasync function delay(ms) {\n    if (ms <= 0) {\n        return;\n    }\n    return new Promise((res)=>setTimeout(res, ms));\n}\n","/** @module @category Utility */ /**\n * Simple utility function to determine if an object implementing the WebStorage API\n * is actually available. Useful for testing the availability of `localStorage` or\n * `sessionStorage`.\n *\n * @param storage The WebStorage API object to check. Defaults to `localStorage`.\n * @returns True if the WebStorage API object is able to be accessed, false otherwise\n */ export function canAccessStorage(storage = window.localStorage) {\n    try {\n        storage.getItem('test');\n        return true;\n    } catch  {\n        return false;\n    }\n}\n","/** @module @category Utility */ /**\n * Given a config schema, this returns an object like is returned by `useConfig`\n * with all default values.\n *\n * This should be used in tests and not in production code.\n *\n * If all you need is the default values in your tests, these are returned by\n * default from the `useConfig`/`getConfig` mock. This function is useful if you\n * need to override some of the default values.\n */ export function getDefaultsFromConfigSchema(schema) {\n    let tmp = {};\n    for (let k of Object.keys(schema)){\n        if (isOrdinaryObject(schema[k]) && schema[k].hasOwnProperty('_default')) {\n            tmp[k] = schema[k]._default;\n        } else if (k.startsWith('_')) {\n            continue;\n        } else if (isOrdinaryObject(schema[k])) {\n            tmp[k] = getDefaultsFromConfigSchema(schema[k]);\n        } else {\n            tmp[k] = schema[k];\n        }\n    }\n    return tmp;\n}\nfunction isOrdinaryObject(x) {\n    return !!x && x.constructor === Object;\n}\n","/** @module @category Utility */ import * as semver from \"semver\";\nfunction normalizeOnlyVersion(version) {\n    const [major, minor, patch] = version.split('.');\n    return `${major}.${minor}.${patch}`;\n}\nfunction normalizeFullVersion(version) {\n    const idx = version.indexOf('-');\n    const prerelease = idx >= 0;\n    if (prerelease) {\n        const ver = normalizeOnlyVersion(version.slice(0, idx));\n        const pre = version.slice(idx + 1);\n        return `${ver}-${pre}`;\n    }\n    return normalizeOnlyVersion(version);\n}\nexport function isVersionSatisfied(requiredVersion, installedVersion) {\n    const version = normalizeFullVersion(installedVersion);\n    return semver.satisfies(version, requiredVersion, {\n        includePrerelease: true\n    });\n}\n","const ANY = Symbol('SemVer ANY')\n// hoisted class for cyclic dependency\nclass Comparator {\n  static get ANY () {\n    return ANY\n  }\n  constructor (comp, options) {\n    if (!options || typeof options !== 'object') {\n      options = {\n        loose: !!options,\n        includePrerelease: false\n      }\n    }\n\n    if (comp instanceof Comparator) {\n      if (comp.loose === !!options.loose) {\n        return comp\n      } else {\n        comp = comp.value\n      }\n    }\n\n    debug('comparator', comp, options)\n    this.options = options\n    this.loose = !!options.loose\n    this.parse(comp)\n\n    if (this.semver === ANY) {\n      this.value = ''\n    } else {\n      this.value = this.operator + this.semver.version\n    }\n\n    debug('comp', this)\n  }\n\n  parse (comp) {\n    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]\n    const m = comp.match(r)\n\n    if (!m) {\n      throw new TypeError(`Invalid comparator: ${comp}`)\n    }\n\n    this.operator = m[1] !== undefined ? m[1] : ''\n    if (this.operator === '=') {\n      this.operator = ''\n    }\n\n    // if it literally is just '>' or '' then allow anything.\n    if (!m[2]) {\n      this.semver = ANY\n    } else {\n      this.semver = new SemVer(m[2], this.options.loose)\n    }\n  }\n\n  toString () {\n    return this.value\n  }\n\n  test (version) {\n    debug('Comparator.test', version, this.options.loose)\n\n    if (this.semver === ANY || version === ANY) {\n      return true\n    }\n\n    if (typeof version === 'string') {\n      try {\n        version = new SemVer(version, this.options)\n      } catch (er) {\n        return false\n      }\n    }\n\n    return cmp(version, this.operator, this.semver, this.options)\n  }\n\n  intersects (comp, options) {\n    if (!(comp instanceof Comparator)) {\n      throw new TypeError('a Comparator is required')\n    }\n\n    if (!options || typeof options !== 'object') {\n      options = {\n        loose: !!options,\n        includePrerelease: false\n      }\n    }\n\n    if (this.operator === '') {\n      if (this.value === '') {\n        return true\n      }\n      return new Range(comp.value, options).test(this.value)\n    } else if (comp.operator === '') {\n      if (comp.value === '') {\n        return true\n      }\n      return new Range(this.value, options).test(comp.semver)\n    }\n\n    const sameDirectionIncreasing =\n      (this.operator === '>=' || this.operator === '>') &&\n      (comp.operator === '>=' || comp.operator === '>')\n    const sameDirectionDecreasing =\n      (this.operator === '<=' || this.operator === '<') &&\n      (comp.operator === '<=' || comp.operator === '<')\n    const sameSemVer = this.semver.version === comp.semver.version\n    const differentDirectionsInclusive =\n      (this.operator === '>=' || this.operator === '<=') &&\n      (comp.operator === '>=' || comp.operator === '<=')\n    const oppositeDirectionsLessThan =\n      cmp(this.semver, '<', comp.semver, options) &&\n      (this.operator === '>=' || this.operator === '>') &&\n        (comp.operator === '<=' || comp.operator === '<')\n    const oppositeDirectionsGreaterThan =\n      cmp(this.semver, '>', comp.semver, options) &&\n      (this.operator === '<=' || this.operator === '<') &&\n        (comp.operator === '>=' || comp.operator === '>')\n\n    return (\n      sameDirectionIncreasing ||\n      sameDirectionDecreasing ||\n      (sameSemVer && differentDirectionsInclusive) ||\n      oppositeDirectionsLessThan ||\n      oppositeDirectionsGreaterThan\n    )\n  }\n}\n\nmodule.exports = Comparator\n\nconst {re, t} = require('../internal/re')\nconst cmp = require('../functions/cmp')\nconst debug = require('../internal/debug')\nconst SemVer = require('./semver')\nconst Range = require('./range')\n","// hoisted class for cyclic dependency\nclass Range {\n  constructor (range, options) {\n    if (!options || typeof options !== 'object') {\n      options = {\n        loose: !!options,\n        includePrerelease: false\n      }\n    }\n\n    if (range instanceof Range) {\n      if (\n        range.loose === !!options.loose &&\n        range.includePrerelease === !!options.includePrerelease\n      ) {\n        return range\n      } else {\n        return new Range(range.raw, options)\n      }\n    }\n\n    if (range instanceof Comparator) {\n      // just put it in the set and return\n      this.raw = range.value\n      this.set = [[range]]\n      this.format()\n      return this\n    }\n\n    this.options = options\n    this.loose = !!options.loose\n    this.includePrerelease = !!options.includePrerelease\n\n    // First, split based on boolean or ||\n    this.raw = range\n    this.set = range\n      .split(/\\s*\\|\\|\\s*/)\n      // map the range to a 2d array of comparators\n      .map(range => this.parseRange(range.trim()))\n      // throw out any comparator lists that are empty\n      // this generally means that it was not a valid range, which is allowed\n      // in loose mode, but will still throw if the WHOLE range is invalid.\n      .filter(c => c.length)\n\n    if (!this.set.length) {\n      throw new TypeError(`Invalid SemVer Range: ${range}`)\n    }\n\n    this.format()\n  }\n\n  format () {\n    this.range = this.set\n      .map((comps) => {\n        return comps.join(' ').trim()\n      })\n      .join('||')\n      .trim()\n    return this.range\n  }\n\n  toString () {\n    return this.range\n  }\n\n  parseRange (range) {\n    const loose = this.options.loose\n    range = range.trim()\n    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]\n    range = range.replace(hr, hyphenReplace(this.options.includePrerelease))\n    debug('hyphen replace', range)\n    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)\n    debug('comparator trim', range, re[t.COMPARATORTRIM])\n\n    // `~ 1.2.3` => `~1.2.3`\n    range = range.replace(re[t.TILDETRIM], tildeTrimReplace)\n\n    // `^ 1.2.3` => `^1.2.3`\n    range = range.replace(re[t.CARETTRIM], caretTrimReplace)\n\n    // normalize spaces\n    range = range.split(/\\s+/).join(' ')\n\n    // At this point, the range is completely trimmed and\n    // ready to be split into comparators.\n\n    const compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]\n    return range\n      .split(' ')\n      .map(comp => parseComparator(comp, this.options))\n      .join(' ')\n      .split(/\\s+/)\n      .map(comp => replaceGTE0(comp, this.options))\n      // in loose mode, throw out any that are not valid comparators\n      .filter(this.options.loose ? comp => !!comp.match(compRe) : () => true)\n      .map(comp => new Comparator(comp, this.options))\n  }\n\n  intersects (range, options) {\n    if (!(range instanceof Range)) {\n      throw new TypeError('a Range is required')\n    }\n\n    return this.set.some((thisComparators) => {\n      return (\n        isSatisfiable(thisComparators, options) &&\n        range.set.some((rangeComparators) => {\n          return (\n            isSatisfiable(rangeComparators, options) &&\n            thisComparators.every((thisComparator) => {\n              return rangeComparators.every((rangeComparator) => {\n                return thisComparator.intersects(rangeComparator, options)\n              })\n            })\n          )\n        })\n      )\n    })\n  }\n\n  // if ANY of the sets match ALL of its comparators, then pass\n  test (version) {\n    if (!version) {\n      return false\n    }\n\n    if (typeof version === 'string') {\n      try {\n        version = new SemVer(version, this.options)\n      } catch (er) {\n        return false\n      }\n    }\n\n    for (let i = 0; i < this.set.length; i++) {\n      if (testSet(this.set[i], version, this.options)) {\n        return true\n      }\n    }\n    return false\n  }\n}\nmodule.exports = Range\n\nconst Comparator = require('./comparator')\nconst debug = require('../internal/debug')\nconst SemVer = require('./semver')\nconst {\n  re,\n  t,\n  comparatorTrimReplace,\n  tildeTrimReplace,\n  caretTrimReplace\n} = require('../internal/re')\n\n// take a set of comparators and determine whether there\n// exists a version which can satisfy it\nconst isSatisfiable = (comparators, options) => {\n  let result = true\n  const remainingComparators = comparators.slice()\n  let testComparator = remainingComparators.pop()\n\n  while (result && remainingComparators.length) {\n    result = remainingComparators.every((otherComparator) => {\n      return testComparator.intersects(otherComparator, options)\n    })\n\n    testComparator = remainingComparators.pop()\n  }\n\n  return result\n}\n\n// comprised of xranges, tildes, stars, and gtlt's at this point.\n// already replaced the hyphen ranges\n// turn into a set of JUST comparators.\nconst parseComparator = (comp, options) => {\n  debug('comp', comp, options)\n  comp = replaceCarets(comp, options)\n  debug('caret', comp)\n  comp = replaceTildes(comp, options)\n  debug('tildes', comp)\n  comp = replaceXRanges(comp, options)\n  debug('xrange', comp)\n  comp = replaceStars(comp, options)\n  debug('stars', comp)\n  return comp\n}\n\nconst isX = id => !id || id.toLowerCase() === 'x' || id === '*'\n\n// ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0\nconst replaceTildes = (comp, options) =>\n  comp.trim().split(/\\s+/).map((comp) => {\n    return replaceTilde(comp, options)\n  }).join(' ')\n\nconst replaceTilde = (comp, options) => {\n  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]\n  return comp.replace(r, (_, M, m, p, pr) => {\n    debug('tilde', comp, _, M, m, p, pr)\n    let ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`\n    } else if (isX(p)) {\n      // ~1.2 == >=1.2.0 <1.3.0-0\n      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`\n    } else if (pr) {\n      debug('replaceTilde pr', pr)\n      ret = `>=${M}.${m}.${p}-${pr\n      } <${M}.${+m + 1}.0-0`\n    } else {\n      // ~1.2.3 == >=1.2.3 <1.3.0-0\n      ret = `>=${M}.${m}.${p\n      } <${M}.${+m + 1}.0-0`\n    }\n\n    debug('tilde return', ret)\n    return ret\n  })\n}\n\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0\n// ^1.2.3 --> >=1.2.3 <2.0.0-0\n// ^1.2.0 --> >=1.2.0 <2.0.0-0\nconst replaceCarets = (comp, options) =>\n  comp.trim().split(/\\s+/).map((comp) => {\n    return replaceCaret(comp, options)\n  }).join(' ')\n\nconst replaceCaret = (comp, options) => {\n  debug('caret', comp, options)\n  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]\n  const z = options.includePrerelease ? '-0' : ''\n  return comp.replace(r, (_, M, m, p, pr) => {\n    debug('caret', comp, _, M, m, p, pr)\n    let ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`\n    } else if (isX(p)) {\n      if (M === '0') {\n        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`\n      } else {\n        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`\n      }\n    } else if (pr) {\n      debug('replaceCaret pr', pr)\n      if (M === '0') {\n        if (m === '0') {\n          ret = `>=${M}.${m}.${p}-${pr\n          } <${M}.${m}.${+p + 1}-0`\n        } else {\n          ret = `>=${M}.${m}.${p}-${pr\n          } <${M}.${+m + 1}.0-0`\n        }\n      } else {\n        ret = `>=${M}.${m}.${p}-${pr\n        } <${+M + 1}.0.0-0`\n      }\n    } else {\n      debug('no pr')\n      if (M === '0') {\n        if (m === '0') {\n          ret = `>=${M}.${m}.${p\n          }${z} <${M}.${m}.${+p + 1}-0`\n        } else {\n          ret = `>=${M}.${m}.${p\n          }${z} <${M}.${+m + 1}.0-0`\n        }\n      } else {\n        ret = `>=${M}.${m}.${p\n        } <${+M + 1}.0.0-0`\n      }\n    }\n\n    debug('caret return', ret)\n    return ret\n  })\n}\n\nconst replaceXRanges = (comp, options) => {\n  debug('replaceXRanges', comp, options)\n  return comp.split(/\\s+/).map((comp) => {\n    return replaceXRange(comp, options)\n  }).join(' ')\n}\n\nconst replaceXRange = (comp, options) => {\n  comp = comp.trim()\n  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]\n  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {\n    debug('xRange', comp, ret, gtlt, M, m, p, pr)\n    const xM = isX(M)\n    const xm = xM || isX(m)\n    const xp = xm || isX(p)\n    const anyX = xp\n\n    if (gtlt === '=' && anyX) {\n      gtlt = ''\n    }\n\n    // if we're including prereleases in the match, then we need\n    // to fix this to -0, the lowest possible prerelease value\n    pr = options.includePrerelease ? '-0' : ''\n\n    if (xM) {\n      if (gtlt === '>' || gtlt === '<') {\n        // nothing is allowed\n        ret = '<0.0.0-0'\n      } else {\n        // nothing is forbidden\n        ret = '*'\n      }\n    } else if (gtlt && anyX) {\n      // we know patch is an x, because we have any x at all.\n      // replace X with 0\n      if (xm) {\n        m = 0\n      }\n      p = 0\n\n      if (gtlt === '>') {\n        // >1 => >=2.0.0\n        // >1.2 => >=1.3.0\n        gtlt = '>='\n        if (xm) {\n          M = +M + 1\n          m = 0\n          p = 0\n        } else {\n          m = +m + 1\n          p = 0\n        }\n      } else if (gtlt === '<=') {\n        // <=0.7.x is actually <0.8.0, since any 0.7.x should\n        // pass.  Similarly, <=7.x is actually <8.0.0, etc.\n        gtlt = '<'\n        if (xm) {\n          M = +M + 1\n        } else {\n          m = +m + 1\n        }\n      }\n\n      if (gtlt === '<')\n        pr = '-0'\n\n      ret = `${gtlt + M}.${m}.${p}${pr}`\n    } else if (xm) {\n      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`\n    } else if (xp) {\n      ret = `>=${M}.${m}.0${pr\n      } <${M}.${+m + 1}.0-0`\n    }\n\n    debug('xRange return', ret)\n\n    return ret\n  })\n}\n\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nconst replaceStars = (comp, options) => {\n  debug('replaceStars', comp, options)\n  // Looseness is ignored here.  star is always as loose as it gets!\n  return comp.trim().replace(re[t.STAR], '')\n}\n\nconst replaceGTE0 = (comp, options) => {\n  debug('replaceGTE0', comp, options)\n  return comp.trim()\n    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')\n}\n\n// This function is passed to string.replace(re[t.HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0-0\nconst hyphenReplace = incPr => ($0,\n  from, fM, fm, fp, fpr, fb,\n  to, tM, tm, tp, tpr, tb) => {\n  if (isX(fM)) {\n    from = ''\n  } else if (isX(fm)) {\n    from = `>=${fM}.0.0${incPr ? '-0' : ''}`\n  } else if (isX(fp)) {\n    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`\n  } else if (fpr) {\n    from = `>=${from}`\n  } else {\n    from = `>=${from}${incPr ? '-0' : ''}`\n  }\n\n  if (isX(tM)) {\n    to = ''\n  } else if (isX(tm)) {\n    to = `<${+tM + 1}.0.0-0`\n  } else if (isX(tp)) {\n    to = `<${tM}.${+tm + 1}.0-0`\n  } else if (tpr) {\n    to = `<=${tM}.${tm}.${tp}-${tpr}`\n  } else if (incPr) {\n    to = `<${tM}.${tm}.${+tp + 1}-0`\n  } else {\n    to = `<=${to}`\n  }\n\n  return (`${from} ${to}`).trim()\n}\n\nconst testSet = (set, version, options) => {\n  for (let i = 0; i < set.length; i++) {\n    if (!set[i].test(version)) {\n      return false\n    }\n  }\n\n  if (version.prerelease.length && !options.includePrerelease) {\n    // Find the set of versions that are allowed to have prereleases\n    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n    // That should allow `1.2.3-pr.2` to pass.\n    // However, `1.2.4-alpha.notready` should NOT be allowed,\n    // even though it's within the range set by the comparators.\n    for (let i = 0; i < set.length; i++) {\n      debug(set[i].semver)\n      if (set[i].semver === Comparator.ANY) {\n        continue\n      }\n\n      if (set[i].semver.prerelease.length > 0) {\n        const allowed = set[i].semver\n        if (allowed.major === version.major &&\n            allowed.minor === version.minor &&\n            allowed.patch === version.patch) {\n          return true\n        }\n      }\n    }\n\n    // Version has a -pre, but it's not one of the ones we like.\n    return false\n  }\n\n  return true\n}\n","const debug = require('../internal/debug')\nconst { MAX_LENGTH, MAX_SAFE_INTEGER } = require('../internal/constants')\nconst { re, t } = require('../internal/re')\n\nconst { compareIdentifiers } = require('../internal/identifiers')\nclass SemVer {\n  constructor (version, options) {\n    if (!options || typeof options !== 'object') {\n      options = {\n        loose: !!options,\n        includePrerelease: false\n      }\n    }\n    if (version instanceof SemVer) {\n      if (version.loose === !!options.loose &&\n          version.includePrerelease === !!options.includePrerelease) {\n        return version\n      } else {\n        version = version.version\n      }\n    } else if (typeof version !== 'string') {\n      throw new TypeError(`Invalid Version: ${version}`)\n    }\n\n    if (version.length > MAX_LENGTH) {\n      throw new TypeError(\n        `version is longer than ${MAX_LENGTH} characters`\n      )\n    }\n\n    debug('SemVer', version, options)\n    this.options = options\n    this.loose = !!options.loose\n    // this isn't actually relevant for versions, but keep it so that we\n    // don't run into trouble passing this.options around.\n    this.includePrerelease = !!options.includePrerelease\n\n    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])\n\n    if (!m) {\n      throw new TypeError(`Invalid Version: ${version}`)\n    }\n\n    this.raw = version\n\n    // these are actually numbers\n    this.major = +m[1]\n    this.minor = +m[2]\n    this.patch = +m[3]\n\n    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {\n      throw new TypeError('Invalid major version')\n    }\n\n    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {\n      throw new TypeError('Invalid minor version')\n    }\n\n    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {\n      throw new TypeError('Invalid patch version')\n    }\n\n    // numberify any prerelease numeric ids\n    if (!m[4]) {\n      this.prerelease = []\n    } else {\n      this.prerelease = m[4].split('.').map((id) => {\n        if (/^[0-9]+$/.test(id)) {\n          const num = +id\n          if (num >= 0 && num < MAX_SAFE_INTEGER) {\n            return num\n          }\n        }\n        return id\n      })\n    }\n\n    this.build = m[5] ? m[5].split('.') : []\n    this.format()\n  }\n\n  format () {\n    this.version = `${this.major}.${this.minor}.${this.patch}`\n    if (this.prerelease.length) {\n      this.version += `-${this.prerelease.join('.')}`\n    }\n    return this.version\n  }\n\n  toString () {\n    return this.version\n  }\n\n  compare (other) {\n    debug('SemVer.compare', this.version, this.options, other)\n    if (!(other instanceof SemVer)) {\n      if (typeof other === 'string' && other === this.version) {\n        return 0\n      }\n      other = new SemVer(other, this.options)\n    }\n\n    if (other.version === this.version) {\n      return 0\n    }\n\n    return this.compareMain(other) || this.comparePre(other)\n  }\n\n  compareMain (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    return (\n      compareIdentifiers(this.major, other.major) ||\n      compareIdentifiers(this.minor, other.minor) ||\n      compareIdentifiers(this.patch, other.patch)\n    )\n  }\n\n  comparePre (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    // NOT having a prerelease is > having one\n    if (this.prerelease.length && !other.prerelease.length) {\n      return -1\n    } else if (!this.prerelease.length && other.prerelease.length) {\n      return 1\n    } else if (!this.prerelease.length && !other.prerelease.length) {\n      return 0\n    }\n\n    let i = 0\n    do {\n      const a = this.prerelease[i]\n      const b = other.prerelease[i]\n      debug('prerelease compare', i, a, b)\n      if (a === undefined && b === undefined) {\n        return 0\n      } else if (b === undefined) {\n        return 1\n      } else if (a === undefined) {\n        return -1\n      } else if (a === b) {\n        continue\n      } else {\n        return compareIdentifiers(a, b)\n      }\n    } while (++i)\n  }\n\n  compareBuild (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    let i = 0\n    do {\n      const a = this.build[i]\n      const b = other.build[i]\n      debug('prerelease compare', i, a, b)\n      if (a === undefined && b === undefined) {\n        return 0\n      } else if (b === undefined) {\n        return 1\n      } else if (a === undefined) {\n        return -1\n      } else if (a === b) {\n        continue\n      } else {\n        return compareIdentifiers(a, b)\n      }\n    } while (++i)\n  }\n\n  // preminor will bump the version up to the next minor release, and immediately\n  // down to pre-release. premajor and prepatch work the same way.\n  inc (release, identifier) {\n    switch (release) {\n      case 'premajor':\n        this.prerelease.length = 0\n        this.patch = 0\n        this.minor = 0\n        this.major++\n        this.inc('pre', identifier)\n        break\n      case 'preminor':\n        this.prerelease.length = 0\n        this.patch = 0\n        this.minor++\n        this.inc('pre', identifier)\n        break\n      case 'prepatch':\n        // If this is already a prerelease, it will bump to the next version\n        // drop any prereleases that might already exist, since they are not\n        // relevant at this point.\n        this.prerelease.length = 0\n        this.inc('patch', identifier)\n        this.inc('pre', identifier)\n        break\n      // If the input is a non-prerelease version, this acts the same as\n      // prepatch.\n      case 'prerelease':\n        if (this.prerelease.length === 0) {\n          this.inc('patch', identifier)\n        }\n        this.inc('pre', identifier)\n        break\n\n      case 'major':\n        // If this is a pre-major version, bump up to the same major version.\n        // Otherwise increment major.\n        // 1.0.0-5 bumps to 1.0.0\n        // 1.1.0 bumps to 2.0.0\n        if (\n          this.minor !== 0 ||\n          this.patch !== 0 ||\n          this.prerelease.length === 0\n        ) {\n          this.major++\n        }\n        this.minor = 0\n        this.patch = 0\n        this.prerelease = []\n        break\n      case 'minor':\n        // If this is a pre-minor version, bump up to the same minor version.\n        // Otherwise increment minor.\n        // 1.2.0-5 bumps to 1.2.0\n        // 1.2.1 bumps to 1.3.0\n        if (this.patch !== 0 || this.prerelease.length === 0) {\n          this.minor++\n        }\n        this.patch = 0\n        this.prerelease = []\n        break\n      case 'patch':\n        // If this is not a pre-release version, it will increment the patch.\n        // If it is a pre-release it will bump up to the same patch version.\n        // 1.2.0-5 patches to 1.2.0\n        // 1.2.0 patches to 1.2.1\n        if (this.prerelease.length === 0) {\n          this.patch++\n        }\n        this.prerelease = []\n        break\n      // This probably shouldn't be used publicly.\n      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.\n      case 'pre':\n        if (this.prerelease.length === 0) {\n          this.prerelease = [0]\n        } else {\n          let i = this.prerelease.length\n          while (--i >= 0) {\n            if (typeof this.prerelease[i] === 'number') {\n              this.prerelease[i]++\n              i = -2\n            }\n          }\n          if (i === -1) {\n            // didn't increment anything\n            this.prerelease.push(0)\n          }\n        }\n        if (identifier) {\n          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n          if (this.prerelease[0] === identifier) {\n            if (isNaN(this.prerelease[1])) {\n              this.prerelease = [identifier, 0]\n            }\n          } else {\n            this.prerelease = [identifier, 0]\n          }\n        }\n        break\n\n      default:\n        throw new Error(`invalid increment argument: ${release}`)\n    }\n    this.format()\n    this.raw = this.version\n    return this\n  }\n}\n\nmodule.exports = SemVer\n","const parse = require('./parse')\nconst clean = (version, options) => {\n  const s = parse(version.trim().replace(/^[=v]+/, ''), options)\n  return s ? s.version : null\n}\nmodule.exports = clean\n","const eq = require('./eq')\nconst neq = require('./neq')\nconst gt = require('./gt')\nconst gte = require('./gte')\nconst lt = require('./lt')\nconst lte = require('./lte')\n\nconst cmp = (a, op, b, loose) => {\n  switch (op) {\n    case '===':\n      if (typeof a === 'object')\n        a = a.version\n      if (typeof b === 'object')\n        b = b.version\n      return a === b\n\n    case '!==':\n      if (typeof a === 'object')\n        a = a.version\n      if (typeof b === 'object')\n        b = b.version\n      return a !== b\n\n    case '':\n    case '=':\n    case '==':\n      return eq(a, b, loose)\n\n    case '!=':\n      return neq(a, b, loose)\n\n    case '>':\n      return gt(a, b, loose)\n\n    case '>=':\n      return gte(a, b, loose)\n\n    case '<':\n      return lt(a, b, loose)\n\n    case '<=':\n      return lte(a, b, loose)\n\n    default:\n      throw new TypeError(`Invalid operator: ${op}`)\n  }\n}\nmodule.exports = cmp\n","const SemVer = require('../classes/semver')\nconst parse = require('./parse')\nconst {re, t} = require('../internal/re')\n\nconst coerce = (version, options) => {\n  if (version instanceof SemVer) {\n    return version\n  }\n\n  if (typeof version === 'number') {\n    version = String(version)\n  }\n\n  if (typeof version !== 'string') {\n    return null\n  }\n\n  options = options || {}\n\n  let match = null\n  if (!options.rtl) {\n    match = version.match(re[t.COERCE])\n  } else {\n    // Find the right-most coercible string that does not share\n    // a terminus with a more left-ward coercible string.\n    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'\n    //\n    // Walk through the string checking with a /g regexp\n    // Manually set the index so as to pick up overlapping matches.\n    // Stop when we get a match that ends at the string end, since no\n    // coercible string can be more right-ward without the same terminus.\n    let next\n    while ((next = re[t.COERCERTL].exec(version)) &&\n        (!match || match.index + match[0].length !== version.length)\n    ) {\n      if (!match ||\n            next.index + next[0].length !== match.index + match[0].length) {\n        match = next\n      }\n      re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length\n    }\n    // leave it in a clean state\n    re[t.COERCERTL].lastIndex = -1\n  }\n\n  if (match === null)\n    return null\n\n  return parse(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)\n}\nmodule.exports = coerce\n","const SemVer = require('../classes/semver')\nconst compareBuild = (a, b, loose) => {\n  const versionA = new SemVer(a, loose)\n  const versionB = new SemVer(b, loose)\n  return versionA.compare(versionB) || versionA.compareBuild(versionB)\n}\nmodule.exports = compareBuild\n","const compare = require('./compare')\nconst compareLoose = (a, b) => compare(a, b, true)\nmodule.exports = compareLoose\n","const SemVer = require('../classes/semver')\nconst compare = (a, b, loose) =>\n  new SemVer(a, loose).compare(new SemVer(b, loose))\n\nmodule.exports = compare\n","const parse = require('./parse')\nconst eq = require('./eq')\n\nconst diff = (version1, version2) => {\n  if (eq(version1, version2)) {\n    return null\n  } else {\n    const v1 = parse(version1)\n    const v2 = parse(version2)\n    const hasPre = v1.prerelease.length || v2.prerelease.length\n    const prefix = hasPre ? 'pre' : ''\n    const defaultResult = hasPre ? 'prerelease' : ''\n    for (const key in v1) {\n      if (key === 'major' || key === 'minor' || key === 'patch') {\n        if (v1[key] !== v2[key]) {\n          return prefix + key\n        }\n      }\n    }\n    return defaultResult // may be undefined\n  }\n}\nmodule.exports = diff\n","const compare = require('./compare')\nconst eq = (a, b, loose) => compare(a, b, loose) === 0\nmodule.exports = eq\n","const compare = require('./compare')\nconst gt = (a, b, loose) => compare(a, b, loose) > 0\nmodule.exports = gt\n","const compare = require('./compare')\nconst gte = (a, b, loose) => compare(a, b, loose) >= 0\nmodule.exports = gte\n","const SemVer = require('../classes/semver')\n\nconst inc = (version, release, options, identifier) => {\n  if (typeof (options) === 'string') {\n    identifier = options\n    options = undefined\n  }\n\n  try {\n    return new SemVer(version, options).inc(release, identifier).version\n  } catch (er) {\n    return null\n  }\n}\nmodule.exports = inc\n","const compare = require('./compare')\nconst lt = (a, b, loose) => compare(a, b, loose) < 0\nmodule.exports = lt\n","const compare = require('./compare')\nconst lte = (a, b, loose) => compare(a, b, loose) <= 0\nmodule.exports = lte\n","const SemVer = require('../classes/semver')\nconst major = (a, loose) => new SemVer(a, loose).major\nmodule.exports = major\n","const SemVer = require('../classes/semver')\nconst minor = (a, loose) => new SemVer(a, loose).minor\nmodule.exports = minor\n","const compare = require('./compare')\nconst neq = (a, b, loose) => compare(a, b, loose) !== 0\nmodule.exports = neq\n","const {MAX_LENGTH} = require('../internal/constants')\nconst { re, t } = require('../internal/re')\nconst SemVer = require('../classes/semver')\n\nconst parse = (version, options) => {\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    }\n  }\n\n  if (version instanceof SemVer) {\n    return version\n  }\n\n  if (typeof version !== 'string') {\n    return null\n  }\n\n  if (version.length > MAX_LENGTH) {\n    return null\n  }\n\n  const r = options.loose ? re[t.LOOSE] : re[t.FULL]\n  if (!r.test(version)) {\n    return null\n  }\n\n  try {\n    return new SemVer(version, options)\n  } catch (er) {\n    return null\n  }\n}\n\nmodule.exports = parse\n","const SemVer = require('../classes/semver')\nconst patch = (a, loose) => new SemVer(a, loose).patch\nmodule.exports = patch\n","const parse = require('./parse')\nconst prerelease = (version, options) => {\n  const parsed = parse(version, options)\n  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null\n}\nmodule.exports = prerelease\n","const compare = require('./compare')\nconst rcompare = (a, b, loose) => compare(b, a, loose)\nmodule.exports = rcompare\n","const compareBuild = require('./compare-build')\nconst rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))\nmodule.exports = rsort\n","const Range = require('../classes/range')\nconst satisfies = (version, range, options) => {\n  try {\n    range = new Range(range, options)\n  } catch (er) {\n    return false\n  }\n  return range.test(version)\n}\nmodule.exports = satisfies\n","const compareBuild = require('./compare-build')\nconst sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))\nmodule.exports = sort\n","const parse = require('./parse')\nconst valid = (version, options) => {\n  const v = parse(version, options)\n  return v ? v.version : null\n}\nmodule.exports = valid\n","// just pre-load all the stuff that index.js lazily exports\nconst internalRe = require('./internal/re')\nmodule.exports = {\n  re: internalRe.re,\n  src: internalRe.src,\n  tokens: internalRe.t,\n  SEMVER_SPEC_VERSION: require('./internal/constants').SEMVER_SPEC_VERSION,\n  SemVer: require('./classes/semver'),\n  compareIdentifiers: require('./internal/identifiers').compareIdentifiers,\n  rcompareIdentifiers: require('./internal/identifiers').rcompareIdentifiers,\n  parse: require('./functions/parse'),\n  valid: require('./functions/valid'),\n  clean: require('./functions/clean'),\n  inc: require('./functions/inc'),\n  diff: require('./functions/diff'),\n  major: require('./functions/major'),\n  minor: require('./functions/minor'),\n  patch: require('./functions/patch'),\n  prerelease: require('./functions/prerelease'),\n  compare: require('./functions/compare'),\n  rcompare: require('./functions/rcompare'),\n  compareLoose: require('./functions/compare-loose'),\n  compareBuild: require('./functions/compare-build'),\n  sort: require('./functions/sort'),\n  rsort: require('./functions/rsort'),\n  gt: require('./functions/gt'),\n  lt: require('./functions/lt'),\n  eq: require('./functions/eq'),\n  neq: require('./functions/neq'),\n  gte: require('./functions/gte'),\n  lte: require('./functions/lte'),\n  cmp: require('./functions/cmp'),\n  coerce: require('./functions/coerce'),\n  Comparator: require('./classes/comparator'),\n  Range: require('./classes/range'),\n  satisfies: require('./functions/satisfies'),\n  toComparators: require('./ranges/to-comparators'),\n  maxSatisfying: require('./ranges/max-satisfying'),\n  minSatisfying: require('./ranges/min-satisfying'),\n  minVersion: require('./ranges/min-version'),\n  validRange: require('./ranges/valid'),\n  outside: require('./ranges/outside'),\n  gtr: require('./ranges/gtr'),\n  ltr: require('./ranges/ltr'),\n  intersects: require('./ranges/intersects'),\n  simplifyRange: require('./ranges/simplify'),\n  subset: require('./ranges/subset'),\n}\n","// Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\nconst SEMVER_SPEC_VERSION = '2.0.0'\n\nconst MAX_LENGTH = 256\nconst MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||\n  /* istanbul ignore next */ 9007199254740991\n\n// Max safe segment length for coercion.\nconst MAX_SAFE_COMPONENT_LENGTH = 16\n\nmodule.exports = {\n  SEMVER_SPEC_VERSION,\n  MAX_LENGTH,\n  MAX_SAFE_INTEGER,\n  MAX_SAFE_COMPONENT_LENGTH\n}\n","const debug = (\n  typeof process === 'object' &&\n  process.env &&\n  process.env.NODE_DEBUG &&\n  /\\bsemver\\b/i.test(process.env.NODE_DEBUG)\n) ? (...args) => console.error('SEMVER', ...args)\n  : () => {}\n\nmodule.exports = debug\n","const numeric = /^[0-9]+$/\nconst compareIdentifiers = (a, b) => {\n  const anum = numeric.test(a)\n  const bnum = numeric.test(b)\n\n  if (anum && bnum) {\n    a = +a\n    b = +b\n  }\n\n  return a === b ? 0\n    : (anum && !bnum) ? -1\n    : (bnum && !anum) ? 1\n    : a < b ? -1\n    : 1\n}\n\nconst rcompareIdentifiers = (a, b) => compareIdentifiers(b, a)\n\nmodule.exports = {\n  compareIdentifiers,\n  rcompareIdentifiers\n}\n","const { MAX_SAFE_COMPONENT_LENGTH } = require('./constants')\nconst debug = require('./debug')\nexports = module.exports = {}\n\n// The actual regexps go on exports.re\nconst re = exports.re = []\nconst src = exports.src = []\nconst t = exports.t = {}\nlet R = 0\n\nconst createToken = (name, value, isGlobal) => {\n  const index = R++\n  debug(index, value)\n  t[name] = index\n  src[index] = value\n  re[index] = new RegExp(value, isGlobal ? 'g' : undefined)\n}\n\n// The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\n\ncreateToken('NUMERICIDENTIFIER', '0|[1-9]\\\\d*')\ncreateToken('NUMERICIDENTIFIERLOOSE', '[0-9]+')\n\n// ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\n\ncreateToken('NONNUMERICIDENTIFIER', '\\\\d*[a-zA-Z-][a-zA-Z0-9-]*')\n\n// ## Main Version\n// Three dot-separated numeric identifiers.\n\ncreateToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\\\.` +\n                   `(${src[t.NUMERICIDENTIFIER]})\\\\.` +\n                   `(${src[t.NUMERICIDENTIFIER]})`)\n\ncreateToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` +\n                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` +\n                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`)\n\n// ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\n\ncreateToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]\n}|${src[t.NONNUMERICIDENTIFIER]})`)\n\ncreateToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]\n}|${src[t.NONNUMERICIDENTIFIER]})`)\n\n// ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\n\ncreateToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]\n}(?:\\\\.${src[t.PRERELEASEIDENTIFIER]})*))`)\n\ncreateToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]\n}(?:\\\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)\n\n// ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\n\ncreateToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+')\n\n// ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\n\ncreateToken('BUILD', `(?:\\\\+(${src[t.BUILDIDENTIFIER]\n}(?:\\\\.${src[t.BUILDIDENTIFIER]})*))`)\n\n// ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups.  The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\n\ncreateToken('FULLPLAIN', `v?${src[t.MAINVERSION]\n}${src[t.PRERELEASE]}?${\n  src[t.BUILD]}?`)\n\ncreateToken('FULL', `^${src[t.FULLPLAIN]}$`)\n\n// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\ncreateToken('LOOSEPLAIN', `[v=\\\\s]*${src[t.MAINVERSIONLOOSE]\n}${src[t.PRERELEASELOOSE]}?${\n  src[t.BUILD]}?`)\n\ncreateToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)\n\ncreateToken('GTLT', '((?:<|>)?=?)')\n\n// Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\ncreateToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\\\*`)\ncreateToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\\\*`)\n\ncreateToken('XRANGEPLAIN', `[v=\\\\s]*(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:${src[t.PRERELEASE]})?${\n                     src[t.BUILD]}?` +\n                   `)?)?`)\n\ncreateToken('XRANGEPLAINLOOSE', `[v=\\\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:${src[t.PRERELEASELOOSE]})?${\n                          src[t.BUILD]}?` +\n                        `)?)?`)\n\ncreateToken('XRANGE', `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAIN]}$`)\ncreateToken('XRANGELOOSE', `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAINLOOSE]}$`)\n\n// Coercion.\n// Extract anything that could conceivably be a part of a valid semver\ncreateToken('COERCE', `${'(^|[^\\\\d])' +\n              '(\\\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +\n              `(?:\\\\.(\\\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +\n              `(?:\\\\.(\\\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +\n              `(?:$|[^\\\\d])`)\ncreateToken('COERCERTL', src[t.COERCE], true)\n\n// Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\ncreateToken('LONETILDE', '(?:~>?)')\n\ncreateToken('TILDETRIM', `(\\\\s*)${src[t.LONETILDE]}\\\\s+`, true)\nexports.tildeTrimReplace = '$1~'\n\ncreateToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)\ncreateToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)\n\n// Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\ncreateToken('LONECARET', '(?:\\\\^)')\n\ncreateToken('CARETTRIM', `(\\\\s*)${src[t.LONECARET]}\\\\s+`, true)\nexports.caretTrimReplace = '$1^'\n\ncreateToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)\ncreateToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)\n\n// A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\ncreateToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\\\s*(${src[t.LOOSEPLAIN]})$|^$`)\ncreateToken('COMPARATOR', `^${src[t.GTLT]}\\\\s*(${src[t.FULLPLAIN]})$|^$`)\n\n// An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\ncreateToken('COMPARATORTRIM', `(\\\\s*)${src[t.GTLT]\n}\\\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)\nexports.comparatorTrimReplace = '$1$2$3'\n\n// Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\ncreateToken('HYPHENRANGE', `^\\\\s*(${src[t.XRANGEPLAIN]})` +\n                   `\\\\s+-\\\\s+` +\n                   `(${src[t.XRANGEPLAIN]})` +\n                   `\\\\s*$`)\n\ncreateToken('HYPHENRANGELOOSE', `^\\\\s*(${src[t.XRANGEPLAINLOOSE]})` +\n                        `\\\\s+-\\\\s+` +\n                        `(${src[t.XRANGEPLAINLOOSE]})` +\n                        `\\\\s*$`)\n\n// Star ranges basically just allow anything at all.\ncreateToken('STAR', '(<|>)?=?\\\\s*\\\\*')\n// >=0.0.0 is like a star\ncreateToken('GTE0', '^\\\\s*>=\\\\s*0\\.0\\.0\\\\s*$')\ncreateToken('GTE0PRE', '^\\\\s*>=\\\\s*0\\.0\\.0-0\\\\s*$')\n","// Determine if version is greater than all the versions possible in the range.\nconst outside = require('./outside')\nconst gtr = (version, range, options) => outside(version, range, '>', options)\nmodule.exports = gtr\n","const Range = require('../classes/range')\nconst intersects = (r1, r2, options) => {\n  r1 = new Range(r1, options)\n  r2 = new Range(r2, options)\n  return r1.intersects(r2)\n}\nmodule.exports = intersects\n","const outside = require('./outside')\n// Determine if version is less than all the versions possible in the range\nconst ltr = (version, range, options) => outside(version, range, '<', options)\nmodule.exports = ltr\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\n\nconst maxSatisfying = (versions, range, options) => {\n  let max = null\n  let maxSV = null\n  let rangeObj = null\n  try {\n    rangeObj = new Range(range, options)\n  } catch (er) {\n    return null\n  }\n  versions.forEach((v) => {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!max || maxSV.compare(v) === -1) {\n        // compare(max, v, true)\n        max = v\n        maxSV = new SemVer(max, options)\n      }\n    }\n  })\n  return max\n}\nmodule.exports = maxSatisfying\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\nconst minSatisfying = (versions, range, options) => {\n  let min = null\n  let minSV = null\n  let rangeObj = null\n  try {\n    rangeObj = new Range(range, options)\n  } catch (er) {\n    return null\n  }\n  versions.forEach((v) => {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!min || minSV.compare(v) === 1) {\n        // compare(min, v, true)\n        min = v\n        minSV = new SemVer(min, options)\n      }\n    }\n  })\n  return min\n}\nmodule.exports = minSatisfying\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\nconst gt = require('../functions/gt')\n\nconst minVersion = (range, loose) => {\n  range = new Range(range, loose)\n\n  let minver = new SemVer('0.0.0')\n  if (range.test(minver)) {\n    return minver\n  }\n\n  minver = new SemVer('0.0.0-0')\n  if (range.test(minver)) {\n    return minver\n  }\n\n  minver = null\n  for (let i = 0; i < range.set.length; ++i) {\n    const comparators = range.set[i]\n\n    comparators.forEach((comparator) => {\n      // Clone to avoid manipulating the comparator's semver object.\n      const compver = new SemVer(comparator.semver.version)\n      switch (comparator.operator) {\n        case '>':\n          if (compver.prerelease.length === 0) {\n            compver.patch++\n          } else {\n            compver.prerelease.push(0)\n          }\n          compver.raw = compver.format()\n          /* fallthrough */\n        case '':\n        case '>=':\n          if (!minver || gt(minver, compver)) {\n            minver = compver\n          }\n          break\n        case '<':\n        case '<=':\n          /* Ignore maximum versions */\n          break\n        /* istanbul ignore next */\n        default:\n          throw new Error(`Unexpected operation: ${comparator.operator}`)\n      }\n    })\n  }\n\n  if (minver && range.test(minver)) {\n    return minver\n  }\n\n  return null\n}\nmodule.exports = minVersion\n","const SemVer = require('../classes/semver')\nconst Comparator = require('../classes/comparator')\nconst {ANY} = Comparator\nconst Range = require('../classes/range')\nconst satisfies = require('../functions/satisfies')\nconst gt = require('../functions/gt')\nconst lt = require('../functions/lt')\nconst lte = require('../functions/lte')\nconst gte = require('../functions/gte')\n\nconst outside = (version, range, hilo, options) => {\n  version = new SemVer(version, options)\n  range = new Range(range, options)\n\n  let gtfn, ltefn, ltfn, comp, ecomp\n  switch (hilo) {\n    case '>':\n      gtfn = gt\n      ltefn = lte\n      ltfn = lt\n      comp = '>'\n      ecomp = '>='\n      break\n    case '<':\n      gtfn = lt\n      ltefn = gte\n      ltfn = gt\n      comp = '<'\n      ecomp = '<='\n      break\n    default:\n      throw new TypeError('Must provide a hilo val of \"<\" or \">\"')\n  }\n\n  // If it satisifes the range it is not outside\n  if (satisfies(version, range, options)) {\n    return false\n  }\n\n  // From now on, variable terms are as if we're in \"gtr\" mode.\n  // but note that everything is flipped for the \"ltr\" function.\n\n  for (let i = 0; i < range.set.length; ++i) {\n    const comparators = range.set[i]\n\n    let high = null\n    let low = null\n\n    comparators.forEach((comparator) => {\n      if (comparator.semver === ANY) {\n        comparator = new Comparator('>=0.0.0')\n      }\n      high = high || comparator\n      low = low || comparator\n      if (gtfn(comparator.semver, high.semver, options)) {\n        high = comparator\n      } else if (ltfn(comparator.semver, low.semver, options)) {\n        low = comparator\n      }\n    })\n\n    // If the edge version comparator has a operator then our version\n    // isn't outside it\n    if (high.operator === comp || high.operator === ecomp) {\n      return false\n    }\n\n    // If the lowest version comparator has an operator and our version\n    // is less than it then it isn't higher than the range\n    if ((!low.operator || low.operator === comp) &&\n        ltefn(version, low.semver)) {\n      return false\n    } else if (low.operator === ecomp && ltfn(version, low.semver)) {\n      return false\n    }\n  }\n  return true\n}\n\nmodule.exports = outside\n","// given a set of versions and a range, create a \"simplified\" range\n// that includes the same versions that the original range does\n// If the original range is shorter than the simplified one, return that.\nconst satisfies = require('../functions/satisfies.js')\nconst compare = require('../functions/compare.js')\nmodule.exports = (versions, range, options) => {\n  const set = []\n  let min = null\n  let prev = null\n  const v = versions.sort((a, b) => compare(a, b, options))\n  for (const version of v) {\n    const included = satisfies(version, range, options)\n    if (included) {\n      prev = version\n      if (!min)\n        min = version\n    } else {\n      if (prev) {\n        set.push([min, prev])\n      }\n      prev = null\n      min = null\n    }\n  }\n  if (min)\n    set.push([min, null])\n\n  const ranges = []\n  for (const [min, max] of set) {\n    if (min === max)\n      ranges.push(min)\n    else if (!max && min === v[0])\n      ranges.push('*')\n    else if (!max)\n      ranges.push(`>=${min}`)\n    else if (min === v[0])\n      ranges.push(`<=${max}`)\n    else\n      ranges.push(`${min} - ${max}`)\n  }\n  const simplified = ranges.join(' || ')\n  const original = typeof range.raw === 'string' ? range.raw : String(range)\n  return simplified.length < original.length ? simplified : range\n}\n","const Range = require('../classes/range.js')\nconst { ANY } = require('../classes/comparator.js')\nconst satisfies = require('../functions/satisfies.js')\nconst compare = require('../functions/compare.js')\n\n// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:\n// - Every simple range `r1, r2, ...` is a subset of some `R1, R2, ...`\n//\n// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:\n// - If c is only the ANY comparator\n//   - If C is only the ANY comparator, return true\n//   - Else return false\n// - Let EQ be the set of = comparators in c\n// - If EQ is more than one, return true (null set)\n// - Let GT be the highest > or >= comparator in c\n// - Let LT be the lowest < or <= comparator in c\n// - If GT and LT, and GT.semver > LT.semver, return true (null set)\n// - If EQ\n//   - If GT, and EQ does not satisfy GT, return true (null set)\n//   - If LT, and EQ does not satisfy LT, return true (null set)\n//   - If EQ satisfies every C, return true\n//   - Else return false\n// - If GT\n//   - If GT is lower than any > or >= comp in C, return false\n//   - If GT is >=, and GT.semver does not satisfy every C, return false\n// - If LT\n//   - If LT.semver is greater than that of any > comp in C, return false\n//   - If LT is <=, and LT.semver does not satisfy every C, return false\n// - If any C is a = range, and GT or LT are set, return false\n// - Else return true\n\nconst subset = (sub, dom, options) => {\n  sub = new Range(sub, options)\n  dom = new Range(dom, options)\n  let sawNonNull = false\n\n  OUTER: for (const simpleSub of sub.set) {\n    for (const simpleDom of dom.set) {\n      const isSub = simpleSubset(simpleSub, simpleDom, options)\n      sawNonNull = sawNonNull || isSub !== null\n      if (isSub)\n        continue OUTER\n    }\n    // the null set is a subset of everything, but null simple ranges in\n    // a complex range should be ignored.  so if we saw a non-null range,\n    // then we know this isn't a subset, but if EVERY simple range was null,\n    // then it is a subset.\n    if (sawNonNull)\n      return false\n  }\n  return true\n}\n\nconst simpleSubset = (sub, dom, options) => {\n  if (sub.length === 1 && sub[0].semver === ANY)\n    return dom.length === 1 && dom[0].semver === ANY\n\n  const eqSet = new Set()\n  let gt, lt\n  for (const c of sub) {\n    if (c.operator === '>' || c.operator === '>=')\n      gt = higherGT(gt, c, options)\n    else if (c.operator === '<' || c.operator === '<=')\n      lt = lowerLT(lt, c, options)\n    else\n      eqSet.add(c.semver)\n  }\n\n  if (eqSet.size > 1)\n    return null\n\n  let gtltComp\n  if (gt && lt) {\n    gtltComp = compare(gt.semver, lt.semver, options)\n    if (gtltComp > 0)\n      return null\n    else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<='))\n      return null\n  }\n\n  // will iterate one or zero times\n  for (const eq of eqSet) {\n    if (gt && !satisfies(eq, String(gt), options))\n      return null\n\n    if (lt && !satisfies(eq, String(lt), options))\n      return null\n\n    for (const c of dom) {\n      if (!satisfies(eq, String(c), options))\n        return false\n    }\n    return true\n  }\n\n  let higher, lower\n  let hasDomLT, hasDomGT\n  for (const c of dom) {\n    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>='\n    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<='\n    if (gt) {\n      if (c.operator === '>' || c.operator === '>=') {\n        higher = higherGT(gt, c, options)\n        if (higher === c)\n          return false\n      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options))\n        return false\n    }\n    if (lt) {\n      if (c.operator === '<' || c.operator === '<=') {\n        lower = lowerLT(lt, c, options)\n        if (lower === c)\n          return false\n      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options))\n        return false\n    }\n    if (!c.operator && (lt || gt) && gtltComp !== 0)\n      return false\n  }\n\n  // if there was a < or >, and nothing in the dom, then must be false\n  // UNLESS it was limited by another range in the other direction.\n  // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0\n  if (gt && hasDomLT && !lt && gtltComp !== 0)\n    return false\n\n  if (lt && hasDomGT && !gt && gtltComp !== 0)\n    return false\n\n  return true\n}\n\n// >=1.2.3 is lower than >1.2.3\nconst higherGT = (a, b, options) => {\n  if (!a)\n    return b\n  const comp = compare(a.semver, b.semver, options)\n  return comp > 0 ? a\n    : comp < 0 ? b\n    : b.operator === '>' && a.operator === '>=' ? b\n    : a\n}\n\n// <=1.2.3 is higher than <1.2.3\nconst lowerLT = (a, b, options) => {\n  if (!a)\n    return b\n  const comp = compare(a.semver, b.semver, options)\n  return comp < 0 ? a\n    : comp > 0 ? b\n    : b.operator === '<' && a.operator === '<=' ? b\n    : a\n}\n\nmodule.exports = subset\n","const Range = require('../classes/range')\n\n// Mostly just for testing and legacy API reasons\nconst toComparators = (range, options) =>\n  new Range(range, options).set\n    .map(comp => comp.map(c => c.value).join(' ').trim().split(' '))\n\nmodule.exports = toComparators\n","const Range = require('../classes/range')\nconst validRange = (range, options) => {\n  try {\n    // Return '*' instead of '' so that truthiness works.\n    // This will throw if it's invalid anyway\n    return new Range(range, options).range || '*'\n  } catch (er) {\n    return null\n  }\n}\nmodule.exports = validRange\n"],"names":["dispatchToastShown","getCoreTranslation","slugify","name","replace","importDynamic","jsPackage","share","options","maxLoadingTime","timeout","undefined","Promise","race","preloadImport","importMap","_","reject","setTimeout","Error","humanReadableMs","clearTimeout","jsPackageSlug","container","window","isFederatedModule","error","console","init","__webpack_share_scopes__","default","factory","get","module","ms","Math","floor","trim","length","activeImportMap","getCurrentImportMap","imports","hasOwnProperty","url","startsWith","spaBase","substring","isOverridden","localStorage","getItem","resolve","loadScript","err","kind","title","description","actionButtonLabel","onActionButtonClick","importMapOverrides","resetOverrides","location","reload","getCurrentPageMap","a","OPENMRS_SCRIPT_LOADING","Symbol","scriptElement","document","head","querySelector","scriptLoading","Set","add","element","createElement","src","type","async","loadTimeout","loadFn","errFn","finishScriptLoading","delete","removeEventListener","ev","msg","message","addEventListener","appendChild","has","warn","jsep","globalsAsync","extractVariableNames","expression","context","createAsynchronousContext","visitExpression","variables","visitUnaryExpression","visitBinaryExpression","visitConditionalExpression","visitCallExpression","visitArrowFunctionExpression","visitMemberExpression","visitArrayExpression","visitSequenceExpression","visitNewExpression","visitLiteral","visitIdentifier","visitTemplateLiteral","visitTemplateElement","argument","left","right","filter","Boolean","consequent","test","alternate","fn","callee","arguments","map","handleNullableExpression","newContext","isLocalExpression","params","bodyVariables","body","Array","isArray","v","includes","object","property","elements","expressions","quasis","globals","createContextInternal","globals_","handleNullableExpressionInner","localStorageRoutesPrefix","registerModuleLoad","emptyLifecycle","initializedApps","Map","getLoader","routesAppName","fullComponentName","poundIndex","indexOf","isNamespaced","appName","componentName","Object","hasOwn","initializeApp","then","_module","startup","catch","attach","registerExtension","registerModal","registerWorkspace","registerWorkspaceGroup","registerFeatureFlag","tryRegisterExtension","extension","slots","slot","component","load","loader","meta","order","moduleName","privileges","online","offline","featureFlag","tryRegisterModal","modal","tryRegisterWorkspace","workspace","canHide","canMaximize","width","preferredWindowSize","groups","group","members","tryRegisterWorkspaceGroup","workspaceGroup","tryRegisterFeatureFlag","flagName","label","bootstrap","mount","unmount","routeRegex","regex","result","pathname","getOpenmrsSpaBase","registerApp","finishRegisteringAllApps","pathToActiveWhen","registerApplication","registerModuleWithConfigSystem","getFeatureFlag","pages","getActivityFn","route","activators","some","activator","RegExp","wrapPageActivityFn","activityFn","offlineEnabled","navigator","onLine","routes","availableExtensions","extensions","availableModals","modals","availableWorkspaces","workspaces","availableWorkspaceGroups","workspaceGroups","availableFeatureFlags","featureFlags","forEach","p","push","Number","MAX_SAFE_INTEGER","ext","sort","b","localeCompare","appIndices","page","set","index","div","id","tryRegisterPage","canAccessStorage","isEnabled","addRoutesOverride","addRouteOverrideInternal","maybeRoutes","JSON","parse","isOpenmrsAppRoutes","e","URL","toString","removeRoutesOverride","key","removeItem","resetAllRoutesOverrides","localStorage1","i","setItem","stringify","prototype","call","isOpenmrsRoutes","entries","every","value","retry","shouldRetry","getDelay","onError","attempt","limitAttempts","getExponentialDelay","lastError","delay","maxAttempts","startingDelay","initialDelay","exponent","pow","res","storage","getDefaultsFromConfigSchema","schema","tmp","k","keys","isOrdinaryObject","_default","x","semver","normalizeOnlyVersion","version","major","minor","patch","split","normalizeFullVersion","idx","prerelease","ver","slice","pre","isVersionSatisfied","requiredVersion","installedVersion","satisfies","includePrerelease"],"sourceRoot":""}