{"version":3,"file":"static/js/33.0a6be810.chunk.js","mappings":"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A,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,KACf,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,KAC7B,C,mCC1vCO,IAAImW,EAAwB,8C,mCCC5B,IAAI3B,EAAW,CAClB,GAAM,CACF,KAEJ,GAAM,CACF,KAEJ,GAAM,CACF,KAEJ,GAAM,CACF,KAEJ,GAAM,CACF,KAEJ,GAAM,CACF,KAEJ,GAAM,CACF,KAEJ,GAAM,CACF,KAEJ,GAAM,CACF,KAEJ,GAAM,CACF,KAEJ,GAAM,CACF,KAEJ,GAAM,CACF,KAEJ,GAAM,CACF,KAEJ,GAAM,CACF,KAEJ,GAAM,CACF,IACA,KAEJ,GAAM,CACF,IACA,KAEJ,GAAM,CACF,IACA,KAEJ,GAAM,CACF,IACA,KAEJ,GAAM,CACF,IACA,KAEJ,GAAM,CACF,IACA,KAEJ,GAAM,CACF,IACA,KAEJ,GAAM,CACF,IACA,KAEJ,GAAM,CACF,IACA,KAEJ,GAAM,CACF,IACA,KAEJ,GAAM,CACF,IACA,KAEJ,GAAM,CACF,IACA,KAEJ,GAAM,CACF,IACA,KAEJ,MAAO,CACH,IACA,KAEJ,GAAM,CACF,IACA,IACA,MAEJ,GAAM,CACF,IACA,IACA,MAEJ,QAAS,CACL,IACA,IACA,MAEJ,GAAM,CACF,IACA,IACA,MAEJ,GAAM,CACF,IACA,IACA,MAEJ,QAAS,CACL,IACA,IACA,MAEJ,QAAS,CACL,IACA,IACA,MAEJ,QAAS,CACL,IACA,IACA,MAEJ,QAAS,CACL,IACA,IACA,MAEJ,GAAM,CACF,IACA,IACA,MAEJ,GAAM,CACF,IACA,IACA,MAEJ,GAAM,CACF,IACA,IACA,MAEJ,GAAM,CACF,IACA,IACA,MAEJ,GAAM,CACF,IACA,IACA,MAEJ,GAAM,CACF,IACA,IACA,MAEJ,GAAM,CACF,IACA,IACA,MAEJ,GAAM,CACF,IACA,IACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,QAAS,CACL,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,QAAS,CACL,IACA,IACA,KACA,MAEJ,QAAS,CACL,IACA,IACA,KACA,MAEJ,QAAS,CACL,IACA,IACA,KACA,MAEJ,QAAS,CACL,IACA,IACA,KACA,MAEJ,QAAS,CACL,IACA,IACA,KACA,MAEJ,QAAS,CACL,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KACA,MAEJ,GAAM,CACF,IACA,IACA,KAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,MAEJ,GAAM,CACF,IACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,SAAU,CACN,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,IACA,MAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,SAAU,CACN,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,GAAM,CACF,IACA,KACA,KACA,KAEJ,QAAS,CACL,IACA,KACA,KACA,KAEJ,GAAM,CACF,KACA,KAEJ,GAAM,CACF,KACA,KAEJ,QAAS,CACL,KACA,IACA,KAEJ,QAAS,CACL,KACA,IACA,KAEJ,QAAS,CACL,KA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","sources":["../node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js","../node_modules/@emotion/is-prop-valid/node_modules/@emotion/memoize/dist/emotion-memoize.esm.js","../node_modules/@emotion/stylis/dist/stylis.browser.esm.js","../node_modules/@emotion/unitless/dist/unitless.browser.esm.js","../node_modules/@formatjs/intl/lib/index.js","../node_modules/@formatjs/intl/lib/src/create-intl.js","../node_modules/@formatjs/intl/lib/src/dateTime.js","../node_modules/@formatjs/intl/lib/src/displayName.js","../node_modules/@formatjs/intl/lib/src/error.js","../node_modules/@formatjs/intl/lib/src/list.js","../node_modules/@formatjs/intl/lib/src/message.js","../node_modules/@formatjs/intl/lib/src/number.js","../node_modules/@formatjs/intl/lib/src/plural.js","../node_modules/@formatjs/intl/lib/src/relativeTime.js","../node_modules/@formatjs/intl/lib/src/utils.js","../node_modules/@formatjs/intl/node_modules/@formatjs/ecma402-abstract/lib/utils.js","../node_modules/@formatjs/intl/node_modules/@formatjs/fast-memoize/lib/index.js","../node_modules/@formatjs/intl/node_modules/@formatjs/icu-messageformat-parser/lib/date-time-pattern-generator.js","../node_modules/@formatjs/intl/node_modules/@formatjs/icu-messageformat-parser/lib/error.js","../node_modules/@formatjs/intl/node_modules/@formatjs/icu-messageformat-parser/lib/index.js","../node_modules/@formatjs/intl/node_modules/@formatjs/icu-messageformat-parser/lib/parser.js","../node_modules/@formatjs/intl/node_modules/@formatjs/icu-messageformat-parser/lib/regex.generated.js","../node_modules/@formatjs/intl/node_modules/@formatjs/icu-messageformat-parser/lib/time-data.generated.js","../node_modules/@formatjs/intl/node_modules/@formatjs/icu-messageformat-parser/lib/types.js","../node_modules/@formatjs/intl/node_modules/@formatjs/icu-skeleton-parser/lib/date-time.js","../node_modules/@formatjs/intl/node_modules/@formatjs/icu-skeleton-parser/lib/number.js","../node_modules/@formatjs/intl/node_modules/@formatjs/icu-skeleton-parser/lib/regex.generated.js","../node_modules/@formatjs/intl/node_modules/intl-messageformat/lib/src/core.js","../node_modules/@formatjs/intl/node_modules/intl-messageformat/lib/src/error.js","../node_modules/@formatjs/intl/node_modules/intl-messageformat/lib/src/formatters.js","../node_modules/copy-to-clipboard/index.js","../node_modules/deepmerge/dist/es.js","../node_modules/formik/src/FormikContext.tsx","../node_modules/formik/src/utils.ts","../node_modules/formik/src/Formik.tsx","../node_modules/formik/src/Field.tsx","../node_modules/formik/src/withFormik.tsx","../node_modules/formik/src/Form.tsx","../node_modules/formik/src/FieldArray.tsx"],"sourcesContent":["import memoize from '@emotion/memoize';\n\nvar reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|download|draggable|encType|enterKeyHint|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23\n\nvar isPropValid = /* #__PURE__ */memoize(function (prop) {\n  return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111\n  /* o */\n  && prop.charCodeAt(1) === 110\n  /* n */\n  && prop.charCodeAt(2) < 91;\n}\n/* Z+1 */\n);\n\nexport { isPropValid as default };\n","function memoize(fn) {\n  var cache = Object.create(null);\n  return function (arg) {\n    if (cache[arg] === undefined) cache[arg] = fn(arg);\n    return cache[arg];\n  };\n}\n\nexport { memoize as default };\n","function stylis_min (W) {\n  function M(d, c, e, h, a) {\n    for (var m = 0, b = 0, v = 0, n = 0, q, g, x = 0, K = 0, k, u = k = q = 0, l = 0, r = 0, I = 0, t = 0, B = e.length, J = B - 1, y, f = '', p = '', F = '', G = '', C; l < B;) {\n      g = e.charCodeAt(l);\n      l === J && 0 !== b + n + v + m && (0 !== b && (g = 47 === b ? 10 : 47), n = v = m = 0, B++, J++);\n\n      if (0 === b + n + v + m) {\n        if (l === J && (0 < r && (f = f.replace(N, '')), 0 < f.trim().length)) {\n          switch (g) {\n            case 32:\n            case 9:\n            case 59:\n            case 13:\n            case 10:\n              break;\n\n            default:\n              f += e.charAt(l);\n          }\n\n          g = 59;\n        }\n\n        switch (g) {\n          case 123:\n            f = f.trim();\n            q = f.charCodeAt(0);\n            k = 1;\n\n            for (t = ++l; l < B;) {\n              switch (g = e.charCodeAt(l)) {\n                case 123:\n                  k++;\n                  break;\n\n                case 125:\n                  k--;\n                  break;\n\n                case 47:\n                  switch (g = e.charCodeAt(l + 1)) {\n                    case 42:\n                    case 47:\n                      a: {\n                        for (u = l + 1; u < J; ++u) {\n                          switch (e.charCodeAt(u)) {\n                            case 47:\n                              if (42 === g && 42 === e.charCodeAt(u - 1) && l + 2 !== u) {\n                                l = u + 1;\n                                break a;\n                              }\n\n                              break;\n\n                            case 10:\n                              if (47 === g) {\n                                l = u + 1;\n                                break a;\n                              }\n\n                          }\n                        }\n\n                        l = u;\n                      }\n\n                  }\n\n                  break;\n\n                case 91:\n                  g++;\n\n                case 40:\n                  g++;\n\n                case 34:\n                case 39:\n                  for (; l++ < J && e.charCodeAt(l) !== g;) {\n                  }\n\n              }\n\n              if (0 === k) break;\n              l++;\n            }\n\n            k = e.substring(t, l);\n            0 === q && (q = (f = f.replace(ca, '').trim()).charCodeAt(0));\n\n            switch (q) {\n              case 64:\n                0 < r && (f = f.replace(N, ''));\n                g = f.charCodeAt(1);\n\n                switch (g) {\n                  case 100:\n                  case 109:\n                  case 115:\n                  case 45:\n                    r = c;\n                    break;\n\n                  default:\n                    r = O;\n                }\n\n                k = M(c, r, k, g, a + 1);\n                t = k.length;\n                0 < A && (r = X(O, f, I), C = H(3, k, r, c, D, z, t, g, a, h), f = r.join(''), void 0 !== C && 0 === (t = (k = C.trim()).length) && (g = 0, k = ''));\n                if (0 < t) switch (g) {\n                  case 115:\n                    f = f.replace(da, ea);\n\n                  case 100:\n                  case 109:\n                  case 45:\n                    k = f + '{' + k + '}';\n                    break;\n\n                  case 107:\n                    f = f.replace(fa, '$1 $2');\n                    k = f + '{' + k + '}';\n                    k = 1 === w || 2 === w && L('@' + k, 3) ? '@-webkit-' + k + '@' + k : '@' + k;\n                    break;\n\n                  default:\n                    k = f + k, 112 === h && (k = (p += k, ''));\n                } else k = '';\n                break;\n\n              default:\n                k = M(c, X(c, f, I), k, h, a + 1);\n            }\n\n            F += k;\n            k = I = r = u = q = 0;\n            f = '';\n            g = e.charCodeAt(++l);\n            break;\n\n          case 125:\n          case 59:\n            f = (0 < r ? f.replace(N, '') : f).trim();\n            if (1 < (t = f.length)) switch (0 === u && (q = f.charCodeAt(0), 45 === q || 96 < q && 123 > q) && (t = (f = f.replace(' ', ':')).length), 0 < A && void 0 !== (C = H(1, f, c, d, D, z, p.length, h, a, h)) && 0 === (t = (f = C.trim()).length) && (f = '\\x00\\x00'), q = f.charCodeAt(0), g = f.charCodeAt(1), q) {\n              case 0:\n                break;\n\n              case 64:\n                if (105 === g || 99 === g) {\n                  G += f + e.charAt(l);\n                  break;\n                }\n\n              default:\n                58 !== f.charCodeAt(t - 1) && (p += P(f, q, g, f.charCodeAt(2)));\n            }\n            I = r = u = q = 0;\n            f = '';\n            g = e.charCodeAt(++l);\n        }\n      }\n\n      switch (g) {\n        case 13:\n        case 10:\n          47 === b ? b = 0 : 0 === 1 + q && 107 !== h && 0 < f.length && (r = 1, f += '\\x00');\n          0 < A * Y && H(0, f, c, d, D, z, p.length, h, a, h);\n          z = 1;\n          D++;\n          break;\n\n        case 59:\n        case 125:\n          if (0 === b + n + v + m) {\n            z++;\n            break;\n          }\n\n        default:\n          z++;\n          y = e.charAt(l);\n\n          switch (g) {\n            case 9:\n            case 32:\n              if (0 === n + m + b) switch (x) {\n                case 44:\n                case 58:\n                case 9:\n                case 32:\n                  y = '';\n                  break;\n\n                default:\n                  32 !== g && (y = ' ');\n              }\n              break;\n\n            case 0:\n              y = '\\\\0';\n              break;\n\n            case 12:\n              y = '\\\\f';\n              break;\n\n            case 11:\n              y = '\\\\v';\n              break;\n\n            case 38:\n              0 === n + b + m && (r = I = 1, y = '\\f' + y);\n              break;\n\n            case 108:\n              if (0 === n + b + m + E && 0 < u) switch (l - u) {\n                case 2:\n                  112 === x && 58 === e.charCodeAt(l - 3) && (E = x);\n\n                case 8:\n                  111 === K && (E = K);\n              }\n              break;\n\n            case 58:\n              0 === n + b + m && (u = l);\n              break;\n\n            case 44:\n              0 === b + v + n + m && (r = 1, y += '\\r');\n              break;\n\n            case 34:\n            case 39:\n              0 === b && (n = n === g ? 0 : 0 === n ? g : n);\n              break;\n\n            case 91:\n              0 === n + b + v && m++;\n              break;\n\n            case 93:\n              0 === n + b + v && m--;\n              break;\n\n            case 41:\n              0 === n + b + m && v--;\n              break;\n\n            case 40:\n              if (0 === n + b + m) {\n                if (0 === q) switch (2 * x + 3 * K) {\n                  case 533:\n                    break;\n\n                  default:\n                    q = 1;\n                }\n                v++;\n              }\n\n              break;\n\n            case 64:\n              0 === b + v + n + m + u + k && (k = 1);\n              break;\n\n            case 42:\n            case 47:\n              if (!(0 < n + m + v)) switch (b) {\n                case 0:\n                  switch (2 * g + 3 * e.charCodeAt(l + 1)) {\n                    case 235:\n                      b = 47;\n                      break;\n\n                    case 220:\n                      t = l, b = 42;\n                  }\n\n                  break;\n\n                case 42:\n                  47 === g && 42 === x && t + 2 !== l && (33 === e.charCodeAt(t + 2) && (p += e.substring(t, l + 1)), y = '', b = 0);\n              }\n          }\n\n          0 === b && (f += y);\n      }\n\n      K = x;\n      x = g;\n      l++;\n    }\n\n    t = p.length;\n\n    if (0 < t) {\n      r = c;\n      if (0 < A && (C = H(2, p, r, d, D, z, t, h, a, h), void 0 !== C && 0 === (p = C).length)) return G + p + F;\n      p = r.join(',') + '{' + p + '}';\n\n      if (0 !== w * E) {\n        2 !== w || L(p, 2) || (E = 0);\n\n        switch (E) {\n          case 111:\n            p = p.replace(ha, ':-moz-$1') + p;\n            break;\n\n          case 112:\n            p = p.replace(Q, '::-webkit-input-$1') + p.replace(Q, '::-moz-$1') + p.replace(Q, ':-ms-input-$1') + p;\n        }\n\n        E = 0;\n      }\n    }\n\n    return G + p + F;\n  }\n\n  function X(d, c, e) {\n    var h = c.trim().split(ia);\n    c = h;\n    var a = h.length,\n        m = d.length;\n\n    switch (m) {\n      case 0:\n      case 1:\n        var b = 0;\n\n        for (d = 0 === m ? '' : d[0] + ' '; b < a; ++b) {\n          c[b] = Z(d, c[b], e).trim();\n        }\n\n        break;\n\n      default:\n        var v = b = 0;\n\n        for (c = []; b < a; ++b) {\n          for (var n = 0; n < m; ++n) {\n            c[v++] = Z(d[n] + ' ', h[b], e).trim();\n          }\n        }\n\n    }\n\n    return c;\n  }\n\n  function Z(d, c, e) {\n    var h = c.charCodeAt(0);\n    33 > h && (h = (c = c.trim()).charCodeAt(0));\n\n    switch (h) {\n      case 38:\n        return c.replace(F, '$1' + d.trim());\n\n      case 58:\n        return d.trim() + c.replace(F, '$1' + d.trim());\n\n      default:\n        if (0 < 1 * e && 0 < c.indexOf('\\f')) return c.replace(F, (58 === d.charCodeAt(0) ? '' : '$1') + d.trim());\n    }\n\n    return d + c;\n  }\n\n  function P(d, c, e, h) {\n    var a = d + ';',\n        m = 2 * c + 3 * e + 4 * h;\n\n    if (944 === m) {\n      d = a.indexOf(':', 9) + 1;\n      var b = a.substring(d, a.length - 1).trim();\n      b = a.substring(0, d).trim() + b + ';';\n      return 1 === w || 2 === w && L(b, 1) ? '-webkit-' + b + b : b;\n    }\n\n    if (0 === w || 2 === w && !L(a, 1)) return a;\n\n    switch (m) {\n      case 1015:\n        return 97 === a.charCodeAt(10) ? '-webkit-' + a + a : a;\n\n      case 951:\n        return 116 === a.charCodeAt(3) ? '-webkit-' + a + a : a;\n\n      case 963:\n        return 110 === a.charCodeAt(5) ? '-webkit-' + a + a : a;\n\n      case 1009:\n        if (100 !== a.charCodeAt(4)) break;\n\n      case 969:\n      case 942:\n        return '-webkit-' + a + a;\n\n      case 978:\n        return '-webkit-' + a + '-moz-' + a + a;\n\n      case 1019:\n      case 983:\n        return '-webkit-' + a + '-moz-' + a + '-ms-' + a + a;\n\n      case 883:\n        if (45 === a.charCodeAt(8)) return '-webkit-' + a + a;\n        if (0 < a.indexOf('image-set(', 11)) return a.replace(ja, '$1-webkit-$2') + a;\n        break;\n\n      case 932:\n        if (45 === a.charCodeAt(4)) switch (a.charCodeAt(5)) {\n          case 103:\n            return '-webkit-box-' + a.replace('-grow', '') + '-webkit-' + a + '-ms-' + a.replace('grow', 'positive') + a;\n\n          case 115:\n            return '-webkit-' + a + '-ms-' + a.replace('shrink', 'negative') + a;\n\n          case 98:\n            return '-webkit-' + a + '-ms-' + a.replace('basis', 'preferred-size') + a;\n        }\n        return '-webkit-' + a + '-ms-' + a + a;\n\n      case 964:\n        return '-webkit-' + a + '-ms-flex-' + a + a;\n\n      case 1023:\n        if (99 !== a.charCodeAt(8)) break;\n        b = a.substring(a.indexOf(':', 15)).replace('flex-', '').replace('space-between', 'justify');\n        return '-webkit-box-pack' + b + '-webkit-' + a + '-ms-flex-pack' + b + a;\n\n      case 1005:\n        return ka.test(a) ? a.replace(aa, ':-webkit-') + a.replace(aa, ':-moz-') + a : a;\n\n      case 1e3:\n        b = a.substring(13).trim();\n        c = b.indexOf('-') + 1;\n\n        switch (b.charCodeAt(0) + b.charCodeAt(c)) {\n          case 226:\n            b = a.replace(G, 'tb');\n            break;\n\n          case 232:\n            b = a.replace(G, 'tb-rl');\n            break;\n\n          case 220:\n            b = a.replace(G, 'lr');\n            break;\n\n          default:\n            return a;\n        }\n\n        return '-webkit-' + a + '-ms-' + b + a;\n\n      case 1017:\n        if (-1 === a.indexOf('sticky', 9)) break;\n\n      case 975:\n        c = (a = d).length - 10;\n        b = (33 === a.charCodeAt(c) ? a.substring(0, c) : a).substring(d.indexOf(':', 7) + 1).trim();\n\n        switch (m = b.charCodeAt(0) + (b.charCodeAt(7) | 0)) {\n          case 203:\n            if (111 > b.charCodeAt(8)) break;\n\n          case 115:\n            a = a.replace(b, '-webkit-' + b) + ';' + a;\n            break;\n\n          case 207:\n          case 102:\n            a = a.replace(b, '-webkit-' + (102 < m ? 'inline-' : '') + 'box') + ';' + a.replace(b, '-webkit-' + b) + ';' + a.replace(b, '-ms-' + b + 'box') + ';' + a;\n        }\n\n        return a + ';';\n\n      case 938:\n        if (45 === a.charCodeAt(5)) switch (a.charCodeAt(6)) {\n          case 105:\n            return b = a.replace('-items', ''), '-webkit-' + a + '-webkit-box-' + b + '-ms-flex-' + b + a;\n\n          case 115:\n            return '-webkit-' + a + '-ms-flex-item-' + a.replace(ba, '') + a;\n\n          default:\n            return '-webkit-' + a + '-ms-flex-line-pack' + a.replace('align-content', '').replace(ba, '') + a;\n        }\n        break;\n\n      case 973:\n      case 989:\n        if (45 !== a.charCodeAt(3) || 122 === a.charCodeAt(4)) break;\n\n      case 931:\n      case 953:\n        if (!0 === la.test(d)) return 115 === (b = d.substring(d.indexOf(':') + 1)).charCodeAt(0) ? P(d.replace('stretch', 'fill-available'), c, e, h).replace(':fill-available', ':stretch') : a.replace(b, '-webkit-' + b) + a.replace(b, '-moz-' + b.replace('fill-', '')) + a;\n        break;\n\n      case 962:\n        if (a = '-webkit-' + a + (102 === a.charCodeAt(5) ? '-ms-' + a : '') + a, 211 === e + h && 105 === a.charCodeAt(13) && 0 < a.indexOf('transform', 10)) return a.substring(0, a.indexOf(';', 27) + 1).replace(ma, '$1-webkit-$2') + a;\n    }\n\n    return a;\n  }\n\n  function L(d, c) {\n    var e = d.indexOf(1 === c ? ':' : '{'),\n        h = d.substring(0, 3 !== c ? e : 10);\n    e = d.substring(e + 1, d.length - 1);\n    return R(2 !== c ? h : h.replace(na, '$1'), e, c);\n  }\n\n  function ea(d, c) {\n    var e = P(c, c.charCodeAt(0), c.charCodeAt(1), c.charCodeAt(2));\n    return e !== c + ';' ? e.replace(oa, ' or ($1)').substring(4) : '(' + c + ')';\n  }\n\n  function H(d, c, e, h, a, m, b, v, n, q) {\n    for (var g = 0, x = c, w; g < A; ++g) {\n      switch (w = S[g].call(B, d, x, e, h, a, m, b, v, n, q)) {\n        case void 0:\n        case !1:\n        case !0:\n        case null:\n          break;\n\n        default:\n          x = w;\n      }\n    }\n\n    if (x !== c) return x;\n  }\n\n  function T(d) {\n    switch (d) {\n      case void 0:\n      case null:\n        A = S.length = 0;\n        break;\n\n      default:\n        if ('function' === typeof d) S[A++] = d;else if ('object' === typeof d) for (var c = 0, e = d.length; c < e; ++c) {\n          T(d[c]);\n        } else Y = !!d | 0;\n    }\n\n    return T;\n  }\n\n  function U(d) {\n    d = d.prefix;\n    void 0 !== d && (R = null, d ? 'function' !== typeof d ? w = 1 : (w = 2, R = d) : w = 0);\n    return U;\n  }\n\n  function B(d, c) {\n    var e = d;\n    33 > e.charCodeAt(0) && (e = e.trim());\n    V = e;\n    e = [V];\n\n    if (0 < A) {\n      var h = H(-1, c, e, e, D, z, 0, 0, 0, 0);\n      void 0 !== h && 'string' === typeof h && (c = h);\n    }\n\n    var a = M(O, e, c, 0, 0);\n    0 < A && (h = H(-2, a, e, e, D, z, a.length, 0, 0, 0), void 0 !== h && (a = h));\n    V = '';\n    E = 0;\n    z = D = 1;\n    return a;\n  }\n\n  var ca = /^\\0+/g,\n      N = /[\\0\\r\\f]/g,\n      aa = /: */g,\n      ka = /zoo|gra/,\n      ma = /([,: ])(transform)/g,\n      ia = /,\\r+?/g,\n      F = /([\\t\\r\\n ])*\\f?&/g,\n      fa = /@(k\\w+)\\s*(\\S*)\\s*/,\n      Q = /::(place)/g,\n      ha = /:(read-only)/g,\n      G = /[svh]\\w+-[tblr]{2}/,\n      da = /\\(\\s*(.*)\\s*\\)/g,\n      oa = /([\\s\\S]*?);/g,\n      ba = /-self|flex-/g,\n      na = /[^]*?(:[rp][el]a[\\w-]+)[^]*/,\n      la = /stretch|:\\s*\\w+\\-(?:conte|avail)/,\n      ja = /([^-])(image-set\\()/,\n      z = 1,\n      D = 1,\n      E = 0,\n      w = 1,\n      O = [],\n      S = [],\n      A = 0,\n      R = null,\n      Y = 0,\n      V = '';\n  B.use = T;\n  B.set = U;\n  void 0 !== W && U(W);\n  return B;\n}\n\nexport default stylis_min;\n","var unitlessKeys = {\n  animationIterationCount: 1,\n  borderImageOutset: 1,\n  borderImageSlice: 1,\n  borderImageWidth: 1,\n  boxFlex: 1,\n  boxFlexGroup: 1,\n  boxOrdinalGroup: 1,\n  columnCount: 1,\n  columns: 1,\n  flex: 1,\n  flexGrow: 1,\n  flexPositive: 1,\n  flexShrink: 1,\n  flexNegative: 1,\n  flexOrder: 1,\n  gridRow: 1,\n  gridRowEnd: 1,\n  gridRowSpan: 1,\n  gridRowStart: 1,\n  gridColumn: 1,\n  gridColumnEnd: 1,\n  gridColumnSpan: 1,\n  gridColumnStart: 1,\n  msGridRow: 1,\n  msGridRowSpan: 1,\n  msGridColumn: 1,\n  msGridColumnSpan: 1,\n  fontWeight: 1,\n  lineHeight: 1,\n  opacity: 1,\n  order: 1,\n  orphans: 1,\n  tabSize: 1,\n  widows: 1,\n  zIndex: 1,\n  zoom: 1,\n  WebkitLineClamp: 1,\n  // SVG-related properties\n  fillOpacity: 1,\n  floodOpacity: 1,\n  stopOpacity: 1,\n  strokeDasharray: 1,\n  strokeDashoffset: 1,\n  strokeMiterlimit: 1,\n  strokeOpacity: 1,\n  strokeWidth: 1\n};\n\nexport default unitlessKeys;\n","export * from './src/types';\nexport function defineMessages(msgs) {\n    return msgs;\n}\nexport function defineMessage(msg) {\n    return msg;\n}\nexport { createIntlCache, filterProps, DEFAULT_INTL_CONFIG, createFormatters, getNamedFormat, } from './src/utils';\nexport * from './src/error';\nexport { formatMessage } from './src/message';\nexport { formatDate, formatDateToParts, formatTime, formatTimeToParts, } from './src/dateTime';\nexport { formatDisplayName } from './src/displayName';\nexport { formatList } from './src/list';\nexport { formatPlural } from './src/plural';\nexport { formatRelativeTime } from './src/relativeTime';\nexport { formatNumber, formatNumberToParts } from './src/number';\nexport { createIntl } from './src/create-intl';\n","import { __assign } from \"tslib\";\nimport { createFormatters, DEFAULT_INTL_CONFIG } from './utils';\nimport { InvalidConfigError, MissingDataError } from './error';\nimport { formatNumber, formatNumberToParts } from './number';\nimport { formatRelativeTime } from './relativeTime';\nimport { formatDate, formatDateToParts, formatTime, formatTimeToParts, formatDateTimeRange, } from './dateTime';\nimport { formatPlural } from './plural';\nimport { formatMessage } from './message';\nimport { formatList, formatListToParts } from './list';\nimport { formatDisplayName } from './displayName';\nfunction messagesContainString(messages) {\n    var firstMessage = messages ? messages[Object.keys(messages)[0]] : undefined;\n    return typeof firstMessage === 'string';\n}\nfunction verifyConfigMessages(config) {\n    if (config.onWarn &&\n        config.defaultRichTextElements &&\n        messagesContainString(config.messages || {})) {\n        config.onWarn(\"[@formatjs/intl] \\\"defaultRichTextElements\\\" was specified but \\\"message\\\" was not pre-compiled. \\nPlease consider using \\\"@formatjs/cli\\\" to pre-compile your messages for performance.\\nFor more details see https://formatjs.io/docs/getting-started/message-distribution\");\n    }\n}\n/**\n * Create intl object\n * @param config intl config\n * @param cache cache for formatter instances to prevent memory leak\n */\nexport function createIntl(config, cache) {\n    var formatters = createFormatters(cache);\n    var resolvedConfig = __assign(__assign({}, DEFAULT_INTL_CONFIG), config);\n    var locale = resolvedConfig.locale, defaultLocale = resolvedConfig.defaultLocale, onError = resolvedConfig.onError;\n    if (!locale) {\n        if (onError) {\n            onError(new InvalidConfigError(\"\\\"locale\\\" was not configured, using \\\"\".concat(defaultLocale, \"\\\" as fallback. See https://formatjs.io/docs/react-intl/api#intlshape for more details\")));\n        }\n        // Since there's no registered locale data for `locale`, this will\n        // fallback to the `defaultLocale` to make sure things can render.\n        // The `messages` are overridden to the `defaultProps` empty object\n        // to maintain referential equality across re-renders. It's assumed\n        // each <FormattedMessage> contains a `defaultMessage` prop.\n        resolvedConfig.locale = resolvedConfig.defaultLocale || 'en';\n    }\n    else if (!Intl.NumberFormat.supportedLocalesOf(locale).length && onError) {\n        onError(new MissingDataError(\"Missing locale data for locale: \\\"\".concat(locale, \"\\\" in Intl.NumberFormat. Using default locale: \\\"\").concat(defaultLocale, \"\\\" as fallback. See https://formatjs.io/docs/react-intl#runtime-requirements for more details\")));\n    }\n    else if (!Intl.DateTimeFormat.supportedLocalesOf(locale).length &&\n        onError) {\n        onError(new MissingDataError(\"Missing locale data for locale: \\\"\".concat(locale, \"\\\" in Intl.DateTimeFormat. Using default locale: \\\"\").concat(defaultLocale, \"\\\" as fallback. See https://formatjs.io/docs/react-intl#runtime-requirements for more details\")));\n    }\n    verifyConfigMessages(resolvedConfig);\n    return __assign(__assign({}, resolvedConfig), { formatters: formatters, formatNumber: formatNumber.bind(null, resolvedConfig, formatters.getNumberFormat), formatNumberToParts: formatNumberToParts.bind(null, resolvedConfig, formatters.getNumberFormat), formatRelativeTime: formatRelativeTime.bind(null, resolvedConfig, formatters.getRelativeTimeFormat), formatDate: formatDate.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatDateToParts: formatDateToParts.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatTime: formatTime.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatDateTimeRange: formatDateTimeRange.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatTimeToParts: formatTimeToParts.bind(null, resolvedConfig, formatters.getDateTimeFormat), formatPlural: formatPlural.bind(null, resolvedConfig, formatters.getPluralRules), formatMessage: formatMessage.bind(null, resolvedConfig, formatters), $t: formatMessage.bind(null, resolvedConfig, formatters), formatList: formatList.bind(null, resolvedConfig, formatters.getListFormat), formatListToParts: formatListToParts.bind(null, resolvedConfig, formatters.getListFormat), formatDisplayName: formatDisplayName.bind(null, resolvedConfig, formatters.getDisplayNames) });\n}\n","import { __assign } from \"tslib\";\nimport { filterProps, getNamedFormat } from './utils';\nimport { IntlError, IntlErrorCode } from './error';\nvar DATE_TIME_FORMAT_OPTIONS = [\n    'localeMatcher',\n    'formatMatcher',\n    'timeZone',\n    'hour12',\n    'weekday',\n    'era',\n    'year',\n    'month',\n    'day',\n    'hour',\n    'minute',\n    'second',\n    'timeZoneName',\n    'hourCycle',\n    'dateStyle',\n    'timeStyle',\n    'calendar',\n    // 'dayPeriod',\n    'numberingSystem',\n];\nexport function getFormatter(_a, type, getDateTimeFormat, options) {\n    var locale = _a.locale, formats = _a.formats, onError = _a.onError, timeZone = _a.timeZone;\n    if (options === void 0) { options = {}; }\n    var format = options.format;\n    var defaults = __assign(__assign({}, (timeZone && { timeZone: timeZone })), (format && getNamedFormat(formats, type, format, onError)));\n    var filteredOptions = filterProps(options, DATE_TIME_FORMAT_OPTIONS, defaults);\n    if (type === 'time' &&\n        !filteredOptions.hour &&\n        !filteredOptions.minute &&\n        !filteredOptions.second &&\n        !filteredOptions.timeStyle &&\n        !filteredOptions.dateStyle) {\n        // Add default formatting options if hour, minute, or second isn't defined.\n        filteredOptions = __assign(__assign({}, filteredOptions), { hour: 'numeric', minute: 'numeric' });\n    }\n    return getDateTimeFormat(locale, filteredOptions);\n}\nexport function formatDate(config, getDateTimeFormat) {\n    var _a = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        _a[_i - 2] = arguments[_i];\n    }\n    var value = _a[0], _b = _a[1], options = _b === void 0 ? {} : _b;\n    var date = typeof value === 'string' ? new Date(value || 0) : value;\n    try {\n        return getFormatter(config, 'date', getDateTimeFormat, options).format(date);\n    }\n    catch (e) {\n        config.onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting date.', e));\n    }\n    return String(date);\n}\nexport function formatTime(config, getDateTimeFormat) {\n    var _a = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        _a[_i - 2] = arguments[_i];\n    }\n    var value = _a[0], _b = _a[1], options = _b === void 0 ? {} : _b;\n    var date = typeof value === 'string' ? new Date(value || 0) : value;\n    try {\n        return getFormatter(config, 'time', getDateTimeFormat, options).format(date);\n    }\n    catch (e) {\n        config.onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting time.', e));\n    }\n    return String(date);\n}\nexport function formatDateTimeRange(config, getDateTimeFormat) {\n    var _a = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        _a[_i - 2] = arguments[_i];\n    }\n    var from = _a[0], to = _a[1], _b = _a[2], options = _b === void 0 ? {} : _b;\n    var timeZone = config.timeZone, locale = config.locale, onError = config.onError;\n    var filteredOptions = filterProps(options, DATE_TIME_FORMAT_OPTIONS, timeZone ? { timeZone: timeZone } : {});\n    try {\n        return getDateTimeFormat(locale, filteredOptions).formatRange(from, to);\n    }\n    catch (e) {\n        onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting date time range.', e));\n    }\n    return String(from);\n}\nexport function formatDateToParts(config, getDateTimeFormat) {\n    var _a = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        _a[_i - 2] = arguments[_i];\n    }\n    var value = _a[0], _b = _a[1], options = _b === void 0 ? {} : _b;\n    var date = typeof value === 'string' ? new Date(value || 0) : value;\n    try {\n        return getFormatter(config, 'date', getDateTimeFormat, options).formatToParts(date);\n    }\n    catch (e) {\n        config.onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting date.', e));\n    }\n    return [];\n}\nexport function formatTimeToParts(config, getDateTimeFormat) {\n    var _a = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        _a[_i - 2] = arguments[_i];\n    }\n    var value = _a[0], _b = _a[1], options = _b === void 0 ? {} : _b;\n    var date = typeof value === 'string' ? new Date(value || 0) : value;\n    try {\n        return getFormatter(config, 'time', getDateTimeFormat, options).formatToParts(date);\n    }\n    catch (e) {\n        config.onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting time.', e));\n    }\n    return [];\n}\n","import { filterProps } from './utils';\nimport { FormatError, ErrorCode } from 'intl-messageformat';\nimport { IntlErrorCode, IntlError } from './error';\nvar DISPLAY_NAMES_OPTONS = [\n    'localeMatcher',\n    'style',\n    'type',\n    'fallback',\n];\nexport function formatDisplayName(_a, getDisplayNames, value, options) {\n    var locale = _a.locale, onError = _a.onError;\n    var DisplayNames = Intl.DisplayNames;\n    if (!DisplayNames) {\n        onError(new FormatError(\"Intl.DisplayNames is not available in this environment.\\nTry polyfilling it using \\\"@formatjs/intl-displaynames\\\"\\n\", ErrorCode.MISSING_INTL_API));\n    }\n    var filteredOptions = filterProps(options, DISPLAY_NAMES_OPTONS);\n    try {\n        return getDisplayNames(locale, filteredOptions).of(value);\n    }\n    catch (e) {\n        onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting display name.', e));\n    }\n}\n","import { __extends } from \"tslib\";\nexport var IntlErrorCode;\n(function (IntlErrorCode) {\n    IntlErrorCode[\"FORMAT_ERROR\"] = \"FORMAT_ERROR\";\n    IntlErrorCode[\"UNSUPPORTED_FORMATTER\"] = \"UNSUPPORTED_FORMATTER\";\n    IntlErrorCode[\"INVALID_CONFIG\"] = \"INVALID_CONFIG\";\n    IntlErrorCode[\"MISSING_DATA\"] = \"MISSING_DATA\";\n    IntlErrorCode[\"MISSING_TRANSLATION\"] = \"MISSING_TRANSLATION\";\n})(IntlErrorCode || (IntlErrorCode = {}));\nvar IntlError = /** @class */ (function (_super) {\n    __extends(IntlError, _super);\n    function IntlError(code, message, exception) {\n        var _this = this;\n        var err = exception\n            ? exception instanceof Error\n                ? exception\n                : new Error(String(exception))\n            : undefined;\n        _this = _super.call(this, \"[@formatjs/intl Error \".concat(code, \"] \").concat(message, \" \\n\").concat(err ? \"\\n\".concat(err.message, \"\\n\").concat(err.stack) : '')) || this;\n        _this.code = code;\n        // @ts-ignore just so we don't need to declare dep on @types/node\n        if (typeof Error.captureStackTrace === 'function') {\n            // @ts-ignore just so we don't need to declare dep on @types/node\n            Error.captureStackTrace(_this, IntlError);\n        }\n        return _this;\n    }\n    return IntlError;\n}(Error));\nexport { IntlError };\nvar UnsupportedFormatterError = /** @class */ (function (_super) {\n    __extends(UnsupportedFormatterError, _super);\n    function UnsupportedFormatterError(message, exception) {\n        return _super.call(this, IntlErrorCode.UNSUPPORTED_FORMATTER, message, exception) || this;\n    }\n    return UnsupportedFormatterError;\n}(IntlError));\nexport { UnsupportedFormatterError };\nvar InvalidConfigError = /** @class */ (function (_super) {\n    __extends(InvalidConfigError, _super);\n    function InvalidConfigError(message, exception) {\n        return _super.call(this, IntlErrorCode.INVALID_CONFIG, message, exception) || this;\n    }\n    return InvalidConfigError;\n}(IntlError));\nexport { InvalidConfigError };\nvar MissingDataError = /** @class */ (function (_super) {\n    __extends(MissingDataError, _super);\n    function MissingDataError(message, exception) {\n        return _super.call(this, IntlErrorCode.MISSING_DATA, message, exception) || this;\n    }\n    return MissingDataError;\n}(IntlError));\nexport { MissingDataError };\nvar IntlFormatError = /** @class */ (function (_super) {\n    __extends(IntlFormatError, _super);\n    function IntlFormatError(message, locale, exception) {\n        return _super.call(this, IntlErrorCode.FORMAT_ERROR, \"\".concat(message, \" \\nLocale: \").concat(locale, \"\\n\"), exception) || this;\n    }\n    return IntlFormatError;\n}(IntlError));\nexport { IntlFormatError };\nvar MessageFormatError = /** @class */ (function (_super) {\n    __extends(MessageFormatError, _super);\n    function MessageFormatError(message, locale, descriptor, exception) {\n        var _this = _super.call(this, \"\".concat(message, \" \\nMessageID: \").concat(descriptor === null || descriptor === void 0 ? void 0 : descriptor.id, \"\\nDefault Message: \").concat(descriptor === null || descriptor === void 0 ? void 0 : descriptor.defaultMessage, \"\\nDescription: \").concat(descriptor === null || descriptor === void 0 ? void 0 : descriptor.description, \" \\n\"), locale, exception) || this;\n        _this.descriptor = descriptor;\n        return _this;\n    }\n    return MessageFormatError;\n}(IntlFormatError));\nexport { MessageFormatError };\nvar MissingTranslationError = /** @class */ (function (_super) {\n    __extends(MissingTranslationError, _super);\n    function MissingTranslationError(descriptor, locale) {\n        var _this = _super.call(this, IntlErrorCode.MISSING_TRANSLATION, \"Missing message: \\\"\".concat(descriptor.id, \"\\\" for locale \\\"\").concat(locale, \"\\\", using \").concat(descriptor.defaultMessage ? 'default message' : 'id', \" as fallback.\")) || this;\n        _this.descriptor = descriptor;\n        return _this;\n    }\n    return MissingTranslationError;\n}(IntlError));\nexport { MissingTranslationError };\n","import { __assign } from \"tslib\";\nimport { filterProps } from './utils';\nimport { FormatError, ErrorCode } from 'intl-messageformat';\nimport { IntlError, IntlErrorCode } from './error';\nvar LIST_FORMAT_OPTIONS = [\n    'localeMatcher',\n    'type',\n    'style',\n];\nvar now = Date.now();\nfunction generateToken(i) {\n    return \"\".concat(now, \"_\").concat(i, \"_\").concat(now);\n}\nexport function formatList(opts, getListFormat, values, options) {\n    if (options === void 0) { options = {}; }\n    var results = formatListToParts(opts, getListFormat, values, options).reduce(function (all, el) {\n        var val = el.value;\n        if (typeof val !== 'string') {\n            all.push(val);\n        }\n        else if (typeof all[all.length - 1] === 'string') {\n            all[all.length - 1] += val;\n        }\n        else {\n            all.push(val);\n        }\n        return all;\n    }, []);\n    return results.length === 1 ? results[0] : results;\n}\nexport function formatListToParts(_a, getListFormat, values, options) {\n    var locale = _a.locale, onError = _a.onError;\n    if (options === void 0) { options = {}; }\n    var ListFormat = Intl.ListFormat;\n    if (!ListFormat) {\n        onError(new FormatError(\"Intl.ListFormat is not available in this environment.\\nTry polyfilling it using \\\"@formatjs/intl-listformat\\\"\\n\", ErrorCode.MISSING_INTL_API));\n    }\n    var filteredOptions = filterProps(options, LIST_FORMAT_OPTIONS);\n    try {\n        var richValues_1 = {};\n        var serializedValues = values.map(function (v, i) {\n            if (typeof v === 'object') {\n                var id = generateToken(i);\n                richValues_1[id] = v;\n                return id;\n            }\n            return String(v);\n        });\n        return getListFormat(locale, filteredOptions)\n            .formatToParts(serializedValues)\n            .map(function (part) {\n            return part.type === 'literal'\n                ? part\n                : __assign(__assign({}, part), { value: richValues_1[part.value] || part.value });\n        });\n    }\n    catch (e) {\n        onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting list.', e));\n    }\n    // @ts-ignore\n    return values;\n}\n","import { __assign } from \"tslib\";\nimport { invariant } from '@formatjs/ecma402-abstract';\nimport { IntlMessageFormat, } from 'intl-messageformat';\nimport { MissingTranslationError, MessageFormatError } from './error';\nimport { TYPE } from '@formatjs/icu-messageformat-parser';\nfunction setTimeZoneInOptions(opts, timeZone) {\n    return Object.keys(opts).reduce(function (all, k) {\n        all[k] = __assign({ timeZone: timeZone }, opts[k]);\n        return all;\n    }, {});\n}\nfunction deepMergeOptions(opts1, opts2) {\n    var keys = Object.keys(__assign(__assign({}, opts1), opts2));\n    return keys.reduce(function (all, k) {\n        all[k] = __assign(__assign({}, (opts1[k] || {})), (opts2[k] || {}));\n        return all;\n    }, {});\n}\nfunction deepMergeFormatsAndSetTimeZone(f1, timeZone) {\n    if (!timeZone) {\n        return f1;\n    }\n    var mfFormats = IntlMessageFormat.formats;\n    return __assign(__assign(__assign({}, mfFormats), f1), { date: deepMergeOptions(setTimeZoneInOptions(mfFormats.date, timeZone), setTimeZoneInOptions(f1.date || {}, timeZone)), time: deepMergeOptions(setTimeZoneInOptions(mfFormats.time, timeZone), setTimeZoneInOptions(f1.time || {}, timeZone)) });\n}\nexport function formatMessage(_a, state, messageDescriptor, values, opts) {\n    var locale = _a.locale, formats = _a.formats, messages = _a.messages, defaultLocale = _a.defaultLocale, defaultFormats = _a.defaultFormats, fallbackOnEmptyString = _a.fallbackOnEmptyString, onError = _a.onError, timeZone = _a.timeZone, defaultRichTextElements = _a.defaultRichTextElements;\n    if (messageDescriptor === void 0) { messageDescriptor = { id: '' }; }\n    var msgId = messageDescriptor.id, defaultMessage = messageDescriptor.defaultMessage;\n    // `id` is a required field of a Message Descriptor.\n    invariant(!!msgId, \"[@formatjs/intl] An `id` must be provided to format a message. You can either:\\n1. Configure your build toolchain with [babel-plugin-formatjs](https://formatjs.io/docs/tooling/babel-plugin)\\nor [@formatjs/ts-transformer](https://formatjs.io/docs/tooling/ts-transformer) OR\\n2. Configure your `eslint` config to include [eslint-plugin-formatjs](https://formatjs.io/docs/tooling/linter#enforce-id)\\nto autofix this issue\");\n    var id = String(msgId);\n    var message = \n    // In case messages is Object.create(null)\n    // e.g import('foo.json') from webpack)\n    // See https://github.com/formatjs/formatjs/issues/1914\n    messages &&\n        Object.prototype.hasOwnProperty.call(messages, id) &&\n        messages[id];\n    // IMPORTANT: Hot path if `message` is AST with a single literal node\n    if (Array.isArray(message) &&\n        message.length === 1 &&\n        message[0].type === TYPE.literal) {\n        return message[0].value;\n    }\n    // IMPORTANT: Hot path straight lookup for performance\n    if (!values &&\n        message &&\n        typeof message === 'string' &&\n        !defaultRichTextElements) {\n        return message.replace(/'\\{(.*?)\\}'/gi, \"{$1}\");\n    }\n    values = __assign(__assign({}, defaultRichTextElements), (values || {}));\n    formats = deepMergeFormatsAndSetTimeZone(formats, timeZone);\n    defaultFormats = deepMergeFormatsAndSetTimeZone(defaultFormats, timeZone);\n    if (!message) {\n        if (fallbackOnEmptyString === false && message === '') {\n            return message;\n        }\n        if (!defaultMessage ||\n            (locale && locale.toLowerCase() !== defaultLocale.toLowerCase())) {\n            // This prevents warnings from littering the console in development\n            // when no `messages` are passed into the <IntlProvider> for the\n            // default locale.\n            onError(new MissingTranslationError(messageDescriptor, locale));\n        }\n        if (defaultMessage) {\n            try {\n                var formatter = state.getMessageFormat(defaultMessage, defaultLocale, defaultFormats, opts);\n                return formatter.format(values);\n            }\n            catch (e) {\n                onError(new MessageFormatError(\"Error formatting default message for: \\\"\".concat(id, \"\\\", rendering default message verbatim\"), locale, messageDescriptor, e));\n                return typeof defaultMessage === 'string' ? defaultMessage : id;\n            }\n        }\n        return id;\n    }\n    // We have the translated message\n    try {\n        var formatter = state.getMessageFormat(message, locale, formats, __assign({ formatters: state }, (opts || {})));\n        return formatter.format(values);\n    }\n    catch (e) {\n        onError(new MessageFormatError(\"Error formatting message: \\\"\".concat(id, \"\\\", using \").concat(defaultMessage ? 'default message' : 'id', \" as fallback.\"), locale, messageDescriptor, e));\n    }\n    if (defaultMessage) {\n        try {\n            var formatter = state.getMessageFormat(defaultMessage, defaultLocale, defaultFormats, opts);\n            return formatter.format(values);\n        }\n        catch (e) {\n            onError(new MessageFormatError(\"Error formatting the default message for: \\\"\".concat(id, \"\\\", rendering message verbatim\"), locale, messageDescriptor, e));\n        }\n    }\n    if (typeof message === 'string') {\n        return message;\n    }\n    if (typeof defaultMessage === 'string') {\n        return defaultMessage;\n    }\n    return id;\n}\n","import { getNamedFormat, filterProps } from './utils';\nimport { IntlError, IntlErrorCode } from './error';\nvar NUMBER_FORMAT_OPTIONS = [\n    'localeMatcher',\n    'style',\n    'currency',\n    'currencyDisplay',\n    'unit',\n    'unitDisplay',\n    'useGrouping',\n    'minimumIntegerDigits',\n    'minimumFractionDigits',\n    'maximumFractionDigits',\n    'minimumSignificantDigits',\n    'maximumSignificantDigits',\n    // ES2020 NumberFormat\n    'compactDisplay',\n    'currencyDisplay',\n    'currencySign',\n    'notation',\n    'signDisplay',\n    'unit',\n    'unitDisplay',\n    'numberingSystem',\n];\nexport function getFormatter(_a, getNumberFormat, options) {\n    var locale = _a.locale, formats = _a.formats, onError = _a.onError;\n    if (options === void 0) { options = {}; }\n    var format = options.format;\n    var defaults = ((format &&\n        getNamedFormat(formats, 'number', format, onError)) ||\n        {});\n    var filteredOptions = filterProps(options, NUMBER_FORMAT_OPTIONS, defaults);\n    return getNumberFormat(locale, filteredOptions);\n}\nexport function formatNumber(config, getNumberFormat, value, options) {\n    if (options === void 0) { options = {}; }\n    try {\n        return getFormatter(config, getNumberFormat, options).format(value);\n    }\n    catch (e) {\n        config.onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting number.', e));\n    }\n    return String(value);\n}\nexport function formatNumberToParts(config, getNumberFormat, value, options) {\n    if (options === void 0) { options = {}; }\n    try {\n        return getFormatter(config, getNumberFormat, options).formatToParts(value);\n    }\n    catch (e) {\n        config.onError(new IntlError(IntlErrorCode.FORMAT_ERROR, 'Error formatting number.', e));\n    }\n    return [];\n}\n","import { filterProps } from './utils';\nimport { IntlFormatError } from './error';\nimport { ErrorCode, FormatError } from 'intl-messageformat';\nvar PLURAL_FORMAT_OPTIONS = [\n    'localeMatcher',\n    'type',\n];\nexport function formatPlural(_a, getPluralRules, value, options) {\n    var locale = _a.locale, onError = _a.onError;\n    if (options === void 0) { options = {}; }\n    if (!Intl.PluralRules) {\n        onError(new FormatError(\"Intl.PluralRules is not available in this environment.\\nTry polyfilling it using \\\"@formatjs/intl-pluralrules\\\"\\n\", ErrorCode.MISSING_INTL_API));\n    }\n    var filteredOptions = filterProps(options, PLURAL_FORMAT_OPTIONS);\n    try {\n        return getPluralRules(locale, filteredOptions).select(value);\n    }\n    catch (e) {\n        onError(new IntlFormatError('Error formatting plural.', locale, e));\n    }\n    return 'other';\n}\n","import { getNamedFormat, filterProps } from './utils';\nimport { FormatError, ErrorCode } from 'intl-messageformat';\nimport { IntlFormatError } from './error';\nvar RELATIVE_TIME_FORMAT_OPTIONS = ['numeric', 'style'];\nfunction getFormatter(_a, getRelativeTimeFormat, options) {\n    var locale = _a.locale, formats = _a.formats, onError = _a.onError;\n    if (options === void 0) { options = {}; }\n    var format = options.format;\n    var defaults = (!!format && getNamedFormat(formats, 'relative', format, onError)) || {};\n    var filteredOptions = filterProps(options, RELATIVE_TIME_FORMAT_OPTIONS, defaults);\n    return getRelativeTimeFormat(locale, filteredOptions);\n}\nexport function formatRelativeTime(config, getRelativeTimeFormat, value, unit, options) {\n    if (options === void 0) { options = {}; }\n    if (!unit) {\n        unit = 'second';\n    }\n    var RelativeTimeFormat = Intl.RelativeTimeFormat;\n    if (!RelativeTimeFormat) {\n        config.onError(new FormatError(\"Intl.RelativeTimeFormat is not available in this environment.\\nTry polyfilling it using \\\"@formatjs/intl-relativetimeformat\\\"\\n\", ErrorCode.MISSING_INTL_API));\n    }\n    try {\n        return getFormatter(config, getRelativeTimeFormat, options).format(value, unit);\n    }\n    catch (e) {\n        config.onError(new IntlFormatError('Error formatting relative time.', config.locale, e));\n    }\n    return String(value);\n}\n","import { __assign, __spreadArray } from \"tslib\";\nimport { IntlMessageFormat } from 'intl-messageformat';\nimport memoize, { strategies } from '@formatjs/fast-memoize';\nimport { UnsupportedFormatterError } from './error';\nexport function filterProps(props, allowlist, defaults) {\n    if (defaults === void 0) { defaults = {}; }\n    return allowlist.reduce(function (filtered, name) {\n        if (name in props) {\n            filtered[name] = props[name];\n        }\n        else if (name in defaults) {\n            filtered[name] = defaults[name];\n        }\n        return filtered;\n    }, {});\n}\nvar defaultErrorHandler = function (error) {\n    // @ts-ignore just so we don't need to declare dep on @types/node\n    if (process.env.NODE_ENV !== 'production') {\n        console.error(error);\n    }\n};\nvar defaultWarnHandler = function (warning) {\n    // @ts-ignore just so we don't need to declare dep on @types/node\n    if (process.env.NODE_ENV !== 'production') {\n        console.warn(warning);\n    }\n};\nexport var DEFAULT_INTL_CONFIG = {\n    formats: {},\n    messages: {},\n    timeZone: undefined,\n    defaultLocale: 'en',\n    defaultFormats: {},\n    fallbackOnEmptyString: true,\n    onError: defaultErrorHandler,\n    onWarn: defaultWarnHandler,\n};\nexport function createIntlCache() {\n    return {\n        dateTime: {},\n        number: {},\n        message: {},\n        relativeTime: {},\n        pluralRules: {},\n        list: {},\n        displayNames: {},\n    };\n}\nfunction createFastMemoizeCache(store) {\n    return {\n        create: function () {\n            return {\n                get: function (key) {\n                    return store[key];\n                },\n                set: function (key, value) {\n                    store[key] = value;\n                },\n            };\n        },\n    };\n}\n/**\n * Create intl formatters and populate cache\n * @param cache explicit cache to prevent leaking memory\n */\nexport function createFormatters(cache) {\n    if (cache === void 0) { cache = createIntlCache(); }\n    var RelativeTimeFormat = Intl.RelativeTimeFormat;\n    var ListFormat = Intl.ListFormat;\n    var DisplayNames = Intl.DisplayNames;\n    var getDateTimeFormat = memoize(function () {\n        var _a;\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return new ((_a = Intl.DateTimeFormat).bind.apply(_a, __spreadArray([void 0], args, false)))();\n    }, {\n        cache: createFastMemoizeCache(cache.dateTime),\n        strategy: strategies.variadic,\n    });\n    var getNumberFormat = memoize(function () {\n        var _a;\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return new ((_a = Intl.NumberFormat).bind.apply(_a, __spreadArray([void 0], args, false)))();\n    }, {\n        cache: createFastMemoizeCache(cache.number),\n        strategy: strategies.variadic,\n    });\n    var getPluralRules = memoize(function () {\n        var _a;\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return new ((_a = Intl.PluralRules).bind.apply(_a, __spreadArray([void 0], args, false)))();\n    }, {\n        cache: createFastMemoizeCache(cache.pluralRules),\n        strategy: strategies.variadic,\n    });\n    return {\n        getDateTimeFormat: getDateTimeFormat,\n        getNumberFormat: getNumberFormat,\n        getMessageFormat: memoize(function (message, locales, overrideFormats, opts) {\n            return new IntlMessageFormat(message, locales, overrideFormats, __assign({ formatters: {\n                    getNumberFormat: getNumberFormat,\n                    getDateTimeFormat: getDateTimeFormat,\n                    getPluralRules: getPluralRules,\n                } }, (opts || {})));\n        }, {\n            cache: createFastMemoizeCache(cache.message),\n            strategy: strategies.variadic,\n        }),\n        getRelativeTimeFormat: memoize(function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return new (RelativeTimeFormat.bind.apply(RelativeTimeFormat, __spreadArray([void 0], args, false)))();\n        }, {\n            cache: createFastMemoizeCache(cache.relativeTime),\n            strategy: strategies.variadic,\n        }),\n        getPluralRules: getPluralRules,\n        getListFormat: memoize(function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return new (ListFormat.bind.apply(ListFormat, __spreadArray([void 0], args, false)))();\n        }, {\n            cache: createFastMemoizeCache(cache.list),\n            strategy: strategies.variadic,\n        }),\n        getDisplayNames: memoize(function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return new (DisplayNames.bind.apply(DisplayNames, __spreadArray([void 0], args, false)))();\n        }, {\n            cache: createFastMemoizeCache(cache.displayNames),\n            strategy: strategies.variadic,\n        }),\n    };\n}\nexport function getNamedFormat(formats, type, name, onError) {\n    var formatType = formats && formats[type];\n    var format;\n    if (formatType) {\n        format = formatType[name];\n    }\n    if (format) {\n        return format;\n    }\n    onError(new UnsupportedFormatterError(\"No \".concat(type, \" format named: \").concat(name)));\n}\n","/**\n * Cannot do Math.log(x) / Math.log(10) bc if IEEE floating point issue\n * @param x number\n */\nexport function getMagnitude(x) {\n    // Cannot count string length via Number.toString because it may use scientific notation\n    // for very small or very large numbers.\n    return Math.floor(Math.log(x) * Math.LOG10E);\n}\nexport function repeat(s, times) {\n    if (typeof s.repeat === 'function') {\n        return s.repeat(times);\n    }\n    var arr = new Array(times);\n    for (var i = 0; i < arr.length; i++) {\n        arr[i] = s;\n    }\n    return arr.join('');\n}\nexport function setInternalSlot(map, pl, field, value) {\n    if (!map.get(pl)) {\n        map.set(pl, Object.create(null));\n    }\n    var slots = map.get(pl);\n    slots[field] = value;\n}\nexport function setMultiInternalSlots(map, pl, props) {\n    for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {\n        var k = _a[_i];\n        setInternalSlot(map, pl, k, props[k]);\n    }\n}\nexport function getInternalSlot(map, pl, field) {\n    return getMultiInternalSlots(map, pl, field)[field];\n}\nexport function getMultiInternalSlots(map, pl) {\n    var fields = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        fields[_i - 2] = arguments[_i];\n    }\n    var slots = map.get(pl);\n    if (!slots) {\n        throw new TypeError(\"\".concat(pl, \" InternalSlot has not been initialized\"));\n    }\n    return fields.reduce(function (all, f) {\n        all[f] = slots[f];\n        return all;\n    }, Object.create(null));\n}\nexport function isLiteralPart(patternPart) {\n    return patternPart.type === 'literal';\n}\n/*\n  17 ECMAScript Standard Built-in Objects:\n    Every built-in Function object, including constructors, that is not\n    identified as an anonymous function has a name property whose value\n    is a String.\n\n    Unless otherwise specified, the name property of a built-in Function\n    object, if it exists, has the attributes { [[Writable]]: false,\n    [[Enumerable]]: false, [[Configurable]]: true }.\n*/\nexport function defineProperty(target, name, _a) {\n    var value = _a.value;\n    Object.defineProperty(target, name, {\n        configurable: true,\n        enumerable: false,\n        writable: true,\n        value: value,\n    });\n}\nexport var UNICODE_EXTENSION_SEQUENCE_REGEX = /-u(?:-[0-9a-z]{2,8})+/gi;\nexport function invariant(condition, message, Err) {\n    if (Err === void 0) { Err = Error; }\n    if (!condition) {\n        throw new Err(message);\n    }\n}\n","//\n// Main\n//\nexport default function memoize(fn, options) {\n    var cache = options && options.cache ? options.cache : cacheDefault;\n    var serializer = options && options.serializer ? options.serializer : serializerDefault;\n    var strategy = options && options.strategy ? options.strategy : strategyDefault;\n    return strategy(fn, {\n        cache: cache,\n        serializer: serializer,\n    });\n}\n//\n// Strategy\n//\nfunction isPrimitive(value) {\n    return (value == null || typeof value === 'number' || typeof value === 'boolean'); // || typeof value === \"string\" 'unsafe' primitive for our needs\n}\nfunction monadic(fn, cache, serializer, arg) {\n    var cacheKey = isPrimitive(arg) ? arg : serializer(arg);\n    var computedValue = cache.get(cacheKey);\n    if (typeof computedValue === 'undefined') {\n        computedValue = fn.call(this, arg);\n        cache.set(cacheKey, computedValue);\n    }\n    return computedValue;\n}\nfunction variadic(fn, cache, serializer) {\n    var args = Array.prototype.slice.call(arguments, 3);\n    var cacheKey = serializer(args);\n    var computedValue = cache.get(cacheKey);\n    if (typeof computedValue === 'undefined') {\n        computedValue = fn.apply(this, args);\n        cache.set(cacheKey, computedValue);\n    }\n    return computedValue;\n}\nfunction assemble(fn, context, strategy, cache, serialize) {\n    return strategy.bind(context, fn, cache, serialize);\n}\nfunction strategyDefault(fn, options) {\n    var strategy = fn.length === 1 ? monadic : variadic;\n    return assemble(fn, this, strategy, options.cache.create(), options.serializer);\n}\nfunction strategyVariadic(fn, options) {\n    return assemble(fn, this, variadic, options.cache.create(), options.serializer);\n}\nfunction strategyMonadic(fn, options) {\n    return assemble(fn, this, monadic, options.cache.create(), options.serializer);\n}\n//\n// Serializer\n//\nvar serializerDefault = function () {\n    return JSON.stringify(arguments);\n};\n//\n// Cache\n//\nfunction ObjectWithoutPrototypeCache() {\n    this.cache = Object.create(null);\n}\nObjectWithoutPrototypeCache.prototype.get = function (key) {\n    return this.cache[key];\n};\nObjectWithoutPrototypeCache.prototype.set = function (key, value) {\n    this.cache[key] = value;\n};\nvar cacheDefault = {\n    create: function create() {\n        // @ts-ignore\n        return new ObjectWithoutPrototypeCache();\n    },\n};\nexport var strategies = {\n    variadic: strategyVariadic,\n    monadic: strategyMonadic,\n};\n","import { timeData } from './time-data.generated';\n/**\n * Returns the best matching date time pattern if a date time skeleton\n * pattern is provided with a locale. Follows the Unicode specification:\n * https://www.unicode.org/reports/tr35/tr35-dates.html#table-mapping-requested-time-skeletons-to-patterns\n * @param skeleton date time skeleton pattern that possibly includes j, J or C\n * @param locale\n */\nexport function getBestPattern(skeleton, locale) {\n    var skeletonCopy = '';\n    for (var patternPos = 0; patternPos < skeleton.length; patternPos++) {\n        var patternChar = skeleton.charAt(patternPos);\n        if (patternChar === 'j') {\n            var extraLength = 0;\n            while (patternPos + 1 < skeleton.length &&\n                skeleton.charAt(patternPos + 1) === patternChar) {\n                extraLength++;\n                patternPos++;\n            }\n            var hourLen = 1 + (extraLength & 1);\n            var dayPeriodLen = extraLength < 2 ? 1 : 3 + (extraLength >> 1);\n            var dayPeriodChar = 'a';\n            var hourChar = getDefaultHourSymbolFromLocale(locale);\n            if (hourChar == 'H' || hourChar == 'k') {\n                dayPeriodLen = 0;\n            }\n            while (dayPeriodLen-- > 0) {\n                skeletonCopy += dayPeriodChar;\n            }\n            while (hourLen-- > 0) {\n                skeletonCopy = hourChar + skeletonCopy;\n            }\n        }\n        else if (patternChar === 'J') {\n            skeletonCopy += 'H';\n        }\n        else {\n            skeletonCopy += patternChar;\n        }\n    }\n    return skeletonCopy;\n}\n/**\n * Maps the [hour cycle type](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/hourCycle)\n * of the given `locale` to the corresponding time pattern.\n * @param locale\n */\nfunction getDefaultHourSymbolFromLocale(locale) {\n    var hourCycle = locale.hourCycle;\n    if (hourCycle === undefined &&\n        // @ts-ignore hourCycle(s) is not identified yet\n        locale.hourCycles &&\n        // @ts-ignore\n        locale.hourCycles.length) {\n        // @ts-ignore\n        hourCycle = locale.hourCycles[0];\n    }\n    if (hourCycle) {\n        switch (hourCycle) {\n            case 'h24':\n                return 'k';\n            case 'h23':\n                return 'H';\n            case 'h12':\n                return 'h';\n            case 'h11':\n                return 'K';\n            default:\n                throw new Error('Invalid hourCycle');\n        }\n    }\n    // TODO: Once hourCycle is fully supported remove the following with data generation\n    var languageTag = locale.language;\n    var regionTag;\n    if (languageTag !== 'root') {\n        regionTag = locale.maximize().region;\n    }\n    var hourCycles = timeData[regionTag || ''] ||\n        timeData[languageTag || ''] ||\n        timeData[\"\".concat(languageTag, \"-001\")] ||\n        timeData['001'];\n    return hourCycles[0];\n}\n","export var ErrorKind;\n(function (ErrorKind) {\n    /** Argument is unclosed (e.g. `{0`) */\n    ErrorKind[ErrorKind[\"EXPECT_ARGUMENT_CLOSING_BRACE\"] = 1] = \"EXPECT_ARGUMENT_CLOSING_BRACE\";\n    /** Argument is empty (e.g. `{}`). */\n    ErrorKind[ErrorKind[\"EMPTY_ARGUMENT\"] = 2] = \"EMPTY_ARGUMENT\";\n    /** Argument is malformed (e.g. `{foo!}``) */\n    ErrorKind[ErrorKind[\"MALFORMED_ARGUMENT\"] = 3] = \"MALFORMED_ARGUMENT\";\n    /** Expect an argument type (e.g. `{foo,}`) */\n    ErrorKind[ErrorKind[\"EXPECT_ARGUMENT_TYPE\"] = 4] = \"EXPECT_ARGUMENT_TYPE\";\n    /** Unsupported argument type (e.g. `{foo,foo}`) */\n    ErrorKind[ErrorKind[\"INVALID_ARGUMENT_TYPE\"] = 5] = \"INVALID_ARGUMENT_TYPE\";\n    /** Expect an argument style (e.g. `{foo, number, }`) */\n    ErrorKind[ErrorKind[\"EXPECT_ARGUMENT_STYLE\"] = 6] = \"EXPECT_ARGUMENT_STYLE\";\n    /** The number skeleton is invalid. */\n    ErrorKind[ErrorKind[\"INVALID_NUMBER_SKELETON\"] = 7] = \"INVALID_NUMBER_SKELETON\";\n    /** The date time skeleton is invalid. */\n    ErrorKind[ErrorKind[\"INVALID_DATE_TIME_SKELETON\"] = 8] = \"INVALID_DATE_TIME_SKELETON\";\n    /** Exepct a number skeleton following the `::` (e.g. `{foo, number, ::}`) */\n    ErrorKind[ErrorKind[\"EXPECT_NUMBER_SKELETON\"] = 9] = \"EXPECT_NUMBER_SKELETON\";\n    /** Exepct a date time skeleton following the `::` (e.g. `{foo, date, ::}`) */\n    ErrorKind[ErrorKind[\"EXPECT_DATE_TIME_SKELETON\"] = 10] = \"EXPECT_DATE_TIME_SKELETON\";\n    /** Unmatched apostrophes in the argument style (e.g. `{foo, number, 'test`) */\n    ErrorKind[ErrorKind[\"UNCLOSED_QUOTE_IN_ARGUMENT_STYLE\"] = 11] = \"UNCLOSED_QUOTE_IN_ARGUMENT_STYLE\";\n    /** Missing select argument options (e.g. `{foo, select}`) */\n    ErrorKind[ErrorKind[\"EXPECT_SELECT_ARGUMENT_OPTIONS\"] = 12] = \"EXPECT_SELECT_ARGUMENT_OPTIONS\";\n    /** Expecting an offset value in `plural` or `selectordinal` argument (e.g `{foo, plural, offset}`) */\n    ErrorKind[ErrorKind[\"EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE\"] = 13] = \"EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE\";\n    /** Offset value in `plural` or `selectordinal` is invalid (e.g. `{foo, plural, offset: x}`) */\n    ErrorKind[ErrorKind[\"INVALID_PLURAL_ARGUMENT_OFFSET_VALUE\"] = 14] = \"INVALID_PLURAL_ARGUMENT_OFFSET_VALUE\";\n    /** Expecting a selector in `select` argument (e.g `{foo, select}`) */\n    ErrorKind[ErrorKind[\"EXPECT_SELECT_ARGUMENT_SELECTOR\"] = 15] = \"EXPECT_SELECT_ARGUMENT_SELECTOR\";\n    /** Expecting a selector in `plural` or `selectordinal` argument (e.g `{foo, plural}`) */\n    ErrorKind[ErrorKind[\"EXPECT_PLURAL_ARGUMENT_SELECTOR\"] = 16] = \"EXPECT_PLURAL_ARGUMENT_SELECTOR\";\n    /** Expecting a message fragment after the `select` selector (e.g. `{foo, select, apple}`) */\n    ErrorKind[ErrorKind[\"EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT\"] = 17] = \"EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT\";\n    /**\n     * Expecting a message fragment after the `plural` or `selectordinal` selector\n     * (e.g. `{foo, plural, one}`)\n     */\n    ErrorKind[ErrorKind[\"EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT\"] = 18] = \"EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT\";\n    /** Selector in `plural` or `selectordinal` is malformed (e.g. `{foo, plural, =x {#}}`) */\n    ErrorKind[ErrorKind[\"INVALID_PLURAL_ARGUMENT_SELECTOR\"] = 19] = \"INVALID_PLURAL_ARGUMENT_SELECTOR\";\n    /**\n     * Duplicate selectors in `plural` or `selectordinal` argument.\n     * (e.g. {foo, plural, one {#} one {#}})\n     */\n    ErrorKind[ErrorKind[\"DUPLICATE_PLURAL_ARGUMENT_SELECTOR\"] = 20] = \"DUPLICATE_PLURAL_ARGUMENT_SELECTOR\";\n    /** Duplicate selectors in `select` argument.\n     * (e.g. {foo, select, apple {apple} apple {apple}})\n     */\n    ErrorKind[ErrorKind[\"DUPLICATE_SELECT_ARGUMENT_SELECTOR\"] = 21] = \"DUPLICATE_SELECT_ARGUMENT_SELECTOR\";\n    /** Plural or select argument option must have `other` clause. */\n    ErrorKind[ErrorKind[\"MISSING_OTHER_CLAUSE\"] = 22] = \"MISSING_OTHER_CLAUSE\";\n    /** The tag is malformed. (e.g. `<bold!>foo</bold!>) */\n    ErrorKind[ErrorKind[\"INVALID_TAG\"] = 23] = \"INVALID_TAG\";\n    /** The tag name is invalid. (e.g. `<123>foo</123>`) */\n    ErrorKind[ErrorKind[\"INVALID_TAG_NAME\"] = 25] = \"INVALID_TAG_NAME\";\n    /** The closing tag does not match the opening tag. (e.g. `<bold>foo</italic>`) */\n    ErrorKind[ErrorKind[\"UNMATCHED_CLOSING_TAG\"] = 26] = \"UNMATCHED_CLOSING_TAG\";\n    /** The opening tag has unmatched closing tag. (e.g. `<bold>foo`) */\n    ErrorKind[ErrorKind[\"UNCLOSED_TAG\"] = 27] = \"UNCLOSED_TAG\";\n})(ErrorKind || (ErrorKind = {}));\n","import { __assign } from \"tslib\";\nimport { ErrorKind } from './error';\nimport { Parser } from './parser';\nimport { isDateElement, isDateTimeSkeleton, isNumberElement, isNumberSkeleton, isPluralElement, isSelectElement, isTagElement, isTimeElement, } from './types';\nfunction pruneLocation(els) {\n    els.forEach(function (el) {\n        delete el.location;\n        if (isSelectElement(el) || isPluralElement(el)) {\n            for (var k in el.options) {\n                delete el.options[k].location;\n                pruneLocation(el.options[k].value);\n            }\n        }\n        else if (isNumberElement(el) && isNumberSkeleton(el.style)) {\n            delete el.style.location;\n        }\n        else if ((isDateElement(el) || isTimeElement(el)) &&\n            isDateTimeSkeleton(el.style)) {\n            delete el.style.location;\n        }\n        else if (isTagElement(el)) {\n            pruneLocation(el.children);\n        }\n    });\n}\nexport function parse(message, opts) {\n    if (opts === void 0) { opts = {}; }\n    opts = __assign({ shouldParseSkeletons: true, requiresOtherClause: true }, opts);\n    var result = new Parser(message, opts).parse();\n    if (result.err) {\n        var error = SyntaxError(ErrorKind[result.err.kind]);\n        // @ts-expect-error Assign to error object\n        error.location = result.err.location;\n        // @ts-expect-error Assign to error object\n        error.originalMessage = result.err.message;\n        throw error;\n    }\n    if (!(opts === null || opts === void 0 ? void 0 : opts.captureLocation)) {\n        pruneLocation(result.val);\n    }\n    return result.val;\n}\nexport * from './types';\n","var _a;\nimport { __assign } from \"tslib\";\nimport { ErrorKind } from './error';\nimport { SKELETON_TYPE, TYPE, } from './types';\nimport { SPACE_SEPARATOR_REGEX } from './regex.generated';\nimport { parseNumberSkeleton, parseNumberSkeletonFromString, parseDateTimeSkeleton, } from '@formatjs/icu-skeleton-parser';\nimport { getBestPattern } from './date-time-pattern-generator';\nvar SPACE_SEPARATOR_START_REGEX = new RegExp(\"^\".concat(SPACE_SEPARATOR_REGEX.source, \"*\"));\nvar SPACE_SEPARATOR_END_REGEX = new RegExp(\"\".concat(SPACE_SEPARATOR_REGEX.source, \"*$\"));\nfunction createLocation(start, end) {\n    return { start: start, end: end };\n}\n// #region Ponyfills\n// Consolidate these variables up top for easier toggling during debugging\nvar hasNativeStartsWith = !!String.prototype.startsWith;\nvar hasNativeFromCodePoint = !!String.fromCodePoint;\nvar hasNativeFromEntries = !!Object.fromEntries;\nvar hasNativeCodePointAt = !!String.prototype.codePointAt;\nvar hasTrimStart = !!String.prototype.trimStart;\nvar hasTrimEnd = !!String.prototype.trimEnd;\nvar hasNativeIsSafeInteger = !!Number.isSafeInteger;\nvar isSafeInteger = hasNativeIsSafeInteger\n    ? Number.isSafeInteger\n    : function (n) {\n        return (typeof n === 'number' &&\n            isFinite(n) &&\n            Math.floor(n) === n &&\n            Math.abs(n) <= 0x1fffffffffffff);\n    };\n// IE11 does not support y and u.\nvar REGEX_SUPPORTS_U_AND_Y = true;\ntry {\n    var re = RE('([^\\\\p{White_Space}\\\\p{Pattern_Syntax}]*)', 'yu');\n    /**\n     * legacy Edge or Xbox One browser\n     * Unicode flag support: supported\n     * Pattern_Syntax support: not supported\n     * See https://github.com/formatjs/formatjs/issues/2822\n     */\n    REGEX_SUPPORTS_U_AND_Y = ((_a = re.exec('a')) === null || _a === void 0 ? void 0 : _a[0]) === 'a';\n}\ncatch (_) {\n    REGEX_SUPPORTS_U_AND_Y = false;\n}\nvar startsWith = hasNativeStartsWith\n    ? // Native\n        function startsWith(s, search, position) {\n            return s.startsWith(search, position);\n        }\n    : // For IE11\n        function startsWith(s, search, position) {\n            return s.slice(position, position + search.length) === search;\n        };\nvar fromCodePoint = hasNativeFromCodePoint\n    ? String.fromCodePoint\n    : // IE11\n        function fromCodePoint() {\n            var codePoints = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                codePoints[_i] = arguments[_i];\n            }\n            var elements = '';\n            var length = codePoints.length;\n            var i = 0;\n            var code;\n            while (length > i) {\n                code = codePoints[i++];\n                if (code > 0x10ffff)\n                    throw RangeError(code + ' is not a valid code point');\n                elements +=\n                    code < 0x10000\n                        ? String.fromCharCode(code)\n                        : String.fromCharCode(((code -= 0x10000) >> 10) + 0xd800, (code % 0x400) + 0xdc00);\n            }\n            return elements;\n        };\nvar fromEntries = \n// native\nhasNativeFromEntries\n    ? Object.fromEntries\n    : // Ponyfill\n        function fromEntries(entries) {\n            var obj = {};\n            for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n                var _a = entries_1[_i], k = _a[0], v = _a[1];\n                obj[k] = v;\n            }\n            return obj;\n        };\nvar codePointAt = hasNativeCodePointAt\n    ? // Native\n        function codePointAt(s, index) {\n            return s.codePointAt(index);\n        }\n    : // IE 11\n        function codePointAt(s, index) {\n            var size = s.length;\n            if (index < 0 || index >= size) {\n                return undefined;\n            }\n            var first = s.charCodeAt(index);\n            var second;\n            return first < 0xd800 ||\n                first > 0xdbff ||\n                index + 1 === size ||\n                (second = s.charCodeAt(index + 1)) < 0xdc00 ||\n                second > 0xdfff\n                ? first\n                : ((first - 0xd800) << 10) + (second - 0xdc00) + 0x10000;\n        };\nvar trimStart = hasTrimStart\n    ? // Native\n        function trimStart(s) {\n            return s.trimStart();\n        }\n    : // Ponyfill\n        function trimStart(s) {\n            return s.replace(SPACE_SEPARATOR_START_REGEX, '');\n        };\nvar trimEnd = hasTrimEnd\n    ? // Native\n        function trimEnd(s) {\n            return s.trimEnd();\n        }\n    : // Ponyfill\n        function trimEnd(s) {\n            return s.replace(SPACE_SEPARATOR_END_REGEX, '');\n        };\n// Prevent minifier to translate new RegExp to literal form that might cause syntax error on IE11.\nfunction RE(s, flag) {\n    return new RegExp(s, flag);\n}\n// #endregion\nvar matchIdentifierAtIndex;\nif (REGEX_SUPPORTS_U_AND_Y) {\n    // Native\n    var IDENTIFIER_PREFIX_RE_1 = RE('([^\\\\p{White_Space}\\\\p{Pattern_Syntax}]*)', 'yu');\n    matchIdentifierAtIndex = function matchIdentifierAtIndex(s, index) {\n        var _a;\n        IDENTIFIER_PREFIX_RE_1.lastIndex = index;\n        var match = IDENTIFIER_PREFIX_RE_1.exec(s);\n        return (_a = match[1]) !== null && _a !== void 0 ? _a : '';\n    };\n}\nelse {\n    // IE11\n    matchIdentifierAtIndex = function matchIdentifierAtIndex(s, index) {\n        var match = [];\n        while (true) {\n            var c = codePointAt(s, index);\n            if (c === undefined || _isWhiteSpace(c) || _isPatternSyntax(c)) {\n                break;\n            }\n            match.push(c);\n            index += c >= 0x10000 ? 2 : 1;\n        }\n        return fromCodePoint.apply(void 0, match);\n    };\n}\nvar Parser = /** @class */ (function () {\n    function Parser(message, options) {\n        if (options === void 0) { options = {}; }\n        this.message = message;\n        this.position = { offset: 0, line: 1, column: 1 };\n        this.ignoreTag = !!options.ignoreTag;\n        this.locale = options.locale;\n        this.requiresOtherClause = !!options.requiresOtherClause;\n        this.shouldParseSkeletons = !!options.shouldParseSkeletons;\n    }\n    Parser.prototype.parse = function () {\n        if (this.offset() !== 0) {\n            throw Error('parser can only be used once');\n        }\n        return this.parseMessage(0, '', false);\n    };\n    Parser.prototype.parseMessage = function (nestingLevel, parentArgType, expectingCloseTag) {\n        var elements = [];\n        while (!this.isEOF()) {\n            var char = this.char();\n            if (char === 123 /* `{` */) {\n                var result = this.parseArgument(nestingLevel, expectingCloseTag);\n                if (result.err) {\n                    return result;\n                }\n                elements.push(result.val);\n            }\n            else if (char === 125 /* `}` */ && nestingLevel > 0) {\n                break;\n            }\n            else if (char === 35 /* `#` */ &&\n                (parentArgType === 'plural' || parentArgType === 'selectordinal')) {\n                var position = this.clonePosition();\n                this.bump();\n                elements.push({\n                    type: TYPE.pound,\n                    location: createLocation(position, this.clonePosition()),\n                });\n            }\n            else if (char === 60 /* `<` */ &&\n                !this.ignoreTag &&\n                this.peek() === 47 // char code for '/'\n            ) {\n                if (expectingCloseTag) {\n                    break;\n                }\n                else {\n                    return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(this.clonePosition(), this.clonePosition()));\n                }\n            }\n            else if (char === 60 /* `<` */ &&\n                !this.ignoreTag &&\n                _isAlpha(this.peek() || 0)) {\n                var result = this.parseTag(nestingLevel, parentArgType);\n                if (result.err) {\n                    return result;\n                }\n                elements.push(result.val);\n            }\n            else {\n                var result = this.parseLiteral(nestingLevel, parentArgType);\n                if (result.err) {\n                    return result;\n                }\n                elements.push(result.val);\n            }\n        }\n        return { val: elements, err: null };\n    };\n    /**\n     * A tag name must start with an ASCII lower/upper case letter. The grammar is based on the\n     * [custom element name][] except that a dash is NOT always mandatory and uppercase letters\n     * are accepted:\n     *\n     * ```\n     * tag ::= \"<\" tagName (whitespace)* \"/>\" | \"<\" tagName (whitespace)* \">\" message \"</\" tagName (whitespace)* \">\"\n     * tagName ::= [a-z] (PENChar)*\n     * PENChar ::=\n     *     \"-\" | \".\" | [0-9] | \"_\" | [a-z] | [A-Z] | #xB7 | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x37D] |\n     *     [#x37F-#x1FFF] | [#x200C-#x200D] | [#x203F-#x2040] | [#x2070-#x218F] | [#x2C00-#x2FEF] |\n     *     [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]\n     * ```\n     *\n     * [custom element name]: https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name\n     * NOTE: We're a bit more lax here since HTML technically does not allow uppercase HTML element but we do\n     * since other tag-based engines like React allow it\n     */\n    Parser.prototype.parseTag = function (nestingLevel, parentArgType) {\n        var startPosition = this.clonePosition();\n        this.bump(); // `<`\n        var tagName = this.parseTagName();\n        this.bumpSpace();\n        if (this.bumpIf('/>')) {\n            // Self closing tag\n            return {\n                val: {\n                    type: TYPE.literal,\n                    value: \"<\".concat(tagName, \"/>\"),\n                    location: createLocation(startPosition, this.clonePosition()),\n                },\n                err: null,\n            };\n        }\n        else if (this.bumpIf('>')) {\n            var childrenResult = this.parseMessage(nestingLevel + 1, parentArgType, true);\n            if (childrenResult.err) {\n                return childrenResult;\n            }\n            var children = childrenResult.val;\n            // Expecting a close tag\n            var endTagStartPosition = this.clonePosition();\n            if (this.bumpIf('</')) {\n                if (this.isEOF() || !_isAlpha(this.char())) {\n                    return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));\n                }\n                var closingTagNameStartPosition = this.clonePosition();\n                var closingTagName = this.parseTagName();\n                if (tagName !== closingTagName) {\n                    return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(closingTagNameStartPosition, this.clonePosition()));\n                }\n                this.bumpSpace();\n                if (!this.bumpIf('>')) {\n                    return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));\n                }\n                return {\n                    val: {\n                        type: TYPE.tag,\n                        value: tagName,\n                        children: children,\n                        location: createLocation(startPosition, this.clonePosition()),\n                    },\n                    err: null,\n                };\n            }\n            else {\n                return this.error(ErrorKind.UNCLOSED_TAG, createLocation(startPosition, this.clonePosition()));\n            }\n        }\n        else {\n            return this.error(ErrorKind.INVALID_TAG, createLocation(startPosition, this.clonePosition()));\n        }\n    };\n    /**\n     * This method assumes that the caller has peeked ahead for the first tag character.\n     */\n    Parser.prototype.parseTagName = function () {\n        var startOffset = this.offset();\n        this.bump(); // the first tag name character\n        while (!this.isEOF() && _isPotentialElementNameChar(this.char())) {\n            this.bump();\n        }\n        return this.message.slice(startOffset, this.offset());\n    };\n    Parser.prototype.parseLiteral = function (nestingLevel, parentArgType) {\n        var start = this.clonePosition();\n        var value = '';\n        while (true) {\n            var parseQuoteResult = this.tryParseQuote(parentArgType);\n            if (parseQuoteResult) {\n                value += parseQuoteResult;\n                continue;\n            }\n            var parseUnquotedResult = this.tryParseUnquoted(nestingLevel, parentArgType);\n            if (parseUnquotedResult) {\n                value += parseUnquotedResult;\n                continue;\n            }\n            var parseLeftAngleResult = this.tryParseLeftAngleBracket();\n            if (parseLeftAngleResult) {\n                value += parseLeftAngleResult;\n                continue;\n            }\n            break;\n        }\n        var location = createLocation(start, this.clonePosition());\n        return {\n            val: { type: TYPE.literal, value: value, location: location },\n            err: null,\n        };\n    };\n    Parser.prototype.tryParseLeftAngleBracket = function () {\n        if (!this.isEOF() &&\n            this.char() === 60 /* `<` */ &&\n            (this.ignoreTag ||\n                // If at the opening tag or closing tag position, bail.\n                !_isAlphaOrSlash(this.peek() || 0))) {\n            this.bump(); // `<`\n            return '<';\n        }\n        return null;\n    };\n    /**\n     * Starting with ICU 4.8, an ASCII apostrophe only starts quoted text if it immediately precedes\n     * a character that requires quoting (that is, \"only where needed\"), and works the same in\n     * nested messages as on the top level of the pattern. The new behavior is otherwise compatible.\n     */\n    Parser.prototype.tryParseQuote = function (parentArgType) {\n        if (this.isEOF() || this.char() !== 39 /* `'` */) {\n            return null;\n        }\n        // Parse escaped char following the apostrophe, or early return if there is no escaped char.\n        // Check if is valid escaped character\n        switch (this.peek()) {\n            case 39 /* `'` */:\n                // double quote, should return as a single quote.\n                this.bump();\n                this.bump();\n                return \"'\";\n            // '{', '<', '>', '}'\n            case 123:\n            case 60:\n            case 62:\n            case 125:\n                break;\n            case 35: // '#'\n                if (parentArgType === 'plural' || parentArgType === 'selectordinal') {\n                    break;\n                }\n                return null;\n            default:\n                return null;\n        }\n        this.bump(); // apostrophe\n        var codePoints = [this.char()]; // escaped char\n        this.bump();\n        // read chars until the optional closing apostrophe is found\n        while (!this.isEOF()) {\n            var ch = this.char();\n            if (ch === 39 /* `'` */) {\n                if (this.peek() === 39 /* `'` */) {\n                    codePoints.push(39);\n                    // Bump one more time because we need to skip 2 characters.\n                    this.bump();\n                }\n                else {\n                    // Optional closing apostrophe.\n                    this.bump();\n                    break;\n                }\n            }\n            else {\n                codePoints.push(ch);\n            }\n            this.bump();\n        }\n        return fromCodePoint.apply(void 0, codePoints);\n    };\n    Parser.prototype.tryParseUnquoted = function (nestingLevel, parentArgType) {\n        if (this.isEOF()) {\n            return null;\n        }\n        var ch = this.char();\n        if (ch === 60 /* `<` */ ||\n            ch === 123 /* `{` */ ||\n            (ch === 35 /* `#` */ &&\n                (parentArgType === 'plural' || parentArgType === 'selectordinal')) ||\n            (ch === 125 /* `}` */ && nestingLevel > 0)) {\n            return null;\n        }\n        else {\n            this.bump();\n            return fromCodePoint(ch);\n        }\n    };\n    Parser.prototype.parseArgument = function (nestingLevel, expectingCloseTag) {\n        var openingBracePosition = this.clonePosition();\n        this.bump(); // `{`\n        this.bumpSpace();\n        if (this.isEOF()) {\n            return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        if (this.char() === 125 /* `}` */) {\n            this.bump();\n            return this.error(ErrorKind.EMPTY_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        // argument name\n        var value = this.parseIdentifierIfPossible().value;\n        if (!value) {\n            return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        this.bumpSpace();\n        if (this.isEOF()) {\n            return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        switch (this.char()) {\n            // Simple argument: `{name}`\n            case 125 /* `}` */: {\n                this.bump(); // `}`\n                return {\n                    val: {\n                        type: TYPE.argument,\n                        // value does not include the opening and closing braces.\n                        value: value,\n                        location: createLocation(openingBracePosition, this.clonePosition()),\n                    },\n                    err: null,\n                };\n            }\n            // Argument with options: `{name, format, ...}`\n            case 44 /* `,` */: {\n                this.bump(); // `,`\n                this.bumpSpace();\n                if (this.isEOF()) {\n                    return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));\n                }\n                return this.parseArgumentOptions(nestingLevel, expectingCloseTag, value, openingBracePosition);\n            }\n            default:\n                return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));\n        }\n    };\n    /**\n     * Advance the parser until the end of the identifier, if it is currently on\n     * an identifier character. Return an empty string otherwise.\n     */\n    Parser.prototype.parseIdentifierIfPossible = function () {\n        var startingPosition = this.clonePosition();\n        var startOffset = this.offset();\n        var value = matchIdentifierAtIndex(this.message, startOffset);\n        var endOffset = startOffset + value.length;\n        this.bumpTo(endOffset);\n        var endPosition = this.clonePosition();\n        var location = createLocation(startingPosition, endPosition);\n        return { value: value, location: location };\n    };\n    Parser.prototype.parseArgumentOptions = function (nestingLevel, expectingCloseTag, value, openingBracePosition) {\n        var _a;\n        // Parse this range:\n        // {name, type, style}\n        //        ^---^\n        var typeStartPosition = this.clonePosition();\n        var argType = this.parseIdentifierIfPossible().value;\n        var typeEndPosition = this.clonePosition();\n        switch (argType) {\n            case '':\n                // Expecting a style string number, date, time, plural, selectordinal, or select.\n                return this.error(ErrorKind.EXPECT_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));\n            case 'number':\n            case 'date':\n            case 'time': {\n                // Parse this range:\n                // {name, number, style}\n                //              ^-------^\n                this.bumpSpace();\n                var styleAndLocation = null;\n                if (this.bumpIf(',')) {\n                    this.bumpSpace();\n                    var styleStartPosition = this.clonePosition();\n                    var result = this.parseSimpleArgStyleIfPossible();\n                    if (result.err) {\n                        return result;\n                    }\n                    var style = trimEnd(result.val);\n                    if (style.length === 0) {\n                        return this.error(ErrorKind.EXPECT_ARGUMENT_STYLE, createLocation(this.clonePosition(), this.clonePosition()));\n                    }\n                    var styleLocation = createLocation(styleStartPosition, this.clonePosition());\n                    styleAndLocation = { style: style, styleLocation: styleLocation };\n                }\n                var argCloseResult = this.tryParseArgumentClose(openingBracePosition);\n                if (argCloseResult.err) {\n                    return argCloseResult;\n                }\n                var location_1 = createLocation(openingBracePosition, this.clonePosition());\n                // Extract style or skeleton\n                if (styleAndLocation && startsWith(styleAndLocation === null || styleAndLocation === void 0 ? void 0 : styleAndLocation.style, '::', 0)) {\n                    // Skeleton starts with `::`.\n                    var skeleton = trimStart(styleAndLocation.style.slice(2));\n                    if (argType === 'number') {\n                        var result = this.parseNumberSkeletonFromString(skeleton, styleAndLocation.styleLocation);\n                        if (result.err) {\n                            return result;\n                        }\n                        return {\n                            val: { type: TYPE.number, value: value, location: location_1, style: result.val },\n                            err: null,\n                        };\n                    }\n                    else {\n                        if (skeleton.length === 0) {\n                            return this.error(ErrorKind.EXPECT_DATE_TIME_SKELETON, location_1);\n                        }\n                        var dateTimePattern = skeleton;\n                        // Get \"best match\" pattern only if locale is passed, if not, let it\n                        // pass as-is where `parseDateTimeSkeleton()` will throw an error\n                        // for unsupported patterns.\n                        if (this.locale) {\n                            dateTimePattern = getBestPattern(skeleton, this.locale);\n                        }\n                        var style = {\n                            type: SKELETON_TYPE.dateTime,\n                            pattern: dateTimePattern,\n                            location: styleAndLocation.styleLocation,\n                            parsedOptions: this.shouldParseSkeletons\n                                ? parseDateTimeSkeleton(dateTimePattern)\n                                : {},\n                        };\n                        var type = argType === 'date' ? TYPE.date : TYPE.time;\n                        return {\n                            val: { type: type, value: value, location: location_1, style: style },\n                            err: null,\n                        };\n                    }\n                }\n                // Regular style or no style.\n                return {\n                    val: {\n                        type: argType === 'number'\n                            ? TYPE.number\n                            : argType === 'date'\n                                ? TYPE.date\n                                : TYPE.time,\n                        value: value,\n                        location: location_1,\n                        style: (_a = styleAndLocation === null || styleAndLocation === void 0 ? void 0 : styleAndLocation.style) !== null && _a !== void 0 ? _a : null,\n                    },\n                    err: null,\n                };\n            }\n            case 'plural':\n            case 'selectordinal':\n            case 'select': {\n                // Parse this range:\n                // {name, plural, options}\n                //              ^---------^\n                var typeEndPosition_1 = this.clonePosition();\n                this.bumpSpace();\n                if (!this.bumpIf(',')) {\n                    return this.error(ErrorKind.EXPECT_SELECT_ARGUMENT_OPTIONS, createLocation(typeEndPosition_1, __assign({}, typeEndPosition_1)));\n                }\n                this.bumpSpace();\n                // Parse offset:\n                // {name, plural, offset:1, options}\n                //                ^-----^\n                //\n                // or the first option:\n                //\n                // {name, plural, one {...} other {...}}\n                //                ^--^\n                var identifierAndLocation = this.parseIdentifierIfPossible();\n                var pluralOffset = 0;\n                if (argType !== 'select' && identifierAndLocation.value === 'offset') {\n                    if (!this.bumpIf(':')) {\n                        return this.error(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, createLocation(this.clonePosition(), this.clonePosition()));\n                    }\n                    this.bumpSpace();\n                    var result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, ErrorKind.INVALID_PLURAL_ARGUMENT_OFFSET_VALUE);\n                    if (result.err) {\n                        return result;\n                    }\n                    // Parse another identifier for option parsing\n                    this.bumpSpace();\n                    identifierAndLocation = this.parseIdentifierIfPossible();\n                    pluralOffset = result.val;\n                }\n                var optionsResult = this.tryParsePluralOrSelectOptions(nestingLevel, argType, expectingCloseTag, identifierAndLocation);\n                if (optionsResult.err) {\n                    return optionsResult;\n                }\n                var argCloseResult = this.tryParseArgumentClose(openingBracePosition);\n                if (argCloseResult.err) {\n                    return argCloseResult;\n                }\n                var location_2 = createLocation(openingBracePosition, this.clonePosition());\n                if (argType === 'select') {\n                    return {\n                        val: {\n                            type: TYPE.select,\n                            value: value,\n                            options: fromEntries(optionsResult.val),\n                            location: location_2,\n                        },\n                        err: null,\n                    };\n                }\n                else {\n                    return {\n                        val: {\n                            type: TYPE.plural,\n                            value: value,\n                            options: fromEntries(optionsResult.val),\n                            offset: pluralOffset,\n                            pluralType: argType === 'plural' ? 'cardinal' : 'ordinal',\n                            location: location_2,\n                        },\n                        err: null,\n                    };\n                }\n            }\n            default:\n                return this.error(ErrorKind.INVALID_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));\n        }\n    };\n    Parser.prototype.tryParseArgumentClose = function (openingBracePosition) {\n        // Parse: {value, number, ::currency/GBP }\n        //\n        if (this.isEOF() || this.char() !== 125 /* `}` */) {\n            return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        this.bump(); // `}`\n        return { val: true, err: null };\n    };\n    /**\n     * See: https://github.com/unicode-org/icu/blob/af7ed1f6d2298013dc303628438ec4abe1f16479/icu4c/source/common/messagepattern.cpp#L659\n     */\n    Parser.prototype.parseSimpleArgStyleIfPossible = function () {\n        var nestedBraces = 0;\n        var startPosition = this.clonePosition();\n        while (!this.isEOF()) {\n            var ch = this.char();\n            switch (ch) {\n                case 39 /* `'` */: {\n                    // Treat apostrophe as quoting but include it in the style part.\n                    // Find the end of the quoted literal text.\n                    this.bump();\n                    var apostrophePosition = this.clonePosition();\n                    if (!this.bumpUntil(\"'\")) {\n                        return this.error(ErrorKind.UNCLOSED_QUOTE_IN_ARGUMENT_STYLE, createLocation(apostrophePosition, this.clonePosition()));\n                    }\n                    this.bump();\n                    break;\n                }\n                case 123 /* `{` */: {\n                    nestedBraces += 1;\n                    this.bump();\n                    break;\n                }\n                case 125 /* `}` */: {\n                    if (nestedBraces > 0) {\n                        nestedBraces -= 1;\n                    }\n                    else {\n                        return {\n                            val: this.message.slice(startPosition.offset, this.offset()),\n                            err: null,\n                        };\n                    }\n                    break;\n                }\n                default:\n                    this.bump();\n                    break;\n            }\n        }\n        return {\n            val: this.message.slice(startPosition.offset, this.offset()),\n            err: null,\n        };\n    };\n    Parser.prototype.parseNumberSkeletonFromString = function (skeleton, location) {\n        var tokens = [];\n        try {\n            tokens = parseNumberSkeletonFromString(skeleton);\n        }\n        catch (e) {\n            return this.error(ErrorKind.INVALID_NUMBER_SKELETON, location);\n        }\n        return {\n            val: {\n                type: SKELETON_TYPE.number,\n                tokens: tokens,\n                location: location,\n                parsedOptions: this.shouldParseSkeletons\n                    ? parseNumberSkeleton(tokens)\n                    : {},\n            },\n            err: null,\n        };\n    };\n    /**\n     * @param nesting_level The current nesting level of messages.\n     *     This can be positive when parsing message fragment in select or plural argument options.\n     * @param parent_arg_type The parent argument's type.\n     * @param parsed_first_identifier If provided, this is the first identifier-like selector of\n     *     the argument. It is a by-product of a previous parsing attempt.\n     * @param expecting_close_tag If true, this message is directly or indirectly nested inside\n     *     between a pair of opening and closing tags. The nested message will not parse beyond\n     *     the closing tag boundary.\n     */\n    Parser.prototype.tryParsePluralOrSelectOptions = function (nestingLevel, parentArgType, expectCloseTag, parsedFirstIdentifier) {\n        var _a;\n        var hasOtherClause = false;\n        var options = [];\n        var parsedSelectors = new Set();\n        var selector = parsedFirstIdentifier.value, selectorLocation = parsedFirstIdentifier.location;\n        // Parse:\n        // one {one apple}\n        // ^--^\n        while (true) {\n            if (selector.length === 0) {\n                var startPosition = this.clonePosition();\n                if (parentArgType !== 'select' && this.bumpIf('=')) {\n                    // Try parse `={number}` selector\n                    var result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, ErrorKind.INVALID_PLURAL_ARGUMENT_SELECTOR);\n                    if (result.err) {\n                        return result;\n                    }\n                    selectorLocation = createLocation(startPosition, this.clonePosition());\n                    selector = this.message.slice(startPosition.offset, this.offset());\n                }\n                else {\n                    break;\n                }\n            }\n            // Duplicate selector clauses\n            if (parsedSelectors.has(selector)) {\n                return this.error(parentArgType === 'select'\n                    ? ErrorKind.DUPLICATE_SELECT_ARGUMENT_SELECTOR\n                    : ErrorKind.DUPLICATE_PLURAL_ARGUMENT_SELECTOR, selectorLocation);\n            }\n            if (selector === 'other') {\n                hasOtherClause = true;\n            }\n            // Parse:\n            // one {one apple}\n            //     ^----------^\n            this.bumpSpace();\n            var openingBracePosition = this.clonePosition();\n            if (!this.bumpIf('{')) {\n                return this.error(parentArgType === 'select'\n                    ? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT\n                    : ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT, createLocation(this.clonePosition(), this.clonePosition()));\n            }\n            var fragmentResult = this.parseMessage(nestingLevel + 1, parentArgType, expectCloseTag);\n            if (fragmentResult.err) {\n                return fragmentResult;\n            }\n            var argCloseResult = this.tryParseArgumentClose(openingBracePosition);\n            if (argCloseResult.err) {\n                return argCloseResult;\n            }\n            options.push([\n                selector,\n                {\n                    value: fragmentResult.val,\n                    location: createLocation(openingBracePosition, this.clonePosition()),\n                },\n            ]);\n            // Keep track of the existing selectors\n            parsedSelectors.add(selector);\n            // Prep next selector clause.\n            this.bumpSpace();\n            (_a = this.parseIdentifierIfPossible(), selector = _a.value, selectorLocation = _a.location);\n        }\n        if (options.length === 0) {\n            return this.error(parentArgType === 'select'\n                ? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR\n                : ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, createLocation(this.clonePosition(), this.clonePosition()));\n        }\n        if (this.requiresOtherClause && !hasOtherClause) {\n            return this.error(ErrorKind.MISSING_OTHER_CLAUSE, createLocation(this.clonePosition(), this.clonePosition()));\n        }\n        return { val: options, err: null };\n    };\n    Parser.prototype.tryParseDecimalInteger = function (expectNumberError, invalidNumberError) {\n        var sign = 1;\n        var startingPosition = this.clonePosition();\n        if (this.bumpIf('+')) {\n        }\n        else if (this.bumpIf('-')) {\n            sign = -1;\n        }\n        var hasDigits = false;\n        var decimal = 0;\n        while (!this.isEOF()) {\n            var ch = this.char();\n            if (ch >= 48 /* `0` */ && ch <= 57 /* `9` */) {\n                hasDigits = true;\n                decimal = decimal * 10 + (ch - 48);\n                this.bump();\n            }\n            else {\n                break;\n            }\n        }\n        var location = createLocation(startingPosition, this.clonePosition());\n        if (!hasDigits) {\n            return this.error(expectNumberError, location);\n        }\n        decimal *= sign;\n        if (!isSafeInteger(decimal)) {\n            return this.error(invalidNumberError, location);\n        }\n        return { val: decimal, err: null };\n    };\n    Parser.prototype.offset = function () {\n        return this.position.offset;\n    };\n    Parser.prototype.isEOF = function () {\n        return this.offset() === this.message.length;\n    };\n    Parser.prototype.clonePosition = function () {\n        // This is much faster than `Object.assign` or spread.\n        return {\n            offset: this.position.offset,\n            line: this.position.line,\n            column: this.position.column,\n        };\n    };\n    /**\n     * Return the code point at the current position of the parser.\n     * Throws if the index is out of bound.\n     */\n    Parser.prototype.char = function () {\n        var offset = this.position.offset;\n        if (offset >= this.message.length) {\n            throw Error('out of bound');\n        }\n        var code = codePointAt(this.message, offset);\n        if (code === undefined) {\n            throw Error(\"Offset \".concat(offset, \" is at invalid UTF-16 code unit boundary\"));\n        }\n        return code;\n    };\n    Parser.prototype.error = function (kind, location) {\n        return {\n            val: null,\n            err: {\n                kind: kind,\n                message: this.message,\n                location: location,\n            },\n        };\n    };\n    /** Bump the parser to the next UTF-16 code unit. */\n    Parser.prototype.bump = function () {\n        if (this.isEOF()) {\n            return;\n        }\n        var code = this.char();\n        if (code === 10 /* '\\n' */) {\n            this.position.line += 1;\n            this.position.column = 1;\n            this.position.offset += 1;\n        }\n        else {\n            this.position.column += 1;\n            // 0 ~ 0x10000 -> unicode BMP, otherwise skip the surrogate pair.\n            this.position.offset += code < 0x10000 ? 1 : 2;\n        }\n    };\n    /**\n     * If the substring starting at the current position of the parser has\n     * the given prefix, then bump the parser to the character immediately\n     * following the prefix and return true. Otherwise, don't bump the parser\n     * and return false.\n     */\n    Parser.prototype.bumpIf = function (prefix) {\n        if (startsWith(this.message, prefix, this.offset())) {\n            for (var i = 0; i < prefix.length; i++) {\n                this.bump();\n            }\n            return true;\n        }\n        return false;\n    };\n    /**\n     * Bump the parser until the pattern character is found and return `true`.\n     * Otherwise bump to the end of the file and return `false`.\n     */\n    Parser.prototype.bumpUntil = function (pattern) {\n        var currentOffset = this.offset();\n        var index = this.message.indexOf(pattern, currentOffset);\n        if (index >= 0) {\n            this.bumpTo(index);\n            return true;\n        }\n        else {\n            this.bumpTo(this.message.length);\n            return false;\n        }\n    };\n    /**\n     * Bump the parser to the target offset.\n     * If target offset is beyond the end of the input, bump the parser to the end of the input.\n     */\n    Parser.prototype.bumpTo = function (targetOffset) {\n        if (this.offset() > targetOffset) {\n            throw Error(\"targetOffset \".concat(targetOffset, \" must be greater than or equal to the current offset \").concat(this.offset()));\n        }\n        targetOffset = Math.min(targetOffset, this.message.length);\n        while (true) {\n            var offset = this.offset();\n            if (offset === targetOffset) {\n                break;\n            }\n            if (offset > targetOffset) {\n                throw Error(\"targetOffset \".concat(targetOffset, \" is at invalid UTF-16 code unit boundary\"));\n            }\n            this.bump();\n            if (this.isEOF()) {\n                break;\n            }\n        }\n    };\n    /** advance the parser through all whitespace to the next non-whitespace code unit. */\n    Parser.prototype.bumpSpace = function () {\n        while (!this.isEOF() && _isWhiteSpace(this.char())) {\n            this.bump();\n        }\n    };\n    /**\n     * Peek at the *next* Unicode codepoint in the input without advancing the parser.\n     * If the input has been exhausted, then this returns null.\n     */\n    Parser.prototype.peek = function () {\n        if (this.isEOF()) {\n            return null;\n        }\n        var code = this.char();\n        var offset = this.offset();\n        var nextCode = this.message.charCodeAt(offset + (code >= 0x10000 ? 2 : 1));\n        return nextCode !== null && nextCode !== void 0 ? nextCode : null;\n    };\n    return Parser;\n}());\nexport { Parser };\n/**\n * This check if codepoint is alphabet (lower & uppercase)\n * @param codepoint\n * @returns\n */\nfunction _isAlpha(codepoint) {\n    return ((codepoint >= 97 && codepoint <= 122) ||\n        (codepoint >= 65 && codepoint <= 90));\n}\nfunction _isAlphaOrSlash(codepoint) {\n    return _isAlpha(codepoint) || codepoint === 47; /* '/' */\n}\n/** See `parseTag` function docs. */\nfunction _isPotentialElementNameChar(c) {\n    return (c === 45 /* '-' */ ||\n        c === 46 /* '.' */ ||\n        (c >= 48 && c <= 57) /* 0..9 */ ||\n        c === 95 /* '_' */ ||\n        (c >= 97 && c <= 122) /** a..z */ ||\n        (c >= 65 && c <= 90) /* A..Z */ ||\n        c == 0xb7 ||\n        (c >= 0xc0 && c <= 0xd6) ||\n        (c >= 0xd8 && c <= 0xf6) ||\n        (c >= 0xf8 && c <= 0x37d) ||\n        (c >= 0x37f && c <= 0x1fff) ||\n        (c >= 0x200c && c <= 0x200d) ||\n        (c >= 0x203f && c <= 0x2040) ||\n        (c >= 0x2070 && c <= 0x218f) ||\n        (c >= 0x2c00 && c <= 0x2fef) ||\n        (c >= 0x3001 && c <= 0xd7ff) ||\n        (c >= 0xf900 && c <= 0xfdcf) ||\n        (c >= 0xfdf0 && c <= 0xfffd) ||\n        (c >= 0x10000 && c <= 0xeffff));\n}\n/**\n * Code point equivalent of regex `\\p{White_Space}`.\n * From: https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt\n */\nfunction _isWhiteSpace(c) {\n    return ((c >= 0x0009 && c <= 0x000d) ||\n        c === 0x0020 ||\n        c === 0x0085 ||\n        (c >= 0x200e && c <= 0x200f) ||\n        c === 0x2028 ||\n        c === 0x2029);\n}\n/**\n * Code point equivalent of regex `\\p{Pattern_Syntax}`.\n * See https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt\n */\nfunction _isPatternSyntax(c) {\n    return ((c >= 0x0021 && c <= 0x0023) ||\n        c === 0x0024 ||\n        (c >= 0x0025 && c <= 0x0027) ||\n        c === 0x0028 ||\n        c === 0x0029 ||\n        c === 0x002a ||\n        c === 0x002b ||\n        c === 0x002c ||\n        c === 0x002d ||\n        (c >= 0x002e && c <= 0x002f) ||\n        (c >= 0x003a && c <= 0x003b) ||\n        (c >= 0x003c && c <= 0x003e) ||\n        (c >= 0x003f && c <= 0x0040) ||\n        c === 0x005b ||\n        c === 0x005c ||\n        c === 0x005d ||\n        c === 0x005e ||\n        c === 0x0060 ||\n        c === 0x007b ||\n        c === 0x007c ||\n        c === 0x007d ||\n        c === 0x007e ||\n        c === 0x00a1 ||\n        (c >= 0x00a2 && c <= 0x00a5) ||\n        c === 0x00a6 ||\n        c === 0x00a7 ||\n        c === 0x00a9 ||\n        c === 0x00ab ||\n        c === 0x00ac ||\n        c === 0x00ae ||\n        c === 0x00b0 ||\n        c === 0x00b1 ||\n        c === 0x00b6 ||\n        c === 0x00bb ||\n        c === 0x00bf ||\n        c === 0x00d7 ||\n        c === 0x00f7 ||\n        (c >= 0x2010 && c <= 0x2015) ||\n        (c >= 0x2016 && c <= 0x2017) ||\n        c === 0x2018 ||\n        c === 0x2019 ||\n        c === 0x201a ||\n        (c >= 0x201b && c <= 0x201c) ||\n        c === 0x201d ||\n        c === 0x201e ||\n        c === 0x201f ||\n        (c >= 0x2020 && c <= 0x2027) ||\n        (c >= 0x2030 && c <= 0x2038) ||\n        c === 0x2039 ||\n        c === 0x203a ||\n        (c >= 0x203b && c <= 0x203e) ||\n        (c >= 0x2041 && c <= 0x2043) ||\n        c === 0x2044 ||\n        c === 0x2045 ||\n        c === 0x2046 ||\n        (c >= 0x2047 && c <= 0x2051) ||\n        c === 0x2052 ||\n        c === 0x2053 ||\n        (c >= 0x2055 && c <= 0x205e) ||\n        (c >= 0x2190 && c <= 0x2194) ||\n        (c >= 0x2195 && c <= 0x2199) ||\n        (c >= 0x219a && c <= 0x219b) ||\n        (c >= 0x219c && c <= 0x219f) ||\n        c === 0x21a0 ||\n        (c >= 0x21a1 && c <= 0x21a2) ||\n        c === 0x21a3 ||\n        (c >= 0x21a4 && c <= 0x21a5) ||\n        c === 0x21a6 ||\n        (c >= 0x21a7 && c <= 0x21ad) ||\n        c === 0x21ae ||\n        (c >= 0x21af && c <= 0x21cd) ||\n        (c >= 0x21ce && c <= 0x21cf) ||\n        (c >= 0x21d0 && c <= 0x21d1) ||\n        c === 0x21d2 ||\n        c === 0x21d3 ||\n        c === 0x21d4 ||\n        (c >= 0x21d5 && c <= 0x21f3) ||\n        (c >= 0x21f4 && c <= 0x22ff) ||\n        (c >= 0x2300 && c <= 0x2307) ||\n        c === 0x2308 ||\n        c === 0x2309 ||\n        c === 0x230a ||\n        c === 0x230b ||\n        (c >= 0x230c && c <= 0x231f) ||\n        (c >= 0x2320 && c <= 0x2321) ||\n        (c >= 0x2322 && c <= 0x2328) ||\n        c === 0x2329 ||\n        c === 0x232a ||\n        (c >= 0x232b && c <= 0x237b) ||\n        c === 0x237c ||\n        (c >= 0x237d && c <= 0x239a) ||\n        (c >= 0x239b && c <= 0x23b3) ||\n        (c >= 0x23b4 && c <= 0x23db) ||\n        (c >= 0x23dc && c <= 0x23e1) ||\n        (c >= 0x23e2 && c <= 0x2426) ||\n        (c >= 0x2427 && c <= 0x243f) ||\n        (c >= 0x2440 && c <= 0x244a) ||\n        (c >= 0x244b && c <= 0x245f) ||\n        (c >= 0x2500 && c <= 0x25b6) ||\n        c === 0x25b7 ||\n        (c >= 0x25b8 && c <= 0x25c0) ||\n        c === 0x25c1 ||\n        (c >= 0x25c2 && c <= 0x25f7) ||\n        (c >= 0x25f8 && c <= 0x25ff) ||\n        (c >= 0x2600 && c <= 0x266e) ||\n        c === 0x266f ||\n        (c >= 0x2670 && c <= 0x2767) ||\n        c === 0x2768 ||\n        c === 0x2769 ||\n        c === 0x276a ||\n        c === 0x276b ||\n        c === 0x276c ||\n        c === 0x276d ||\n        c === 0x276e ||\n        c === 0x276f ||\n        c === 0x2770 ||\n        c === 0x2771 ||\n        c === 0x2772 ||\n        c === 0x2773 ||\n        c === 0x2774 ||\n        c === 0x2775 ||\n        (c >= 0x2794 && c <= 0x27bf) ||\n        (c >= 0x27c0 && c <= 0x27c4) ||\n        c === 0x27c5 ||\n        c === 0x27c6 ||\n        (c >= 0x27c7 && c <= 0x27e5) ||\n        c === 0x27e6 ||\n        c === 0x27e7 ||\n        c === 0x27e8 ||\n        c === 0x27e9 ||\n        c === 0x27ea ||\n        c === 0x27eb ||\n        c === 0x27ec ||\n        c === 0x27ed ||\n        c === 0x27ee ||\n        c === 0x27ef ||\n        (c >= 0x27f0 && c <= 0x27ff) ||\n        (c >= 0x2800 && c <= 0x28ff) ||\n        (c >= 0x2900 && c <= 0x2982) ||\n        c === 0x2983 ||\n        c === 0x2984 ||\n        c === 0x2985 ||\n        c === 0x2986 ||\n        c === 0x2987 ||\n        c === 0x2988 ||\n        c === 0x2989 ||\n        c === 0x298a ||\n        c === 0x298b ||\n        c === 0x298c ||\n        c === 0x298d ||\n        c === 0x298e ||\n        c === 0x298f ||\n        c === 0x2990 ||\n        c === 0x2991 ||\n        c === 0x2992 ||\n        c === 0x2993 ||\n        c === 0x2994 ||\n        c === 0x2995 ||\n        c === 0x2996 ||\n        c === 0x2997 ||\n        c === 0x2998 ||\n        (c >= 0x2999 && c <= 0x29d7) ||\n        c === 0x29d8 ||\n        c === 0x29d9 ||\n        c === 0x29da ||\n        c === 0x29db ||\n        (c >= 0x29dc && c <= 0x29fb) ||\n        c === 0x29fc ||\n        c === 0x29fd ||\n        (c >= 0x29fe && c <= 0x2aff) ||\n        (c >= 0x2b00 && c <= 0x2b2f) ||\n        (c >= 0x2b30 && c <= 0x2b44) ||\n        (c >= 0x2b45 && c <= 0x2b46) ||\n        (c >= 0x2b47 && c <= 0x2b4c) ||\n        (c >= 0x2b4d && c <= 0x2b73) ||\n        (c >= 0x2b74 && c <= 0x2b75) ||\n        (c >= 0x2b76 && c <= 0x2b95) ||\n        c === 0x2b96 ||\n        (c >= 0x2b97 && c <= 0x2bff) ||\n        (c >= 0x2e00 && c <= 0x2e01) ||\n        c === 0x2e02 ||\n        c === 0x2e03 ||\n        c === 0x2e04 ||\n        c === 0x2e05 ||\n        (c >= 0x2e06 && c <= 0x2e08) ||\n        c === 0x2e09 ||\n        c === 0x2e0a ||\n        c === 0x2e0b ||\n        c === 0x2e0c ||\n        c === 0x2e0d ||\n        (c >= 0x2e0e && c <= 0x2e16) ||\n        c === 0x2e17 ||\n        (c >= 0x2e18 && c <= 0x2e19) ||\n        c === 0x2e1a ||\n        c === 0x2e1b ||\n        c === 0x2e1c ||\n        c === 0x2e1d ||\n        (c >= 0x2e1e && c <= 0x2e1f) ||\n        c === 0x2e20 ||\n        c === 0x2e21 ||\n        c === 0x2e22 ||\n        c === 0x2e23 ||\n        c === 0x2e24 ||\n        c === 0x2e25 ||\n        c === 0x2e26 ||\n        c === 0x2e27 ||\n        c === 0x2e28 ||\n        c === 0x2e29 ||\n        (c >= 0x2e2a && c <= 0x2e2e) ||\n        c === 0x2e2f ||\n        (c >= 0x2e30 && c <= 0x2e39) ||\n        (c >= 0x2e3a && c <= 0x2e3b) ||\n        (c >= 0x2e3c && c <= 0x2e3f) ||\n        c === 0x2e40 ||\n        c === 0x2e41 ||\n        c === 0x2e42 ||\n        (c >= 0x2e43 && c <= 0x2e4f) ||\n        (c >= 0x2e50 && c <= 0x2e51) ||\n        c === 0x2e52 ||\n        (c >= 0x2e53 && c <= 0x2e7f) ||\n        (c >= 0x3001 && c <= 0x3003) ||\n        c === 0x3008 ||\n        c === 0x3009 ||\n        c === 0x300a ||\n        c === 0x300b ||\n        c === 0x300c ||\n        c === 0x300d ||\n        c === 0x300e ||\n        c === 0x300f ||\n        c === 0x3010 ||\n        c === 0x3011 ||\n        (c >= 0x3012 && c <= 0x3013) ||\n        c === 0x3014 ||\n        c === 0x3015 ||\n        c === 0x3016 ||\n        c === 0x3017 ||\n        c === 0x3018 ||\n        c === 0x3019 ||\n        c === 0x301a ||\n        c === 0x301b ||\n        c === 0x301c ||\n        c === 0x301d ||\n        (c >= 0x301e && c <= 0x301f) ||\n        c === 0x3020 ||\n        c === 0x3030 ||\n        c === 0xfd3e ||\n        c === 0xfd3f ||\n        (c >= 0xfe45 && c <= 0xfe46));\n}\n","// @generated from regex-gen.ts\nexport var SPACE_SEPARATOR_REGEX = /[ \\xA0\\u1680\\u2000-\\u200A\\u202F\\u205F\\u3000]/;\nexport var WHITE_SPACE_REGEX = /[\\t-\\r \\x85\\u200E\\u200F\\u2028\\u2029]/;\n","// @generated from time-data-gen.ts\n// prettier-ignore  \nexport var timeData = {\n    \"AX\": [\n        \"H\"\n    ],\n    \"BQ\": [\n        \"H\"\n    ],\n    \"CP\": [\n        \"H\"\n    ],\n    \"CZ\": [\n        \"H\"\n    ],\n    \"DK\": [\n        \"H\"\n    ],\n    \"FI\": [\n        \"H\"\n    ],\n    \"ID\": [\n        \"H\"\n    ],\n    \"IS\": [\n        \"H\"\n    ],\n    \"ML\": [\n        \"H\"\n    ],\n    \"NE\": [\n        \"H\"\n    ],\n    \"RU\": [\n        \"H\"\n    ],\n    \"SE\": [\n        \"H\"\n    ],\n    \"SJ\": [\n        \"H\"\n    ],\n    \"SK\": [\n        \"H\"\n    ],\n    \"AS\": [\n        \"h\",\n        \"H\"\n    ],\n    \"BT\": [\n        \"h\",\n        \"H\"\n    ],\n    \"DJ\": [\n        \"h\",\n        \"H\"\n    ],\n    \"ER\": [\n        \"h\",\n        \"H\"\n    ],\n    \"GH\": [\n        \"h\",\n        \"H\"\n    ],\n    \"IN\": [\n        \"h\",\n        \"H\"\n    ],\n    \"LS\": [\n        \"h\",\n        \"H\"\n    ],\n    \"PG\": [\n        \"h\",\n        \"H\"\n    ],\n    \"PW\": [\n        \"h\",\n        \"H\"\n    ],\n    \"SO\": [\n        \"h\",\n        \"H\"\n    ],\n    \"TO\": [\n        \"h\",\n        \"H\"\n    ],\n    \"VU\": [\n        \"h\",\n        \"H\"\n    ],\n    \"WS\": [\n        \"h\",\n        \"H\"\n    ],\n    \"001\": [\n        \"H\",\n        \"h\"\n    ],\n    \"AL\": [\n        \"h\",\n        \"H\",\n        \"hB\"\n    ],\n    \"TD\": [\n        \"h\",\n        \"H\",\n        \"hB\"\n    ],\n    \"ca-ES\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"CF\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"CM\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"fr-CA\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"gl-ES\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"it-CH\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"it-IT\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"LU\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"NP\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"PF\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"SC\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"SM\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"SN\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"TF\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"VA\": [\n        \"H\",\n        \"h\",\n        \"hB\"\n    ],\n    \"CY\": [\n        \"h\",\n        \"H\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"GR\": [\n        \"h\",\n        \"H\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"CO\": [\n        \"h\",\n        \"H\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"DO\": [\n        \"h\",\n        \"H\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"KP\": [\n        \"h\",\n        \"H\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"KR\": [\n        \"h\",\n        \"H\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"NA\": [\n        \"h\",\n        \"H\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"PA\": [\n        \"h\",\n        \"H\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"PR\": [\n        \"h\",\n        \"H\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"VE\": [\n        \"h\",\n        \"H\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"AC\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"AI\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"BW\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"BZ\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"CC\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"CK\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"CX\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"DG\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"FK\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"GB\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"GG\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"GI\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"IE\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"IM\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"IO\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"JE\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"LT\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"MK\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"MN\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"MS\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"NF\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"NG\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"NR\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"NU\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"PN\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"SH\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"SX\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"TA\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"ZA\": [\n        \"H\",\n        \"h\",\n        \"hb\",\n        \"hB\"\n    ],\n    \"af-ZA\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"AR\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"CL\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"CR\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"CU\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"EA\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"es-BO\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"es-BR\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"es-EC\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"es-ES\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"es-GQ\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"es-PE\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"GT\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"HN\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"IC\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"KG\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"KM\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"LK\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"MA\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"MX\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"NI\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"PY\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"SV\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"UY\": [\n        \"H\",\n        \"h\",\n        \"hB\",\n        \"hb\"\n    ],\n    \"JP\": [\n        \"H\",\n        \"h\",\n        \"K\"\n    ],\n    \"AD\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"AM\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"AO\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"AT\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"AW\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"BE\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"BF\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"BJ\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"BL\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"BR\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"CG\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"CI\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"CV\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"DE\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"EE\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"FR\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"GA\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"GF\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"GN\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"GP\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"GW\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"HR\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"IL\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"IT\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"KZ\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"MC\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"MD\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"MF\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"MQ\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"MZ\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"NC\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"NL\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"PM\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"PT\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"RE\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"RO\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"SI\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"SR\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"ST\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"TG\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"TR\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"WF\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"YT\": [\n        \"H\",\n        \"hB\"\n    ],\n    \"BD\": [\n        \"h\",\n        \"hB\",\n        \"H\"\n    ],\n    \"PK\": [\n        \"h\",\n        \"hB\",\n        \"H\"\n    ],\n    \"AZ\": [\n        \"H\",\n        \"hB\",\n        \"h\"\n    ],\n    \"BA\": [\n        \"H\",\n        \"hB\",\n        \"h\"\n    ],\n    \"BG\": [\n        \"H\",\n        \"hB\",\n        \"h\"\n    ],\n    \"CH\": [\n        \"H\",\n        \"hB\",\n        \"h\"\n    ],\n    \"GE\": [\n        \"H\",\n        \"hB\",\n        \"h\"\n    ],\n    \"LI\": [\n        \"H\",\n        \"hB\",\n        \"h\"\n    ],\n    \"ME\": [\n        \"H\",\n        \"hB\",\n        \"h\"\n    ],\n    \"RS\": [\n        \"H\",\n        \"hB\",\n        \"h\"\n    ],\n    \"UA\": [\n        \"H\",\n        \"hB\",\n        \"h\"\n    ],\n    \"UZ\": [\n        \"H\",\n        \"hB\",\n        \"h\"\n    ],\n    \"XK\": [\n        \"H\",\n        \"hB\",\n        \"h\"\n    ],\n    \"AG\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"AU\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"BB\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"BM\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"BS\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"CA\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"DM\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"en-001\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"FJ\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"FM\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"GD\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"GM\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"GU\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"GY\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"JM\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"KI\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"KN\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"KY\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"LC\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"LR\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"MH\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"MP\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"MW\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"NZ\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"SB\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"SG\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"SL\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"SS\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"SZ\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"TC\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"TT\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"UM\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"US\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"VC\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"VG\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"VI\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"ZM\": [\n        \"h\",\n        \"hb\",\n        \"H\",\n        \"hB\"\n    ],\n    \"BO\": [\n        \"H\",\n        \"hB\",\n        \"h\",\n        \"hb\"\n    ],\n    \"EC\": [\n        \"H\",\n        \"hB\",\n        \"h\",\n        \"hb\"\n    ],\n    \"ES\": [\n        \"H\",\n        \"hB\",\n        \"h\",\n        \"hb\"\n    ],\n    \"GQ\": [\n        \"H\",\n        \"hB\",\n        \"h\",\n        \"hb\"\n    ],\n    \"PE\": [\n        \"H\",\n        \"hB\",\n        \"h\",\n        \"hb\"\n    ],\n    \"AE\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"ar-001\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"BH\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"DZ\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"EG\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"EH\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"HK\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"IQ\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"JO\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"KW\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"LB\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"LY\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"MO\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"MR\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"OM\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"PH\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"PS\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"QA\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"SA\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"SD\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"SY\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"TN\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"YE\": [\n        \"h\",\n        \"hB\",\n        \"hb\",\n        \"H\"\n    ],\n    \"AF\": [\n        \"H\",\n        \"hb\",\n        \"hB\",\n        \"h\"\n    ],\n    \"LA\": [\n        \"H\",\n        \"hb\",\n        \"hB\",\n        \"h\"\n    ],\n    \"CN\": [\n        \"H\",\n        \"hB\",\n        \"hb\",\n        \"h\"\n    ],\n    \"LV\": [\n        \"H\",\n        \"hB\",\n        \"hb\",\n        \"h\"\n    ],\n    \"TL\": [\n        \"H\",\n        \"hB\",\n        \"hb\",\n        \"h\"\n    ],\n    \"zu-ZA\": [\n        \"H\",\n        \"hB\",\n        \"hb\",\n        \"h\"\n    ],\n    \"CD\": [\n        \"hB\",\n        \"H\"\n    ],\n    \"IR\": [\n        \"hB\",\n        \"H\"\n    ],\n    \"hi-IN\": [\n        \"hB\",\n        \"h\",\n        \"H\"\n    ],\n    \"kn-IN\": [\n        \"hB\",\n        \"h\",\n        \"H\"\n    ],\n    \"ml-IN\": [\n        \"hB\",\n        \"h\",\n        \"H\"\n    ],\n    \"te-IN\": [\n        \"hB\",\n        \"h\",\n        \"H\"\n    ],\n    \"KH\": [\n        \"hB\",\n        \"h\",\n        \"H\",\n        \"hb\"\n    ],\n    \"ta-IN\": [\n        \"hB\",\n        \"h\",\n        \"hb\",\n        \"H\"\n    ],\n    \"BN\": [\n        \"hb\",\n        \"hB\",\n        \"h\",\n        \"H\"\n    ],\n    \"MY\": [\n        \"hb\",\n        \"hB\",\n        \"h\",\n        \"H\"\n    ],\n    \"ET\": [\n        \"hB\",\n        \"hb\",\n        \"h\",\n        \"H\"\n    ],\n    \"gu-IN\": [\n        \"hB\",\n        \"hb\",\n        \"h\",\n        \"H\"\n    ],\n    \"mr-IN\": [\n        \"hB\",\n        \"hb\",\n        \"h\",\n        \"H\"\n    ],\n    \"pa-IN\": [\n        \"hB\",\n        \"hb\",\n        \"h\",\n        \"H\"\n    ],\n    \"TW\": [\n        \"hB\",\n        \"hb\",\n        \"h\",\n        \"H\"\n    ],\n    \"KE\": [\n        \"hB\",\n        \"hb\",\n        \"H\",\n        \"h\"\n    ],\n    \"MM\": [\n        \"hB\",\n        \"hb\",\n        \"H\",\n        \"h\"\n    ],\n    \"TZ\": [\n        \"hB\",\n        \"hb\",\n        \"H\",\n        \"h\"\n    ],\n    \"UG\": [\n        \"hB\",\n        \"hb\",\n        \"H\",\n        \"h\"\n    ]\n};\n","export var TYPE;\n(function (TYPE) {\n    /**\n     * Raw text\n     */\n    TYPE[TYPE[\"literal\"] = 0] = \"literal\";\n    /**\n     * Variable w/o any format, e.g `var` in `this is a {var}`\n     */\n    TYPE[TYPE[\"argument\"] = 1] = \"argument\";\n    /**\n     * Variable w/ number format\n     */\n    TYPE[TYPE[\"number\"] = 2] = \"number\";\n    /**\n     * Variable w/ date format\n     */\n    TYPE[TYPE[\"date\"] = 3] = \"date\";\n    /**\n     * Variable w/ time format\n     */\n    TYPE[TYPE[\"time\"] = 4] = \"time\";\n    /**\n     * Variable w/ select format\n     */\n    TYPE[TYPE[\"select\"] = 5] = \"select\";\n    /**\n     * Variable w/ plural format\n     */\n    TYPE[TYPE[\"plural\"] = 6] = \"plural\";\n    /**\n     * Only possible within plural argument.\n     * This is the `#` symbol that will be substituted with the count.\n     */\n    TYPE[TYPE[\"pound\"] = 7] = \"pound\";\n    /**\n     * XML-like tag\n     */\n    TYPE[TYPE[\"tag\"] = 8] = \"tag\";\n})(TYPE || (TYPE = {}));\nexport var SKELETON_TYPE;\n(function (SKELETON_TYPE) {\n    SKELETON_TYPE[SKELETON_TYPE[\"number\"] = 0] = \"number\";\n    SKELETON_TYPE[SKELETON_TYPE[\"dateTime\"] = 1] = \"dateTime\";\n})(SKELETON_TYPE || (SKELETON_TYPE = {}));\n/**\n * Type Guards\n */\nexport function isLiteralElement(el) {\n    return el.type === TYPE.literal;\n}\nexport function isArgumentElement(el) {\n    return el.type === TYPE.argument;\n}\nexport function isNumberElement(el) {\n    return el.type === TYPE.number;\n}\nexport function isDateElement(el) {\n    return el.type === TYPE.date;\n}\nexport function isTimeElement(el) {\n    return el.type === TYPE.time;\n}\nexport function isSelectElement(el) {\n    return el.type === TYPE.select;\n}\nexport function isPluralElement(el) {\n    return el.type === TYPE.plural;\n}\nexport function isPoundElement(el) {\n    return el.type === TYPE.pound;\n}\nexport function isTagElement(el) {\n    return el.type === TYPE.tag;\n}\nexport function isNumberSkeleton(el) {\n    return !!(el && typeof el === 'object' && el.type === SKELETON_TYPE.number);\n}\nexport function isDateTimeSkeleton(el) {\n    return !!(el && typeof el === 'object' && el.type === SKELETON_TYPE.dateTime);\n}\nexport function createLiteralElement(value) {\n    return {\n        type: TYPE.literal,\n        value: value,\n    };\n}\nexport function createNumberElement(value, style) {\n    return {\n        type: TYPE.number,\n        value: value,\n        style: style,\n    };\n}\n","/**\n * https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table\n * Credit: https://github.com/caridy/intl-datetimeformat-pattern/blob/master/index.js\n * with some tweaks\n */\nvar DATE_TIME_REGEX = /(?:[Eec]{1,6}|G{1,5}|[Qq]{1,5}|(?:[yYur]+|U{1,5})|[ML]{1,5}|d{1,2}|D{1,3}|F{1}|[abB]{1,5}|[hkHK]{1,2}|w{1,2}|W{1}|m{1,2}|s{1,2}|[zZOvVxX]{1,4})(?=([^']*'[^']*')*[^']*$)/g;\n/**\n * Parse Date time skeleton into Intl.DateTimeFormatOptions\n * Ref: https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table\n * @public\n * @param skeleton skeleton string\n */\nexport function parseDateTimeSkeleton(skeleton) {\n    var result = {};\n    skeleton.replace(DATE_TIME_REGEX, function (match) {\n        var len = match.length;\n        switch (match[0]) {\n            // Era\n            case 'G':\n                result.era = len === 4 ? 'long' : len === 5 ? 'narrow' : 'short';\n                break;\n            // Year\n            case 'y':\n                result.year = len === 2 ? '2-digit' : 'numeric';\n                break;\n            case 'Y':\n            case 'u':\n            case 'U':\n            case 'r':\n                throw new RangeError('`Y/u/U/r` (year) patterns are not supported, use `y` instead');\n            // Quarter\n            case 'q':\n            case 'Q':\n                throw new RangeError('`q/Q` (quarter) patterns are not supported');\n            // Month\n            case 'M':\n            case 'L':\n                result.month = ['numeric', '2-digit', 'short', 'long', 'narrow'][len - 1];\n                break;\n            // Week\n            case 'w':\n            case 'W':\n                throw new RangeError('`w/W` (week) patterns are not supported');\n            case 'd':\n                result.day = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'D':\n            case 'F':\n            case 'g':\n                throw new RangeError('`D/F/g` (day) patterns are not supported, use `d` instead');\n            // Weekday\n            case 'E':\n                result.weekday = len === 4 ? 'short' : len === 5 ? 'narrow' : 'short';\n                break;\n            case 'e':\n                if (len < 4) {\n                    throw new RangeError('`e..eee` (weekday) patterns are not supported');\n                }\n                result.weekday = ['short', 'long', 'narrow', 'short'][len - 4];\n                break;\n            case 'c':\n                if (len < 4) {\n                    throw new RangeError('`c..ccc` (weekday) patterns are not supported');\n                }\n                result.weekday = ['short', 'long', 'narrow', 'short'][len - 4];\n                break;\n            // Period\n            case 'a': // AM, PM\n                result.hour12 = true;\n                break;\n            case 'b': // am, pm, noon, midnight\n            case 'B': // flexible day periods\n                throw new RangeError('`b/B` (period) patterns are not supported, use `a` instead');\n            // Hour\n            case 'h':\n                result.hourCycle = 'h12';\n                result.hour = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'H':\n                result.hourCycle = 'h23';\n                result.hour = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'K':\n                result.hourCycle = 'h11';\n                result.hour = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'k':\n                result.hourCycle = 'h24';\n                result.hour = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'j':\n            case 'J':\n            case 'C':\n                throw new RangeError('`j/J/C` (hour) patterns are not supported, use `h/H/K/k` instead');\n            // Minute\n            case 'm':\n                result.minute = ['numeric', '2-digit'][len - 1];\n                break;\n            // Second\n            case 's':\n                result.second = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'S':\n            case 'A':\n                throw new RangeError('`S/A` (second) patterns are not supported, use `s` instead');\n            // Zone\n            case 'z': // 1..3, 4: specific non-location format\n                result.timeZoneName = len < 4 ? 'short' : 'long';\n                break;\n            case 'Z': // 1..3, 4, 5: The ISO8601 varios formats\n            case 'O': // 1, 4: miliseconds in day short, long\n            case 'v': // 1, 4: generic non-location format\n            case 'V': // 1, 2, 3, 4: time zone ID or city\n            case 'X': // 1, 2, 3, 4: The ISO8601 varios formats\n            case 'x': // 1, 2, 3, 4: The ISO8601 varios formats\n                throw new RangeError('`Z/O/v/V/X/x` (timeZone) patterns are not supported, use `z` instead');\n        }\n        return '';\n    });\n    return result;\n}\n","import { __assign } from \"tslib\";\nimport { WHITE_SPACE_REGEX } from './regex.generated';\nexport function parseNumberSkeletonFromString(skeleton) {\n    if (skeleton.length === 0) {\n        throw new Error('Number skeleton cannot be empty');\n    }\n    // Parse the skeleton\n    var stringTokens = skeleton\n        .split(WHITE_SPACE_REGEX)\n        .filter(function (x) { return x.length > 0; });\n    var tokens = [];\n    for (var _i = 0, stringTokens_1 = stringTokens; _i < stringTokens_1.length; _i++) {\n        var stringToken = stringTokens_1[_i];\n        var stemAndOptions = stringToken.split('/');\n        if (stemAndOptions.length === 0) {\n            throw new Error('Invalid number skeleton');\n        }\n        var stem = stemAndOptions[0], options = stemAndOptions.slice(1);\n        for (var _a = 0, options_1 = options; _a < options_1.length; _a++) {\n            var option = options_1[_a];\n            if (option.length === 0) {\n                throw new Error('Invalid number skeleton');\n            }\n        }\n        tokens.push({ stem: stem, options: options });\n    }\n    return tokens;\n}\nfunction icuUnitToEcma(unit) {\n    return unit.replace(/^(.*?)-/, '');\n}\nvar FRACTION_PRECISION_REGEX = /^\\.(?:(0+)(\\*)?|(#+)|(0+)(#+))$/g;\nvar SIGNIFICANT_PRECISION_REGEX = /^(@+)?(\\+|#+)?[rs]?$/g;\nvar INTEGER_WIDTH_REGEX = /(\\*)(0+)|(#+)(0+)|(0+)/g;\nvar CONCISE_INTEGER_WIDTH_REGEX = /^(0+)$/;\nfunction parseSignificantPrecision(str) {\n    var result = {};\n    if (str[str.length - 1] === 'r') {\n        result.roundingPriority = 'morePrecision';\n    }\n    else if (str[str.length - 1] === 's') {\n        result.roundingPriority = 'lessPrecision';\n    }\n    str.replace(SIGNIFICANT_PRECISION_REGEX, function (_, g1, g2) {\n        // @@@ case\n        if (typeof g2 !== 'string') {\n            result.minimumSignificantDigits = g1.length;\n            result.maximumSignificantDigits = g1.length;\n        }\n        // @@@+ case\n        else if (g2 === '+') {\n            result.minimumSignificantDigits = g1.length;\n        }\n        // .### case\n        else if (g1[0] === '#') {\n            result.maximumSignificantDigits = g1.length;\n        }\n        // .@@## or .@@@ case\n        else {\n            result.minimumSignificantDigits = g1.length;\n            result.maximumSignificantDigits =\n                g1.length + (typeof g2 === 'string' ? g2.length : 0);\n        }\n        return '';\n    });\n    return result;\n}\nfunction parseSign(str) {\n    switch (str) {\n        case 'sign-auto':\n            return {\n                signDisplay: 'auto',\n            };\n        case 'sign-accounting':\n        case '()':\n            return {\n                currencySign: 'accounting',\n            };\n        case 'sign-always':\n        case '+!':\n            return {\n                signDisplay: 'always',\n            };\n        case 'sign-accounting-always':\n        case '()!':\n            return {\n                signDisplay: 'always',\n                currencySign: 'accounting',\n            };\n        case 'sign-except-zero':\n        case '+?':\n            return {\n                signDisplay: 'exceptZero',\n            };\n        case 'sign-accounting-except-zero':\n        case '()?':\n            return {\n                signDisplay: 'exceptZero',\n                currencySign: 'accounting',\n            };\n        case 'sign-never':\n        case '+_':\n            return {\n                signDisplay: 'never',\n            };\n    }\n}\nfunction parseConciseScientificAndEngineeringStem(stem) {\n    // Engineering\n    var result;\n    if (stem[0] === 'E' && stem[1] === 'E') {\n        result = {\n            notation: 'engineering',\n        };\n        stem = stem.slice(2);\n    }\n    else if (stem[0] === 'E') {\n        result = {\n            notation: 'scientific',\n        };\n        stem = stem.slice(1);\n    }\n    if (result) {\n        var signDisplay = stem.slice(0, 2);\n        if (signDisplay === '+!') {\n            result.signDisplay = 'always';\n            stem = stem.slice(2);\n        }\n        else if (signDisplay === '+?') {\n            result.signDisplay = 'exceptZero';\n            stem = stem.slice(2);\n        }\n        if (!CONCISE_INTEGER_WIDTH_REGEX.test(stem)) {\n            throw new Error('Malformed concise eng/scientific notation');\n        }\n        result.minimumIntegerDigits = stem.length;\n    }\n    return result;\n}\nfunction parseNotationOptions(opt) {\n    var result = {};\n    var signOpts = parseSign(opt);\n    if (signOpts) {\n        return signOpts;\n    }\n    return result;\n}\n/**\n * https://github.com/unicode-org/icu/blob/master/docs/userguide/format_parse/numbers/skeletons.md#skeleton-stems-and-options\n */\nexport function parseNumberSkeleton(tokens) {\n    var result = {};\n    for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {\n        var token = tokens_1[_i];\n        switch (token.stem) {\n            case 'percent':\n            case '%':\n                result.style = 'percent';\n                continue;\n            case '%x100':\n                result.style = 'percent';\n                result.scale = 100;\n                continue;\n            case 'currency':\n                result.style = 'currency';\n                result.currency = token.options[0];\n                continue;\n            case 'group-off':\n            case ',_':\n                result.useGrouping = false;\n                continue;\n            case 'precision-integer':\n            case '.':\n                result.maximumFractionDigits = 0;\n                continue;\n            case 'measure-unit':\n            case 'unit':\n                result.style = 'unit';\n                result.unit = icuUnitToEcma(token.options[0]);\n                continue;\n            case 'compact-short':\n            case 'K':\n                result.notation = 'compact';\n                result.compactDisplay = 'short';\n                continue;\n            case 'compact-long':\n            case 'KK':\n                result.notation = 'compact';\n                result.compactDisplay = 'long';\n                continue;\n            case 'scientific':\n                result = __assign(__assign(__assign({}, result), { notation: 'scientific' }), token.options.reduce(function (all, opt) { return (__assign(__assign({}, all), parseNotationOptions(opt))); }, {}));\n                continue;\n            case 'engineering':\n                result = __assign(__assign(__assign({}, result), { notation: 'engineering' }), token.options.reduce(function (all, opt) { return (__assign(__assign({}, all), parseNotationOptions(opt))); }, {}));\n                continue;\n            case 'notation-simple':\n                result.notation = 'standard';\n                continue;\n            // https://github.com/unicode-org/icu/blob/master/icu4c/source/i18n/unicode/unumberformatter.h\n            case 'unit-width-narrow':\n                result.currencyDisplay = 'narrowSymbol';\n                result.unitDisplay = 'narrow';\n                continue;\n            case 'unit-width-short':\n                result.currencyDisplay = 'code';\n                result.unitDisplay = 'short';\n                continue;\n            case 'unit-width-full-name':\n                result.currencyDisplay = 'name';\n                result.unitDisplay = 'long';\n                continue;\n            case 'unit-width-iso-code':\n                result.currencyDisplay = 'symbol';\n                continue;\n            case 'scale':\n                result.scale = parseFloat(token.options[0]);\n                continue;\n            // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#integer-width\n            case 'integer-width':\n                if (token.options.length > 1) {\n                    throw new RangeError('integer-width stems only accept a single optional option');\n                }\n                token.options[0].replace(INTEGER_WIDTH_REGEX, function (_, g1, g2, g3, g4, g5) {\n                    if (g1) {\n                        result.minimumIntegerDigits = g2.length;\n                    }\n                    else if (g3 && g4) {\n                        throw new Error('We currently do not support maximum integer digits');\n                    }\n                    else if (g5) {\n                        throw new Error('We currently do not support exact integer digits');\n                    }\n                    return '';\n                });\n                continue;\n        }\n        // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#integer-width\n        if (CONCISE_INTEGER_WIDTH_REGEX.test(token.stem)) {\n            result.minimumIntegerDigits = token.stem.length;\n            continue;\n        }\n        if (FRACTION_PRECISION_REGEX.test(token.stem)) {\n            // Precision\n            // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#fraction-precision\n            // precision-integer case\n            if (token.options.length > 1) {\n                throw new RangeError('Fraction-precision stems only accept a single optional option');\n            }\n            token.stem.replace(FRACTION_PRECISION_REGEX, function (_, g1, g2, g3, g4, g5) {\n                // .000* case (before ICU67 it was .000+)\n                if (g2 === '*') {\n                    result.minimumFractionDigits = g1.length;\n                }\n                // .### case\n                else if (g3 && g3[0] === '#') {\n                    result.maximumFractionDigits = g3.length;\n                }\n                // .00## case\n                else if (g4 && g5) {\n                    result.minimumFractionDigits = g4.length;\n                    result.maximumFractionDigits = g4.length + g5.length;\n                }\n                else {\n                    result.minimumFractionDigits = g1.length;\n                    result.maximumFractionDigits = g1.length;\n                }\n                return '';\n            });\n            var opt = token.options[0];\n            // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#trailing-zero-display\n            if (opt === 'w') {\n                result = __assign(__assign({}, result), { trailingZeroDisplay: 'stripIfInteger' });\n            }\n            else if (opt) {\n                result = __assign(__assign({}, result), parseSignificantPrecision(opt));\n            }\n            continue;\n        }\n        // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#significant-digits-precision\n        if (SIGNIFICANT_PRECISION_REGEX.test(token.stem)) {\n            result = __assign(__assign({}, result), parseSignificantPrecision(token.stem));\n            continue;\n        }\n        var signOpts = parseSign(token.stem);\n        if (signOpts) {\n            result = __assign(__assign({}, result), signOpts);\n        }\n        var conciseScientificAndEngineeringOpts = parseConciseScientificAndEngineeringStem(token.stem);\n        if (conciseScientificAndEngineeringOpts) {\n            result = __assign(__assign({}, result), conciseScientificAndEngineeringOpts);\n        }\n    }\n    return result;\n}\n","// @generated from regex-gen.ts\nexport var WHITE_SPACE_REGEX = /[\\t-\\r \\x85\\u200E\\u200F\\u2028\\u2029]/i;\n","/*\nCopyright (c) 2014, Yahoo! Inc. All rights reserved.\nCopyrights licensed under the New BSD License.\nSee the accompanying LICENSE file for terms.\n*/\nimport { __assign, __spreadArray } from \"tslib\";\nimport { parse } from '@formatjs/icu-messageformat-parser';\nimport memoize, { strategies } from '@formatjs/fast-memoize';\nimport { formatToParts, PART_TYPE, } from './formatters';\n// -- MessageFormat --------------------------------------------------------\nfunction mergeConfig(c1, c2) {\n    if (!c2) {\n        return c1;\n    }\n    return __assign(__assign(__assign({}, (c1 || {})), (c2 || {})), Object.keys(c1).reduce(function (all, k) {\n        all[k] = __assign(__assign({}, c1[k]), (c2[k] || {}));\n        return all;\n    }, {}));\n}\nfunction mergeConfigs(defaultConfig, configs) {\n    if (!configs) {\n        return defaultConfig;\n    }\n    return Object.keys(defaultConfig).reduce(function (all, k) {\n        all[k] = mergeConfig(defaultConfig[k], configs[k]);\n        return all;\n    }, __assign({}, defaultConfig));\n}\nfunction createFastMemoizeCache(store) {\n    return {\n        create: function () {\n            return {\n                get: function (key) {\n                    return store[key];\n                },\n                set: function (key, value) {\n                    store[key] = value;\n                },\n            };\n        },\n    };\n}\nfunction createDefaultFormatters(cache) {\n    if (cache === void 0) { cache = {\n        number: {},\n        dateTime: {},\n        pluralRules: {},\n    }; }\n    return {\n        getNumberFormat: memoize(function () {\n            var _a;\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return new ((_a = Intl.NumberFormat).bind.apply(_a, __spreadArray([void 0], args, false)))();\n        }, {\n            cache: createFastMemoizeCache(cache.number),\n            strategy: strategies.variadic,\n        }),\n        getDateTimeFormat: memoize(function () {\n            var _a;\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return new ((_a = Intl.DateTimeFormat).bind.apply(_a, __spreadArray([void 0], args, false)))();\n        }, {\n            cache: createFastMemoizeCache(cache.dateTime),\n            strategy: strategies.variadic,\n        }),\n        getPluralRules: memoize(function () {\n            var _a;\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return new ((_a = Intl.PluralRules).bind.apply(_a, __spreadArray([void 0], args, false)))();\n        }, {\n            cache: createFastMemoizeCache(cache.pluralRules),\n            strategy: strategies.variadic,\n        }),\n    };\n}\nvar IntlMessageFormat = /** @class */ (function () {\n    function IntlMessageFormat(message, locales, overrideFormats, opts) {\n        var _this = this;\n        if (locales === void 0) { locales = IntlMessageFormat.defaultLocale; }\n        this.formatterCache = {\n            number: {},\n            dateTime: {},\n            pluralRules: {},\n        };\n        this.format = function (values) {\n            var parts = _this.formatToParts(values);\n            // Hot path for straight simple msg translations\n            if (parts.length === 1) {\n                return parts[0].value;\n            }\n            var result = parts.reduce(function (all, part) {\n                if (!all.length ||\n                    part.type !== PART_TYPE.literal ||\n                    typeof all[all.length - 1] !== 'string') {\n                    all.push(part.value);\n                }\n                else {\n                    all[all.length - 1] += part.value;\n                }\n                return all;\n            }, []);\n            if (result.length <= 1) {\n                return result[0] || '';\n            }\n            return result;\n        };\n        this.formatToParts = function (values) {\n            return formatToParts(_this.ast, _this.locales, _this.formatters, _this.formats, values, undefined, _this.message);\n        };\n        this.resolvedOptions = function () { return ({\n            locale: _this.resolvedLocale.toString(),\n        }); };\n        this.getAst = function () { return _this.ast; };\n        // Defined first because it's used to build the format pattern.\n        this.locales = locales;\n        this.resolvedLocale = IntlMessageFormat.resolveLocale(locales);\n        if (typeof message === 'string') {\n            this.message = message;\n            if (!IntlMessageFormat.__parse) {\n                throw new TypeError('IntlMessageFormat.__parse must be set to process `message` of type `string`');\n            }\n            // Parse string messages into an AST.\n            this.ast = IntlMessageFormat.__parse(message, {\n                ignoreTag: opts === null || opts === void 0 ? void 0 : opts.ignoreTag,\n                locale: this.resolvedLocale,\n            });\n        }\n        else {\n            this.ast = message;\n        }\n        if (!Array.isArray(this.ast)) {\n            throw new TypeError('A message must be provided as a String or AST.');\n        }\n        // Creates a new object with the specified `formats` merged with the default\n        // formats.\n        this.formats = mergeConfigs(IntlMessageFormat.formats, overrideFormats);\n        this.formatters =\n            (opts && opts.formatters) || createDefaultFormatters(this.formatterCache);\n    }\n    Object.defineProperty(IntlMessageFormat, \"defaultLocale\", {\n        get: function () {\n            if (!IntlMessageFormat.memoizedDefaultLocale) {\n                IntlMessageFormat.memoizedDefaultLocale =\n                    new Intl.NumberFormat().resolvedOptions().locale;\n            }\n            return IntlMessageFormat.memoizedDefaultLocale;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    IntlMessageFormat.memoizedDefaultLocale = null;\n    IntlMessageFormat.resolveLocale = function (locales) {\n        var supportedLocales = Intl.NumberFormat.supportedLocalesOf(locales);\n        if (supportedLocales.length > 0) {\n            return new Intl.Locale(supportedLocales[0]);\n        }\n        return new Intl.Locale(typeof locales === 'string' ? locales : locales[0]);\n    };\n    IntlMessageFormat.__parse = parse;\n    // Default format options used as the prototype of the `formats` provided to the\n    // constructor. These are used when constructing the internal Intl.NumberFormat\n    // and Intl.DateTimeFormat instances.\n    IntlMessageFormat.formats = {\n        number: {\n            integer: {\n                maximumFractionDigits: 0,\n            },\n            currency: {\n                style: 'currency',\n            },\n            percent: {\n                style: 'percent',\n            },\n        },\n        date: {\n            short: {\n                month: 'numeric',\n                day: 'numeric',\n                year: '2-digit',\n            },\n            medium: {\n                month: 'short',\n                day: 'numeric',\n                year: 'numeric',\n            },\n            long: {\n                month: 'long',\n                day: 'numeric',\n                year: 'numeric',\n            },\n            full: {\n                weekday: 'long',\n                month: 'long',\n                day: 'numeric',\n                year: 'numeric',\n            },\n        },\n        time: {\n            short: {\n                hour: 'numeric',\n                minute: 'numeric',\n            },\n            medium: {\n                hour: 'numeric',\n                minute: 'numeric',\n                second: 'numeric',\n            },\n            long: {\n                hour: 'numeric',\n                minute: 'numeric',\n                second: 'numeric',\n                timeZoneName: 'short',\n            },\n            full: {\n                hour: 'numeric',\n                minute: 'numeric',\n                second: 'numeric',\n                timeZoneName: 'short',\n            },\n        },\n    };\n    return IntlMessageFormat;\n}());\nexport { IntlMessageFormat };\n","import { __extends } from \"tslib\";\nexport var ErrorCode;\n(function (ErrorCode) {\n    // When we have a placeholder but no value to format\n    ErrorCode[\"MISSING_VALUE\"] = \"MISSING_VALUE\";\n    // When value supplied is invalid\n    ErrorCode[\"INVALID_VALUE\"] = \"INVALID_VALUE\";\n    // When we need specific Intl API but it's not available\n    ErrorCode[\"MISSING_INTL_API\"] = \"MISSING_INTL_API\";\n})(ErrorCode || (ErrorCode = {}));\nvar FormatError = /** @class */ (function (_super) {\n    __extends(FormatError, _super);\n    function FormatError(msg, code, originalMessage) {\n        var _this = _super.call(this, msg) || this;\n        _this.code = code;\n        _this.originalMessage = originalMessage;\n        return _this;\n    }\n    FormatError.prototype.toString = function () {\n        return \"[formatjs Error: \".concat(this.code, \"] \").concat(this.message);\n    };\n    return FormatError;\n}(Error));\nexport { FormatError };\nvar InvalidValueError = /** @class */ (function (_super) {\n    __extends(InvalidValueError, _super);\n    function InvalidValueError(variableId, value, options, originalMessage) {\n        return _super.call(this, \"Invalid values for \\\"\".concat(variableId, \"\\\": \\\"\").concat(value, \"\\\". Options are \\\"\").concat(Object.keys(options).join('\", \"'), \"\\\"\"), ErrorCode.INVALID_VALUE, originalMessage) || this;\n    }\n    return InvalidValueError;\n}(FormatError));\nexport { InvalidValueError };\nvar InvalidValueTypeError = /** @class */ (function (_super) {\n    __extends(InvalidValueTypeError, _super);\n    function InvalidValueTypeError(value, type, originalMessage) {\n        return _super.call(this, \"Value for \\\"\".concat(value, \"\\\" must be of type \").concat(type), ErrorCode.INVALID_VALUE, originalMessage) || this;\n    }\n    return InvalidValueTypeError;\n}(FormatError));\nexport { InvalidValueTypeError };\nvar MissingValueError = /** @class */ (function (_super) {\n    __extends(MissingValueError, _super);\n    function MissingValueError(variableId, originalMessage) {\n        return _super.call(this, \"The intl string context variable \\\"\".concat(variableId, \"\\\" was not provided to the string \\\"\").concat(originalMessage, \"\\\"\"), ErrorCode.MISSING_VALUE, originalMessage) || this;\n    }\n    return MissingValueError;\n}(FormatError));\nexport { MissingValueError };\n","import { isArgumentElement, isDateElement, isDateTimeSkeleton, isLiteralElement, isNumberElement, isNumberSkeleton, isPluralElement, isPoundElement, isSelectElement, isTimeElement, isTagElement, } from '@formatjs/icu-messageformat-parser';\nimport { MissingValueError, InvalidValueError, ErrorCode, FormatError, InvalidValueTypeError, } from './error';\nexport var PART_TYPE;\n(function (PART_TYPE) {\n    PART_TYPE[PART_TYPE[\"literal\"] = 0] = \"literal\";\n    PART_TYPE[PART_TYPE[\"object\"] = 1] = \"object\";\n})(PART_TYPE || (PART_TYPE = {}));\nfunction mergeLiteral(parts) {\n    if (parts.length < 2) {\n        return parts;\n    }\n    return parts.reduce(function (all, part) {\n        var lastPart = all[all.length - 1];\n        if (!lastPart ||\n            lastPart.type !== PART_TYPE.literal ||\n            part.type !== PART_TYPE.literal) {\n            all.push(part);\n        }\n        else {\n            lastPart.value += part.value;\n        }\n        return all;\n    }, []);\n}\nexport function isFormatXMLElementFn(el) {\n    return typeof el === 'function';\n}\n// TODO(skeleton): add skeleton support\nexport function formatToParts(els, locales, formatters, formats, values, currentPluralValue, \n// For debugging\noriginalMessage) {\n    // Hot path for straight simple msg translations\n    if (els.length === 1 && isLiteralElement(els[0])) {\n        return [\n            {\n                type: PART_TYPE.literal,\n                value: els[0].value,\n            },\n        ];\n    }\n    var result = [];\n    for (var _i = 0, els_1 = els; _i < els_1.length; _i++) {\n        var el = els_1[_i];\n        // Exit early for string parts.\n        if (isLiteralElement(el)) {\n            result.push({\n                type: PART_TYPE.literal,\n                value: el.value,\n            });\n            continue;\n        }\n        // TODO: should this part be literal type?\n        // Replace `#` in plural rules with the actual numeric value.\n        if (isPoundElement(el)) {\n            if (typeof currentPluralValue === 'number') {\n                result.push({\n                    type: PART_TYPE.literal,\n                    value: formatters.getNumberFormat(locales).format(currentPluralValue),\n                });\n            }\n            continue;\n        }\n        var varName = el.value;\n        // Enforce that all required values are provided by the caller.\n        if (!(values && varName in values)) {\n            throw new MissingValueError(varName, originalMessage);\n        }\n        var value = values[varName];\n        if (isArgumentElement(el)) {\n            if (!value || typeof value === 'string' || typeof value === 'number') {\n                value =\n                    typeof value === 'string' || typeof value === 'number'\n                        ? String(value)\n                        : '';\n            }\n            result.push({\n                type: typeof value === 'string' ? PART_TYPE.literal : PART_TYPE.object,\n                value: value,\n            });\n            continue;\n        }\n        // Recursively format plural and select parts' option — which can be a\n        // nested pattern structure. The choosing of the option to use is\n        // abstracted-by and delegated-to the part helper object.\n        if (isDateElement(el)) {\n            var style = typeof el.style === 'string'\n                ? formats.date[el.style]\n                : isDateTimeSkeleton(el.style)\n                    ? el.style.parsedOptions\n                    : undefined;\n            result.push({\n                type: PART_TYPE.literal,\n                value: formatters\n                    .getDateTimeFormat(locales, style)\n                    .format(value),\n            });\n            continue;\n        }\n        if (isTimeElement(el)) {\n            var style = typeof el.style === 'string'\n                ? formats.time[el.style]\n                : isDateTimeSkeleton(el.style)\n                    ? el.style.parsedOptions\n                    : formats.time.medium;\n            result.push({\n                type: PART_TYPE.literal,\n                value: formatters\n                    .getDateTimeFormat(locales, style)\n                    .format(value),\n            });\n            continue;\n        }\n        if (isNumberElement(el)) {\n            var style = typeof el.style === 'string'\n                ? formats.number[el.style]\n                : isNumberSkeleton(el.style)\n                    ? el.style.parsedOptions\n                    : undefined;\n            if (style && style.scale) {\n                value =\n                    value *\n                        (style.scale || 1);\n            }\n            result.push({\n                type: PART_TYPE.literal,\n                value: formatters\n                    .getNumberFormat(locales, style)\n                    .format(value),\n            });\n            continue;\n        }\n        if (isTagElement(el)) {\n            var children = el.children, value_1 = el.value;\n            var formatFn = values[value_1];\n            if (!isFormatXMLElementFn(formatFn)) {\n                throw new InvalidValueTypeError(value_1, 'function', originalMessage);\n            }\n            var parts = formatToParts(children, locales, formatters, formats, values, currentPluralValue);\n            var chunks = formatFn(parts.map(function (p) { return p.value; }));\n            if (!Array.isArray(chunks)) {\n                chunks = [chunks];\n            }\n            result.push.apply(result, chunks.map(function (c) {\n                return {\n                    type: typeof c === 'string' ? PART_TYPE.literal : PART_TYPE.object,\n                    value: c,\n                };\n            }));\n        }\n        if (isSelectElement(el)) {\n            var opt = el.options[value] || el.options.other;\n            if (!opt) {\n                throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);\n            }\n            result.push.apply(result, formatToParts(opt.value, locales, formatters, formats, values));\n            continue;\n        }\n        if (isPluralElement(el)) {\n            var opt = el.options[\"=\".concat(value)];\n            if (!opt) {\n                if (!Intl.PluralRules) {\n                    throw new FormatError(\"Intl.PluralRules is not available in this environment.\\nTry polyfilling it using \\\"@formatjs/intl-pluralrules\\\"\\n\", ErrorCode.MISSING_INTL_API, originalMessage);\n                }\n                var rule = formatters\n                    .getPluralRules(locales, { type: el.pluralType })\n                    .select(value - (el.offset || 0));\n                opt = el.options[rule] || el.options.other;\n            }\n            if (!opt) {\n                throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);\n            }\n            result.push.apply(result, formatToParts(opt.value, locales, formatters, formats, values, value - (el.offset || 0)));\n            continue;\n        }\n    }\n    return mergeLiteral(result);\n}\n","\"use strict\";\n\nvar deselectCurrent = require(\"toggle-selection\");\n\nvar clipboardToIE11Formatting = {\n  \"text/plain\": \"Text\",\n  \"text/html\": \"Url\",\n  \"default\": \"Text\"\n}\n\nvar defaultMessage = \"Copy to clipboard: #{key}, Enter\";\n\nfunction format(message) {\n  var copyKey = (/mac os x/i.test(navigator.userAgent) ? \"⌘\" : \"Ctrl\") + \"+C\";\n  return message.replace(/#{\\s*key\\s*}/g, copyKey);\n}\n\nfunction copy(text, options) {\n  var debug,\n    message,\n    reselectPrevious,\n    range,\n    selection,\n    mark,\n    success = false;\n  if (!options) {\n    options = {};\n  }\n  debug = options.debug || false;\n  try {\n    reselectPrevious = deselectCurrent();\n\n    range = document.createRange();\n    selection = document.getSelection();\n\n    mark = document.createElement(\"span\");\n    mark.textContent = text;\n    // avoid screen readers from reading out loud the text\n    mark.ariaHidden = \"true\"\n    // reset user styles for span element\n    mark.style.all = \"unset\";\n    // prevents scrolling to the end of the page\n    mark.style.position = \"fixed\";\n    mark.style.top = 0;\n    mark.style.clip = \"rect(0, 0, 0, 0)\";\n    // used to preserve spaces and line breaks\n    mark.style.whiteSpace = \"pre\";\n    // do not inherit user-select (it may be `none`)\n    mark.style.webkitUserSelect = \"text\";\n    mark.style.MozUserSelect = \"text\";\n    mark.style.msUserSelect = \"text\";\n    mark.style.userSelect = \"text\";\n    mark.addEventListener(\"copy\", function(e) {\n      e.stopPropagation();\n      if (options.format) {\n        e.preventDefault();\n        if (typeof e.clipboardData === \"undefined\") { // IE 11\n          debug && console.warn(\"unable to use e.clipboardData\");\n          debug && console.warn(\"trying IE specific stuff\");\n          window.clipboardData.clearData();\n          var format = clipboardToIE11Formatting[options.format] || clipboardToIE11Formatting[\"default\"]\n          window.clipboardData.setData(format, text);\n        } else { // all other browsers\n          e.clipboardData.clearData();\n          e.clipboardData.setData(options.format, text);\n        }\n      }\n      if (options.onCopy) {\n        e.preventDefault();\n        options.onCopy(e.clipboardData);\n      }\n    });\n\n    document.body.appendChild(mark);\n\n    range.selectNodeContents(mark);\n    selection.addRange(range);\n\n    var successful = document.execCommand(\"copy\");\n    if (!successful) {\n      throw new Error(\"copy command was unsuccessful\");\n    }\n    success = true;\n  } catch (err) {\n    debug && console.error(\"unable to copy using execCommand: \", err);\n    debug && console.warn(\"trying IE specific stuff\");\n    try {\n      window.clipboardData.setData(options.format || \"text\", text);\n      options.onCopy && options.onCopy(window.clipboardData);\n      success = true;\n    } catch (err) {\n      debug && console.error(\"unable to copy using clipboardData: \", err);\n      debug && console.error(\"falling back to prompt\");\n      message = format(\"message\" in options ? options.message : defaultMessage);\n      window.prompt(message, text);\n    }\n  } finally {\n    if (selection) {\n      if (typeof selection.removeRange == \"function\") {\n        selection.removeRange(range);\n      } else {\n        selection.removeAllRanges();\n      }\n    }\n\n    if (mark) {\n      document.body.removeChild(mark);\n    }\n    reselectPrevious();\n  }\n\n  return success;\n}\n\nmodule.exports = copy;\n","var isMergeableObject = function isMergeableObject(value) {\n\treturn isNonNullObject(value)\n\t\t&& !isSpecial(value)\n};\n\nfunction isNonNullObject(value) {\n\treturn !!value && typeof value === 'object'\n}\n\nfunction isSpecial(value) {\n\tvar stringValue = Object.prototype.toString.call(value);\n\n\treturn stringValue === '[object RegExp]'\n\t\t|| stringValue === '[object Date]'\n\t\t|| isReactElement(value)\n}\n\n// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25\nvar canUseSymbol = typeof Symbol === 'function' && Symbol.for;\nvar REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;\n\nfunction isReactElement(value) {\n\treturn value.$$typeof === REACT_ELEMENT_TYPE\n}\n\nfunction emptyTarget(val) {\n\treturn Array.isArray(val) ? [] : {}\n}\n\nfunction cloneUnlessOtherwiseSpecified(value, options) {\n\treturn (options.clone !== false && options.isMergeableObject(value))\n\t\t? deepmerge(emptyTarget(value), value, options)\n\t\t: value\n}\n\nfunction defaultArrayMerge(target, source, options) {\n\treturn target.concat(source).map(function(element) {\n\t\treturn cloneUnlessOtherwiseSpecified(element, options)\n\t})\n}\n\nfunction mergeObject(target, source, options) {\n\tvar destination = {};\n\tif (options.isMergeableObject(target)) {\n\t\tObject.keys(target).forEach(function(key) {\n\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(target[key], options);\n\t\t});\n\t}\n\tObject.keys(source).forEach(function(key) {\n\t\tif (!options.isMergeableObject(source[key]) || !target[key]) {\n\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(source[key], options);\n\t\t} else {\n\t\t\tdestination[key] = deepmerge(target[key], source[key], options);\n\t\t}\n\t});\n\treturn destination\n}\n\nfunction deepmerge(target, source, options) {\n\toptions = options || {};\n\toptions.arrayMerge = options.arrayMerge || defaultArrayMerge;\n\toptions.isMergeableObject = options.isMergeableObject || isMergeableObject;\n\n\tvar sourceIsArray = Array.isArray(source);\n\tvar targetIsArray = Array.isArray(target);\n\tvar sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;\n\n\tif (!sourceAndTargetTypesMatch) {\n\t\treturn cloneUnlessOtherwiseSpecified(source, options)\n\t} else if (sourceIsArray) {\n\t\treturn options.arrayMerge(target, source, options)\n\t} else {\n\t\treturn mergeObject(target, source, options)\n\t}\n}\n\ndeepmerge.all = function deepmergeAll(array, options) {\n\tif (!Array.isArray(array)) {\n\t\tthrow new Error('first argument should be an array')\n\t}\n\n\treturn array.reduce(function(prev, next) {\n\t\treturn deepmerge(prev, next, options)\n\t}, {})\n};\n\nvar deepmerge_1 = deepmerge;\n\nexport default deepmerge_1;\n","import * as React from 'react';\nimport { FormikContextType } from './types';\nimport invariant from 'tiny-warning';\n\nexport const FormikContext = React.createContext<FormikContextType<any>>(\n  undefined as any\n);\nFormikContext.displayName = 'FormikContext';\n\nexport const FormikProvider = FormikContext.Provider;\nexport const FormikConsumer = FormikContext.Consumer;\n\nexport function useFormikContext<Values>() {\n  const formik = React.useContext<FormikContextType<Values>>(FormikContext);\n\n  invariant(\n    !!formik,\n    `Formik context is undefined, please verify you are calling useFormikContext() as child of a <Formik> component.`\n  );\n\n  return formik;\n}\n","import clone from 'lodash/clone';\nimport toPath from 'lodash/toPath';\nimport * as React from 'react';\n\n// Assertions\n\n/** @private is the value an empty array? */\nexport const isEmptyArray = (value?: any) =>\n  Array.isArray(value) && value.length === 0;\n\n/** @private is the given object a Function? */\nexport const isFunction = (obj: any): obj is Function =>\n  typeof obj === 'function';\n\n/** @private is the given object an Object? */\nexport const isObject = (obj: any): obj is Object =>\n  obj !== null && typeof obj === 'object';\n\n/** @private is the given object an integer? */\nexport const isInteger = (obj: any): boolean =>\n  String(Math.floor(Number(obj))) === obj;\n\n/** @private is the given object a string? */\nexport const isString = (obj: any): obj is string =>\n  Object.prototype.toString.call(obj) === '[object String]';\n\n/** @private is the given object a NaN? */\n// eslint-disable-next-line no-self-compare\nexport const isNaN = (obj: any): boolean => obj !== obj;\n\n/** @private Does a React component have exactly 0 children? */\nexport const isEmptyChildren = (children: any): boolean =>\n  React.Children.count(children) === 0;\n\n/** @private is the given object/value a promise? */\nexport const isPromise = (value: any): value is PromiseLike<any> =>\n  isObject(value) && isFunction(value.then);\n\n/** @private is the given object/value a type of synthetic event? */\nexport const isInputEvent = (value: any): value is React.SyntheticEvent<any> =>\n  value && isObject(value) && isObject(value.target);\n\n/**\n * Same as document.activeElement but wraps in a try-catch block. In IE it is\n * not safe to call document.activeElement if there is nothing focused.\n *\n * The activeElement will be null only if the document or document body is not\n * yet defined.\n *\n * @param {?Document} doc Defaults to current document.\n * @return {Element | null}\n * @see https://github.com/facebook/fbjs/blob/master/packages/fbjs/src/core/dom/getActiveElement.js\n */\nexport function getActiveElement(doc?: Document): Element | null {\n  doc = doc || (typeof document !== 'undefined' ? document : undefined);\n  if (typeof doc === 'undefined') {\n    return null;\n  }\n  try {\n    return doc.activeElement || doc.body;\n  } catch (e) {\n    return doc.body;\n  }\n}\n\n/**\n * Deeply get a value from an object via its path.\n */\nexport function getIn(\n  obj: any,\n  key: string | string[],\n  def?: any,\n  p: number = 0\n) {\n  const path = toPath(key);\n  while (obj && p < path.length) {\n    obj = obj[path[p++]];\n  }\n\n  // check if path is not in the end\n  if (p !== path.length && !obj) {\n    return def;\n  }\n\n  return obj === undefined ? def : obj;\n}\n\n/**\n * Deeply set a value from in object via it's path. If the value at `path`\n * has changed, return a shallow copy of obj with `value` set at `path`.\n * If `value` has not changed, return the original `obj`.\n *\n * Existing objects / arrays along `path` are also shallow copied. Sibling\n * objects along path retain the same internal js reference. Since new\n * objects / arrays are only created along `path`, we can test if anything\n * changed in a nested structure by comparing the object's reference in\n * the old and new object, similar to how russian doll cache invalidation\n * works.\n *\n * In earlier versions of this function, which used cloneDeep, there were\n * issues whereby settings a nested value would mutate the parent\n * instead of creating a new object. `clone` avoids that bug making a\n * shallow copy of the objects along the update path\n * so no object is mutated in place.\n *\n * Before changing this function, please read through the following\n * discussions.\n *\n * @see https://github.com/developit/linkstate\n * @see https://github.com/jaredpalmer/formik/pull/123\n */\nexport function setIn(obj: any, path: string, value: any): any {\n  let res: any = clone(obj); // this keeps inheritance when obj is a class\n  let resVal: any = res;\n  let i = 0;\n  let pathArray = toPath(path);\n\n  for (; i < pathArray.length - 1; i++) {\n    const currentPath: string = pathArray[i];\n    let currentObj: any = getIn(obj, pathArray.slice(0, i + 1));\n\n    if (currentObj && (isObject(currentObj) || Array.isArray(currentObj))) {\n      resVal = resVal[currentPath] = clone(currentObj);\n    } else {\n      const nextPath: string = pathArray[i + 1];\n      resVal = resVal[currentPath] =\n        isInteger(nextPath) && Number(nextPath) >= 0 ? [] : {};\n    }\n  }\n\n  // Return original object if new value is the same as current\n  if ((i === 0 ? obj : resVal)[pathArray[i]] === value) {\n    return obj;\n  }\n\n  if (value === undefined) {\n    delete resVal[pathArray[i]];\n  } else {\n    resVal[pathArray[i]] = value;\n  }\n\n  // If the path array has a single element, the loop did not run.\n  // Deleting on `resVal` had no effect in this scenario, so we delete on the result instead.\n  if (i === 0 && value === undefined) {\n    delete res[pathArray[i]];\n  }\n\n  return res;\n}\n\n/**\n * Recursively a set the same value for all keys and arrays nested object, cloning\n * @param object\n * @param value\n * @param visited\n * @param response\n */\nexport function setNestedObjectValues<T>(\n  object: any,\n  value: any,\n  visited: any = new WeakMap(),\n  response: any = {}\n): T {\n  for (let k of Object.keys(object)) {\n    const val = object[k];\n    if (isObject(val)) {\n      if (!visited.get(val)) {\n        visited.set(val, true);\n        // In order to keep array values consistent for both dot path  and\n        // bracket syntax, we need to check if this is an array so that\n        // this will output  { friends: [true] } and not { friends: { \"0\": true } }\n        response[k] = Array.isArray(val) ? [] : {};\n        setNestedObjectValues(val, value, visited, response[k]);\n      }\n    } else {\n      response[k] = value;\n    }\n  }\n\n  return response;\n}\n","import deepmerge from 'deepmerge';\nimport isPlainObject from 'lodash/isPlainObject';\nimport * as React from 'react';\nimport isEqual from 'react-fast-compare';\nimport invariant from 'tiny-warning';\nimport { FieldConfig } from './Field';\nimport { FormikProvider } from './FormikContext';\nimport {\n  FieldHelperProps,\n  FieldInputProps,\n  FieldMetaProps,\n  FormikConfig,\n  FormikErrors,\n  FormikHandlers,\n  FormikHelpers,\n  FormikProps,\n  FormikState,\n  FormikTouched,\n  FormikValues,\n} from './types';\nimport {\n  getActiveElement,\n  getIn,\n  isEmptyChildren,\n  isFunction,\n  isObject,\n  isPromise,\n  isString,\n  setIn,\n  setNestedObjectValues,\n} from './utils';\n\ntype FormikMessage<Values> =\n  | { type: 'SUBMIT_ATTEMPT' }\n  | { type: 'SUBMIT_FAILURE' }\n  | { type: 'SUBMIT_SUCCESS' }\n  | { type: 'SET_ISVALIDATING'; payload: boolean }\n  | { type: 'SET_ISSUBMITTING'; payload: boolean }\n  | { type: 'SET_VALUES'; payload: Values }\n  | { type: 'SET_FIELD_VALUE'; payload: { field: string; value?: any } }\n  | { type: 'SET_FIELD_TOUCHED'; payload: { field: string; value?: boolean } }\n  | { type: 'SET_FIELD_ERROR'; payload: { field: string; value?: string } }\n  | { type: 'SET_TOUCHED'; payload: FormikTouched<Values> }\n  | { type: 'SET_ERRORS'; payload: FormikErrors<Values> }\n  | { type: 'SET_STATUS'; payload: any }\n  | {\n      type: 'SET_FORMIK_STATE';\n      payload: (s: FormikState<Values>) => FormikState<Values>;\n    }\n  | {\n      type: 'RESET_FORM';\n      payload: FormikState<Values>;\n    };\n\n// State reducer\nfunction formikReducer<Values>(\n  state: FormikState<Values>,\n  msg: FormikMessage<Values>\n) {\n  switch (msg.type) {\n    case 'SET_VALUES':\n      return { ...state, values: msg.payload };\n    case 'SET_TOUCHED':\n      return { ...state, touched: msg.payload };\n    case 'SET_ERRORS':\n      if (isEqual(state.errors, msg.payload)) {\n        return state;\n      }\n\n      return { ...state, errors: msg.payload };\n    case 'SET_STATUS':\n      return { ...state, status: msg.payload };\n    case 'SET_ISSUBMITTING':\n      return { ...state, isSubmitting: msg.payload };\n    case 'SET_ISVALIDATING':\n      return { ...state, isValidating: msg.payload };\n    case 'SET_FIELD_VALUE':\n      return {\n        ...state,\n        values: setIn(state.values, msg.payload.field, msg.payload.value),\n      };\n    case 'SET_FIELD_TOUCHED':\n      return {\n        ...state,\n        touched: setIn(state.touched, msg.payload.field, msg.payload.value),\n      };\n    case 'SET_FIELD_ERROR':\n      return {\n        ...state,\n        errors: setIn(state.errors, msg.payload.field, msg.payload.value),\n      };\n    case 'RESET_FORM':\n      return { ...state, ...msg.payload };\n    case 'SET_FORMIK_STATE':\n      return msg.payload(state);\n    case 'SUBMIT_ATTEMPT':\n      return {\n        ...state,\n        touched: setNestedObjectValues<FormikTouched<Values>>(\n          state.values,\n          true\n        ),\n        isSubmitting: true,\n        submitCount: state.submitCount + 1,\n      };\n    case 'SUBMIT_FAILURE':\n      return {\n        ...state,\n        isSubmitting: false,\n      };\n    case 'SUBMIT_SUCCESS':\n      return {\n        ...state,\n        isSubmitting: false,\n      };\n    default:\n      return state;\n  }\n}\n\n// Initial empty states // objects\nconst emptyErrors: FormikErrors<unknown> = {};\nconst emptyTouched: FormikTouched<unknown> = {};\n\n// This is an object that contains a map of all registered fields\n// and their validate functions\ninterface FieldRegistry {\n  [field: string]: {\n    validate: (value: any) => string | Promise<string> | undefined;\n  };\n}\n\nexport function useFormik<Values extends FormikValues = FormikValues>({\n  validateOnChange = true,\n  validateOnBlur = true,\n  validateOnMount = false,\n  isInitialValid,\n  enableReinitialize = false,\n  onSubmit,\n  ...rest\n}: FormikConfig<Values>) {\n  const props = {\n    validateOnChange,\n    validateOnBlur,\n    validateOnMount,\n    onSubmit,\n    ...rest,\n  };\n  const initialValues = React.useRef(props.initialValues);\n  const initialErrors = React.useRef(props.initialErrors || emptyErrors);\n  const initialTouched = React.useRef(props.initialTouched || emptyTouched);\n  const initialStatus = React.useRef(props.initialStatus);\n  const isMounted = React.useRef<boolean>(false);\n  const fieldRegistry = React.useRef<FieldRegistry>({});\n  if (__DEV__) {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useEffect(() => {\n      invariant(\n        typeof isInitialValid === 'undefined',\n        'isInitialValid has been deprecated and will be removed in future versions of Formik. Please use initialErrors or validateOnMount instead.'\n      );\n      // eslint-disable-next-line\n    }, []);\n  }\n\n  React.useEffect(() => {\n    isMounted.current = true;\n\n    return () => {\n      isMounted.current = false;\n    };\n  }, []);\n\n  const [, setIteration] = React.useState(0);\n  const stateRef = React.useRef<FormikState<Values>>({\n    values: props.initialValues,\n    errors: props.initialErrors || emptyErrors,\n    touched: props.initialTouched || emptyTouched,\n    status: props.initialStatus,\n    isSubmitting: false,\n    isValidating: false,\n    submitCount: 0,\n  });\n\n  const state = stateRef.current;\n\n  const dispatch = React.useCallback((action: FormikMessage<Values>) => {\n    const prev = stateRef.current;\n\n    stateRef.current = formikReducer(prev, action);\n\n    // force rerender\n    if (prev !== stateRef.current) setIteration(x => x + 1);\n  }, []);\n\n  const runValidateHandler = React.useCallback(\n    (values: Values, field?: string): Promise<FormikErrors<Values>> => {\n      return new Promise((resolve, reject) => {\n        const maybePromisedErrors = (props.validate as any)(values, field);\n        if (maybePromisedErrors == null) {\n          // use loose null check here on purpose\n          resolve(emptyErrors);\n        } else if (isPromise(maybePromisedErrors)) {\n          (maybePromisedErrors as Promise<any>).then(\n            errors => {\n              resolve(errors || emptyErrors);\n            },\n            actualException => {\n              if (process.env.NODE_ENV !== 'production') {\n                console.warn(\n                  `Warning: An unhandled error was caught during validation in <Formik validate />`,\n                  actualException\n                );\n              }\n\n              reject(actualException);\n            }\n          );\n        } else {\n          resolve(maybePromisedErrors);\n        }\n      });\n    },\n    [props.validate]\n  );\n\n  /**\n   * Run validation against a Yup schema and optionally run a function if successful\n   */\n  const runValidationSchema = React.useCallback(\n    (values: Values, field?: string): Promise<FormikErrors<Values>> => {\n      const validationSchema = props.validationSchema;\n      const schema = isFunction(validationSchema)\n        ? validationSchema(field)\n        : validationSchema;\n      const promise =\n        field && schema.validateAt\n          ? schema.validateAt(field, values)\n          : validateYupSchema(values, schema);\n      return new Promise((resolve, reject) => {\n        promise.then(\n          () => {\n            resolve(emptyErrors);\n          },\n          (err: any) => {\n            // Yup will throw a validation error if validation fails. We catch those and\n            // resolve them into Formik errors. We can sniff if something is a Yup error\n            // by checking error.name.\n            // @see https://github.com/jquense/yup#validationerrorerrors-string--arraystring-value-any-path-string\n            if (err.name === 'ValidationError') {\n              resolve(yupToFormErrors(err));\n            } else {\n              // We throw any other errors\n              if (process.env.NODE_ENV !== 'production') {\n                console.warn(\n                  `Warning: An unhandled error was caught during validation in <Formik validationSchema />`,\n                  err\n                );\n              }\n\n              reject(err);\n            }\n          }\n        );\n      });\n    },\n    [props.validationSchema]\n  );\n\n  const runSingleFieldLevelValidation = React.useCallback(\n    (field: string, value: void | string): Promise<string> => {\n      return new Promise(resolve =>\n        resolve(fieldRegistry.current[field].validate(value) as string)\n      );\n    },\n    []\n  );\n\n  const runFieldLevelValidations = React.useCallback(\n    (values: Values): Promise<FormikErrors<Values>> => {\n      const fieldKeysWithValidation: string[] = Object.keys(\n        fieldRegistry.current\n      ).filter(f => isFunction(fieldRegistry.current[f].validate));\n\n      // Construct an array with all of the field validation functions\n      const fieldValidations: Promise<string>[] =\n        fieldKeysWithValidation.length > 0\n          ? fieldKeysWithValidation.map(f =>\n              runSingleFieldLevelValidation(f, getIn(values, f))\n            )\n          : [Promise.resolve('DO_NOT_DELETE_YOU_WILL_BE_FIRED')]; // use special case ;)\n\n      return Promise.all(fieldValidations).then((fieldErrorsList: string[]) =>\n        fieldErrorsList.reduce((prev, curr, index) => {\n          if (curr === 'DO_NOT_DELETE_YOU_WILL_BE_FIRED') {\n            return prev;\n          }\n          if (curr) {\n            prev = setIn(prev, fieldKeysWithValidation[index], curr);\n          }\n          return prev;\n        }, {})\n      );\n    },\n    [runSingleFieldLevelValidation]\n  );\n\n  // Run all validations and return the result\n  const runAllValidations = React.useCallback(\n    (values: Values) => {\n      return Promise.all([\n        runFieldLevelValidations(values),\n        props.validationSchema ? runValidationSchema(values) : {},\n        props.validate ? runValidateHandler(values) : {},\n      ]).then(([fieldErrors, schemaErrors, validateErrors]) => {\n        const combinedErrors = deepmerge.all<FormikErrors<Values>>(\n          [fieldErrors, schemaErrors, validateErrors],\n          { arrayMerge }\n        );\n        return combinedErrors;\n      });\n    },\n    [\n      props.validate,\n      props.validationSchema,\n      runFieldLevelValidations,\n      runValidateHandler,\n      runValidationSchema,\n    ]\n  );\n\n  // Run all validations methods and update state accordingly\n  const validateFormWithHighPriority = useEventCallback(\n    (values: Values = state.values) => {\n      dispatch({ type: 'SET_ISVALIDATING', payload: true });\n      return runAllValidations(values).then(combinedErrors => {\n        if (!!isMounted.current) {\n          dispatch({ type: 'SET_ISVALIDATING', payload: false });\n          dispatch({ type: 'SET_ERRORS', payload: combinedErrors });\n        }\n        return combinedErrors;\n      });\n    }\n  );\n\n  React.useEffect(() => {\n    if (\n      validateOnMount &&\n      isMounted.current === true &&\n      isEqual(initialValues.current, props.initialValues)\n    ) {\n      validateFormWithHighPriority(initialValues.current);\n    }\n  }, [validateOnMount, validateFormWithHighPriority]);\n\n  const resetForm = React.useCallback(\n    (nextState?: Partial<FormikState<Values>>) => {\n      const values =\n        nextState && nextState.values\n          ? nextState.values\n          : initialValues.current;\n      const errors =\n        nextState && nextState.errors\n          ? nextState.errors\n          : initialErrors.current\n          ? initialErrors.current\n          : props.initialErrors || {};\n      const touched =\n        nextState && nextState.touched\n          ? nextState.touched\n          : initialTouched.current\n          ? initialTouched.current\n          : props.initialTouched || {};\n      const status =\n        nextState && nextState.status\n          ? nextState.status\n          : initialStatus.current\n          ? initialStatus.current\n          : props.initialStatus;\n      initialValues.current = values;\n      initialErrors.current = errors;\n      initialTouched.current = touched;\n      initialStatus.current = status;\n\n      const dispatchFn = () => {\n        dispatch({\n          type: 'RESET_FORM',\n          payload: {\n            isSubmitting: !!nextState && !!nextState.isSubmitting,\n            errors,\n            touched,\n            status,\n            values,\n            isValidating: !!nextState && !!nextState.isValidating,\n            submitCount:\n              !!nextState &&\n              !!nextState.submitCount &&\n              typeof nextState.submitCount === 'number'\n                ? nextState.submitCount\n                : 0,\n          },\n        });\n      };\n\n      if (props.onReset) {\n        const maybePromisedOnReset = (props.onReset as any)(\n          state.values,\n          imperativeMethods\n        );\n\n        if (isPromise(maybePromisedOnReset)) {\n          (maybePromisedOnReset as Promise<any>).then(dispatchFn);\n        } else {\n          dispatchFn();\n        }\n      } else {\n        dispatchFn();\n      }\n    },\n    [props.initialErrors, props.initialStatus, props.initialTouched, props.onReset]\n  );\n\n  React.useEffect(() => {\n    if (\n      isMounted.current === true &&\n      !isEqual(initialValues.current, props.initialValues)\n    ) {\n      if (enableReinitialize) {\n        initialValues.current = props.initialValues;\n        resetForm();\n        if (validateOnMount) {\n          validateFormWithHighPriority(initialValues.current);\n        }\n      }\n    }\n  }, [\n    enableReinitialize,\n    props.initialValues,\n    resetForm,\n    validateOnMount,\n    validateFormWithHighPriority,\n  ]);\n\n  React.useEffect(() => {\n    if (\n      enableReinitialize &&\n      isMounted.current === true &&\n      !isEqual(initialErrors.current, props.initialErrors)\n    ) {\n      initialErrors.current = props.initialErrors || emptyErrors;\n      dispatch({\n        type: 'SET_ERRORS',\n        payload: props.initialErrors || emptyErrors,\n      });\n    }\n  }, [enableReinitialize, props.initialErrors]);\n\n  React.useEffect(() => {\n    if (\n      enableReinitialize &&\n      isMounted.current === true &&\n      !isEqual(initialTouched.current, props.initialTouched)\n    ) {\n      initialTouched.current = props.initialTouched || emptyTouched;\n      dispatch({\n        type: 'SET_TOUCHED',\n        payload: props.initialTouched || emptyTouched,\n      });\n    }\n  }, [enableReinitialize, props.initialTouched]);\n\n  React.useEffect(() => {\n    if (\n      enableReinitialize &&\n      isMounted.current === true &&\n      !isEqual(initialStatus.current, props.initialStatus)\n    ) {\n      initialStatus.current = props.initialStatus;\n      dispatch({\n        type: 'SET_STATUS',\n        payload: props.initialStatus,\n      });\n    }\n  }, [enableReinitialize, props.initialStatus, props.initialTouched]);\n\n  const validateField = useEventCallback((name: string) => {\n    // This will efficiently validate a single field by avoiding state\n    // changes if the validation function is synchronous. It's different from\n    // what is called when using validateForm.\n\n    if (\n      fieldRegistry.current[name] &&\n      isFunction(fieldRegistry.current[name].validate)\n    ) {\n      const value = getIn(state.values, name);\n      const maybePromise = fieldRegistry.current[name].validate(value);\n      if (isPromise(maybePromise)) {\n        // Only flip isValidating if the function is async.\n        dispatch({ type: 'SET_ISVALIDATING', payload: true });\n        return maybePromise\n          .then((x: any) => x)\n          .then((error: string) => {\n            dispatch({\n              type: 'SET_FIELD_ERROR',\n              payload: { field: name, value: error },\n            });\n            dispatch({ type: 'SET_ISVALIDATING', payload: false });\n          });\n      } else {\n        dispatch({\n          type: 'SET_FIELD_ERROR',\n          payload: {\n            field: name,\n            value: maybePromise as string | undefined,\n          },\n        });\n        return Promise.resolve(maybePromise as string | undefined);\n      }\n    } else if (props.validationSchema) {\n      dispatch({ type: 'SET_ISVALIDATING', payload: true });\n      return runValidationSchema(state.values, name)\n        .then((x: any) => x)\n        .then((error: any) => {\n          dispatch({\n            type: 'SET_FIELD_ERROR',\n            payload: { field: name, value: getIn(error, name) },\n          });\n          dispatch({ type: 'SET_ISVALIDATING', payload: false });\n        });\n    }\n\n    return Promise.resolve();\n  });\n\n  const registerField = React.useCallback((name: string, { validate }: any) => {\n    fieldRegistry.current[name] = {\n      validate,\n    };\n  }, []);\n\n  const unregisterField = React.useCallback((name: string) => {\n    delete fieldRegistry.current[name];\n  }, []);\n\n  const setTouched = useEventCallback(\n    (touched: FormikTouched<Values>, shouldValidate?: boolean) => {\n      dispatch({ type: 'SET_TOUCHED', payload: touched });\n      const willValidate =\n        shouldValidate === undefined ? validateOnBlur : shouldValidate;\n      return willValidate\n        ? validateFormWithHighPriority(state.values)\n        : Promise.resolve();\n    }\n  );\n\n  const setErrors = React.useCallback((errors: FormikErrors<Values>) => {\n    dispatch({ type: 'SET_ERRORS', payload: errors });\n  }, []);\n\n  const setValues = useEventCallback(\n    (values: React.SetStateAction<Values>, shouldValidate?: boolean) => {\n      const resolvedValues = isFunction(values) ? values(state.values) : values;\n\n      dispatch({ type: 'SET_VALUES', payload: resolvedValues });\n      const willValidate =\n        shouldValidate === undefined ? validateOnChange : shouldValidate;\n      return willValidate\n        ? validateFormWithHighPriority(resolvedValues)\n        : Promise.resolve();\n    }\n  );\n\n  const setFieldError = React.useCallback(\n    (field: string, value: string | undefined) => {\n      dispatch({\n        type: 'SET_FIELD_ERROR',\n        payload: { field, value },\n      });\n    },\n    []\n  );\n\n  const setFieldValue = useEventCallback(\n    (field: string, value: any, shouldValidate?: boolean) => {\n      dispatch({\n        type: 'SET_FIELD_VALUE',\n        payload: {\n          field,\n          value,\n        },\n      });\n      const willValidate =\n        shouldValidate === undefined ? validateOnChange : shouldValidate;\n      return willValidate\n        ? validateFormWithHighPriority(setIn(state.values, field, value))\n        : Promise.resolve();\n    }\n  );\n\n  const executeChange = React.useCallback(\n    (eventOrTextValue: string | React.ChangeEvent<any>, maybePath?: string) => {\n      // By default, assume that the first argument is a string. This allows us to use\n      // handleChange with React Native and React Native Web's onChangeText prop which\n      // provides just the value of the input.\n      let field = maybePath;\n      let val = eventOrTextValue;\n      let parsed;\n      // If the first argument is not a string though, it has to be a synthetic React Event (or a fake one),\n      // so we handle like we would a normal HTML change event.\n      if (!isString(eventOrTextValue)) {\n        // If we can, persist the event\n        // @see https://reactjs.org/docs/events.html#event-pooling\n        if ((eventOrTextValue as any).persist) {\n          (eventOrTextValue as React.ChangeEvent<any>).persist();\n        }\n        const target = eventOrTextValue.target\n          ? (eventOrTextValue as React.ChangeEvent<any>).target\n          : (eventOrTextValue as React.ChangeEvent<any>).currentTarget;\n\n        const {\n          type,\n          name,\n          id,\n          value,\n          checked,\n          outerHTML,\n          options,\n          multiple,\n        } = target;\n\n        field = maybePath ? maybePath : name ? name : id;\n        if (!field && __DEV__) {\n          warnAboutMissingIdentifier({\n            htmlContent: outerHTML,\n            documentationAnchorLink: 'handlechange-e-reactchangeeventany--void',\n            handlerName: 'handleChange',\n          });\n        }\n        val = /number|range/.test(type)\n          ? ((parsed = parseFloat(value)), isNaN(parsed) ? '' : parsed)\n          : /checkbox/.test(type) // checkboxes\n          ? getValueForCheckbox(getIn(state.values, field!), checked, value)\n          : options && multiple // <select multiple>\n          ? getSelectedValues(options)\n          : value;\n      }\n\n      if (field) {\n        // Set form fields by name\n        setFieldValue(field, val);\n      }\n    },\n    [setFieldValue, state.values]\n  );\n\n  const handleChange = useEventCallback<FormikHandlers['handleChange']>(\n    (\n      eventOrPath: string | React.ChangeEvent<any>\n    ): void | ((eventOrTextValue: string | React.ChangeEvent<any>) => void) => {\n      if (isString(eventOrPath)) {\n        return event => executeChange(event, eventOrPath);\n      } else {\n        executeChange(eventOrPath);\n      }\n    }\n  );\n\n  const setFieldTouched = useEventCallback(\n    (field: string, touched: boolean = true, shouldValidate?: boolean) => {\n      dispatch({\n        type: 'SET_FIELD_TOUCHED',\n        payload: {\n          field,\n          value: touched,\n        },\n      });\n      const willValidate =\n        shouldValidate === undefined ? validateOnBlur : shouldValidate;\n      return willValidate\n        ? validateFormWithHighPriority(state.values)\n        : Promise.resolve();\n    }\n  );\n\n  const executeBlur = React.useCallback(\n    (e: any, path?: string) => {\n      if (e.persist) {\n        e.persist();\n      }\n      const { name, id, outerHTML } = e.target;\n      const field = path ? path : name ? name : id;\n\n      if (!field && __DEV__) {\n        warnAboutMissingIdentifier({\n          htmlContent: outerHTML,\n          documentationAnchorLink: 'handleblur-e-any--void',\n          handlerName: 'handleBlur',\n        });\n      }\n\n      setFieldTouched(field, true);\n    },\n    [setFieldTouched]\n  );\n\n  const handleBlur = useEventCallback<FormikHandlers['handleBlur']>(\n    (eventOrString: any): void | ((e: any) => void) => {\n      if (isString(eventOrString)) {\n        return event => executeBlur(event, eventOrString);\n      } else {\n        executeBlur(eventOrString);\n      }\n    }\n  );\n\n  const setFormikState = React.useCallback(\n    (\n      stateOrCb:\n        | FormikState<Values>\n        | ((state: FormikState<Values>) => FormikState<Values>)\n    ): void => {\n      if (isFunction(stateOrCb)) {\n        dispatch({ type: 'SET_FORMIK_STATE', payload: stateOrCb });\n      } else {\n        dispatch({ type: 'SET_FORMIK_STATE', payload: () => stateOrCb });\n      }\n    },\n    []\n  );\n\n  const setStatus = React.useCallback((status: any) => {\n    dispatch({ type: 'SET_STATUS', payload: status });\n  }, []);\n\n  const setSubmitting = React.useCallback((isSubmitting: boolean) => {\n    dispatch({ type: 'SET_ISSUBMITTING', payload: isSubmitting });\n  }, []);\n\n  const submitForm = useEventCallback(() => {\n    dispatch({ type: 'SUBMIT_ATTEMPT' });\n    return validateFormWithHighPriority().then(\n      (combinedErrors: FormikErrors<Values>) => {\n        // In case an error was thrown and passed to the resolved Promise,\n        // `combinedErrors` can be an instance of an Error. We need to check\n        // that and abort the submit.\n        // If we don't do that, calling `Object.keys(new Error())` yields an\n        // empty array, which causes the validation to pass and the form\n        // to be submitted.\n\n        const isInstanceOfError = combinedErrors instanceof Error;\n        const isActuallyValid =\n          !isInstanceOfError && Object.keys(combinedErrors).length === 0;\n        if (isActuallyValid) {\n          // Proceed with submit...\n          //\n          // To respect sync submit fns, we can't simply wrap executeSubmit in a promise and\n          // _always_ dispatch SUBMIT_SUCCESS because isSubmitting would then always be false.\n          // This would be fine in simple cases, but make it impossible to disable submit\n          // buttons where people use callbacks or promises as side effects (which is basically\n          // all of v1 Formik code). Instead, recall that we are inside of a promise chain already,\n          //  so we can try/catch executeSubmit(), if it returns undefined, then just bail.\n          // If there are errors, throw em. Otherwise, wrap executeSubmit in a promise and handle\n          // cleanup of isSubmitting on behalf of the consumer.\n          let promiseOrUndefined;\n          try {\n            promiseOrUndefined = executeSubmit();\n            // Bail if it's sync, consumer is responsible for cleaning up\n            // via setSubmitting(false)\n            if (promiseOrUndefined === undefined) {\n              return;\n            }\n          } catch (error) {\n            throw error;\n          }\n\n          return Promise.resolve(promiseOrUndefined)\n            .then(result => {\n              if (!!isMounted.current) {\n                dispatch({ type: 'SUBMIT_SUCCESS' });\n              }\n              return result;\n            })\n            .catch(_errors => {\n              if (!!isMounted.current) {\n                dispatch({ type: 'SUBMIT_FAILURE' });\n                // This is a legit error rejected by the onSubmit fn\n                // so we don't want to break the promise chain\n                throw _errors;\n              }\n            });\n        } else if (!!isMounted.current) {\n          // ^^^ Make sure Formik is still mounted before updating state\n          dispatch({ type: 'SUBMIT_FAILURE' });\n          // throw combinedErrors;\n          if (isInstanceOfError) {\n            throw combinedErrors;\n          }\n        }\n        return;\n      }\n    );\n  });\n\n  const handleSubmit = useEventCallback(\n    (e?: React.FormEvent<HTMLFormElement>) => {\n      if (e && e.preventDefault && isFunction(e.preventDefault)) {\n        e.preventDefault();\n      }\n\n      if (e && e.stopPropagation && isFunction(e.stopPropagation)) {\n        e.stopPropagation();\n      }\n\n      // Warn if form submission is triggered by a <button> without a\n      // specified `type` attribute during development. This mitigates\n      // a common gotcha in forms with both reset and submit buttons,\n      // where the dev forgets to add type=\"button\" to the reset button.\n      if (__DEV__ && typeof document !== 'undefined') {\n        // Safely get the active element (works with IE)\n        const activeElement = getActiveElement();\n        if (\n          activeElement !== null &&\n          activeElement instanceof HTMLButtonElement\n        ) {\n          invariant(\n            activeElement.attributes &&\n              activeElement.attributes.getNamedItem('type'),\n            'You submitted a Formik form using a button with an unspecified `type` attribute.  Most browsers default button elements to `type=\"submit\"`. If this is not a submit button, please add `type=\"button\"`.'\n          );\n        }\n      }\n\n      submitForm().catch(reason => {\n        console.warn(\n          `Warning: An unhandled error was caught from submitForm()`,\n          reason\n        );\n      });\n    }\n  );\n\n  const imperativeMethods: FormikHelpers<Values> = {\n    resetForm,\n    validateForm: validateFormWithHighPriority,\n    validateField,\n    setErrors,\n    setFieldError,\n    setFieldTouched,\n    setFieldValue,\n    setStatus,\n    setSubmitting,\n    setTouched,\n    setValues,\n    setFormikState,\n    submitForm,\n  };\n\n  const executeSubmit = useEventCallback(() => {\n    return onSubmit(state.values, imperativeMethods);\n  });\n\n  const handleReset = useEventCallback(e => {\n    if (e && e.preventDefault && isFunction(e.preventDefault)) {\n      e.preventDefault();\n    }\n\n    if (e && e.stopPropagation && isFunction(e.stopPropagation)) {\n      e.stopPropagation();\n    }\n\n    resetForm();\n  });\n\n  const getFieldMeta = React.useCallback(\n    (name: string): FieldMetaProps<any> => {\n      return {\n        value: getIn(state.values, name),\n        error: getIn(state.errors, name),\n        touched: !!getIn(state.touched, name),\n        initialValue: getIn(initialValues.current, name),\n        initialTouched: !!getIn(initialTouched.current, name),\n        initialError: getIn(initialErrors.current, name),\n      };\n    },\n    [state.errors, state.touched, state.values]\n  );\n\n  const getFieldHelpers = React.useCallback(\n    (name: string): FieldHelperProps<any> => {\n      return {\n        setValue: (value: any, shouldValidate?: boolean) =>\n          setFieldValue(name, value, shouldValidate),\n        setTouched: (value: boolean, shouldValidate?: boolean) =>\n          setFieldTouched(name, value, shouldValidate),\n        setError: (value: any) => setFieldError(name, value),\n      };\n    },\n    [setFieldValue, setFieldTouched, setFieldError]\n  );\n\n  const getFieldProps = React.useCallback(\n    (nameOrOptions: string | FieldConfig<any>): FieldInputProps<any> => {\n      const isAnObject = isObject(nameOrOptions);\n      const name = isAnObject\n        ? (nameOrOptions as FieldConfig<any>).name\n        : nameOrOptions;\n      const valueState = getIn(state.values, name);\n\n      const field: FieldInputProps<any> = {\n        name,\n        value: valueState,\n        onChange: handleChange,\n        onBlur: handleBlur,\n      };\n      if (isAnObject) {\n        const {\n          type,\n          value: valueProp, // value is special for checkboxes\n          as: is,\n          multiple,\n        } = nameOrOptions as FieldConfig<any>;\n\n        if (type === 'checkbox') {\n          if (valueProp === undefined) {\n            field.checked = !!valueState;\n          } else {\n            field.checked = !!(\n              Array.isArray(valueState) && ~valueState.indexOf(valueProp)\n            );\n            field.value = valueProp;\n          }\n        } else if (type === 'radio') {\n          field.checked = valueState === valueProp;\n          field.value = valueProp;\n        } else if (is === 'select' && multiple) {\n          field.value = field.value || [];\n          field.multiple = true;\n        }\n      }\n      return field;\n    },\n    [handleBlur, handleChange, state.values]\n  );\n\n  const dirty = React.useMemo(\n    () => !isEqual(initialValues.current, state.values),\n    [initialValues.current, state.values]\n  );\n\n  const isValid = React.useMemo(\n    () =>\n      typeof isInitialValid !== 'undefined'\n        ? dirty\n          ? state.errors && Object.keys(state.errors).length === 0\n          : isInitialValid !== false && isFunction(isInitialValid)\n          ? (isInitialValid as (props: FormikConfig<Values>) => boolean)(props)\n          : (isInitialValid as boolean)\n        : state.errors && Object.keys(state.errors).length === 0,\n    [isInitialValid, dirty, state.errors, props]\n  );\n\n  const ctx = {\n    ...state,\n    initialValues: initialValues.current,\n    initialErrors: initialErrors.current,\n    initialTouched: initialTouched.current,\n    initialStatus: initialStatus.current,\n    handleBlur,\n    handleChange,\n    handleReset,\n    handleSubmit,\n    resetForm,\n    setErrors,\n    setFormikState,\n    setFieldTouched,\n    setFieldValue,\n    setFieldError,\n    setStatus,\n    setSubmitting,\n    setTouched,\n    setValues,\n    submitForm,\n    validateForm: validateFormWithHighPriority,\n    validateField,\n    isValid,\n    dirty,\n    unregisterField,\n    registerField,\n    getFieldProps,\n    getFieldMeta,\n    getFieldHelpers,\n    validateOnBlur,\n    validateOnChange,\n    validateOnMount,\n  };\n\n  return ctx;\n}\n\nexport function Formik<\n  Values extends FormikValues = FormikValues,\n  ExtraProps = {}\n>(props: FormikConfig<Values> & ExtraProps) {\n  const formikbag = useFormik<Values>(props);\n  const { component, children, render, innerRef } = props;\n\n  // This allows folks to pass a ref to <Formik />\n  React.useImperativeHandle(innerRef, () => formikbag);\n\n  if (__DEV__) {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useEffect(() => {\n      invariant(\n        !props.render,\n        `<Formik render> has been deprecated and will be removed in future versions of Formik. Please use a child callback function instead. To get rid of this warning, replace <Formik render={(props) => ...} /> with <Formik>{(props) => ...}</Formik>`\n      );\n      // eslint-disable-next-line\n    }, []);\n  }\n  return (\n    <FormikProvider value={formikbag}>\n      {component\n        ? React.createElement(component as any, formikbag)\n        : render\n        ? render(formikbag)\n        : children // children come last, always called\n        ? isFunction(children)\n          ? (children as (bag: FormikProps<Values>) => React.ReactNode)(\n              formikbag as FormikProps<Values>\n            )\n          : !isEmptyChildren(children)\n          ? React.Children.only(children)\n          : null\n        : null}\n    </FormikProvider>\n  );\n}\n\nfunction warnAboutMissingIdentifier({\n  htmlContent,\n  documentationAnchorLink,\n  handlerName,\n}: {\n  htmlContent: string;\n  documentationAnchorLink: string;\n  handlerName: string;\n}) {\n  console.warn(\n    `Warning: Formik called \\`${handlerName}\\`, but you forgot to pass an \\`id\\` or \\`name\\` attribute to your input:\n    ${htmlContent}\n    Formik cannot determine which value to update. For more info see https://formik.org/docs/api/formik#${documentationAnchorLink}\n  `\n  );\n}\n\n/**\n * Transform Yup ValidationError to a more usable object\n */\nexport function yupToFormErrors<Values>(yupError: any): FormikErrors<Values> {\n  let errors: FormikErrors<Values> = {};\n  if (yupError.inner) {\n    if (yupError.inner.length === 0) {\n      return setIn(errors, yupError.path, yupError.message);\n    }\n    for (let err of yupError.inner) {\n      if (!getIn(errors, err.path)) {\n        errors = setIn(errors, err.path, err.message);\n      }\n    }\n  }\n  return errors;\n}\n\n/**\n * Validate a yup schema.\n */\nexport function validateYupSchema<T extends FormikValues>(\n  values: T,\n  schema: any,\n  sync: boolean = false,\n  context?: any\n): Promise<Partial<T>> {\n  const normalizedValues: FormikValues = prepareDataForValidation(values);\n\n  return schema[sync ? 'validateSync' : 'validate'](normalizedValues, {\n    abortEarly: false,\n    context: context || normalizedValues,\n  });\n}\n\n/**\n * Recursively prepare values.\n */\nexport function prepareDataForValidation<T extends FormikValues>(\n  values: T\n): FormikValues {\n  let data: FormikValues = Array.isArray(values) ? [] : {};\n  for (let k in values) {\n    if (Object.prototype.hasOwnProperty.call(values, k)) {\n      const key = String(k);\n      if (Array.isArray(values[key]) === true) {\n        data[key] = values[key].map((value: any) => {\n          if (Array.isArray(value) === true || isPlainObject(value)) {\n            return prepareDataForValidation(value);\n          } else {\n            return value !== '' ? value : undefined;\n          }\n        });\n      } else if (isPlainObject(values[key])) {\n        data[key] = prepareDataForValidation(values[key]);\n      } else {\n        data[key] = values[key] !== '' ? values[key] : undefined;\n      }\n    }\n  }\n  return data;\n}\n\n/**\n * deepmerge array merging algorithm\n * https://github.com/KyleAMathews/deepmerge#combine-array\n */\nfunction arrayMerge(target: any[], source: any[], options: any): any[] {\n  const destination = target.slice();\n\n  source.forEach(function merge(e: any, i: number) {\n    if (typeof destination[i] === 'undefined') {\n      const cloneRequested = options.clone !== false;\n      const shouldClone = cloneRequested && options.isMergeableObject(e);\n      destination[i] = shouldClone\n        ? deepmerge(Array.isArray(e) ? [] : {}, e, options)\n        : e;\n    } else if (options.isMergeableObject(e)) {\n      destination[i] = deepmerge(target[i], e, options);\n    } else if (target.indexOf(e) === -1) {\n      destination.push(e);\n    }\n  });\n  return destination;\n}\n\n/** Return multi select values based on an array of options */\nfunction getSelectedValues(options: any[]) {\n  return Array.from(options)\n    .filter(el => el.selected)\n    .map(el => el.value);\n}\n\n/** Return the next value for a checkbox */\nfunction getValueForCheckbox(\n  currentValue: string | any[],\n  checked: boolean,\n  valueProp: any\n) {\n  // If the current value was a boolean, return a boolean\n  if (typeof currentValue === 'boolean') {\n    return Boolean(checked);\n  }\n\n  // If the currentValue was not a boolean we want to return an array\n  let currentArrayOfValues = [];\n  let isValueInArray = false;\n  let index = -1;\n\n  if (!Array.isArray(currentValue)) {\n    // eslint-disable-next-line eqeqeq\n    if (!valueProp || valueProp == 'true' || valueProp == 'false') {\n      return Boolean(checked);\n    }\n  } else {\n    // If the current value is already an array, use it\n    currentArrayOfValues = currentValue;\n    index = currentValue.indexOf(valueProp);\n    isValueInArray = index >= 0;\n  }\n\n  // If the checkbox was checked and the value is not already present in the aray we want to add the new value to the array of values\n  if (checked && valueProp && !isValueInArray) {\n    return currentArrayOfValues.concat(valueProp);\n  }\n\n  // If the checkbox was unchecked and the value is not in the array, simply return the already existing array of values\n  if (!isValueInArray) {\n    return currentArrayOfValues;\n  }\n\n  // If the checkbox was unchecked and the value is in the array, remove the value and return the array\n  return currentArrayOfValues\n    .slice(0, index)\n    .concat(currentArrayOfValues.slice(index + 1));\n}\n\n// React currently throws a warning when using useLayoutEffect on the server.\n// To get around it, we can conditionally useEffect on the server (no-op) and\n// useLayoutEffect in the browser.\n// @see https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85\nconst useIsomorphicLayoutEffect =\n  typeof window !== 'undefined' &&\n  typeof window.document !== 'undefined' &&\n  typeof window.document.createElement !== 'undefined'\n    ? React.useLayoutEffect\n    : React.useEffect;\n\nfunction useEventCallback<T extends (...args: any[]) => any>(fn: T): T {\n  const ref: any = React.useRef(fn);\n\n  // we copy a ref to the callback scoped to the current state/props on each render\n  useIsomorphicLayoutEffect(() => {\n    ref.current = fn;\n  });\n\n  return React.useCallback(\n    (...args: any[]) => ref.current.apply(void 0, args),\n    []\n  ) as T;\n}\n","import * as React from 'react';\nimport {\n  FormikProps,\n  GenericFieldHTMLAttributes,\n  FieldMetaProps,\n  FieldHelperProps,\n  FieldInputProps,\n  FieldValidator,\n} from './types';\nimport { useFormikContext } from './FormikContext';\nimport { isFunction, isEmptyChildren, isObject } from './utils';\nimport invariant from 'tiny-warning';\n\nexport interface FieldProps<V = any, FormValues = any> {\n  field: FieldInputProps<V>;\n  form: FormikProps<FormValues>; // if ppl want to restrict this for a given form, let them.\n  meta: FieldMetaProps<V>;\n}\n\nexport interface FieldConfig<V = any> {\n  /**\n   * Field component to render. Can either be a string like 'select' or a component.\n   */\n  component?:\n  | string\n  | React.ComponentType<FieldProps<V>>\n  | React.ComponentType\n  | React.ForwardRefExoticComponent<any>;\n\n  /**\n   * Component to render. Can either be a string e.g. 'select', 'input', or 'textarea', or a component.\n   */\n  as?:\n  | React.ComponentType<FieldProps<V>['field']>\n  | string\n  | React.ComponentType\n  | React.ForwardRefExoticComponent<any>;\n\n  /**\n   * Render prop (works like React router's <Route render={props =>} />)\n   * @deprecated\n   */\n  render?: (props: FieldProps<V>) => React.ReactNode;\n\n  /**\n   * Children render function <Field name>{props => ...}</Field>)\n   */\n  children?: ((props: FieldProps<V>) => React.ReactNode) | React.ReactNode;\n\n  /**\n   * Validate a single field value independently\n   */\n  validate?: FieldValidator;\n\n  /**\n   * Used for 'select' and related input types.\n   */\n  multiple?: boolean;\n\n  /**\n   * Field name\n   */\n  name: string;\n\n  /** HTML input type */\n  type?: string;\n\n  /** Field value */\n  value?: any;\n\n  /** Inner ref */\n  innerRef?: (instance: any) => void;\n}\n\nexport type FieldAttributes<T> = { className?: string; } & GenericFieldHTMLAttributes &\n  FieldConfig<T> &\n  T & {\n    name: string,\n  };\n\nexport type FieldHookConfig<T> = GenericFieldHTMLAttributes & FieldConfig<T>;\n\nexport function useField<Val = any>(\n  propsOrFieldName: string | FieldHookConfig<Val>\n): [FieldInputProps<Val>, FieldMetaProps<Val>, FieldHelperProps<Val>] {\n  const formik = useFormikContext();\n  const {\n    getFieldProps,\n    getFieldMeta,\n    getFieldHelpers,\n    registerField,\n    unregisterField,\n  } = formik;\n\n  const isAnObject = isObject(propsOrFieldName);\n\n  // Normalize propsOrFieldName to FieldHookConfig<Val>\n  const props: FieldHookConfig<Val> = isAnObject\n    ? (propsOrFieldName as FieldHookConfig<Val>)\n    : { name: propsOrFieldName as string };\n\n  const { name: fieldName, validate: validateFn } = props;\n\n  React.useEffect(() => {\n    if (fieldName) {\n      registerField(fieldName, {\n        validate: validateFn,\n      });\n    }\n    return () => {\n      if (fieldName) {\n        unregisterField(fieldName);\n      }\n    };\n  }, [registerField, unregisterField, fieldName, validateFn]);\n\n  if (__DEV__) {\n    invariant(\n      formik,\n      'useField() / <Field /> must be used underneath a <Formik> component or withFormik() higher order component'\n    );\n  }\n\n  invariant(\n    fieldName,\n    'Invalid field name. Either pass `useField` a string or an object containing a `name` key.'\n  );\n\n  const fieldHelpers = React.useMemo(() => getFieldHelpers(fieldName), [\n    getFieldHelpers,\n    fieldName,\n  ]);\n\n  return [getFieldProps(props), getFieldMeta(fieldName), fieldHelpers];\n}\n\nexport function Field({\n  validate,\n  name,\n  render,\n  children,\n  as: is, // `as` is reserved in typescript lol\n  component,\n  className,\n  ...props\n}: FieldAttributes<any>) {\n  const {\n    validate: _validate,\n    validationSchema: _validationSchema,\n\n    ...formik\n  } = useFormikContext();\n\n  if (__DEV__) {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useEffect(() => {\n      invariant(\n        !render,\n        `<Field render> has been deprecated and will be removed in future versions of Formik. Please use a child callback function instead. To get rid of this warning, replace <Field name=\"${name}\" render={({field, form}) => ...} /> with <Field name=\"${name}\">{({field, form, meta}) => ...}</Field>`\n      );\n\n      invariant(\n        !(is && children && isFunction(children)),\n        'You should not use <Field as> and <Field children> as a function in the same <Field> component; <Field as> will be ignored.'\n      );\n\n      invariant(\n        !(component && children && isFunction(children)),\n        'You should not use <Field component> and <Field children> as a function in the same <Field> component; <Field component> will be ignored.'\n      );\n\n      invariant(\n        !(render && children && !isEmptyChildren(children)),\n        'You should not use <Field render> and <Field children> in the same <Field> component; <Field children> will be ignored'\n      );\n      // eslint-disable-next-line\n    }, []);\n  }\n\n  // Register field and field-level validation with parent <Formik>\n  const { registerField, unregisterField } = formik;\n  React.useEffect(() => {\n    registerField(name, {\n      validate: validate,\n    });\n    return () => {\n      unregisterField(name);\n    };\n  }, [registerField, unregisterField, name, validate]);\n  const field = formik.getFieldProps({ name, ...props });\n  const meta = formik.getFieldMeta(name);\n  const legacyBag = { field, form: formik };\n\n  if (render) {\n    return render({ ...legacyBag, meta });\n  }\n\n  if (isFunction(children)) {\n    return children({ ...legacyBag, meta });\n  }\n\n  if (component) {\n    // This behavior is backwards compat with earlier Formik 0.9 to 1.x\n    if (typeof component === 'string') {\n      const { innerRef, ...rest } = props;\n      return React.createElement(\n        component,\n        { ref: innerRef, ...field, ...rest, className },\n        children\n      );\n    }\n    // We don't pass `meta` for backwards compat\n    return React.createElement(\n      component,\n      { field, form: formik, ...props, className },\n      children\n    );\n  }\n\n  // default to input here so we can check for both `as` and `children` above\n  const asElement = is || 'input';\n\n  if (typeof asElement === 'string') {\n    const { innerRef, ...rest } = props;\n    return React.createElement(\n      asElement,\n      { ref: innerRef, ...field, ...rest, className },\n      children\n    );\n  }\n\n  return React.createElement(asElement, { ...field, ...props, className }, children);\n}\n","import hoistNonReactStatics from 'hoist-non-react-statics';\nimport * as React from 'react';\nimport { Formik } from './Formik';\nimport {\n  FormikHelpers,\n  FormikProps,\n  FormikSharedConfig,\n  FormikValues,\n  FormikTouched,\n  FormikErrors,\n} from './types';\nimport { isFunction } from './utils';\n\n/**\n * State, handlers, and helpers injected as props into the wrapped form component.\n * Used with withFormik()\n *\n * @deprecated  Use `OuterProps & FormikProps<Values>` instead.\n */\nexport type InjectedFormikProps<Props, Values> = Props & FormikProps<Values>;\n\n/**\n * Formik helpers + { props }\n */\nexport type FormikBag<P, V> = { props: P } & FormikHelpers<V>;\n\n/**\n * withFormik() configuration options. Backwards compatible.\n */\nexport interface WithFormikConfig<\n  Props,\n  Values extends FormikValues = FormikValues,\n  DeprecatedPayload = Values\n> extends FormikSharedConfig<Props> {\n  /**\n   * Set the display name of the component. Useful for React DevTools.\n   */\n  displayName?: string;\n\n  /**\n   * Submission handler\n   */\n  handleSubmit: (values: Values, formikBag: FormikBag<Props, Values>) => void;\n\n  /**\n   * Map props to the form values\n   */\n  mapPropsToValues?: (props: Props) => Values;\n\n  /**\n   * Map props to the form status\n   */\n  mapPropsToStatus?: (props: Props) => any;\n\n  /**\n   * Map props to the form touched state\n   */\n  mapPropsToTouched?: (props: Props) => FormikTouched<Values>;\n\n  /**\n   * Map props to the form errors state\n   */\n  mapPropsToErrors?: (props: Props) => FormikErrors<Values>;\n\n  /**\n   * @deprecated in 0.9.0 (but needed to break TS types)\n   */\n  mapValuesToPayload?: (values: Values) => DeprecatedPayload;\n\n  /**\n   * A Yup Schema or a function that returns a Yup schema\n   */\n  validationSchema?: any | ((props: Props) => any);\n\n  /**\n   * Validation function. Must return an error object or promise that\n   * throws an error object where that object keys map to corresponding value.\n   */\n  validate?: (values: Values, props: Props) => void | object | Promise<any>;\n}\n\nexport type CompositeComponent<P> =\n  | React.ComponentClass<P>\n  | React.FunctionComponent<P>;\n\nexport interface ComponentDecorator<TOwnProps, TMergedProps> {\n  (component: CompositeComponent<TMergedProps>): React.ComponentType<TOwnProps>;\n}\n\nexport interface InferableComponentDecorator<TOwnProps> {\n  <T extends CompositeComponent<TOwnProps>>(component: T): T;\n}\n\n/**\n * A public higher-order component to access the imperative API\n */\nexport function withFormik<\n  OuterProps extends object,\n  Values extends FormikValues,\n  Payload = Values\n>({\n  mapPropsToValues = (vanillaProps: OuterProps): Values => {\n    let val: Values = {} as Values;\n    for (let k in vanillaProps) {\n      if (\n        vanillaProps.hasOwnProperty(k) &&\n        typeof vanillaProps[k] !== 'function'\n      ) {\n        // @todo TypeScript fix\n        (val as any)[k] = vanillaProps[k];\n      }\n    }\n    return val as Values;\n  },\n  ...config\n}: WithFormikConfig<OuterProps, Values, Payload>): ComponentDecorator<\n  OuterProps,\n  OuterProps & FormikProps<Values>\n> {\n  return function createFormik(\n    Component: CompositeComponent<OuterProps & FormikProps<Values>>\n  ): React.ComponentClass<OuterProps> {\n    const componentDisplayName =\n      Component.displayName ||\n      Component.name ||\n      (Component.constructor && Component.constructor.name) ||\n      'Component';\n    /**\n     * We need to use closures here for to provide the wrapped component's props to\n     * the respective withFormik config methods.\n     */\n    class C extends React.Component<OuterProps, {}> {\n      static displayName = `WithFormik(${componentDisplayName})`;\n\n      validate = (values: Values): void | object | Promise<any> => {\n        return config.validate!(values, this.props);\n      };\n\n      validationSchema = () => {\n        return isFunction(config.validationSchema)\n          ? config.validationSchema!(this.props)\n          : config.validationSchema;\n      };\n\n      handleSubmit = (values: Values, actions: FormikHelpers<Values>) => {\n        return config.handleSubmit(values, {\n          ...actions,\n          props: this.props,\n        });\n      };\n\n      /**\n       * Just avoiding a render callback for perf here\n       */\n      renderFormComponent = (formikProps: FormikProps<Values>) => {\n        return <Component {...this.props} {...formikProps} />;\n      };\n\n      render() {\n        const { children, ...props } = this.props as any;\n        return (\n          <Formik\n            {...props}\n            {...config}\n            validate={config.validate && this.validate}\n            validationSchema={config.validationSchema && this.validationSchema}\n            initialValues={mapPropsToValues(this.props)}\n            initialStatus={\n              config.mapPropsToStatus && config.mapPropsToStatus(this.props)\n            }\n            initialErrors={\n              config.mapPropsToErrors && config.mapPropsToErrors(this.props)\n            }\n            initialTouched={\n              config.mapPropsToTouched && config.mapPropsToTouched(this.props)\n            }\n            onSubmit={this.handleSubmit as any}\n            children={this.renderFormComponent}\n          />\n        );\n      }\n    }\n\n    return hoistNonReactStatics(\n      C,\n      Component as React.ComponentClass<OuterProps & FormikProps<Values>> // cast type to ComponentClass (even if SFC)\n    ) as React.ComponentClass<OuterProps>;\n  };\n}\n","import * as React from 'react';\nimport { useFormikContext } from './FormikContext';\n\nexport type FormikFormProps = Pick<\n  React.FormHTMLAttributes<HTMLFormElement>,\n  Exclude<\n    keyof React.FormHTMLAttributes<HTMLFormElement>,\n    'onReset' | 'onSubmit'\n  >\n>;\n\ntype FormProps = React.ComponentPropsWithoutRef<'form'>;\n\n// @todo tests\nexport const Form = React.forwardRef<HTMLFormElement, FormProps>(\n  (props: FormikFormProps, ref) => {\n    // iOS needs an \"action\" attribute for nice input: https://stackoverflow.com/a/39485162/406725\n    // We default the action to \"#\" in case the preventDefault fails (just updates the URL hash)\n    const { action, ...rest } = props;\n    const _action = action ?? '#';\n    const { handleReset, handleSubmit } = useFormikContext();\n    return (\n      <form\n        onSubmit={handleSubmit}\n        ref={ref}\n        onReset={handleReset}\n        action={_action}\n        {...rest}\n      />\n    );\n  }\n);\n\nForm.displayName = 'Form';\n","import cloneDeep from 'lodash/cloneDeep';\nimport * as React from 'react';\nimport isEqual from 'react-fast-compare';\nimport { connect } from './connect';\nimport {\n  FormikContextType,\n  FormikProps,\n  FormikState,\n  SharedRenderProps,\n} from './types';\nimport {\n  getIn,\n  isEmptyArray,\n  isEmptyChildren,\n  isFunction,\n  isObject,\n  setIn,\n} from './utils';\n\nexport type FieldArrayRenderProps = ArrayHelpers & {\n  form: FormikProps<any>;\n  name: string;\n};\n\nexport type FieldArrayConfig = {\n  /** Really the path to the array field to be updated */\n  name: string;\n  /** Should field array validate the form AFTER array updates/changes? */\n  validateOnChange?: boolean;\n} & SharedRenderProps<FieldArrayRenderProps>;\nexport interface ArrayHelpers<T extends any[] = any[]> {\n  /** Imperatively add a value to the end of an array */\n  push<X = T[number]>(obj: X): void;\n  /** Curried fn to add a value to the end of an array */\n  handlePush<X = T[number]>(obj: X): () => void;\n  /** Imperatively swap two values in an array */\n  swap: (indexA: number, indexB: number) => void;\n  /** Curried fn to swap two values in an array */\n  handleSwap: (indexA: number, indexB: number) => () => void;\n  /** Imperatively move an element in an array to another index */\n  move: (from: number, to: number) => void;\n  /** Imperatively move an element in an array to another index */\n  handleMove: (from: number, to: number) => () => void;\n  /** Imperatively insert an element at a given index into the array */\n  insert<X = T[number]>(index: number, value: X): void;\n  /** Curried fn to insert an element at a given index into the array */\n  handleInsert<X = T[number]>(index: number, value: X): () => void;\n  /** Imperatively replace a value at an index of an array  */\n  replace<X = T[number]>(index: number, value: X): void;\n  /** Curried fn to replace an element at a given index into the array */\n  handleReplace<X = T[number]>(index: number, value: X): () => void;\n  /** Imperatively add an element to the beginning of an array and return its length */\n  unshift<X = T[number]>(value: X): number;\n  /** Curried fn to add an element to the beginning of an array */\n  handleUnshift<X = T[number]>(value: X): () => void;\n  /** Curried fn to remove an element at an index of an array */\n  handleRemove: (index: number) => () => void;\n  /** Curried fn to remove a value from the end of the array */\n  handlePop: () => () => void;\n  /** Imperatively remove and element at an index of an array */\n  remove<X = T[number]>(index: number): X | undefined;\n  /** Imperatively remove and return value from the end of the array */\n  pop<X = T[number]>(): X | undefined;\n}\n\n/**\n * Some array helpers!\n */\nexport const move = <T,>(array: T[], from: number, to: number) => {\n  const copy = copyArrayLike(array);\n  const value = copy[from];\n  copy.splice(from, 1);\n  copy.splice(to, 0, value);\n  return copy;\n};\n\nexport const swap = <T,>(\n  arrayLike: ArrayLike<T>,\n  indexA: number,\n  indexB: number\n) => {\n  const copy = copyArrayLike(arrayLike);\n  const a = copy[indexA];\n  copy[indexA] = copy[indexB];\n  copy[indexB] = a;\n  return copy;\n};\n\nexport const insert = <T,>(\n  arrayLike: ArrayLike<T>,\n  index: number,\n  value: T\n) => {\n  const copy = copyArrayLike(arrayLike);\n  copy.splice(index, 0, value);\n  return copy;\n};\n\nexport const replace = <T,>(\n  arrayLike: ArrayLike<T>,\n  index: number,\n  value: T\n) => {\n  const copy = copyArrayLike(arrayLike);\n  copy[index] = value;\n  return copy;\n};\n\nconst copyArrayLike = (arrayLike: ArrayLike<any>) => {\n  if (!arrayLike) {\n    return [];\n  } else if (Array.isArray(arrayLike)) {\n    return [...arrayLike];\n  } else {\n    const maxIndex = Object.keys(arrayLike)\n      .map(key => parseInt(key))\n      .reduce((max, el) => (el > max ? el : max), 0);\n    return Array.from({ ...arrayLike, length: maxIndex + 1 });\n  }\n};\n\nconst createAlterationHandler = (\n  alteration: boolean | Function,\n  defaultFunction: Function\n) => {\n  const fn = typeof alteration === 'function' ? alteration : defaultFunction;\n\n  return (data: any | any[]) => {\n    if (Array.isArray(data) || isObject(data)) {\n      const clone = copyArrayLike(data);\n      return fn(clone);\n    }\n\n    // This can be assumed to be a primitive, which\n    // is a case for top level validation errors\n    return data;\n  };\n};\n\nclass FieldArrayInner<Values = {}> extends React.Component<\n  FieldArrayConfig & { formik: FormikContextType<Values> },\n  {}\n> {\n  static defaultProps = {\n    validateOnChange: true,\n  };\n\n  constructor(props: FieldArrayConfig & { formik: FormikContextType<Values> }) {\n    super(props);\n    // We need TypeScript generics on these, so we'll bind them in the constructor\n    // @todo Fix TS 3.2.1\n    this.remove = this.remove.bind(this) as any;\n    this.pop = this.pop.bind(this) as any;\n  }\n\n  componentDidUpdate(\n    prevProps: FieldArrayConfig & { formik: FormikContextType<Values> }\n  ) {\n    if (\n      this.props.validateOnChange &&\n      this.props.formik.validateOnChange &&\n      !isEqual(\n        getIn(prevProps.formik.values, prevProps.name),\n        getIn(this.props.formik.values, this.props.name)\n      )\n    ) {\n      this.props.formik.validateForm(this.props.formik.values);\n    }\n  }\n\n  updateArrayField = (\n    fn: Function,\n    alterTouched: boolean | Function,\n    alterErrors: boolean | Function\n  ) => {\n    const {\n      name,\n\n      formik: { setFormikState },\n    } = this.props;\n\n    setFormikState((prevState: FormikState<any>) => {\n      let updateErrors = createAlterationHandler(alterErrors, fn);\n      let updateTouched = createAlterationHandler(alterTouched, fn);\n\n      // values fn should be executed before updateErrors and updateTouched,\n      // otherwise it causes an error with unshift.\n      let values = setIn(\n        prevState.values,\n        name,\n        fn(getIn(prevState.values, name))\n      );\n\n      let fieldError = alterErrors\n        ? updateErrors(getIn(prevState.errors, name))\n        : undefined;\n      let fieldTouched = alterTouched\n        ? updateTouched(getIn(prevState.touched, name))\n        : undefined;\n\n      if (isEmptyArray(fieldError)) {\n        fieldError = undefined;\n      }\n      if (isEmptyArray(fieldTouched)) {\n        fieldTouched = undefined;\n      }\n\n      return {\n        ...prevState,\n        values,\n        errors: alterErrors\n          ? setIn(prevState.errors, name, fieldError)\n          : prevState.errors,\n        touched: alterTouched\n          ? setIn(prevState.touched, name, fieldTouched)\n          : prevState.touched,\n      };\n    });\n  };\n\n  push = (value: any) =>\n    this.updateArrayField(\n      (arrayLike: ArrayLike<any>) => [\n        ...copyArrayLike(arrayLike),\n        cloneDeep(value),\n      ],\n      false,\n      false\n    );\n\n  handlePush = (value: any) => () => this.push(value);\n\n  swap = (indexA: number, indexB: number) =>\n    this.updateArrayField(\n      (array: any[]) => swap(array, indexA, indexB),\n      true,\n      true\n    );\n\n  handleSwap = (indexA: number, indexB: number) => () =>\n    this.swap(indexA, indexB);\n\n  move = (from: number, to: number) =>\n    this.updateArrayField((array: any[]) => move(array, from, to), true, true);\n\n  handleMove = (from: number, to: number) => () => this.move(from, to);\n\n  insert = (index: number, value: any) =>\n    this.updateArrayField(\n      (array: any[]) => insert(array, index, value),\n      (array: any[]) => insert(array, index, null),\n      (array: any[]) => insert(array, index, null)\n    );\n\n  handleInsert = (index: number, value: any) => () => this.insert(index, value);\n\n  replace = (index: number, value: any) =>\n    this.updateArrayField(\n      (array: any[]) => replace(array, index, value),\n      false,\n      false\n    );\n\n  handleReplace = (index: number, value: any) => () =>\n    this.replace(index, value);\n\n  unshift = (value: any) => {\n    let length = -1;\n    this.updateArrayField(\n      (array: any[]) => {\n        const arr = array ? [value, ...array] : [value];\n\n        length = arr.length;\n\n        return arr;\n      },\n      (array: any[]) => {\n        return array ? [null, ...array] : [null];\n      },\n      (array: any[]) => {\n        return array ? [null, ...array] : [null];\n      }\n    );\n\n    return length;\n  };\n\n  handleUnshift = (value: any) => () => this.unshift(value);\n\n  remove<T>(index: number): T {\n    // We need to make sure we also remove relevant pieces of `touched` and `errors`\n    let result: any;\n    this.updateArrayField(\n      // so this gets call 3 times\n      (array?: any[]) => {\n        const copy = array ? copyArrayLike(array) : [];\n        if (!result) {\n          result = copy[index];\n        }\n        if (isFunction(copy.splice)) {\n          copy.splice(index, 1);\n        }\n        // if the array only includes undefined values we have to return an empty array\n        return isFunction(copy.every)\n          ? copy.every(v => v === undefined)\n            ? []\n            : copy\n          : copy;\n      },\n      true,\n      true\n    );\n\n    return result as T;\n  }\n\n  handleRemove = (index: number) => () => this.remove<any>(index);\n\n  pop<T>(): T {\n    // Remove relevant pieces of `touched` and `errors` too!\n    let result: any;\n    this.updateArrayField(\n      // so this gets call 3 times\n      (array: any[]) => {\n        const tmp = array.slice();\n        if (!result) {\n          result = tmp && tmp.pop && tmp.pop();\n        }\n        return tmp;\n      },\n      true,\n      true\n    );\n\n    return result as T;\n  }\n\n  handlePop = () => () => this.pop<any>();\n\n  render() {\n    const arrayHelpers: ArrayHelpers = {\n      push: this.push,\n      pop: this.pop,\n      swap: this.swap,\n      move: this.move,\n      insert: this.insert,\n      replace: this.replace,\n      unshift: this.unshift,\n      remove: this.remove,\n      handlePush: this.handlePush,\n      handlePop: this.handlePop,\n      handleSwap: this.handleSwap,\n      handleMove: this.handleMove,\n      handleInsert: this.handleInsert,\n      handleReplace: this.handleReplace,\n      handleUnshift: this.handleUnshift,\n      handleRemove: this.handleRemove,\n    };\n\n    const {\n      component,\n      render,\n      children,\n      name,\n      formik: {\n        validate: _validate,\n        validationSchema: _validationSchema,\n        ...restOfFormik\n      },\n    } = this.props;\n\n    const props: FieldArrayRenderProps = {\n      ...arrayHelpers,\n      form: restOfFormik,\n      name,\n    };\n\n    return component\n      ? React.createElement(component as any, props)\n      : render\n      ? (render as any)(props)\n      : children // children come last, always called\n      ? typeof children === 'function'\n        ? (children as any)(props)\n        : !isEmptyChildren(children)\n        ? React.Children.only(children)\n        : null\n      : null;\n  }\n}\n\nexport const FieldArray = connect<FieldArrayConfig, any>(FieldArrayInner);\n"],"names":["reactPropsRegex","isPropValid","memoize","prop","test","charCodeAt","fn","cache","Object","create","arg","undefined","W","M","d","c","e","h","a","q","g","k","y","C","m","b","v","n","x","K","u","l","r","I","t","B","length","J","f","p","F","G","replace","N","trim","charAt","substring","ca","O","A","H","X","D","z","join","da","ea","fa","w","L","P","Y","E","ha","Q","split","ia","Z","indexOf","ja","ka","aa","ba","la","ma","R","na","oa","S","call","U","prefix","use","T","set","animationIterationCount","borderImageOutset","borderImageSlice","borderImageWidth","boxFlex","boxFlexGroup","boxOrdinalGroup","columnCount","columns","flex","flexGrow","flexPositive","flexShrink","flexNegative","flexOrder","gridRow","gridRowEnd","gridRowSpan","gridRowStart","gridColumn","gridColumnEnd","gridColumnSpan","gridColumnStart","msGridRow","msGridRowSpan","msGridColumn","msGridColumnSpan","fontWeight","lineHeight","opacity","order","orphans","tabSize","widows","zIndex","zoom","WebkitLineClamp","fillOpacity","floodOpacity","stopOpacity","strokeDasharray","strokeDashoffset","strokeMiterlimit","strokeOpacity","strokeWidth","defineMessages","msgs","defineMessage","msg","createIntl","config","formatters","createFormatters","resolvedConfig","__assign","DEFAULT_INTL_CONFIG","locale","defaultLocale","onError","Intl","NumberFormat","supportedLocalesOf","MissingDataError","concat","DateTimeFormat","InvalidConfigError","messages","onWarn","defaultRichTextElements","keys","verifyConfigMessages","formatNumber","bind","getNumberFormat","formatNumberToParts","formatRelativeTime","getRelativeTimeFormat","formatDate","getDateTimeFormat","formatDateToParts","formatTime","formatDateTimeRange","formatTimeToParts","formatPlural","getPluralRules","formatMessage","$t","formatList","getListFormat","formatListToParts","formatDisplayName","getDisplayNames","DATE_TIME_FORMAT_OPTIONS","getFormatter","_a","type","options","formats","timeZone","format","defaults","getNamedFormat","filteredOptions","filterProps","hour","minute","second","timeStyle","dateStyle","_i","arguments","value","_b","date","Date","IntlError","IntlErrorCode","FORMAT_ERROR","String","from","to","formatRange","formatToParts","DISPLAY_NAMES_OPTONS","DisplayNames","FormatError","ErrorCode","MISSING_INTL_API","of","_super","code","message","exception","_this","this","err","Error","stack","captureStackTrace","__extends","UnsupportedFormatterError","UNSUPPORTED_FORMATTER","INVALID_CONFIG","MISSING_DATA","IntlFormatError","MessageFormatError","descriptor","id","defaultMessage","description","MissingTranslationError","MISSING_TRANSLATION","LIST_FORMAT_OPTIONS","now","opts","values","results","reduce","all","el","val","push","ListFormat","richValues_1","serializedValues","map","i","generateToken","part","setTimeZoneInOptions","deepMergeOptions","opts1","opts2","deepMergeFormatsAndSetTimeZone","f1","mfFormats","IntlMessageFormat","time","state","messageDescriptor","defaultFormats","fallbackOnEmptyString","msgId","invariant","prototype","hasOwnProperty","Array","isArray","TYPE","literal","toLowerCase","getMessageFormat","NUMBER_FORMAT_OPTIONS","PLURAL_FORMAT_OPTIONS","PluralRules","select","RELATIVE_TIME_FORMAT_OPTIONS","unit","RelativeTimeFormat","props","allowlist","filtered","name","error","warning","createIntlCache","dateTime","number","relativeTime","pluralRules","list","displayNames","createFastMemoizeCache","store","get","key","args","apply","__spreadArray","strategy","strategies","variadic","locales","overrideFormats","formatType","condition","Err","cacheDefault","serializer","serializerDefault","strategyDefault","monadic","cacheKey","computedValue","slice","assemble","context","serialize","JSON","stringify","ObjectWithoutPrototypeCache","getBestPattern","skeleton","skeletonCopy","patternPos","patternChar","extraLength","hourLen","dayPeriodLen","hourChar","getDefaultHourSymbolFromLocale","hourCycle","hourCycles","regionTag","languageTag","language","maximize","region","timeData","ErrorKind","pruneLocation","els","forEach","location","isSelectElement","isPluralElement","isNumberElement","isNumberSkeleton","style","isDateElement","isTimeElement","isDateTimeSkeleton","isTagElement","children","parse","shouldParseSkeletons","requiresOtherClause","result","Parser","SyntaxError","kind","originalMessage","captureLocation","SPACE_SEPARATOR_START_REGEX","RegExp","SPACE_SEPARATOR_REGEX","source","SPACE_SEPARATOR_END_REGEX","createLocation","start","end","hasNativeStartsWith","startsWith","hasNativeFromCodePoint","fromCodePoint","hasNativeFromEntries","fromEntries","hasNativeCodePointAt","codePointAt","hasTrimStart","trimStart","hasTrimEnd","trimEnd","isSafeInteger","Number","isFinite","Math","floor","abs","REGEX_SUPPORTS_U_AND_Y","RE","exec","_","matchIdentifierAtIndex","s","search","position","codePoints","elements","RangeError","fromCharCode","entries","obj","entries_1","index","size","first","flag","IDENTIFIER_PREFIX_RE_1","lastIndex","match","_isWhiteSpace","_isPatternSyntax","offset","line","column","ignoreTag","parseMessage","nestingLevel","parentArgType","expectingCloseTag","isEOF","char","parseArgument","peek","UNMATCHED_CLOSING_TAG","clonePosition","_isAlpha","parseTag","parseLiteral","bump","pound","startPosition","tagName","parseTagName","bumpSpace","bumpIf","childrenResult","endTagStartPosition","INVALID_TAG","closingTagNameStartPosition","tag","UNCLOSED_TAG","startOffset","parseQuoteResult","tryParseQuote","parseUnquotedResult","tryParseUnquoted","parseLeftAngleResult","tryParseLeftAngleBracket","codepoint","ch","openingBracePosition","EXPECT_ARGUMENT_CLOSING_BRACE","EMPTY_ARGUMENT","parseIdentifierIfPossible","MALFORMED_ARGUMENT","argument","parseArgumentOptions","startingPosition","endOffset","bumpTo","typeStartPosition","argType","typeEndPosition","EXPECT_ARGUMENT_TYPE","styleAndLocation","styleStartPosition","parseSimpleArgStyleIfPossible","EXPECT_ARGUMENT_STYLE","styleLocation","argCloseResult","tryParseArgumentClose","location_1","parseNumberSkeletonFromString","EXPECT_DATE_TIME_SKELETON","dateTimePattern","SKELETON_TYPE","pattern","parsedOptions","parseDateTimeSkeleton","typeEndPosition_1","EXPECT_SELECT_ARGUMENT_OPTIONS","identifierAndLocation","pluralOffset","EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE","tryParseDecimalInteger","INVALID_PLURAL_ARGUMENT_OFFSET_VALUE","optionsResult","tryParsePluralOrSelectOptions","location_2","plural","pluralType","INVALID_ARGUMENT_TYPE","nestedBraces","apostrophePosition","bumpUntil","UNCLOSED_QUOTE_IN_ARGUMENT_STYLE","tokens","INVALID_NUMBER_SKELETON","parseNumberSkeleton","expectCloseTag","parsedFirstIdentifier","hasOtherClause","parsedSelectors","Set","selector","selectorLocation","EXPECT_PLURAL_ARGUMENT_SELECTOR","INVALID_PLURAL_ARGUMENT_SELECTOR","has","DUPLICATE_SELECT_ARGUMENT_SELECTOR","DUPLICATE_PLURAL_ARGUMENT_SELECTOR","EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT","EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT","fragmentResult","add","EXPECT_SELECT_ARGUMENT_SELECTOR","MISSING_OTHER_CLAUSE","expectNumberError","invalidNumberError","sign","hasDigits","decimal","currentOffset","targetOffset","min","nextCode","isLiteralElement","isArgumentElement","isPoundElement","DATE_TIME_REGEX","len","era","year","month","day","weekday","hour12","timeZoneName","stringTokens_1","WHITE_SPACE_REGEX","filter","stemAndOptions","stem","options_1","FRACTION_PRECISION_REGEX","SIGNIFICANT_PRECISION_REGEX","INTEGER_WIDTH_REGEX","CONCISE_INTEGER_WIDTH_REGEX","parseSignificantPrecision","str","roundingPriority","g1","g2","minimumSignificantDigits","maximumSignificantDigits","parseSign","signDisplay","currencySign","parseConciseScientificAndEngineeringStem","notation","minimumIntegerDigits","parseNotationOptions","opt","tokens_1","token","scale","currency","useGrouping","maximumFractionDigits","compactDisplay","currencyDisplay","unitDisplay","parseFloat","g3","g4","g5","minimumFractionDigits","trailingZeroDisplay","signOpts","conciseScientificAndEngineeringOpts","defaultConfig","configs","formatterCache","parts","PART_TYPE","ast","resolvedOptions","resolvedLocale","toString","getAst","resolveLocale","__parse","TypeError","c1","c2","defineProperty","memoizedDefaultLocale","enumerable","configurable","supportedLocales","Locale","integer","percent","short","medium","long","full","InvalidValueError","variableId","INVALID_VALUE","InvalidValueTypeError","MissingValueError","MISSING_VALUE","isFormatXMLElementFn","currentPluralValue","els_1","varName","object","value_1","formatFn","chunks","other","rule","lastPart","deselectCurrent","require","clipboardToIE11Formatting","module","exports","text","debug","reselectPrevious","range","selection","mark","success","document","createRange","getSelection","createElement","textContent","ariaHidden","top","clip","whiteSpace","webkitUserSelect","MozUserSelect","msUserSelect","userSelect","addEventListener","stopPropagation","preventDefault","clipboardData","console","warn","window","clearData","setData","onCopy","body","appendChild","selectNodeContents","addRange","execCommand","copyKey","navigator","userAgent","prompt","removeRange","removeAllRanges","removeChild","isMergeableObject","isNonNullObject","stringValue","$$typeof","REACT_ELEMENT_TYPE","isReactElement","isSpecial","Symbol","for","cloneUnlessOtherwiseSpecified","clone","deepmerge","defaultArrayMerge","target","element","arrayMerge","sourceIsArray","destination","mergeObject","array","prev","next","FormikContext","createContext","displayName","FormikProvider","Provider","useFormikContext","formik","useContext","Consumer","isEmptyArray","isFunction","isObject","isInteger","isString","isEmptyChildren","Children","count","isPromise","then","getIn","def","path","toPath","setIn","res","resVal","pathArray","currentPath","currentObj","nextPath","setNestedObjectValues","visited","response","WeakMap","_Object$keys","emptyErrors","emptyTouched","useFormik","_ref","validateOnChange","_ref$validateOnChange","validateOnBlur","_ref$validateOnBlur","validateOnMount","_ref$validateOnMount","isInitialValid","enableReinitialize","_ref$enableReinitiali","onSubmit","rest","_objectWithoutPropertiesLoose","_extends","initialValues","useRef","initialErrors","initialTouched","initialStatus","isMounted","fieldRegistry","useEffect","current","setIteration","useState","stateRef","errors","touched","status","isSubmitting","isValidating","submitCount","dispatch","useCallback","action","payload","isEqual","field","formikReducer","runValidateHandler","Promise","resolve","reject","maybePromisedErrors","validate","actualException","runValidationSchema","validationSchema","schema","promise","validateAt","sync","normalizedValues","prepareDataForValidation","abortEarly","validateYupSchema","yupError","inner","_iterator","_isArray","iterator","_ref5","done","yupToFormErrors","runSingleFieldLevelValidation","runFieldLevelValidations","fieldKeysWithValidation","fieldValidations","fieldErrorsList","curr","runAllValidations","_ref2","fieldErrors","schemaErrors","validateErrors","validateFormWithHighPriority","useEventCallback","combinedErrors","resetForm","nextState","dispatchFn","onReset","maybePromisedOnReset","imperativeMethods","validateField","maybePromise","registerField","_ref3","unregisterField","setTouched","shouldValidate","setErrors","setValues","resolvedValues","setFieldError","setFieldValue","executeChange","eventOrTextValue","maybePath","parsed","persist","currentTarget","checked","outerHTML","multiple","isNaN","currentValue","valueProp","Boolean","currentArrayOfValues","isValueInArray","getValueForCheckbox","selected","getSelectedValues","handleChange","eventOrPath","event","setFieldTouched","executeBlur","_e$target","handleBlur","eventOrString","setFormikState","stateOrCb","setStatus","setSubmitting","submitForm","isInstanceOfError","promiseOrUndefined","executeSubmit","_errors","handleSubmit","reason","validateForm","handleReset","getFieldMeta","initialValue","initialError","getFieldHelpers","setValue","setError","getFieldProps","nameOrOptions","isAnObject","valueState","onChange","onBlur","is","as","dirty","useMemo","isValid","Formik","formikbag","component","render","innerRef","useImperativeHandle","only","data","isPlainObject","shouldClone","useIsomorphicLayoutEffect","useLayoutEffect","ref","_len","_key","Field","className","meta","legacyBag","form","asElement","_innerRef","_rest","withFormik","mapPropsToValues","_ref$mapPropsToValues","vanillaProps","Component$1","componentDisplayName","constructor","_React$Component","actions","renderFormComponent","formikProps","mapPropsToStatus","mapPropsToErrors","mapPropsToTouched","Component","hoistNonReactStatics","forwardRef","_action","_useFormikContext","insert","arrayLike","copy","copyArrayLike","splice","maxIndex","parseInt","max","createAlterationHandler","alteration","defaultFunction","FieldArrayInner","updateArrayField","alterTouched","alterErrors","_this$props","prevState","updateErrors","updateTouched","fieldError","fieldTouched","cloneDeep","handlePush","swap","indexA","indexB","handleSwap","move","handleMove","handleInsert","handleReplace","unshift","arr","handleUnshift","handleRemove","remove","handlePop","pop","_assertThisInitialized","componentDidUpdate","prevProps","every","tmp","arrayHelpers","_this$props2","defaultProps"],"sourceRoot":""}