{"version":3,"sources":["jsdelivr-header.js","/npm/openapi-comment-parser@1.0.0/dist/openapi-comment-parser.js"],"names":[],"mappings":"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,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,IAAI,EAAE,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,IAAI,GAAG,IAAI,EAAE,GAAG,IAAI,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK,KAAK,IAAI,KAAK,IAAI,EAAE,GAAG,IAAI,GAAG,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,GAAG,EAAE,EAAE,GAAG,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,KAAK,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,GAAG,EAAE,GAAG,EAAE,EAAE,IAAI,KAAK,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,KAAK,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,KAAK,GAAG,GAAG,EAAE,GAAG,EAAE,IAAI,GAAG,KAAK,IAAI,GAAG,GAAG,EAAE,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,KAAK,MAAM,GAAG,KAAK,GAAG,IAAI,EAAE,KAAK,GAAG,KAAK,KAAK,IAAI,KAAK,MAGpyC,sBAAwB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,GAAG,EAAE,EAAE,IAAI,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,IAAI,GAAG,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,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CA,mBACA,KACA,iBACA,KACA,QACA,iBACA,KACA,oBACA,KACA,SACA,KACA,sBACA,KACA,SACA,IACA,gBACA,KACA,iBACA,KACA,mBACA,KACA,OACA,IACA,iBACA,cACA,KACA,kBACA,KACA,kBACA,KACA,kBACA,KACA,SACA,IACA,mBACA,KACA,QACA,IACA,eACA,KACA,eACA,KACA,oBACA,KACA,eACA,KACA,sBACA,KACA,cACA,KACA,cACA,IACA,QACA,YACA,IACA,kBACA,KACA,eACA,KACA,YACA,KACA,SACA,IACA,mBACA,KACA,aACA,KACA,mBACA,OAEJ,OAAQ,IAAI,IAAI,CACZ,QACA,OACA,OACA,wBACA,OACA,SACA,OACA,WACA,OACA,UACA,OACA,WACA,OACA,QACA,OACA,YACA,OACA,QACA,OACA,UACA,OACA,YACA,OACA,WACA,OACA,SACA,OACA,UACA,OACA,WACA,OACA,QACA,OACA,sBACA,OACA,SACA,OACA,qBACA,OACA,SACA,OACA,OACA,WACA,OACA,SACA,OACA,SACA,OACA,OACA,YACA,OACA,UACA,OACA,WACA,OACA,UACA,OACA,aACA,OACA,WACA,OACA,uBACA,OACA,UACA,OACA,WACA,OACA,WACA,OACA,aACA,OACA,SACA,OACA,UACA,OACA,QACA,OACA,WACA,OACA,WACA,OACA,MACA,OACA,SACA,OACA,UACA,OACA,SACA,OACA,SACA,OACA,WACA,OACA,mBACA,OACA,YACA,OACA,OACA,wBACA,OACA,yBACA,OACA,WACA,OACA,SACA,OACA,UACA,OACA,WACA,OACA,WACA,OACA,aACA,OACA,QACA,OACA,SACA,OACA,YACA,OACA,MACA,OACA,QACA,OACA,SACA,OACA,QACA,OACA,WACA,OACA,WACA,OACA,OACA,SACA,OACA,SACA,OACA,WACA,OACA,YACA,OACA,UACA,OACA,aACA,OACA,UACA,OACA,gBACA,OACA,eACA,OACA,gBACA,OACA,mBACA,OACA,uBACA,OACA,OACA,OACA,OACA,YACA,OACA,MACA,OACA,UACA,OACA,UACA,OACA,YACA,OACA,cACA,OACA,OACA,MACA,OACA,QACA,OACA,QACA,OACA,WACA,OACA,gBACA,OACA,aACA,OACA,oBACA,OACA,aACA,OACA,cACA,OACA,oBACA,OACA,aACA,OACA,QACA,OACA,QACA,OACA,UACA,OACA,eACA,OACA,YACA,OACA,cACA,OACA,WACA,OACA,aACA,OACA,kBACA,OACA,SACA,OACA,QACA,OACA,YACA,OACA,aACA,OACA,UACA,OACA,UACA,OACA,UACA,OACA,cACA,OACA,UACA,OACA,eACA,OACA,UACA,OACA,YACA,OACA,eACA,OACA,SACA,OACA,UACA,OACA,WACA,OACA,SACA,OACA,WACA,OACA,WACA,OACA,QACA,OACA,QACA,OACA,SACA,OACA,SACA,OACA,SACA,OACA,OACA,UACA,OACA,WACA,OACA,UACA,OACA,WACA,OACA,MACA,OACA,cACA,OACA,KACA,OACA,mBACA,UAGR,aAAa,GAAK,aAAa,iBAC/B,aAAa,GAAK,aAAa,kBAAoB,aAAa,IAC5D,aAAa,OAEjB,MAAM,UAAY,EACZ,oBAAsB,EACtB,SAAW,GACX,eAAiB,GACjB,SAAW,GACX,eAAiB,GACjB,gBAAkB,GAClB,WAAa,GACb,gBAAkB,GAClB,iBAAmB,GACnB,SAAW,GACX,SAAW,GACX,MAAQ,GACR,YAAc,GACd,SAAW,GACX,QAAU,GACV,UAAY,GACZ,SAAW,GACX,WAAa,GACb,UAAY,GACZ,MAAQ,GACR,aAAe,GACf,WAAa,GACb,gBAAkB,GAClB,aAAe,GACf,oBAAsB,GACtB,oBAAsB,GACtB,oBAAsB,GACtB,oBAAsB,GACtB,oBAAsB,GACtB,oBAAsB,GACtB,oBAAsB,GACtB,oBAAsB,GACtB,QAAU,GACV,kBAAoB,GACpB,kBAAoB,GACpB,kBAAoB,GACpB,kBAAoB,IACpB,kBAAoB,IACpB,kBAAoB,IACpB,kBAAoB,IACpB,kBAAoB,IACpB,kBAAoB,IACpB,kBAAoB,IACpB,kBAAoB,IACpB,kBAAoB,IACp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KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,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","file":"/npm/openapi-comment-parser@1.0.0/dist/openapi-comment-parser.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/openapi-comment-parser@1.0.0/dist/openapi-comment-parser.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","'use strict';\n\nfunction _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }\n\nvar path$1 = _interopDefault(require('path'));\nvar os = _interopDefault(require('os'));\nvar tty = _interopDefault(require('tty'));\nvar fs$2 = _interopDefault(require('fs'));\nvar module$1 = _interopDefault(require('module'));\nvar assert = _interopDefault(require('assert'));\nvar util$2 = _interopDefault(require('util'));\nvar crypto = _interopDefault(require('crypto'));\nvar events = _interopDefault(require('events'));\nvar stream$4 = _interopDefault(require('stream'));\n\nfunction isNothing(subject) {\n  return (typeof subject === 'undefined') || (subject === null);\n}\n\n\nfunction isObject(subject) {\n  return (typeof subject === 'object') && (subject !== null);\n}\n\n\nfunction toArray(sequence) {\n  if (Array.isArray(sequence)) return sequence;\n  else if (isNothing(sequence)) return [];\n\n  return [ sequence ];\n}\n\n\nfunction extend(target, source) {\n  var index, length, key, sourceKeys;\n\n  if (source) {\n    sourceKeys = Object.keys(source);\n\n    for (index = 0, length = sourceKeys.length; index < length; index += 1) {\n      key = sourceKeys[index];\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n\n\nfunction repeat(string, count) {\n  var result = '', cycle;\n\n  for (cycle = 0; cycle < count; cycle += 1) {\n    result += string;\n  }\n\n  return result;\n}\n\n\nfunction isNegativeZero(number) {\n  return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);\n}\n\n\nvar isNothing_1      = isNothing;\nvar isObject_1       = isObject;\nvar toArray_1        = toArray;\nvar repeat_1         = repeat;\nvar isNegativeZero_1 = isNegativeZero;\nvar extend_1         = extend;\n\nvar common = {\n\tisNothing: isNothing_1,\n\tisObject: isObject_1,\n\ttoArray: toArray_1,\n\trepeat: repeat_1,\n\tisNegativeZero: isNegativeZero_1,\n\textend: extend_1\n};\n\n// YAML error class. http://stackoverflow.com/questions/8458984\n\nfunction YAMLException(reason, mark) {\n  // Super constructor\n  Error.call(this);\n\n  this.name = 'YAMLException';\n  this.reason = reason;\n  this.mark = mark;\n  this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : '');\n\n  // Include stack trace in error object\n  if (Error.captureStackTrace) {\n    // Chrome and NodeJS\n    Error.captureStackTrace(this, this.constructor);\n  } else {\n    // FF, IE 10+ and Safari 6+. Fallback for others\n    this.stack = (new Error()).stack || '';\n  }\n}\n\n\n// Inherit from Error\nYAMLException.prototype = Object.create(Error.prototype);\nYAMLException.prototype.constructor = YAMLException;\n\n\nYAMLException.prototype.toString = function toString(compact) {\n  var result = this.name + ': ';\n\n  result += this.reason || '(unknown reason)';\n\n  if (!compact && this.mark) {\n    result += ' ' + this.mark.toString();\n  }\n\n  return result;\n};\n\n\nvar exception = YAMLException;\n\nfunction Mark(name, buffer, position, line, column) {\n  this.name     = name;\n  this.buffer   = buffer;\n  this.position = position;\n  this.line     = line;\n  this.column   = column;\n}\n\n\nMark.prototype.getSnippet = function getSnippet(indent, maxLength) {\n  var head, start, tail, end, snippet;\n\n  if (!this.buffer) return null;\n\n  indent = indent || 4;\n  maxLength = maxLength || 75;\n\n  head = '';\n  start = this.position;\n\n  while (start > 0 && '\\x00\\r\\n\\x85\\u2028\\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) {\n    start -= 1;\n    if (this.position - start > (maxLength / 2 - 1)) {\n      head = ' ... ';\n      start += 5;\n      break;\n    }\n  }\n\n  tail = '';\n  end = this.position;\n\n  while (end < this.buffer.length && '\\x00\\r\\n\\x85\\u2028\\u2029'.indexOf(this.buffer.charAt(end)) === -1) {\n    end += 1;\n    if (end - this.position > (maxLength / 2 - 1)) {\n      tail = ' ... ';\n      end -= 5;\n      break;\n    }\n  }\n\n  snippet = this.buffer.slice(start, end);\n\n  return common.repeat(' ', indent) + head + snippet + tail + '\\n' +\n         common.repeat(' ', indent + this.position - start + head.length) + '^';\n};\n\n\nMark.prototype.toString = function toString(compact) {\n  var snippet, where = '';\n\n  if (this.name) {\n    where += 'in \"' + this.name + '\" ';\n  }\n\n  where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1);\n\n  if (!compact) {\n    snippet = this.getSnippet();\n\n    if (snippet) {\n      where += ':\\n' + snippet;\n    }\n  }\n\n  return where;\n};\n\n\nvar mark = Mark;\n\nvar TYPE_CONSTRUCTOR_OPTIONS = [\n  'kind',\n  'resolve',\n  'construct',\n  'instanceOf',\n  'predicate',\n  'represent',\n  'defaultStyle',\n  'styleAliases'\n];\n\nvar YAML_NODE_KINDS = [\n  'scalar',\n  'sequence',\n  'mapping'\n];\n\nfunction compileStyleAliases(map) {\n  var result = {};\n\n  if (map !== null) {\n    Object.keys(map).forEach(function (style) {\n      map[style].forEach(function (alias) {\n        result[String(alias)] = style;\n      });\n    });\n  }\n\n  return result;\n}\n\nfunction Type(tag, options) {\n  options = options || {};\n\n  Object.keys(options).forEach(function (name) {\n    if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {\n      throw new exception('Unknown option \"' + name + '\" is met in definition of \"' + tag + '\" YAML type.');\n    }\n  });\n\n  // TODO: Add tag format check.\n  this.tag          = tag;\n  this.kind         = options['kind']         || null;\n  this.resolve      = options['resolve']      || function () { return true; };\n  this.construct    = options['construct']    || function (data) { return data; };\n  this.instanceOf   = options['instanceOf']   || null;\n  this.predicate    = options['predicate']    || null;\n  this.represent    = options['represent']    || null;\n  this.defaultStyle = options['defaultStyle'] || null;\n  this.styleAliases = compileStyleAliases(options['styleAliases'] || null);\n\n  if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {\n    throw new exception('Unknown kind \"' + this.kind + '\" is specified for \"' + tag + '\" YAML type.');\n  }\n}\n\nvar type = Type;\n\n/*eslint-disable max-len*/\n\n\n\n\n\n\nfunction compileList(schema, name, result) {\n  var exclude = [];\n\n  schema.include.forEach(function (includedSchema) {\n    result = compileList(includedSchema, name, result);\n  });\n\n  schema[name].forEach(function (currentType) {\n    result.forEach(function (previousType, previousIndex) {\n      if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {\n        exclude.push(previousIndex);\n      }\n    });\n\n    result.push(currentType);\n  });\n\n  return result.filter(function (type, index) {\n    return exclude.indexOf(index) === -1;\n  });\n}\n\n\nfunction compileMap(/* lists... */) {\n  var result = {\n        scalar: {},\n        sequence: {},\n        mapping: {},\n        fallback: {}\n      }, index, length;\n\n  function collectType(type) {\n    result[type.kind][type.tag] = result['fallback'][type.tag] = type;\n  }\n\n  for (index = 0, length = arguments.length; index < length; index += 1) {\n    arguments[index].forEach(collectType);\n  }\n  return result;\n}\n\n\nfunction Schema(definition) {\n  this.include  = definition.include  || [];\n  this.implicit = definition.implicit || [];\n  this.explicit = definition.explicit || [];\n\n  this.implicit.forEach(function (type) {\n    if (type.loadKind && type.loadKind !== 'scalar') {\n      throw new exception('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');\n    }\n  });\n\n  this.compiledImplicit = compileList(this, 'implicit', []);\n  this.compiledExplicit = compileList(this, 'explicit', []);\n  this.compiledTypeMap  = compileMap(this.compiledImplicit, this.compiledExplicit);\n}\n\n\nSchema.DEFAULT = null;\n\n\nSchema.create = function createSchema() {\n  var schemas, types;\n\n  switch (arguments.length) {\n    case 1:\n      schemas = Schema.DEFAULT;\n      types = arguments[0];\n      break;\n\n    case 2:\n      schemas = arguments[0];\n      types = arguments[1];\n      break;\n\n    default:\n      throw new exception('Wrong number of arguments for Schema.create function');\n  }\n\n  schemas = common.toArray(schemas);\n  types = common.toArray(types);\n\n  if (!schemas.every(function (schema) { return schema instanceof Schema; })) {\n    throw new exception('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');\n  }\n\n  if (!types.every(function (type$1) { return type$1 instanceof type; })) {\n    throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type object.');\n  }\n\n  return new Schema({\n    include: schemas,\n    explicit: types\n  });\n};\n\n\nvar schema = Schema;\n\nvar str = new type('tag:yaml.org,2002:str', {\n  kind: 'scalar',\n  construct: function (data) { return data !== null ? data : ''; }\n});\n\nvar seq = new type('tag:yaml.org,2002:seq', {\n  kind: 'sequence',\n  construct: function (data) { return data !== null ? data : []; }\n});\n\nvar map = new type('tag:yaml.org,2002:map', {\n  kind: 'mapping',\n  construct: function (data) { return data !== null ? data : {}; }\n});\n\nvar failsafe = new schema({\n  explicit: [\n    str,\n    seq,\n    map\n  ]\n});\n\nfunction resolveYamlNull(data) {\n  if (data === null) return true;\n\n  var max = data.length;\n\n  return (max === 1 && data === '~') ||\n         (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));\n}\n\nfunction constructYamlNull() {\n  return null;\n}\n\nfunction isNull(object) {\n  return object === null;\n}\n\nvar _null = new type('tag:yaml.org,2002:null', {\n  kind: 'scalar',\n  resolve: resolveYamlNull,\n  construct: constructYamlNull,\n  predicate: isNull,\n  represent: {\n    canonical: function () { return '~';    },\n    lowercase: function () { return 'null'; },\n    uppercase: function () { return 'NULL'; },\n    camelcase: function () { return 'Null'; }\n  },\n  defaultStyle: 'lowercase'\n});\n\nfunction resolveYamlBoolean(data) {\n  if (data === null) return false;\n\n  var max = data.length;\n\n  return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||\n         (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));\n}\n\nfunction constructYamlBoolean(data) {\n  return data === 'true' ||\n         data === 'True' ||\n         data === 'TRUE';\n}\n\nfunction isBoolean(object) {\n  return Object.prototype.toString.call(object) === '[object Boolean]';\n}\n\nvar bool = new type('tag:yaml.org,2002:bool', {\n  kind: 'scalar',\n  resolve: resolveYamlBoolean,\n  construct: constructYamlBoolean,\n  predicate: isBoolean,\n  represent: {\n    lowercase: function (object) { return object ? 'true' : 'false'; },\n    uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },\n    camelcase: function (object) { return object ? 'True' : 'False'; }\n  },\n  defaultStyle: 'lowercase'\n});\n\nfunction isHexCode(c) {\n  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) ||\n         ((0x41/* A */ <= c) && (c <= 0x46/* F */)) ||\n         ((0x61/* a */ <= c) && (c <= 0x66/* f */));\n}\n\nfunction isOctCode(c) {\n  return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */));\n}\n\nfunction isDecCode(c) {\n  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */));\n}\n\nfunction resolveYamlInteger(data) {\n  if (data === null) return false;\n\n  var max = data.length,\n      index = 0,\n      hasDigits = false,\n      ch;\n\n  if (!max) return false;\n\n  ch = data[index];\n\n  // sign\n  if (ch === '-' || ch === '+') {\n    ch = data[++index];\n  }\n\n  if (ch === '0') {\n    // 0\n    if (index + 1 === max) return true;\n    ch = data[++index];\n\n    // base 2, base 8, base 16\n\n    if (ch === 'b') {\n      // base 2\n      index++;\n\n      for (; index < max; index++) {\n        ch = data[index];\n        if (ch === '_') continue;\n        if (ch !== '0' && ch !== '1') return false;\n        hasDigits = true;\n      }\n      return hasDigits && ch !== '_';\n    }\n\n\n    if (ch === 'x') {\n      // base 16\n      index++;\n\n      for (; index < max; index++) {\n        ch = data[index];\n        if (ch === '_') continue;\n        if (!isHexCode(data.charCodeAt(index))) return false;\n        hasDigits = true;\n      }\n      return hasDigits && ch !== '_';\n    }\n\n    // base 8\n    for (; index < max; index++) {\n      ch = data[index];\n      if (ch === '_') continue;\n      if (!isOctCode(data.charCodeAt(index))) return false;\n      hasDigits = true;\n    }\n    return hasDigits && ch !== '_';\n  }\n\n  // base 10 (except 0) or base 60\n\n  // value should not start with `_`;\n  if (ch === '_') return false;\n\n  for (; index < max; index++) {\n    ch = data[index];\n    if (ch === '_') continue;\n    if (ch === ':') break;\n    if (!isDecCode(data.charCodeAt(index))) {\n      return false;\n    }\n    hasDigits = true;\n  }\n\n  // Should have digits and should not end with `_`\n  if (!hasDigits || ch === '_') return false;\n\n  // if !base60 - done;\n  if (ch !== ':') return true;\n\n  // base60 almost not used, no needs to optimize\n  return /^(:[0-5]?[0-9])+$/.test(data.slice(index));\n}\n\nfunction constructYamlInteger(data) {\n  var value = data, sign = 1, ch, base, digits = [];\n\n  if (value.indexOf('_') !== -1) {\n    value = value.replace(/_/g, '');\n  }\n\n  ch = value[0];\n\n  if (ch === '-' || ch === '+') {\n    if (ch === '-') sign = -1;\n    value = value.slice(1);\n    ch = value[0];\n  }\n\n  if (value === '0') return 0;\n\n  if (ch === '0') {\n    if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);\n    if (value[1] === 'x') return sign * parseInt(value, 16);\n    return sign * parseInt(value, 8);\n  }\n\n  if (value.indexOf(':') !== -1) {\n    value.split(':').forEach(function (v) {\n      digits.unshift(parseInt(v, 10));\n    });\n\n    value = 0;\n    base = 1;\n\n    digits.forEach(function (d) {\n      value += (d * base);\n      base *= 60;\n    });\n\n    return sign * value;\n\n  }\n\n  return sign * parseInt(value, 10);\n}\n\nfunction isInteger(object) {\n  return (Object.prototype.toString.call(object)) === '[object Number]' &&\n         (object % 1 === 0 && !common.isNegativeZero(object));\n}\n\nvar int_1 = new type('tag:yaml.org,2002:int', {\n  kind: 'scalar',\n  resolve: resolveYamlInteger,\n  construct: constructYamlInteger,\n  predicate: isInteger,\n  represent: {\n    binary:      function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); },\n    octal:       function (obj) { return obj >= 0 ? '0'  + obj.toString(8) : '-0'  + obj.toString(8).slice(1); },\n    decimal:     function (obj) { return obj.toString(10); },\n    /* eslint-disable max-len */\n    hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() :  '-0x' + obj.toString(16).toUpperCase().slice(1); }\n  },\n  defaultStyle: 'decimal',\n  styleAliases: {\n    binary:      [ 2,  'bin' ],\n    octal:       [ 8,  'oct' ],\n    decimal:     [ 10, 'dec' ],\n    hexadecimal: [ 16, 'hex' ]\n  }\n});\n\nvar YAML_FLOAT_PATTERN = new RegExp(\n  // 2.5e4, 2.5 and integers\n  '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +\n  // .2e4, .2\n  // special case, seems not from spec\n  '|\\\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +\n  // 20:59\n  '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\\\.[0-9_]*' +\n  // .inf\n  '|[-+]?\\\\.(?:inf|Inf|INF)' +\n  // .nan\n  '|\\\\.(?:nan|NaN|NAN))$');\n\nfunction resolveYamlFloat(data) {\n  if (data === null) return false;\n\n  if (!YAML_FLOAT_PATTERN.test(data) ||\n      // Quick hack to not allow integers end with `_`\n      // Probably should update regexp & check speed\n      data[data.length - 1] === '_') {\n    return false;\n  }\n\n  return true;\n}\n\nfunction constructYamlFloat(data) {\n  var value, sign, base, digits;\n\n  value  = data.replace(/_/g, '').toLowerCase();\n  sign   = value[0] === '-' ? -1 : 1;\n  digits = [];\n\n  if ('+-'.indexOf(value[0]) >= 0) {\n    value = value.slice(1);\n  }\n\n  if (value === '.inf') {\n    return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;\n\n  } else if (value === '.nan') {\n    return NaN;\n\n  } else if (value.indexOf(':') >= 0) {\n    value.split(':').forEach(function (v) {\n      digits.unshift(parseFloat(v, 10));\n    });\n\n    value = 0.0;\n    base = 1;\n\n    digits.forEach(function (d) {\n      value += d * base;\n      base *= 60;\n    });\n\n    return sign * value;\n\n  }\n  return sign * parseFloat(value, 10);\n}\n\n\nvar SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;\n\nfunction representYamlFloat(object, style) {\n  var res;\n\n  if (isNaN(object)) {\n    switch (style) {\n      case 'lowercase': return '.nan';\n      case 'uppercase': return '.NAN';\n      case 'camelcase': return '.NaN';\n    }\n  } else if (Number.POSITIVE_INFINITY === object) {\n    switch (style) {\n      case 'lowercase': return '.inf';\n      case 'uppercase': return '.INF';\n      case 'camelcase': return '.Inf';\n    }\n  } else if (Number.NEGATIVE_INFINITY === object) {\n    switch (style) {\n      case 'lowercase': return '-.inf';\n      case 'uppercase': return '-.INF';\n      case 'camelcase': return '-.Inf';\n    }\n  } else if (common.isNegativeZero(object)) {\n    return '-0.0';\n  }\n\n  res = object.toString(10);\n\n  // JS stringifier can build scientific format without dots: 5e-100,\n  // while YAML requres dot: 5.e-100. Fix it with simple hack\n\n  return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;\n}\n\nfunction isFloat(object) {\n  return (Object.prototype.toString.call(object) === '[object Number]') &&\n         (object % 1 !== 0 || common.isNegativeZero(object));\n}\n\nvar float_1 = new type('tag:yaml.org,2002:float', {\n  kind: 'scalar',\n  resolve: resolveYamlFloat,\n  construct: constructYamlFloat,\n  predicate: isFloat,\n  represent: representYamlFloat,\n  defaultStyle: 'lowercase'\n});\n\nvar json = new schema({\n  include: [\n    failsafe\n  ],\n  implicit: [\n    _null,\n    bool,\n    int_1,\n    float_1\n  ]\n});\n\nvar core = new schema({\n  include: [\n    json\n  ]\n});\n\nvar YAML_DATE_REGEXP = new RegExp(\n  '^([0-9][0-9][0-9][0-9])'          + // [1] year\n  '-([0-9][0-9])'                    + // [2] month\n  '-([0-9][0-9])$');                   // [3] day\n\nvar YAML_TIMESTAMP_REGEXP = new RegExp(\n  '^([0-9][0-9][0-9][0-9])'          + // [1] year\n  '-([0-9][0-9]?)'                   + // [2] month\n  '-([0-9][0-9]?)'                   + // [3] day\n  '(?:[Tt]|[ \\\\t]+)'                 + // ...\n  '([0-9][0-9]?)'                    + // [4] hour\n  ':([0-9][0-9])'                    + // [5] minute\n  ':([0-9][0-9])'                    + // [6] second\n  '(?:\\\\.([0-9]*))?'                 + // [7] fraction\n  '(?:[ \\\\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour\n  '(?::([0-9][0-9]))?))?$');           // [11] tz_minute\n\nfunction resolveYamlTimestamp(data) {\n  if (data === null) return false;\n  if (YAML_DATE_REGEXP.exec(data) !== null) return true;\n  if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;\n  return false;\n}\n\nfunction constructYamlTimestamp(data) {\n  var match, year, month, day, hour, minute, second, fraction = 0,\n      delta = null, tz_hour, tz_minute, date;\n\n  match = YAML_DATE_REGEXP.exec(data);\n  if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);\n\n  if (match === null) throw new Error('Date resolve error');\n\n  // match: [1] year [2] month [3] day\n\n  year = +(match[1]);\n  month = +(match[2]) - 1; // JS month starts with 0\n  day = +(match[3]);\n\n  if (!match[4]) { // no hour\n    return new Date(Date.UTC(year, month, day));\n  }\n\n  // match: [4] hour [5] minute [6] second [7] fraction\n\n  hour = +(match[4]);\n  minute = +(match[5]);\n  second = +(match[6]);\n\n  if (match[7]) {\n    fraction = match[7].slice(0, 3);\n    while (fraction.length < 3) { // milli-seconds\n      fraction += '0';\n    }\n    fraction = +fraction;\n  }\n\n  // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute\n\n  if (match[9]) {\n    tz_hour = +(match[10]);\n    tz_minute = +(match[11] || 0);\n    delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds\n    if (match[9] === '-') delta = -delta;\n  }\n\n  date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));\n\n  if (delta) date.setTime(date.getTime() - delta);\n\n  return date;\n}\n\nfunction representYamlTimestamp(object /*, style*/) {\n  return object.toISOString();\n}\n\nvar timestamp = new type('tag:yaml.org,2002:timestamp', {\n  kind: 'scalar',\n  resolve: resolveYamlTimestamp,\n  construct: constructYamlTimestamp,\n  instanceOf: Date,\n  represent: representYamlTimestamp\n});\n\nfunction resolveYamlMerge(data) {\n  return data === '<<' || data === null;\n}\n\nvar merge = new type('tag:yaml.org,2002:merge', {\n  kind: 'scalar',\n  resolve: resolveYamlMerge\n});\n\nfunction unwrapExports (x) {\n\treturn x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;\n}\n\nfunction createCommonjsModule(fn, module) {\n\treturn module = { exports: {} }, fn(module, module.exports), module.exports;\n}\n\nfunction getCjsExportFromNamespace (n) {\n\treturn n && n['default'] || n;\n}\n\nfunction commonjsRequire () {\n\tthrow new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');\n}\n\n/*eslint-disable no-bitwise*/\n\nvar NodeBuffer;\n\ntry {\n  // A trick for browserified version, to not include `Buffer` shim\n  var _require = commonjsRequire;\n  NodeBuffer = _require('buffer').Buffer;\n} catch (__) {}\n\n\n\n\n// [ 64, 65, 66 ] -> [ padding, CR, LF ]\nvar BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\\n\\r';\n\n\nfunction resolveYamlBinary(data) {\n  if (data === null) return false;\n\n  var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;\n\n  // Convert one by one.\n  for (idx = 0; idx < max; idx++) {\n    code = map.indexOf(data.charAt(idx));\n\n    // Skip CR/LF\n    if (code > 64) continue;\n\n    // Fail on illegal characters\n    if (code < 0) return false;\n\n    bitlen += 6;\n  }\n\n  // If there are any bits left, source was corrupted\n  return (bitlen % 8) === 0;\n}\n\nfunction constructYamlBinary(data) {\n  var idx, tailbits,\n      input = data.replace(/[\\r\\n=]/g, ''), // remove CR/LF & padding to simplify scan\n      max = input.length,\n      map = BASE64_MAP,\n      bits = 0,\n      result = [];\n\n  // Collect by 6*4 bits (3 bytes)\n\n  for (idx = 0; idx < max; idx++) {\n    if ((idx % 4 === 0) && idx) {\n      result.push((bits >> 16) & 0xFF);\n      result.push((bits >> 8) & 0xFF);\n      result.push(bits & 0xFF);\n    }\n\n    bits = (bits << 6) | map.indexOf(input.charAt(idx));\n  }\n\n  // Dump tail\n\n  tailbits = (max % 4) * 6;\n\n  if (tailbits === 0) {\n    result.push((bits >> 16) & 0xFF);\n    result.push((bits >> 8) & 0xFF);\n    result.push(bits & 0xFF);\n  } else if (tailbits === 18) {\n    result.push((bits >> 10) & 0xFF);\n    result.push((bits >> 2) & 0xFF);\n  } else if (tailbits === 12) {\n    result.push((bits >> 4) & 0xFF);\n  }\n\n  // Wrap into Buffer for NodeJS and leave Array for browser\n  if (NodeBuffer) {\n    // Support node 6.+ Buffer API when available\n    return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result);\n  }\n\n  return result;\n}\n\nfunction representYamlBinary(object /*, style*/) {\n  var result = '', bits = 0, idx, tail,\n      max = object.length,\n      map = BASE64_MAP;\n\n  // Convert every three bytes to 4 ASCII characters.\n\n  for (idx = 0; idx < max; idx++) {\n    if ((idx % 3 === 0) && idx) {\n      result += map[(bits >> 18) & 0x3F];\n      result += map[(bits >> 12) & 0x3F];\n      result += map[(bits >> 6) & 0x3F];\n      result += map[bits & 0x3F];\n    }\n\n    bits = (bits << 8) + object[idx];\n  }\n\n  // Dump tail\n\n  tail = max % 3;\n\n  if (tail === 0) {\n    result += map[(bits >> 18) & 0x3F];\n    result += map[(bits >> 12) & 0x3F];\n    result += map[(bits >> 6) & 0x3F];\n    result += map[bits & 0x3F];\n  } else if (tail === 2) {\n    result += map[(bits >> 10) & 0x3F];\n    result += map[(bits >> 4) & 0x3F];\n    result += map[(bits << 2) & 0x3F];\n    result += map[64];\n  } else if (tail === 1) {\n    result += map[(bits >> 2) & 0x3F];\n    result += map[(bits << 4) & 0x3F];\n    result += map[64];\n    result += map[64];\n  }\n\n  return result;\n}\n\nfunction isBinary(object) {\n  return NodeBuffer && NodeBuffer.isBuffer(object);\n}\n\nvar binary = new type('tag:yaml.org,2002:binary', {\n  kind: 'scalar',\n  resolve: resolveYamlBinary,\n  construct: constructYamlBinary,\n  predicate: isBinary,\n  represent: representYamlBinary\n});\n\nvar _hasOwnProperty = Object.prototype.hasOwnProperty;\nvar _toString       = Object.prototype.toString;\n\nfunction resolveYamlOmap(data) {\n  if (data === null) return true;\n\n  var objectKeys = [], index, length, pair, pairKey, pairHasKey,\n      object = data;\n\n  for (index = 0, length = object.length; index < length; index += 1) {\n    pair = object[index];\n    pairHasKey = false;\n\n    if (_toString.call(pair) !== '[object Object]') return false;\n\n    for (pairKey in pair) {\n      if (_hasOwnProperty.call(pair, pairKey)) {\n        if (!pairHasKey) pairHasKey = true;\n        else return false;\n      }\n    }\n\n    if (!pairHasKey) return false;\n\n    if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);\n    else return false;\n  }\n\n  return true;\n}\n\nfunction constructYamlOmap(data) {\n  return data !== null ? data : [];\n}\n\nvar omap = new type('tag:yaml.org,2002:omap', {\n  kind: 'sequence',\n  resolve: resolveYamlOmap,\n  construct: constructYamlOmap\n});\n\nvar _toString$1 = Object.prototype.toString;\n\nfunction resolveYamlPairs(data) {\n  if (data === null) return true;\n\n  var index, length, pair, keys, result,\n      object = data;\n\n  result = new Array(object.length);\n\n  for (index = 0, length = object.length; index < length; index += 1) {\n    pair = object[index];\n\n    if (_toString$1.call(pair) !== '[object Object]') return false;\n\n    keys = Object.keys(pair);\n\n    if (keys.length !== 1) return false;\n\n    result[index] = [ keys[0], pair[keys[0]] ];\n  }\n\n  return true;\n}\n\nfunction constructYamlPairs(data) {\n  if (data === null) return [];\n\n  var index, length, pair, keys, result,\n      object = data;\n\n  result = new Array(object.length);\n\n  for (index = 0, length = object.length; index < length; index += 1) {\n    pair = object[index];\n\n    keys = Object.keys(pair);\n\n    result[index] = [ keys[0], pair[keys[0]] ];\n  }\n\n  return result;\n}\n\nvar pairs = new type('tag:yaml.org,2002:pairs', {\n  kind: 'sequence',\n  resolve: resolveYamlPairs,\n  construct: constructYamlPairs\n});\n\nvar _hasOwnProperty$1 = Object.prototype.hasOwnProperty;\n\nfunction resolveYamlSet(data) {\n  if (data === null) return true;\n\n  var key, object = data;\n\n  for (key in object) {\n    if (_hasOwnProperty$1.call(object, key)) {\n      if (object[key] !== null) return false;\n    }\n  }\n\n  return true;\n}\n\nfunction constructYamlSet(data) {\n  return data !== null ? data : {};\n}\n\nvar set = new type('tag:yaml.org,2002:set', {\n  kind: 'mapping',\n  resolve: resolveYamlSet,\n  construct: constructYamlSet\n});\n\nvar default_safe = new schema({\n  include: [\n    core\n  ],\n  implicit: [\n    timestamp,\n    merge\n  ],\n  explicit: [\n    binary,\n    omap,\n    pairs,\n    set\n  ]\n});\n\nfunction resolveJavascriptUndefined() {\n  return true;\n}\n\nfunction constructJavascriptUndefined() {\n  /*eslint-disable no-undefined*/\n  return undefined;\n}\n\nfunction representJavascriptUndefined() {\n  return '';\n}\n\nfunction isUndefined(object) {\n  return typeof object === 'undefined';\n}\n\nvar _undefined = new type('tag:yaml.org,2002:js/undefined', {\n  kind: 'scalar',\n  resolve: resolveJavascriptUndefined,\n  construct: constructJavascriptUndefined,\n  predicate: isUndefined,\n  represent: representJavascriptUndefined\n});\n\nfunction resolveJavascriptRegExp(data) {\n  if (data === null) return false;\n  if (data.length === 0) return false;\n\n  var regexp = data,\n      tail   = /\\/([gim]*)$/.exec(data),\n      modifiers = '';\n\n  // if regexp starts with '/' it can have modifiers and must be properly closed\n  // `/foo/gim` - modifiers tail can be maximum 3 chars\n  if (regexp[0] === '/') {\n    if (tail) modifiers = tail[1];\n\n    if (modifiers.length > 3) return false;\n    // if expression starts with /, is should be properly terminated\n    if (regexp[regexp.length - modifiers.length - 1] !== '/') return false;\n  }\n\n  return true;\n}\n\nfunction constructJavascriptRegExp(data) {\n  var regexp = data,\n      tail   = /\\/([gim]*)$/.exec(data),\n      modifiers = '';\n\n  // `/foo/gim` - tail can be maximum 4 chars\n  if (regexp[0] === '/') {\n    if (tail) modifiers = tail[1];\n    regexp = regexp.slice(1, regexp.length - modifiers.length - 1);\n  }\n\n  return new RegExp(regexp, modifiers);\n}\n\nfunction representJavascriptRegExp(object /*, style*/) {\n  var result = '/' + object.source + '/';\n\n  if (object.global) result += 'g';\n  if (object.multiline) result += 'm';\n  if (object.ignoreCase) result += 'i';\n\n  return result;\n}\n\nfunction isRegExp(object) {\n  return Object.prototype.toString.call(object) === '[object RegExp]';\n}\n\nvar regexp = new type('tag:yaml.org,2002:js/regexp', {\n  kind: 'scalar',\n  resolve: resolveJavascriptRegExp,\n  construct: constructJavascriptRegExp,\n  predicate: isRegExp,\n  represent: representJavascriptRegExp\n});\n\nvar esprima;\n\n// Browserified version does not have esprima\n//\n// 1. For node.js just require module as deps\n// 2. For browser try to require mudule via external AMD system.\n//    If not found - try to fallback to window.esprima. If not\n//    found too - then fail to parse.\n//\ntry {\n  // workaround to exclude package from browserify list.\n  var _require$1 = commonjsRequire;\n  esprima = _require$1('esprima');\n} catch (_) {\n  /* eslint-disable no-redeclare */\n  /* global window */\n  if (typeof window !== 'undefined') esprima = window.esprima;\n}\n\n\n\nfunction resolveJavascriptFunction(data) {\n  if (data === null) return false;\n\n  try {\n    var source = '(' + data + ')',\n        ast    = esprima.parse(source, { range: true });\n\n    if (ast.type                    !== 'Program'             ||\n        ast.body.length             !== 1                     ||\n        ast.body[0].type            !== 'ExpressionStatement' ||\n        (ast.body[0].expression.type !== 'ArrowFunctionExpression' &&\n          ast.body[0].expression.type !== 'FunctionExpression')) {\n      return false;\n    }\n\n    return true;\n  } catch (err) {\n    return false;\n  }\n}\n\nfunction constructJavascriptFunction(data) {\n  /*jslint evil:true*/\n\n  var source = '(' + data + ')',\n      ast    = esprima.parse(source, { range: true }),\n      params = [],\n      body;\n\n  if (ast.type                    !== 'Program'             ||\n      ast.body.length             !== 1                     ||\n      ast.body[0].type            !== 'ExpressionStatement' ||\n      (ast.body[0].expression.type !== 'ArrowFunctionExpression' &&\n        ast.body[0].expression.type !== 'FunctionExpression')) {\n    throw new Error('Failed to resolve function');\n  }\n\n  ast.body[0].expression.params.forEach(function (param) {\n    params.push(param.name);\n  });\n\n  body = ast.body[0].expression.body.range;\n\n  // Esprima's ranges include the first '{' and the last '}' characters on\n  // function expressions. So cut them out.\n  if (ast.body[0].expression.body.type === 'BlockStatement') {\n    /*eslint-disable no-new-func*/\n    return new Function(params, source.slice(body[0] + 1, body[1] - 1));\n  }\n  // ES6 arrow functions can omit the BlockStatement. In that case, just return\n  // the body.\n  /*eslint-disable no-new-func*/\n  return new Function(params, 'return ' + source.slice(body[0], body[1]));\n}\n\nfunction representJavascriptFunction(object /*, style*/) {\n  return object.toString();\n}\n\nfunction isFunction(object) {\n  return Object.prototype.toString.call(object) === '[object Function]';\n}\n\nvar _function = new type('tag:yaml.org,2002:js/function', {\n  kind: 'scalar',\n  resolve: resolveJavascriptFunction,\n  construct: constructJavascriptFunction,\n  predicate: isFunction,\n  represent: representJavascriptFunction\n});\n\nvar default_full = schema.DEFAULT = new schema({\n  include: [\n    default_safe\n  ],\n  explicit: [\n    _undefined,\n    regexp,\n    _function\n  ]\n});\n\n/*eslint-disable max-len,no-use-before-define*/\n\n\n\n\n\n\n\n\nvar _hasOwnProperty$2 = Object.prototype.hasOwnProperty;\n\n\nvar CONTEXT_FLOW_IN   = 1;\nvar CONTEXT_FLOW_OUT  = 2;\nvar CONTEXT_BLOCK_IN  = 3;\nvar CONTEXT_BLOCK_OUT = 4;\n\n\nvar CHOMPING_CLIP  = 1;\nvar CHOMPING_STRIP = 2;\nvar CHOMPING_KEEP  = 3;\n\n\nvar PATTERN_NON_PRINTABLE         = /[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F\\x7F-\\x84\\x86-\\x9F\\uFFFE\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/;\nvar PATTERN_NON_ASCII_LINE_BREAKS = /[\\x85\\u2028\\u2029]/;\nvar PATTERN_FLOW_INDICATORS       = /[,\\[\\]\\{\\}]/;\nvar PATTERN_TAG_HANDLE            = /^(?:!|!!|![a-z\\-]+!)$/i;\nvar PATTERN_TAG_URI               = /^(?:!|[^,\\[\\]\\{\\}])(?:%[0-9a-f]{2}|[0-9a-z\\-#;\\/\\?:@&=\\+\\$,_\\.!~\\*'\\(\\)\\[\\]])*$/i;\n\n\nfunction _class(obj) { return Object.prototype.toString.call(obj); }\n\nfunction is_EOL(c) {\n  return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);\n}\n\nfunction is_WHITE_SPACE(c) {\n  return (c === 0x09/* Tab */) || (c === 0x20/* Space */);\n}\n\nfunction is_WS_OR_EOL(c) {\n  return (c === 0x09/* Tab */) ||\n         (c === 0x20/* Space */) ||\n         (c === 0x0A/* LF */) ||\n         (c === 0x0D/* CR */);\n}\n\nfunction is_FLOW_INDICATOR(c) {\n  return c === 0x2C/* , */ ||\n         c === 0x5B/* [ */ ||\n         c === 0x5D/* ] */ ||\n         c === 0x7B/* { */ ||\n         c === 0x7D/* } */;\n}\n\nfunction fromHexCode(c) {\n  var lc;\n\n  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {\n    return c - 0x30;\n  }\n\n  /*eslint-disable no-bitwise*/\n  lc = c | 0x20;\n\n  if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) {\n    return lc - 0x61 + 10;\n  }\n\n  return -1;\n}\n\nfunction escapedHexLen(c) {\n  if (c === 0x78/* x */) { return 2; }\n  if (c === 0x75/* u */) { return 4; }\n  if (c === 0x55/* U */) { return 8; }\n  return 0;\n}\n\nfunction fromDecimalCode(c) {\n  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {\n    return c - 0x30;\n  }\n\n  return -1;\n}\n\nfunction simpleEscapeSequence(c) {\n  /* eslint-disable indent */\n  return (c === 0x30/* 0 */) ? '\\x00' :\n        (c === 0x61/* a */) ? '\\x07' :\n        (c === 0x62/* b */) ? '\\x08' :\n        (c === 0x74/* t */) ? '\\x09' :\n        (c === 0x09/* Tab */) ? '\\x09' :\n        (c === 0x6E/* n */) ? '\\x0A' :\n        (c === 0x76/* v */) ? '\\x0B' :\n        (c === 0x66/* f */) ? '\\x0C' :\n        (c === 0x72/* r */) ? '\\x0D' :\n        (c === 0x65/* e */) ? '\\x1B' :\n        (c === 0x20/* Space */) ? ' ' :\n        (c === 0x22/* \" */) ? '\\x22' :\n        (c === 0x2F/* / */) ? '/' :\n        (c === 0x5C/* \\ */) ? '\\x5C' :\n        (c === 0x4E/* N */) ? '\\x85' :\n        (c === 0x5F/* _ */) ? '\\xA0' :\n        (c === 0x4C/* L */) ? '\\u2028' :\n        (c === 0x50/* P */) ? '\\u2029' : '';\n}\n\nfunction charFromCodepoint(c) {\n  if (c <= 0xFFFF) {\n    return String.fromCharCode(c);\n  }\n  // Encode UTF-16 surrogate pair\n  // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF\n  return String.fromCharCode(\n    ((c - 0x010000) >> 10) + 0xD800,\n    ((c - 0x010000) & 0x03FF) + 0xDC00\n  );\n}\n\nvar simpleEscapeCheck = new Array(256); // integer, for fast access\nvar simpleEscapeMap = new Array(256);\nfor (var i = 0; i < 256; i++) {\n  simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;\n  simpleEscapeMap[i] = simpleEscapeSequence(i);\n}\n\n\nfunction State(input, options) {\n  this.input = input;\n\n  this.filename  = options['filename']  || null;\n  this.schema    = options['schema']    || default_full;\n  this.onWarning = options['onWarning'] || null;\n  this.legacy    = options['legacy']    || false;\n  this.json      = options['json']      || false;\n  this.listener  = options['listener']  || null;\n\n  this.implicitTypes = this.schema.compiledImplicit;\n  this.typeMap       = this.schema.compiledTypeMap;\n\n  this.length     = input.length;\n  this.position   = 0;\n  this.line       = 0;\n  this.lineStart  = 0;\n  this.lineIndent = 0;\n\n  this.documents = [];\n\n  /*\n  this.version;\n  this.checkLineBreaks;\n  this.tagMap;\n  this.anchorMap;\n  this.tag;\n  this.anchor;\n  this.kind;\n  this.result;*/\n\n}\n\n\nfunction generateError(state, message) {\n  return new exception(\n    message,\n    new mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart)));\n}\n\nfunction throwError(state, message) {\n  throw generateError(state, message);\n}\n\nfunction throwWarning(state, message) {\n  if (state.onWarning) {\n    state.onWarning.call(null, generateError(state, message));\n  }\n}\n\n\nvar directiveHandlers = {\n\n  YAML: function handleYamlDirective(state, name, args) {\n\n    var match, major, minor;\n\n    if (state.version !== null) {\n      throwError(state, 'duplication of %YAML directive');\n    }\n\n    if (args.length !== 1) {\n      throwError(state, 'YAML directive accepts exactly one argument');\n    }\n\n    match = /^([0-9]+)\\.([0-9]+)$/.exec(args[0]);\n\n    if (match === null) {\n      throwError(state, 'ill-formed argument of the YAML directive');\n    }\n\n    major = parseInt(match[1], 10);\n    minor = parseInt(match[2], 10);\n\n    if (major !== 1) {\n      throwError(state, 'unacceptable YAML version of the document');\n    }\n\n    state.version = args[0];\n    state.checkLineBreaks = (minor < 2);\n\n    if (minor !== 1 && minor !== 2) {\n      throwWarning(state, 'unsupported YAML version of the document');\n    }\n  },\n\n  TAG: function handleTagDirective(state, name, args) {\n\n    var handle, prefix;\n\n    if (args.length !== 2) {\n      throwError(state, 'TAG directive accepts exactly two arguments');\n    }\n\n    handle = args[0];\n    prefix = args[1];\n\n    if (!PATTERN_TAG_HANDLE.test(handle)) {\n      throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');\n    }\n\n    if (_hasOwnProperty$2.call(state.tagMap, handle)) {\n      throwError(state, 'there is a previously declared suffix for \"' + handle + '\" tag handle');\n    }\n\n    if (!PATTERN_TAG_URI.test(prefix)) {\n      throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');\n    }\n\n    state.tagMap[handle] = prefix;\n  }\n};\n\n\nfunction captureSegment(state, start, end, checkJson) {\n  var _position, _length, _character, _result;\n\n  if (start < end) {\n    _result = state.input.slice(start, end);\n\n    if (checkJson) {\n      for (_position = 0, _length = _result.length; _position < _length; _position += 1) {\n        _character = _result.charCodeAt(_position);\n        if (!(_character === 0x09 ||\n              (0x20 <= _character && _character <= 0x10FFFF))) {\n          throwError(state, 'expected valid JSON character');\n        }\n      }\n    } else if (PATTERN_NON_PRINTABLE.test(_result)) {\n      throwError(state, 'the stream contains non-printable characters');\n    }\n\n    state.result += _result;\n  }\n}\n\nfunction mergeMappings(state, destination, source, overridableKeys) {\n  var sourceKeys, key, index, quantity;\n\n  if (!common.isObject(source)) {\n    throwError(state, 'cannot merge mappings; the provided source object is unacceptable');\n  }\n\n  sourceKeys = Object.keys(source);\n\n  for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {\n    key = sourceKeys[index];\n\n    if (!_hasOwnProperty$2.call(destination, key)) {\n      destination[key] = source[key];\n      overridableKeys[key] = true;\n    }\n  }\n}\n\nfunction storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {\n  var index, quantity;\n\n  // The output is a plain object here, so keys can only be strings.\n  // We need to convert keyNode to a string, but doing so can hang the process\n  // (deeply nested arrays that explode exponentially using aliases).\n  if (Array.isArray(keyNode)) {\n    keyNode = Array.prototype.slice.call(keyNode);\n\n    for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {\n      if (Array.isArray(keyNode[index])) {\n        throwError(state, 'nested arrays are not supported inside keys');\n      }\n\n      if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {\n        keyNode[index] = '[object Object]';\n      }\n    }\n  }\n\n  // Avoid code execution in load() via toString property\n  // (still use its own toString for arrays, timestamps,\n  // and whatever user schema extensions happen to have @@toStringTag)\n  if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {\n    keyNode = '[object Object]';\n  }\n\n\n  keyNode = String(keyNode);\n\n  if (_result === null) {\n    _result = {};\n  }\n\n  if (keyTag === 'tag:yaml.org,2002:merge') {\n    if (Array.isArray(valueNode)) {\n      for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {\n        mergeMappings(state, _result, valueNode[index], overridableKeys);\n      }\n    } else {\n      mergeMappings(state, _result, valueNode, overridableKeys);\n    }\n  } else {\n    if (!state.json &&\n        !_hasOwnProperty$2.call(overridableKeys, keyNode) &&\n        _hasOwnProperty$2.call(_result, keyNode)) {\n      state.line = startLine || state.line;\n      state.position = startPos || state.position;\n      throwError(state, 'duplicated mapping key');\n    }\n    _result[keyNode] = valueNode;\n    delete overridableKeys[keyNode];\n  }\n\n  return _result;\n}\n\nfunction readLineBreak(state) {\n  var ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch === 0x0A/* LF */) {\n    state.position++;\n  } else if (ch === 0x0D/* CR */) {\n    state.position++;\n    if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {\n      state.position++;\n    }\n  } else {\n    throwError(state, 'a line break is expected');\n  }\n\n  state.line += 1;\n  state.lineStart = state.position;\n}\n\nfunction skipSeparationSpace(state, allowComments, checkIndent) {\n  var lineBreaks = 0,\n      ch = state.input.charCodeAt(state.position);\n\n  while (ch !== 0) {\n    while (is_WHITE_SPACE(ch)) {\n      ch = state.input.charCodeAt(++state.position);\n    }\n\n    if (allowComments && ch === 0x23/* # */) {\n      do {\n        ch = state.input.charCodeAt(++state.position);\n      } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);\n    }\n\n    if (is_EOL(ch)) {\n      readLineBreak(state);\n\n      ch = state.input.charCodeAt(state.position);\n      lineBreaks++;\n      state.lineIndent = 0;\n\n      while (ch === 0x20/* Space */) {\n        state.lineIndent++;\n        ch = state.input.charCodeAt(++state.position);\n      }\n    } else {\n      break;\n    }\n  }\n\n  if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {\n    throwWarning(state, 'deficient indentation');\n  }\n\n  return lineBreaks;\n}\n\nfunction testDocumentSeparator(state) {\n  var _position = state.position,\n      ch;\n\n  ch = state.input.charCodeAt(_position);\n\n  // Condition state.position === state.lineStart is tested\n  // in parent on each call, for efficiency. No needs to test here again.\n  if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&\n      ch === state.input.charCodeAt(_position + 1) &&\n      ch === state.input.charCodeAt(_position + 2)) {\n\n    _position += 3;\n\n    ch = state.input.charCodeAt(_position);\n\n    if (ch === 0 || is_WS_OR_EOL(ch)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction writeFoldedLines(state, count) {\n  if (count === 1) {\n    state.result += ' ';\n  } else if (count > 1) {\n    state.result += common.repeat('\\n', count - 1);\n  }\n}\n\n\nfunction readPlainScalar(state, nodeIndent, withinFlowCollection) {\n  var preceding,\n      following,\n      captureStart,\n      captureEnd,\n      hasPendingContent,\n      _line,\n      _lineStart,\n      _lineIndent,\n      _kind = state.kind,\n      _result = state.result,\n      ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (is_WS_OR_EOL(ch)      ||\n      is_FLOW_INDICATOR(ch) ||\n      ch === 0x23/* # */    ||\n      ch === 0x26/* & */    ||\n      ch === 0x2A/* * */    ||\n      ch === 0x21/* ! */    ||\n      ch === 0x7C/* | */    ||\n      ch === 0x3E/* > */    ||\n      ch === 0x27/* ' */    ||\n      ch === 0x22/* \" */    ||\n      ch === 0x25/* % */    ||\n      ch === 0x40/* @ */    ||\n      ch === 0x60/* ` */) {\n    return false;\n  }\n\n  if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {\n    following = state.input.charCodeAt(state.position + 1);\n\n    if (is_WS_OR_EOL(following) ||\n        withinFlowCollection && is_FLOW_INDICATOR(following)) {\n      return false;\n    }\n  }\n\n  state.kind = 'scalar';\n  state.result = '';\n  captureStart = captureEnd = state.position;\n  hasPendingContent = false;\n\n  while (ch !== 0) {\n    if (ch === 0x3A/* : */) {\n      following = state.input.charCodeAt(state.position + 1);\n\n      if (is_WS_OR_EOL(following) ||\n          withinFlowCollection && is_FLOW_INDICATOR(following)) {\n        break;\n      }\n\n    } else if (ch === 0x23/* # */) {\n      preceding = state.input.charCodeAt(state.position - 1);\n\n      if (is_WS_OR_EOL(preceding)) {\n        break;\n      }\n\n    } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||\n               withinFlowCollection && is_FLOW_INDICATOR(ch)) {\n      break;\n\n    } else if (is_EOL(ch)) {\n      _line = state.line;\n      _lineStart = state.lineStart;\n      _lineIndent = state.lineIndent;\n      skipSeparationSpace(state, false, -1);\n\n      if (state.lineIndent >= nodeIndent) {\n        hasPendingContent = true;\n        ch = state.input.charCodeAt(state.position);\n        continue;\n      } else {\n        state.position = captureEnd;\n        state.line = _line;\n        state.lineStart = _lineStart;\n        state.lineIndent = _lineIndent;\n        break;\n      }\n    }\n\n    if (hasPendingContent) {\n      captureSegment(state, captureStart, captureEnd, false);\n      writeFoldedLines(state, state.line - _line);\n      captureStart = captureEnd = state.position;\n      hasPendingContent = false;\n    }\n\n    if (!is_WHITE_SPACE(ch)) {\n      captureEnd = state.position + 1;\n    }\n\n    ch = state.input.charCodeAt(++state.position);\n  }\n\n  captureSegment(state, captureStart, captureEnd, false);\n\n  if (state.result) {\n    return true;\n  }\n\n  state.kind = _kind;\n  state.result = _result;\n  return false;\n}\n\nfunction readSingleQuotedScalar(state, nodeIndent) {\n  var ch,\n      captureStart, captureEnd;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch !== 0x27/* ' */) {\n    return false;\n  }\n\n  state.kind = 'scalar';\n  state.result = '';\n  state.position++;\n  captureStart = captureEnd = state.position;\n\n  while ((ch = state.input.charCodeAt(state.position)) !== 0) {\n    if (ch === 0x27/* ' */) {\n      captureSegment(state, captureStart, state.position, true);\n      ch = state.input.charCodeAt(++state.position);\n\n      if (ch === 0x27/* ' */) {\n        captureStart = state.position;\n        state.position++;\n        captureEnd = state.position;\n      } else {\n        return true;\n      }\n\n    } else if (is_EOL(ch)) {\n      captureSegment(state, captureStart, captureEnd, true);\n      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));\n      captureStart = captureEnd = state.position;\n\n    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {\n      throwError(state, 'unexpected end of the document within a single quoted scalar');\n\n    } else {\n      state.position++;\n      captureEnd = state.position;\n    }\n  }\n\n  throwError(state, 'unexpected end of the stream within a single quoted scalar');\n}\n\nfunction readDoubleQuotedScalar(state, nodeIndent) {\n  var captureStart,\n      captureEnd,\n      hexLength,\n      hexResult,\n      tmp,\n      ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch !== 0x22/* \" */) {\n    return false;\n  }\n\n  state.kind = 'scalar';\n  state.result = '';\n  state.position++;\n  captureStart = captureEnd = state.position;\n\n  while ((ch = state.input.charCodeAt(state.position)) !== 0) {\n    if (ch === 0x22/* \" */) {\n      captureSegment(state, captureStart, state.position, true);\n      state.position++;\n      return true;\n\n    } else if (ch === 0x5C/* \\ */) {\n      captureSegment(state, captureStart, state.position, true);\n      ch = state.input.charCodeAt(++state.position);\n\n      if (is_EOL(ch)) {\n        skipSeparationSpace(state, false, nodeIndent);\n\n        // TODO: rework to inline fn with no type cast?\n      } else if (ch < 256 && simpleEscapeCheck[ch]) {\n        state.result += simpleEscapeMap[ch];\n        state.position++;\n\n      } else if ((tmp = escapedHexLen(ch)) > 0) {\n        hexLength = tmp;\n        hexResult = 0;\n\n        for (; hexLength > 0; hexLength--) {\n          ch = state.input.charCodeAt(++state.position);\n\n          if ((tmp = fromHexCode(ch)) >= 0) {\n            hexResult = (hexResult << 4) + tmp;\n\n          } else {\n            throwError(state, 'expected hexadecimal character');\n          }\n        }\n\n        state.result += charFromCodepoint(hexResult);\n\n        state.position++;\n\n      } else {\n        throwError(state, 'unknown escape sequence');\n      }\n\n      captureStart = captureEnd = state.position;\n\n    } else if (is_EOL(ch)) {\n      captureSegment(state, captureStart, captureEnd, true);\n      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));\n      captureStart = captureEnd = state.position;\n\n    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {\n      throwError(state, 'unexpected end of the document within a double quoted scalar');\n\n    } else {\n      state.position++;\n      captureEnd = state.position;\n    }\n  }\n\n  throwError(state, 'unexpected end of the stream within a double quoted scalar');\n}\n\nfunction readFlowCollection(state, nodeIndent) {\n  var readNext = true,\n      _line,\n      _tag     = state.tag,\n      _result,\n      _anchor  = state.anchor,\n      following,\n      terminator,\n      isPair,\n      isExplicitPair,\n      isMapping,\n      overridableKeys = {},\n      keyNode,\n      keyTag,\n      valueNode,\n      ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch === 0x5B/* [ */) {\n    terminator = 0x5D;/* ] */\n    isMapping = false;\n    _result = [];\n  } else if (ch === 0x7B/* { */) {\n    terminator = 0x7D;/* } */\n    isMapping = true;\n    _result = {};\n  } else {\n    return false;\n  }\n\n  if (state.anchor !== null) {\n    state.anchorMap[state.anchor] = _result;\n  }\n\n  ch = state.input.charCodeAt(++state.position);\n\n  while (ch !== 0) {\n    skipSeparationSpace(state, true, nodeIndent);\n\n    ch = state.input.charCodeAt(state.position);\n\n    if (ch === terminator) {\n      state.position++;\n      state.tag = _tag;\n      state.anchor = _anchor;\n      state.kind = isMapping ? 'mapping' : 'sequence';\n      state.result = _result;\n      return true;\n    } else if (!readNext) {\n      throwError(state, 'missed comma between flow collection entries');\n    }\n\n    keyTag = keyNode = valueNode = null;\n    isPair = isExplicitPair = false;\n\n    if (ch === 0x3F/* ? */) {\n      following = state.input.charCodeAt(state.position + 1);\n\n      if (is_WS_OR_EOL(following)) {\n        isPair = isExplicitPair = true;\n        state.position++;\n        skipSeparationSpace(state, true, nodeIndent);\n      }\n    }\n\n    _line = state.line;\n    composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);\n    keyTag = state.tag;\n    keyNode = state.result;\n    skipSeparationSpace(state, true, nodeIndent);\n\n    ch = state.input.charCodeAt(state.position);\n\n    if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {\n      isPair = true;\n      ch = state.input.charCodeAt(++state.position);\n      skipSeparationSpace(state, true, nodeIndent);\n      composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);\n      valueNode = state.result;\n    }\n\n    if (isMapping) {\n      storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode);\n    } else if (isPair) {\n      _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode));\n    } else {\n      _result.push(keyNode);\n    }\n\n    skipSeparationSpace(state, true, nodeIndent);\n\n    ch = state.input.charCodeAt(state.position);\n\n    if (ch === 0x2C/* , */) {\n      readNext = true;\n      ch = state.input.charCodeAt(++state.position);\n    } else {\n      readNext = false;\n    }\n  }\n\n  throwError(state, 'unexpected end of the stream within a flow collection');\n}\n\nfunction readBlockScalar(state, nodeIndent) {\n  var captureStart,\n      folding,\n      chomping       = CHOMPING_CLIP,\n      didReadContent = false,\n      detectedIndent = false,\n      textIndent     = nodeIndent,\n      emptyLines     = 0,\n      atMoreIndented = false,\n      tmp,\n      ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch === 0x7C/* | */) {\n    folding = false;\n  } else if (ch === 0x3E/* > */) {\n    folding = true;\n  } else {\n    return false;\n  }\n\n  state.kind = 'scalar';\n  state.result = '';\n\n  while (ch !== 0) {\n    ch = state.input.charCodeAt(++state.position);\n\n    if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {\n      if (CHOMPING_CLIP === chomping) {\n        chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;\n      } else {\n        throwError(state, 'repeat of a chomping mode identifier');\n      }\n\n    } else if ((tmp = fromDecimalCode(ch)) >= 0) {\n      if (tmp === 0) {\n        throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');\n      } else if (!detectedIndent) {\n        textIndent = nodeIndent + tmp - 1;\n        detectedIndent = true;\n      } else {\n        throwError(state, 'repeat of an indentation width identifier');\n      }\n\n    } else {\n      break;\n    }\n  }\n\n  if (is_WHITE_SPACE(ch)) {\n    do { ch = state.input.charCodeAt(++state.position); }\n    while (is_WHITE_SPACE(ch));\n\n    if (ch === 0x23/* # */) {\n      do { ch = state.input.charCodeAt(++state.position); }\n      while (!is_EOL(ch) && (ch !== 0));\n    }\n  }\n\n  while (ch !== 0) {\n    readLineBreak(state);\n    state.lineIndent = 0;\n\n    ch = state.input.charCodeAt(state.position);\n\n    while ((!detectedIndent || state.lineIndent < textIndent) &&\n           (ch === 0x20/* Space */)) {\n      state.lineIndent++;\n      ch = state.input.charCodeAt(++state.position);\n    }\n\n    if (!detectedIndent && state.lineIndent > textIndent) {\n      textIndent = state.lineIndent;\n    }\n\n    if (is_EOL(ch)) {\n      emptyLines++;\n      continue;\n    }\n\n    // End of the scalar.\n    if (state.lineIndent < textIndent) {\n\n      // Perform the chomping.\n      if (chomping === CHOMPING_KEEP) {\n        state.result += common.repeat('\\n', didReadContent ? 1 + emptyLines : emptyLines);\n      } else if (chomping === CHOMPING_CLIP) {\n        if (didReadContent) { // i.e. only if the scalar is not empty.\n          state.result += '\\n';\n        }\n      }\n\n      // Break this `while` cycle and go to the funciton's epilogue.\n      break;\n    }\n\n    // Folded style: use fancy rules to handle line breaks.\n    if (folding) {\n\n      // Lines starting with white space characters (more-indented lines) are not folded.\n      if (is_WHITE_SPACE(ch)) {\n        atMoreIndented = true;\n        // except for the first content line (cf. Example 8.1)\n        state.result += common.repeat('\\n', didReadContent ? 1 + emptyLines : emptyLines);\n\n      // End of more-indented block.\n      } else if (atMoreIndented) {\n        atMoreIndented = false;\n        state.result += common.repeat('\\n', emptyLines + 1);\n\n      // Just one line break - perceive as the same line.\n      } else if (emptyLines === 0) {\n        if (didReadContent) { // i.e. only if we have already read some scalar content.\n          state.result += ' ';\n        }\n\n      // Several line breaks - perceive as different lines.\n      } else {\n        state.result += common.repeat('\\n', emptyLines);\n      }\n\n    // Literal style: just add exact number of line breaks between content lines.\n    } else {\n      // Keep all line breaks except the header line break.\n      state.result += common.repeat('\\n', didReadContent ? 1 + emptyLines : emptyLines);\n    }\n\n    didReadContent = true;\n    detectedIndent = true;\n    emptyLines = 0;\n    captureStart = state.position;\n\n    while (!is_EOL(ch) && (ch !== 0)) {\n      ch = state.input.charCodeAt(++state.position);\n    }\n\n    captureSegment(state, captureStart, state.position, false);\n  }\n\n  return true;\n}\n\nfunction readBlockSequence(state, nodeIndent) {\n  var _line,\n      _tag      = state.tag,\n      _anchor   = state.anchor,\n      _result   = [],\n      following,\n      detected  = false,\n      ch;\n\n  if (state.anchor !== null) {\n    state.anchorMap[state.anchor] = _result;\n  }\n\n  ch = state.input.charCodeAt(state.position);\n\n  while (ch !== 0) {\n\n    if (ch !== 0x2D/* - */) {\n      break;\n    }\n\n    following = state.input.charCodeAt(state.position + 1);\n\n    if (!is_WS_OR_EOL(following)) {\n      break;\n    }\n\n    detected = true;\n    state.position++;\n\n    if (skipSeparationSpace(state, true, -1)) {\n      if (state.lineIndent <= nodeIndent) {\n        _result.push(null);\n        ch = state.input.charCodeAt(state.position);\n        continue;\n      }\n    }\n\n    _line = state.line;\n    composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);\n    _result.push(state.result);\n    skipSeparationSpace(state, true, -1);\n\n    ch = state.input.charCodeAt(state.position);\n\n    if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {\n      throwError(state, 'bad indentation of a sequence entry');\n    } else if (state.lineIndent < nodeIndent) {\n      break;\n    }\n  }\n\n  if (detected) {\n    state.tag = _tag;\n    state.anchor = _anchor;\n    state.kind = 'sequence';\n    state.result = _result;\n    return true;\n  }\n  return false;\n}\n\nfunction readBlockMapping(state, nodeIndent, flowIndent) {\n  var following,\n      allowCompact,\n      _line,\n      _pos,\n      _tag          = state.tag,\n      _anchor       = state.anchor,\n      _result       = {},\n      overridableKeys = {},\n      keyTag        = null,\n      keyNode       = null,\n      valueNode     = null,\n      atExplicitKey = false,\n      detected      = false,\n      ch;\n\n  if (state.anchor !== null) {\n    state.anchorMap[state.anchor] = _result;\n  }\n\n  ch = state.input.charCodeAt(state.position);\n\n  while (ch !== 0) {\n    following = state.input.charCodeAt(state.position + 1);\n    _line = state.line; // Save the current line.\n    _pos = state.position;\n\n    //\n    // Explicit notation case. There are two separate blocks:\n    // first for the key (denoted by \"?\") and second for the value (denoted by \":\")\n    //\n    if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {\n\n      if (ch === 0x3F/* ? */) {\n        if (atExplicitKey) {\n          storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);\n          keyTag = keyNode = valueNode = null;\n        }\n\n        detected = true;\n        atExplicitKey = true;\n        allowCompact = true;\n\n      } else if (atExplicitKey) {\n        // i.e. 0x3A/* : */ === character after the explicit key.\n        atExplicitKey = false;\n        allowCompact = true;\n\n      } else {\n        throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');\n      }\n\n      state.position += 1;\n      ch = following;\n\n    //\n    // Implicit notation case. Flow-style node as the key first, then \":\", and the value.\n    //\n    } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {\n\n      if (state.line === _line) {\n        ch = state.input.charCodeAt(state.position);\n\n        while (is_WHITE_SPACE(ch)) {\n          ch = state.input.charCodeAt(++state.position);\n        }\n\n        if (ch === 0x3A/* : */) {\n          ch = state.input.charCodeAt(++state.position);\n\n          if (!is_WS_OR_EOL(ch)) {\n            throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping');\n          }\n\n          if (atExplicitKey) {\n            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);\n            keyTag = keyNode = valueNode = null;\n          }\n\n          detected = true;\n          atExplicitKey = false;\n          allowCompact = false;\n          keyTag = state.tag;\n          keyNode = state.result;\n\n        } else if (detected) {\n          throwError(state, 'can not read an implicit mapping pair; a colon is missed');\n\n        } else {\n          state.tag = _tag;\n          state.anchor = _anchor;\n          return true; // Keep the result of `composeNode`.\n        }\n\n      } else if (detected) {\n        throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');\n\n      } else {\n        state.tag = _tag;\n        state.anchor = _anchor;\n        return true; // Keep the result of `composeNode`.\n      }\n\n    } else {\n      break; // Reading is done. Go to the epilogue.\n    }\n\n    //\n    // Common reading code for both explicit and implicit notations.\n    //\n    if (state.line === _line || state.lineIndent > nodeIndent) {\n      if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {\n        if (atExplicitKey) {\n          keyNode = state.result;\n        } else {\n          valueNode = state.result;\n        }\n      }\n\n      if (!atExplicitKey) {\n        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos);\n        keyTag = keyNode = valueNode = null;\n      }\n\n      skipSeparationSpace(state, true, -1);\n      ch = state.input.charCodeAt(state.position);\n    }\n\n    if (state.lineIndent > nodeIndent && (ch !== 0)) {\n      throwError(state, 'bad indentation of a mapping entry');\n    } else if (state.lineIndent < nodeIndent) {\n      break;\n    }\n  }\n\n  //\n  // Epilogue.\n  //\n\n  // Special case: last mapping's node contains only the key in explicit notation.\n  if (atExplicitKey) {\n    storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);\n  }\n\n  // Expose the resulting mapping.\n  if (detected) {\n    state.tag = _tag;\n    state.anchor = _anchor;\n    state.kind = 'mapping';\n    state.result = _result;\n  }\n\n  return detected;\n}\n\nfunction readTagProperty(state) {\n  var _position,\n      isVerbatim = false,\n      isNamed    = false,\n      tagHandle,\n      tagName,\n      ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch !== 0x21/* ! */) return false;\n\n  if (state.tag !== null) {\n    throwError(state, 'duplication of a tag property');\n  }\n\n  ch = state.input.charCodeAt(++state.position);\n\n  if (ch === 0x3C/* < */) {\n    isVerbatim = true;\n    ch = state.input.charCodeAt(++state.position);\n\n  } else if (ch === 0x21/* ! */) {\n    isNamed = true;\n    tagHandle = '!!';\n    ch = state.input.charCodeAt(++state.position);\n\n  } else {\n    tagHandle = '!';\n  }\n\n  _position = state.position;\n\n  if (isVerbatim) {\n    do { ch = state.input.charCodeAt(++state.position); }\n    while (ch !== 0 && ch !== 0x3E/* > */);\n\n    if (state.position < state.length) {\n      tagName = state.input.slice(_position, state.position);\n      ch = state.input.charCodeAt(++state.position);\n    } else {\n      throwError(state, 'unexpected end of the stream within a verbatim tag');\n    }\n  } else {\n    while (ch !== 0 && !is_WS_OR_EOL(ch)) {\n\n      if (ch === 0x21/* ! */) {\n        if (!isNamed) {\n          tagHandle = state.input.slice(_position - 1, state.position + 1);\n\n          if (!PATTERN_TAG_HANDLE.test(tagHandle)) {\n            throwError(state, 'named tag handle cannot contain such characters');\n          }\n\n          isNamed = true;\n          _position = state.position + 1;\n        } else {\n          throwError(state, 'tag suffix cannot contain exclamation marks');\n        }\n      }\n\n      ch = state.input.charCodeAt(++state.position);\n    }\n\n    tagName = state.input.slice(_position, state.position);\n\n    if (PATTERN_FLOW_INDICATORS.test(tagName)) {\n      throwError(state, 'tag suffix cannot contain flow indicator characters');\n    }\n  }\n\n  if (tagName && !PATTERN_TAG_URI.test(tagName)) {\n    throwError(state, 'tag name cannot contain such characters: ' + tagName);\n  }\n\n  if (isVerbatim) {\n    state.tag = tagName;\n\n  } else if (_hasOwnProperty$2.call(state.tagMap, tagHandle)) {\n    state.tag = state.tagMap[tagHandle] + tagName;\n\n  } else if (tagHandle === '!') {\n    state.tag = '!' + tagName;\n\n  } else if (tagHandle === '!!') {\n    state.tag = 'tag:yaml.org,2002:' + tagName;\n\n  } else {\n    throwError(state, 'undeclared tag handle \"' + tagHandle + '\"');\n  }\n\n  return true;\n}\n\nfunction readAnchorProperty(state) {\n  var _position,\n      ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch !== 0x26/* & */) return false;\n\n  if (state.anchor !== null) {\n    throwError(state, 'duplication of an anchor property');\n  }\n\n  ch = state.input.charCodeAt(++state.position);\n  _position = state.position;\n\n  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {\n    ch = state.input.charCodeAt(++state.position);\n  }\n\n  if (state.position === _position) {\n    throwError(state, 'name of an anchor node must contain at least one character');\n  }\n\n  state.anchor = state.input.slice(_position, state.position);\n  return true;\n}\n\nfunction readAlias(state) {\n  var _position, alias,\n      ch;\n\n  ch = state.input.charCodeAt(state.position);\n\n  if (ch !== 0x2A/* * */) return false;\n\n  ch = state.input.charCodeAt(++state.position);\n  _position = state.position;\n\n  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {\n    ch = state.input.charCodeAt(++state.position);\n  }\n\n  if (state.position === _position) {\n    throwError(state, 'name of an alias node must contain at least one character');\n  }\n\n  alias = state.input.slice(_position, state.position);\n\n  if (!state.anchorMap.hasOwnProperty(alias)) {\n    throwError(state, 'unidentified alias \"' + alias + '\"');\n  }\n\n  state.result = state.anchorMap[alias];\n  skipSeparationSpace(state, true, -1);\n  return true;\n}\n\nfunction composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {\n  var allowBlockStyles,\n      allowBlockScalars,\n      allowBlockCollections,\n      indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent\n      atNewLine  = false,\n      hasContent = false,\n      typeIndex,\n      typeQuantity,\n      type,\n      flowIndent,\n      blockIndent;\n\n  if (state.listener !== null) {\n    state.listener('open', state);\n  }\n\n  state.tag    = null;\n  state.anchor = null;\n  state.kind   = null;\n  state.result = null;\n\n  allowBlockStyles = allowBlockScalars = allowBlockCollections =\n    CONTEXT_BLOCK_OUT === nodeContext ||\n    CONTEXT_BLOCK_IN  === nodeContext;\n\n  if (allowToSeek) {\n    if (skipSeparationSpace(state, true, -1)) {\n      atNewLine = true;\n\n      if (state.lineIndent > parentIndent) {\n        indentStatus = 1;\n      } else if (state.lineIndent === parentIndent) {\n        indentStatus = 0;\n      } else if (state.lineIndent < parentIndent) {\n        indentStatus = -1;\n      }\n    }\n  }\n\n  if (indentStatus === 1) {\n    while (readTagProperty(state) || readAnchorProperty(state)) {\n      if (skipSeparationSpace(state, true, -1)) {\n        atNewLine = true;\n        allowBlockCollections = allowBlockStyles;\n\n        if (state.lineIndent > parentIndent) {\n          indentStatus = 1;\n        } else if (state.lineIndent === parentIndent) {\n          indentStatus = 0;\n        } else if (state.lineIndent < parentIndent) {\n          indentStatus = -1;\n        }\n      } else {\n        allowBlockCollections = false;\n      }\n    }\n  }\n\n  if (allowBlockCollections) {\n    allowBlockCollections = atNewLine || allowCompact;\n  }\n\n  if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {\n    if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {\n      flowIndent = parentIndent;\n    } else {\n      flowIndent = parentIndent + 1;\n    }\n\n    blockIndent = state.position - state.lineStart;\n\n    if (indentStatus === 1) {\n      if (allowBlockCollections &&\n          (readBlockSequence(state, blockIndent) ||\n           readBlockMapping(state, blockIndent, flowIndent)) ||\n          readFlowCollection(state, flowIndent)) {\n        hasContent = true;\n      } else {\n        if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||\n            readSingleQuotedScalar(state, flowIndent) ||\n            readDoubleQuotedScalar(state, flowIndent)) {\n          hasContent = true;\n\n        } else if (readAlias(state)) {\n          hasContent = true;\n\n          if (state.tag !== null || state.anchor !== null) {\n            throwError(state, 'alias node should not have any properties');\n          }\n\n        } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {\n          hasContent = true;\n\n          if (state.tag === null) {\n            state.tag = '?';\n          }\n        }\n\n        if (state.anchor !== null) {\n          state.anchorMap[state.anchor] = state.result;\n        }\n      }\n    } else if (indentStatus === 0) {\n      // Special case: block sequences are allowed to have same indentation level as the parent.\n      // http://www.yaml.org/spec/1.2/spec.html#id2799784\n      hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);\n    }\n  }\n\n  if (state.tag !== null && state.tag !== '!') {\n    if (state.tag === '?') {\n      // Implicit resolving is not allowed for non-scalar types, and '?'\n      // non-specific tag is only automatically assigned to plain scalars.\n      //\n      // We only need to check kind conformity in case user explicitly assigns '?'\n      // tag, for example like this: \"!<?> [0]\"\n      //\n      if (state.result !== null && state.kind !== 'scalar') {\n        throwError(state, 'unacceptable node kind for !<?> tag; it should be \"scalar\", not \"' + state.kind + '\"');\n      }\n\n      for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {\n        type = state.implicitTypes[typeIndex];\n\n        if (type.resolve(state.result)) { // `state.result` updated in resolver if matched\n          state.result = type.construct(state.result);\n          state.tag = type.tag;\n          if (state.anchor !== null) {\n            state.anchorMap[state.anchor] = state.result;\n          }\n          break;\n        }\n      }\n    } else if (_hasOwnProperty$2.call(state.typeMap[state.kind || 'fallback'], state.tag)) {\n      type = state.typeMap[state.kind || 'fallback'][state.tag];\n\n      if (state.result !== null && type.kind !== state.kind) {\n        throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be \"' + type.kind + '\", not \"' + state.kind + '\"');\n      }\n\n      if (!type.resolve(state.result)) { // `state.result` updated in resolver if matched\n        throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');\n      } else {\n        state.result = type.construct(state.result);\n        if (state.anchor !== null) {\n          state.anchorMap[state.anchor] = state.result;\n        }\n      }\n    } else {\n      throwError(state, 'unknown tag !<' + state.tag + '>');\n    }\n  }\n\n  if (state.listener !== null) {\n    state.listener('close', state);\n  }\n  return state.tag !== null ||  state.anchor !== null || hasContent;\n}\n\nfunction readDocument(state) {\n  var documentStart = state.position,\n      _position,\n      directiveName,\n      directiveArgs,\n      hasDirectives = false,\n      ch;\n\n  state.version = null;\n  state.checkLineBreaks = state.legacy;\n  state.tagMap = {};\n  state.anchorMap = {};\n\n  while ((ch = state.input.charCodeAt(state.position)) !== 0) {\n    skipSeparationSpace(state, true, -1);\n\n    ch = state.input.charCodeAt(state.position);\n\n    if (state.lineIndent > 0 || ch !== 0x25/* % */) {\n      break;\n    }\n\n    hasDirectives = true;\n    ch = state.input.charCodeAt(++state.position);\n    _position = state.position;\n\n    while (ch !== 0 && !is_WS_OR_EOL(ch)) {\n      ch = state.input.charCodeAt(++state.position);\n    }\n\n    directiveName = state.input.slice(_position, state.position);\n    directiveArgs = [];\n\n    if (directiveName.length < 1) {\n      throwError(state, 'directive name must not be less than one character in length');\n    }\n\n    while (ch !== 0) {\n      while (is_WHITE_SPACE(ch)) {\n        ch = state.input.charCodeAt(++state.position);\n      }\n\n      if (ch === 0x23/* # */) {\n        do { ch = state.input.charCodeAt(++state.position); }\n        while (ch !== 0 && !is_EOL(ch));\n        break;\n      }\n\n      if (is_EOL(ch)) break;\n\n      _position = state.position;\n\n      while (ch !== 0 && !is_WS_OR_EOL(ch)) {\n        ch = state.input.charCodeAt(++state.position);\n      }\n\n      directiveArgs.push(state.input.slice(_position, state.position));\n    }\n\n    if (ch !== 0) readLineBreak(state);\n\n    if (_hasOwnProperty$2.call(directiveHandlers, directiveName)) {\n      directiveHandlers[directiveName](state, directiveName, directiveArgs);\n    } else {\n      throwWarning(state, 'unknown document directive \"' + directiveName + '\"');\n    }\n  }\n\n  skipSeparationSpace(state, true, -1);\n\n  if (state.lineIndent === 0 &&\n      state.input.charCodeAt(state.position)     === 0x2D/* - */ &&\n      state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&\n      state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {\n    state.position += 3;\n    skipSeparationSpace(state, true, -1);\n\n  } else if (hasDirectives) {\n    throwError(state, 'directives end mark is expected');\n  }\n\n  composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);\n  skipSeparationSpace(state, true, -1);\n\n  if (state.checkLineBreaks &&\n      PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {\n    throwWarning(state, 'non-ASCII line breaks are interpreted as content');\n  }\n\n  state.documents.push(state.result);\n\n  if (state.position === state.lineStart && testDocumentSeparator(state)) {\n\n    if (state.input.charCodeAt(state.position) === 0x2E/* . */) {\n      state.position += 3;\n      skipSeparationSpace(state, true, -1);\n    }\n    return;\n  }\n\n  if (state.position < (state.length - 1)) {\n    throwError(state, 'end of the stream or a document separator is expected');\n  } else {\n    return;\n  }\n}\n\n\nfunction loadDocuments(input, options) {\n  input = String(input);\n  options = options || {};\n\n  if (input.length !== 0) {\n\n    // Add tailing `\\n` if not exists\n    if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&\n        input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {\n      input += '\\n';\n    }\n\n    // Strip BOM\n    if (input.charCodeAt(0) === 0xFEFF) {\n      input = input.slice(1);\n    }\n  }\n\n  var state = new State(input, options);\n\n  var nullpos = input.indexOf('\\0');\n\n  if (nullpos !== -1) {\n    state.position = nullpos;\n    throwError(state, 'null byte is not allowed in input');\n  }\n\n  // Use 0 as string terminator. That significantly simplifies bounds check.\n  state.input += '\\0';\n\n  while (state.input.charCodeAt(state.position) === 0x20/* Space */) {\n    state.lineIndent += 1;\n    state.position += 1;\n  }\n\n  while (state.position < (state.length - 1)) {\n    readDocument(state);\n  }\n\n  return state.documents;\n}\n\n\nfunction loadAll(input, iterator, options) {\n  if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') {\n    options = iterator;\n    iterator = null;\n  }\n\n  var documents = loadDocuments(input, options);\n\n  if (typeof iterator !== 'function') {\n    return documents;\n  }\n\n  for (var index = 0, length = documents.length; index < length; index += 1) {\n    iterator(documents[index]);\n  }\n}\n\n\nfunction load(input, options) {\n  var documents = loadDocuments(input, options);\n\n  if (documents.length === 0) {\n    /*eslint-disable no-undefined*/\n    return undefined;\n  } else if (documents.length === 1) {\n    return documents[0];\n  }\n  throw new exception('expected a single document in the stream, but found more');\n}\n\n\nfunction safeLoadAll(input, iterator, options) {\n  if (typeof iterator === 'object' && iterator !== null && typeof options === 'undefined') {\n    options = iterator;\n    iterator = null;\n  }\n\n  return loadAll(input, iterator, common.extend({ schema: default_safe }, options));\n}\n\n\nfunction safeLoad(input, options) {\n  return load(input, common.extend({ schema: default_safe }, options));\n}\n\n\nvar loadAll_1     = loadAll;\nvar load_1        = load;\nvar safeLoadAll_1 = safeLoadAll;\nvar safeLoad_1    = safeLoad;\n\nvar loader = {\n\tloadAll: loadAll_1,\n\tload: load_1,\n\tsafeLoadAll: safeLoadAll_1,\n\tsafeLoad: safeLoad_1\n};\n\n/*eslint-disable no-use-before-define*/\n\n\n\n\n\n\nvar _toString$2       = Object.prototype.toString;\nvar _hasOwnProperty$3 = Object.prototype.hasOwnProperty;\n\nvar CHAR_TAB                  = 0x09; /* Tab */\nvar CHAR_LINE_FEED            = 0x0A; /* LF */\nvar CHAR_CARRIAGE_RETURN      = 0x0D; /* CR */\nvar CHAR_SPACE                = 0x20; /* Space */\nvar CHAR_EXCLAMATION          = 0x21; /* ! */\nvar CHAR_DOUBLE_QUOTE         = 0x22; /* \" */\nvar CHAR_SHARP                = 0x23; /* # */\nvar CHAR_PERCENT              = 0x25; /* % */\nvar CHAR_AMPERSAND            = 0x26; /* & */\nvar CHAR_SINGLE_QUOTE         = 0x27; /* ' */\nvar CHAR_ASTERISK             = 0x2A; /* * */\nvar CHAR_COMMA                = 0x2C; /* , */\nvar CHAR_MINUS                = 0x2D; /* - */\nvar CHAR_COLON                = 0x3A; /* : */\nvar CHAR_EQUALS               = 0x3D; /* = */\nvar CHAR_GREATER_THAN         = 0x3E; /* > */\nvar CHAR_QUESTION             = 0x3F; /* ? */\nvar CHAR_COMMERCIAL_AT        = 0x40; /* @ */\nvar CHAR_LEFT_SQUARE_BRACKET  = 0x5B; /* [ */\nvar CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */\nvar CHAR_GRAVE_ACCENT         = 0x60; /* ` */\nvar CHAR_LEFT_CURLY_BRACKET   = 0x7B; /* { */\nvar CHAR_VERTICAL_LINE        = 0x7C; /* | */\nvar CHAR_RIGHT_CURLY_BRACKET  = 0x7D; /* } */\n\nvar ESCAPE_SEQUENCES = {};\n\nESCAPE_SEQUENCES[0x00]   = '\\\\0';\nESCAPE_SEQUENCES[0x07]   = '\\\\a';\nESCAPE_SEQUENCES[0x08]   = '\\\\b';\nESCAPE_SEQUENCES[0x09]   = '\\\\t';\nESCAPE_SEQUENCES[0x0A]   = '\\\\n';\nESCAPE_SEQUENCES[0x0B]   = '\\\\v';\nESCAPE_SEQUENCES[0x0C]   = '\\\\f';\nESCAPE_SEQUENCES[0x0D]   = '\\\\r';\nESCAPE_SEQUENCES[0x1B]   = '\\\\e';\nESCAPE_SEQUENCES[0x22]   = '\\\\\"';\nESCAPE_SEQUENCES[0x5C]   = '\\\\\\\\';\nESCAPE_SEQUENCES[0x85]   = '\\\\N';\nESCAPE_SEQUENCES[0xA0]   = '\\\\_';\nESCAPE_SEQUENCES[0x2028] = '\\\\L';\nESCAPE_SEQUENCES[0x2029] = '\\\\P';\n\nvar DEPRECATED_BOOLEANS_SYNTAX = [\n  'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',\n  'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'\n];\n\nfunction compileStyleMap(schema, map) {\n  var result, keys, index, length, tag, style, type;\n\n  if (map === null) return {};\n\n  result = {};\n  keys = Object.keys(map);\n\n  for (index = 0, length = keys.length; index < length; index += 1) {\n    tag = keys[index];\n    style = String(map[tag]);\n\n    if (tag.slice(0, 2) === '!!') {\n      tag = 'tag:yaml.org,2002:' + tag.slice(2);\n    }\n    type = schema.compiledTypeMap['fallback'][tag];\n\n    if (type && _hasOwnProperty$3.call(type.styleAliases, style)) {\n      style = type.styleAliases[style];\n    }\n\n    result[tag] = style;\n  }\n\n  return result;\n}\n\nfunction encodeHex(character) {\n  var string, handle, length;\n\n  string = character.toString(16).toUpperCase();\n\n  if (character <= 0xFF) {\n    handle = 'x';\n    length = 2;\n  } else if (character <= 0xFFFF) {\n    handle = 'u';\n    length = 4;\n  } else if (character <= 0xFFFFFFFF) {\n    handle = 'U';\n    length = 8;\n  } else {\n    throw new exception('code point within a string may not be greater than 0xFFFFFFFF');\n  }\n\n  return '\\\\' + handle + common.repeat('0', length - string.length) + string;\n}\n\nfunction State$1(options) {\n  this.schema        = options['schema'] || default_full;\n  this.indent        = Math.max(1, (options['indent'] || 2));\n  this.noArrayIndent = options['noArrayIndent'] || false;\n  this.skipInvalid   = options['skipInvalid'] || false;\n  this.flowLevel     = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);\n  this.styleMap      = compileStyleMap(this.schema, options['styles'] || null);\n  this.sortKeys      = options['sortKeys'] || false;\n  this.lineWidth     = options['lineWidth'] || 80;\n  this.noRefs        = options['noRefs'] || false;\n  this.noCompatMode  = options['noCompatMode'] || false;\n  this.condenseFlow  = options['condenseFlow'] || false;\n\n  this.implicitTypes = this.schema.compiledImplicit;\n  this.explicitTypes = this.schema.compiledExplicit;\n\n  this.tag = null;\n  this.result = '';\n\n  this.duplicates = [];\n  this.usedDuplicates = null;\n}\n\n// Indents every line in a string. Empty lines (\\n only) are not indented.\nfunction indentString(string, spaces) {\n  var ind = common.repeat(' ', spaces),\n      position = 0,\n      next = -1,\n      result = '',\n      line,\n      length = string.length;\n\n  while (position < length) {\n    next = string.indexOf('\\n', position);\n    if (next === -1) {\n      line = string.slice(position);\n      position = length;\n    } else {\n      line = string.slice(position, next + 1);\n      position = next + 1;\n    }\n\n    if (line.length && line !== '\\n') result += ind;\n\n    result += line;\n  }\n\n  return result;\n}\n\nfunction generateNextLine(state, level) {\n  return '\\n' + common.repeat(' ', state.indent * level);\n}\n\nfunction testImplicitResolving(state, str) {\n  var index, length, type;\n\n  for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {\n    type = state.implicitTypes[index];\n\n    if (type.resolve(str)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n// [33] s-white ::= s-space | s-tab\nfunction isWhitespace(c) {\n  return c === CHAR_SPACE || c === CHAR_TAB;\n}\n\n// Returns true if the character can be printed without escaping.\n// From YAML 1.2: \"any allowed characters known to be non-printable\n// should also be escaped. [However,] This isn’t mandatory\"\n// Derived from nb-char - \\t - #x85 - #xA0 - #x2028 - #x2029.\nfunction isPrintable(c) {\n  return  (0x00020 <= c && c <= 0x00007E)\n      || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)\n      || ((0x0E000 <= c && c <= 0x00FFFD) && c !== 0xFEFF /* BOM */)\n      ||  (0x10000 <= c && c <= 0x10FFFF);\n}\n\n// [34] ns-char ::= nb-char - s-white\n// [27] nb-char ::= c-printable - b-char - c-byte-order-mark\n// [26] b-char  ::= b-line-feed | b-carriage-return\n// [24] b-line-feed       ::=     #xA    /* LF */\n// [25] b-carriage-return ::=     #xD    /* CR */\n// [3]  c-byte-order-mark ::=     #xFEFF\nfunction isNsChar(c) {\n  return isPrintable(c) && !isWhitespace(c)\n    // byte-order-mark\n    && c !== 0xFEFF\n    // b-char\n    && c !== CHAR_CARRIAGE_RETURN\n    && c !== CHAR_LINE_FEED;\n}\n\n// Simplified test for values allowed after the first character in plain style.\nfunction isPlainSafe(c, prev) {\n  // Uses a subset of nb-char - c-flow-indicator - \":\" - \"#\"\n  // where nb-char ::= c-printable - b-char - c-byte-order-mark.\n  return isPrintable(c) && c !== 0xFEFF\n    // - c-flow-indicator\n    && c !== CHAR_COMMA\n    && c !== CHAR_LEFT_SQUARE_BRACKET\n    && c !== CHAR_RIGHT_SQUARE_BRACKET\n    && c !== CHAR_LEFT_CURLY_BRACKET\n    && c !== CHAR_RIGHT_CURLY_BRACKET\n    // - \":\" - \"#\"\n    // /* An ns-char preceding */ \"#\"\n    && c !== CHAR_COLON\n    && ((c !== CHAR_SHARP) || (prev && isNsChar(prev)));\n}\n\n// Simplified test for values allowed as the first character in plain style.\nfunction isPlainSafeFirst(c) {\n  // Uses a subset of ns-char - c-indicator\n  // where ns-char = nb-char - s-white.\n  return isPrintable(c) && c !== 0xFEFF\n    && !isWhitespace(c) // - s-white\n    // - (c-indicator ::=\n    // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”\n    && c !== CHAR_MINUS\n    && c !== CHAR_QUESTION\n    && c !== CHAR_COLON\n    && c !== CHAR_COMMA\n    && c !== CHAR_LEFT_SQUARE_BRACKET\n    && c !== CHAR_RIGHT_SQUARE_BRACKET\n    && c !== CHAR_LEFT_CURLY_BRACKET\n    && c !== CHAR_RIGHT_CURLY_BRACKET\n    // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “\"”\n    && c !== CHAR_SHARP\n    && c !== CHAR_AMPERSAND\n    && c !== CHAR_ASTERISK\n    && c !== CHAR_EXCLAMATION\n    && c !== CHAR_VERTICAL_LINE\n    && c !== CHAR_EQUALS\n    && c !== CHAR_GREATER_THAN\n    && c !== CHAR_SINGLE_QUOTE\n    && c !== CHAR_DOUBLE_QUOTE\n    // | “%” | “@” | “`”)\n    && c !== CHAR_PERCENT\n    && c !== CHAR_COMMERCIAL_AT\n    && c !== CHAR_GRAVE_ACCENT;\n}\n\n// Determines whether block indentation indicator is required.\nfunction needIndentIndicator(string) {\n  var leadingSpaceRe = /^\\n* /;\n  return leadingSpaceRe.test(string);\n}\n\nvar STYLE_PLAIN   = 1,\n    STYLE_SINGLE  = 2,\n    STYLE_LITERAL = 3,\n    STYLE_FOLDED  = 4,\n    STYLE_DOUBLE  = 5;\n\n// Determines which scalar styles are possible and returns the preferred style.\n// lineWidth = -1 => no limit.\n// Pre-conditions: str.length > 0.\n// Post-conditions:\n//    STYLE_PLAIN or STYLE_SINGLE => no \\n are in the string.\n//    STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).\n//    STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).\nfunction chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) {\n  var i;\n  var char, prev_char;\n  var hasLineBreak = false;\n  var hasFoldableLine = false; // only checked if shouldTrackWidth\n  var shouldTrackWidth = lineWidth !== -1;\n  var previousLineBreak = -1; // count the first line correctly\n  var plain = isPlainSafeFirst(string.charCodeAt(0))\n          && !isWhitespace(string.charCodeAt(string.length - 1));\n\n  if (singleLineOnly) {\n    // Case: no block styles.\n    // Check for disallowed characters to rule out plain and single.\n    for (i = 0; i < string.length; i++) {\n      char = string.charCodeAt(i);\n      if (!isPrintable(char)) {\n        return STYLE_DOUBLE;\n      }\n      prev_char = i > 0 ? string.charCodeAt(i - 1) : null;\n      plain = plain && isPlainSafe(char, prev_char);\n    }\n  } else {\n    // Case: block styles permitted.\n    for (i = 0; i < string.length; i++) {\n      char = string.charCodeAt(i);\n      if (char === CHAR_LINE_FEED) {\n        hasLineBreak = true;\n        // Check if any line can be folded.\n        if (shouldTrackWidth) {\n          hasFoldableLine = hasFoldableLine ||\n            // Foldable line = too long, and not more-indented.\n            (i - previousLineBreak - 1 > lineWidth &&\n             string[previousLineBreak + 1] !== ' ');\n          previousLineBreak = i;\n        }\n      } else if (!isPrintable(char)) {\n        return STYLE_DOUBLE;\n      }\n      prev_char = i > 0 ? string.charCodeAt(i - 1) : null;\n      plain = plain && isPlainSafe(char, prev_char);\n    }\n    // in case the end is missing a \\n\n    hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&\n      (i - previousLineBreak - 1 > lineWidth &&\n       string[previousLineBreak + 1] !== ' '));\n  }\n  // Although every style can represent \\n without escaping, prefer block styles\n  // for multiline, since they're more readable and they don't add empty lines.\n  // Also prefer folding a super-long line.\n  if (!hasLineBreak && !hasFoldableLine) {\n    // Strings interpretable as another type have to be quoted;\n    // e.g. the string 'true' vs. the boolean true.\n    return plain && !testAmbiguousType(string)\n      ? STYLE_PLAIN : STYLE_SINGLE;\n  }\n  // Edge case: block indentation indicator can only have one digit.\n  if (indentPerLevel > 9 && needIndentIndicator(string)) {\n    return STYLE_DOUBLE;\n  }\n  // At this point we know block styles are valid.\n  // Prefer literal style unless we want to fold.\n  return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;\n}\n\n// Note: line breaking/folding is implemented for only the folded style.\n// NB. We drop the last trailing newline (if any) of a returned block scalar\n//  since the dumper adds its own newline. This always works:\n//    • No ending newline => unaffected; already using strip \"-\" chomping.\n//    • Ending newline    => removed then restored.\n//  Importantly, this keeps the \"+\" chomp indicator from gaining an extra line.\nfunction writeScalar(state, string, level, iskey) {\n  state.dump = (function () {\n    if (string.length === 0) {\n      return \"''\";\n    }\n    if (!state.noCompatMode &&\n        DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) {\n      return \"'\" + string + \"'\";\n    }\n\n    var indent = state.indent * Math.max(1, level); // no 0-indent scalars\n    // As indentation gets deeper, let the width decrease monotonically\n    // to the lower bound min(state.lineWidth, 40).\n    // Note that this implies\n    //  state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound.\n    //  state.lineWidth > 40 + state.indent: width decreases until the lower bound.\n    // This behaves better than a constant minimum width which disallows narrower options,\n    // or an indent threshold which causes the width to suddenly increase.\n    var lineWidth = state.lineWidth === -1\n      ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);\n\n    // Without knowing if keys are implicit/explicit, assume implicit for safety.\n    var singleLineOnly = iskey\n      // No block styles in flow mode.\n      || (state.flowLevel > -1 && level >= state.flowLevel);\n    function testAmbiguity(string) {\n      return testImplicitResolving(state, string);\n    }\n\n    switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) {\n      case STYLE_PLAIN:\n        return string;\n      case STYLE_SINGLE:\n        return \"'\" + string.replace(/'/g, \"''\") + \"'\";\n      case STYLE_LITERAL:\n        return '|' + blockHeader(string, state.indent)\n          + dropEndingNewline(indentString(string, indent));\n      case STYLE_FOLDED:\n        return '>' + blockHeader(string, state.indent)\n          + dropEndingNewline(indentString(foldString(string, lineWidth), indent));\n      case STYLE_DOUBLE:\n        return '\"' + escapeString(string) + '\"';\n      default:\n        throw new exception('impossible error: invalid scalar style');\n    }\n  }());\n}\n\n// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.\nfunction blockHeader(string, indentPerLevel) {\n  var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';\n\n  // note the special case: the string '\\n' counts as a \"trailing\" empty line.\n  var clip =          string[string.length - 1] === '\\n';\n  var keep = clip && (string[string.length - 2] === '\\n' || string === '\\n');\n  var chomp = keep ? '+' : (clip ? '' : '-');\n\n  return indentIndicator + chomp + '\\n';\n}\n\n// (See the note for writeScalar.)\nfunction dropEndingNewline(string) {\n  return string[string.length - 1] === '\\n' ? string.slice(0, -1) : string;\n}\n\n// Note: a long line without a suitable break point will exceed the width limit.\n// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.\nfunction foldString(string, width) {\n  // In folded style, $k$ consecutive newlines output as $k+1$ newlines—\n  // unless they're before or after a more-indented line, or at the very\n  // beginning or end, in which case $k$ maps to $k$.\n  // Therefore, parse each chunk as newline(s) followed by a content line.\n  var lineRe = /(\\n+)([^\\n]*)/g;\n\n  // first line (possibly an empty line)\n  var result = (function () {\n    var nextLF = string.indexOf('\\n');\n    nextLF = nextLF !== -1 ? nextLF : string.length;\n    lineRe.lastIndex = nextLF;\n    return foldLine(string.slice(0, nextLF), width);\n  }());\n  // If we haven't reached the first content line yet, don't add an extra \\n.\n  var prevMoreIndented = string[0] === '\\n' || string[0] === ' ';\n  var moreIndented;\n\n  // rest of the lines\n  var match;\n  while ((match = lineRe.exec(string))) {\n    var prefix = match[1], line = match[2];\n    moreIndented = (line[0] === ' ');\n    result += prefix\n      + (!prevMoreIndented && !moreIndented && line !== ''\n        ? '\\n' : '')\n      + foldLine(line, width);\n    prevMoreIndented = moreIndented;\n  }\n\n  return result;\n}\n\n// Greedy line breaking.\n// Picks the longest line under the limit each time,\n// otherwise settles for the shortest line over the limit.\n// NB. More-indented lines *cannot* be folded, as that would add an extra \\n.\nfunction foldLine(line, width) {\n  if (line === '' || line[0] === ' ') return line;\n\n  // Since a more-indented line adds a \\n, breaks can't be followed by a space.\n  var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.\n  var match;\n  // start is an inclusive index. end, curr, and next are exclusive.\n  var start = 0, end, curr = 0, next = 0;\n  var result = '';\n\n  // Invariants: 0 <= start <= length-1.\n  //   0 <= curr <= next <= max(0, length-2). curr - start <= width.\n  // Inside the loop:\n  //   A match implies length >= 2, so curr and next are <= length-2.\n  while ((match = breakRe.exec(line))) {\n    next = match.index;\n    // maintain invariant: curr - start <= width\n    if (next - start > width) {\n      end = (curr > start) ? curr : next; // derive end <= length-2\n      result += '\\n' + line.slice(start, end);\n      // skip the space that was output as \\n\n      start = end + 1;                    // derive start <= length-1\n    }\n    curr = next;\n  }\n\n  // By the invariants, start <= length-1, so there is something left over.\n  // It is either the whole string or a part starting from non-whitespace.\n  result += '\\n';\n  // Insert a break if the remainder is too long and there is a break available.\n  if (line.length - start > width && curr > start) {\n    result += line.slice(start, curr) + '\\n' + line.slice(curr + 1);\n  } else {\n    result += line.slice(start);\n  }\n\n  return result.slice(1); // drop extra \\n joiner\n}\n\n// Escapes a double-quoted string.\nfunction escapeString(string) {\n  var result = '';\n  var char, nextChar;\n  var escapeSeq;\n\n  for (var i = 0; i < string.length; i++) {\n    char = string.charCodeAt(i);\n    // Check for surrogate pairs (reference Unicode 3.0 section \"3.7 Surrogates\").\n    if (char >= 0xD800 && char <= 0xDBFF/* high surrogate */) {\n      nextChar = string.charCodeAt(i + 1);\n      if (nextChar >= 0xDC00 && nextChar <= 0xDFFF/* low surrogate */) {\n        // Combine the surrogate pair and store it escaped.\n        result += encodeHex((char - 0xD800) * 0x400 + nextChar - 0xDC00 + 0x10000);\n        // Advance index one extra since we already used that char here.\n        i++; continue;\n      }\n    }\n    escapeSeq = ESCAPE_SEQUENCES[char];\n    result += !escapeSeq && isPrintable(char)\n      ? string[i]\n      : escapeSeq || encodeHex(char);\n  }\n\n  return result;\n}\n\nfunction writeFlowSequence(state, level, object) {\n  var _result = '',\n      _tag    = state.tag,\n      index,\n      length;\n\n  for (index = 0, length = object.length; index < length; index += 1) {\n    // Write only valid elements.\n    if (writeNode(state, level, object[index], false, false)) {\n      if (index !== 0) _result += ',' + (!state.condenseFlow ? ' ' : '');\n      _result += state.dump;\n    }\n  }\n\n  state.tag = _tag;\n  state.dump = '[' + _result + ']';\n}\n\nfunction writeBlockSequence(state, level, object, compact) {\n  var _result = '',\n      _tag    = state.tag,\n      index,\n      length;\n\n  for (index = 0, length = object.length; index < length; index += 1) {\n    // Write only valid elements.\n    if (writeNode(state, level + 1, object[index], true, true)) {\n      if (!compact || index !== 0) {\n        _result += generateNextLine(state, level);\n      }\n\n      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {\n        _result += '-';\n      } else {\n        _result += '- ';\n      }\n\n      _result += state.dump;\n    }\n  }\n\n  state.tag = _tag;\n  state.dump = _result || '[]'; // Empty sequence if no valid values.\n}\n\nfunction writeFlowMapping(state, level, object) {\n  var _result       = '',\n      _tag          = state.tag,\n      objectKeyList = Object.keys(object),\n      index,\n      length,\n      objectKey,\n      objectValue,\n      pairBuffer;\n\n  for (index = 0, length = objectKeyList.length; index < length; index += 1) {\n\n    pairBuffer = '';\n    if (index !== 0) pairBuffer += ', ';\n\n    if (state.condenseFlow) pairBuffer += '\"';\n\n    objectKey = objectKeyList[index];\n    objectValue = object[objectKey];\n\n    if (!writeNode(state, level, objectKey, false, false)) {\n      continue; // Skip this pair because of invalid key;\n    }\n\n    if (state.dump.length > 1024) pairBuffer += '? ';\n\n    pairBuffer += state.dump + (state.condenseFlow ? '\"' : '') + ':' + (state.condenseFlow ? '' : ' ');\n\n    if (!writeNode(state, level, objectValue, false, false)) {\n      continue; // Skip this pair because of invalid value.\n    }\n\n    pairBuffer += state.dump;\n\n    // Both key and value are valid.\n    _result += pairBuffer;\n  }\n\n  state.tag = _tag;\n  state.dump = '{' + _result + '}';\n}\n\nfunction writeBlockMapping(state, level, object, compact) {\n  var _result       = '',\n      _tag          = state.tag,\n      objectKeyList = Object.keys(object),\n      index,\n      length,\n      objectKey,\n      objectValue,\n      explicitPair,\n      pairBuffer;\n\n  // Allow sorting keys so that the output file is deterministic\n  if (state.sortKeys === true) {\n    // Default sorting\n    objectKeyList.sort();\n  } else if (typeof state.sortKeys === 'function') {\n    // Custom sort function\n    objectKeyList.sort(state.sortKeys);\n  } else if (state.sortKeys) {\n    // Something is wrong\n    throw new exception('sortKeys must be a boolean or a function');\n  }\n\n  for (index = 0, length = objectKeyList.length; index < length; index += 1) {\n    pairBuffer = '';\n\n    if (!compact || index !== 0) {\n      pairBuffer += generateNextLine(state, level);\n    }\n\n    objectKey = objectKeyList[index];\n    objectValue = object[objectKey];\n\n    if (!writeNode(state, level + 1, objectKey, true, true, true)) {\n      continue; // Skip this pair because of invalid key.\n    }\n\n    explicitPair = (state.tag !== null && state.tag !== '?') ||\n                   (state.dump && state.dump.length > 1024);\n\n    if (explicitPair) {\n      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {\n        pairBuffer += '?';\n      } else {\n        pairBuffer += '? ';\n      }\n    }\n\n    pairBuffer += state.dump;\n\n    if (explicitPair) {\n      pairBuffer += generateNextLine(state, level);\n    }\n\n    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {\n      continue; // Skip this pair because of invalid value.\n    }\n\n    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {\n      pairBuffer += ':';\n    } else {\n      pairBuffer += ': ';\n    }\n\n    pairBuffer += state.dump;\n\n    // Both key and value are valid.\n    _result += pairBuffer;\n  }\n\n  state.tag = _tag;\n  state.dump = _result || '{}'; // Empty mapping if no valid pairs.\n}\n\nfunction detectType(state, object, explicit) {\n  var _result, typeList, index, length, type, style;\n\n  typeList = explicit ? state.explicitTypes : state.implicitTypes;\n\n  for (index = 0, length = typeList.length; index < length; index += 1) {\n    type = typeList[index];\n\n    if ((type.instanceOf  || type.predicate) &&\n        (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&\n        (!type.predicate  || type.predicate(object))) {\n\n      state.tag = explicit ? type.tag : '?';\n\n      if (type.represent) {\n        style = state.styleMap[type.tag] || type.defaultStyle;\n\n        if (_toString$2.call(type.represent) === '[object Function]') {\n          _result = type.represent(object, style);\n        } else if (_hasOwnProperty$3.call(type.represent, style)) {\n          _result = type.represent[style](object, style);\n        } else {\n          throw new exception('!<' + type.tag + '> tag resolver accepts not \"' + style + '\" style');\n        }\n\n        state.dump = _result;\n      }\n\n      return true;\n    }\n  }\n\n  return false;\n}\n\n// Serializes `object` and writes it to global `result`.\n// Returns true on success, or false on invalid object.\n//\nfunction writeNode(state, level, object, block, compact, iskey) {\n  state.tag = null;\n  state.dump = object;\n\n  if (!detectType(state, object, false)) {\n    detectType(state, object, true);\n  }\n\n  var type = _toString$2.call(state.dump);\n\n  if (block) {\n    block = (state.flowLevel < 0 || state.flowLevel > level);\n  }\n\n  var objectOrArray = type === '[object Object]' || type === '[object Array]',\n      duplicateIndex,\n      duplicate;\n\n  if (objectOrArray) {\n    duplicateIndex = state.duplicates.indexOf(object);\n    duplicate = duplicateIndex !== -1;\n  }\n\n  if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {\n    compact = false;\n  }\n\n  if (duplicate && state.usedDuplicates[duplicateIndex]) {\n    state.dump = '*ref_' + duplicateIndex;\n  } else {\n    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {\n      state.usedDuplicates[duplicateIndex] = true;\n    }\n    if (type === '[object Object]') {\n      if (block && (Object.keys(state.dump).length !== 0)) {\n        writeBlockMapping(state, level, state.dump, compact);\n        if (duplicate) {\n          state.dump = '&ref_' + duplicateIndex + state.dump;\n        }\n      } else {\n        writeFlowMapping(state, level, state.dump);\n        if (duplicate) {\n          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;\n        }\n      }\n    } else if (type === '[object Array]') {\n      var arrayLevel = (state.noArrayIndent && (level > 0)) ? level - 1 : level;\n      if (block && (state.dump.length !== 0)) {\n        writeBlockSequence(state, arrayLevel, state.dump, compact);\n        if (duplicate) {\n          state.dump = '&ref_' + duplicateIndex + state.dump;\n        }\n      } else {\n        writeFlowSequence(state, arrayLevel, state.dump);\n        if (duplicate) {\n          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;\n        }\n      }\n    } else if (type === '[object String]') {\n      if (state.tag !== '?') {\n        writeScalar(state, state.dump, level, iskey);\n      }\n    } else {\n      if (state.skipInvalid) return false;\n      throw new exception('unacceptable kind of an object to dump ' + type);\n    }\n\n    if (state.tag !== null && state.tag !== '?') {\n      state.dump = '!<' + state.tag + '> ' + state.dump;\n    }\n  }\n\n  return true;\n}\n\nfunction getDuplicateReferences(object, state) {\n  var objects = [],\n      duplicatesIndexes = [],\n      index,\n      length;\n\n  inspectNode(object, objects, duplicatesIndexes);\n\n  for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {\n    state.duplicates.push(objects[duplicatesIndexes[index]]);\n  }\n  state.usedDuplicates = new Array(length);\n}\n\nfunction inspectNode(object, objects, duplicatesIndexes) {\n  var objectKeyList,\n      index,\n      length;\n\n  if (object !== null && typeof object === 'object') {\n    index = objects.indexOf(object);\n    if (index !== -1) {\n      if (duplicatesIndexes.indexOf(index) === -1) {\n        duplicatesIndexes.push(index);\n      }\n    } else {\n      objects.push(object);\n\n      if (Array.isArray(object)) {\n        for (index = 0, length = object.length; index < length; index += 1) {\n          inspectNode(object[index], objects, duplicatesIndexes);\n        }\n      } else {\n        objectKeyList = Object.keys(object);\n\n        for (index = 0, length = objectKeyList.length; index < length; index += 1) {\n          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);\n        }\n      }\n    }\n  }\n}\n\nfunction dump(input, options) {\n  options = options || {};\n\n  var state = new State$1(options);\n\n  if (!state.noRefs) getDuplicateReferences(input, state);\n\n  if (writeNode(state, 0, input, true, true)) return state.dump + '\\n';\n\n  return '';\n}\n\nfunction safeDump(input, options) {\n  return dump(input, common.extend({ schema: default_safe }, options));\n}\n\nvar dump_1     = dump;\nvar safeDump_1 = safeDump;\n\nvar dumper = {\n\tdump: dump_1,\n\tsafeDump: safeDump_1\n};\n\nfunction deprecated(name) {\n  return function () {\n    throw new Error('Function ' + name + ' is deprecated and cannot be used.');\n  };\n}\n\n\nvar Type$1                = type;\nvar Schema$1              = schema;\nvar FAILSAFE_SCHEMA     = failsafe;\nvar JSON_SCHEMA         = json;\nvar CORE_SCHEMA         = core;\nvar DEFAULT_SAFE_SCHEMA = default_safe;\nvar DEFAULT_FULL_SCHEMA = default_full;\nvar load$1                = loader.load;\nvar loadAll$1             = loader.loadAll;\nvar safeLoad$1            = loader.safeLoad;\nvar safeLoadAll$1         = loader.safeLoadAll;\nvar dump$1                = dumper.dump;\nvar safeDump$1            = dumper.safeDump;\nvar YAMLException$1       = exception;\n\n// Deprecated schema names from JS-YAML 2.0.x\nvar MINIMAL_SCHEMA = failsafe;\nvar SAFE_SCHEMA    = default_safe;\nvar DEFAULT_SCHEMA = default_full;\n\n// Deprecated functions from JS-YAML 1.x.x\nvar scan           = deprecated('scan');\nvar parse          = deprecated('parse');\nvar compose        = deprecated('compose');\nvar addConstructor = deprecated('addConstructor');\n\nvar jsYaml = {\n\tType: Type$1,\n\tSchema: Schema$1,\n\tFAILSAFE_SCHEMA: FAILSAFE_SCHEMA,\n\tJSON_SCHEMA: JSON_SCHEMA,\n\tCORE_SCHEMA: CORE_SCHEMA,\n\tDEFAULT_SAFE_SCHEMA: DEFAULT_SAFE_SCHEMA,\n\tDEFAULT_FULL_SCHEMA: DEFAULT_FULL_SCHEMA,\n\tload: load$1,\n\tloadAll: loadAll$1,\n\tsafeLoad: safeLoad$1,\n\tsafeLoadAll: safeLoadAll$1,\n\tdump: dump$1,\n\tsafeDump: safeDump$1,\n\tYAMLException: YAMLException$1,\n\tMINIMAL_SCHEMA: MINIMAL_SCHEMA,\n\tSAFE_SCHEMA: SAFE_SCHEMA,\n\tDEFAULT_SCHEMA: DEFAULT_SCHEMA,\n\tscan: scan,\n\tparse: parse,\n\tcompose: compose,\n\taddConstructor: addConstructor\n};\n\nvar jsYaml$1 = jsYaml;\n\nconst callsites = () => {\n\tconst _prepareStackTrace = Error.prepareStackTrace;\n\tError.prepareStackTrace = (_, stack) => stack;\n\tconst stack = new Error().stack.slice(1);\n\tError.prepareStackTrace = _prepareStackTrace;\n\treturn stack;\n};\n\nvar callsites_1 = callsites;\n// TODO: Remove this for the next major release\nvar _default = callsites;\ncallsites_1.default = _default;\n\nvar callerCallsite = ({depth = 0} = {}) => {\n\tconst callers = [];\n\tconst callerFileSet = new Set();\n\n\tfor (const callsite of callsites_1()) {\n\t\tconst fileName = callsite.getFileName();\n\t\tconst hasReceiver = callsite.getTypeName() !== null && fileName !== null;\n\n\t\tif (!callerFileSet.has(fileName)) {\n\t\t\tcallerFileSet.add(fileName);\n\t\t\tcallers.unshift(callsite);\n\t\t}\n\n\t\tif (hasReceiver) {\n\t\t\treturn callers[depth];\n\t\t}\n\t}\n};\n\nvar colorName = {\r\n\t\"aliceblue\": [240, 248, 255],\r\n\t\"antiquewhite\": [250, 235, 215],\r\n\t\"aqua\": [0, 255, 255],\r\n\t\"aquamarine\": [127, 255, 212],\r\n\t\"azure\": [240, 255, 255],\r\n\t\"beige\": [245, 245, 220],\r\n\t\"bisque\": [255, 228, 196],\r\n\t\"black\": [0, 0, 0],\r\n\t\"blanchedalmond\": [255, 235, 205],\r\n\t\"blue\": [0, 0, 255],\r\n\t\"blueviolet\": [138, 43, 226],\r\n\t\"brown\": [165, 42, 42],\r\n\t\"burlywood\": [222, 184, 135],\r\n\t\"cadetblue\": [95, 158, 160],\r\n\t\"chartreuse\": [127, 255, 0],\r\n\t\"chocolate\": [210, 105, 30],\r\n\t\"coral\": [255, 127, 80],\r\n\t\"cornflowerblue\": [100, 149, 237],\r\n\t\"cornsilk\": [255, 248, 220],\r\n\t\"crimson\": [220, 20, 60],\r\n\t\"cyan\": [0, 255, 255],\r\n\t\"darkblue\": [0, 0, 139],\r\n\t\"darkcyan\": [0, 139, 139],\r\n\t\"darkgoldenrod\": [184, 134, 11],\r\n\t\"darkgray\": [169, 169, 169],\r\n\t\"darkgreen\": [0, 100, 0],\r\n\t\"darkgrey\": [169, 169, 169],\r\n\t\"darkkhaki\": [189, 183, 107],\r\n\t\"darkmagenta\": [139, 0, 139],\r\n\t\"darkolivegreen\": [85, 107, 47],\r\n\t\"darkorange\": [255, 140, 0],\r\n\t\"darkorchid\": [153, 50, 204],\r\n\t\"darkred\": [139, 0, 0],\r\n\t\"darksalmon\": [233, 150, 122],\r\n\t\"darkseagreen\": [143, 188, 143],\r\n\t\"darkslateblue\": [72, 61, 139],\r\n\t\"darkslategray\": [47, 79, 79],\r\n\t\"darkslategrey\": [47, 79, 79],\r\n\t\"darkturquoise\": [0, 206, 209],\r\n\t\"darkviolet\": [148, 0, 211],\r\n\t\"deeppink\": [255, 20, 147],\r\n\t\"deepskyblue\": [0, 191, 255],\r\n\t\"dimgray\": [105, 105, 105],\r\n\t\"dimgrey\": [105, 105, 105],\r\n\t\"dodgerblue\": [30, 144, 255],\r\n\t\"firebrick\": [178, 34, 34],\r\n\t\"floralwhite\": [255, 250, 240],\r\n\t\"forestgreen\": [34, 139, 34],\r\n\t\"fuchsia\": [255, 0, 255],\r\n\t\"gainsboro\": [220, 220, 220],\r\n\t\"ghostwhite\": [248, 248, 255],\r\n\t\"gold\": [255, 215, 0],\r\n\t\"goldenrod\": [218, 165, 32],\r\n\t\"gray\": [128, 128, 128],\r\n\t\"green\": [0, 128, 0],\r\n\t\"greenyellow\": [173, 255, 47],\r\n\t\"grey\": [128, 128, 128],\r\n\t\"honeydew\": [240, 255, 240],\r\n\t\"hotpink\": [255, 105, 180],\r\n\t\"indianred\": [205, 92, 92],\r\n\t\"indigo\": [75, 0, 130],\r\n\t\"ivory\": [255, 255, 240],\r\n\t\"khaki\": [240, 230, 140],\r\n\t\"lavender\": [230, 230, 250],\r\n\t\"lavenderblush\": [255, 240, 245],\r\n\t\"lawngreen\": [124, 252, 0],\r\n\t\"lemonchiffon\": [255, 250, 205],\r\n\t\"lightblue\": [173, 216, 230],\r\n\t\"lightcoral\": [240, 128, 128],\r\n\t\"lightcyan\": [224, 255, 255],\r\n\t\"lightgoldenrodyellow\": [250, 250, 210],\r\n\t\"lightgray\": [211, 211, 211],\r\n\t\"lightgreen\": [144, 238, 144],\r\n\t\"lightgrey\": [211, 211, 211],\r\n\t\"lightpink\": [255, 182, 193],\r\n\t\"lightsalmon\": [255, 160, 122],\r\n\t\"lightseagreen\": [32, 178, 170],\r\n\t\"lightskyblue\": [135, 206, 250],\r\n\t\"lightslategray\": [119, 136, 153],\r\n\t\"lightslategrey\": [119, 136, 153],\r\n\t\"lightsteelblue\": [176, 196, 222],\r\n\t\"lightyellow\": [255, 255, 224],\r\n\t\"lime\": [0, 255, 0],\r\n\t\"limegreen\": [50, 205, 50],\r\n\t\"linen\": [250, 240, 230],\r\n\t\"magenta\": [255, 0, 255],\r\n\t\"maroon\": [128, 0, 0],\r\n\t\"mediumaquamarine\": [102, 205, 170],\r\n\t\"mediumblue\": [0, 0, 205],\r\n\t\"mediumorchid\": [186, 85, 211],\r\n\t\"mediumpurple\": [147, 112, 219],\r\n\t\"mediumseagreen\": [60, 179, 113],\r\n\t\"mediumslateblue\": [123, 104, 238],\r\n\t\"mediumspringgreen\": [0, 250, 154],\r\n\t\"mediumturquoise\": [72, 209, 204],\r\n\t\"mediumvioletred\": [199, 21, 133],\r\n\t\"midnightblue\": [25, 25, 112],\r\n\t\"mintcream\": [245, 255, 250],\r\n\t\"mistyrose\": [255, 228, 225],\r\n\t\"moccasin\": [255, 228, 181],\r\n\t\"navajowhite\": [255, 222, 173],\r\n\t\"navy\": [0, 0, 128],\r\n\t\"oldlace\": [253, 245, 230],\r\n\t\"olive\": [128, 128, 0],\r\n\t\"olivedrab\": [107, 142, 35],\r\n\t\"orange\": [255, 165, 0],\r\n\t\"orangered\": [255, 69, 0],\r\n\t\"orchid\": [218, 112, 214],\r\n\t\"palegoldenrod\": [238, 232, 170],\r\n\t\"palegreen\": [152, 251, 152],\r\n\t\"paleturquoise\": [175, 238, 238],\r\n\t\"palevioletred\": [219, 112, 147],\r\n\t\"papayawhip\": [255, 239, 213],\r\n\t\"peachpuff\": [255, 218, 185],\r\n\t\"peru\": [205, 133, 63],\r\n\t\"pink\": [255, 192, 203],\r\n\t\"plum\": [221, 160, 221],\r\n\t\"powderblue\": [176, 224, 230],\r\n\t\"purple\": [128, 0, 128],\r\n\t\"rebeccapurple\": [102, 51, 153],\r\n\t\"red\": [255, 0, 0],\r\n\t\"rosybrown\": [188, 143, 143],\r\n\t\"royalblue\": [65, 105, 225],\r\n\t\"saddlebrown\": [139, 69, 19],\r\n\t\"salmon\": [250, 128, 114],\r\n\t\"sandybrown\": [244, 164, 96],\r\n\t\"seagreen\": [46, 139, 87],\r\n\t\"seashell\": [255, 245, 238],\r\n\t\"sienna\": [160, 82, 45],\r\n\t\"silver\": [192, 192, 192],\r\n\t\"skyblue\": [135, 206, 235],\r\n\t\"slateblue\": [106, 90, 205],\r\n\t\"slategray\": [112, 128, 144],\r\n\t\"slategrey\": [112, 128, 144],\r\n\t\"snow\": [255, 250, 250],\r\n\t\"springgreen\": [0, 255, 127],\r\n\t\"steelblue\": [70, 130, 180],\r\n\t\"tan\": [210, 180, 140],\r\n\t\"teal\": [0, 128, 128],\r\n\t\"thistle\": [216, 191, 216],\r\n\t\"tomato\": [255, 99, 71],\r\n\t\"turquoise\": [64, 224, 208],\r\n\t\"violet\": [238, 130, 238],\r\n\t\"wheat\": [245, 222, 179],\r\n\t\"white\": [255, 255, 255],\r\n\t\"whitesmoke\": [245, 245, 245],\r\n\t\"yellow\": [255, 255, 0],\r\n\t\"yellowgreen\": [154, 205, 50]\r\n};\n\n/* MIT license */\n/* eslint-disable no-mixed-operators */\n\n\n// NOTE: conversions should only return primitive values (i.e. arrays, or\n//       values that give correct `typeof` results).\n//       do not use box values types (i.e. Number(), String(), etc.)\n\nconst reverseKeywords = {};\nfor (const key of Object.keys(colorName)) {\n\treverseKeywords[colorName[key]] = key;\n}\n\nconst convert = {\n\trgb: {channels: 3, labels: 'rgb'},\n\thsl: {channels: 3, labels: 'hsl'},\n\thsv: {channels: 3, labels: 'hsv'},\n\thwb: {channels: 3, labels: 'hwb'},\n\tcmyk: {channels: 4, labels: 'cmyk'},\n\txyz: {channels: 3, labels: 'xyz'},\n\tlab: {channels: 3, labels: 'lab'},\n\tlch: {channels: 3, labels: 'lch'},\n\thex: {channels: 1, labels: ['hex']},\n\tkeyword: {channels: 1, labels: ['keyword']},\n\tansi16: {channels: 1, labels: ['ansi16']},\n\tansi256: {channels: 1, labels: ['ansi256']},\n\thcg: {channels: 3, labels: ['h', 'c', 'g']},\n\tapple: {channels: 3, labels: ['r16', 'g16', 'b16']},\n\tgray: {channels: 1, labels: ['gray']}\n};\n\nvar conversions = convert;\n\n// Hide .channels and .labels properties\nfor (const model of Object.keys(convert)) {\n\tif (!('channels' in convert[model])) {\n\t\tthrow new Error('missing channels property: ' + model);\n\t}\n\n\tif (!('labels' in convert[model])) {\n\t\tthrow new Error('missing channel labels property: ' + model);\n\t}\n\n\tif (convert[model].labels.length !== convert[model].channels) {\n\t\tthrow new Error('channel and label counts mismatch: ' + model);\n\t}\n\n\tconst {channels, labels} = convert[model];\n\tdelete convert[model].channels;\n\tdelete convert[model].labels;\n\tObject.defineProperty(convert[model], 'channels', {value: channels});\n\tObject.defineProperty(convert[model], 'labels', {value: labels});\n}\n\nconvert.rgb.hsl = function (rgb) {\n\tconst r = rgb[0] / 255;\n\tconst g = rgb[1] / 255;\n\tconst b = rgb[2] / 255;\n\tconst min = Math.min(r, g, b);\n\tconst max = Math.max(r, g, b);\n\tconst delta = max - min;\n\tlet h;\n\tlet s;\n\n\tif (max === min) {\n\t\th = 0;\n\t} else if (r === max) {\n\t\th = (g - b) / delta;\n\t} else if (g === max) {\n\t\th = 2 + (b - r) / delta;\n\t} else if (b === max) {\n\t\th = 4 + (r - g) / delta;\n\t}\n\n\th = Math.min(h * 60, 360);\n\n\tif (h < 0) {\n\t\th += 360;\n\t}\n\n\tconst l = (min + max) / 2;\n\n\tif (max === min) {\n\t\ts = 0;\n\t} else if (l <= 0.5) {\n\t\ts = delta / (max + min);\n\t} else {\n\t\ts = delta / (2 - max - min);\n\t}\n\n\treturn [h, s * 100, l * 100];\n};\n\nconvert.rgb.hsv = function (rgb) {\n\tlet rdif;\n\tlet gdif;\n\tlet bdif;\n\tlet h;\n\tlet s;\n\n\tconst r = rgb[0] / 255;\n\tconst g = rgb[1] / 255;\n\tconst b = rgb[2] / 255;\n\tconst v = Math.max(r, g, b);\n\tconst diff = v - Math.min(r, g, b);\n\tconst diffc = function (c) {\n\t\treturn (v - c) / 6 / diff + 1 / 2;\n\t};\n\n\tif (diff === 0) {\n\t\th = 0;\n\t\ts = 0;\n\t} else {\n\t\ts = diff / v;\n\t\trdif = diffc(r);\n\t\tgdif = diffc(g);\n\t\tbdif = diffc(b);\n\n\t\tif (r === v) {\n\t\t\th = bdif - gdif;\n\t\t} else if (g === v) {\n\t\t\th = (1 / 3) + rdif - bdif;\n\t\t} else if (b === v) {\n\t\t\th = (2 / 3) + gdif - rdif;\n\t\t}\n\n\t\tif (h < 0) {\n\t\t\th += 1;\n\t\t} else if (h > 1) {\n\t\t\th -= 1;\n\t\t}\n\t}\n\n\treturn [\n\t\th * 360,\n\t\ts * 100,\n\t\tv * 100\n\t];\n};\n\nconvert.rgb.hwb = function (rgb) {\n\tconst r = rgb[0];\n\tconst g = rgb[1];\n\tlet b = rgb[2];\n\tconst h = convert.rgb.hsl(rgb)[0];\n\tconst w = 1 / 255 * Math.min(r, Math.min(g, b));\n\n\tb = 1 - 1 / 255 * Math.max(r, Math.max(g, b));\n\n\treturn [h, w * 100, b * 100];\n};\n\nconvert.rgb.cmyk = function (rgb) {\n\tconst r = rgb[0] / 255;\n\tconst g = rgb[1] / 255;\n\tconst b = rgb[2] / 255;\n\n\tconst k = Math.min(1 - r, 1 - g, 1 - b);\n\tconst c = (1 - r - k) / (1 - k) || 0;\n\tconst m = (1 - g - k) / (1 - k) || 0;\n\tconst y = (1 - b - k) / (1 - k) || 0;\n\n\treturn [c * 100, m * 100, y * 100, k * 100];\n};\n\nfunction comparativeDistance(x, y) {\n\t/*\n\t\tSee https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance\n\t*/\n\treturn (\n\t\t((x[0] - y[0]) ** 2) +\n\t\t((x[1] - y[1]) ** 2) +\n\t\t((x[2] - y[2]) ** 2)\n\t);\n}\n\nconvert.rgb.keyword = function (rgb) {\n\tconst reversed = reverseKeywords[rgb];\n\tif (reversed) {\n\t\treturn reversed;\n\t}\n\n\tlet currentClosestDistance = Infinity;\n\tlet currentClosestKeyword;\n\n\tfor (const keyword of Object.keys(colorName)) {\n\t\tconst value = colorName[keyword];\n\n\t\t// Compute comparative distance\n\t\tconst distance = comparativeDistance(rgb, value);\n\n\t\t// Check if its less, if so set as closest\n\t\tif (distance < currentClosestDistance) {\n\t\t\tcurrentClosestDistance = distance;\n\t\t\tcurrentClosestKeyword = keyword;\n\t\t}\n\t}\n\n\treturn currentClosestKeyword;\n};\n\nconvert.keyword.rgb = function (keyword) {\n\treturn colorName[keyword];\n};\n\nconvert.rgb.xyz = function (rgb) {\n\tlet r = rgb[0] / 255;\n\tlet g = rgb[1] / 255;\n\tlet b = rgb[2] / 255;\n\n\t// Assume sRGB\n\tr = r > 0.04045 ? (((r + 0.055) / 1.055) ** 2.4) : (r / 12.92);\n\tg = g > 0.04045 ? (((g + 0.055) / 1.055) ** 2.4) : (g / 12.92);\n\tb = b > 0.04045 ? (((b + 0.055) / 1.055) ** 2.4) : (b / 12.92);\n\n\tconst x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);\n\tconst y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);\n\tconst z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);\n\n\treturn [x * 100, y * 100, z * 100];\n};\n\nconvert.rgb.lab = function (rgb) {\n\tconst xyz = convert.rgb.xyz(rgb);\n\tlet x = xyz[0];\n\tlet y = xyz[1];\n\tlet z = xyz[2];\n\n\tx /= 95.047;\n\ty /= 100;\n\tz /= 108.883;\n\n\tx = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);\n\ty = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);\n\tz = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);\n\n\tconst l = (116 * y) - 16;\n\tconst a = 500 * (x - y);\n\tconst b = 200 * (y - z);\n\n\treturn [l, a, b];\n};\n\nconvert.hsl.rgb = function (hsl) {\n\tconst h = hsl[0] / 360;\n\tconst s = hsl[1] / 100;\n\tconst l = hsl[2] / 100;\n\tlet t2;\n\tlet t3;\n\tlet val;\n\n\tif (s === 0) {\n\t\tval = l * 255;\n\t\treturn [val, val, val];\n\t}\n\n\tif (l < 0.5) {\n\t\tt2 = l * (1 + s);\n\t} else {\n\t\tt2 = l + s - l * s;\n\t}\n\n\tconst t1 = 2 * l - t2;\n\n\tconst rgb = [0, 0, 0];\n\tfor (let i = 0; i < 3; i++) {\n\t\tt3 = h + 1 / 3 * -(i - 1);\n\t\tif (t3 < 0) {\n\t\t\tt3++;\n\t\t}\n\n\t\tif (t3 > 1) {\n\t\t\tt3--;\n\t\t}\n\n\t\tif (6 * t3 < 1) {\n\t\t\tval = t1 + (t2 - t1) * 6 * t3;\n\t\t} else if (2 * t3 < 1) {\n\t\t\tval = t2;\n\t\t} else if (3 * t3 < 2) {\n\t\t\tval = t1 + (t2 - t1) * (2 / 3 - t3) * 6;\n\t\t} else {\n\t\t\tval = t1;\n\t\t}\n\n\t\trgb[i] = val * 255;\n\t}\n\n\treturn rgb;\n};\n\nconvert.hsl.hsv = function (hsl) {\n\tconst h = hsl[0];\n\tlet s = hsl[1] / 100;\n\tlet l = hsl[2] / 100;\n\tlet smin = s;\n\tconst lmin = Math.max(l, 0.01);\n\n\tl *= 2;\n\ts *= (l <= 1) ? l : 2 - l;\n\tsmin *= lmin <= 1 ? lmin : 2 - lmin;\n\tconst v = (l + s) / 2;\n\tconst sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);\n\n\treturn [h, sv * 100, v * 100];\n};\n\nconvert.hsv.rgb = function (hsv) {\n\tconst h = hsv[0] / 60;\n\tconst s = hsv[1] / 100;\n\tlet v = hsv[2] / 100;\n\tconst hi = Math.floor(h) % 6;\n\n\tconst f = h - Math.floor(h);\n\tconst p = 255 * v * (1 - s);\n\tconst q = 255 * v * (1 - (s * f));\n\tconst t = 255 * v * (1 - (s * (1 - f)));\n\tv *= 255;\n\n\tswitch (hi) {\n\t\tcase 0:\n\t\t\treturn [v, t, p];\n\t\tcase 1:\n\t\t\treturn [q, v, p];\n\t\tcase 2:\n\t\t\treturn [p, v, t];\n\t\tcase 3:\n\t\t\treturn [p, q, v];\n\t\tcase 4:\n\t\t\treturn [t, p, v];\n\t\tcase 5:\n\t\t\treturn [v, p, q];\n\t}\n};\n\nconvert.hsv.hsl = function (hsv) {\n\tconst h = hsv[0];\n\tconst s = hsv[1] / 100;\n\tconst v = hsv[2] / 100;\n\tconst vmin = Math.max(v, 0.01);\n\tlet sl;\n\tlet l;\n\n\tl = (2 - s) * v;\n\tconst lmin = (2 - s) * vmin;\n\tsl = s * vmin;\n\tsl /= (lmin <= 1) ? lmin : 2 - lmin;\n\tsl = sl || 0;\n\tl /= 2;\n\n\treturn [h, sl * 100, l * 100];\n};\n\n// http://dev.w3.org/csswg/css-color/#hwb-to-rgb\nconvert.hwb.rgb = function (hwb) {\n\tconst h = hwb[0] / 360;\n\tlet wh = hwb[1] / 100;\n\tlet bl = hwb[2] / 100;\n\tconst ratio = wh + bl;\n\tlet f;\n\n\t// Wh + bl cant be > 1\n\tif (ratio > 1) {\n\t\twh /= ratio;\n\t\tbl /= ratio;\n\t}\n\n\tconst i = Math.floor(6 * h);\n\tconst v = 1 - bl;\n\tf = 6 * h - i;\n\n\tif ((i & 0x01) !== 0) {\n\t\tf = 1 - f;\n\t}\n\n\tconst n = wh + f * (v - wh); // Linear interpolation\n\n\tlet r;\n\tlet g;\n\tlet b;\n\t/* eslint-disable max-statements-per-line,no-multi-spaces */\n\tswitch (i) {\n\t\tdefault:\n\t\tcase 6:\n\t\tcase 0: r = v;  g = n;  b = wh; break;\n\t\tcase 1: r = n;  g = v;  b = wh; break;\n\t\tcase 2: r = wh; g = v;  b = n; break;\n\t\tcase 3: r = wh; g = n;  b = v; break;\n\t\tcase 4: r = n;  g = wh; b = v; break;\n\t\tcase 5: r = v;  g = wh; b = n; break;\n\t}\n\t/* eslint-enable max-statements-per-line,no-multi-spaces */\n\n\treturn [r * 255, g * 255, b * 255];\n};\n\nconvert.cmyk.rgb = function (cmyk) {\n\tconst c = cmyk[0] / 100;\n\tconst m = cmyk[1] / 100;\n\tconst y = cmyk[2] / 100;\n\tconst k = cmyk[3] / 100;\n\n\tconst r = 1 - Math.min(1, c * (1 - k) + k);\n\tconst g = 1 - Math.min(1, m * (1 - k) + k);\n\tconst b = 1 - Math.min(1, y * (1 - k) + k);\n\n\treturn [r * 255, g * 255, b * 255];\n};\n\nconvert.xyz.rgb = function (xyz) {\n\tconst x = xyz[0] / 100;\n\tconst y = xyz[1] / 100;\n\tconst z = xyz[2] / 100;\n\tlet r;\n\tlet g;\n\tlet b;\n\n\tr = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);\n\tg = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);\n\tb = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);\n\n\t// Assume sRGB\n\tr = r > 0.0031308\n\t\t? ((1.055 * (r ** (1.0 / 2.4))) - 0.055)\n\t\t: r * 12.92;\n\n\tg = g > 0.0031308\n\t\t? ((1.055 * (g ** (1.0 / 2.4))) - 0.055)\n\t\t: g * 12.92;\n\n\tb = b > 0.0031308\n\t\t? ((1.055 * (b ** (1.0 / 2.4))) - 0.055)\n\t\t: b * 12.92;\n\n\tr = Math.min(Math.max(0, r), 1);\n\tg = Math.min(Math.max(0, g), 1);\n\tb = Math.min(Math.max(0, b), 1);\n\n\treturn [r * 255, g * 255, b * 255];\n};\n\nconvert.xyz.lab = function (xyz) {\n\tlet x = xyz[0];\n\tlet y = xyz[1];\n\tlet z = xyz[2];\n\n\tx /= 95.047;\n\ty /= 100;\n\tz /= 108.883;\n\n\tx = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);\n\ty = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);\n\tz = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);\n\n\tconst l = (116 * y) - 16;\n\tconst a = 500 * (x - y);\n\tconst b = 200 * (y - z);\n\n\treturn [l, a, b];\n};\n\nconvert.lab.xyz = function (lab) {\n\tconst l = lab[0];\n\tconst a = lab[1];\n\tconst b = lab[2];\n\tlet x;\n\tlet y;\n\tlet z;\n\n\ty = (l + 16) / 116;\n\tx = a / 500 + y;\n\tz = y - b / 200;\n\n\tconst y2 = y ** 3;\n\tconst x2 = x ** 3;\n\tconst z2 = z ** 3;\n\ty = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;\n\tx = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;\n\tz = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;\n\n\tx *= 95.047;\n\ty *= 100;\n\tz *= 108.883;\n\n\treturn [x, y, z];\n};\n\nconvert.lab.lch = function (lab) {\n\tconst l = lab[0];\n\tconst a = lab[1];\n\tconst b = lab[2];\n\tlet h;\n\n\tconst hr = Math.atan2(b, a);\n\th = hr * 360 / 2 / Math.PI;\n\n\tif (h < 0) {\n\t\th += 360;\n\t}\n\n\tconst c = Math.sqrt(a * a + b * b);\n\n\treturn [l, c, h];\n};\n\nconvert.lch.lab = function (lch) {\n\tconst l = lch[0];\n\tconst c = lch[1];\n\tconst h = lch[2];\n\n\tconst hr = h / 360 * 2 * Math.PI;\n\tconst a = c * Math.cos(hr);\n\tconst b = c * Math.sin(hr);\n\n\treturn [l, a, b];\n};\n\nconvert.rgb.ansi16 = function (args, saturation = null) {\n\tconst [r, g, b] = args;\n\tlet value = saturation === null ? convert.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization\n\n\tvalue = Math.round(value / 50);\n\n\tif (value === 0) {\n\t\treturn 30;\n\t}\n\n\tlet ansi = 30\n\t\t+ ((Math.round(b / 255) << 2)\n\t\t| (Math.round(g / 255) << 1)\n\t\t| Math.round(r / 255));\n\n\tif (value === 2) {\n\t\tansi += 60;\n\t}\n\n\treturn ansi;\n};\n\nconvert.hsv.ansi16 = function (args) {\n\t// Optimization here; we already know the value and don't need to get\n\t// it converted for us.\n\treturn convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);\n};\n\nconvert.rgb.ansi256 = function (args) {\n\tconst r = args[0];\n\tconst g = args[1];\n\tconst b = args[2];\n\n\t// We use the extended greyscale palette here, with the exception of\n\t// black and white. normal palette only has 4 greyscale shades.\n\tif (r === g && g === b) {\n\t\tif (r < 8) {\n\t\t\treturn 16;\n\t\t}\n\n\t\tif (r > 248) {\n\t\t\treturn 231;\n\t\t}\n\n\t\treturn Math.round(((r - 8) / 247) * 24) + 232;\n\t}\n\n\tconst ansi = 16\n\t\t+ (36 * Math.round(r / 255 * 5))\n\t\t+ (6 * Math.round(g / 255 * 5))\n\t\t+ Math.round(b / 255 * 5);\n\n\treturn ansi;\n};\n\nconvert.ansi16.rgb = function (args) {\n\tlet color = args % 10;\n\n\t// Handle greyscale\n\tif (color === 0 || color === 7) {\n\t\tif (args > 50) {\n\t\t\tcolor += 3.5;\n\t\t}\n\n\t\tcolor = color / 10.5 * 255;\n\n\t\treturn [color, color, color];\n\t}\n\n\tconst mult = (~~(args > 50) + 1) * 0.5;\n\tconst r = ((color & 1) * mult) * 255;\n\tconst g = (((color >> 1) & 1) * mult) * 255;\n\tconst b = (((color >> 2) & 1) * mult) * 255;\n\n\treturn [r, g, b];\n};\n\nconvert.ansi256.rgb = function (args) {\n\t// Handle greyscale\n\tif (args >= 232) {\n\t\tconst c = (args - 232) * 10 + 8;\n\t\treturn [c, c, c];\n\t}\n\n\targs -= 16;\n\n\tlet rem;\n\tconst r = Math.floor(args / 36) / 5 * 255;\n\tconst g = Math.floor((rem = args % 36) / 6) / 5 * 255;\n\tconst b = (rem % 6) / 5 * 255;\n\n\treturn [r, g, b];\n};\n\nconvert.rgb.hex = function (args) {\n\tconst integer = ((Math.round(args[0]) & 0xFF) << 16)\n\t\t+ ((Math.round(args[1]) & 0xFF) << 8)\n\t\t+ (Math.round(args[2]) & 0xFF);\n\n\tconst string = integer.toString(16).toUpperCase();\n\treturn '000000'.substring(string.length) + string;\n};\n\nconvert.hex.rgb = function (args) {\n\tconst match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);\n\tif (!match) {\n\t\treturn [0, 0, 0];\n\t}\n\n\tlet colorString = match[0];\n\n\tif (match[0].length === 3) {\n\t\tcolorString = colorString.split('').map(char => {\n\t\t\treturn char + char;\n\t\t}).join('');\n\t}\n\n\tconst integer = parseInt(colorString, 16);\n\tconst r = (integer >> 16) & 0xFF;\n\tconst g = (integer >> 8) & 0xFF;\n\tconst b = integer & 0xFF;\n\n\treturn [r, g, b];\n};\n\nconvert.rgb.hcg = function (rgb) {\n\tconst r = rgb[0] / 255;\n\tconst g = rgb[1] / 255;\n\tconst b = rgb[2] / 255;\n\tconst max = Math.max(Math.max(r, g), b);\n\tconst min = Math.min(Math.min(r, g), b);\n\tconst chroma = (max - min);\n\tlet grayscale;\n\tlet hue;\n\n\tif (chroma < 1) {\n\t\tgrayscale = min / (1 - chroma);\n\t} else {\n\t\tgrayscale = 0;\n\t}\n\n\tif (chroma <= 0) {\n\t\thue = 0;\n\t} else\n\tif (max === r) {\n\t\thue = ((g - b) / chroma) % 6;\n\t} else\n\tif (max === g) {\n\t\thue = 2 + (b - r) / chroma;\n\t} else {\n\t\thue = 4 + (r - g) / chroma;\n\t}\n\n\thue /= 6;\n\thue %= 1;\n\n\treturn [hue * 360, chroma * 100, grayscale * 100];\n};\n\nconvert.hsl.hcg = function (hsl) {\n\tconst s = hsl[1] / 100;\n\tconst l = hsl[2] / 100;\n\n\tconst c = l < 0.5 ? (2.0 * s * l) : (2.0 * s * (1.0 - l));\n\n\tlet f = 0;\n\tif (c < 1.0) {\n\t\tf = (l - 0.5 * c) / (1.0 - c);\n\t}\n\n\treturn [hsl[0], c * 100, f * 100];\n};\n\nconvert.hsv.hcg = function (hsv) {\n\tconst s = hsv[1] / 100;\n\tconst v = hsv[2] / 100;\n\n\tconst c = s * v;\n\tlet f = 0;\n\n\tif (c < 1.0) {\n\t\tf = (v - c) / (1 - c);\n\t}\n\n\treturn [hsv[0], c * 100, f * 100];\n};\n\nconvert.hcg.rgb = function (hcg) {\n\tconst h = hcg[0] / 360;\n\tconst c = hcg[1] / 100;\n\tconst g = hcg[2] / 100;\n\n\tif (c === 0.0) {\n\t\treturn [g * 255, g * 255, g * 255];\n\t}\n\n\tconst pure = [0, 0, 0];\n\tconst hi = (h % 1) * 6;\n\tconst v = hi % 1;\n\tconst w = 1 - v;\n\tlet mg = 0;\n\n\t/* eslint-disable max-statements-per-line */\n\tswitch (Math.floor(hi)) {\n\t\tcase 0:\n\t\t\tpure[0] = 1; pure[1] = v; pure[2] = 0; break;\n\t\tcase 1:\n\t\t\tpure[0] = w; pure[1] = 1; pure[2] = 0; break;\n\t\tcase 2:\n\t\t\tpure[0] = 0; pure[1] = 1; pure[2] = v; break;\n\t\tcase 3:\n\t\t\tpure[0] = 0; pure[1] = w; pure[2] = 1; break;\n\t\tcase 4:\n\t\t\tpure[0] = v; pure[1] = 0; pure[2] = 1; break;\n\t\tdefault:\n\t\t\tpure[0] = 1; pure[1] = 0; pure[2] = w;\n\t}\n\t/* eslint-enable max-statements-per-line */\n\n\tmg = (1.0 - c) * g;\n\n\treturn [\n\t\t(c * pure[0] + mg) * 255,\n\t\t(c * pure[1] + mg) * 255,\n\t\t(c * pure[2] + mg) * 255\n\t];\n};\n\nconvert.hcg.hsv = function (hcg) {\n\tconst c = hcg[1] / 100;\n\tconst g = hcg[2] / 100;\n\n\tconst v = c + g * (1.0 - c);\n\tlet f = 0;\n\n\tif (v > 0.0) {\n\t\tf = c / v;\n\t}\n\n\treturn [hcg[0], f * 100, v * 100];\n};\n\nconvert.hcg.hsl = function (hcg) {\n\tconst c = hcg[1] / 100;\n\tconst g = hcg[2] / 100;\n\n\tconst l = g * (1.0 - c) + 0.5 * c;\n\tlet s = 0;\n\n\tif (l > 0.0 && l < 0.5) {\n\t\ts = c / (2 * l);\n\t} else\n\tif (l >= 0.5 && l < 1.0) {\n\t\ts = c / (2 * (1 - l));\n\t}\n\n\treturn [hcg[0], s * 100, l * 100];\n};\n\nconvert.hcg.hwb = function (hcg) {\n\tconst c = hcg[1] / 100;\n\tconst g = hcg[2] / 100;\n\tconst v = c + g * (1.0 - c);\n\treturn [hcg[0], (v - c) * 100, (1 - v) * 100];\n};\n\nconvert.hwb.hcg = function (hwb) {\n\tconst w = hwb[1] / 100;\n\tconst b = hwb[2] / 100;\n\tconst v = 1 - b;\n\tconst c = v - w;\n\tlet g = 0;\n\n\tif (c < 1) {\n\t\tg = (v - c) / (1 - c);\n\t}\n\n\treturn [hwb[0], c * 100, g * 100];\n};\n\nconvert.apple.rgb = function (apple) {\n\treturn [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];\n};\n\nconvert.rgb.apple = function (rgb) {\n\treturn [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];\n};\n\nconvert.gray.rgb = function (args) {\n\treturn [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];\n};\n\nconvert.gray.hsl = function (args) {\n\treturn [0, 0, args[0]];\n};\n\nconvert.gray.hsv = convert.gray.hsl;\n\nconvert.gray.hwb = function (gray) {\n\treturn [0, 100, gray[0]];\n};\n\nconvert.gray.cmyk = function (gray) {\n\treturn [0, 0, 0, gray[0]];\n};\n\nconvert.gray.lab = function (gray) {\n\treturn [gray[0], 0, 0];\n};\n\nconvert.gray.hex = function (gray) {\n\tconst val = Math.round(gray[0] / 100 * 255) & 0xFF;\n\tconst integer = (val << 16) + (val << 8) + val;\n\n\tconst string = integer.toString(16).toUpperCase();\n\treturn '000000'.substring(string.length) + string;\n};\n\nconvert.rgb.gray = function (rgb) {\n\tconst val = (rgb[0] + rgb[1] + rgb[2]) / 3;\n\treturn [val / 255 * 100];\n};\n\n/*\n\tThis function routes a model to all other models.\n\n\tall functions that are routed have a property `.conversion` attached\n\tto the returned synthetic function. This property is an array\n\tof strings, each with the steps in between the 'from' and 'to'\n\tcolor models (inclusive).\n\n\tconversions that are not possible simply are not included.\n*/\n\nfunction buildGraph() {\n\tconst graph = {};\n\t// https://jsperf.com/object-keys-vs-for-in-with-closure/3\n\tconst models = Object.keys(conversions);\n\n\tfor (let len = models.length, i = 0; i < len; i++) {\n\t\tgraph[models[i]] = {\n\t\t\t// http://jsperf.com/1-vs-infinity\n\t\t\t// micro-opt, but this is simple.\n\t\t\tdistance: -1,\n\t\t\tparent: null\n\t\t};\n\t}\n\n\treturn graph;\n}\n\n// https://en.wikipedia.org/wiki/Breadth-first_search\nfunction deriveBFS(fromModel) {\n\tconst graph = buildGraph();\n\tconst queue = [fromModel]; // Unshift -> queue -> pop\n\n\tgraph[fromModel].distance = 0;\n\n\twhile (queue.length) {\n\t\tconst current = queue.pop();\n\t\tconst adjacents = Object.keys(conversions[current]);\n\n\t\tfor (let len = adjacents.length, i = 0; i < len; i++) {\n\t\t\tconst adjacent = adjacents[i];\n\t\t\tconst node = graph[adjacent];\n\n\t\t\tif (node.distance === -1) {\n\t\t\t\tnode.distance = graph[current].distance + 1;\n\t\t\t\tnode.parent = current;\n\t\t\t\tqueue.unshift(adjacent);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn graph;\n}\n\nfunction link(from, to) {\n\treturn function (args) {\n\t\treturn to(from(args));\n\t};\n}\n\nfunction wrapConversion(toModel, graph) {\n\tconst path = [graph[toModel].parent, toModel];\n\tlet fn = conversions[graph[toModel].parent][toModel];\n\n\tlet cur = graph[toModel].parent;\n\twhile (graph[cur].parent) {\n\t\tpath.unshift(graph[cur].parent);\n\t\tfn = link(conversions[graph[cur].parent][cur], fn);\n\t\tcur = graph[cur].parent;\n\t}\n\n\tfn.conversion = path;\n\treturn fn;\n}\n\nvar route = function (fromModel) {\n\tconst graph = deriveBFS(fromModel);\n\tconst conversion = {};\n\n\tconst models = Object.keys(graph);\n\tfor (let len = models.length, i = 0; i < len; i++) {\n\t\tconst toModel = models[i];\n\t\tconst node = graph[toModel];\n\n\t\tif (node.parent === null) {\n\t\t\t// No possible conversion, or this node is the source model.\n\t\t\tcontinue;\n\t\t}\n\n\t\tconversion[toModel] = wrapConversion(toModel, graph);\n\t}\n\n\treturn conversion;\n};\n\nconst convert$1 = {};\n\nconst models = Object.keys(conversions);\n\nfunction wrapRaw(fn) {\n\tconst wrappedFn = function (...args) {\n\t\tconst arg0 = args[0];\n\t\tif (arg0 === undefined || arg0 === null) {\n\t\t\treturn arg0;\n\t\t}\n\n\t\tif (arg0.length > 1) {\n\t\t\targs = arg0;\n\t\t}\n\n\t\treturn fn(args);\n\t};\n\n\t// Preserve .conversion property if there is one\n\tif ('conversion' in fn) {\n\t\twrappedFn.conversion = fn.conversion;\n\t}\n\n\treturn wrappedFn;\n}\n\nfunction wrapRounded(fn) {\n\tconst wrappedFn = function (...args) {\n\t\tconst arg0 = args[0];\n\n\t\tif (arg0 === undefined || arg0 === null) {\n\t\t\treturn arg0;\n\t\t}\n\n\t\tif (arg0.length > 1) {\n\t\t\targs = arg0;\n\t\t}\n\n\t\tconst result = fn(args);\n\n\t\t// We're assuming the result is an array here.\n\t\t// see notice in conversions.js; don't use box types\n\t\t// in conversion functions.\n\t\tif (typeof result === 'object') {\n\t\t\tfor (let len = result.length, i = 0; i < len; i++) {\n\t\t\t\tresult[i] = Math.round(result[i]);\n\t\t\t}\n\t\t}\n\n\t\treturn result;\n\t};\n\n\t// Preserve .conversion property if there is one\n\tif ('conversion' in fn) {\n\t\twrappedFn.conversion = fn.conversion;\n\t}\n\n\treturn wrappedFn;\n}\n\nmodels.forEach(fromModel => {\n\tconvert$1[fromModel] = {};\n\n\tObject.defineProperty(convert$1[fromModel], 'channels', {value: conversions[fromModel].channels});\n\tObject.defineProperty(convert$1[fromModel], 'labels', {value: conversions[fromModel].labels});\n\n\tconst routes = route(fromModel);\n\tconst routeModels = Object.keys(routes);\n\n\trouteModels.forEach(toModel => {\n\t\tconst fn = routes[toModel];\n\n\t\tconvert$1[fromModel][toModel] = wrapRounded(fn);\n\t\tconvert$1[fromModel][toModel].raw = wrapRaw(fn);\n\t});\n});\n\nvar colorConvert = convert$1;\n\nvar ansiStyles = createCommonjsModule(function (module) {\n\nconst wrapAnsi16 = (fn, offset) => (...args) => {\n\tconst code = fn(...args);\n\treturn `\\u001B[${code + offset}m`;\n};\n\nconst wrapAnsi256 = (fn, offset) => (...args) => {\n\tconst code = fn(...args);\n\treturn `\\u001B[${38 + offset};5;${code}m`;\n};\n\nconst wrapAnsi16m = (fn, offset) => (...args) => {\n\tconst rgb = fn(...args);\n\treturn `\\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;\n};\n\nconst ansi2ansi = n => n;\nconst rgb2rgb = (r, g, b) => [r, g, b];\n\nconst setLazyProperty = (object, property, get) => {\n\tObject.defineProperty(object, property, {\n\t\tget: () => {\n\t\t\tconst value = get();\n\n\t\t\tObject.defineProperty(object, property, {\n\t\t\t\tvalue,\n\t\t\t\tenumerable: true,\n\t\t\t\tconfigurable: true\n\t\t\t});\n\n\t\t\treturn value;\n\t\t},\n\t\tenumerable: true,\n\t\tconfigurable: true\n\t});\n};\n\n/** @type {typeof import('color-convert')} */\nlet colorConvert$1;\nconst makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {\n\tif (colorConvert$1 === undefined) {\n\t\tcolorConvert$1 = colorConvert;\n\t}\n\n\tconst offset = isBackground ? 10 : 0;\n\tconst styles = {};\n\n\tfor (const [sourceSpace, suite] of Object.entries(colorConvert$1)) {\n\t\tconst name = sourceSpace === 'ansi16' ? 'ansi' : sourceSpace;\n\t\tif (sourceSpace === targetSpace) {\n\t\t\tstyles[name] = wrap(identity, offset);\n\t\t} else if (typeof suite === 'object') {\n\t\t\tstyles[name] = wrap(suite[targetSpace], offset);\n\t\t}\n\t}\n\n\treturn styles;\n};\n\nfunction assembleStyles() {\n\tconst codes = new Map();\n\tconst styles = {\n\t\tmodifier: {\n\t\t\treset: [0, 0],\n\t\t\t// 21 isn't widely supported and 22 does the same thing\n\t\t\tbold: [1, 22],\n\t\t\tdim: [2, 22],\n\t\t\titalic: [3, 23],\n\t\t\tunderline: [4, 24],\n\t\t\tinverse: [7, 27],\n\t\t\thidden: [8, 28],\n\t\t\tstrikethrough: [9, 29]\n\t\t},\n\t\tcolor: {\n\t\t\tblack: [30, 39],\n\t\t\tred: [31, 39],\n\t\t\tgreen: [32, 39],\n\t\t\tyellow: [33, 39],\n\t\t\tblue: [34, 39],\n\t\t\tmagenta: [35, 39],\n\t\t\tcyan: [36, 39],\n\t\t\twhite: [37, 39],\n\n\t\t\t// Bright color\n\t\t\tblackBright: [90, 39],\n\t\t\tredBright: [91, 39],\n\t\t\tgreenBright: [92, 39],\n\t\t\tyellowBright: [93, 39],\n\t\t\tblueBright: [94, 39],\n\t\t\tmagentaBright: [95, 39],\n\t\t\tcyanBright: [96, 39],\n\t\t\twhiteBright: [97, 39]\n\t\t},\n\t\tbgColor: {\n\t\t\tbgBlack: [40, 49],\n\t\t\tbgRed: [41, 49],\n\t\t\tbgGreen: [42, 49],\n\t\t\tbgYellow: [43, 49],\n\t\t\tbgBlue: [44, 49],\n\t\t\tbgMagenta: [45, 49],\n\t\t\tbgCyan: [46, 49],\n\t\t\tbgWhite: [47, 49],\n\n\t\t\t// Bright color\n\t\t\tbgBlackBright: [100, 49],\n\t\t\tbgRedBright: [101, 49],\n\t\t\tbgGreenBright: [102, 49],\n\t\t\tbgYellowBright: [103, 49],\n\t\t\tbgBlueBright: [104, 49],\n\t\t\tbgMagentaBright: [105, 49],\n\t\t\tbgCyanBright: [106, 49],\n\t\t\tbgWhiteBright: [107, 49]\n\t\t}\n\t};\n\n\t// Alias bright black as gray (and grey)\n\tstyles.color.gray = styles.color.blackBright;\n\tstyles.bgColor.bgGray = styles.bgColor.bgBlackBright;\n\tstyles.color.grey = styles.color.blackBright;\n\tstyles.bgColor.bgGrey = styles.bgColor.bgBlackBright;\n\n\tfor (const [groupName, group] of Object.entries(styles)) {\n\t\tfor (const [styleName, style] of Object.entries(group)) {\n\t\t\tstyles[styleName] = {\n\t\t\t\topen: `\\u001B[${style[0]}m`,\n\t\t\t\tclose: `\\u001B[${style[1]}m`\n\t\t\t};\n\n\t\t\tgroup[styleName] = styles[styleName];\n\n\t\t\tcodes.set(style[0], style[1]);\n\t\t}\n\n\t\tObject.defineProperty(styles, groupName, {\n\t\t\tvalue: group,\n\t\t\tenumerable: false\n\t\t});\n\t}\n\n\tObject.defineProperty(styles, 'codes', {\n\t\tvalue: codes,\n\t\tenumerable: false\n\t});\n\n\tstyles.color.close = '\\u001B[39m';\n\tstyles.bgColor.close = '\\u001B[49m';\n\n\tsetLazyProperty(styles.color, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, false));\n\tsetLazyProperty(styles.color, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, false));\n\tsetLazyProperty(styles.color, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, false));\n\tsetLazyProperty(styles.bgColor, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, true));\n\tsetLazyProperty(styles.bgColor, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, true));\n\tsetLazyProperty(styles.bgColor, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, true));\n\n\treturn styles;\n}\n\n// Make the export immutable\nObject.defineProperty(module, 'exports', {\n\tenumerable: true,\n\tget: assembleStyles\n});\n});\n\nvar hasFlag = (flag, argv = process.argv) => {\n\tconst prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');\n\tconst position = argv.indexOf(prefix + flag);\n\tconst terminatorPosition = argv.indexOf('--');\n\treturn position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);\n};\n\nconst {env} = process;\n\nlet forceColor;\nif (hasFlag('no-color') ||\n\thasFlag('no-colors') ||\n\thasFlag('color=false') ||\n\thasFlag('color=never')) {\n\tforceColor = 0;\n} else if (hasFlag('color') ||\n\thasFlag('colors') ||\n\thasFlag('color=true') ||\n\thasFlag('color=always')) {\n\tforceColor = 1;\n}\n\nif ('FORCE_COLOR' in env) {\n\tif (env.FORCE_COLOR === 'true') {\n\t\tforceColor = 1;\n\t} else if (env.FORCE_COLOR === 'false') {\n\t\tforceColor = 0;\n\t} else {\n\t\tforceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);\n\t}\n}\n\nfunction translateLevel(level) {\n\tif (level === 0) {\n\t\treturn false;\n\t}\n\n\treturn {\n\t\tlevel,\n\t\thasBasic: true,\n\t\thas256: level >= 2,\n\t\thas16m: level >= 3\n\t};\n}\n\nfunction supportsColor(haveStream, streamIsTTY) {\n\tif (forceColor === 0) {\n\t\treturn 0;\n\t}\n\n\tif (hasFlag('color=16m') ||\n\t\thasFlag('color=full') ||\n\t\thasFlag('color=truecolor')) {\n\t\treturn 3;\n\t}\n\n\tif (hasFlag('color=256')) {\n\t\treturn 2;\n\t}\n\n\tif (haveStream && !streamIsTTY && forceColor === undefined) {\n\t\treturn 0;\n\t}\n\n\tconst min = forceColor || 0;\n\n\tif (env.TERM === 'dumb') {\n\t\treturn min;\n\t}\n\n\tif (process.platform === 'win32') {\n\t\t// Windows 10 build 10586 is the first Windows release that supports 256 colors.\n\t\t// Windows 10 build 14931 is the first release that supports 16m/TrueColor.\n\t\tconst osRelease = os.release().split('.');\n\t\tif (\n\t\t\tNumber(osRelease[0]) >= 10 &&\n\t\t\tNumber(osRelease[2]) >= 10586\n\t\t) {\n\t\t\treturn Number(osRelease[2]) >= 14931 ? 3 : 2;\n\t\t}\n\n\t\treturn 1;\n\t}\n\n\tif ('CI' in env) {\n\t\tif (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {\n\t\t\treturn 1;\n\t\t}\n\n\t\treturn min;\n\t}\n\n\tif ('TEAMCITY_VERSION' in env) {\n\t\treturn /^(9\\.(0*[1-9]\\d*)\\.|\\d{2,}\\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;\n\t}\n\n\tif ('GITHUB_ACTIONS' in env) {\n\t\treturn 1;\n\t}\n\n\tif (env.COLORTERM === 'truecolor') {\n\t\treturn 3;\n\t}\n\n\tif ('TERM_PROGRAM' in env) {\n\t\tconst version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);\n\n\t\tswitch (env.TERM_PROGRAM) {\n\t\t\tcase 'iTerm.app':\n\t\t\t\treturn version >= 3 ? 3 : 2;\n\t\t\tcase 'Apple_Terminal':\n\t\t\t\treturn 2;\n\t\t\t// No default\n\t\t}\n\t}\n\n\tif (/-256(color)?$/i.test(env.TERM)) {\n\t\treturn 2;\n\t}\n\n\tif (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {\n\t\treturn 1;\n\t}\n\n\tif ('COLORTERM' in env) {\n\t\treturn 1;\n\t}\n\n\treturn min;\n}\n\nfunction getSupportLevel(stream) {\n\tconst level = supportsColor(stream, stream && stream.isTTY);\n\treturn translateLevel(level);\n}\n\nvar supportsColor_1 = {\n\tsupportsColor: getSupportLevel,\n\tstdout: translateLevel(supportsColor(true, tty.isatty(1))),\n\tstderr: translateLevel(supportsColor(true, tty.isatty(2)))\n};\n\nconst stringReplaceAll = (string, substring, replacer) => {\n\tlet index = string.indexOf(substring);\n\tif (index === -1) {\n\t\treturn string;\n\t}\n\n\tconst substringLength = substring.length;\n\tlet endIndex = 0;\n\tlet returnValue = '';\n\tdo {\n\t\treturnValue += string.substr(endIndex, index - endIndex) + substring + replacer;\n\t\tendIndex = index + substringLength;\n\t\tindex = string.indexOf(substring, endIndex);\n\t} while (index !== -1);\n\n\treturnValue += string.substr(endIndex);\n\treturn returnValue;\n};\n\nconst stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {\n\tlet endIndex = 0;\n\tlet returnValue = '';\n\tdo {\n\t\tconst gotCR = string[index - 1] === '\\r';\n\t\treturnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? '\\r\\n' : '\\n') + postfix;\n\t\tendIndex = index + 1;\n\t\tindex = string.indexOf('\\n', endIndex);\n\t} while (index !== -1);\n\n\treturnValue += string.substr(endIndex);\n\treturn returnValue;\n};\n\nvar util = {\n\tstringReplaceAll,\n\tstringEncaseCRLFWithFirstIndex\n};\n\nconst TEMPLATE_REGEX = /(?:\\\\(u(?:[a-f\\d]{4}|\\{[a-f\\d]{1,6}\\})|x[a-f\\d]{2}|.))|(?:\\{(~)?(\\w+(?:\\([^)]*\\))?(?:\\.\\w+(?:\\([^)]*\\))?)*)(?:[ \\t]|(?=\\r?\\n)))|(\\})|((?:.|[\\r\\n\\f])+?)/gi;\nconst STYLE_REGEX = /(?:^|\\.)(\\w+)(?:\\(([^)]*)\\))?/g;\nconst STRING_REGEX = /^(['\"])((?:\\\\.|(?!\\1)[^\\\\])*)\\1$/;\nconst ESCAPE_REGEX = /\\\\(u(?:[a-f\\d]{4}|{[a-f\\d]{1,6}})|x[a-f\\d]{2}|.)|([^\\\\])/gi;\n\nconst ESCAPES = new Map([\n\t['n', '\\n'],\n\t['r', '\\r'],\n\t['t', '\\t'],\n\t['b', '\\b'],\n\t['f', '\\f'],\n\t['v', '\\v'],\n\t['0', '\\0'],\n\t['\\\\', '\\\\'],\n\t['e', '\\u001B'],\n\t['a', '\\u0007']\n]);\n\nfunction unescape$1(c) {\n\tconst u = c[0] === 'u';\n\tconst bracket = c[1] === '{';\n\n\tif ((u && !bracket && c.length === 5) || (c[0] === 'x' && c.length === 3)) {\n\t\treturn String.fromCharCode(parseInt(c.slice(1), 16));\n\t}\n\n\tif (u && bracket) {\n\t\treturn String.fromCodePoint(parseInt(c.slice(2, -1), 16));\n\t}\n\n\treturn ESCAPES.get(c) || c;\n}\n\nfunction parseArguments(name, arguments_) {\n\tconst results = [];\n\tconst chunks = arguments_.trim().split(/\\s*,\\s*/g);\n\tlet matches;\n\n\tfor (const chunk of chunks) {\n\t\tconst number = Number(chunk);\n\t\tif (!Number.isNaN(number)) {\n\t\t\tresults.push(number);\n\t\t} else if ((matches = chunk.match(STRING_REGEX))) {\n\t\t\tresults.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape$1(escape) : character));\n\t\t} else {\n\t\t\tthrow new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);\n\t\t}\n\t}\n\n\treturn results;\n}\n\nfunction parseStyle(style) {\n\tSTYLE_REGEX.lastIndex = 0;\n\n\tconst results = [];\n\tlet matches;\n\n\twhile ((matches = STYLE_REGEX.exec(style)) !== null) {\n\t\tconst name = matches[1];\n\n\t\tif (matches[2]) {\n\t\t\tconst args = parseArguments(name, matches[2]);\n\t\t\tresults.push([name].concat(args));\n\t\t} else {\n\t\t\tresults.push([name]);\n\t\t}\n\t}\n\n\treturn results;\n}\n\nfunction buildStyle(chalk, styles) {\n\tconst enabled = {};\n\n\tfor (const layer of styles) {\n\t\tfor (const style of layer.styles) {\n\t\t\tenabled[style[0]] = layer.inverse ? null : style.slice(1);\n\t\t}\n\t}\n\n\tlet current = chalk;\n\tfor (const [styleName, styles] of Object.entries(enabled)) {\n\t\tif (!Array.isArray(styles)) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (!(styleName in current)) {\n\t\t\tthrow new Error(`Unknown Chalk style: ${styleName}`);\n\t\t}\n\n\t\tcurrent = styles.length > 0 ? current[styleName](...styles) : current[styleName];\n\t}\n\n\treturn current;\n}\n\nvar templates = (chalk, temporary) => {\n\tconst styles = [];\n\tconst chunks = [];\n\tlet chunk = [];\n\n\t// eslint-disable-next-line max-params\n\ttemporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {\n\t\tif (escapeCharacter) {\n\t\t\tchunk.push(unescape$1(escapeCharacter));\n\t\t} else if (style) {\n\t\t\tconst string = chunk.join('');\n\t\t\tchunk = [];\n\t\t\tchunks.push(styles.length === 0 ? string : buildStyle(chalk, styles)(string));\n\t\t\tstyles.push({inverse, styles: parseStyle(style)});\n\t\t} else if (close) {\n\t\t\tif (styles.length === 0) {\n\t\t\t\tthrow new Error('Found extraneous } in Chalk template literal');\n\t\t\t}\n\n\t\t\tchunks.push(buildStyle(chalk, styles)(chunk.join('')));\n\t\t\tchunk = [];\n\t\t\tstyles.pop();\n\t\t} else {\n\t\t\tchunk.push(character);\n\t\t}\n\t});\n\n\tchunks.push(chunk.join(''));\n\n\tif (styles.length > 0) {\n\t\tconst errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\\`}\\`)`;\n\t\tthrow new Error(errMessage);\n\t}\n\n\treturn chunks.join('');\n};\n\nconst {stdout: stdoutColor, stderr: stderrColor} = supportsColor_1;\nconst {\n\tstringReplaceAll: stringReplaceAll$1,\n\tstringEncaseCRLFWithFirstIndex: stringEncaseCRLFWithFirstIndex$1\n} = util;\n\n// `supportsColor.level` → `ansiStyles.color[name]` mapping\nconst levelMapping = [\n\t'ansi',\n\t'ansi',\n\t'ansi256',\n\t'ansi16m'\n];\n\nconst styles = Object.create(null);\n\nconst applyOptions = (object, options = {}) => {\n\tif (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {\n\t\tthrow new Error('The `level` option should be an integer from 0 to 3');\n\t}\n\n\t// Detect level if not set manually\n\tconst colorLevel = stdoutColor ? stdoutColor.level : 0;\n\tobject.level = options.level === undefined ? colorLevel : options.level;\n};\n\nclass ChalkClass {\n\tconstructor(options) {\n\t\t// eslint-disable-next-line no-constructor-return\n\t\treturn chalkFactory(options);\n\t}\n}\n\nconst chalkFactory = options => {\n\tconst chalk = {};\n\tapplyOptions(chalk, options);\n\n\tchalk.template = (...arguments_) => chalkTag(chalk.template, ...arguments_);\n\n\tObject.setPrototypeOf(chalk, Chalk.prototype);\n\tObject.setPrototypeOf(chalk.template, chalk);\n\n\tchalk.template.constructor = () => {\n\t\tthrow new Error('`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.');\n\t};\n\n\tchalk.template.Instance = ChalkClass;\n\n\treturn chalk.template;\n};\n\nfunction Chalk(options) {\n\treturn chalkFactory(options);\n}\n\nfor (const [styleName, style] of Object.entries(ansiStyles)) {\n\tstyles[styleName] = {\n\t\tget() {\n\t\t\tconst builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);\n\t\t\tObject.defineProperty(this, styleName, {value: builder});\n\t\t\treturn builder;\n\t\t}\n\t};\n}\n\nstyles.visible = {\n\tget() {\n\t\tconst builder = createBuilder(this, this._styler, true);\n\t\tObject.defineProperty(this, 'visible', {value: builder});\n\t\treturn builder;\n\t}\n};\n\nconst usedModels = ['rgb', 'hex', 'keyword', 'hsl', 'hsv', 'hwb', 'ansi', 'ansi256'];\n\nfor (const model of usedModels) {\n\tstyles[model] = {\n\t\tget() {\n\t\t\tconst {level} = this;\n\t\t\treturn function (...arguments_) {\n\t\t\t\tconst styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);\n\t\t\t\treturn createBuilder(this, styler, this._isEmpty);\n\t\t\t};\n\t\t}\n\t};\n}\n\nfor (const model of usedModels) {\n\tconst bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);\n\tstyles[bgModel] = {\n\t\tget() {\n\t\t\tconst {level} = this;\n\t\t\treturn function (...arguments_) {\n\t\t\t\tconst styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);\n\t\t\t\treturn createBuilder(this, styler, this._isEmpty);\n\t\t\t};\n\t\t}\n\t};\n}\n\nconst proto = Object.defineProperties(() => {}, {\n\t...styles,\n\tlevel: {\n\t\tenumerable: true,\n\t\tget() {\n\t\t\treturn this._generator.level;\n\t\t},\n\t\tset(level) {\n\t\t\tthis._generator.level = level;\n\t\t}\n\t}\n});\n\nconst createStyler = (open, close, parent) => {\n\tlet openAll;\n\tlet closeAll;\n\tif (parent === undefined) {\n\t\topenAll = open;\n\t\tcloseAll = close;\n\t} else {\n\t\topenAll = parent.openAll + open;\n\t\tcloseAll = close + parent.closeAll;\n\t}\n\n\treturn {\n\t\topen,\n\t\tclose,\n\t\topenAll,\n\t\tcloseAll,\n\t\tparent\n\t};\n};\n\nconst createBuilder = (self, _styler, _isEmpty) => {\n\tconst builder = (...arguments_) => {\n\t\t// Single argument is hot path, implicit coercion is faster than anything\n\t\t// eslint-disable-next-line no-implicit-coercion\n\t\treturn applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));\n\t};\n\n\t// We alter the prototype because we must return a function, but there is\n\t// no way to create a function with a different prototype\n\tObject.setPrototypeOf(builder, proto);\n\n\tbuilder._generator = self;\n\tbuilder._styler = _styler;\n\tbuilder._isEmpty = _isEmpty;\n\n\treturn builder;\n};\n\nconst applyStyle = (self, string) => {\n\tif (self.level <= 0 || !string) {\n\t\treturn self._isEmpty ? '' : string;\n\t}\n\n\tlet styler = self._styler;\n\n\tif (styler === undefined) {\n\t\treturn string;\n\t}\n\n\tconst {openAll, closeAll} = styler;\n\tif (string.indexOf('\\u001B') !== -1) {\n\t\twhile (styler !== undefined) {\n\t\t\t// Replace any instances already present with a re-opening code\n\t\t\t// otherwise only the part of the string until said closing code\n\t\t\t// will be colored, and the rest will simply be 'plain'.\n\t\t\tstring = stringReplaceAll$1(string, styler.close, styler.open);\n\n\t\t\tstyler = styler.parent;\n\t\t}\n\t}\n\n\t// We can move both next actions out of loop, because remaining actions in loop won't have\n\t// any/visible effect on parts we add here. Close the styling before a linebreak and reopen\n\t// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92\n\tconst lfIndex = string.indexOf('\\n');\n\tif (lfIndex !== -1) {\n\t\tstring = stringEncaseCRLFWithFirstIndex$1(string, closeAll, openAll, lfIndex);\n\t}\n\n\treturn openAll + string + closeAll;\n};\n\nlet template;\nconst chalkTag = (chalk, ...strings) => {\n\tconst [firstString] = strings;\n\n\tif (!Array.isArray(firstString)) {\n\t\t// If chalk() was called by itself or with a string,\n\t\t// return the string itself as a string.\n\t\treturn strings.join(' ');\n\t}\n\n\tconst arguments_ = strings.slice(1);\n\tconst parts = [firstString.raw[0]];\n\n\tfor (let i = 1; i < firstString.length; i++) {\n\t\tparts.push(\n\t\t\tString(arguments_[i - 1]).replace(/[{}\\\\]/g, '\\\\$&'),\n\t\t\tString(firstString.raw[i])\n\t\t);\n\t}\n\n\tif (template === undefined) {\n\t\ttemplate = templates;\n\t}\n\n\treturn template(chalk, parts.join(''));\n};\n\nObject.defineProperties(Chalk.prototype, styles);\n\nconst chalk = Chalk(); // eslint-disable-line new-cap\nchalk.supportsColor = stdoutColor;\nchalk.stderr = Chalk({level: stderrColor ? stderrColor.level : 0}); // eslint-disable-line new-cap\nchalk.stderr.supportsColor = stderrColor;\n\nvar source = chalk;\n\n/**\n * @fileoverview Default CLIEngineOptions.\n * @author Ian VanSchooten\n */\n\nvar defaultCliOptions = {\n    configFile: null,\n    baseConfig: false,\n    rulePaths: [],\n    useEslintrc: true,\n    envs: [],\n    globals: [],\n    extensions: [\".js\"],\n    ignore: true,\n    ignorePath: void 0,\n    cache: false,\n\n    /*\n     * in order to honor the cacheFile option if specified\n     * this option should not have a default value otherwise\n     * it will always be used\n     */\n    cacheLocation: \"\",\n    cacheFile: \".eslintcache\",\n    fix: false,\n    allowInlineConfig: true,\n    reportUnusedDisableDirectives: void 0,\n    globInputPaths: true\n};\n\nvar name = \"eslint\";\nvar version = \"6.8.0\";\nvar author = \"Nicholas C. Zakas <nicholas+npm@nczconsulting.com>\";\nvar description = \"An AST-based pattern checker for JavaScript.\";\nvar bin = {\n\teslint: \"./bin/eslint.js\"\n};\nvar main = \"./lib/api.js\";\nvar scripts = {\n\ttest: \"node Makefile.js test\",\n\t\"test:cli\": \"mocha\",\n\tlint: \"node Makefile.js lint\",\n\tfix: \"node Makefile.js lint -- fix\",\n\tfuzz: \"node Makefile.js fuzz\",\n\t\"generate-release\": \"node Makefile.js generateRelease\",\n\t\"generate-alpharelease\": \"node Makefile.js generatePrerelease -- alpha\",\n\t\"generate-betarelease\": \"node Makefile.js generatePrerelease -- beta\",\n\t\"generate-rcrelease\": \"node Makefile.js generatePrerelease -- rc\",\n\t\"publish-release\": \"node Makefile.js publishRelease\",\n\tdocs: \"node Makefile.js docs\",\n\tgensite: \"node Makefile.js gensite\",\n\twebpack: \"node Makefile.js webpack\",\n\tperf: \"node Makefile.js perf\"\n};\nvar gitHooks = {\n\t\"pre-commit\": \"lint-staged\"\n};\nvar files = [\n\t\"LICENSE\",\n\t\"README.md\",\n\t\"bin\",\n\t\"conf\",\n\t\"lib\",\n\t\"messages\"\n];\nvar repository = \"eslint/eslint\";\nvar funding = \"https://opencollective.com/eslint\";\nvar homepage = \"https://eslint.org\";\nvar bugs = \"https://github.com/eslint/eslint/issues/\";\nvar dependencies = {\n\t\"@babel/code-frame\": \"^7.0.0\",\n\tajv: \"^6.10.0\",\n\tchalk: \"^2.1.0\",\n\t\"cross-spawn\": \"^6.0.5\",\n\tdebug: \"^4.0.1\",\n\tdoctrine: \"^3.0.0\",\n\t\"eslint-scope\": \"^5.0.0\",\n\t\"eslint-utils\": \"^1.4.3\",\n\t\"eslint-visitor-keys\": \"^1.1.0\",\n\tespree: \"^6.1.2\",\n\tesquery: \"^1.0.1\",\n\tesutils: \"^2.0.2\",\n\t\"file-entry-cache\": \"^5.0.1\",\n\t\"functional-red-black-tree\": \"^1.0.1\",\n\t\"glob-parent\": \"^5.0.0\",\n\tglobals: \"^12.1.0\",\n\tignore: \"^4.0.6\",\n\t\"import-fresh\": \"^3.0.0\",\n\timurmurhash: \"^0.1.4\",\n\tinquirer: \"^7.0.0\",\n\t\"is-glob\": \"^4.0.0\",\n\t\"js-yaml\": \"^3.13.1\",\n\t\"json-stable-stringify-without-jsonify\": \"^1.0.1\",\n\tlevn: \"^0.3.0\",\n\tlodash: \"^4.17.14\",\n\tminimatch: \"^3.0.4\",\n\tmkdirp: \"^0.5.1\",\n\t\"natural-compare\": \"^1.4.0\",\n\toptionator: \"^0.8.3\",\n\tprogress: \"^2.0.0\",\n\tregexpp: \"^2.0.1\",\n\tsemver: \"^6.1.2\",\n\t\"strip-ansi\": \"^5.2.0\",\n\t\"strip-json-comments\": \"^3.0.1\",\n\ttable: \"^5.2.3\",\n\t\"text-table\": \"^0.2.0\",\n\t\"v8-compile-cache\": \"^2.0.3\"\n};\nvar devDependencies = {\n\t\"@babel/core\": \"^7.4.3\",\n\t\"@babel/preset-env\": \"^7.4.3\",\n\tacorn: \"^7.1.0\",\n\t\"babel-loader\": \"^8.0.5\",\n\tchai: \"^4.0.1\",\n\tcheerio: \"^0.22.0\",\n\t\"common-tags\": \"^1.8.0\",\n\t\"core-js\": \"^3.1.3\",\n\tdateformat: \"^3.0.3\",\n\tejs: \"^2.6.1\",\n\teslint: \"file:.\",\n\t\"eslint-config-eslint\": \"file:packages/eslint-config-eslint\",\n\t\"eslint-plugin-eslint-plugin\": \"^2.0.1\",\n\t\"eslint-plugin-internal-rules\": \"file:tools/internal-rules\",\n\t\"eslint-plugin-jsdoc\": \"^15.9.5\",\n\t\"eslint-plugin-node\": \"^9.0.0\",\n\t\"eslint-release\": \"^1.2.0\",\n\teslump: \"^2.0.0\",\n\tesprima: \"^4.0.1\",\n\tglob: \"^7.1.3\",\n\tjsdoc: \"^3.5.5\",\n\tkarma: \"^4.0.1\",\n\t\"karma-chrome-launcher\": \"^2.2.0\",\n\t\"karma-mocha\": \"^1.3.0\",\n\t\"karma-mocha-reporter\": \"^2.2.3\",\n\t\"karma-webpack\": \"^4.0.0-rc.6\",\n\tleche: \"^2.2.3\",\n\t\"lint-staged\": \"^8.1.5\",\n\t\"load-perf\": \"^0.2.0\",\n\tmarkdownlint: \"^0.15.0\",\n\t\"markdownlint-cli\": \"^0.17.0\",\n\t\"metro-memory-fs\": \"^0.54.1\",\n\tmocha: \"^6.1.2\",\n\t\"mocha-junit-reporter\": \"^1.23.0\",\n\t\"npm-license\": \"^0.3.3\",\n\tnyc: \"^14.1.1\",\n\tproxyquire: \"^2.0.1\",\n\tpuppeteer: \"^1.18.0\",\n\trecast: \"^0.18.1\",\n\t\"regenerator-runtime\": \"^0.13.2\",\n\tshelljs: \"^0.8.2\",\n\tsinon: \"^7.3.2\",\n\ttemp: \"^0.9.0\",\n\twebpack: \"^4.35.0\",\n\t\"webpack-cli\": \"^3.3.5\",\n\tyorkie: \"^2.0.0\"\n};\nvar keywords = [\n\t\"ast\",\n\t\"lint\",\n\t\"javascript\",\n\t\"ecmascript\",\n\t\"espree\"\n];\nvar license = \"MIT\";\nvar engines = {\n\tnode: \"^8.10.0 || ^10.13.0 || >=11.10.1\"\n};\nvar _package = {\n\tname: name,\n\tversion: version,\n\tauthor: author,\n\tdescription: description,\n\tbin: bin,\n\tmain: main,\n\tscripts: scripts,\n\tgitHooks: gitHooks,\n\t\"lint-staged\": {\n\t\"*.js\": [\n\t\t\"eslint --fix\",\n\t\t\"git add\"\n\t],\n\t\"*.md\": \"markdownlint\"\n},\n\tfiles: files,\n\trepository: repository,\n\tfunding: funding,\n\thomepage: homepage,\n\tbugs: bugs,\n\tdependencies: dependencies,\n\tdevDependencies: devDependencies,\n\tkeywords: keywords,\n\tlicense: license,\n\tengines: engines\n};\n\nvar _package$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  name: name,\n  version: version,\n  author: author,\n  description: description,\n  bin: bin,\n  main: main,\n  scripts: scripts,\n  gitHooks: gitHooks,\n  files: files,\n  repository: repository,\n  funding: funding,\n  homepage: homepage,\n  bugs: bugs,\n  dependencies: dependencies,\n  devDependencies: devDependencies,\n  keywords: keywords,\n  license: license,\n  engines: engines,\n  'default': _package\n});\n\nvar configOps = createCommonjsModule(function (module) {\n\n//------------------------------------------------------------------------------\n// Private\n//------------------------------------------------------------------------------\n\nconst RULE_SEVERITY_STRINGS = [\"off\", \"warn\", \"error\"],\n    RULE_SEVERITY = RULE_SEVERITY_STRINGS.reduce((map, value, index) => {\n        map[value] = index;\n        return map;\n    }, {}),\n    VALID_SEVERITIES = [0, 1, 2, \"off\", \"warn\", \"error\"];\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nmodule.exports = {\n\n    /**\n     * Normalizes the severity value of a rule's configuration to a number\n     * @param {(number|string|[number, ...*]|[string, ...*])} ruleConfig A rule's configuration value, generally\n     * received from the user. A valid config value is either 0, 1, 2, the string \"off\" (treated the same as 0),\n     * the string \"warn\" (treated the same as 1), the string \"error\" (treated the same as 2), or an array\n     * whose first element is one of the above values. Strings are matched case-insensitively.\n     * @returns {(0|1|2)} The numeric severity value if the config value was valid, otherwise 0.\n     */\n    getRuleSeverity(ruleConfig) {\n        const severityValue = Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig;\n\n        if (severityValue === 0 || severityValue === 1 || severityValue === 2) {\n            return severityValue;\n        }\n\n        if (typeof severityValue === \"string\") {\n            return RULE_SEVERITY[severityValue.toLowerCase()] || 0;\n        }\n\n        return 0;\n    },\n\n    /**\n     * Converts old-style severity settings (0, 1, 2) into new-style\n     * severity settings (off, warn, error) for all rules. Assumption is that severity\n     * values have already been validated as correct.\n     * @param {Object} config The config object to normalize.\n     * @returns {void}\n     */\n    normalizeToStrings(config) {\n\n        if (config.rules) {\n            Object.keys(config.rules).forEach(ruleId => {\n                const ruleConfig = config.rules[ruleId];\n\n                if (typeof ruleConfig === \"number\") {\n                    config.rules[ruleId] = RULE_SEVERITY_STRINGS[ruleConfig] || RULE_SEVERITY_STRINGS[0];\n                } else if (Array.isArray(ruleConfig) && typeof ruleConfig[0] === \"number\") {\n                    ruleConfig[0] = RULE_SEVERITY_STRINGS[ruleConfig[0]] || RULE_SEVERITY_STRINGS[0];\n                }\n            });\n        }\n    },\n\n    /**\n     * Determines if the severity for the given rule configuration represents an error.\n     * @param {int|string|Array} ruleConfig The configuration for an individual rule.\n     * @returns {boolean} True if the rule represents an error, false if not.\n     */\n    isErrorSeverity(ruleConfig) {\n        return module.exports.getRuleSeverity(ruleConfig) === 2;\n    },\n\n    /**\n     * Checks whether a given config has valid severity or not.\n     * @param {number|string|Array} ruleConfig The configuration for an individual rule.\n     * @returns {boolean} `true` if the configuration has valid severity.\n     */\n    isValidSeverity(ruleConfig) {\n        let severity = Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig;\n\n        if (typeof severity === \"string\") {\n            severity = severity.toLowerCase();\n        }\n        return VALID_SEVERITIES.indexOf(severity) !== -1;\n    },\n\n    /**\n     * Checks whether every rule of a given config has valid severity or not.\n     * @param {Object} config The configuration for rules.\n     * @returns {boolean} `true` if the configuration has valid severity.\n     */\n    isEverySeverityValid(config) {\n        return Object.keys(config).every(ruleId => this.isValidSeverity(config[ruleId]));\n    },\n\n    /**\n     * Normalizes a value for a global in a config\n     * @param {(boolean|string|null)} configuredValue The value given for a global in configuration or in\n     * a global directive comment\n     * @returns {(\"readable\"|\"writeable\"|\"off\")} The value normalized as a string\n     * @throws Error if global value is invalid\n     */\n    normalizeConfigGlobal(configuredValue) {\n        switch (configuredValue) {\n            case \"off\":\n                return \"off\";\n\n            case true:\n            case \"true\":\n            case \"writeable\":\n            case \"writable\":\n                return \"writable\";\n\n            case null:\n            case false:\n            case \"false\":\n            case \"readable\":\n            case \"readonly\":\n                return \"readonly\";\n\n            default:\n                throw new Error(`'${configuredValue}' is not a valid configuration for a global (use 'readonly', 'writable', or 'off')`);\n        }\n    }\n};\n});\nvar configOps_1 = configOps.getRuleSeverity;\nvar configOps_2 = configOps.normalizeToStrings;\nvar configOps_3 = configOps.isErrorSeverity;\nvar configOps_4 = configOps.isValidSeverity;\nvar configOps_5 = configOps.isEverySeverityValid;\nvar configOps_6 = configOps.normalizeConfigGlobal;\n\n/**\n * @fileoverview Common helpers for naming of plugins, formatters and configs\n */\n\nconst NAMESPACE_REGEX = /^@.*\\//iu;\n\n/**\n * Brings package name to correct format based on prefix\n * @param {string} name The name of the package.\n * @param {string} prefix Can be either \"eslint-plugin\", \"eslint-config\" or \"eslint-formatter\"\n * @returns {string} Normalized name of the package\n * @private\n */\nfunction normalizePackageName(name, prefix) {\n    let normalizedName = name;\n\n    /**\n     * On Windows, name can come in with Windows slashes instead of Unix slashes.\n     * Normalize to Unix first to avoid errors later on.\n     * https://github.com/eslint/eslint/issues/5644\n     */\n    if (normalizedName.includes(\"\\\\\")) {\n        normalizedName = normalizedName.replace(/\\\\/gu, \"/\");\n    }\n\n    if (normalizedName.charAt(0) === \"@\") {\n\n        /**\n         * it's a scoped package\n         * package name is the prefix, or just a username\n         */\n        const scopedPackageShortcutRegex = new RegExp(`^(@[^/]+)(?:/(?:${prefix})?)?$`, \"u\"),\n            scopedPackageNameRegex = new RegExp(`^${prefix}(-|$)`, \"u\");\n\n        if (scopedPackageShortcutRegex.test(normalizedName)) {\n            normalizedName = normalizedName.replace(scopedPackageShortcutRegex, `$1/${prefix}`);\n        } else if (!scopedPackageNameRegex.test(normalizedName.split(\"/\")[1])) {\n\n            /**\n             * for scoped packages, insert the prefix after the first / unless\n             * the path is already @scope/eslint or @scope/eslint-xxx-yyy\n             */\n            normalizedName = normalizedName.replace(/^@([^/]+)\\/(.*)$/u, `@$1/${prefix}-$2`);\n        }\n    } else if (!normalizedName.startsWith(`${prefix}-`)) {\n        normalizedName = `${prefix}-${normalizedName}`;\n    }\n\n    return normalizedName;\n}\n\n/**\n * Removes the prefix from a fullname.\n * @param {string} fullname The term which may have the prefix.\n * @param {string} prefix The prefix to remove.\n * @returns {string} The term without prefix.\n */\nfunction getShorthandName(fullname, prefix) {\n    if (fullname[0] === \"@\") {\n        let matchResult = new RegExp(`^(@[^/]+)/${prefix}$`, \"u\").exec(fullname);\n\n        if (matchResult) {\n            return matchResult[1];\n        }\n\n        matchResult = new RegExp(`^(@[^/]+)/${prefix}-(.+)$`, \"u\").exec(fullname);\n        if (matchResult) {\n            return `${matchResult[1]}/${matchResult[2]}`;\n        }\n    } else if (fullname.startsWith(`${prefix}-`)) {\n        return fullname.slice(prefix.length + 1);\n    }\n\n    return fullname;\n}\n\n/**\n * Gets the scope (namespace) of a term.\n * @param {string} term The term which may have the namespace.\n * @returns {string} The namepace of the term if it has one.\n */\nfunction getNamespaceFromTerm(term) {\n    const match = term.match(NAMESPACE_REGEX);\n\n    return match ? match[0] : \"\";\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nvar naming = {\n    normalizePackageName,\n    getShorthandName,\n    getNamespaceFromTerm\n};\n\n// Polyfill Node's `Module.createRequire` if not present. We only support the case where the argument is a filepath, not a URL.\nconst createRequire = (\n\n    // Added in v12.2.0\n    module$1.createRequire ||\n\n    // Added in v10.12.0, but deprecated in v12.2.0.\n    module$1.createRequireFromPath ||\n\n    // Polyfill - This is not executed on the tests on node@>=10.\n    /* istanbul ignore next */\n    (filename => {\n        const mod = new module$1(filename, null);\n\n        mod.filename = filename;\n        mod.paths = module$1._nodeModulePaths(path$1.dirname(filename)); // eslint-disable-line no-underscore-dangle\n        mod._compile(\"module.exports = require;\", filename); // eslint-disable-line no-underscore-dangle\n        return mod.exports;\n    })\n);\n\nvar relativeModuleResolver = {\n\n    /**\n     * Resolves a Node module relative to another module\n     * @param {string} moduleName The name of a Node module, or a path to a Node module.\n     *\n     * @param {string} relativeToPath An absolute path indicating the module that `moduleName` should be resolved relative to. This must be\n     * a file rather than a directory, but the file need not actually exist.\n     * @returns {string} The absolute path that would result from calling `require.resolve(moduleName)` in a file located at `relativeToPath`\n     */\n    resolve(moduleName, relativeToPath) {\n        try {\n            return createRequire(relativeToPath).resolve(moduleName);\n        } catch (error) {\n            if (\n                typeof error === \"object\" &&\n                error !== null &&\n                error.code === \"MODULE_NOT_FOUND\" &&\n                !error.requireStack &&\n                error.message.includes(moduleName)\n            ) {\n                error.message += `\\nRequire stack:\\n- ${relativeToPath}`;\n            }\n            throw error;\n        }\n    }\n};\n\nvar name$1 = \"estraverse\";\nvar description$1 = \"ECMAScript JS AST traversal functions\";\nvar homepage$1 = \"https://github.com/estools/estraverse\";\nvar main$1 = \"estraverse.js\";\nvar version$1 = \"4.3.0\";\nvar engines$1 = {\n\tnode: \">=4.0\"\n};\nvar maintainers = [\n\t{\n\t\tname: \"Yusuke Suzuki\",\n\t\temail: \"utatane.tea@gmail.com\",\n\t\tweb: \"http://github.com/Constellation\"\n\t}\n];\nvar repository$1 = {\n\ttype: \"git\",\n\turl: \"http://github.com/estools/estraverse.git\"\n};\nvar devDependencies$1 = {\n\t\"babel-preset-env\": \"^1.6.1\",\n\t\"babel-register\": \"^6.3.13\",\n\tchai: \"^2.1.1\",\n\tespree: \"^1.11.0\",\n\tgulp: \"^3.8.10\",\n\t\"gulp-bump\": \"^0.2.2\",\n\t\"gulp-filter\": \"^2.0.0\",\n\t\"gulp-git\": \"^1.0.1\",\n\t\"gulp-tag-version\": \"^1.3.0\",\n\tjshint: \"^2.5.6\",\n\tmocha: \"^2.1.0\"\n};\nvar license$1 = \"BSD-2-Clause\";\nvar scripts$1 = {\n\ttest: \"npm run-script lint && npm run-script unit-test\",\n\tlint: \"jshint estraverse.js\",\n\t\"unit-test\": \"mocha --compilers js:babel-register\"\n};\nvar _package$2 = {\n\tname: name$1,\n\tdescription: description$1,\n\thomepage: homepage$1,\n\tmain: main$1,\n\tversion: version$1,\n\tengines: engines$1,\n\tmaintainers: maintainers,\n\trepository: repository$1,\n\tdevDependencies: devDependencies$1,\n\tlicense: license$1,\n\tscripts: scripts$1\n};\n\nvar _package$3 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  name: name$1,\n  description: description$1,\n  homepage: homepage$1,\n  main: main$1,\n  version: version$1,\n  engines: engines$1,\n  maintainers: maintainers,\n  repository: repository$1,\n  devDependencies: devDependencies$1,\n  license: license$1,\n  scripts: scripts$1,\n  'default': _package$2\n});\n\nvar require$$0 = getCjsExportFromNamespace(_package$3);\n\nvar estraverse = createCommonjsModule(function (module, exports) {\n/*\n  Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>\n  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n/*jslint vars:false, bitwise:true*/\n/*jshint indent:4*/\n/*global exports:true*/\n(function clone(exports) {\n\n    var Syntax,\n        VisitorOption,\n        VisitorKeys,\n        BREAK,\n        SKIP,\n        REMOVE;\n\n    function deepCopy(obj) {\n        var ret = {}, key, val;\n        for (key in obj) {\n            if (obj.hasOwnProperty(key)) {\n                val = obj[key];\n                if (typeof val === 'object' && val !== null) {\n                    ret[key] = deepCopy(val);\n                } else {\n                    ret[key] = val;\n                }\n            }\n        }\n        return ret;\n    }\n\n    // based on LLVM libc++ upper_bound / lower_bound\n    // MIT License\n\n    function upperBound(array, func) {\n        var diff, len, i, current;\n\n        len = array.length;\n        i = 0;\n\n        while (len) {\n            diff = len >>> 1;\n            current = i + diff;\n            if (func(array[current])) {\n                len = diff;\n            } else {\n                i = current + 1;\n                len -= diff + 1;\n            }\n        }\n        return i;\n    }\n\n    Syntax = {\n        AssignmentExpression: 'AssignmentExpression',\n        AssignmentPattern: 'AssignmentPattern',\n        ArrayExpression: 'ArrayExpression',\n        ArrayPattern: 'ArrayPattern',\n        ArrowFunctionExpression: 'ArrowFunctionExpression',\n        AwaitExpression: 'AwaitExpression', // CAUTION: It's deferred to ES7.\n        BlockStatement: 'BlockStatement',\n        BinaryExpression: 'BinaryExpression',\n        BreakStatement: 'BreakStatement',\n        CallExpression: 'CallExpression',\n        CatchClause: 'CatchClause',\n        ClassBody: 'ClassBody',\n        ClassDeclaration: 'ClassDeclaration',\n        ClassExpression: 'ClassExpression',\n        ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.\n        ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.\n        ConditionalExpression: 'ConditionalExpression',\n        ContinueStatement: 'ContinueStatement',\n        DebuggerStatement: 'DebuggerStatement',\n        DirectiveStatement: 'DirectiveStatement',\n        DoWhileStatement: 'DoWhileStatement',\n        EmptyStatement: 'EmptyStatement',\n        ExportAllDeclaration: 'ExportAllDeclaration',\n        ExportDefaultDeclaration: 'ExportDefaultDeclaration',\n        ExportNamedDeclaration: 'ExportNamedDeclaration',\n        ExportSpecifier: 'ExportSpecifier',\n        ExpressionStatement: 'ExpressionStatement',\n        ForStatement: 'ForStatement',\n        ForInStatement: 'ForInStatement',\n        ForOfStatement: 'ForOfStatement',\n        FunctionDeclaration: 'FunctionDeclaration',\n        FunctionExpression: 'FunctionExpression',\n        GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.\n        Identifier: 'Identifier',\n        IfStatement: 'IfStatement',\n        ImportExpression: 'ImportExpression',\n        ImportDeclaration: 'ImportDeclaration',\n        ImportDefaultSpecifier: 'ImportDefaultSpecifier',\n        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',\n        ImportSpecifier: 'ImportSpecifier',\n        Literal: 'Literal',\n        LabeledStatement: 'LabeledStatement',\n        LogicalExpression: 'LogicalExpression',\n        MemberExpression: 'MemberExpression',\n        MetaProperty: 'MetaProperty',\n        MethodDefinition: 'MethodDefinition',\n        ModuleSpecifier: 'ModuleSpecifier',\n        NewExpression: 'NewExpression',\n        ObjectExpression: 'ObjectExpression',\n        ObjectPattern: 'ObjectPattern',\n        Program: 'Program',\n        Property: 'Property',\n        RestElement: 'RestElement',\n        ReturnStatement: 'ReturnStatement',\n        SequenceExpression: 'SequenceExpression',\n        SpreadElement: 'SpreadElement',\n        Super: 'Super',\n        SwitchStatement: 'SwitchStatement',\n        SwitchCase: 'SwitchCase',\n        TaggedTemplateExpression: 'TaggedTemplateExpression',\n        TemplateElement: 'TemplateElement',\n        TemplateLiteral: 'TemplateLiteral',\n        ThisExpression: 'ThisExpression',\n        ThrowStatement: 'ThrowStatement',\n        TryStatement: 'TryStatement',\n        UnaryExpression: 'UnaryExpression',\n        UpdateExpression: 'UpdateExpression',\n        VariableDeclaration: 'VariableDeclaration',\n        VariableDeclarator: 'VariableDeclarator',\n        WhileStatement: 'WhileStatement',\n        WithStatement: 'WithStatement',\n        YieldExpression: 'YieldExpression'\n    };\n\n    VisitorKeys = {\n        AssignmentExpression: ['left', 'right'],\n        AssignmentPattern: ['left', 'right'],\n        ArrayExpression: ['elements'],\n        ArrayPattern: ['elements'],\n        ArrowFunctionExpression: ['params', 'body'],\n        AwaitExpression: ['argument'], // CAUTION: It's deferred to ES7.\n        BlockStatement: ['body'],\n        BinaryExpression: ['left', 'right'],\n        BreakStatement: ['label'],\n        CallExpression: ['callee', 'arguments'],\n        CatchClause: ['param', 'body'],\n        ClassBody: ['body'],\n        ClassDeclaration: ['id', 'superClass', 'body'],\n        ClassExpression: ['id', 'superClass', 'body'],\n        ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.\n        ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.\n        ConditionalExpression: ['test', 'consequent', 'alternate'],\n        ContinueStatement: ['label'],\n        DebuggerStatement: [],\n        DirectiveStatement: [],\n        DoWhileStatement: ['body', 'test'],\n        EmptyStatement: [],\n        ExportAllDeclaration: ['source'],\n        ExportDefaultDeclaration: ['declaration'],\n        ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],\n        ExportSpecifier: ['exported', 'local'],\n        ExpressionStatement: ['expression'],\n        ForStatement: ['init', 'test', 'update', 'body'],\n        ForInStatement: ['left', 'right', 'body'],\n        ForOfStatement: ['left', 'right', 'body'],\n        FunctionDeclaration: ['id', 'params', 'body'],\n        FunctionExpression: ['id', 'params', 'body'],\n        GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.\n        Identifier: [],\n        IfStatement: ['test', 'consequent', 'alternate'],\n        ImportExpression: ['source'],\n        ImportDeclaration: ['specifiers', 'source'],\n        ImportDefaultSpecifier: ['local'],\n        ImportNamespaceSpecifier: ['local'],\n        ImportSpecifier: ['imported', 'local'],\n        Literal: [],\n        LabeledStatement: ['label', 'body'],\n        LogicalExpression: ['left', 'right'],\n        MemberExpression: ['object', 'property'],\n        MetaProperty: ['meta', 'property'],\n        MethodDefinition: ['key', 'value'],\n        ModuleSpecifier: [],\n        NewExpression: ['callee', 'arguments'],\n        ObjectExpression: ['properties'],\n        ObjectPattern: ['properties'],\n        Program: ['body'],\n        Property: ['key', 'value'],\n        RestElement: [ 'argument' ],\n        ReturnStatement: ['argument'],\n        SequenceExpression: ['expressions'],\n        SpreadElement: ['argument'],\n        Super: [],\n        SwitchStatement: ['discriminant', 'cases'],\n        SwitchCase: ['test', 'consequent'],\n        TaggedTemplateExpression: ['tag', 'quasi'],\n        TemplateElement: [],\n        TemplateLiteral: ['quasis', 'expressions'],\n        ThisExpression: [],\n        ThrowStatement: ['argument'],\n        TryStatement: ['block', 'handler', 'finalizer'],\n        UnaryExpression: ['argument'],\n        UpdateExpression: ['argument'],\n        VariableDeclaration: ['declarations'],\n        VariableDeclarator: ['id', 'init'],\n        WhileStatement: ['test', 'body'],\n        WithStatement: ['object', 'body'],\n        YieldExpression: ['argument']\n    };\n\n    // unique id\n    BREAK = {};\n    SKIP = {};\n    REMOVE = {};\n\n    VisitorOption = {\n        Break: BREAK,\n        Skip: SKIP,\n        Remove: REMOVE\n    };\n\n    function Reference(parent, key) {\n        this.parent = parent;\n        this.key = key;\n    }\n\n    Reference.prototype.replace = function replace(node) {\n        this.parent[this.key] = node;\n    };\n\n    Reference.prototype.remove = function remove() {\n        if (Array.isArray(this.parent)) {\n            this.parent.splice(this.key, 1);\n            return true;\n        } else {\n            this.replace(null);\n            return false;\n        }\n    };\n\n    function Element(node, path, wrap, ref) {\n        this.node = node;\n        this.path = path;\n        this.wrap = wrap;\n        this.ref = ref;\n    }\n\n    function Controller() { }\n\n    // API:\n    // return property path array from root to current node\n    Controller.prototype.path = function path() {\n        var i, iz, j, jz, result, element;\n\n        function addToPath(result, path) {\n            if (Array.isArray(path)) {\n                for (j = 0, jz = path.length; j < jz; ++j) {\n                    result.push(path[j]);\n                }\n            } else {\n                result.push(path);\n            }\n        }\n\n        // root node\n        if (!this.__current.path) {\n            return null;\n        }\n\n        // first node is sentinel, second node is root element\n        result = [];\n        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {\n            element = this.__leavelist[i];\n            addToPath(result, element.path);\n        }\n        addToPath(result, this.__current.path);\n        return result;\n    };\n\n    // API:\n    // return type of current node\n    Controller.prototype.type = function () {\n        var node = this.current();\n        return node.type || this.__current.wrap;\n    };\n\n    // API:\n    // return array of parent elements\n    Controller.prototype.parents = function parents() {\n        var i, iz, result;\n\n        // first node is sentinel\n        result = [];\n        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {\n            result.push(this.__leavelist[i].node);\n        }\n\n        return result;\n    };\n\n    // API:\n    // return current node\n    Controller.prototype.current = function current() {\n        return this.__current.node;\n    };\n\n    Controller.prototype.__execute = function __execute(callback, element) {\n        var previous, result;\n\n        result = undefined;\n\n        previous  = this.__current;\n        this.__current = element;\n        this.__state = null;\n        if (callback) {\n            result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);\n        }\n        this.__current = previous;\n\n        return result;\n    };\n\n    // API:\n    // notify control skip / break\n    Controller.prototype.notify = function notify(flag) {\n        this.__state = flag;\n    };\n\n    // API:\n    // skip child nodes of current node\n    Controller.prototype.skip = function () {\n        this.notify(SKIP);\n    };\n\n    // API:\n    // break traversals\n    Controller.prototype['break'] = function () {\n        this.notify(BREAK);\n    };\n\n    // API:\n    // remove node\n    Controller.prototype.remove = function () {\n        this.notify(REMOVE);\n    };\n\n    Controller.prototype.__initialize = function(root, visitor) {\n        this.visitor = visitor;\n        this.root = root;\n        this.__worklist = [];\n        this.__leavelist = [];\n        this.__current = null;\n        this.__state = null;\n        this.__fallback = null;\n        if (visitor.fallback === 'iteration') {\n            this.__fallback = Object.keys;\n        } else if (typeof visitor.fallback === 'function') {\n            this.__fallback = visitor.fallback;\n        }\n\n        this.__keys = VisitorKeys;\n        if (visitor.keys) {\n            this.__keys = Object.assign(Object.create(this.__keys), visitor.keys);\n        }\n    };\n\n    function isNode(node) {\n        if (node == null) {\n            return false;\n        }\n        return typeof node === 'object' && typeof node.type === 'string';\n    }\n\n    function isProperty(nodeType, key) {\n        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;\n    }\n\n    Controller.prototype.traverse = function traverse(root, visitor) {\n        var worklist,\n            leavelist,\n            element,\n            node,\n            nodeType,\n            ret,\n            key,\n            current,\n            current2,\n            candidates,\n            candidate,\n            sentinel;\n\n        this.__initialize(root, visitor);\n\n        sentinel = {};\n\n        // reference\n        worklist = this.__worklist;\n        leavelist = this.__leavelist;\n\n        // initialize\n        worklist.push(new Element(root, null, null, null));\n        leavelist.push(new Element(null, null, null, null));\n\n        while (worklist.length) {\n            element = worklist.pop();\n\n            if (element === sentinel) {\n                element = leavelist.pop();\n\n                ret = this.__execute(visitor.leave, element);\n\n                if (this.__state === BREAK || ret === BREAK) {\n                    return;\n                }\n                continue;\n            }\n\n            if (element.node) {\n\n                ret = this.__execute(visitor.enter, element);\n\n                if (this.__state === BREAK || ret === BREAK) {\n                    return;\n                }\n\n                worklist.push(sentinel);\n                leavelist.push(element);\n\n                if (this.__state === SKIP || ret === SKIP) {\n                    continue;\n                }\n\n                node = element.node;\n                nodeType = node.type || element.wrap;\n                candidates = this.__keys[nodeType];\n                if (!candidates) {\n                    if (this.__fallback) {\n                        candidates = this.__fallback(node);\n                    } else {\n                        throw new Error('Unknown node type ' + nodeType + '.');\n                    }\n                }\n\n                current = candidates.length;\n                while ((current -= 1) >= 0) {\n                    key = candidates[current];\n                    candidate = node[key];\n                    if (!candidate) {\n                        continue;\n                    }\n\n                    if (Array.isArray(candidate)) {\n                        current2 = candidate.length;\n                        while ((current2 -= 1) >= 0) {\n                            if (!candidate[current2]) {\n                                continue;\n                            }\n                            if (isProperty(nodeType, candidates[current])) {\n                                element = new Element(candidate[current2], [key, current2], 'Property', null);\n                            } else if (isNode(candidate[current2])) {\n                                element = new Element(candidate[current2], [key, current2], null, null);\n                            } else {\n                                continue;\n                            }\n                            worklist.push(element);\n                        }\n                    } else if (isNode(candidate)) {\n                        worklist.push(new Element(candidate, key, null, null));\n                    }\n                }\n            }\n        }\n    };\n\n    Controller.prototype.replace = function replace(root, visitor) {\n        var worklist,\n            leavelist,\n            node,\n            nodeType,\n            target,\n            element,\n            current,\n            current2,\n            candidates,\n            candidate,\n            sentinel,\n            outer,\n            key;\n\n        function removeElem(element) {\n            var i,\n                key,\n                nextElem,\n                parent;\n\n            if (element.ref.remove()) {\n                // When the reference is an element of an array.\n                key = element.ref.key;\n                parent = element.ref.parent;\n\n                // If removed from array, then decrease following items' keys.\n                i = worklist.length;\n                while (i--) {\n                    nextElem = worklist[i];\n                    if (nextElem.ref && nextElem.ref.parent === parent) {\n                        if  (nextElem.ref.key < key) {\n                            break;\n                        }\n                        --nextElem.ref.key;\n                    }\n                }\n            }\n        }\n\n        this.__initialize(root, visitor);\n\n        sentinel = {};\n\n        // reference\n        worklist = this.__worklist;\n        leavelist = this.__leavelist;\n\n        // initialize\n        outer = {\n            root: root\n        };\n        element = new Element(root, null, null, new Reference(outer, 'root'));\n        worklist.push(element);\n        leavelist.push(element);\n\n        while (worklist.length) {\n            element = worklist.pop();\n\n            if (element === sentinel) {\n                element = leavelist.pop();\n\n                target = this.__execute(visitor.leave, element);\n\n                // node may be replaced with null,\n                // so distinguish between undefined and null in this place\n                if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {\n                    // replace\n                    element.ref.replace(target);\n                }\n\n                if (this.__state === REMOVE || target === REMOVE) {\n                    removeElem(element);\n                }\n\n                if (this.__state === BREAK || target === BREAK) {\n                    return outer.root;\n                }\n                continue;\n            }\n\n            target = this.__execute(visitor.enter, element);\n\n            // node may be replaced with null,\n            // so distinguish between undefined and null in this place\n            if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {\n                // replace\n                element.ref.replace(target);\n                element.node = target;\n            }\n\n            if (this.__state === REMOVE || target === REMOVE) {\n                removeElem(element);\n                element.node = null;\n            }\n\n            if (this.__state === BREAK || target === BREAK) {\n                return outer.root;\n            }\n\n            // node may be null\n            node = element.node;\n            if (!node) {\n                continue;\n            }\n\n            worklist.push(sentinel);\n            leavelist.push(element);\n\n            if (this.__state === SKIP || target === SKIP) {\n                continue;\n            }\n\n            nodeType = node.type || element.wrap;\n            candidates = this.__keys[nodeType];\n            if (!candidates) {\n                if (this.__fallback) {\n                    candidates = this.__fallback(node);\n                } else {\n                    throw new Error('Unknown node type ' + nodeType + '.');\n                }\n            }\n\n            current = candidates.length;\n            while ((current -= 1) >= 0) {\n                key = candidates[current];\n                candidate = node[key];\n                if (!candidate) {\n                    continue;\n                }\n\n                if (Array.isArray(candidate)) {\n                    current2 = candidate.length;\n                    while ((current2 -= 1) >= 0) {\n                        if (!candidate[current2]) {\n                            continue;\n                        }\n                        if (isProperty(nodeType, candidates[current])) {\n                            element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));\n                        } else if (isNode(candidate[current2])) {\n                            element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));\n                        } else {\n                            continue;\n                        }\n                        worklist.push(element);\n                    }\n                } else if (isNode(candidate)) {\n                    worklist.push(new Element(candidate, key, null, new Reference(node, key)));\n                }\n            }\n        }\n\n        return outer.root;\n    };\n\n    function traverse(root, visitor) {\n        var controller = new Controller();\n        return controller.traverse(root, visitor);\n    }\n\n    function replace(root, visitor) {\n        var controller = new Controller();\n        return controller.replace(root, visitor);\n    }\n\n    function extendCommentRange(comment, tokens) {\n        var target;\n\n        target = upperBound(tokens, function search(token) {\n            return token.range[0] > comment.range[0];\n        });\n\n        comment.extendedRange = [comment.range[0], comment.range[1]];\n\n        if (target !== tokens.length) {\n            comment.extendedRange[1] = tokens[target].range[0];\n        }\n\n        target -= 1;\n        if (target >= 0) {\n            comment.extendedRange[0] = tokens[target].range[1];\n        }\n\n        return comment;\n    }\n\n    function attachComments(tree, providedComments, tokens) {\n        // At first, we should calculate extended comment ranges.\n        var comments = [], comment, len, i, cursor;\n\n        if (!tree.range) {\n            throw new Error('attachComments needs range information');\n        }\n\n        // tokens array is empty, we attach comments to tree as 'leadingComments'\n        if (!tokens.length) {\n            if (providedComments.length) {\n                for (i = 0, len = providedComments.length; i < len; i += 1) {\n                    comment = deepCopy(providedComments[i]);\n                    comment.extendedRange = [0, tree.range[0]];\n                    comments.push(comment);\n                }\n                tree.leadingComments = comments;\n            }\n            return tree;\n        }\n\n        for (i = 0, len = providedComments.length; i < len; i += 1) {\n            comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));\n        }\n\n        // This is based on John Freeman's implementation.\n        cursor = 0;\n        traverse(tree, {\n            enter: function (node) {\n                var comment;\n\n                while (cursor < comments.length) {\n                    comment = comments[cursor];\n                    if (comment.extendedRange[1] > node.range[0]) {\n                        break;\n                    }\n\n                    if (comment.extendedRange[1] === node.range[0]) {\n                        if (!node.leadingComments) {\n                            node.leadingComments = [];\n                        }\n                        node.leadingComments.push(comment);\n                        comments.splice(cursor, 1);\n                    } else {\n                        cursor += 1;\n                    }\n                }\n\n                // already out of owned node\n                if (cursor === comments.length) {\n                    return VisitorOption.Break;\n                }\n\n                if (comments[cursor].extendedRange[0] > node.range[1]) {\n                    return VisitorOption.Skip;\n                }\n            }\n        });\n\n        cursor = 0;\n        traverse(tree, {\n            leave: function (node) {\n                var comment;\n\n                while (cursor < comments.length) {\n                    comment = comments[cursor];\n                    if (node.range[1] < comment.extendedRange[0]) {\n                        break;\n                    }\n\n                    if (node.range[1] === comment.extendedRange[0]) {\n                        if (!node.trailingComments) {\n                            node.trailingComments = [];\n                        }\n                        node.trailingComments.push(comment);\n                        comments.splice(cursor, 1);\n                    } else {\n                        cursor += 1;\n                    }\n                }\n\n                // already out of owned node\n                if (cursor === comments.length) {\n                    return VisitorOption.Break;\n                }\n\n                if (comments[cursor].extendedRange[0] > node.range[1]) {\n                    return VisitorOption.Skip;\n                }\n            }\n        });\n\n        return tree;\n    }\n\n    exports.version = require$$0.version;\n    exports.Syntax = Syntax;\n    exports.traverse = traverse;\n    exports.replace = replace;\n    exports.attachComments = attachComments;\n    exports.VisitorKeys = VisitorKeys;\n    exports.VisitorOption = VisitorOption;\n    exports.Controller = Controller;\n    exports.cloneEnvironment = function () { return clone({}); };\n\n    return exports;\n}(exports));\n/* vim: set sw=4 ts=4 et tw=80 : */\n});\n\n/*\n  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\nconst READ = 0x1;\nconst WRITE = 0x2;\nconst RW = READ | WRITE;\n\n/**\n * A Reference represents a single occurrence of an identifier in code.\n * @class Reference\n */\nclass Reference {\n    constructor(ident, scope, flag, writeExpr, maybeImplicitGlobal, partial, init) {\n\n        /**\n         * Identifier syntax node.\n         * @member {espreeIdentifier} Reference#identifier\n         */\n        this.identifier = ident;\n\n        /**\n         * Reference to the enclosing Scope.\n         * @member {Scope} Reference#from\n         */\n        this.from = scope;\n\n        /**\n         * Whether the reference comes from a dynamic scope (such as 'eval',\n         * 'with', etc.), and may be trapped by dynamic scopes.\n         * @member {boolean} Reference#tainted\n         */\n        this.tainted = false;\n\n        /**\n         * The variable this reference is resolved with.\n         * @member {Variable} Reference#resolved\n         */\n        this.resolved = null;\n\n        /**\n         * The read-write mode of the reference. (Value is one of {@link\n         * Reference.READ}, {@link Reference.RW}, {@link Reference.WRITE}).\n         * @member {number} Reference#flag\n         * @private\n         */\n        this.flag = flag;\n        if (this.isWrite()) {\n\n            /**\n             * If reference is writeable, this is the tree being written to it.\n             * @member {espreeNode} Reference#writeExpr\n             */\n            this.writeExpr = writeExpr;\n\n            /**\n             * Whether the Reference might refer to a partial value of writeExpr.\n             * @member {boolean} Reference#partial\n             */\n            this.partial = partial;\n\n            /**\n             * Whether the Reference is to write of initialization.\n             * @member {boolean} Reference#init\n             */\n            this.init = init;\n        }\n        this.__maybeImplicitGlobal = maybeImplicitGlobal;\n    }\n\n    /**\n     * Whether the reference is static.\n     * @method Reference#isStatic\n     * @returns {boolean} static\n     */\n    isStatic() {\n        return !this.tainted && this.resolved && this.resolved.scope.isStatic();\n    }\n\n    /**\n     * Whether the reference is writeable.\n     * @method Reference#isWrite\n     * @returns {boolean} write\n     */\n    isWrite() {\n        return !!(this.flag & Reference.WRITE);\n    }\n\n    /**\n     * Whether the reference is readable.\n     * @method Reference#isRead\n     * @returns {boolean} read\n     */\n    isRead() {\n        return !!(this.flag & Reference.READ);\n    }\n\n    /**\n     * Whether the reference is read-only.\n     * @method Reference#isReadOnly\n     * @returns {boolean} read only\n     */\n    isReadOnly() {\n        return this.flag === Reference.READ;\n    }\n\n    /**\n     * Whether the reference is write-only.\n     * @method Reference#isWriteOnly\n     * @returns {boolean} write only\n     */\n    isWriteOnly() {\n        return this.flag === Reference.WRITE;\n    }\n\n    /**\n     * Whether the reference is read-write.\n     * @method Reference#isReadWrite\n     * @returns {boolean} read write\n     */\n    isReadWrite() {\n        return this.flag === Reference.RW;\n    }\n}\n\n/**\n * @constant Reference.READ\n * @private\n */\nReference.READ = READ;\n\n/**\n * @constant Reference.WRITE\n * @private\n */\nReference.WRITE = WRITE;\n\n/**\n * @constant Reference.RW\n * @private\n */\nReference.RW = RW;\n\nvar reference = Reference;\n\n/*\n  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * A Variable represents a locally scoped identifier. These include arguments to\n * functions.\n * @class Variable\n */\nclass Variable {\n    constructor(name, scope) {\n\n        /**\n         * The variable name, as given in the source code.\n         * @member {String} Variable#name\n         */\n        this.name = name;\n\n        /**\n         * List of defining occurrences of this variable (like in 'var ...'\n         * statements or as parameter), as AST nodes.\n         * @member {espree.Identifier[]} Variable#identifiers\n         */\n        this.identifiers = [];\n\n        /**\n         * List of {@link Reference|references} of this variable (excluding parameter entries)\n         * in its defining scope and all nested scopes. For defining\n         * occurrences only see {@link Variable#defs}.\n         * @member {Reference[]} Variable#references\n         */\n        this.references = [];\n\n        /**\n         * List of defining occurrences of this variable (like in 'var ...'\n         * statements or as parameter), as custom objects.\n         * @member {Definition[]} Variable#defs\n         */\n        this.defs = [];\n\n        this.tainted = false;\n\n        /**\n         * Whether this is a stack variable.\n         * @member {boolean} Variable#stack\n         */\n        this.stack = true;\n\n        /**\n         * Reference to the enclosing Scope.\n         * @member {Scope} Variable#scope\n         */\n        this.scope = scope;\n    }\n}\n\nVariable.CatchClause = \"CatchClause\";\nVariable.Parameter = \"Parameter\";\nVariable.FunctionName = \"FunctionName\";\nVariable.ClassName = \"ClassName\";\nVariable.Variable = \"Variable\";\nVariable.ImportBinding = \"ImportBinding\";\nVariable.ImplicitGlobalVariable = \"ImplicitGlobalVariable\";\n\nvar variable = Variable;\n\n/**\n * @class Definition\n */\nclass Definition {\n    constructor(type, name, node, parent, index, kind) {\n\n        /**\n         * @member {String} Definition#type - type of the occurrence (e.g. \"Parameter\", \"Variable\", ...).\n         */\n        this.type = type;\n\n        /**\n         * @member {espree.Identifier} Definition#name - the identifier AST node of the occurrence.\n         */\n        this.name = name;\n\n        /**\n         * @member {espree.Node} Definition#node - the enclosing node of the identifier.\n         */\n        this.node = node;\n\n        /**\n         * @member {espree.Node?} Definition#parent - the enclosing statement node of the identifier.\n         */\n        this.parent = parent;\n\n        /**\n         * @member {Number?} Definition#index - the index in the declaration statement.\n         */\n        this.index = index;\n\n        /**\n         * @member {String?} Definition#kind - the kind of the declaration statement.\n         */\n        this.kind = kind;\n    }\n}\n\n/**\n * @class ParameterDefinition\n */\nclass ParameterDefinition extends Definition {\n    constructor(name, node, index, rest) {\n        super(variable.Parameter, name, node, null, index, null);\n\n        /**\n         * Whether the parameter definition is a part of a rest parameter.\n         * @member {boolean} ParameterDefinition#rest\n         */\n        this.rest = rest;\n    }\n}\n\nvar definition = {\n    ParameterDefinition,\n    Definition\n};\n\n/* eslint-disable no-underscore-dangle */\n/* eslint-disable no-undefined */\n\nconst Syntax = estraverse.Syntax;\n\n\n\nconst Definition$1 = definition.Definition;\n\n\n/**\n * Test if scope is struct\n * @param {Scope} scope - scope\n * @param {Block} block - block\n * @param {boolean} isMethodDefinition - is method definiton\n * @param {boolean} useDirective - use directive\n * @returns {boolean} is strict scope\n */\nfunction isStrictScope(scope, block, isMethodDefinition, useDirective) {\n    let body;\n\n    // When upper scope is exists and strict, inner scope is also strict.\n    if (scope.upper && scope.upper.isStrict) {\n        return true;\n    }\n\n    if (isMethodDefinition) {\n        return true;\n    }\n\n    if (scope.type === \"class\" || scope.type === \"module\") {\n        return true;\n    }\n\n    if (scope.type === \"block\" || scope.type === \"switch\") {\n        return false;\n    }\n\n    if (scope.type === \"function\") {\n        if (block.type === Syntax.ArrowFunctionExpression && block.body.type !== Syntax.BlockStatement) {\n            return false;\n        }\n\n        if (block.type === Syntax.Program) {\n            body = block;\n        } else {\n            body = block.body;\n        }\n\n        if (!body) {\n            return false;\n        }\n    } else if (scope.type === \"global\") {\n        body = block;\n    } else {\n        return false;\n    }\n\n    // Search 'use strict' directive.\n    if (useDirective) {\n        for (let i = 0, iz = body.body.length; i < iz; ++i) {\n            const stmt = body.body[i];\n\n            if (stmt.type !== Syntax.DirectiveStatement) {\n                break;\n            }\n            if (stmt.raw === \"\\\"use strict\\\"\" || stmt.raw === \"'use strict'\") {\n                return true;\n            }\n        }\n    } else {\n        for (let i = 0, iz = body.body.length; i < iz; ++i) {\n            const stmt = body.body[i];\n\n            if (stmt.type !== Syntax.ExpressionStatement) {\n                break;\n            }\n            const expr = stmt.expression;\n\n            if (expr.type !== Syntax.Literal || typeof expr.value !== \"string\") {\n                break;\n            }\n            if (expr.raw !== null && expr.raw !== undefined) {\n                if (expr.raw === \"\\\"use strict\\\"\" || expr.raw === \"'use strict'\") {\n                    return true;\n                }\n            } else {\n                if (expr.value === \"use strict\") {\n                    return true;\n                }\n            }\n        }\n    }\n    return false;\n}\n\n/**\n * Register scope\n * @param {ScopeManager} scopeManager - scope manager\n * @param {Scope} scope - scope\n * @returns {void}\n */\nfunction registerScope(scopeManager, scope) {\n    scopeManager.scopes.push(scope);\n\n    const scopes = scopeManager.__nodeToScope.get(scope.block);\n\n    if (scopes) {\n        scopes.push(scope);\n    } else {\n        scopeManager.__nodeToScope.set(scope.block, [scope]);\n    }\n}\n\n/**\n * Should be statically\n * @param {Object} def - def\n * @returns {boolean} should be statically\n */\nfunction shouldBeStatically(def) {\n    return (\n        (def.type === variable.ClassName) ||\n        (def.type === variable.Variable && def.parent.kind !== \"var\")\n    );\n}\n\n/**\n * @class Scope\n */\nclass Scope {\n    constructor(scopeManager, type, upperScope, block, isMethodDefinition) {\n\n        /**\n         * One of 'module', 'block', 'switch', 'function', 'catch', 'with', 'function', 'class', 'global'.\n         * @member {String} Scope#type\n         */\n        this.type = type;\n\n        /**\n         * The scoped {@link Variable}s of this scope, as <code>{ Variable.name\n         * : Variable }</code>.\n         * @member {Map} Scope#set\n         */\n        this.set = new Map();\n\n        /**\n         * The tainted variables of this scope, as <code>{ Variable.name :\n         * boolean }</code>.\n         * @member {Map} Scope#taints */\n        this.taints = new Map();\n\n        /**\n         * Generally, through the lexical scoping of JS you can always know\n         * which variable an identifier in the source code refers to. There are\n         * a few exceptions to this rule. With 'global' and 'with' scopes you\n         * can only decide at runtime which variable a reference refers to.\n         * Moreover, if 'eval()' is used in a scope, it might introduce new\n         * bindings in this or its parent scopes.\n         * All those scopes are considered 'dynamic'.\n         * @member {boolean} Scope#dynamic\n         */\n        this.dynamic = this.type === \"global\" || this.type === \"with\";\n\n        /**\n         * A reference to the scope-defining syntax node.\n         * @member {espree.Node} Scope#block\n         */\n        this.block = block;\n\n        /**\n         * The {@link Reference|references} that are not resolved with this scope.\n         * @member {Reference[]} Scope#through\n         */\n        this.through = [];\n\n        /**\n         * The scoped {@link Variable}s of this scope. In the case of a\n         * 'function' scope this includes the automatic argument <em>arguments</em> as\n         * its first element, as well as all further formal arguments.\n         * @member {Variable[]} Scope#variables\n         */\n        this.variables = [];\n\n        /**\n         * Any variable {@link Reference|reference} found in this scope. This\n         * includes occurrences of local variables as well as variables from\n         * parent scopes (including the global scope). For local variables\n         * this also includes defining occurrences (like in a 'var' statement).\n         * In a 'function' scope this does not include the occurrences of the\n         * formal parameter in the parameter list.\n         * @member {Reference[]} Scope#references\n         */\n        this.references = [];\n\n        /**\n         * For 'global' and 'function' scopes, this is a self-reference. For\n         * other scope types this is the <em>variableScope</em> value of the\n         * parent scope.\n         * @member {Scope} Scope#variableScope\n         */\n        this.variableScope =\n            (this.type === \"global\" || this.type === \"function\" || this.type === \"module\") ? this : upperScope.variableScope;\n\n        /**\n         * Whether this scope is created by a FunctionExpression.\n         * @member {boolean} Scope#functionExpressionScope\n         */\n        this.functionExpressionScope = false;\n\n        /**\n         * Whether this is a scope that contains an 'eval()' invocation.\n         * @member {boolean} Scope#directCallToEvalScope\n         */\n        this.directCallToEvalScope = false;\n\n        /**\n         * @member {boolean} Scope#thisFound\n         */\n        this.thisFound = false;\n\n        this.__left = [];\n\n        /**\n         * Reference to the parent {@link Scope|scope}.\n         * @member {Scope} Scope#upper\n         */\n        this.upper = upperScope;\n\n        /**\n         * Whether 'use strict' is in effect in this scope.\n         * @member {boolean} Scope#isStrict\n         */\n        this.isStrict = isStrictScope(this, block, isMethodDefinition, scopeManager.__useDirective());\n\n        /**\n         * List of nested {@link Scope}s.\n         * @member {Scope[]} Scope#childScopes\n         */\n        this.childScopes = [];\n        if (this.upper) {\n            this.upper.childScopes.push(this);\n        }\n\n        this.__declaredVariables = scopeManager.__declaredVariables;\n\n        registerScope(scopeManager, this);\n    }\n\n    __shouldStaticallyClose(scopeManager) {\n        return (!this.dynamic || scopeManager.__isOptimistic());\n    }\n\n    __shouldStaticallyCloseForGlobal(ref) {\n\n        // On global scope, let/const/class declarations should be resolved statically.\n        const name = ref.identifier.name;\n\n        if (!this.set.has(name)) {\n            return false;\n        }\n\n        const variable = this.set.get(name);\n        const defs = variable.defs;\n\n        return defs.length > 0 && defs.every(shouldBeStatically);\n    }\n\n    __staticCloseRef(ref) {\n        if (!this.__resolve(ref)) {\n            this.__delegateToUpperScope(ref);\n        }\n    }\n\n    __dynamicCloseRef(ref) {\n\n        // notify all names are through to global\n        let current = this;\n\n        do {\n            current.through.push(ref);\n            current = current.upper;\n        } while (current);\n    }\n\n    __globalCloseRef(ref) {\n\n        // let/const/class declarations should be resolved statically.\n        // others should be resolved dynamically.\n        if (this.__shouldStaticallyCloseForGlobal(ref)) {\n            this.__staticCloseRef(ref);\n        } else {\n            this.__dynamicCloseRef(ref);\n        }\n    }\n\n    __close(scopeManager) {\n        let closeRef;\n\n        if (this.__shouldStaticallyClose(scopeManager)) {\n            closeRef = this.__staticCloseRef;\n        } else if (this.type !== \"global\") {\n            closeRef = this.__dynamicCloseRef;\n        } else {\n            closeRef = this.__globalCloseRef;\n        }\n\n        // Try Resolving all references in this scope.\n        for (let i = 0, iz = this.__left.length; i < iz; ++i) {\n            const ref = this.__left[i];\n\n            closeRef.call(this, ref);\n        }\n        this.__left = null;\n\n        return this.upper;\n    }\n\n    // To override by function scopes.\n    // References in default parameters isn't resolved to variables which are in their function body.\n    __isValidResolution(ref, variable) { // eslint-disable-line class-methods-use-this, no-unused-vars\n        return true;\n    }\n\n    __resolve(ref) {\n        const name = ref.identifier.name;\n\n        if (!this.set.has(name)) {\n            return false;\n        }\n        const variable = this.set.get(name);\n\n        if (!this.__isValidResolution(ref, variable)) {\n            return false;\n        }\n        variable.references.push(ref);\n        variable.stack = variable.stack && ref.from.variableScope === this.variableScope;\n        if (ref.tainted) {\n            variable.tainted = true;\n            this.taints.set(variable.name, true);\n        }\n        ref.resolved = variable;\n\n        return true;\n    }\n\n    __delegateToUpperScope(ref) {\n        if (this.upper) {\n            this.upper.__left.push(ref);\n        }\n        this.through.push(ref);\n    }\n\n    __addDeclaredVariablesOfNode(variable, node) {\n        if (node === null || node === undefined) {\n            return;\n        }\n\n        let variables = this.__declaredVariables.get(node);\n\n        if (variables === null || variables === undefined) {\n            variables = [];\n            this.__declaredVariables.set(node, variables);\n        }\n        if (variables.indexOf(variable) === -1) {\n            variables.push(variable);\n        }\n    }\n\n    __defineGeneric(name, set, variables, node, def) {\n        let variable$1;\n\n        variable$1 = set.get(name);\n        if (!variable$1) {\n            variable$1 = new variable(name, this);\n            set.set(name, variable$1);\n            variables.push(variable$1);\n        }\n\n        if (def) {\n            variable$1.defs.push(def);\n            this.__addDeclaredVariablesOfNode(variable$1, def.node);\n            this.__addDeclaredVariablesOfNode(variable$1, def.parent);\n        }\n        if (node) {\n            variable$1.identifiers.push(node);\n        }\n    }\n\n    __define(node, def) {\n        if (node && node.type === Syntax.Identifier) {\n            this.__defineGeneric(\n                node.name,\n                this.set,\n                this.variables,\n                node,\n                def\n            );\n        }\n    }\n\n    __referencing(node, assign, writeExpr, maybeImplicitGlobal, partial, init) {\n\n        // because Array element may be null\n        if (!node || node.type !== Syntax.Identifier) {\n            return;\n        }\n\n        // Specially handle like `this`.\n        if (node.name === \"super\") {\n            return;\n        }\n\n        const ref = new reference(node, this, assign || reference.READ, writeExpr, maybeImplicitGlobal, !!partial, !!init);\n\n        this.references.push(ref);\n        this.__left.push(ref);\n    }\n\n    __detectEval() {\n        let current = this;\n\n        this.directCallToEvalScope = true;\n        do {\n            current.dynamic = true;\n            current = current.upper;\n        } while (current);\n    }\n\n    __detectThis() {\n        this.thisFound = true;\n    }\n\n    __isClosed() {\n        return this.__left === null;\n    }\n\n    /**\n     * returns resolved {Reference}\n     * @method Scope#resolve\n     * @param {Espree.Identifier} ident - identifier to be resolved.\n     * @returns {Reference} reference\n     */\n    resolve(ident) {\n        let ref, i, iz;\n\n        assert(this.__isClosed(), \"Scope should be closed.\");\n        assert(ident.type === Syntax.Identifier, \"Target should be identifier.\");\n        for (i = 0, iz = this.references.length; i < iz; ++i) {\n            ref = this.references[i];\n            if (ref.identifier === ident) {\n                return ref;\n            }\n        }\n        return null;\n    }\n\n    /**\n     * returns this scope is static\n     * @method Scope#isStatic\n     * @returns {boolean} static\n     */\n    isStatic() {\n        return !this.dynamic;\n    }\n\n    /**\n     * returns this scope has materialized arguments\n     * @method Scope#isArgumentsMaterialized\n     * @returns {boolean} arguemnts materialized\n     */\n    isArgumentsMaterialized() { // eslint-disable-line class-methods-use-this\n        return true;\n    }\n\n    /**\n     * returns this scope has materialized `this` reference\n     * @method Scope#isThisMaterialized\n     * @returns {boolean} this materialized\n     */\n    isThisMaterialized() { // eslint-disable-line class-methods-use-this\n        return true;\n    }\n\n    isUsedName(name) {\n        if (this.set.has(name)) {\n            return true;\n        }\n        for (let i = 0, iz = this.through.length; i < iz; ++i) {\n            if (this.through[i].identifier.name === name) {\n                return true;\n            }\n        }\n        return false;\n    }\n}\n\nclass GlobalScope extends Scope {\n    constructor(scopeManager, block) {\n        super(scopeManager, \"global\", null, block, false);\n        this.implicit = {\n            set: new Map(),\n            variables: [],\n\n            /**\n            * List of {@link Reference}s that are left to be resolved (i.e. which\n            * need to be linked to the variable they refer to).\n            * @member {Reference[]} Scope#implicit#left\n            */\n            left: []\n        };\n    }\n\n    __close(scopeManager) {\n        const implicit = [];\n\n        for (let i = 0, iz = this.__left.length; i < iz; ++i) {\n            const ref = this.__left[i];\n\n            if (ref.__maybeImplicitGlobal && !this.set.has(ref.identifier.name)) {\n                implicit.push(ref.__maybeImplicitGlobal);\n            }\n        }\n\n        // create an implicit global variable from assignment expression\n        for (let i = 0, iz = implicit.length; i < iz; ++i) {\n            const info = implicit[i];\n\n            this.__defineImplicit(info.pattern,\n                new Definition$1(\n                    variable.ImplicitGlobalVariable,\n                    info.pattern,\n                    info.node,\n                    null,\n                    null,\n                    null\n                ));\n\n        }\n\n        this.implicit.left = this.__left;\n\n        return super.__close(scopeManager);\n    }\n\n    __defineImplicit(node, def) {\n        if (node && node.type === Syntax.Identifier) {\n            this.__defineGeneric(\n                node.name,\n                this.implicit.set,\n                this.implicit.variables,\n                node,\n                def\n            );\n        }\n    }\n}\n\nclass ModuleScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, \"module\", upperScope, block, false);\n    }\n}\n\nclass FunctionExpressionNameScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, \"function-expression-name\", upperScope, block, false);\n        this.__define(block.id,\n            new Definition$1(\n                variable.FunctionName,\n                block.id,\n                block,\n                null,\n                null,\n                null\n            ));\n        this.functionExpressionScope = true;\n    }\n}\n\nclass CatchScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, \"catch\", upperScope, block, false);\n    }\n}\n\nclass WithScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, \"with\", upperScope, block, false);\n    }\n\n    __close(scopeManager) {\n        if (this.__shouldStaticallyClose(scopeManager)) {\n            return super.__close(scopeManager);\n        }\n\n        for (let i = 0, iz = this.__left.length; i < iz; ++i) {\n            const ref = this.__left[i];\n\n            ref.tainted = true;\n            this.__delegateToUpperScope(ref);\n        }\n        this.__left = null;\n\n        return this.upper;\n    }\n}\n\nclass BlockScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, \"block\", upperScope, block, false);\n    }\n}\n\nclass SwitchScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, \"switch\", upperScope, block, false);\n    }\n}\n\nclass FunctionScope extends Scope {\n    constructor(scopeManager, upperScope, block, isMethodDefinition) {\n        super(scopeManager, \"function\", upperScope, block, isMethodDefinition);\n\n        // section 9.2.13, FunctionDeclarationInstantiation.\n        // NOTE Arrow functions never have an arguments objects.\n        if (this.block.type !== Syntax.ArrowFunctionExpression) {\n            this.__defineArguments();\n        }\n    }\n\n    isArgumentsMaterialized() {\n\n        // TODO(Constellation)\n        // We can more aggressive on this condition like this.\n        //\n        // function t() {\n        //     // arguments of t is always hidden.\n        //     function arguments() {\n        //     }\n        // }\n        if (this.block.type === Syntax.ArrowFunctionExpression) {\n            return false;\n        }\n\n        if (!this.isStatic()) {\n            return true;\n        }\n\n        const variable = this.set.get(\"arguments\");\n\n        assert(variable, \"Always have arguments variable.\");\n        return variable.tainted || variable.references.length !== 0;\n    }\n\n    isThisMaterialized() {\n        if (!this.isStatic()) {\n            return true;\n        }\n        return this.thisFound;\n    }\n\n    __defineArguments() {\n        this.__defineGeneric(\n            \"arguments\",\n            this.set,\n            this.variables,\n            null,\n            null\n        );\n        this.taints.set(\"arguments\", true);\n    }\n\n    // References in default parameters isn't resolved to variables which are in their function body.\n    //     const x = 1\n    //     function f(a = x) { // This `x` is resolved to the `x` in the outer scope.\n    //         const x = 2\n    //         console.log(a)\n    //     }\n    __isValidResolution(ref, variable) {\n\n        // If `options.nodejsScope` is true, `this.block` becomes a Program node.\n        if (this.block.type === \"Program\") {\n            return true;\n        }\n\n        const bodyStart = this.block.body.range[0];\n\n        // It's invalid resolution in the following case:\n        return !(\n            variable.scope === this &&\n            ref.identifier.range[0] < bodyStart && // the reference is in the parameter part.\n            variable.defs.every(d => d.name.range[0] >= bodyStart) // the variable is in the body.\n        );\n    }\n}\n\nclass ForScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, \"for\", upperScope, block, false);\n    }\n}\n\nclass ClassScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, \"class\", upperScope, block, false);\n    }\n}\n\nvar scope = {\n    Scope,\n    GlobalScope,\n    ModuleScope,\n    FunctionExpressionNameScope,\n    CatchScope,\n    WithScope,\n    BlockScope,\n    SwitchScope,\n    FunctionScope,\n    ForScope,\n    ClassScope\n};\n\n/* eslint-disable no-underscore-dangle */\n\n\n\n\nconst GlobalScope$1 = scope.GlobalScope;\nconst CatchScope$1 = scope.CatchScope;\nconst WithScope$1 = scope.WithScope;\nconst ModuleScope$1 = scope.ModuleScope;\nconst ClassScope$1 = scope.ClassScope;\nconst SwitchScope$1 = scope.SwitchScope;\nconst FunctionScope$1 = scope.FunctionScope;\nconst ForScope$1 = scope.ForScope;\nconst FunctionExpressionNameScope$1 = scope.FunctionExpressionNameScope;\nconst BlockScope$1 = scope.BlockScope;\n\n/**\n * @class ScopeManager\n */\nclass ScopeManager {\n    constructor(options) {\n        this.scopes = [];\n        this.globalScope = null;\n        this.__nodeToScope = new WeakMap();\n        this.__currentScope = null;\n        this.__options = options;\n        this.__declaredVariables = new WeakMap();\n    }\n\n    __useDirective() {\n        return this.__options.directive;\n    }\n\n    __isOptimistic() {\n        return this.__options.optimistic;\n    }\n\n    __ignoreEval() {\n        return this.__options.ignoreEval;\n    }\n\n    __isNodejsScope() {\n        return this.__options.nodejsScope;\n    }\n\n    isModule() {\n        return this.__options.sourceType === \"module\";\n    }\n\n    isImpliedStrict() {\n        return this.__options.impliedStrict;\n    }\n\n    isStrictModeSupported() {\n        return this.__options.ecmaVersion >= 5;\n    }\n\n    // Returns appropriate scope for this node.\n    __get(node) {\n        return this.__nodeToScope.get(node);\n    }\n\n    /**\n     * Get variables that are declared by the node.\n     *\n     * \"are declared by the node\" means the node is same as `Variable.defs[].node` or `Variable.defs[].parent`.\n     * If the node declares nothing, this method returns an empty array.\n     * CAUTION: This API is experimental. See https://github.com/estools/escope/pull/69 for more details.\n     *\n     * @param {Espree.Node} node - a node to get.\n     * @returns {Variable[]} variables that declared by the node.\n     */\n    getDeclaredVariables(node) {\n        return this.__declaredVariables.get(node) || [];\n    }\n\n    /**\n     * acquire scope from node.\n     * @method ScopeManager#acquire\n     * @param {Espree.Node} node - node for the acquired scope.\n     * @param {boolean=} inner - look up the most inner scope, default value is false.\n     * @returns {Scope?} Scope from node\n     */\n    acquire(node, inner) {\n\n        /**\n         * predicate\n         * @param {Scope} testScope - scope to test\n         * @returns {boolean} predicate\n         */\n        function predicate(testScope) {\n            if (testScope.type === \"function\" && testScope.functionExpressionScope) {\n                return false;\n            }\n            return true;\n        }\n\n        const scopes = this.__get(node);\n\n        if (!scopes || scopes.length === 0) {\n            return null;\n        }\n\n        // Heuristic selection from all scopes.\n        // If you would like to get all scopes, please use ScopeManager#acquireAll.\n        if (scopes.length === 1) {\n            return scopes[0];\n        }\n\n        if (inner) {\n            for (let i = scopes.length - 1; i >= 0; --i) {\n                const scope = scopes[i];\n\n                if (predicate(scope)) {\n                    return scope;\n                }\n            }\n        } else {\n            for (let i = 0, iz = scopes.length; i < iz; ++i) {\n                const scope = scopes[i];\n\n                if (predicate(scope)) {\n                    return scope;\n                }\n            }\n        }\n\n        return null;\n    }\n\n    /**\n     * acquire all scopes from node.\n     * @method ScopeManager#acquireAll\n     * @param {Espree.Node} node - node for the acquired scope.\n     * @returns {Scopes?} Scope array\n     */\n    acquireAll(node) {\n        return this.__get(node);\n    }\n\n    /**\n     * release the node.\n     * @method ScopeManager#release\n     * @param {Espree.Node} node - releasing node.\n     * @param {boolean=} inner - look up the most inner scope, default value is false.\n     * @returns {Scope?} upper scope for the node.\n     */\n    release(node, inner) {\n        const scopes = this.__get(node);\n\n        if (scopes && scopes.length) {\n            const scope = scopes[0].upper;\n\n            if (!scope) {\n                return null;\n            }\n            return this.acquire(scope.block, inner);\n        }\n        return null;\n    }\n\n    attach() { } // eslint-disable-line class-methods-use-this\n\n    detach() { } // eslint-disable-line class-methods-use-this\n\n    __nestScope(scope) {\n        if (scope instanceof GlobalScope$1) {\n            assert(this.__currentScope === null);\n            this.globalScope = scope;\n        }\n        this.__currentScope = scope;\n        return scope;\n    }\n\n    __nestGlobalScope(node) {\n        return this.__nestScope(new GlobalScope$1(this, node));\n    }\n\n    __nestBlockScope(node) {\n        return this.__nestScope(new BlockScope$1(this, this.__currentScope, node));\n    }\n\n    __nestFunctionScope(node, isMethodDefinition) {\n        return this.__nestScope(new FunctionScope$1(this, this.__currentScope, node, isMethodDefinition));\n    }\n\n    __nestForScope(node) {\n        return this.__nestScope(new ForScope$1(this, this.__currentScope, node));\n    }\n\n    __nestCatchScope(node) {\n        return this.__nestScope(new CatchScope$1(this, this.__currentScope, node));\n    }\n\n    __nestWithScope(node) {\n        return this.__nestScope(new WithScope$1(this, this.__currentScope, node));\n    }\n\n    __nestClassScope(node) {\n        return this.__nestScope(new ClassScope$1(this, this.__currentScope, node));\n    }\n\n    __nestSwitchScope(node) {\n        return this.__nestScope(new SwitchScope$1(this, this.__currentScope, node));\n    }\n\n    __nestModuleScope(node) {\n        return this.__nestScope(new ModuleScope$1(this, this.__currentScope, node));\n    }\n\n    __nestFunctionExpressionNameScope(node) {\n        return this.__nestScope(new FunctionExpressionNameScope$1(this, this.__currentScope, node));\n    }\n\n    __isES6() {\n        return this.__options.ecmaVersion >= 6;\n    }\n}\n\nvar scopeManager = ScopeManager;\n\nvar name$2 = \"esrecurse\";\nvar description$2 = \"ECMAScript AST recursive visitor\";\nvar homepage$2 = \"https://github.com/estools/esrecurse\";\nvar main$2 = \"esrecurse.js\";\nvar version$2 = \"4.2.1\";\nvar engines$2 = {\n\tnode: \">=4.0\"\n};\nvar maintainers$1 = [\n\t{\n\t\tname: \"Yusuke Suzuki\",\n\t\temail: \"utatane.tea@gmail.com\",\n\t\tweb: \"https://github.com/Constellation\"\n\t}\n];\nvar repository$2 = {\n\ttype: \"git\",\n\turl: \"https://github.com/estools/esrecurse.git\"\n};\nvar dependencies$1 = {\n\testraverse: \"^4.1.0\"\n};\nvar devDependencies$2 = {\n\t\"babel-cli\": \"^6.24.1\",\n\t\"babel-eslint\": \"^7.2.3\",\n\t\"babel-preset-es2015\": \"^6.24.1\",\n\t\"babel-register\": \"^6.24.1\",\n\tchai: \"^4.0.2\",\n\tesprima: \"^4.0.0\",\n\tgulp: \"^3.9.0\",\n\t\"gulp-bump\": \"^2.7.0\",\n\t\"gulp-eslint\": \"^4.0.0\",\n\t\"gulp-filter\": \"^5.0.0\",\n\t\"gulp-git\": \"^2.4.1\",\n\t\"gulp-mocha\": \"^4.3.1\",\n\t\"gulp-tag-version\": \"^1.2.1\",\n\tjsdoc: \"^3.3.0-alpha10\",\n\tminimist: \"^1.1.0\"\n};\nvar license$2 = \"BSD-2-Clause\";\nvar scripts$2 = {\n\ttest: \"gulp travis\",\n\t\"unit-test\": \"gulp test\",\n\tlint: \"gulp lint\"\n};\nvar babel = {\n\tpresets: [\n\t\t\"es2015\"\n\t]\n};\nvar _package$4 = {\n\tname: name$2,\n\tdescription: description$2,\n\thomepage: homepage$2,\n\tmain: main$2,\n\tversion: version$2,\n\tengines: engines$2,\n\tmaintainers: maintainers$1,\n\trepository: repository$2,\n\tdependencies: dependencies$1,\n\tdevDependencies: devDependencies$2,\n\tlicense: license$2,\n\tscripts: scripts$2,\n\tbabel: babel\n};\n\nvar _package$5 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  name: name$2,\n  description: description$2,\n  homepage: homepage$2,\n  main: main$2,\n  version: version$2,\n  engines: engines$2,\n  maintainers: maintainers$1,\n  repository: repository$2,\n  dependencies: dependencies$1,\n  devDependencies: devDependencies$2,\n  license: license$2,\n  scripts: scripts$2,\n  babel: babel,\n  'default': _package$4\n});\n\nvar require$$1 = getCjsExportFromNamespace(_package$5);\n\nvar esrecurse = createCommonjsModule(function (module, exports) {\n/*\n  Copyright (C) 2014 Yusuke Suzuki <utatane.tea@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n(function () {\n\n    var estraverse$1 = estraverse;\n\n    function isNode(node) {\n        if (node == null) {\n            return false;\n        }\n        return typeof node === 'object' && typeof node.type === 'string';\n    }\n\n    function isProperty(nodeType, key) {\n        return (nodeType === estraverse$1.Syntax.ObjectExpression || nodeType === estraverse$1.Syntax.ObjectPattern) && key === 'properties';\n    }\n\n    function Visitor(visitor, options) {\n        options = options || {};\n\n        this.__visitor = visitor ||  this;\n        this.__childVisitorKeys = options.childVisitorKeys\n            ? Object.assign({}, estraverse$1.VisitorKeys, options.childVisitorKeys)\n            : estraverse$1.VisitorKeys;\n        if (options.fallback === 'iteration') {\n            this.__fallback = Object.keys;\n        } else if (typeof options.fallback === 'function') {\n            this.__fallback = options.fallback;\n        }\n    }\n\n    /* Default method for visiting children.\n     * When you need to call default visiting operation inside custom visiting\n     * operation, you can use it with `this.visitChildren(node)`.\n     */\n    Visitor.prototype.visitChildren = function (node) {\n        var type, children, i, iz, j, jz, child;\n\n        if (node == null) {\n            return;\n        }\n\n        type = node.type || estraverse$1.Syntax.Property;\n\n        children = this.__childVisitorKeys[type];\n        if (!children) {\n            if (this.__fallback) {\n                children = this.__fallback(node);\n            } else {\n                throw new Error('Unknown node type ' + type + '.');\n            }\n        }\n\n        for (i = 0, iz = children.length; i < iz; ++i) {\n            child = node[children[i]];\n            if (child) {\n                if (Array.isArray(child)) {\n                    for (j = 0, jz = child.length; j < jz; ++j) {\n                        if (child[j]) {\n                            if (isNode(child[j]) || isProperty(type, children[i])) {\n                                this.visit(child[j]);\n                            }\n                        }\n                    }\n                } else if (isNode(child)) {\n                    this.visit(child);\n                }\n            }\n        }\n    };\n\n    /* Dispatching node. */\n    Visitor.prototype.visit = function (node) {\n        var type;\n\n        if (node == null) {\n            return;\n        }\n\n        type = node.type || estraverse$1.Syntax.Property;\n        if (this.__visitor[type]) {\n            this.__visitor[type].call(this, node);\n            return;\n        }\n        this.visitChildren(node);\n    };\n\n    exports.version = require$$1.version;\n    exports.Visitor = Visitor;\n    exports.visit = function (node, visitor, options) {\n        var v = new Visitor(visitor, options);\n        v.visit(node);\n    };\n}());\n/* vim: set sw=4 ts=4 et tw=80 : */\n});\nvar esrecurse_1 = esrecurse.version;\nvar esrecurse_2 = esrecurse.Visitor;\nvar esrecurse_3 = esrecurse.visit;\n\n/* eslint-disable no-undefined */\n\nconst Syntax$1 = estraverse.Syntax;\n\n\n/**\n * Get last array element\n * @param {array} xs - array\n * @returns {any} Last elment\n */\nfunction getLast(xs) {\n    return xs[xs.length - 1] || null;\n}\n\nclass PatternVisitor extends esrecurse.Visitor {\n    static isPattern(node) {\n        const nodeType = node.type;\n\n        return (\n            nodeType === Syntax$1.Identifier ||\n            nodeType === Syntax$1.ObjectPattern ||\n            nodeType === Syntax$1.ArrayPattern ||\n            nodeType === Syntax$1.SpreadElement ||\n            nodeType === Syntax$1.RestElement ||\n            nodeType === Syntax$1.AssignmentPattern\n        );\n    }\n\n    constructor(options, rootPattern, callback) {\n        super(null, options);\n        this.rootPattern = rootPattern;\n        this.callback = callback;\n        this.assignments = [];\n        this.rightHandNodes = [];\n        this.restElements = [];\n    }\n\n    Identifier(pattern) {\n        const lastRestElement = getLast(this.restElements);\n\n        this.callback(pattern, {\n            topLevel: pattern === this.rootPattern,\n            rest: lastRestElement !== null && lastRestElement !== undefined && lastRestElement.argument === pattern,\n            assignments: this.assignments\n        });\n    }\n\n    Property(property) {\n\n        // Computed property's key is a right hand node.\n        if (property.computed) {\n            this.rightHandNodes.push(property.key);\n        }\n\n        // If it's shorthand, its key is same as its value.\n        // If it's shorthand and has its default value, its key is same as its value.left (the value is AssignmentPattern).\n        // If it's not shorthand, the name of new variable is its value's.\n        this.visit(property.value);\n    }\n\n    ArrayPattern(pattern) {\n        for (let i = 0, iz = pattern.elements.length; i < iz; ++i) {\n            const element = pattern.elements[i];\n\n            this.visit(element);\n        }\n    }\n\n    AssignmentPattern(pattern) {\n        this.assignments.push(pattern);\n        this.visit(pattern.left);\n        this.rightHandNodes.push(pattern.right);\n        this.assignments.pop();\n    }\n\n    RestElement(pattern) {\n        this.restElements.push(pattern);\n        this.visit(pattern.argument);\n        this.restElements.pop();\n    }\n\n    MemberExpression(node) {\n\n        // Computed property's key is a right hand node.\n        if (node.computed) {\n            this.rightHandNodes.push(node.property);\n        }\n\n        // the object is only read, write to its property.\n        this.rightHandNodes.push(node.object);\n    }\n\n    //\n    // ForInStatement.left and AssignmentExpression.left are LeftHandSideExpression.\n    // By spec, LeftHandSideExpression is Pattern or MemberExpression.\n    //   (see also: https://github.com/estree/estree/pull/20#issuecomment-74584758)\n    // But espree 2.0 parses to ArrayExpression, ObjectExpression, etc...\n    //\n\n    SpreadElement(node) {\n        this.visit(node.argument);\n    }\n\n    ArrayExpression(node) {\n        node.elements.forEach(this.visit, this);\n    }\n\n    AssignmentExpression(node) {\n        this.assignments.push(node);\n        this.visit(node.left);\n        this.rightHandNodes.push(node.right);\n        this.assignments.pop();\n    }\n\n    CallExpression(node) {\n\n        // arguments are right hand nodes.\n        node.arguments.forEach(a => {\n            this.rightHandNodes.push(a);\n        });\n        this.visit(node.callee);\n    }\n}\n\nvar patternVisitor = PatternVisitor;\n\n/* eslint-disable no-underscore-dangle */\n/* eslint-disable no-undefined */\n\nconst Syntax$2 = estraverse.Syntax;\n\n\n\n\n\n\n\nconst ParameterDefinition$1 = definition.ParameterDefinition;\nconst Definition$2 = definition.Definition;\n\n/**\n * Traverse identifier in pattern\n * @param {Object} options - options\n * @param {pattern} rootPattern - root pattern\n * @param {Refencer} referencer - referencer\n * @param {callback} callback - callback\n * @returns {void}\n */\nfunction traverseIdentifierInPattern(options, rootPattern, referencer, callback) {\n\n    // Call the callback at left hand identifier nodes, and Collect right hand nodes.\n    const visitor = new patternVisitor(options, rootPattern, callback);\n\n    visitor.visit(rootPattern);\n\n    // Process the right hand nodes recursively.\n    if (referencer !== null && referencer !== undefined) {\n        visitor.rightHandNodes.forEach(referencer.visit, referencer);\n    }\n}\n\n// Importing ImportDeclaration.\n// http://people.mozilla.org/~jorendorff/es6-draft.html#sec-moduledeclarationinstantiation\n// https://github.com/estree/estree/blob/master/es6.md#importdeclaration\n// FIXME: Now, we don't create module environment, because the context is\n// implementation dependent.\n\nclass Importer extends esrecurse.Visitor {\n    constructor(declaration, referencer) {\n        super(null, referencer.options);\n        this.declaration = declaration;\n        this.referencer = referencer;\n    }\n\n    visitImport(id, specifier) {\n        this.referencer.visitPattern(id, pattern => {\n            this.referencer.currentScope().__define(pattern,\n                new Definition$2(\n                    variable.ImportBinding,\n                    pattern,\n                    specifier,\n                    this.declaration,\n                    null,\n                    null\n                ));\n        });\n    }\n\n    ImportNamespaceSpecifier(node) {\n        const local = (node.local || node.id);\n\n        if (local) {\n            this.visitImport(local, node);\n        }\n    }\n\n    ImportDefaultSpecifier(node) {\n        const local = (node.local || node.id);\n\n        this.visitImport(local, node);\n    }\n\n    ImportSpecifier(node) {\n        const local = (node.local || node.id);\n\n        if (node.name) {\n            this.visitImport(node.name, node);\n        } else {\n            this.visitImport(local, node);\n        }\n    }\n}\n\n// Referencing variables and creating bindings.\nclass Referencer extends esrecurse.Visitor {\n    constructor(options, scopeManager) {\n        super(null, options);\n        this.options = options;\n        this.scopeManager = scopeManager;\n        this.parent = null;\n        this.isInnerMethodDefinition = false;\n    }\n\n    currentScope() {\n        return this.scopeManager.__currentScope;\n    }\n\n    close(node) {\n        while (this.currentScope() && node === this.currentScope().block) {\n            this.scopeManager.__currentScope = this.currentScope().__close(this.scopeManager);\n        }\n    }\n\n    pushInnerMethodDefinition(isInnerMethodDefinition) {\n        const previous = this.isInnerMethodDefinition;\n\n        this.isInnerMethodDefinition = isInnerMethodDefinition;\n        return previous;\n    }\n\n    popInnerMethodDefinition(isInnerMethodDefinition) {\n        this.isInnerMethodDefinition = isInnerMethodDefinition;\n    }\n\n    referencingDefaultValue(pattern, assignments, maybeImplicitGlobal, init) {\n        const scope = this.currentScope();\n\n        assignments.forEach(assignment => {\n            scope.__referencing(\n                pattern,\n                reference.WRITE,\n                assignment.right,\n                maybeImplicitGlobal,\n                pattern !== assignment.left,\n                init\n            );\n        });\n    }\n\n    visitPattern(node, options, callback) {\n        let visitPatternOptions = options;\n        let visitPatternCallback = callback;\n\n        if (typeof options === \"function\") {\n            visitPatternCallback = options;\n            visitPatternOptions = { processRightHandNodes: false };\n        }\n\n        traverseIdentifierInPattern(\n            this.options,\n            node,\n            visitPatternOptions.processRightHandNodes ? this : null,\n            visitPatternCallback\n        );\n    }\n\n    visitFunction(node) {\n        let i, iz;\n\n        // FunctionDeclaration name is defined in upper scope\n        // NOTE: Not referring variableScope. It is intended.\n        // Since\n        //  in ES5, FunctionDeclaration should be in FunctionBody.\n        //  in ES6, FunctionDeclaration should be block scoped.\n\n        if (node.type === Syntax$2.FunctionDeclaration) {\n\n            // id is defined in upper scope\n            this.currentScope().__define(node.id,\n                new Definition$2(\n                    variable.FunctionName,\n                    node.id,\n                    node,\n                    null,\n                    null,\n                    null\n                ));\n        }\n\n        // FunctionExpression with name creates its special scope;\n        // FunctionExpressionNameScope.\n        if (node.type === Syntax$2.FunctionExpression && node.id) {\n            this.scopeManager.__nestFunctionExpressionNameScope(node);\n        }\n\n        // Consider this function is in the MethodDefinition.\n        this.scopeManager.__nestFunctionScope(node, this.isInnerMethodDefinition);\n\n        const that = this;\n\n        /**\n         * Visit pattern callback\n         * @param {pattern} pattern - pattern\n         * @param {Object} info - info\n         * @returns {void}\n         */\n        function visitPatternCallback(pattern, info) {\n            that.currentScope().__define(pattern,\n                new ParameterDefinition$1(\n                    pattern,\n                    node,\n                    i,\n                    info.rest\n                ));\n\n            that.referencingDefaultValue(pattern, info.assignments, null, true);\n        }\n\n        // Process parameter declarations.\n        for (i = 0, iz = node.params.length; i < iz; ++i) {\n            this.visitPattern(node.params[i], { processRightHandNodes: true }, visitPatternCallback);\n        }\n\n        // if there's a rest argument, add that\n        if (node.rest) {\n            this.visitPattern({\n                type: \"RestElement\",\n                argument: node.rest\n            }, pattern => {\n                this.currentScope().__define(pattern,\n                    new ParameterDefinition$1(\n                        pattern,\n                        node,\n                        node.params.length,\n                        true\n                    ));\n            });\n        }\n\n        // In TypeScript there are a number of function-like constructs which have no body,\n        // so check it exists before traversing\n        if (node.body) {\n\n            // Skip BlockStatement to prevent creating BlockStatement scope.\n            if (node.body.type === Syntax$2.BlockStatement) {\n                this.visitChildren(node.body);\n            } else {\n                this.visit(node.body);\n            }\n        }\n\n        this.close(node);\n    }\n\n    visitClass(node) {\n        if (node.type === Syntax$2.ClassDeclaration) {\n            this.currentScope().__define(node.id,\n                new Definition$2(\n                    variable.ClassName,\n                    node.id,\n                    node,\n                    null,\n                    null,\n                    null\n                ));\n        }\n\n        this.visit(node.superClass);\n\n        this.scopeManager.__nestClassScope(node);\n\n        if (node.id) {\n            this.currentScope().__define(node.id,\n                new Definition$2(\n                    variable.ClassName,\n                    node.id,\n                    node\n                ));\n        }\n        this.visit(node.body);\n\n        this.close(node);\n    }\n\n    visitProperty(node) {\n        let previous;\n\n        if (node.computed) {\n            this.visit(node.key);\n        }\n\n        const isMethodDefinition = node.type === Syntax$2.MethodDefinition;\n\n        if (isMethodDefinition) {\n            previous = this.pushInnerMethodDefinition(true);\n        }\n        this.visit(node.value);\n        if (isMethodDefinition) {\n            this.popInnerMethodDefinition(previous);\n        }\n    }\n\n    visitForIn(node) {\n        if (node.left.type === Syntax$2.VariableDeclaration && node.left.kind !== \"var\") {\n            this.scopeManager.__nestForScope(node);\n        }\n\n        if (node.left.type === Syntax$2.VariableDeclaration) {\n            this.visit(node.left);\n            this.visitPattern(node.left.declarations[0].id, pattern => {\n                this.currentScope().__referencing(pattern, reference.WRITE, node.right, null, true, true);\n            });\n        } else {\n            this.visitPattern(node.left, { processRightHandNodes: true }, (pattern, info) => {\n                let maybeImplicitGlobal = null;\n\n                if (!this.currentScope().isStrict) {\n                    maybeImplicitGlobal = {\n                        pattern,\n                        node\n                    };\n                }\n                this.referencingDefaultValue(pattern, info.assignments, maybeImplicitGlobal, false);\n                this.currentScope().__referencing(pattern, reference.WRITE, node.right, maybeImplicitGlobal, true, false);\n            });\n        }\n        this.visit(node.right);\n        this.visit(node.body);\n\n        this.close(node);\n    }\n\n    visitVariableDeclaration(variableTargetScope, type, node, index) {\n\n        const decl = node.declarations[index];\n        const init = decl.init;\n\n        this.visitPattern(decl.id, { processRightHandNodes: true }, (pattern, info) => {\n            variableTargetScope.__define(\n                pattern,\n                new Definition$2(\n                    type,\n                    pattern,\n                    decl,\n                    node,\n                    index,\n                    node.kind\n                )\n            );\n\n            this.referencingDefaultValue(pattern, info.assignments, null, true);\n            if (init) {\n                this.currentScope().__referencing(pattern, reference.WRITE, init, null, !info.topLevel, true);\n            }\n        });\n    }\n\n    AssignmentExpression(node) {\n        if (patternVisitor.isPattern(node.left)) {\n            if (node.operator === \"=\") {\n                this.visitPattern(node.left, { processRightHandNodes: true }, (pattern, info) => {\n                    let maybeImplicitGlobal = null;\n\n                    if (!this.currentScope().isStrict) {\n                        maybeImplicitGlobal = {\n                            pattern,\n                            node\n                        };\n                    }\n                    this.referencingDefaultValue(pattern, info.assignments, maybeImplicitGlobal, false);\n                    this.currentScope().__referencing(pattern, reference.WRITE, node.right, maybeImplicitGlobal, !info.topLevel, false);\n                });\n            } else {\n                this.currentScope().__referencing(node.left, reference.RW, node.right);\n            }\n        } else {\n            this.visit(node.left);\n        }\n        this.visit(node.right);\n    }\n\n    CatchClause(node) {\n        this.scopeManager.__nestCatchScope(node);\n\n        this.visitPattern(node.param, { processRightHandNodes: true }, (pattern, info) => {\n            this.currentScope().__define(pattern,\n                new Definition$2(\n                    variable.CatchClause,\n                    node.param,\n                    node,\n                    null,\n                    null,\n                    null\n                ));\n            this.referencingDefaultValue(pattern, info.assignments, null, true);\n        });\n        this.visit(node.body);\n\n        this.close(node);\n    }\n\n    Program(node) {\n        this.scopeManager.__nestGlobalScope(node);\n\n        if (this.scopeManager.__isNodejsScope()) {\n\n            // Force strictness of GlobalScope to false when using node.js scope.\n            this.currentScope().isStrict = false;\n            this.scopeManager.__nestFunctionScope(node, false);\n        }\n\n        if (this.scopeManager.__isES6() && this.scopeManager.isModule()) {\n            this.scopeManager.__nestModuleScope(node);\n        }\n\n        if (this.scopeManager.isStrictModeSupported() && this.scopeManager.isImpliedStrict()) {\n            this.currentScope().isStrict = true;\n        }\n\n        this.visitChildren(node);\n        this.close(node);\n    }\n\n    Identifier(node) {\n        this.currentScope().__referencing(node);\n    }\n\n    UpdateExpression(node) {\n        if (patternVisitor.isPattern(node.argument)) {\n            this.currentScope().__referencing(node.argument, reference.RW, null);\n        } else {\n            this.visitChildren(node);\n        }\n    }\n\n    MemberExpression(node) {\n        this.visit(node.object);\n        if (node.computed) {\n            this.visit(node.property);\n        }\n    }\n\n    Property(node) {\n        this.visitProperty(node);\n    }\n\n    MethodDefinition(node) {\n        this.visitProperty(node);\n    }\n\n    BreakStatement() {} // eslint-disable-line class-methods-use-this\n\n    ContinueStatement() {} // eslint-disable-line class-methods-use-this\n\n    LabeledStatement(node) {\n        this.visit(node.body);\n    }\n\n    ForStatement(node) {\n\n        // Create ForStatement declaration.\n        // NOTE: In ES6, ForStatement dynamically generates\n        // per iteration environment. However, escope is\n        // a static analyzer, we only generate one scope for ForStatement.\n        if (node.init && node.init.type === Syntax$2.VariableDeclaration && node.init.kind !== \"var\") {\n            this.scopeManager.__nestForScope(node);\n        }\n\n        this.visitChildren(node);\n\n        this.close(node);\n    }\n\n    ClassExpression(node) {\n        this.visitClass(node);\n    }\n\n    ClassDeclaration(node) {\n        this.visitClass(node);\n    }\n\n    CallExpression(node) {\n\n        // Check this is direct call to eval\n        if (!this.scopeManager.__ignoreEval() && node.callee.type === Syntax$2.Identifier && node.callee.name === \"eval\") {\n\n            // NOTE: This should be `variableScope`. Since direct eval call always creates Lexical environment and\n            // let / const should be enclosed into it. Only VariableDeclaration affects on the caller's environment.\n            this.currentScope().variableScope.__detectEval();\n        }\n        this.visitChildren(node);\n    }\n\n    BlockStatement(node) {\n        if (this.scopeManager.__isES6()) {\n            this.scopeManager.__nestBlockScope(node);\n        }\n\n        this.visitChildren(node);\n\n        this.close(node);\n    }\n\n    ThisExpression() {\n        this.currentScope().variableScope.__detectThis();\n    }\n\n    WithStatement(node) {\n        this.visit(node.object);\n\n        // Then nest scope for WithStatement.\n        this.scopeManager.__nestWithScope(node);\n\n        this.visit(node.body);\n\n        this.close(node);\n    }\n\n    VariableDeclaration(node) {\n        const variableTargetScope = (node.kind === \"var\") ? this.currentScope().variableScope : this.currentScope();\n\n        for (let i = 0, iz = node.declarations.length; i < iz; ++i) {\n            const decl = node.declarations[i];\n\n            this.visitVariableDeclaration(variableTargetScope, variable.Variable, node, i);\n            if (decl.init) {\n                this.visit(decl.init);\n            }\n        }\n    }\n\n    // sec 13.11.8\n    SwitchStatement(node) {\n        this.visit(node.discriminant);\n\n        if (this.scopeManager.__isES6()) {\n            this.scopeManager.__nestSwitchScope(node);\n        }\n\n        for (let i = 0, iz = node.cases.length; i < iz; ++i) {\n            this.visit(node.cases[i]);\n        }\n\n        this.close(node);\n    }\n\n    FunctionDeclaration(node) {\n        this.visitFunction(node);\n    }\n\n    FunctionExpression(node) {\n        this.visitFunction(node);\n    }\n\n    ForOfStatement(node) {\n        this.visitForIn(node);\n    }\n\n    ForInStatement(node) {\n        this.visitForIn(node);\n    }\n\n    ArrowFunctionExpression(node) {\n        this.visitFunction(node);\n    }\n\n    ImportDeclaration(node) {\n        assert(this.scopeManager.__isES6() && this.scopeManager.isModule(), \"ImportDeclaration should appear when the mode is ES6 and in the module context.\");\n\n        const importer = new Importer(node, this);\n\n        importer.visit(node);\n    }\n\n    visitExportDeclaration(node) {\n        if (node.source) {\n            return;\n        }\n        if (node.declaration) {\n            this.visit(node.declaration);\n            return;\n        }\n\n        this.visitChildren(node);\n    }\n\n    ExportDeclaration(node) {\n        this.visitExportDeclaration(node);\n    }\n\n    ExportNamedDeclaration(node) {\n        this.visitExportDeclaration(node);\n    }\n\n    ExportSpecifier(node) {\n        const local = (node.id || node.local);\n\n        this.visit(local);\n    }\n\n    MetaProperty() { // eslint-disable-line class-methods-use-this\n\n        // do nothing.\n    }\n}\n\nvar referencer = Referencer;\n\nvar name$3 = \"eslint-scope\";\nvar description$3 = \"ECMAScript scope analyzer for ESLint\";\nvar homepage$3 = \"http://github.com/eslint/eslint-scope\";\nvar main$3 = \"lib/index.js\";\nvar version$3 = \"5.0.0\";\nvar engines$3 = {\n\tnode: \">=8.0.0\"\n};\nvar repository$3 = \"eslint/eslint-scope\";\nvar bugs$1 = {\n\turl: \"https://github.com/eslint/eslint-scope/issues\"\n};\nvar license$3 = \"BSD-2-Clause\";\nvar scripts$3 = {\n\ttest: \"node Makefile.js test\",\n\tlint: \"node Makefile.js lint\",\n\t\"generate-release\": \"eslint-generate-release\",\n\t\"generate-alpharelease\": \"eslint-generate-prerelease alpha\",\n\t\"generate-betarelease\": \"eslint-generate-prerelease beta\",\n\t\"generate-rcrelease\": \"eslint-generate-prerelease rc\",\n\t\"publish-release\": \"eslint-publish-release\"\n};\nvar files$1 = [\n\t\"LICENSE\",\n\t\"README.md\",\n\t\"lib\"\n];\nvar dependencies$2 = {\n\tesrecurse: \"^4.1.0\",\n\testraverse: \"^4.1.1\"\n};\nvar devDependencies$3 = {\n\t\"@typescript-eslint/parser\": \"^1.11.0\",\n\tchai: \"^4.2.0\",\n\teslint: \"^6.0.1\",\n\t\"eslint-config-eslint\": \"^5.0.1\",\n\t\"eslint-plugin-node\": \"^9.1.0\",\n\t\"eslint-release\": \"^1.0.0\",\n\tespree: \"^6.0.0\",\n\tistanbul: \"^0.4.5\",\n\tmocha: \"^6.1.4\",\n\t\"npm-license\": \"^0.3.3\",\n\tshelljs: \"^0.8.3\",\n\ttypescript: \"^3.5.2\"\n};\nvar _package$6 = {\n\tname: name$3,\n\tdescription: description$3,\n\thomepage: homepage$3,\n\tmain: main$3,\n\tversion: version$3,\n\tengines: engines$3,\n\trepository: repository$3,\n\tbugs: bugs$1,\n\tlicense: license$3,\n\tscripts: scripts$3,\n\tfiles: files$1,\n\tdependencies: dependencies$2,\n\tdevDependencies: devDependencies$3\n};\n\nvar _package$7 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  name: name$3,\n  description: description$3,\n  homepage: homepage$3,\n  main: main$3,\n  version: version$3,\n  engines: engines$3,\n  repository: repository$3,\n  bugs: bugs$1,\n  license: license$3,\n  scripts: scripts$3,\n  files: files$1,\n  dependencies: dependencies$2,\n  devDependencies: devDependencies$3,\n  'default': _package$6\n});\n\nvar require$$1$1 = getCjsExportFromNamespace(_package$7);\n\n/* eslint no-underscore-dangle: [\"error\", { \"allow\": [\"__currentScope\"] }] */\n\n\n\n\n\n\n\nconst Scope$1 = scope.Scope;\nconst version$4 = require$$1$1.version;\n\n/**\n * Set the default options\n * @returns {Object} options\n */\nfunction defaultOptions() {\n    return {\n        optimistic: false,\n        directive: false,\n        nodejsScope: false,\n        impliedStrict: false,\n        sourceType: \"script\", // one of ['script', 'module']\n        ecmaVersion: 5,\n        childVisitorKeys: null,\n        fallback: \"iteration\"\n    };\n}\n\n/**\n * Preform deep update on option object\n * @param {Object} target - Options\n * @param {Object} override - Updates\n * @returns {Object} Updated options\n */\nfunction updateDeeply(target, override) {\n\n    /**\n     * Is hash object\n     * @param {Object} value - Test value\n     * @returns {boolean} Result\n     */\n    function isHashObject(value) {\n        return typeof value === \"object\" && value instanceof Object && !(value instanceof Array) && !(value instanceof RegExp);\n    }\n\n    for (const key in override) {\n        if (Object.prototype.hasOwnProperty.call(override, key)) {\n            const val = override[key];\n\n            if (isHashObject(val)) {\n                if (isHashObject(target[key])) {\n                    updateDeeply(target[key], val);\n                } else {\n                    target[key] = updateDeeply({}, val);\n                }\n            } else {\n                target[key] = val;\n            }\n        }\n    }\n    return target;\n}\n\n/**\n * Main interface function. Takes an Espree syntax tree and returns the\n * analyzed scopes.\n * @function analyze\n * @param {espree.Tree} tree - Abstract Syntax Tree\n * @param {Object} providedOptions - Options that tailor the scope analysis\n * @param {boolean} [providedOptions.optimistic=false] - the optimistic flag\n * @param {boolean} [providedOptions.directive=false]- the directive flag\n * @param {boolean} [providedOptions.ignoreEval=false]- whether to check 'eval()' calls\n * @param {boolean} [providedOptions.nodejsScope=false]- whether the whole\n * script is executed under node.js environment. When enabled, escope adds\n * a function scope immediately following the global scope.\n * @param {boolean} [providedOptions.impliedStrict=false]- implied strict mode\n * (if ecmaVersion >= 5).\n * @param {string} [providedOptions.sourceType='script']- the source type of the script. one of 'script' and 'module'\n * @param {number} [providedOptions.ecmaVersion=5]- which ECMAScript version is considered\n * @param {Object} [providedOptions.childVisitorKeys=null] - Additional known visitor keys. See [esrecurse](https://github.com/estools/esrecurse)'s the `childVisitorKeys` option.\n * @param {string} [providedOptions.fallback='iteration'] - A kind of the fallback in order to encounter with unknown node. See [esrecurse](https://github.com/estools/esrecurse)'s the `fallback` option.\n * @returns {ScopeManager} ScopeManager\n */\nfunction analyze(tree, providedOptions) {\n    const options = updateDeeply(defaultOptions(), providedOptions);\n    const scopeManager$1 = new scopeManager(options);\n    const referencer$1 = new referencer(options, scopeManager$1);\n\n    referencer$1.visit(tree);\n\n    assert(scopeManager$1.__currentScope === null, \"currentScope should be null.\");\n\n    return scopeManager$1;\n}\n\nvar lib = {\n\n    /** @name module:escope.version */\n    version: version$4,\n\n    /** @name module:escope.Reference */\n    Reference: reference,\n\n    /** @name module:escope.Variable */\n    Variable: variable,\n\n    /** @name module:escope.Scope */\n    Scope: Scope$1,\n\n    /** @name module:escope.ScopeManager */\n    ScopeManager: scopeManager,\n    analyze\n};\n\nvar AssignmentExpression = [\n\t\"left\",\n\t\"right\"\n];\nvar AssignmentPattern = [\n\t\"left\",\n\t\"right\"\n];\nvar ArrayExpression = [\n\t\"elements\"\n];\nvar ArrayPattern = [\n\t\"elements\"\n];\nvar ArrowFunctionExpression = [\n\t\"params\",\n\t\"body\"\n];\nvar AwaitExpression = [\n\t\"argument\"\n];\nvar BlockStatement = [\n\t\"body\"\n];\nvar BinaryExpression = [\n\t\"left\",\n\t\"right\"\n];\nvar BreakStatement = [\n\t\"label\"\n];\nvar CallExpression = [\n\t\"callee\",\n\t\"arguments\"\n];\nvar CatchClause = [\n\t\"param\",\n\t\"body\"\n];\nvar ClassBody = [\n\t\"body\"\n];\nvar ClassDeclaration = [\n\t\"id\",\n\t\"superClass\",\n\t\"body\"\n];\nvar ClassExpression = [\n\t\"id\",\n\t\"superClass\",\n\t\"body\"\n];\nvar ConditionalExpression = [\n\t\"test\",\n\t\"consequent\",\n\t\"alternate\"\n];\nvar ContinueStatement = [\n\t\"label\"\n];\nvar DebuggerStatement = [\n];\nvar DoWhileStatement = [\n\t\"body\",\n\t\"test\"\n];\nvar EmptyStatement = [\n];\nvar ExportAllDeclaration = [\n\t\"source\"\n];\nvar ExportDefaultDeclaration = [\n\t\"declaration\"\n];\nvar ExportNamedDeclaration = [\n\t\"declaration\",\n\t\"specifiers\",\n\t\"source\"\n];\nvar ExportSpecifier = [\n\t\"exported\",\n\t\"local\"\n];\nvar ExpressionStatement = [\n\t\"expression\"\n];\nvar ExperimentalRestProperty = [\n\t\"argument\"\n];\nvar ExperimentalSpreadProperty = [\n\t\"argument\"\n];\nvar ForStatement = [\n\t\"init\",\n\t\"test\",\n\t\"update\",\n\t\"body\"\n];\nvar ForInStatement = [\n\t\"left\",\n\t\"right\",\n\t\"body\"\n];\nvar ForOfStatement = [\n\t\"left\",\n\t\"right\",\n\t\"body\"\n];\nvar FunctionDeclaration = [\n\t\"id\",\n\t\"params\",\n\t\"body\"\n];\nvar FunctionExpression = [\n\t\"id\",\n\t\"params\",\n\t\"body\"\n];\nvar Identifier = [\n];\nvar IfStatement = [\n\t\"test\",\n\t\"consequent\",\n\t\"alternate\"\n];\nvar ImportDeclaration = [\n\t\"specifiers\",\n\t\"source\"\n];\nvar ImportDefaultSpecifier = [\n\t\"local\"\n];\nvar ImportExpression = [\n\t\"source\"\n];\nvar ImportNamespaceSpecifier = [\n\t\"local\"\n];\nvar ImportSpecifier = [\n\t\"imported\",\n\t\"local\"\n];\nvar JSXAttribute = [\n\t\"name\",\n\t\"value\"\n];\nvar JSXClosingElement = [\n\t\"name\"\n];\nvar JSXElement = [\n\t\"openingElement\",\n\t\"children\",\n\t\"closingElement\"\n];\nvar JSXEmptyExpression = [\n];\nvar JSXExpressionContainer = [\n\t\"expression\"\n];\nvar JSXIdentifier = [\n];\nvar JSXMemberExpression = [\n\t\"object\",\n\t\"property\"\n];\nvar JSXNamespacedName = [\n\t\"namespace\",\n\t\"name\"\n];\nvar JSXOpeningElement = [\n\t\"name\",\n\t\"attributes\"\n];\nvar JSXSpreadAttribute = [\n\t\"argument\"\n];\nvar JSXText = [\n];\nvar JSXFragment = [\n\t\"openingFragment\",\n\t\"children\",\n\t\"closingFragment\"\n];\nvar Literal = [\n];\nvar LabeledStatement = [\n\t\"label\",\n\t\"body\"\n];\nvar LogicalExpression = [\n\t\"left\",\n\t\"right\"\n];\nvar MemberExpression = [\n\t\"object\",\n\t\"property\"\n];\nvar MetaProperty = [\n\t\"meta\",\n\t\"property\"\n];\nvar MethodDefinition = [\n\t\"key\",\n\t\"value\"\n];\nvar NewExpression = [\n\t\"callee\",\n\t\"arguments\"\n];\nvar ObjectExpression = [\n\t\"properties\"\n];\nvar ObjectPattern = [\n\t\"properties\"\n];\nvar Program = [\n\t\"body\"\n];\nvar Property = [\n\t\"key\",\n\t\"value\"\n];\nvar RestElement = [\n\t\"argument\"\n];\nvar ReturnStatement = [\n\t\"argument\"\n];\nvar SequenceExpression = [\n\t\"expressions\"\n];\nvar SpreadElement = [\n\t\"argument\"\n];\nvar Super = [\n];\nvar SwitchStatement = [\n\t\"discriminant\",\n\t\"cases\"\n];\nvar SwitchCase = [\n\t\"test\",\n\t\"consequent\"\n];\nvar TaggedTemplateExpression = [\n\t\"tag\",\n\t\"quasi\"\n];\nvar TemplateElement = [\n];\nvar TemplateLiteral = [\n\t\"quasis\",\n\t\"expressions\"\n];\nvar ThisExpression = [\n];\nvar ThrowStatement = [\n\t\"argument\"\n];\nvar TryStatement = [\n\t\"block\",\n\t\"handler\",\n\t\"finalizer\"\n];\nvar UnaryExpression = [\n\t\"argument\"\n];\nvar UpdateExpression = [\n\t\"argument\"\n];\nvar VariableDeclaration = [\n\t\"declarations\"\n];\nvar VariableDeclarator = [\n\t\"id\",\n\t\"init\"\n];\nvar WhileStatement = [\n\t\"test\",\n\t\"body\"\n];\nvar WithStatement = [\n\t\"object\",\n\t\"body\"\n];\nvar YieldExpression = [\n\t\"argument\"\n];\nvar visitorKeys = {\n\tAssignmentExpression: AssignmentExpression,\n\tAssignmentPattern: AssignmentPattern,\n\tArrayExpression: ArrayExpression,\n\tArrayPattern: ArrayPattern,\n\tArrowFunctionExpression: ArrowFunctionExpression,\n\tAwaitExpression: AwaitExpression,\n\tBlockStatement: BlockStatement,\n\tBinaryExpression: BinaryExpression,\n\tBreakStatement: BreakStatement,\n\tCallExpression: CallExpression,\n\tCatchClause: CatchClause,\n\tClassBody: ClassBody,\n\tClassDeclaration: ClassDeclaration,\n\tClassExpression: ClassExpression,\n\tConditionalExpression: ConditionalExpression,\n\tContinueStatement: ContinueStatement,\n\tDebuggerStatement: DebuggerStatement,\n\tDoWhileStatement: DoWhileStatement,\n\tEmptyStatement: EmptyStatement,\n\tExportAllDeclaration: ExportAllDeclaration,\n\tExportDefaultDeclaration: ExportDefaultDeclaration,\n\tExportNamedDeclaration: ExportNamedDeclaration,\n\tExportSpecifier: ExportSpecifier,\n\tExpressionStatement: ExpressionStatement,\n\tExperimentalRestProperty: ExperimentalRestProperty,\n\tExperimentalSpreadProperty: ExperimentalSpreadProperty,\n\tForStatement: ForStatement,\n\tForInStatement: ForInStatement,\n\tForOfStatement: ForOfStatement,\n\tFunctionDeclaration: FunctionDeclaration,\n\tFunctionExpression: FunctionExpression,\n\tIdentifier: Identifier,\n\tIfStatement: IfStatement,\n\tImportDeclaration: ImportDeclaration,\n\tImportDefaultSpecifier: ImportDefaultSpecifier,\n\tImportExpression: ImportExpression,\n\tImportNamespaceSpecifier: ImportNamespaceSpecifier,\n\tImportSpecifier: ImportSpecifier,\n\tJSXAttribute: JSXAttribute,\n\tJSXClosingElement: JSXClosingElement,\n\tJSXElement: JSXElement,\n\tJSXEmptyExpression: JSXEmptyExpression,\n\tJSXExpressionContainer: JSXExpressionContainer,\n\tJSXIdentifier: JSXIdentifier,\n\tJSXMemberExpression: JSXMemberExpression,\n\tJSXNamespacedName: JSXNamespacedName,\n\tJSXOpeningElement: JSXOpeningElement,\n\tJSXSpreadAttribute: JSXSpreadAttribute,\n\tJSXText: JSXText,\n\tJSXFragment: JSXFragment,\n\tLiteral: Literal,\n\tLabeledStatement: LabeledStatement,\n\tLogicalExpression: LogicalExpression,\n\tMemberExpression: MemberExpression,\n\tMetaProperty: MetaProperty,\n\tMethodDefinition: MethodDefinition,\n\tNewExpression: NewExpression,\n\tObjectExpression: ObjectExpression,\n\tObjectPattern: ObjectPattern,\n\tProgram: Program,\n\tProperty: Property,\n\tRestElement: RestElement,\n\tReturnStatement: ReturnStatement,\n\tSequenceExpression: SequenceExpression,\n\tSpreadElement: SpreadElement,\n\tSuper: Super,\n\tSwitchStatement: SwitchStatement,\n\tSwitchCase: SwitchCase,\n\tTaggedTemplateExpression: TaggedTemplateExpression,\n\tTemplateElement: TemplateElement,\n\tTemplateLiteral: TemplateLiteral,\n\tThisExpression: ThisExpression,\n\tThrowStatement: ThrowStatement,\n\tTryStatement: TryStatement,\n\tUnaryExpression: UnaryExpression,\n\tUpdateExpression: UpdateExpression,\n\tVariableDeclaration: VariableDeclaration,\n\tVariableDeclarator: VariableDeclarator,\n\tWhileStatement: WhileStatement,\n\tWithStatement: WithStatement,\n\tYieldExpression: YieldExpression\n};\n\nvar visitorKeys$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  AssignmentExpression: AssignmentExpression,\n  AssignmentPattern: AssignmentPattern,\n  ArrayExpression: ArrayExpression,\n  ArrayPattern: ArrayPattern,\n  ArrowFunctionExpression: ArrowFunctionExpression,\n  AwaitExpression: AwaitExpression,\n  BlockStatement: BlockStatement,\n  BinaryExpression: BinaryExpression,\n  BreakStatement: BreakStatement,\n  CallExpression: CallExpression,\n  CatchClause: CatchClause,\n  ClassBody: ClassBody,\n  ClassDeclaration: ClassDeclaration,\n  ClassExpression: ClassExpression,\n  ConditionalExpression: ConditionalExpression,\n  ContinueStatement: ContinueStatement,\n  DebuggerStatement: DebuggerStatement,\n  DoWhileStatement: DoWhileStatement,\n  EmptyStatement: EmptyStatement,\n  ExportAllDeclaration: ExportAllDeclaration,\n  ExportDefaultDeclaration: ExportDefaultDeclaration,\n  ExportNamedDeclaration: ExportNamedDeclaration,\n  ExportSpecifier: ExportSpecifier,\n  ExpressionStatement: ExpressionStatement,\n  ExperimentalRestProperty: ExperimentalRestProperty,\n  ExperimentalSpreadProperty: ExperimentalSpreadProperty,\n  ForStatement: ForStatement,\n  ForInStatement: ForInStatement,\n  ForOfStatement: ForOfStatement,\n  FunctionDeclaration: FunctionDeclaration,\n  FunctionExpression: FunctionExpression,\n  Identifier: Identifier,\n  IfStatement: IfStatement,\n  ImportDeclaration: ImportDeclaration,\n  ImportDefaultSpecifier: ImportDefaultSpecifier,\n  ImportExpression: ImportExpression,\n  ImportNamespaceSpecifier: ImportNamespaceSpecifier,\n  ImportSpecifier: ImportSpecifier,\n  JSXAttribute: JSXAttribute,\n  JSXClosingElement: JSXClosingElement,\n  JSXElement: JSXElement,\n  JSXEmptyExpression: JSXEmptyExpression,\n  JSXExpressionContainer: JSXExpressionContainer,\n  JSXIdentifier: JSXIdentifier,\n  JSXMemberExpression: JSXMemberExpression,\n  JSXNamespacedName: JSXNamespacedName,\n  JSXOpeningElement: JSXOpeningElement,\n  JSXSpreadAttribute: JSXSpreadAttribute,\n  JSXText: JSXText,\n  JSXFragment: JSXFragment,\n  Literal: Literal,\n  LabeledStatement: LabeledStatement,\n  LogicalExpression: LogicalExpression,\n  MemberExpression: MemberExpression,\n  MetaProperty: MetaProperty,\n  MethodDefinition: MethodDefinition,\n  NewExpression: NewExpression,\n  ObjectExpression: ObjectExpression,\n  ObjectPattern: ObjectPattern,\n  Program: Program,\n  Property: Property,\n  RestElement: RestElement,\n  ReturnStatement: ReturnStatement,\n  SequenceExpression: SequenceExpression,\n  SpreadElement: SpreadElement,\n  Super: Super,\n  SwitchStatement: SwitchStatement,\n  SwitchCase: SwitchCase,\n  TaggedTemplateExpression: TaggedTemplateExpression,\n  TemplateElement: TemplateElement,\n  TemplateLiteral: TemplateLiteral,\n  ThisExpression: ThisExpression,\n  ThrowStatement: ThrowStatement,\n  TryStatement: TryStatement,\n  UnaryExpression: UnaryExpression,\n  UpdateExpression: UpdateExpression,\n  VariableDeclaration: VariableDeclaration,\n  VariableDeclarator: VariableDeclarator,\n  WhileStatement: WhileStatement,\n  WithStatement: WithStatement,\n  YieldExpression: YieldExpression,\n  'default': visitorKeys\n});\n\nvar KEYS = getCjsExportFromNamespace(visitorKeys$1);\n\n// Types.\nconst NODE_TYPES = Object.freeze(Object.keys(KEYS));\n\n// Freeze the keys.\nfor (const type of NODE_TYPES) {\n    Object.freeze(KEYS[type]);\n}\nObject.freeze(KEYS);\n\n// List to ignore keys.\nconst KEY_BLACKLIST = new Set([\n    \"parent\",\n    \"leadingComments\",\n    \"trailingComments\"\n]);\n\n/**\n * Check whether a given key should be used or not.\n * @param {string} key The key to check.\n * @returns {boolean} `true` if the key should be used.\n */\nfunction filterKey(key) {\n    return !KEY_BLACKLIST.has(key) && key[0] !== \"_\";\n}\n\n//------------------------------------------------------------------------------\n// Public interfaces\n//------------------------------------------------------------------------------\n\nvar lib$1 = Object.freeze({\n\n    /**\n     * Visitor keys.\n     * @type {{ [type: string]: string[] | undefined }}\n     */\n    KEYS,\n\n    /**\n     * Get visitor keys of a given node.\n     * @param {Object} node The AST node to get keys.\n     * @returns {string[]} Visitor keys of the node.\n     */\n    getKeys(node) {\n        return Object.keys(node).filter(filterKey);\n    },\n\n    // Disable valid-jsdoc rule because it reports syntax error on the type of @returns.\n    // eslint-disable-next-line valid-jsdoc\n    /**\n     * Make the union set with `KEYS` and given keys.\n     * @param {Object} additionalKeys The additional keys.\n     * @returns {{ [type: string]: string[] | undefined }} The union set.\n     */\n    unionWith(additionalKeys) {\n        const retv = Object.assign({}, KEYS);\n\n        for (const type of Object.keys(additionalKeys)) {\n            if (retv.hasOwnProperty(type)) {\n                const keys = new Set(additionalKeys[type]);\n\n                for (const key of retv[type]) {\n                    keys.add(key);\n                }\n\n                retv[type] = Object.freeze(Array.from(keys));\n            } else {\n                retv[type] = Object.freeze(Array.from(additionalKeys[type]));\n            }\n        }\n\n        return Object.freeze(retv);\n    }\n});\n\n// Reserved word lists for various dialects of the language\n\nvar reservedWords = {\n  3: \"abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile\",\n  5: \"class enum extends super const export import\",\n  6: \"enum\",\n  strict: \"implements interface let package private protected public static yield\",\n  strictBind: \"eval arguments\"\n};\n\n// And the keywords\n\nvar ecma5AndLessKeywords = \"break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this\";\n\nvar keywords$1 = {\n  5: ecma5AndLessKeywords,\n  \"5module\": ecma5AndLessKeywords + \" export import\",\n  6: ecma5AndLessKeywords + \" const class extends export import super\"\n};\n\nvar keywordRelationalOperator = /^in(stanceof)?$/;\n\n// ## Character categories\n\n// Big ugly regular expressions that match characters in the\n// whitespace, identifier, and identifier-start categories. These\n// are only applied when a character is found to actually have a\n// code point above 128.\n// Generated by `bin/generate-identifier-regex.js`.\nvar nonASCIIidentifierStartChars = \"\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u037f\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u052f\\u0531-\\u0556\\u0559\\u0560-\\u0588\\u05d0-\\u05ea\\u05ef-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u0860-\\u086a\\u08a0-\\u08b4\\u08b6-\\u08c7\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u09fc\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0af9\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c39\\u0c3d\\u0c58-\\u0c5a\\u0c60\\u0c61\\u0c80\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d04-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d54-\\u0d56\\u0d5f-\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e86-\\u0e8a\\u0e8c-\\u0ea3\\u0ea5\\u0ea7-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f5\\u13f8-\\u13fd\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f8\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1878\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191e\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19b0-\\u19c9\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1c80-\\u1c88\\u1c90-\\u1cba\\u1cbd-\\u1cbf\\u1ce9-\\u1cec\\u1cee-\\u1cf3\\u1cf5\\u1cf6\\u1cfa\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2118-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309b-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312f\\u3131-\\u318e\\u31a0-\\u31bf\\u31f0-\\u31ff\\u3400-\\u4dbf\\u4e00-\\u9ffc\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua69d\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua7bf\\ua7c2-\\ua7ca\\ua7f5-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua8fd\\ua8fe\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\ua9e0-\\ua9e4\\ua9e6-\\ua9ef\\ua9fa-\\ua9fe\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa7e-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uab30-\\uab5a\\uab5c-\\uab69\\uab70-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc\";\nvar nonASCIIidentifierChars = \"\\u200c\\u200d\\xb7\\u0300-\\u036f\\u0387\\u0483-\\u0487\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u064b-\\u0669\\u0670\\u06d6-\\u06dc\\u06df-\\u06e4\\u06e7\\u06e8\\u06ea-\\u06ed\\u06f0-\\u06f9\\u0711\\u0730-\\u074a\\u07a6-\\u07b0\\u07c0-\\u07c9\\u07eb-\\u07f3\\u07fd\\u0816-\\u0819\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0859-\\u085b\\u08d3-\\u08e1\\u08e3-\\u0903\\u093a-\\u093c\\u093e-\\u094f\\u0951-\\u0957\\u0962\\u0963\\u0966-\\u096f\\u0981-\\u0983\\u09bc\\u09be-\\u09c4\\u09c7\\u09c8\\u09cb-\\u09cd\\u09d7\\u09e2\\u09e3\\u09e6-\\u09ef\\u09fe\\u0a01-\\u0a03\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a66-\\u0a71\\u0a75\\u0a81-\\u0a83\\u0abc\\u0abe-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ae2\\u0ae3\\u0ae6-\\u0aef\\u0afa-\\u0aff\\u0b01-\\u0b03\\u0b3c\\u0b3e-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b55-\\u0b57\\u0b62\\u0b63\\u0b66-\\u0b6f\\u0b82\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd7\\u0be6-\\u0bef\\u0c00-\\u0c04\\u0c3e-\\u0c44\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62\\u0c63\\u0c66-\\u0c6f\\u0c81-\\u0c83\\u0cbc\\u0cbe-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0ce2\\u0ce3\\u0ce6-\\u0cef\\u0d00-\\u0d03\\u0d3b\\u0d3c\\u0d3e-\\u0d44\\u0d46-\\u0d48\\u0d4a-\\u0d4d\\u0d57\\u0d62\\u0d63\\u0d66-\\u0d6f\\u0d81-\\u0d83\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0de6-\\u0def\\u0df2\\u0df3\\u0e31\\u0e34-\\u0e3a\\u0e47-\\u0e4e\\u0e50-\\u0e59\\u0eb1\\u0eb4-\\u0ebc\\u0ec8-\\u0ecd\\u0ed0-\\u0ed9\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f3e\\u0f3f\\u0f71-\\u0f84\\u0f86\\u0f87\\u0f8d-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u102b-\\u103e\\u1040-\\u1049\\u1056-\\u1059\\u105e-\\u1060\\u1062-\\u1064\\u1067-\\u106d\\u1071-\\u1074\\u1082-\\u108d\\u108f-\\u109d\\u135d-\\u135f\\u1369-\\u1371\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17b4-\\u17d3\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u1810-\\u1819\\u18a9\\u1920-\\u192b\\u1930-\\u193b\\u1946-\\u194f\\u19d0-\\u19da\\u1a17-\\u1a1b\\u1a55-\\u1a5e\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1ab0-\\u1abd\\u1abf\\u1ac0\\u1b00-\\u1b04\\u1b34-\\u1b44\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1b80-\\u1b82\\u1ba1-\\u1bad\\u1bb0-\\u1bb9\\u1be6-\\u1bf3\\u1c24-\\u1c37\\u1c40-\\u1c49\\u1c50-\\u1c59\\u1cd0-\\u1cd2\\u1cd4-\\u1ce8\\u1ced\\u1cf4\\u1cf7-\\u1cf9\\u1dc0-\\u1df9\\u1dfb-\\u1dff\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2cef-\\u2cf1\\u2d7f\\u2de0-\\u2dff\\u302a-\\u302f\\u3099\\u309a\\ua620-\\ua629\\ua66f\\ua674-\\ua67d\\ua69e\\ua69f\\ua6f0\\ua6f1\\ua802\\ua806\\ua80b\\ua823-\\ua827\\ua82c\\ua880\\ua881\\ua8b4-\\ua8c5\\ua8d0-\\ua8d9\\ua8e0-\\ua8f1\\ua8ff-\\ua909\\ua926-\\ua92d\\ua947-\\ua953\\ua980-\\ua983\\ua9b3-\\ua9c0\\ua9d0-\\ua9d9\\ua9e5\\ua9f0-\\ua9f9\\uaa29-\\uaa36\\uaa43\\uaa4c\\uaa4d\\uaa50-\\uaa59\\uaa7b-\\uaa7d\\uaab0\\uaab2-\\uaab4\\uaab7\\uaab8\\uaabe\\uaabf\\uaac1\\uaaeb-\\uaaef\\uaaf5\\uaaf6\\uabe3-\\uabea\\uabec\\uabed\\uabf0-\\uabf9\\ufb1e\\ufe00-\\ufe0f\\ufe20-\\ufe2f\\ufe33\\ufe34\\ufe4d-\\ufe4f\\uff10-\\uff19\\uff3f\";\n\nvar nonASCIIidentifierStart = new RegExp(\"[\" + nonASCIIidentifierStartChars + \"]\");\nvar nonASCIIidentifier = new RegExp(\"[\" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + \"]\");\n\nnonASCIIidentifierStartChars = nonASCIIidentifierChars = null;\n\n// These are a run-length and offset encoded representation of the\n// >0xffff code points that are a valid part of identifiers. The\n// offset starts at 0x10000, and each pair of numbers represents an\n// offset to the next range, and then a size of the range. They were\n// generated by bin/generate-identifier-regex.js\n\n// eslint-disable-next-line comma-spacing\nvar astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,14,29,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,349,41,7,1,79,28,11,0,9,21,107,20,28,22,13,52,76,44,33,24,27,35,30,0,3,0,9,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,21,2,31,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,14,0,72,26,230,43,117,63,32,7,3,0,3,7,2,1,2,23,16,0,2,0,95,7,3,38,17,0,2,0,29,0,11,39,8,0,22,0,12,45,20,0,35,56,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,190,0,80,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,689,63,129,74,6,0,67,12,65,1,2,0,29,6135,9,1237,43,8,8952,286,50,2,18,3,9,395,2309,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,2357,44,11,6,17,0,370,43,1301,196,60,67,8,0,1205,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42717,35,4148,12,221,3,5761,15,7472,3104,541,1507,4938];\n\n// eslint-disable-next-line comma-spacing\nvar astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,574,3,9,9,370,1,154,10,176,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,2,11,83,11,7,0,161,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,71,5,2,1,3,3,2,0,2,1,13,9,120,6,3,6,4,0,29,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,19306,9,135,4,60,6,26,9,1014,0,2,54,8,3,82,0,12,1,19628,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,262,6,10,9,419,13,1495,6,110,6,6,9,4759,9,787719,239];\n\n// This has a complexity linear to the value of the code. The\n// assumption is that looking up astral identifier characters is\n// rare.\nfunction isInAstralSet(code, set) {\n  var pos = 0x10000;\n  for (var i = 0; i < set.length; i += 2) {\n    pos += set[i];\n    if (pos > code) { return false }\n    pos += set[i + 1];\n    if (pos >= code) { return true }\n  }\n}\n\n// Test whether a given character code starts an identifier.\n\nfunction isIdentifierStart(code, astral) {\n  if (code < 65) { return code === 36 }\n  if (code < 91) { return true }\n  if (code < 97) { return code === 95 }\n  if (code < 123) { return true }\n  if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)) }\n  if (astral === false) { return false }\n  return isInAstralSet(code, astralIdentifierStartCodes)\n}\n\n// Test whether a given character is part of an identifier.\n\nfunction isIdentifierChar(code, astral) {\n  if (code < 48) { return code === 36 }\n  if (code < 58) { return true }\n  if (code < 65) { return false }\n  if (code < 91) { return true }\n  if (code < 97) { return code === 95 }\n  if (code < 123) { return true }\n  if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)) }\n  if (astral === false) { return false }\n  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes)\n}\n\n// ## Token types\n\n// The assignment of fine-grained, information-carrying type objects\n// allows the tokenizer to store the information it has about a\n// token in a way that is very cheap for the parser to look up.\n\n// All token type variables start with an underscore, to make them\n// easy to recognize.\n\n// The `beforeExpr` property is used to disambiguate between regular\n// expressions and divisions. It is set on all token types that can\n// be followed by an expression (thus, a slash after them would be a\n// regular expression).\n//\n// The `startsExpr` property is used to check if the token ends a\n// `yield` expression. It is set on all token types that either can\n// directly start an expression (like a quotation mark) or can\n// continue an expression (like the body of a string).\n//\n// `isLoop` marks a keyword as starting a loop, which is important\n// to know when parsing a label, in order to allow or disallow\n// continue jumps to that label.\n\nvar TokenType = function TokenType(label, conf) {\n  if ( conf === void 0 ) conf = {};\n\n  this.label = label;\n  this.keyword = conf.keyword;\n  this.beforeExpr = !!conf.beforeExpr;\n  this.startsExpr = !!conf.startsExpr;\n  this.isLoop = !!conf.isLoop;\n  this.isAssign = !!conf.isAssign;\n  this.prefix = !!conf.prefix;\n  this.postfix = !!conf.postfix;\n  this.binop = conf.binop || null;\n  this.updateContext = null;\n};\n\nfunction binop(name, prec) {\n  return new TokenType(name, {beforeExpr: true, binop: prec})\n}\nvar beforeExpr = {beforeExpr: true}, startsExpr = {startsExpr: true};\n\n// Map keyword names to token types.\n\nvar keywords$1$1 = {};\n\n// Succinct definitions of keyword token types\nfunction kw(name, options) {\n  if ( options === void 0 ) options = {};\n\n  options.keyword = name;\n  return keywords$1$1[name] = new TokenType(name, options)\n}\n\nvar types = {\n  num: new TokenType(\"num\", startsExpr),\n  regexp: new TokenType(\"regexp\", startsExpr),\n  string: new TokenType(\"string\", startsExpr),\n  name: new TokenType(\"name\", startsExpr),\n  eof: new TokenType(\"eof\"),\n\n  // Punctuation token types.\n  bracketL: new TokenType(\"[\", {beforeExpr: true, startsExpr: true}),\n  bracketR: new TokenType(\"]\"),\n  braceL: new TokenType(\"{\", {beforeExpr: true, startsExpr: true}),\n  braceR: new TokenType(\"}\"),\n  parenL: new TokenType(\"(\", {beforeExpr: true, startsExpr: true}),\n  parenR: new TokenType(\")\"),\n  comma: new TokenType(\",\", beforeExpr),\n  semi: new TokenType(\";\", beforeExpr),\n  colon: new TokenType(\":\", beforeExpr),\n  dot: new TokenType(\".\"),\n  question: new TokenType(\"?\", beforeExpr),\n  arrow: new TokenType(\"=>\", beforeExpr),\n  template: new TokenType(\"template\"),\n  invalidTemplate: new TokenType(\"invalidTemplate\"),\n  ellipsis: new TokenType(\"...\", beforeExpr),\n  backQuote: new TokenType(\"`\", startsExpr),\n  dollarBraceL: new TokenType(\"${\", {beforeExpr: true, startsExpr: true}),\n\n  // Operators. These carry several kinds of properties to help the\n  // parser use them properly (the presence of these properties is\n  // what categorizes them as operators).\n  //\n  // `binop`, when present, specifies that this operator is a binary\n  // operator, and will refer to its precedence.\n  //\n  // `prefix` and `postfix` mark the operator as a prefix or postfix\n  // unary operator.\n  //\n  // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as\n  // binary operators with a very low precedence, that should result\n  // in AssignmentExpression nodes.\n\n  eq: new TokenType(\"=\", {beforeExpr: true, isAssign: true}),\n  assign: new TokenType(\"_=\", {beforeExpr: true, isAssign: true}),\n  incDec: new TokenType(\"++/--\", {prefix: true, postfix: true, startsExpr: true}),\n  prefix: new TokenType(\"!/~\", {beforeExpr: true, prefix: true, startsExpr: true}),\n  logicalOR: binop(\"||\", 1),\n  logicalAND: binop(\"&&\", 2),\n  bitwiseOR: binop(\"|\", 3),\n  bitwiseXOR: binop(\"^\", 4),\n  bitwiseAND: binop(\"&\", 5),\n  equality: binop(\"==/!=/===/!==\", 6),\n  relational: binop(\"</>/<=/>=\", 7),\n  bitShift: binop(\"<</>>/>>>\", 8),\n  plusMin: new TokenType(\"+/-\", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),\n  modulo: binop(\"%\", 10),\n  star: binop(\"*\", 10),\n  slash: binop(\"/\", 10),\n  starstar: new TokenType(\"**\", {beforeExpr: true}),\n  coalesce: binop(\"??\", 1),\n\n  // Keyword token types.\n  _break: kw(\"break\"),\n  _case: kw(\"case\", beforeExpr),\n  _catch: kw(\"catch\"),\n  _continue: kw(\"continue\"),\n  _debugger: kw(\"debugger\"),\n  _default: kw(\"default\", beforeExpr),\n  _do: kw(\"do\", {isLoop: true, beforeExpr: true}),\n  _else: kw(\"else\", beforeExpr),\n  _finally: kw(\"finally\"),\n  _for: kw(\"for\", {isLoop: true}),\n  _function: kw(\"function\", startsExpr),\n  _if: kw(\"if\"),\n  _return: kw(\"return\", beforeExpr),\n  _switch: kw(\"switch\"),\n  _throw: kw(\"throw\", beforeExpr),\n  _try: kw(\"try\"),\n  _var: kw(\"var\"),\n  _const: kw(\"const\"),\n  _while: kw(\"while\", {isLoop: true}),\n  _with: kw(\"with\"),\n  _new: kw(\"new\", {beforeExpr: true, startsExpr: true}),\n  _this: kw(\"this\", startsExpr),\n  _super: kw(\"super\", startsExpr),\n  _class: kw(\"class\", startsExpr),\n  _extends: kw(\"extends\", beforeExpr),\n  _export: kw(\"export\"),\n  _import: kw(\"import\", startsExpr),\n  _null: kw(\"null\", startsExpr),\n  _true: kw(\"true\", startsExpr),\n  _false: kw(\"false\", startsExpr),\n  _in: kw(\"in\", {beforeExpr: true, binop: 7}),\n  _instanceof: kw(\"instanceof\", {beforeExpr: true, binop: 7}),\n  _typeof: kw(\"typeof\", {beforeExpr: true, prefix: true, startsExpr: true}),\n  _void: kw(\"void\", {beforeExpr: true, prefix: true, startsExpr: true}),\n  _delete: kw(\"delete\", {beforeExpr: true, prefix: true, startsExpr: true})\n};\n\n// Matches a whole line break (where CRLF is considered a single\n// line break). Used to count lines.\n\nvar lineBreak = /\\r\\n?|\\n|\\u2028|\\u2029/;\nvar lineBreakG = new RegExp(lineBreak.source, \"g\");\n\nfunction isNewLine(code, ecma2019String) {\n  return code === 10 || code === 13 || (!ecma2019String && (code === 0x2028 || code === 0x2029))\n}\n\nvar nonASCIIwhitespace = /[\\u1680\\u2000-\\u200a\\u202f\\u205f\\u3000\\ufeff]/;\n\nvar skipWhiteSpace = /(?:\\s|\\/\\/.*|\\/\\*[^]*?\\*\\/)*/g;\n\nvar ref = Object.prototype;\nvar hasOwnProperty = ref.hasOwnProperty;\nvar toString = ref.toString;\n\n// Checks if an object has a property.\n\nfunction has(obj, propName) {\n  return hasOwnProperty.call(obj, propName)\n}\n\nvar isArray = Array.isArray || (function (obj) { return (\n  toString.call(obj) === \"[object Array]\"\n); });\n\nfunction wordsRegexp(words) {\n  return new RegExp(\"^(?:\" + words.replace(/ /g, \"|\") + \")$\")\n}\n\n// These are used when `options.locations` is on, for the\n// `startLoc` and `endLoc` properties.\n\nvar Position = function Position(line, col) {\n  this.line = line;\n  this.column = col;\n};\n\nPosition.prototype.offset = function offset (n) {\n  return new Position(this.line, this.column + n)\n};\n\nvar SourceLocation = function SourceLocation(p, start, end) {\n  this.start = start;\n  this.end = end;\n  if (p.sourceFile !== null) { this.source = p.sourceFile; }\n};\n\n// The `getLineInfo` function is mostly useful when the\n// `locations` option is off (for performance reasons) and you\n// want to find the line/column position for a given character\n// offset. `input` should be the code string that the offset refers\n// into.\n\nfunction getLineInfo(input, offset) {\n  for (var line = 1, cur = 0;;) {\n    lineBreakG.lastIndex = cur;\n    var match = lineBreakG.exec(input);\n    if (match && match.index < offset) {\n      ++line;\n      cur = match.index + match[0].length;\n    } else {\n      return new Position(line, offset - cur)\n    }\n  }\n}\n\n// A second optional argument can be given to further configure\n// the parser process. These options are recognized:\n\nvar defaultOptions$1 = {\n  // `ecmaVersion` indicates the ECMAScript version to parse. Must be\n  // either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018), or 10\n  // (2019). This influences support for strict mode, the set of\n  // reserved words, and support for new syntax features. The default\n  // is 10.\n  ecmaVersion: 10,\n  // `sourceType` indicates the mode the code should be parsed in.\n  // Can be either `\"script\"` or `\"module\"`. This influences global\n  // strict mode and parsing of `import` and `export` declarations.\n  sourceType: \"script\",\n  // `onInsertedSemicolon` can be a callback that will be called\n  // when a semicolon is automatically inserted. It will be passed\n  // the position of the comma as an offset, and if `locations` is\n  // enabled, it is given the location as a `{line, column}` object\n  // as second argument.\n  onInsertedSemicolon: null,\n  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for\n  // trailing commas.\n  onTrailingComma: null,\n  // By default, reserved words are only enforced if ecmaVersion >= 5.\n  // Set `allowReserved` to a boolean value to explicitly turn this on\n  // an off. When this option has the value \"never\", reserved words\n  // and keywords can also not be used as property names.\n  allowReserved: null,\n  // When enabled, a return at the top level is not considered an\n  // error.\n  allowReturnOutsideFunction: false,\n  // When enabled, import/export statements are not constrained to\n  // appearing at the top of the program.\n  allowImportExportEverywhere: false,\n  // When enabled, await identifiers are allowed to appear at the top-level scope,\n  // but they are still not allowed in non-async functions.\n  allowAwaitOutsideFunction: false,\n  // When enabled, hashbang directive in the beginning of file\n  // is allowed and treated as a line comment.\n  allowHashBang: false,\n  // When `locations` is on, `loc` properties holding objects with\n  // `start` and `end` properties in `{line, column}` form (with\n  // line being 1-based and column 0-based) will be attached to the\n  // nodes.\n  locations: false,\n  // A function can be passed as `onToken` option, which will\n  // cause Acorn to call that function with object in the same\n  // format as tokens returned from `tokenizer().getToken()`. Note\n  // that you are not allowed to call the parser from the\n  // callback—that will corrupt its internal state.\n  onToken: null,\n  // A function can be passed as `onComment` option, which will\n  // cause Acorn to call that function with `(block, text, start,\n  // end)` parameters whenever a comment is skipped. `block` is a\n  // boolean indicating whether this is a block (`/* */`) comment,\n  // `text` is the content of the comment, and `start` and `end` are\n  // character offsets that denote the start and end of the comment.\n  // When the `locations` option is on, two more parameters are\n  // passed, the full `{line, column}` locations of the start and\n  // end of the comments. Note that you are not allowed to call the\n  // parser from the callback—that will corrupt its internal state.\n  onComment: null,\n  // Nodes have their start and end characters offsets recorded in\n  // `start` and `end` properties (directly on the node, rather than\n  // the `loc` object, which holds line/column data. To also add a\n  // [semi-standardized][range] `range` property holding a `[start,\n  // end]` array with the same numbers, set the `ranges` option to\n  // `true`.\n  //\n  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678\n  ranges: false,\n  // It is possible to parse multiple files into a single AST by\n  // passing the tree produced by parsing the first file as\n  // `program` option in subsequent parses. This will add the\n  // toplevel forms of the parsed file to the `Program` (top) node\n  // of an existing parse tree.\n  program: null,\n  // When `locations` is on, you can pass this to record the source\n  // file in every node's `loc` object.\n  sourceFile: null,\n  // This value, if given, is stored in every node, whether\n  // `locations` is on or off.\n  directSourceFile: null,\n  // When enabled, parenthesized expressions are represented by\n  // (non-standard) ParenthesizedExpression nodes\n  preserveParens: false\n};\n\n// Interpret and default an options object\n\nfunction getOptions(opts) {\n  var options = {};\n\n  for (var opt in defaultOptions$1)\n    { options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions$1[opt]; }\n\n  if (options.ecmaVersion >= 2015)\n    { options.ecmaVersion -= 2009; }\n\n  if (options.allowReserved == null)\n    { options.allowReserved = options.ecmaVersion < 5; }\n\n  if (isArray(options.onToken)) {\n    var tokens = options.onToken;\n    options.onToken = function (token) { return tokens.push(token); };\n  }\n  if (isArray(options.onComment))\n    { options.onComment = pushComment(options, options.onComment); }\n\n  return options\n}\n\nfunction pushComment(options, array) {\n  return function(block, text, start, end, startLoc, endLoc) {\n    var comment = {\n      type: block ? \"Block\" : \"Line\",\n      value: text,\n      start: start,\n      end: end\n    };\n    if (options.locations)\n      { comment.loc = new SourceLocation(this, startLoc, endLoc); }\n    if (options.ranges)\n      { comment.range = [start, end]; }\n    array.push(comment);\n  }\n}\n\n// Each scope gets a bitset that may contain these flags\nvar\n    SCOPE_TOP = 1,\n    SCOPE_FUNCTION = 2,\n    SCOPE_VAR = SCOPE_TOP | SCOPE_FUNCTION,\n    SCOPE_ASYNC = 4,\n    SCOPE_GENERATOR = 8,\n    SCOPE_ARROW = 16,\n    SCOPE_SIMPLE_CATCH = 32,\n    SCOPE_SUPER = 64,\n    SCOPE_DIRECT_SUPER = 128;\n\nfunction functionFlags(async, generator) {\n  return SCOPE_FUNCTION | (async ? SCOPE_ASYNC : 0) | (generator ? SCOPE_GENERATOR : 0)\n}\n\n// Used in checkLVal and declareName to determine the type of a binding\nvar\n    BIND_NONE = 0, // Not a binding\n    BIND_VAR = 1, // Var-style binding\n    BIND_LEXICAL = 2, // Let- or const-style binding\n    BIND_FUNCTION = 3, // Function declaration\n    BIND_SIMPLE_CATCH = 4, // Simple (identifier pattern) catch binding\n    BIND_OUTSIDE = 5; // Special case for function names as bound inside the function\n\nvar Parser = function Parser(options, input, startPos) {\n  this.options = options = getOptions(options);\n  this.sourceFile = options.sourceFile;\n  this.keywords = wordsRegexp(keywords$1[options.ecmaVersion >= 6 ? 6 : options.sourceType === \"module\" ? \"5module\" : 5]);\n  var reserved = \"\";\n  if (options.allowReserved !== true) {\n    for (var v = options.ecmaVersion;; v--)\n      { if (reserved = reservedWords[v]) { break } }\n    if (options.sourceType === \"module\") { reserved += \" await\"; }\n  }\n  this.reservedWords = wordsRegexp(reserved);\n  var reservedStrict = (reserved ? reserved + \" \" : \"\") + reservedWords.strict;\n  this.reservedWordsStrict = wordsRegexp(reservedStrict);\n  this.reservedWordsStrictBind = wordsRegexp(reservedStrict + \" \" + reservedWords.strictBind);\n  this.input = String(input);\n\n  // Used to signal to callers of `readWord1` whether the word\n  // contained any escape sequences. This is needed because words with\n  // escape sequences must not be interpreted as keywords.\n  this.containsEsc = false;\n\n  // Set up token state\n\n  // The current position of the tokenizer in the input.\n  if (startPos) {\n    this.pos = startPos;\n    this.lineStart = this.input.lastIndexOf(\"\\n\", startPos - 1) + 1;\n    this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length;\n  } else {\n    this.pos = this.lineStart = 0;\n    this.curLine = 1;\n  }\n\n  // Properties of the current token:\n  // Its type\n  this.type = types.eof;\n  // For tokens that include more information than their type, the value\n  this.value = null;\n  // Its start and end offset\n  this.start = this.end = this.pos;\n  // And, if locations are used, the {line, column} object\n  // corresponding to those offsets\n  this.startLoc = this.endLoc = this.curPosition();\n\n  // Position information for the previous token\n  this.lastTokEndLoc = this.lastTokStartLoc = null;\n  this.lastTokStart = this.lastTokEnd = this.pos;\n\n  // The context stack is used to superficially track syntactic\n  // context to predict whether a regular expression is allowed in a\n  // given position.\n  this.context = this.initialContext();\n  this.exprAllowed = true;\n\n  // Figure out if it's a module code.\n  this.inModule = options.sourceType === \"module\";\n  this.strict = this.inModule || this.strictDirective(this.pos);\n\n  // Used to signify the start of a potential arrow function\n  this.potentialArrowAt = -1;\n\n  // Positions to delayed-check that yield/await does not exist in default parameters.\n  this.yieldPos = this.awaitPos = this.awaitIdentPos = 0;\n  // Labels in scope.\n  this.labels = [];\n  // Thus-far undefined exports.\n  this.undefinedExports = {};\n\n  // If enabled, skip leading hashbang line.\n  if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === \"#!\")\n    { this.skipLineComment(2); }\n\n  // Scope tracking for duplicate variable names (see scope.js)\n  this.scopeStack = [];\n  this.enterScope(SCOPE_TOP);\n\n  // For RegExp validation\n  this.regexpState = null;\n};\n\nvar prototypeAccessors = { inFunction: { configurable: true },inGenerator: { configurable: true },inAsync: { configurable: true },allowSuper: { configurable: true },allowDirectSuper: { configurable: true },treatFunctionsAsVar: { configurable: true } };\n\nParser.prototype.parse = function parse () {\n  var node = this.options.program || this.startNode();\n  this.nextToken();\n  return this.parseTopLevel(node)\n};\n\nprototypeAccessors.inFunction.get = function () { return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0 };\nprototypeAccessors.inGenerator.get = function () { return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 };\nprototypeAccessors.inAsync.get = function () { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 };\nprototypeAccessors.allowSuper.get = function () { return (this.currentThisScope().flags & SCOPE_SUPER) > 0 };\nprototypeAccessors.allowDirectSuper.get = function () { return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0 };\nprototypeAccessors.treatFunctionsAsVar.get = function () { return this.treatFunctionsAsVarInScope(this.currentScope()) };\n\n// Switch to a getter for 7.0.0.\nParser.prototype.inNonArrowFunction = function inNonArrowFunction () { return (this.currentThisScope().flags & SCOPE_FUNCTION) > 0 };\n\nParser.extend = function extend () {\n    var plugins = [], len = arguments.length;\n    while ( len-- ) plugins[ len ] = arguments[ len ];\n\n  var cls = this;\n  for (var i = 0; i < plugins.length; i++) { cls = plugins[i](cls); }\n  return cls\n};\n\nParser.parse = function parse (input, options) {\n  return new this(options, input).parse()\n};\n\nParser.parseExpressionAt = function parseExpressionAt (input, pos, options) {\n  var parser = new this(options, input, pos);\n  parser.nextToken();\n  return parser.parseExpression()\n};\n\nParser.tokenizer = function tokenizer (input, options) {\n  return new this(options, input)\n};\n\nObject.defineProperties( Parser.prototype, prototypeAccessors );\n\nvar pp = Parser.prototype;\n\n// ## Parser utilities\n\nvar literal = /^(?:'((?:\\\\.|[^'])*?)'|\"((?:\\\\.|[^\"])*?)\")/;\npp.strictDirective = function(start) {\n  for (;;) {\n    // Try to find string literal.\n    skipWhiteSpace.lastIndex = start;\n    start += skipWhiteSpace.exec(this.input)[0].length;\n    var match = literal.exec(this.input.slice(start));\n    if (!match) { return false }\n    if ((match[1] || match[2]) === \"use strict\") {\n      skipWhiteSpace.lastIndex = start + match[0].length;\n      var spaceAfter = skipWhiteSpace.exec(this.input), end = spaceAfter.index + spaceAfter[0].length;\n      var next = this.input.charAt(end);\n      return next === \";\" || next === \"}\" ||\n        (lineBreak.test(spaceAfter[0]) &&\n         !(/[(`.[+\\-/*%<>=,?^&]/.test(next) || next === \"!\" && this.input.charAt(end + 1) === \"=\"))\n    }\n    start += match[0].length;\n\n    // Skip semicolon, if any.\n    skipWhiteSpace.lastIndex = start;\n    start += skipWhiteSpace.exec(this.input)[0].length;\n    if (this.input[start] === \";\")\n      { start++; }\n  }\n};\n\n// Predicate that tests whether the next token is of the given\n// type, and if yes, consumes it as a side effect.\n\npp.eat = function(type) {\n  if (this.type === type) {\n    this.next();\n    return true\n  } else {\n    return false\n  }\n};\n\n// Tests whether parsed token is a contextual keyword.\n\npp.isContextual = function(name) {\n  return this.type === types.name && this.value === name && !this.containsEsc\n};\n\n// Consumes contextual keyword if possible.\n\npp.eatContextual = function(name) {\n  if (!this.isContextual(name)) { return false }\n  this.next();\n  return true\n};\n\n// Asserts that following token is given contextual keyword.\n\npp.expectContextual = function(name) {\n  if (!this.eatContextual(name)) { this.unexpected(); }\n};\n\n// Test whether a semicolon can be inserted at the current position.\n\npp.canInsertSemicolon = function() {\n  return this.type === types.eof ||\n    this.type === types.braceR ||\n    lineBreak.test(this.input.slice(this.lastTokEnd, this.start))\n};\n\npp.insertSemicolon = function() {\n  if (this.canInsertSemicolon()) {\n    if (this.options.onInsertedSemicolon)\n      { this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc); }\n    return true\n  }\n};\n\n// Consume a semicolon, or, failing that, see if we are allowed to\n// pretend that there is a semicolon at this position.\n\npp.semicolon = function() {\n  if (!this.eat(types.semi) && !this.insertSemicolon()) { this.unexpected(); }\n};\n\npp.afterTrailingComma = function(tokType, notNext) {\n  if (this.type === tokType) {\n    if (this.options.onTrailingComma)\n      { this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc); }\n    if (!notNext)\n      { this.next(); }\n    return true\n  }\n};\n\n// Expect a token of a given type. If found, consume it, otherwise,\n// raise an unexpected token error.\n\npp.expect = function(type) {\n  this.eat(type) || this.unexpected();\n};\n\n// Raise an unexpected token error.\n\npp.unexpected = function(pos) {\n  this.raise(pos != null ? pos : this.start, \"Unexpected token\");\n};\n\nfunction DestructuringErrors() {\n  this.shorthandAssign =\n  this.trailingComma =\n  this.parenthesizedAssign =\n  this.parenthesizedBind =\n  this.doubleProto =\n    -1;\n}\n\npp.checkPatternErrors = function(refDestructuringErrors, isAssign) {\n  if (!refDestructuringErrors) { return }\n  if (refDestructuringErrors.trailingComma > -1)\n    { this.raiseRecoverable(refDestructuringErrors.trailingComma, \"Comma is not permitted after the rest element\"); }\n  var parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind;\n  if (parens > -1) { this.raiseRecoverable(parens, \"Parenthesized pattern\"); }\n};\n\npp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {\n  if (!refDestructuringErrors) { return false }\n  var shorthandAssign = refDestructuringErrors.shorthandAssign;\n  var doubleProto = refDestructuringErrors.doubleProto;\n  if (!andThrow) { return shorthandAssign >= 0 || doubleProto >= 0 }\n  if (shorthandAssign >= 0)\n    { this.raise(shorthandAssign, \"Shorthand property assignments are valid only in destructuring patterns\"); }\n  if (doubleProto >= 0)\n    { this.raiseRecoverable(doubleProto, \"Redefinition of __proto__ property\"); }\n};\n\npp.checkYieldAwaitInDefaultParams = function() {\n  if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos))\n    { this.raise(this.yieldPos, \"Yield expression cannot be a default value\"); }\n  if (this.awaitPos)\n    { this.raise(this.awaitPos, \"Await expression cannot be a default value\"); }\n};\n\npp.isSimpleAssignTarget = function(expr) {\n  if (expr.type === \"ParenthesizedExpression\")\n    { return this.isSimpleAssignTarget(expr.expression) }\n  return expr.type === \"Identifier\" || expr.type === \"MemberExpression\"\n};\n\nvar pp$1 = Parser.prototype;\n\n// ### Statement parsing\n\n// Parse a program. Initializes the parser, reads any number of\n// statements, and wraps them in a Program node.  Optionally takes a\n// `program` argument.  If present, the statements will be appended\n// to its body instead of creating a new node.\n\npp$1.parseTopLevel = function(node) {\n  var exports = {};\n  if (!node.body) { node.body = []; }\n  while (this.type !== types.eof) {\n    var stmt = this.parseStatement(null, true, exports);\n    node.body.push(stmt);\n  }\n  if (this.inModule)\n    { for (var i = 0, list = Object.keys(this.undefinedExports); i < list.length; i += 1)\n      {\n        var name = list[i];\n\n        this.raiseRecoverable(this.undefinedExports[name].start, (\"Export '\" + name + \"' is not defined\"));\n      } }\n  this.adaptDirectivePrologue(node.body);\n  this.next();\n  node.sourceType = this.options.sourceType;\n  return this.finishNode(node, \"Program\")\n};\n\nvar loopLabel = {kind: \"loop\"}, switchLabel = {kind: \"switch\"};\n\npp$1.isLet = function(context) {\n  if (this.options.ecmaVersion < 6 || !this.isContextual(\"let\")) { return false }\n  skipWhiteSpace.lastIndex = this.pos;\n  var skip = skipWhiteSpace.exec(this.input);\n  var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);\n  // For ambiguous cases, determine if a LexicalDeclaration (or only a\n  // Statement) is allowed here. If context is not empty then only a Statement\n  // is allowed. However, `let [` is an explicit negative lookahead for\n  // ExpressionStatement, so special-case it first.\n  if (nextCh === 91) { return true } // '['\n  if (context) { return false }\n\n  if (nextCh === 123) { return true } // '{'\n  if (isIdentifierStart(nextCh, true)) {\n    var pos = next + 1;\n    while (isIdentifierChar(this.input.charCodeAt(pos), true)) { ++pos; }\n    var ident = this.input.slice(next, pos);\n    if (!keywordRelationalOperator.test(ident)) { return true }\n  }\n  return false\n};\n\n// check 'async [no LineTerminator here] function'\n// - 'async /*foo*/ function' is OK.\n// - 'async /*\\n*/ function' is invalid.\npp$1.isAsyncFunction = function() {\n  if (this.options.ecmaVersion < 8 || !this.isContextual(\"async\"))\n    { return false }\n\n  skipWhiteSpace.lastIndex = this.pos;\n  var skip = skipWhiteSpace.exec(this.input);\n  var next = this.pos + skip[0].length;\n  return !lineBreak.test(this.input.slice(this.pos, next)) &&\n    this.input.slice(next, next + 8) === \"function\" &&\n    (next + 8 === this.input.length || !isIdentifierChar(this.input.charAt(next + 8)))\n};\n\n// Parse a single statement.\n//\n// If expecting a statement and finding a slash operator, parse a\n// regular expression literal. This is to handle cases like\n// `if (foo) /blah/.exec(foo)`, where looking at the previous token\n// does not help.\n\npp$1.parseStatement = function(context, topLevel, exports) {\n  var starttype = this.type, node = this.startNode(), kind;\n\n  if (this.isLet(context)) {\n    starttype = types._var;\n    kind = \"let\";\n  }\n\n  // Most types of statements are recognized by the keyword they\n  // start with. Many are trivial to parse, some require a bit of\n  // complexity.\n\n  switch (starttype) {\n  case types._break: case types._continue: return this.parseBreakContinueStatement(node, starttype.keyword)\n  case types._debugger: return this.parseDebuggerStatement(node)\n  case types._do: return this.parseDoStatement(node)\n  case types._for: return this.parseForStatement(node)\n  case types._function:\n    // Function as sole body of either an if statement or a labeled statement\n    // works, but not when it is part of a labeled statement that is the sole\n    // body of an if statement.\n    if ((context && (this.strict || context !== \"if\" && context !== \"label\")) && this.options.ecmaVersion >= 6) { this.unexpected(); }\n    return this.parseFunctionStatement(node, false, !context)\n  case types._class:\n    if (context) { this.unexpected(); }\n    return this.parseClass(node, true)\n  case types._if: return this.parseIfStatement(node)\n  case types._return: return this.parseReturnStatement(node)\n  case types._switch: return this.parseSwitchStatement(node)\n  case types._throw: return this.parseThrowStatement(node)\n  case types._try: return this.parseTryStatement(node)\n  case types._const: case types._var:\n    kind = kind || this.value;\n    if (context && kind !== \"var\") { this.unexpected(); }\n    return this.parseVarStatement(node, kind)\n  case types._while: return this.parseWhileStatement(node)\n  case types._with: return this.parseWithStatement(node)\n  case types.braceL: return this.parseBlock(true, node)\n  case types.semi: return this.parseEmptyStatement(node)\n  case types._export:\n  case types._import:\n    if (this.options.ecmaVersion > 10 && starttype === types._import) {\n      skipWhiteSpace.lastIndex = this.pos;\n      var skip = skipWhiteSpace.exec(this.input);\n      var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);\n      if (nextCh === 40 || nextCh === 46) // '(' or '.'\n        { return this.parseExpressionStatement(node, this.parseExpression()) }\n    }\n\n    if (!this.options.allowImportExportEverywhere) {\n      if (!topLevel)\n        { this.raise(this.start, \"'import' and 'export' may only appear at the top level\"); }\n      if (!this.inModule)\n        { this.raise(this.start, \"'import' and 'export' may appear only with 'sourceType: module'\"); }\n    }\n    return starttype === types._import ? this.parseImport(node) : this.parseExport(node, exports)\n\n    // If the statement does not start with a statement keyword or a\n    // brace, it's an ExpressionStatement or LabeledStatement. We\n    // simply start parsing an expression, and afterwards, if the\n    // next token is a colon and the expression was a simple\n    // Identifier node, we switch to interpreting it as a label.\n  default:\n    if (this.isAsyncFunction()) {\n      if (context) { this.unexpected(); }\n      this.next();\n      return this.parseFunctionStatement(node, true, !context)\n    }\n\n    var maybeName = this.value, expr = this.parseExpression();\n    if (starttype === types.name && expr.type === \"Identifier\" && this.eat(types.colon))\n      { return this.parseLabeledStatement(node, maybeName, expr, context) }\n    else { return this.parseExpressionStatement(node, expr) }\n  }\n};\n\npp$1.parseBreakContinueStatement = function(node, keyword) {\n  var isBreak = keyword === \"break\";\n  this.next();\n  if (this.eat(types.semi) || this.insertSemicolon()) { node.label = null; }\n  else if (this.type !== types.name) { this.unexpected(); }\n  else {\n    node.label = this.parseIdent();\n    this.semicolon();\n  }\n\n  // Verify that there is an actual destination to break or\n  // continue to.\n  var i = 0;\n  for (; i < this.labels.length; ++i) {\n    var lab = this.labels[i];\n    if (node.label == null || lab.name === node.label.name) {\n      if (lab.kind != null && (isBreak || lab.kind === \"loop\")) { break }\n      if (node.label && isBreak) { break }\n    }\n  }\n  if (i === this.labels.length) { this.raise(node.start, \"Unsyntactic \" + keyword); }\n  return this.finishNode(node, isBreak ? \"BreakStatement\" : \"ContinueStatement\")\n};\n\npp$1.parseDebuggerStatement = function(node) {\n  this.next();\n  this.semicolon();\n  return this.finishNode(node, \"DebuggerStatement\")\n};\n\npp$1.parseDoStatement = function(node) {\n  this.next();\n  this.labels.push(loopLabel);\n  node.body = this.parseStatement(\"do\");\n  this.labels.pop();\n  this.expect(types._while);\n  node.test = this.parseParenExpression();\n  if (this.options.ecmaVersion >= 6)\n    { this.eat(types.semi); }\n  else\n    { this.semicolon(); }\n  return this.finishNode(node, \"DoWhileStatement\")\n};\n\n// Disambiguating between a `for` and a `for`/`in` or `for`/`of`\n// loop is non-trivial. Basically, we have to parse the init `var`\n// statement or expression, disallowing the `in` operator (see\n// the second parameter to `parseExpression`), and then check\n// whether the next token is `in` or `of`. When there is no init\n// part (semicolon immediately after the opening parenthesis), it\n// is a regular `for` loop.\n\npp$1.parseForStatement = function(node) {\n  this.next();\n  var awaitAt = (this.options.ecmaVersion >= 9 && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction)) && this.eatContextual(\"await\")) ? this.lastTokStart : -1;\n  this.labels.push(loopLabel);\n  this.enterScope(0);\n  this.expect(types.parenL);\n  if (this.type === types.semi) {\n    if (awaitAt > -1) { this.unexpected(awaitAt); }\n    return this.parseFor(node, null)\n  }\n  var isLet = this.isLet();\n  if (this.type === types._var || this.type === types._const || isLet) {\n    var init$1 = this.startNode(), kind = isLet ? \"let\" : this.value;\n    this.next();\n    this.parseVar(init$1, true, kind);\n    this.finishNode(init$1, \"VariableDeclaration\");\n    if ((this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual(\"of\"))) && init$1.declarations.length === 1) {\n      if (this.options.ecmaVersion >= 9) {\n        if (this.type === types._in) {\n          if (awaitAt > -1) { this.unexpected(awaitAt); }\n        } else { node.await = awaitAt > -1; }\n      }\n      return this.parseForIn(node, init$1)\n    }\n    if (awaitAt > -1) { this.unexpected(awaitAt); }\n    return this.parseFor(node, init$1)\n  }\n  var refDestructuringErrors = new DestructuringErrors;\n  var init = this.parseExpression(true, refDestructuringErrors);\n  if (this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual(\"of\"))) {\n    if (this.options.ecmaVersion >= 9) {\n      if (this.type === types._in) {\n        if (awaitAt > -1) { this.unexpected(awaitAt); }\n      } else { node.await = awaitAt > -1; }\n    }\n    this.toAssignable(init, false, refDestructuringErrors);\n    this.checkLVal(init);\n    return this.parseForIn(node, init)\n  } else {\n    this.checkExpressionErrors(refDestructuringErrors, true);\n  }\n  if (awaitAt > -1) { this.unexpected(awaitAt); }\n  return this.parseFor(node, init)\n};\n\npp$1.parseFunctionStatement = function(node, isAsync, declarationPosition) {\n  this.next();\n  return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync)\n};\n\npp$1.parseIfStatement = function(node) {\n  this.next();\n  node.test = this.parseParenExpression();\n  // allow function declarations in branches, but only in non-strict mode\n  node.consequent = this.parseStatement(\"if\");\n  node.alternate = this.eat(types._else) ? this.parseStatement(\"if\") : null;\n  return this.finishNode(node, \"IfStatement\")\n};\n\npp$1.parseReturnStatement = function(node) {\n  if (!this.inFunction && !this.options.allowReturnOutsideFunction)\n    { this.raise(this.start, \"'return' outside of function\"); }\n  this.next();\n\n  // In `return` (and `break`/`continue`), the keywords with\n  // optional arguments, we eagerly look for a semicolon or the\n  // possibility to insert one.\n\n  if (this.eat(types.semi) || this.insertSemicolon()) { node.argument = null; }\n  else { node.argument = this.parseExpression(); this.semicolon(); }\n  return this.finishNode(node, \"ReturnStatement\")\n};\n\npp$1.parseSwitchStatement = function(node) {\n  this.next();\n  node.discriminant = this.parseParenExpression();\n  node.cases = [];\n  this.expect(types.braceL);\n  this.labels.push(switchLabel);\n  this.enterScope(0);\n\n  // Statements under must be grouped (by label) in SwitchCase\n  // nodes. `cur` is used to keep the node that we are currently\n  // adding statements to.\n\n  var cur;\n  for (var sawDefault = false; this.type !== types.braceR;) {\n    if (this.type === types._case || this.type === types._default) {\n      var isCase = this.type === types._case;\n      if (cur) { this.finishNode(cur, \"SwitchCase\"); }\n      node.cases.push(cur = this.startNode());\n      cur.consequent = [];\n      this.next();\n      if (isCase) {\n        cur.test = this.parseExpression();\n      } else {\n        if (sawDefault) { this.raiseRecoverable(this.lastTokStart, \"Multiple default clauses\"); }\n        sawDefault = true;\n        cur.test = null;\n      }\n      this.expect(types.colon);\n    } else {\n      if (!cur) { this.unexpected(); }\n      cur.consequent.push(this.parseStatement(null));\n    }\n  }\n  this.exitScope();\n  if (cur) { this.finishNode(cur, \"SwitchCase\"); }\n  this.next(); // Closing brace\n  this.labels.pop();\n  return this.finishNode(node, \"SwitchStatement\")\n};\n\npp$1.parseThrowStatement = function(node) {\n  this.next();\n  if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))\n    { this.raise(this.lastTokEnd, \"Illegal newline after throw\"); }\n  node.argument = this.parseExpression();\n  this.semicolon();\n  return this.finishNode(node, \"ThrowStatement\")\n};\n\n// Reused empty array added for node fields that are always empty.\n\nvar empty = [];\n\npp$1.parseTryStatement = function(node) {\n  this.next();\n  node.block = this.parseBlock();\n  node.handler = null;\n  if (this.type === types._catch) {\n    var clause = this.startNode();\n    this.next();\n    if (this.eat(types.parenL)) {\n      clause.param = this.parseBindingAtom();\n      var simple = clause.param.type === \"Identifier\";\n      this.enterScope(simple ? SCOPE_SIMPLE_CATCH : 0);\n      this.checkLVal(clause.param, simple ? BIND_SIMPLE_CATCH : BIND_LEXICAL);\n      this.expect(types.parenR);\n    } else {\n      if (this.options.ecmaVersion < 10) { this.unexpected(); }\n      clause.param = null;\n      this.enterScope(0);\n    }\n    clause.body = this.parseBlock(false);\n    this.exitScope();\n    node.handler = this.finishNode(clause, \"CatchClause\");\n  }\n  node.finalizer = this.eat(types._finally) ? this.parseBlock() : null;\n  if (!node.handler && !node.finalizer)\n    { this.raise(node.start, \"Missing catch or finally clause\"); }\n  return this.finishNode(node, \"TryStatement\")\n};\n\npp$1.parseVarStatement = function(node, kind) {\n  this.next();\n  this.parseVar(node, false, kind);\n  this.semicolon();\n  return this.finishNode(node, \"VariableDeclaration\")\n};\n\npp$1.parseWhileStatement = function(node) {\n  this.next();\n  node.test = this.parseParenExpression();\n  this.labels.push(loopLabel);\n  node.body = this.parseStatement(\"while\");\n  this.labels.pop();\n  return this.finishNode(node, \"WhileStatement\")\n};\n\npp$1.parseWithStatement = function(node) {\n  if (this.strict) { this.raise(this.start, \"'with' in strict mode\"); }\n  this.next();\n  node.object = this.parseParenExpression();\n  node.body = this.parseStatement(\"with\");\n  return this.finishNode(node, \"WithStatement\")\n};\n\npp$1.parseEmptyStatement = function(node) {\n  this.next();\n  return this.finishNode(node, \"EmptyStatement\")\n};\n\npp$1.parseLabeledStatement = function(node, maybeName, expr, context) {\n  for (var i$1 = 0, list = this.labels; i$1 < list.length; i$1 += 1)\n    {\n    var label = list[i$1];\n\n    if (label.name === maybeName)\n      { this.raise(expr.start, \"Label '\" + maybeName + \"' is already declared\");\n  } }\n  var kind = this.type.isLoop ? \"loop\" : this.type === types._switch ? \"switch\" : null;\n  for (var i = this.labels.length - 1; i >= 0; i--) {\n    var label$1 = this.labels[i];\n    if (label$1.statementStart === node.start) {\n      // Update information about previous labels on this node\n      label$1.statementStart = this.start;\n      label$1.kind = kind;\n    } else { break }\n  }\n  this.labels.push({name: maybeName, kind: kind, statementStart: this.start});\n  node.body = this.parseStatement(context ? context.indexOf(\"label\") === -1 ? context + \"label\" : context : \"label\");\n  this.labels.pop();\n  node.label = expr;\n  return this.finishNode(node, \"LabeledStatement\")\n};\n\npp$1.parseExpressionStatement = function(node, expr) {\n  node.expression = expr;\n  this.semicolon();\n  return this.finishNode(node, \"ExpressionStatement\")\n};\n\n// Parse a semicolon-enclosed block of statements, handling `\"use\n// strict\"` declarations when `allowStrict` is true (used for\n// function bodies).\n\npp$1.parseBlock = function(createNewLexicalScope, node, exitStrict) {\n  if ( createNewLexicalScope === void 0 ) createNewLexicalScope = true;\n  if ( node === void 0 ) node = this.startNode();\n\n  node.body = [];\n  this.expect(types.braceL);\n  if (createNewLexicalScope) { this.enterScope(0); }\n  while (this.type !== types.braceR) {\n    var stmt = this.parseStatement(null);\n    node.body.push(stmt);\n  }\n  if (exitStrict) { this.strict = false; }\n  this.next();\n  if (createNewLexicalScope) { this.exitScope(); }\n  return this.finishNode(node, \"BlockStatement\")\n};\n\n// Parse a regular `for` loop. The disambiguation code in\n// `parseStatement` will already have parsed the init statement or\n// expression.\n\npp$1.parseFor = function(node, init) {\n  node.init = init;\n  this.expect(types.semi);\n  node.test = this.type === types.semi ? null : this.parseExpression();\n  this.expect(types.semi);\n  node.update = this.type === types.parenR ? null : this.parseExpression();\n  this.expect(types.parenR);\n  node.body = this.parseStatement(\"for\");\n  this.exitScope();\n  this.labels.pop();\n  return this.finishNode(node, \"ForStatement\")\n};\n\n// Parse a `for`/`in` and `for`/`of` loop, which are almost\n// same from parser's perspective.\n\npp$1.parseForIn = function(node, init) {\n  var isForIn = this.type === types._in;\n  this.next();\n\n  if (\n    init.type === \"VariableDeclaration\" &&\n    init.declarations[0].init != null &&\n    (\n      !isForIn ||\n      this.options.ecmaVersion < 8 ||\n      this.strict ||\n      init.kind !== \"var\" ||\n      init.declarations[0].id.type !== \"Identifier\"\n    )\n  ) {\n    this.raise(\n      init.start,\n      ((isForIn ? \"for-in\" : \"for-of\") + \" loop variable declaration may not have an initializer\")\n    );\n  } else if (init.type === \"AssignmentPattern\") {\n    this.raise(init.start, \"Invalid left-hand side in for-loop\");\n  }\n  node.left = init;\n  node.right = isForIn ? this.parseExpression() : this.parseMaybeAssign();\n  this.expect(types.parenR);\n  node.body = this.parseStatement(\"for\");\n  this.exitScope();\n  this.labels.pop();\n  return this.finishNode(node, isForIn ? \"ForInStatement\" : \"ForOfStatement\")\n};\n\n// Parse a list of variable declarations.\n\npp$1.parseVar = function(node, isFor, kind) {\n  node.declarations = [];\n  node.kind = kind;\n  for (;;) {\n    var decl = this.startNode();\n    this.parseVarId(decl, kind);\n    if (this.eat(types.eq)) {\n      decl.init = this.parseMaybeAssign(isFor);\n    } else if (kind === \"const\" && !(this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual(\"of\")))) {\n      this.unexpected();\n    } else if (decl.id.type !== \"Identifier\" && !(isFor && (this.type === types._in || this.isContextual(\"of\")))) {\n      this.raise(this.lastTokEnd, \"Complex binding patterns require an initialization value\");\n    } else {\n      decl.init = null;\n    }\n    node.declarations.push(this.finishNode(decl, \"VariableDeclarator\"));\n    if (!this.eat(types.comma)) { break }\n  }\n  return node\n};\n\npp$1.parseVarId = function(decl, kind) {\n  decl.id = this.parseBindingAtom();\n  this.checkLVal(decl.id, kind === \"var\" ? BIND_VAR : BIND_LEXICAL, false);\n};\n\nvar FUNC_STATEMENT = 1, FUNC_HANGING_STATEMENT = 2, FUNC_NULLABLE_ID = 4;\n\n// Parse a function declaration or literal (depending on the\n// `statement & FUNC_STATEMENT`).\n\n// Remove `allowExpressionBody` for 7.0.0, as it is only called with false\npp$1.parseFunction = function(node, statement, allowExpressionBody, isAsync) {\n  this.initFunction(node);\n  if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync) {\n    if (this.type === types.star && (statement & FUNC_HANGING_STATEMENT))\n      { this.unexpected(); }\n    node.generator = this.eat(types.star);\n  }\n  if (this.options.ecmaVersion >= 8)\n    { node.async = !!isAsync; }\n\n  if (statement & FUNC_STATEMENT) {\n    node.id = (statement & FUNC_NULLABLE_ID) && this.type !== types.name ? null : this.parseIdent();\n    if (node.id && !(statement & FUNC_HANGING_STATEMENT))\n      // If it is a regular function declaration in sloppy mode, then it is\n      // subject to Annex B semantics (BIND_FUNCTION). Otherwise, the binding\n      // mode depends on properties of the current scope (see\n      // treatFunctionsAsVar).\n      { this.checkLVal(node.id, (this.strict || node.generator || node.async) ? this.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION); }\n  }\n\n  var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;\n  this.yieldPos = 0;\n  this.awaitPos = 0;\n  this.awaitIdentPos = 0;\n  this.enterScope(functionFlags(node.async, node.generator));\n\n  if (!(statement & FUNC_STATEMENT))\n    { node.id = this.type === types.name ? this.parseIdent() : null; }\n\n  this.parseFunctionParams(node);\n  this.parseFunctionBody(node, allowExpressionBody, false);\n\n  this.yieldPos = oldYieldPos;\n  this.awaitPos = oldAwaitPos;\n  this.awaitIdentPos = oldAwaitIdentPos;\n  return this.finishNode(node, (statement & FUNC_STATEMENT) ? \"FunctionDeclaration\" : \"FunctionExpression\")\n};\n\npp$1.parseFunctionParams = function(node) {\n  this.expect(types.parenL);\n  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);\n  this.checkYieldAwaitInDefaultParams();\n};\n\n// Parse a class declaration or literal (depending on the\n// `isStatement` parameter).\n\npp$1.parseClass = function(node, isStatement) {\n  this.next();\n\n  // ecma-262 14.6 Class Definitions\n  // A class definition is always strict mode code.\n  var oldStrict = this.strict;\n  this.strict = true;\n\n  this.parseClassId(node, isStatement);\n  this.parseClassSuper(node);\n  var classBody = this.startNode();\n  var hadConstructor = false;\n  classBody.body = [];\n  this.expect(types.braceL);\n  while (this.type !== types.braceR) {\n    var element = this.parseClassElement(node.superClass !== null);\n    if (element) {\n      classBody.body.push(element);\n      if (element.type === \"MethodDefinition\" && element.kind === \"constructor\") {\n        if (hadConstructor) { this.raise(element.start, \"Duplicate constructor in the same class\"); }\n        hadConstructor = true;\n      }\n    }\n  }\n  this.strict = oldStrict;\n  this.next();\n  node.body = this.finishNode(classBody, \"ClassBody\");\n  return this.finishNode(node, isStatement ? \"ClassDeclaration\" : \"ClassExpression\")\n};\n\npp$1.parseClassElement = function(constructorAllowsSuper) {\n  var this$1 = this;\n\n  if (this.eat(types.semi)) { return null }\n\n  var method = this.startNode();\n  var tryContextual = function (k, noLineBreak) {\n    if ( noLineBreak === void 0 ) noLineBreak = false;\n\n    var start = this$1.start, startLoc = this$1.startLoc;\n    if (!this$1.eatContextual(k)) { return false }\n    if (this$1.type !== types.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) { return true }\n    if (method.key) { this$1.unexpected(); }\n    method.computed = false;\n    method.key = this$1.startNodeAt(start, startLoc);\n    method.key.name = k;\n    this$1.finishNode(method.key, \"Identifier\");\n    return false\n  };\n\n  method.kind = \"method\";\n  method.static = tryContextual(\"static\");\n  var isGenerator = this.eat(types.star);\n  var isAsync = false;\n  if (!isGenerator) {\n    if (this.options.ecmaVersion >= 8 && tryContextual(\"async\", true)) {\n      isAsync = true;\n      isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);\n    } else if (tryContextual(\"get\")) {\n      method.kind = \"get\";\n    } else if (tryContextual(\"set\")) {\n      method.kind = \"set\";\n    }\n  }\n  if (!method.key) { this.parsePropertyName(method); }\n  var key = method.key;\n  var allowsDirectSuper = false;\n  if (!method.computed && !method.static && (key.type === \"Identifier\" && key.name === \"constructor\" ||\n      key.type === \"Literal\" && key.value === \"constructor\")) {\n    if (method.kind !== \"method\") { this.raise(key.start, \"Constructor can't have get/set modifier\"); }\n    if (isGenerator) { this.raise(key.start, \"Constructor can't be a generator\"); }\n    if (isAsync) { this.raise(key.start, \"Constructor can't be an async method\"); }\n    method.kind = \"constructor\";\n    allowsDirectSuper = constructorAllowsSuper;\n  } else if (method.static && key.type === \"Identifier\" && key.name === \"prototype\") {\n    this.raise(key.start, \"Classes may not have a static property named prototype\");\n  }\n  this.parseClassMethod(method, isGenerator, isAsync, allowsDirectSuper);\n  if (method.kind === \"get\" && method.value.params.length !== 0)\n    { this.raiseRecoverable(method.value.start, \"getter should have no params\"); }\n  if (method.kind === \"set\" && method.value.params.length !== 1)\n    { this.raiseRecoverable(method.value.start, \"setter should have exactly one param\"); }\n  if (method.kind === \"set\" && method.value.params[0].type === \"RestElement\")\n    { this.raiseRecoverable(method.value.params[0].start, \"Setter cannot use rest params\"); }\n  return method\n};\n\npp$1.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {\n  method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);\n  return this.finishNode(method, \"MethodDefinition\")\n};\n\npp$1.parseClassId = function(node, isStatement) {\n  if (this.type === types.name) {\n    node.id = this.parseIdent();\n    if (isStatement)\n      { this.checkLVal(node.id, BIND_LEXICAL, false); }\n  } else {\n    if (isStatement === true)\n      { this.unexpected(); }\n    node.id = null;\n  }\n};\n\npp$1.parseClassSuper = function(node) {\n  node.superClass = this.eat(types._extends) ? this.parseExprSubscripts() : null;\n};\n\n// Parses module export declaration.\n\npp$1.parseExport = function(node, exports) {\n  this.next();\n  // export * from '...'\n  if (this.eat(types.star)) {\n    if (this.options.ecmaVersion >= 11) {\n      if (this.eatContextual(\"as\")) {\n        node.exported = this.parseIdent(true);\n        this.checkExport(exports, node.exported.name, this.lastTokStart);\n      } else {\n        node.exported = null;\n      }\n    }\n    this.expectContextual(\"from\");\n    if (this.type !== types.string) { this.unexpected(); }\n    node.source = this.parseExprAtom();\n    this.semicolon();\n    return this.finishNode(node, \"ExportAllDeclaration\")\n  }\n  if (this.eat(types._default)) { // export default ...\n    this.checkExport(exports, \"default\", this.lastTokStart);\n    var isAsync;\n    if (this.type === types._function || (isAsync = this.isAsyncFunction())) {\n      var fNode = this.startNode();\n      this.next();\n      if (isAsync) { this.next(); }\n      node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync);\n    } else if (this.type === types._class) {\n      var cNode = this.startNode();\n      node.declaration = this.parseClass(cNode, \"nullableID\");\n    } else {\n      node.declaration = this.parseMaybeAssign();\n      this.semicolon();\n    }\n    return this.finishNode(node, \"ExportDefaultDeclaration\")\n  }\n  // export var|const|let|function|class ...\n  if (this.shouldParseExportStatement()) {\n    node.declaration = this.parseStatement(null);\n    if (node.declaration.type === \"VariableDeclaration\")\n      { this.checkVariableExport(exports, node.declaration.declarations); }\n    else\n      { this.checkExport(exports, node.declaration.id.name, node.declaration.id.start); }\n    node.specifiers = [];\n    node.source = null;\n  } else { // export { x, y as z } [from '...']\n    node.declaration = null;\n    node.specifiers = this.parseExportSpecifiers(exports);\n    if (this.eatContextual(\"from\")) {\n      if (this.type !== types.string) { this.unexpected(); }\n      node.source = this.parseExprAtom();\n    } else {\n      for (var i = 0, list = node.specifiers; i < list.length; i += 1) {\n        // check for keywords used as local names\n        var spec = list[i];\n\n        this.checkUnreserved(spec.local);\n        // check if export is defined\n        this.checkLocalExport(spec.local);\n      }\n\n      node.source = null;\n    }\n    this.semicolon();\n  }\n  return this.finishNode(node, \"ExportNamedDeclaration\")\n};\n\npp$1.checkExport = function(exports, name, pos) {\n  if (!exports) { return }\n  if (has(exports, name))\n    { this.raiseRecoverable(pos, \"Duplicate export '\" + name + \"'\"); }\n  exports[name] = true;\n};\n\npp$1.checkPatternExport = function(exports, pat) {\n  var type = pat.type;\n  if (type === \"Identifier\")\n    { this.checkExport(exports, pat.name, pat.start); }\n  else if (type === \"ObjectPattern\")\n    { for (var i = 0, list = pat.properties; i < list.length; i += 1)\n      {\n        var prop = list[i];\n\n        this.checkPatternExport(exports, prop);\n      } }\n  else if (type === \"ArrayPattern\")\n    { for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) {\n      var elt = list$1[i$1];\n\n        if (elt) { this.checkPatternExport(exports, elt); }\n    } }\n  else if (type === \"Property\")\n    { this.checkPatternExport(exports, pat.value); }\n  else if (type === \"AssignmentPattern\")\n    { this.checkPatternExport(exports, pat.left); }\n  else if (type === \"RestElement\")\n    { this.checkPatternExport(exports, pat.argument); }\n  else if (type === \"ParenthesizedExpression\")\n    { this.checkPatternExport(exports, pat.expression); }\n};\n\npp$1.checkVariableExport = function(exports, decls) {\n  if (!exports) { return }\n  for (var i = 0, list = decls; i < list.length; i += 1)\n    {\n    var decl = list[i];\n\n    this.checkPatternExport(exports, decl.id);\n  }\n};\n\npp$1.shouldParseExportStatement = function() {\n  return this.type.keyword === \"var\" ||\n    this.type.keyword === \"const\" ||\n    this.type.keyword === \"class\" ||\n    this.type.keyword === \"function\" ||\n    this.isLet() ||\n    this.isAsyncFunction()\n};\n\n// Parses a comma-separated list of module exports.\n\npp$1.parseExportSpecifiers = function(exports) {\n  var nodes = [], first = true;\n  // export { x, y as z } [from '...']\n  this.expect(types.braceL);\n  while (!this.eat(types.braceR)) {\n    if (!first) {\n      this.expect(types.comma);\n      if (this.afterTrailingComma(types.braceR)) { break }\n    } else { first = false; }\n\n    var node = this.startNode();\n    node.local = this.parseIdent(true);\n    node.exported = this.eatContextual(\"as\") ? this.parseIdent(true) : node.local;\n    this.checkExport(exports, node.exported.name, node.exported.start);\n    nodes.push(this.finishNode(node, \"ExportSpecifier\"));\n  }\n  return nodes\n};\n\n// Parses import declaration.\n\npp$1.parseImport = function(node) {\n  this.next();\n  // import '...'\n  if (this.type === types.string) {\n    node.specifiers = empty;\n    node.source = this.parseExprAtom();\n  } else {\n    node.specifiers = this.parseImportSpecifiers();\n    this.expectContextual(\"from\");\n    node.source = this.type === types.string ? this.parseExprAtom() : this.unexpected();\n  }\n  this.semicolon();\n  return this.finishNode(node, \"ImportDeclaration\")\n};\n\n// Parses a comma-separated list of module imports.\n\npp$1.parseImportSpecifiers = function() {\n  var nodes = [], first = true;\n  if (this.type === types.name) {\n    // import defaultObj, { x, y as z } from '...'\n    var node = this.startNode();\n    node.local = this.parseIdent();\n    this.checkLVal(node.local, BIND_LEXICAL);\n    nodes.push(this.finishNode(node, \"ImportDefaultSpecifier\"));\n    if (!this.eat(types.comma)) { return nodes }\n  }\n  if (this.type === types.star) {\n    var node$1 = this.startNode();\n    this.next();\n    this.expectContextual(\"as\");\n    node$1.local = this.parseIdent();\n    this.checkLVal(node$1.local, BIND_LEXICAL);\n    nodes.push(this.finishNode(node$1, \"ImportNamespaceSpecifier\"));\n    return nodes\n  }\n  this.expect(types.braceL);\n  while (!this.eat(types.braceR)) {\n    if (!first) {\n      this.expect(types.comma);\n      if (this.afterTrailingComma(types.braceR)) { break }\n    } else { first = false; }\n\n    var node$2 = this.startNode();\n    node$2.imported = this.parseIdent(true);\n    if (this.eatContextual(\"as\")) {\n      node$2.local = this.parseIdent();\n    } else {\n      this.checkUnreserved(node$2.imported);\n      node$2.local = node$2.imported;\n    }\n    this.checkLVal(node$2.local, BIND_LEXICAL);\n    nodes.push(this.finishNode(node$2, \"ImportSpecifier\"));\n  }\n  return nodes\n};\n\n// Set `ExpressionStatement#directive` property for directive prologues.\npp$1.adaptDirectivePrologue = function(statements) {\n  for (var i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) {\n    statements[i].directive = statements[i].expression.raw.slice(1, -1);\n  }\n};\npp$1.isDirectiveCandidate = function(statement) {\n  return (\n    statement.type === \"ExpressionStatement\" &&\n    statement.expression.type === \"Literal\" &&\n    typeof statement.expression.value === \"string\" &&\n    // Reject parenthesized strings.\n    (this.input[statement.start] === \"\\\"\" || this.input[statement.start] === \"'\")\n  )\n};\n\nvar pp$2 = Parser.prototype;\n\n// Convert existing expression atom to assignable pattern\n// if possible.\n\npp$2.toAssignable = function(node, isBinding, refDestructuringErrors) {\n  if (this.options.ecmaVersion >= 6 && node) {\n    switch (node.type) {\n    case \"Identifier\":\n      if (this.inAsync && node.name === \"await\")\n        { this.raise(node.start, \"Cannot use 'await' as identifier inside an async function\"); }\n      break\n\n    case \"ObjectPattern\":\n    case \"ArrayPattern\":\n    case \"RestElement\":\n      break\n\n    case \"ObjectExpression\":\n      node.type = \"ObjectPattern\";\n      if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }\n      for (var i = 0, list = node.properties; i < list.length; i += 1) {\n        var prop = list[i];\n\n      this.toAssignable(prop, isBinding);\n        // Early error:\n        //   AssignmentRestProperty[Yield, Await] :\n        //     `...` DestructuringAssignmentTarget[Yield, Await]\n        //\n        //   It is a Syntax Error if |DestructuringAssignmentTarget| is an |ArrayLiteral| or an |ObjectLiteral|.\n        if (\n          prop.type === \"RestElement\" &&\n          (prop.argument.type === \"ArrayPattern\" || prop.argument.type === \"ObjectPattern\")\n        ) {\n          this.raise(prop.argument.start, \"Unexpected token\");\n        }\n      }\n      break\n\n    case \"Property\":\n      // AssignmentProperty has type === \"Property\"\n      if (node.kind !== \"init\") { this.raise(node.key.start, \"Object pattern can't contain getter or setter\"); }\n      this.toAssignable(node.value, isBinding);\n      break\n\n    case \"ArrayExpression\":\n      node.type = \"ArrayPattern\";\n      if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }\n      this.toAssignableList(node.elements, isBinding);\n      break\n\n    case \"SpreadElement\":\n      node.type = \"RestElement\";\n      this.toAssignable(node.argument, isBinding);\n      if (node.argument.type === \"AssignmentPattern\")\n        { this.raise(node.argument.start, \"Rest elements cannot have a default value\"); }\n      break\n\n    case \"AssignmentExpression\":\n      if (node.operator !== \"=\") { this.raise(node.left.end, \"Only '=' operator can be used for specifying default value.\"); }\n      node.type = \"AssignmentPattern\";\n      delete node.operator;\n      this.toAssignable(node.left, isBinding);\n      // falls through to AssignmentPattern\n\n    case \"AssignmentPattern\":\n      break\n\n    case \"ParenthesizedExpression\":\n      this.toAssignable(node.expression, isBinding, refDestructuringErrors);\n      break\n\n    case \"MemberExpression\":\n      if (!isBinding) { break }\n\n    default:\n      this.raise(node.start, \"Assigning to rvalue\");\n    }\n  } else if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }\n  return node\n};\n\n// Convert list of expression atoms to binding list.\n\npp$2.toAssignableList = function(exprList, isBinding) {\n  var end = exprList.length;\n  for (var i = 0; i < end; i++) {\n    var elt = exprList[i];\n    if (elt) { this.toAssignable(elt, isBinding); }\n  }\n  if (end) {\n    var last = exprList[end - 1];\n    if (this.options.ecmaVersion === 6 && isBinding && last && last.type === \"RestElement\" && last.argument.type !== \"Identifier\")\n      { this.unexpected(last.argument.start); }\n  }\n  return exprList\n};\n\n// Parses spread element.\n\npp$2.parseSpread = function(refDestructuringErrors) {\n  var node = this.startNode();\n  this.next();\n  node.argument = this.parseMaybeAssign(false, refDestructuringErrors);\n  return this.finishNode(node, \"SpreadElement\")\n};\n\npp$2.parseRestBinding = function() {\n  var node = this.startNode();\n  this.next();\n\n  // RestElement inside of a function parameter must be an identifier\n  if (this.options.ecmaVersion === 6 && this.type !== types.name)\n    { this.unexpected(); }\n\n  node.argument = this.parseBindingAtom();\n\n  return this.finishNode(node, \"RestElement\")\n};\n\n// Parses lvalue (assignable) atom.\n\npp$2.parseBindingAtom = function() {\n  if (this.options.ecmaVersion >= 6) {\n    switch (this.type) {\n    case types.bracketL:\n      var node = this.startNode();\n      this.next();\n      node.elements = this.parseBindingList(types.bracketR, true, true);\n      return this.finishNode(node, \"ArrayPattern\")\n\n    case types.braceL:\n      return this.parseObj(true)\n    }\n  }\n  return this.parseIdent()\n};\n\npp$2.parseBindingList = function(close, allowEmpty, allowTrailingComma) {\n  var elts = [], first = true;\n  while (!this.eat(close)) {\n    if (first) { first = false; }\n    else { this.expect(types.comma); }\n    if (allowEmpty && this.type === types.comma) {\n      elts.push(null);\n    } else if (allowTrailingComma && this.afterTrailingComma(close)) {\n      break\n    } else if (this.type === types.ellipsis) {\n      var rest = this.parseRestBinding();\n      this.parseBindingListItem(rest);\n      elts.push(rest);\n      if (this.type === types.comma) { this.raise(this.start, \"Comma is not permitted after the rest element\"); }\n      this.expect(close);\n      break\n    } else {\n      var elem = this.parseMaybeDefault(this.start, this.startLoc);\n      this.parseBindingListItem(elem);\n      elts.push(elem);\n    }\n  }\n  return elts\n};\n\npp$2.parseBindingListItem = function(param) {\n  return param\n};\n\n// Parses assignment pattern around given atom if possible.\n\npp$2.parseMaybeDefault = function(startPos, startLoc, left) {\n  left = left || this.parseBindingAtom();\n  if (this.options.ecmaVersion < 6 || !this.eat(types.eq)) { return left }\n  var node = this.startNodeAt(startPos, startLoc);\n  node.left = left;\n  node.right = this.parseMaybeAssign();\n  return this.finishNode(node, \"AssignmentPattern\")\n};\n\n// Verify that a node is an lval — something that can be assigned\n// to.\n// bindingType can be either:\n// 'var' indicating that the lval creates a 'var' binding\n// 'let' indicating that the lval creates a lexical ('let' or 'const') binding\n// 'none' indicating that the binding should be checked for illegal identifiers, but not for duplicate references\n\npp$2.checkLVal = function(expr, bindingType, checkClashes) {\n  if ( bindingType === void 0 ) bindingType = BIND_NONE;\n\n  switch (expr.type) {\n  case \"Identifier\":\n    if (bindingType === BIND_LEXICAL && expr.name === \"let\")\n      { this.raiseRecoverable(expr.start, \"let is disallowed as a lexically bound name\"); }\n    if (this.strict && this.reservedWordsStrictBind.test(expr.name))\n      { this.raiseRecoverable(expr.start, (bindingType ? \"Binding \" : \"Assigning to \") + expr.name + \" in strict mode\"); }\n    if (checkClashes) {\n      if (has(checkClashes, expr.name))\n        { this.raiseRecoverable(expr.start, \"Argument name clash\"); }\n      checkClashes[expr.name] = true;\n    }\n    if (bindingType !== BIND_NONE && bindingType !== BIND_OUTSIDE) { this.declareName(expr.name, bindingType, expr.start); }\n    break\n\n  case \"MemberExpression\":\n    if (bindingType) { this.raiseRecoverable(expr.start, \"Binding member expression\"); }\n    break\n\n  case \"ObjectPattern\":\n    for (var i = 0, list = expr.properties; i < list.length; i += 1)\n      {\n    var prop = list[i];\n\n    this.checkLVal(prop, bindingType, checkClashes);\n  }\n    break\n\n  case \"Property\":\n    // AssignmentProperty has type === \"Property\"\n    this.checkLVal(expr.value, bindingType, checkClashes);\n    break\n\n  case \"ArrayPattern\":\n    for (var i$1 = 0, list$1 = expr.elements; i$1 < list$1.length; i$1 += 1) {\n      var elem = list$1[i$1];\n\n    if (elem) { this.checkLVal(elem, bindingType, checkClashes); }\n    }\n    break\n\n  case \"AssignmentPattern\":\n    this.checkLVal(expr.left, bindingType, checkClashes);\n    break\n\n  case \"RestElement\":\n    this.checkLVal(expr.argument, bindingType, checkClashes);\n    break\n\n  case \"ParenthesizedExpression\":\n    this.checkLVal(expr.expression, bindingType, checkClashes);\n    break\n\n  default:\n    this.raise(expr.start, (bindingType ? \"Binding\" : \"Assigning to\") + \" rvalue\");\n  }\n};\n\n// A recursive descent parser operates by defining functions for all\n\nvar pp$3 = Parser.prototype;\n\n// Check if property name clashes with already added.\n// Object/class getters and setters are not allowed to clash —\n// either with each other or with an init property — and in\n// strict mode, init properties are also not allowed to be repeated.\n\npp$3.checkPropClash = function(prop, propHash, refDestructuringErrors) {\n  if (this.options.ecmaVersion >= 9 && prop.type === \"SpreadElement\")\n    { return }\n  if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))\n    { return }\n  var key = prop.key;\n  var name;\n  switch (key.type) {\n  case \"Identifier\": name = key.name; break\n  case \"Literal\": name = String(key.value); break\n  default: return\n  }\n  var kind = prop.kind;\n  if (this.options.ecmaVersion >= 6) {\n    if (name === \"__proto__\" && kind === \"init\") {\n      if (propHash.proto) {\n        if (refDestructuringErrors) {\n          if (refDestructuringErrors.doubleProto < 0)\n            { refDestructuringErrors.doubleProto = key.start; }\n          // Backwards-compat kludge. Can be removed in version 6.0\n        } else { this.raiseRecoverable(key.start, \"Redefinition of __proto__ property\"); }\n      }\n      propHash.proto = true;\n    }\n    return\n  }\n  name = \"$\" + name;\n  var other = propHash[name];\n  if (other) {\n    var redefinition;\n    if (kind === \"init\") {\n      redefinition = this.strict && other.init || other.get || other.set;\n    } else {\n      redefinition = other.init || other[kind];\n    }\n    if (redefinition)\n      { this.raiseRecoverable(key.start, \"Redefinition of property\"); }\n  } else {\n    other = propHash[name] = {\n      init: false,\n      get: false,\n      set: false\n    };\n  }\n  other[kind] = true;\n};\n\n// ### Expression parsing\n\n// These nest, from the most general expression type at the top to\n// 'atomic', nondivisible expression types at the bottom. Most of\n// the functions will simply let the function(s) below them parse,\n// and, *if* the syntactic construct they handle is present, wrap\n// the AST node that the inner parser gave them in another node.\n\n// Parse a full expression. The optional arguments are used to\n// forbid the `in` operator (in for loops initalization expressions)\n// and provide reference for storing '=' operator inside shorthand\n// property assignment in contexts where both object expression\n// and object pattern might appear (so it's possible to raise\n// delayed syntax error at correct position).\n\npp$3.parseExpression = function(noIn, refDestructuringErrors) {\n  var startPos = this.start, startLoc = this.startLoc;\n  var expr = this.parseMaybeAssign(noIn, refDestructuringErrors);\n  if (this.type === types.comma) {\n    var node = this.startNodeAt(startPos, startLoc);\n    node.expressions = [expr];\n    while (this.eat(types.comma)) { node.expressions.push(this.parseMaybeAssign(noIn, refDestructuringErrors)); }\n    return this.finishNode(node, \"SequenceExpression\")\n  }\n  return expr\n};\n\n// Parse an assignment expression. This includes applications of\n// operators like `+=`.\n\npp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {\n  if (this.isContextual(\"yield\")) {\n    if (this.inGenerator) { return this.parseYield(noIn) }\n    // The tokenizer will assume an expression is allowed after\n    // `yield`, but this isn't that kind of yield\n    else { this.exprAllowed = false; }\n  }\n\n  var ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1;\n  if (refDestructuringErrors) {\n    oldParenAssign = refDestructuringErrors.parenthesizedAssign;\n    oldTrailingComma = refDestructuringErrors.trailingComma;\n    refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = -1;\n  } else {\n    refDestructuringErrors = new DestructuringErrors;\n    ownDestructuringErrors = true;\n  }\n\n  var startPos = this.start, startLoc = this.startLoc;\n  if (this.type === types.parenL || this.type === types.name)\n    { this.potentialArrowAt = this.start; }\n  var left = this.parseMaybeConditional(noIn, refDestructuringErrors);\n  if (afterLeftParse) { left = afterLeftParse.call(this, left, startPos, startLoc); }\n  if (this.type.isAssign) {\n    var node = this.startNodeAt(startPos, startLoc);\n    node.operator = this.value;\n    node.left = this.type === types.eq ? this.toAssignable(left, false, refDestructuringErrors) : left;\n    if (!ownDestructuringErrors) {\n      refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = refDestructuringErrors.doubleProto = -1;\n    }\n    if (refDestructuringErrors.shorthandAssign >= node.left.start)\n      { refDestructuringErrors.shorthandAssign = -1; } // reset because shorthand default was used correctly\n    this.checkLVal(left);\n    this.next();\n    node.right = this.parseMaybeAssign(noIn);\n    return this.finishNode(node, \"AssignmentExpression\")\n  } else {\n    if (ownDestructuringErrors) { this.checkExpressionErrors(refDestructuringErrors, true); }\n  }\n  if (oldParenAssign > -1) { refDestructuringErrors.parenthesizedAssign = oldParenAssign; }\n  if (oldTrailingComma > -1) { refDestructuringErrors.trailingComma = oldTrailingComma; }\n  return left\n};\n\n// Parse a ternary conditional (`?:`) operator.\n\npp$3.parseMaybeConditional = function(noIn, refDestructuringErrors) {\n  var startPos = this.start, startLoc = this.startLoc;\n  var expr = this.parseExprOps(noIn, refDestructuringErrors);\n  if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }\n  if (this.eat(types.question)) {\n    var node = this.startNodeAt(startPos, startLoc);\n    node.test = expr;\n    node.consequent = this.parseMaybeAssign();\n    this.expect(types.colon);\n    node.alternate = this.parseMaybeAssign(noIn);\n    return this.finishNode(node, \"ConditionalExpression\")\n  }\n  return expr\n};\n\n// Start the precedence parser.\n\npp$3.parseExprOps = function(noIn, refDestructuringErrors) {\n  var startPos = this.start, startLoc = this.startLoc;\n  var expr = this.parseMaybeUnary(refDestructuringErrors, false);\n  if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }\n  return expr.start === startPos && expr.type === \"ArrowFunctionExpression\" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, noIn)\n};\n\n// Parse binary operators with the operator precedence parsing\n// algorithm. `left` is the left-hand side of the operator.\n// `minPrec` provides context that allows the function to stop and\n// defer further parser to one of its callers when it encounters an\n// operator that has a lower precedence than the set it is parsing.\n\npp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {\n  var prec = this.type.binop;\n  if (prec != null && (!noIn || this.type !== types._in)) {\n    if (prec > minPrec) {\n      var logical = this.type === types.logicalOR || this.type === types.logicalAND;\n      var coalesce = this.type === types.coalesce;\n      if (coalesce) {\n        // Handle the precedence of `tt.coalesce` as equal to the range of logical expressions.\n        // In other words, `node.right` shouldn't contain logical expressions in order to check the mixed error.\n        prec = types.logicalAND.binop;\n      }\n      var op = this.value;\n      this.next();\n      var startPos = this.start, startLoc = this.startLoc;\n      var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn);\n      var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical || coalesce);\n      if ((logical && this.type === types.coalesce) || (coalesce && (this.type === types.logicalOR || this.type === types.logicalAND))) {\n        this.raiseRecoverable(this.start, \"Logical expressions and coalesce expressions cannot be mixed. Wrap either by parentheses\");\n      }\n      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)\n    }\n  }\n  return left\n};\n\npp$3.buildBinary = function(startPos, startLoc, left, right, op, logical) {\n  var node = this.startNodeAt(startPos, startLoc);\n  node.left = left;\n  node.operator = op;\n  node.right = right;\n  return this.finishNode(node, logical ? \"LogicalExpression\" : \"BinaryExpression\")\n};\n\n// Parse unary operators, both prefix and postfix.\n\npp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {\n  var startPos = this.start, startLoc = this.startLoc, expr;\n  if (this.isContextual(\"await\") && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction))) {\n    expr = this.parseAwait();\n    sawUnary = true;\n  } else if (this.type.prefix) {\n    var node = this.startNode(), update = this.type === types.incDec;\n    node.operator = this.value;\n    node.prefix = true;\n    this.next();\n    node.argument = this.parseMaybeUnary(null, true);\n    this.checkExpressionErrors(refDestructuringErrors, true);\n    if (update) { this.checkLVal(node.argument); }\n    else if (this.strict && node.operator === \"delete\" &&\n             node.argument.type === \"Identifier\")\n      { this.raiseRecoverable(node.start, \"Deleting local variable in strict mode\"); }\n    else { sawUnary = true; }\n    expr = this.finishNode(node, update ? \"UpdateExpression\" : \"UnaryExpression\");\n  } else {\n    expr = this.parseExprSubscripts(refDestructuringErrors);\n    if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }\n    while (this.type.postfix && !this.canInsertSemicolon()) {\n      var node$1 = this.startNodeAt(startPos, startLoc);\n      node$1.operator = this.value;\n      node$1.prefix = false;\n      node$1.argument = expr;\n      this.checkLVal(expr);\n      this.next();\n      expr = this.finishNode(node$1, \"UpdateExpression\");\n    }\n  }\n\n  if (!sawUnary && this.eat(types.starstar))\n    { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), \"**\", false) }\n  else\n    { return expr }\n};\n\n// Parse call, dot, and `[]`-subscript expressions.\n\npp$3.parseExprSubscripts = function(refDestructuringErrors) {\n  var startPos = this.start, startLoc = this.startLoc;\n  var expr = this.parseExprAtom(refDestructuringErrors);\n  if (expr.type === \"ArrowFunctionExpression\" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== \")\")\n    { return expr }\n  var result = this.parseSubscripts(expr, startPos, startLoc);\n  if (refDestructuringErrors && result.type === \"MemberExpression\") {\n    if (refDestructuringErrors.parenthesizedAssign >= result.start) { refDestructuringErrors.parenthesizedAssign = -1; }\n    if (refDestructuringErrors.parenthesizedBind >= result.start) { refDestructuringErrors.parenthesizedBind = -1; }\n  }\n  return result\n};\n\npp$3.parseSubscripts = function(base, startPos, startLoc, noCalls) {\n  var maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === \"Identifier\" && base.name === \"async\" &&\n      this.lastTokEnd === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 &&\n      this.potentialArrowAt === base.start;\n  while (true) {\n    var element = this.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow);\n    if (element === base || element.type === \"ArrowFunctionExpression\") { return element }\n    base = element;\n  }\n};\n\npp$3.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow) {\n  var computed = this.eat(types.bracketL);\n  if (computed || this.eat(types.dot)) {\n    var node = this.startNodeAt(startPos, startLoc);\n    node.object = base;\n    node.property = computed ? this.parseExpression() : this.parseIdent(this.options.allowReserved !== \"never\");\n    node.computed = !!computed;\n    if (computed) { this.expect(types.bracketR); }\n    base = this.finishNode(node, \"MemberExpression\");\n  } else if (!noCalls && this.eat(types.parenL)) {\n    var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;\n    this.yieldPos = 0;\n    this.awaitPos = 0;\n    this.awaitIdentPos = 0;\n    var exprList = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8, false, refDestructuringErrors);\n    if (maybeAsyncArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {\n      this.checkPatternErrors(refDestructuringErrors, false);\n      this.checkYieldAwaitInDefaultParams();\n      if (this.awaitIdentPos > 0)\n        { this.raise(this.awaitIdentPos, \"Cannot use 'await' as identifier inside an async function\"); }\n      this.yieldPos = oldYieldPos;\n      this.awaitPos = oldAwaitPos;\n      this.awaitIdentPos = oldAwaitIdentPos;\n      return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, true)\n    }\n    this.checkExpressionErrors(refDestructuringErrors, true);\n    this.yieldPos = oldYieldPos || this.yieldPos;\n    this.awaitPos = oldAwaitPos || this.awaitPos;\n    this.awaitIdentPos = oldAwaitIdentPos || this.awaitIdentPos;\n    var node$1 = this.startNodeAt(startPos, startLoc);\n    node$1.callee = base;\n    node$1.arguments = exprList;\n    base = this.finishNode(node$1, \"CallExpression\");\n  } else if (this.type === types.backQuote) {\n    var node$2 = this.startNodeAt(startPos, startLoc);\n    node$2.tag = base;\n    node$2.quasi = this.parseTemplate({isTagged: true});\n    base = this.finishNode(node$2, \"TaggedTemplateExpression\");\n  }\n  return base\n};\n\n// Parse an atomic expression — either a single token that is an\n// expression, an expression started by a keyword like `function` or\n// `new`, or an expression wrapped in punctuation like `()`, `[]`,\n// or `{}`.\n\npp$3.parseExprAtom = function(refDestructuringErrors) {\n  // If a division operator appears in an expression position, the\n  // tokenizer got confused, and we force it to read a regexp instead.\n  if (this.type === types.slash) { this.readRegexp(); }\n\n  var node, canBeArrow = this.potentialArrowAt === this.start;\n  switch (this.type) {\n  case types._super:\n    if (!this.allowSuper)\n      { this.raise(this.start, \"'super' keyword outside a method\"); }\n    node = this.startNode();\n    this.next();\n    if (this.type === types.parenL && !this.allowDirectSuper)\n      { this.raise(node.start, \"super() call outside constructor of a subclass\"); }\n    // The `super` keyword can appear at below:\n    // SuperProperty:\n    //     super [ Expression ]\n    //     super . IdentifierName\n    // SuperCall:\n    //     super ( Arguments )\n    if (this.type !== types.dot && this.type !== types.bracketL && this.type !== types.parenL)\n      { this.unexpected(); }\n    return this.finishNode(node, \"Super\")\n\n  case types._this:\n    node = this.startNode();\n    this.next();\n    return this.finishNode(node, \"ThisExpression\")\n\n  case types.name:\n    var startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc;\n    var id = this.parseIdent(false);\n    if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === \"async\" && !this.canInsertSemicolon() && this.eat(types._function))\n      { return this.parseFunction(this.startNodeAt(startPos, startLoc), 0, false, true) }\n    if (canBeArrow && !this.canInsertSemicolon()) {\n      if (this.eat(types.arrow))\n        { return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false) }\n      if (this.options.ecmaVersion >= 8 && id.name === \"async\" && this.type === types.name && !containsEsc) {\n        id = this.parseIdent(false);\n        if (this.canInsertSemicolon() || !this.eat(types.arrow))\n          { this.unexpected(); }\n        return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true)\n      }\n    }\n    return id\n\n  case types.regexp:\n    var value = this.value;\n    node = this.parseLiteral(value.value);\n    node.regex = {pattern: value.pattern, flags: value.flags};\n    return node\n\n  case types.num: case types.string:\n    return this.parseLiteral(this.value)\n\n  case types._null: case types._true: case types._false:\n    node = this.startNode();\n    node.value = this.type === types._null ? null : this.type === types._true;\n    node.raw = this.type.keyword;\n    this.next();\n    return this.finishNode(node, \"Literal\")\n\n  case types.parenL:\n    var start = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow);\n    if (refDestructuringErrors) {\n      if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr))\n        { refDestructuringErrors.parenthesizedAssign = start; }\n      if (refDestructuringErrors.parenthesizedBind < 0)\n        { refDestructuringErrors.parenthesizedBind = start; }\n    }\n    return expr\n\n  case types.bracketL:\n    node = this.startNode();\n    this.next();\n    node.elements = this.parseExprList(types.bracketR, true, true, refDestructuringErrors);\n    return this.finishNode(node, \"ArrayExpression\")\n\n  case types.braceL:\n    return this.parseObj(false, refDestructuringErrors)\n\n  case types._function:\n    node = this.startNode();\n    this.next();\n    return this.parseFunction(node, 0)\n\n  case types._class:\n    return this.parseClass(this.startNode(), false)\n\n  case types._new:\n    return this.parseNew()\n\n  case types.backQuote:\n    return this.parseTemplate()\n\n  case types._import:\n    if (this.options.ecmaVersion >= 11) {\n      return this.parseExprImport()\n    } else {\n      return this.unexpected()\n    }\n\n  default:\n    this.unexpected();\n  }\n};\n\npp$3.parseExprImport = function() {\n  var node = this.startNode();\n\n  // Consume `import` as an identifier for `import.meta`.\n  // Because `this.parseIdent(true)` doesn't check escape sequences, it needs the check of `this.containsEsc`.\n  if (this.containsEsc) { this.raiseRecoverable(this.start, \"Escape sequence in keyword import\"); }\n  var meta = this.parseIdent(true);\n\n  switch (this.type) {\n  case types.parenL:\n    return this.parseDynamicImport(node)\n  case types.dot:\n    node.meta = meta;\n    return this.parseImportMeta(node)\n  default:\n    this.unexpected();\n  }\n};\n\npp$3.parseDynamicImport = function(node) {\n  this.next(); // skip `(`\n\n  // Parse node.source.\n  node.source = this.parseMaybeAssign();\n\n  // Verify ending.\n  if (!this.eat(types.parenR)) {\n    var errorPos = this.start;\n    if (this.eat(types.comma) && this.eat(types.parenR)) {\n      this.raiseRecoverable(errorPos, \"Trailing comma is not allowed in import()\");\n    } else {\n      this.unexpected(errorPos);\n    }\n  }\n\n  return this.finishNode(node, \"ImportExpression\")\n};\n\npp$3.parseImportMeta = function(node) {\n  this.next(); // skip `.`\n\n  var containsEsc = this.containsEsc;\n  node.property = this.parseIdent(true);\n\n  if (node.property.name !== \"meta\")\n    { this.raiseRecoverable(node.property.start, \"The only valid meta property for import is 'import.meta'\"); }\n  if (containsEsc)\n    { this.raiseRecoverable(node.start, \"'import.meta' must not contain escaped characters\"); }\n  if (this.options.sourceType !== \"module\")\n    { this.raiseRecoverable(node.start, \"Cannot use 'import.meta' outside a module\"); }\n\n  return this.finishNode(node, \"MetaProperty\")\n};\n\npp$3.parseLiteral = function(value) {\n  var node = this.startNode();\n  node.value = value;\n  node.raw = this.input.slice(this.start, this.end);\n  if (node.raw.charCodeAt(node.raw.length - 1) === 110) { node.bigint = node.raw.slice(0, -1); }\n  this.next();\n  return this.finishNode(node, \"Literal\")\n};\n\npp$3.parseParenExpression = function() {\n  this.expect(types.parenL);\n  var val = this.parseExpression();\n  this.expect(types.parenR);\n  return val\n};\n\npp$3.parseParenAndDistinguishExpression = function(canBeArrow) {\n  var startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8;\n  if (this.options.ecmaVersion >= 6) {\n    this.next();\n\n    var innerStartPos = this.start, innerStartLoc = this.startLoc;\n    var exprList = [], first = true, lastIsComma = false;\n    var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart;\n    this.yieldPos = 0;\n    this.awaitPos = 0;\n    // Do not save awaitIdentPos to allow checking awaits nested in parameters\n    while (this.type !== types.parenR) {\n      first ? first = false : this.expect(types.comma);\n      if (allowTrailingComma && this.afterTrailingComma(types.parenR, true)) {\n        lastIsComma = true;\n        break\n      } else if (this.type === types.ellipsis) {\n        spreadStart = this.start;\n        exprList.push(this.parseParenItem(this.parseRestBinding()));\n        if (this.type === types.comma) { this.raise(this.start, \"Comma is not permitted after the rest element\"); }\n        break\n      } else {\n        exprList.push(this.parseMaybeAssign(false, refDestructuringErrors, this.parseParenItem));\n      }\n    }\n    var innerEndPos = this.start, innerEndLoc = this.startLoc;\n    this.expect(types.parenR);\n\n    if (canBeArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {\n      this.checkPatternErrors(refDestructuringErrors, false);\n      this.checkYieldAwaitInDefaultParams();\n      this.yieldPos = oldYieldPos;\n      this.awaitPos = oldAwaitPos;\n      return this.parseParenArrowList(startPos, startLoc, exprList)\n    }\n\n    if (!exprList.length || lastIsComma) { this.unexpected(this.lastTokStart); }\n    if (spreadStart) { this.unexpected(spreadStart); }\n    this.checkExpressionErrors(refDestructuringErrors, true);\n    this.yieldPos = oldYieldPos || this.yieldPos;\n    this.awaitPos = oldAwaitPos || this.awaitPos;\n\n    if (exprList.length > 1) {\n      val = this.startNodeAt(innerStartPos, innerStartLoc);\n      val.expressions = exprList;\n      this.finishNodeAt(val, \"SequenceExpression\", innerEndPos, innerEndLoc);\n    } else {\n      val = exprList[0];\n    }\n  } else {\n    val = this.parseParenExpression();\n  }\n\n  if (this.options.preserveParens) {\n    var par = this.startNodeAt(startPos, startLoc);\n    par.expression = val;\n    return this.finishNode(par, \"ParenthesizedExpression\")\n  } else {\n    return val\n  }\n};\n\npp$3.parseParenItem = function(item) {\n  return item\n};\n\npp$3.parseParenArrowList = function(startPos, startLoc, exprList) {\n  return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList)\n};\n\n// New's precedence is slightly tricky. It must allow its argument to\n// be a `[]` or dot subscript expression, but not a call — at least,\n// not without wrapping it in parentheses. Thus, it uses the noCalls\n// argument to parseSubscripts to prevent it from consuming the\n// argument list.\n\nvar empty$1 = [];\n\npp$3.parseNew = function() {\n  if (this.containsEsc) { this.raiseRecoverable(this.start, \"Escape sequence in keyword new\"); }\n  var node = this.startNode();\n  var meta = this.parseIdent(true);\n  if (this.options.ecmaVersion >= 6 && this.eat(types.dot)) {\n    node.meta = meta;\n    var containsEsc = this.containsEsc;\n    node.property = this.parseIdent(true);\n    if (node.property.name !== \"target\")\n      { this.raiseRecoverable(node.property.start, \"The only valid meta property for new is 'new.target'\"); }\n    if (containsEsc)\n      { this.raiseRecoverable(node.start, \"'new.target' must not contain escaped characters\"); }\n    if (!this.inNonArrowFunction())\n      { this.raiseRecoverable(node.start, \"'new.target' can only be used in functions\"); }\n    return this.finishNode(node, \"MetaProperty\")\n  }\n  var startPos = this.start, startLoc = this.startLoc, isImport = this.type === types._import;\n  node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);\n  if (isImport && node.callee.type === \"ImportExpression\") {\n    this.raise(startPos, \"Cannot use new with import()\");\n  }\n  if (this.eat(types.parenL)) { node.arguments = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8, false); }\n  else { node.arguments = empty$1; }\n  return this.finishNode(node, \"NewExpression\")\n};\n\n// Parse template expression.\n\npp$3.parseTemplateElement = function(ref) {\n  var isTagged = ref.isTagged;\n\n  var elem = this.startNode();\n  if (this.type === types.invalidTemplate) {\n    if (!isTagged) {\n      this.raiseRecoverable(this.start, \"Bad escape sequence in untagged template literal\");\n    }\n    elem.value = {\n      raw: this.value,\n      cooked: null\n    };\n  } else {\n    elem.value = {\n      raw: this.input.slice(this.start, this.end).replace(/\\r\\n?/g, \"\\n\"),\n      cooked: this.value\n    };\n  }\n  this.next();\n  elem.tail = this.type === types.backQuote;\n  return this.finishNode(elem, \"TemplateElement\")\n};\n\npp$3.parseTemplate = function(ref) {\n  if ( ref === void 0 ) ref = {};\n  var isTagged = ref.isTagged; if ( isTagged === void 0 ) isTagged = false;\n\n  var node = this.startNode();\n  this.next();\n  node.expressions = [];\n  var curElt = this.parseTemplateElement({isTagged: isTagged});\n  node.quasis = [curElt];\n  while (!curElt.tail) {\n    if (this.type === types.eof) { this.raise(this.pos, \"Unterminated template literal\"); }\n    this.expect(types.dollarBraceL);\n    node.expressions.push(this.parseExpression());\n    this.expect(types.braceR);\n    node.quasis.push(curElt = this.parseTemplateElement({isTagged: isTagged}));\n  }\n  this.next();\n  return this.finishNode(node, \"TemplateLiteral\")\n};\n\npp$3.isAsyncProp = function(prop) {\n  return !prop.computed && prop.key.type === \"Identifier\" && prop.key.name === \"async\" &&\n    (this.type === types.name || this.type === types.num || this.type === types.string || this.type === types.bracketL || this.type.keyword || (this.options.ecmaVersion >= 9 && this.type === types.star)) &&\n    !lineBreak.test(this.input.slice(this.lastTokEnd, this.start))\n};\n\n// Parse an object literal or binding pattern.\n\npp$3.parseObj = function(isPattern, refDestructuringErrors) {\n  var node = this.startNode(), first = true, propHash = {};\n  node.properties = [];\n  this.next();\n  while (!this.eat(types.braceR)) {\n    if (!first) {\n      this.expect(types.comma);\n      if (this.options.ecmaVersion >= 5 && this.afterTrailingComma(types.braceR)) { break }\n    } else { first = false; }\n\n    var prop = this.parseProperty(isPattern, refDestructuringErrors);\n    if (!isPattern) { this.checkPropClash(prop, propHash, refDestructuringErrors); }\n    node.properties.push(prop);\n  }\n  return this.finishNode(node, isPattern ? \"ObjectPattern\" : \"ObjectExpression\")\n};\n\npp$3.parseProperty = function(isPattern, refDestructuringErrors) {\n  var prop = this.startNode(), isGenerator, isAsync, startPos, startLoc;\n  if (this.options.ecmaVersion >= 9 && this.eat(types.ellipsis)) {\n    if (isPattern) {\n      prop.argument = this.parseIdent(false);\n      if (this.type === types.comma) {\n        this.raise(this.start, \"Comma is not permitted after the rest element\");\n      }\n      return this.finishNode(prop, \"RestElement\")\n    }\n    // To disallow parenthesized identifier via `this.toAssignable()`.\n    if (this.type === types.parenL && refDestructuringErrors) {\n      if (refDestructuringErrors.parenthesizedAssign < 0) {\n        refDestructuringErrors.parenthesizedAssign = this.start;\n      }\n      if (refDestructuringErrors.parenthesizedBind < 0) {\n        refDestructuringErrors.parenthesizedBind = this.start;\n      }\n    }\n    // Parse argument.\n    prop.argument = this.parseMaybeAssign(false, refDestructuringErrors);\n    // To disallow trailing comma via `this.toAssignable()`.\n    if (this.type === types.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {\n      refDestructuringErrors.trailingComma = this.start;\n    }\n    // Finish\n    return this.finishNode(prop, \"SpreadElement\")\n  }\n  if (this.options.ecmaVersion >= 6) {\n    prop.method = false;\n    prop.shorthand = false;\n    if (isPattern || refDestructuringErrors) {\n      startPos = this.start;\n      startLoc = this.startLoc;\n    }\n    if (!isPattern)\n      { isGenerator = this.eat(types.star); }\n  }\n  var containsEsc = this.containsEsc;\n  this.parsePropertyName(prop);\n  if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) {\n    isAsync = true;\n    isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);\n    this.parsePropertyName(prop, refDestructuringErrors);\n  } else {\n    isAsync = false;\n  }\n  this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc);\n  return this.finishNode(prop, \"Property\")\n};\n\npp$3.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) {\n  if ((isGenerator || isAsync) && this.type === types.colon)\n    { this.unexpected(); }\n\n  if (this.eat(types.colon)) {\n    prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors);\n    prop.kind = \"init\";\n  } else if (this.options.ecmaVersion >= 6 && this.type === types.parenL) {\n    if (isPattern) { this.unexpected(); }\n    prop.kind = \"init\";\n    prop.method = true;\n    prop.value = this.parseMethod(isGenerator, isAsync);\n  } else if (!isPattern && !containsEsc &&\n             this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === \"Identifier\" &&\n             (prop.key.name === \"get\" || prop.key.name === \"set\") &&\n             (this.type !== types.comma && this.type !== types.braceR)) {\n    if (isGenerator || isAsync) { this.unexpected(); }\n    prop.kind = prop.key.name;\n    this.parsePropertyName(prop);\n    prop.value = this.parseMethod(false);\n    var paramCount = prop.kind === \"get\" ? 0 : 1;\n    if (prop.value.params.length !== paramCount) {\n      var start = prop.value.start;\n      if (prop.kind === \"get\")\n        { this.raiseRecoverable(start, \"getter should have no params\"); }\n      else\n        { this.raiseRecoverable(start, \"setter should have exactly one param\"); }\n    } else {\n      if (prop.kind === \"set\" && prop.value.params[0].type === \"RestElement\")\n        { this.raiseRecoverable(prop.value.params[0].start, \"Setter cannot use rest params\"); }\n    }\n  } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === \"Identifier\") {\n    if (isGenerator || isAsync) { this.unexpected(); }\n    this.checkUnreserved(prop.key);\n    if (prop.key.name === \"await\" && !this.awaitIdentPos)\n      { this.awaitIdentPos = startPos; }\n    prop.kind = \"init\";\n    if (isPattern) {\n      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);\n    } else if (this.type === types.eq && refDestructuringErrors) {\n      if (refDestructuringErrors.shorthandAssign < 0)\n        { refDestructuringErrors.shorthandAssign = this.start; }\n      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);\n    } else {\n      prop.value = prop.key;\n    }\n    prop.shorthand = true;\n  } else { this.unexpected(); }\n};\n\npp$3.parsePropertyName = function(prop) {\n  if (this.options.ecmaVersion >= 6) {\n    if (this.eat(types.bracketL)) {\n      prop.computed = true;\n      prop.key = this.parseMaybeAssign();\n      this.expect(types.bracketR);\n      return prop.key\n    } else {\n      prop.computed = false;\n    }\n  }\n  return prop.key = this.type === types.num || this.type === types.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== \"never\")\n};\n\n// Initialize empty function node.\n\npp$3.initFunction = function(node) {\n  node.id = null;\n  if (this.options.ecmaVersion >= 6) { node.generator = node.expression = false; }\n  if (this.options.ecmaVersion >= 8) { node.async = false; }\n};\n\n// Parse object or class method.\n\npp$3.parseMethod = function(isGenerator, isAsync, allowDirectSuper) {\n  var node = this.startNode(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;\n\n  this.initFunction(node);\n  if (this.options.ecmaVersion >= 6)\n    { node.generator = isGenerator; }\n  if (this.options.ecmaVersion >= 8)\n    { node.async = !!isAsync; }\n\n  this.yieldPos = 0;\n  this.awaitPos = 0;\n  this.awaitIdentPos = 0;\n  this.enterScope(functionFlags(isAsync, node.generator) | SCOPE_SUPER | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));\n\n  this.expect(types.parenL);\n  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);\n  this.checkYieldAwaitInDefaultParams();\n  this.parseFunctionBody(node, false, true);\n\n  this.yieldPos = oldYieldPos;\n  this.awaitPos = oldAwaitPos;\n  this.awaitIdentPos = oldAwaitIdentPos;\n  return this.finishNode(node, \"FunctionExpression\")\n};\n\n// Parse arrow function expression with given parameters.\n\npp$3.parseArrowExpression = function(node, params, isAsync) {\n  var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;\n\n  this.enterScope(functionFlags(isAsync, false) | SCOPE_ARROW);\n  this.initFunction(node);\n  if (this.options.ecmaVersion >= 8) { node.async = !!isAsync; }\n\n  this.yieldPos = 0;\n  this.awaitPos = 0;\n  this.awaitIdentPos = 0;\n\n  node.params = this.toAssignableList(params, true);\n  this.parseFunctionBody(node, true, false);\n\n  this.yieldPos = oldYieldPos;\n  this.awaitPos = oldAwaitPos;\n  this.awaitIdentPos = oldAwaitIdentPos;\n  return this.finishNode(node, \"ArrowFunctionExpression\")\n};\n\n// Parse function body and check parameters.\n\npp$3.parseFunctionBody = function(node, isArrowFunction, isMethod) {\n  var isExpression = isArrowFunction && this.type !== types.braceL;\n  var oldStrict = this.strict, useStrict = false;\n\n  if (isExpression) {\n    node.body = this.parseMaybeAssign();\n    node.expression = true;\n    this.checkParams(node, false);\n  } else {\n    var nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params);\n    if (!oldStrict || nonSimple) {\n      useStrict = this.strictDirective(this.end);\n      // If this is a strict mode function, verify that argument names\n      // are not repeated, and it does not try to bind the words `eval`\n      // or `arguments`.\n      if (useStrict && nonSimple)\n        { this.raiseRecoverable(node.start, \"Illegal 'use strict' directive in function with non-simple parameter list\"); }\n    }\n    // Start a new scope with regard to labels and the `inFunction`\n    // flag (restore them to their old value afterwards).\n    var oldLabels = this.labels;\n    this.labels = [];\n    if (useStrict) { this.strict = true; }\n\n    // Add the params to varDeclaredNames to ensure that an error is thrown\n    // if a let/const declaration in the function clashes with one of the params.\n    this.checkParams(node, !oldStrict && !useStrict && !isArrowFunction && !isMethod && this.isSimpleParamList(node.params));\n    // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'\n    if (this.strict && node.id) { this.checkLVal(node.id, BIND_OUTSIDE); }\n    node.body = this.parseBlock(false, undefined, useStrict && !oldStrict);\n    node.expression = false;\n    this.adaptDirectivePrologue(node.body.body);\n    this.labels = oldLabels;\n  }\n  this.exitScope();\n};\n\npp$3.isSimpleParamList = function(params) {\n  for (var i = 0, list = params; i < list.length; i += 1)\n    {\n    var param = list[i];\n\n    if (param.type !== \"Identifier\") { return false\n  } }\n  return true\n};\n\n// Checks function params for various disallowed patterns such as using \"eval\"\n// or \"arguments\" and duplicate parameters.\n\npp$3.checkParams = function(node, allowDuplicates) {\n  var nameHash = {};\n  for (var i = 0, list = node.params; i < list.length; i += 1)\n    {\n    var param = list[i];\n\n    this.checkLVal(param, BIND_VAR, allowDuplicates ? null : nameHash);\n  }\n};\n\n// Parses a comma-separated list of expressions, and returns them as\n// an array. `close` is the token type that ends the list, and\n// `allowEmpty` can be turned on to allow subsequent commas with\n// nothing in between them to be parsed as `null` (which is needed\n// for array literals).\n\npp$3.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {\n  var elts = [], first = true;\n  while (!this.eat(close)) {\n    if (!first) {\n      this.expect(types.comma);\n      if (allowTrailingComma && this.afterTrailingComma(close)) { break }\n    } else { first = false; }\n\n    var elt = (void 0);\n    if (allowEmpty && this.type === types.comma)\n      { elt = null; }\n    else if (this.type === types.ellipsis) {\n      elt = this.parseSpread(refDestructuringErrors);\n      if (refDestructuringErrors && this.type === types.comma && refDestructuringErrors.trailingComma < 0)\n        { refDestructuringErrors.trailingComma = this.start; }\n    } else {\n      elt = this.parseMaybeAssign(false, refDestructuringErrors);\n    }\n    elts.push(elt);\n  }\n  return elts\n};\n\npp$3.checkUnreserved = function(ref) {\n  var start = ref.start;\n  var end = ref.end;\n  var name = ref.name;\n\n  if (this.inGenerator && name === \"yield\")\n    { this.raiseRecoverable(start, \"Cannot use 'yield' as identifier inside a generator\"); }\n  if (this.inAsync && name === \"await\")\n    { this.raiseRecoverable(start, \"Cannot use 'await' as identifier inside an async function\"); }\n  if (this.keywords.test(name))\n    { this.raise(start, (\"Unexpected keyword '\" + name + \"'\")); }\n  if (this.options.ecmaVersion < 6 &&\n    this.input.slice(start, end).indexOf(\"\\\\\") !== -1) { return }\n  var re = this.strict ? this.reservedWordsStrict : this.reservedWords;\n  if (re.test(name)) {\n    if (!this.inAsync && name === \"await\")\n      { this.raiseRecoverable(start, \"Cannot use keyword 'await' outside an async function\"); }\n    this.raiseRecoverable(start, (\"The keyword '\" + name + \"' is reserved\"));\n  }\n};\n\n// Parse the next token as an identifier. If `liberal` is true (used\n// when parsing properties), it will also convert keywords into\n// identifiers.\n\npp$3.parseIdent = function(liberal, isBinding) {\n  var node = this.startNode();\n  if (this.type === types.name) {\n    node.name = this.value;\n  } else if (this.type.keyword) {\n    node.name = this.type.keyword;\n\n    // To fix https://github.com/acornjs/acorn/issues/575\n    // `class` and `function` keywords push new context into this.context.\n    // But there is no chance to pop the context if the keyword is consumed as an identifier such as a property name.\n    // If the previous token is a dot, this does not apply because the context-managing code already ignored the keyword\n    if ((node.name === \"class\" || node.name === \"function\") &&\n        (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {\n      this.context.pop();\n    }\n  } else {\n    this.unexpected();\n  }\n  this.next(!!liberal);\n  this.finishNode(node, \"Identifier\");\n  if (!liberal) {\n    this.checkUnreserved(node);\n    if (node.name === \"await\" && !this.awaitIdentPos)\n      { this.awaitIdentPos = node.start; }\n  }\n  return node\n};\n\n// Parses yield expression inside generator.\n\npp$3.parseYield = function(noIn) {\n  if (!this.yieldPos) { this.yieldPos = this.start; }\n\n  var node = this.startNode();\n  this.next();\n  if (this.type === types.semi || this.canInsertSemicolon() || (this.type !== types.star && !this.type.startsExpr)) {\n    node.delegate = false;\n    node.argument = null;\n  } else {\n    node.delegate = this.eat(types.star);\n    node.argument = this.parseMaybeAssign(noIn);\n  }\n  return this.finishNode(node, \"YieldExpression\")\n};\n\npp$3.parseAwait = function() {\n  if (!this.awaitPos) { this.awaitPos = this.start; }\n\n  var node = this.startNode();\n  this.next();\n  node.argument = this.parseMaybeUnary(null, false);\n  return this.finishNode(node, \"AwaitExpression\")\n};\n\nvar pp$4 = Parser.prototype;\n\n// This function is used to raise exceptions on parse errors. It\n// takes an offset integer (into the current `input`) to indicate\n// the location of the error, attaches the position to the end\n// of the error message, and then raises a `SyntaxError` with that\n// message.\n\npp$4.raise = function(pos, message) {\n  var loc = getLineInfo(this.input, pos);\n  message += \" (\" + loc.line + \":\" + loc.column + \")\";\n  var err = new SyntaxError(message);\n  err.pos = pos; err.loc = loc; err.raisedAt = this.pos;\n  throw err\n};\n\npp$4.raiseRecoverable = pp$4.raise;\n\npp$4.curPosition = function() {\n  if (this.options.locations) {\n    return new Position(this.curLine, this.pos - this.lineStart)\n  }\n};\n\nvar pp$5 = Parser.prototype;\n\nvar Scope$2 = function Scope(flags) {\n  this.flags = flags;\n  // A list of var-declared names in the current lexical scope\n  this.var = [];\n  // A list of lexically-declared names in the current lexical scope\n  this.lexical = [];\n  // A list of lexically-declared FunctionDeclaration names in the current lexical scope\n  this.functions = [];\n};\n\n// The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.\n\npp$5.enterScope = function(flags) {\n  this.scopeStack.push(new Scope$2(flags));\n};\n\npp$5.exitScope = function() {\n  this.scopeStack.pop();\n};\n\n// The spec says:\n// > At the top level of a function, or script, function declarations are\n// > treated like var declarations rather than like lexical declarations.\npp$5.treatFunctionsAsVarInScope = function(scope) {\n  return (scope.flags & SCOPE_FUNCTION) || !this.inModule && (scope.flags & SCOPE_TOP)\n};\n\npp$5.declareName = function(name, bindingType, pos) {\n  var redeclared = false;\n  if (bindingType === BIND_LEXICAL) {\n    var scope = this.currentScope();\n    redeclared = scope.lexical.indexOf(name) > -1 || scope.functions.indexOf(name) > -1 || scope.var.indexOf(name) > -1;\n    scope.lexical.push(name);\n    if (this.inModule && (scope.flags & SCOPE_TOP))\n      { delete this.undefinedExports[name]; }\n  } else if (bindingType === BIND_SIMPLE_CATCH) {\n    var scope$1 = this.currentScope();\n    scope$1.lexical.push(name);\n  } else if (bindingType === BIND_FUNCTION) {\n    var scope$2 = this.currentScope();\n    if (this.treatFunctionsAsVar)\n      { redeclared = scope$2.lexical.indexOf(name) > -1; }\n    else\n      { redeclared = scope$2.lexical.indexOf(name) > -1 || scope$2.var.indexOf(name) > -1; }\n    scope$2.functions.push(name);\n  } else {\n    for (var i = this.scopeStack.length - 1; i >= 0; --i) {\n      var scope$3 = this.scopeStack[i];\n      if (scope$3.lexical.indexOf(name) > -1 && !((scope$3.flags & SCOPE_SIMPLE_CATCH) && scope$3.lexical[0] === name) ||\n          !this.treatFunctionsAsVarInScope(scope$3) && scope$3.functions.indexOf(name) > -1) {\n        redeclared = true;\n        break\n      }\n      scope$3.var.push(name);\n      if (this.inModule && (scope$3.flags & SCOPE_TOP))\n        { delete this.undefinedExports[name]; }\n      if (scope$3.flags & SCOPE_VAR) { break }\n    }\n  }\n  if (redeclared) { this.raiseRecoverable(pos, (\"Identifier '\" + name + \"' has already been declared\")); }\n};\n\npp$5.checkLocalExport = function(id) {\n  // scope.functions must be empty as Module code is always strict.\n  if (this.scopeStack[0].lexical.indexOf(id.name) === -1 &&\n      this.scopeStack[0].var.indexOf(id.name) === -1) {\n    this.undefinedExports[id.name] = id;\n  }\n};\n\npp$5.currentScope = function() {\n  return this.scopeStack[this.scopeStack.length - 1]\n};\n\npp$5.currentVarScope = function() {\n  for (var i = this.scopeStack.length - 1;; i--) {\n    var scope = this.scopeStack[i];\n    if (scope.flags & SCOPE_VAR) { return scope }\n  }\n};\n\n// Could be useful for `this`, `new.target`, `super()`, `super.property`, and `super[property]`.\npp$5.currentThisScope = function() {\n  for (var i = this.scopeStack.length - 1;; i--) {\n    var scope = this.scopeStack[i];\n    if (scope.flags & SCOPE_VAR && !(scope.flags & SCOPE_ARROW)) { return scope }\n  }\n};\n\nvar Node = function Node(parser, pos, loc) {\n  this.type = \"\";\n  this.start = pos;\n  this.end = 0;\n  if (parser.options.locations)\n    { this.loc = new SourceLocation(parser, loc); }\n  if (parser.options.directSourceFile)\n    { this.sourceFile = parser.options.directSourceFile; }\n  if (parser.options.ranges)\n    { this.range = [pos, 0]; }\n};\n\n// Start an AST node, attaching a start offset.\n\nvar pp$6 = Parser.prototype;\n\npp$6.startNode = function() {\n  return new Node(this, this.start, this.startLoc)\n};\n\npp$6.startNodeAt = function(pos, loc) {\n  return new Node(this, pos, loc)\n};\n\n// Finish an AST node, adding `type` and `end` properties.\n\nfunction finishNodeAt(node, type, pos, loc) {\n  node.type = type;\n  node.end = pos;\n  if (this.options.locations)\n    { node.loc.end = loc; }\n  if (this.options.ranges)\n    { node.range[1] = pos; }\n  return node\n}\n\npp$6.finishNode = function(node, type) {\n  return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)\n};\n\n// Finish node at given position\n\npp$6.finishNodeAt = function(node, type, pos, loc) {\n  return finishNodeAt.call(this, node, type, pos, loc)\n};\n\n// The algorithm used to determine whether a regexp can appear at a\n\nvar TokContext = function TokContext(token, isExpr, preserveSpace, override, generator) {\n  this.token = token;\n  this.isExpr = !!isExpr;\n  this.preserveSpace = !!preserveSpace;\n  this.override = override;\n  this.generator = !!generator;\n};\n\nvar types$1 = {\n  b_stat: new TokContext(\"{\", false),\n  b_expr: new TokContext(\"{\", true),\n  b_tmpl: new TokContext(\"${\", false),\n  p_stat: new TokContext(\"(\", false),\n  p_expr: new TokContext(\"(\", true),\n  q_tmpl: new TokContext(\"`\", true, true, function (p) { return p.tryReadTemplateToken(); }),\n  f_stat: new TokContext(\"function\", false),\n  f_expr: new TokContext(\"function\", true),\n  f_expr_gen: new TokContext(\"function\", true, false, null, true),\n  f_gen: new TokContext(\"function\", false, false, null, true)\n};\n\nvar pp$7 = Parser.prototype;\n\npp$7.initialContext = function() {\n  return [types$1.b_stat]\n};\n\npp$7.braceIsBlock = function(prevType) {\n  var parent = this.curContext();\n  if (parent === types$1.f_expr || parent === types$1.f_stat)\n    { return true }\n  if (prevType === types.colon && (parent === types$1.b_stat || parent === types$1.b_expr))\n    { return !parent.isExpr }\n\n  // The check for `tt.name && exprAllowed` detects whether we are\n  // after a `yield` or `of` construct. See the `updateContext` for\n  // `tt.name`.\n  if (prevType === types._return || prevType === types.name && this.exprAllowed)\n    { return lineBreak.test(this.input.slice(this.lastTokEnd, this.start)) }\n  if (prevType === types._else || prevType === types.semi || prevType === types.eof || prevType === types.parenR || prevType === types.arrow)\n    { return true }\n  if (prevType === types.braceL)\n    { return parent === types$1.b_stat }\n  if (prevType === types._var || prevType === types._const || prevType === types.name)\n    { return false }\n  return !this.exprAllowed\n};\n\npp$7.inGeneratorContext = function() {\n  for (var i = this.context.length - 1; i >= 1; i--) {\n    var context = this.context[i];\n    if (context.token === \"function\")\n      { return context.generator }\n  }\n  return false\n};\n\npp$7.updateContext = function(prevType) {\n  var update, type = this.type;\n  if (type.keyword && prevType === types.dot)\n    { this.exprAllowed = false; }\n  else if (update = type.updateContext)\n    { update.call(this, prevType); }\n  else\n    { this.exprAllowed = type.beforeExpr; }\n};\n\n// Token-specific context update code\n\ntypes.parenR.updateContext = types.braceR.updateContext = function() {\n  if (this.context.length === 1) {\n    this.exprAllowed = true;\n    return\n  }\n  var out = this.context.pop();\n  if (out === types$1.b_stat && this.curContext().token === \"function\") {\n    out = this.context.pop();\n  }\n  this.exprAllowed = !out.isExpr;\n};\n\ntypes.braceL.updateContext = function(prevType) {\n  this.context.push(this.braceIsBlock(prevType) ? types$1.b_stat : types$1.b_expr);\n  this.exprAllowed = true;\n};\n\ntypes.dollarBraceL.updateContext = function() {\n  this.context.push(types$1.b_tmpl);\n  this.exprAllowed = true;\n};\n\ntypes.parenL.updateContext = function(prevType) {\n  var statementParens = prevType === types._if || prevType === types._for || prevType === types._with || prevType === types._while;\n  this.context.push(statementParens ? types$1.p_stat : types$1.p_expr);\n  this.exprAllowed = true;\n};\n\ntypes.incDec.updateContext = function() {\n  // tokExprAllowed stays unchanged\n};\n\ntypes._function.updateContext = types._class.updateContext = function(prevType) {\n  if (prevType.beforeExpr && prevType !== types.semi && prevType !== types._else &&\n      !(prevType === types._return && lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) &&\n      !((prevType === types.colon || prevType === types.braceL) && this.curContext() === types$1.b_stat))\n    { this.context.push(types$1.f_expr); }\n  else\n    { this.context.push(types$1.f_stat); }\n  this.exprAllowed = false;\n};\n\ntypes.backQuote.updateContext = function() {\n  if (this.curContext() === types$1.q_tmpl)\n    { this.context.pop(); }\n  else\n    { this.context.push(types$1.q_tmpl); }\n  this.exprAllowed = false;\n};\n\ntypes.star.updateContext = function(prevType) {\n  if (prevType === types._function) {\n    var index = this.context.length - 1;\n    if (this.context[index] === types$1.f_expr)\n      { this.context[index] = types$1.f_expr_gen; }\n    else\n      { this.context[index] = types$1.f_gen; }\n  }\n  this.exprAllowed = true;\n};\n\ntypes.name.updateContext = function(prevType) {\n  var allowed = false;\n  if (this.options.ecmaVersion >= 6 && prevType !== types.dot) {\n    if (this.value === \"of\" && !this.exprAllowed ||\n        this.value === \"yield\" && this.inGeneratorContext())\n      { allowed = true; }\n  }\n  this.exprAllowed = allowed;\n};\n\n// This file contains Unicode properties extracted from the ECMAScript\n// specification. The lists are extracted like so:\n// $$('#table-binary-unicode-properties > figure > table > tbody > tr > td:nth-child(1) code').map(el => el.innerText)\n\n// #table-binary-unicode-properties\nvar ecma9BinaryProperties = \"ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS\";\nvar ecma10BinaryProperties = ecma9BinaryProperties + \" Extended_Pictographic\";\nvar ecma11BinaryProperties = ecma10BinaryProperties;\nvar unicodeBinaryProperties = {\n  9: ecma9BinaryProperties,\n  10: ecma10BinaryProperties,\n  11: ecma11BinaryProperties\n};\n\n// #table-unicode-general-category-values\nvar unicodeGeneralCategoryValues = \"Cased_Letter LC Close_Punctuation Pe Connector_Punctuation Pc Control Cc cntrl Currency_Symbol Sc Dash_Punctuation Pd Decimal_Number Nd digit Enclosing_Mark Me Final_Punctuation Pf Format Cf Initial_Punctuation Pi Letter L Letter_Number Nl Line_Separator Zl Lowercase_Letter Ll Mark M Combining_Mark Math_Symbol Sm Modifier_Letter Lm Modifier_Symbol Sk Nonspacing_Mark Mn Number N Open_Punctuation Ps Other C Other_Letter Lo Other_Number No Other_Punctuation Po Other_Symbol So Paragraph_Separator Zp Private_Use Co Punctuation P punct Separator Z Space_Separator Zs Spacing_Mark Mc Surrogate Cs Symbol S Titlecase_Letter Lt Unassigned Cn Uppercase_Letter Lu\";\n\n// #table-unicode-script-values\nvar ecma9ScriptValues = \"Adlam Adlm Ahom Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb\";\nvar ecma10ScriptValues = ecma9ScriptValues + \" Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd\";\nvar ecma11ScriptValues = ecma10ScriptValues + \" Elymaic Elym Nandinagari Nand Nyiakeng_Puachue_Hmong Hmnp Wancho Wcho\";\nvar unicodeScriptValues = {\n  9: ecma9ScriptValues,\n  10: ecma10ScriptValues,\n  11: ecma11ScriptValues\n};\n\nvar data = {};\nfunction buildUnicodeData(ecmaVersion) {\n  var d = data[ecmaVersion] = {\n    binary: wordsRegexp(unicodeBinaryProperties[ecmaVersion] + \" \" + unicodeGeneralCategoryValues),\n    nonBinary: {\n      General_Category: wordsRegexp(unicodeGeneralCategoryValues),\n      Script: wordsRegexp(unicodeScriptValues[ecmaVersion])\n    }\n  };\n  d.nonBinary.Script_Extensions = d.nonBinary.Script;\n\n  d.nonBinary.gc = d.nonBinary.General_Category;\n  d.nonBinary.sc = d.nonBinary.Script;\n  d.nonBinary.scx = d.nonBinary.Script_Extensions;\n}\nbuildUnicodeData(9);\nbuildUnicodeData(10);\nbuildUnicodeData(11);\n\nvar pp$8 = Parser.prototype;\n\nvar RegExpValidationState = function RegExpValidationState(parser) {\n  this.parser = parser;\n  this.validFlags = \"gim\" + (parser.options.ecmaVersion >= 6 ? \"uy\" : \"\") + (parser.options.ecmaVersion >= 9 ? \"s\" : \"\");\n  this.unicodeProperties = data[parser.options.ecmaVersion >= 11 ? 11 : parser.options.ecmaVersion];\n  this.source = \"\";\n  this.flags = \"\";\n  this.start = 0;\n  this.switchU = false;\n  this.switchN = false;\n  this.pos = 0;\n  this.lastIntValue = 0;\n  this.lastStringValue = \"\";\n  this.lastAssertionIsQuantifiable = false;\n  this.numCapturingParens = 0;\n  this.maxBackReference = 0;\n  this.groupNames = [];\n  this.backReferenceNames = [];\n};\n\nRegExpValidationState.prototype.reset = function reset (start, pattern, flags) {\n  var unicode = flags.indexOf(\"u\") !== -1;\n  this.start = start | 0;\n  this.source = pattern + \"\";\n  this.flags = flags;\n  this.switchU = unicode && this.parser.options.ecmaVersion >= 6;\n  this.switchN = unicode && this.parser.options.ecmaVersion >= 9;\n};\n\nRegExpValidationState.prototype.raise = function raise (message) {\n  this.parser.raiseRecoverable(this.start, (\"Invalid regular expression: /\" + (this.source) + \"/: \" + message));\n};\n\n// If u flag is given, this returns the code point at the index (it combines a surrogate pair).\n// Otherwise, this returns the code unit of the index (can be a part of a surrogate pair).\nRegExpValidationState.prototype.at = function at (i, forceU) {\n    if ( forceU === void 0 ) forceU = false;\n\n  var s = this.source;\n  var l = s.length;\n  if (i >= l) {\n    return -1\n  }\n  var c = s.charCodeAt(i);\n  if (!(forceU || this.switchU) || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {\n    return c\n  }\n  var next = s.charCodeAt(i + 1);\n  return next >= 0xDC00 && next <= 0xDFFF ? (c << 10) + next - 0x35FDC00 : c\n};\n\nRegExpValidationState.prototype.nextIndex = function nextIndex (i, forceU) {\n    if ( forceU === void 0 ) forceU = false;\n\n  var s = this.source;\n  var l = s.length;\n  if (i >= l) {\n    return l\n  }\n  var c = s.charCodeAt(i), next;\n  if (!(forceU || this.switchU) || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l ||\n      (next = s.charCodeAt(i + 1)) < 0xDC00 || next > 0xDFFF) {\n    return i + 1\n  }\n  return i + 2\n};\n\nRegExpValidationState.prototype.current = function current (forceU) {\n    if ( forceU === void 0 ) forceU = false;\n\n  return this.at(this.pos, forceU)\n};\n\nRegExpValidationState.prototype.lookahead = function lookahead (forceU) {\n    if ( forceU === void 0 ) forceU = false;\n\n  return this.at(this.nextIndex(this.pos, forceU), forceU)\n};\n\nRegExpValidationState.prototype.advance = function advance (forceU) {\n    if ( forceU === void 0 ) forceU = false;\n\n  this.pos = this.nextIndex(this.pos, forceU);\n};\n\nRegExpValidationState.prototype.eat = function eat (ch, forceU) {\n    if ( forceU === void 0 ) forceU = false;\n\n  if (this.current(forceU) === ch) {\n    this.advance(forceU);\n    return true\n  }\n  return false\n};\n\nfunction codePointToString(ch) {\n  if (ch <= 0xFFFF) { return String.fromCharCode(ch) }\n  ch -= 0x10000;\n  return String.fromCharCode((ch >> 10) + 0xD800, (ch & 0x03FF) + 0xDC00)\n}\n\n/**\n * Validate the flags part of a given RegExpLiteral.\n *\n * @param {RegExpValidationState} state The state to validate RegExp.\n * @returns {void}\n */\npp$8.validateRegExpFlags = function(state) {\n  var validFlags = state.validFlags;\n  var flags = state.flags;\n\n  for (var i = 0; i < flags.length; i++) {\n    var flag = flags.charAt(i);\n    if (validFlags.indexOf(flag) === -1) {\n      this.raise(state.start, \"Invalid regular expression flag\");\n    }\n    if (flags.indexOf(flag, i + 1) > -1) {\n      this.raise(state.start, \"Duplicate regular expression flag\");\n    }\n  }\n};\n\n/**\n * Validate the pattern part of a given RegExpLiteral.\n *\n * @param {RegExpValidationState} state The state to validate RegExp.\n * @returns {void}\n */\npp$8.validateRegExpPattern = function(state) {\n  this.regexp_pattern(state);\n\n  // The goal symbol for the parse is |Pattern[~U, ~N]|. If the result of\n  // parsing contains a |GroupName|, reparse with the goal symbol\n  // |Pattern[~U, +N]| and use this result instead. Throw a *SyntaxError*\n  // exception if _P_ did not conform to the grammar, if any elements of _P_\n  // were not matched by the parse, or if any Early Error conditions exist.\n  if (!state.switchN && this.options.ecmaVersion >= 9 && state.groupNames.length > 0) {\n    state.switchN = true;\n    this.regexp_pattern(state);\n  }\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Pattern\npp$8.regexp_pattern = function(state) {\n  state.pos = 0;\n  state.lastIntValue = 0;\n  state.lastStringValue = \"\";\n  state.lastAssertionIsQuantifiable = false;\n  state.numCapturingParens = 0;\n  state.maxBackReference = 0;\n  state.groupNames.length = 0;\n  state.backReferenceNames.length = 0;\n\n  this.regexp_disjunction(state);\n\n  if (state.pos !== state.source.length) {\n    // Make the same messages as V8.\n    if (state.eat(0x29 /* ) */)) {\n      state.raise(\"Unmatched ')'\");\n    }\n    if (state.eat(0x5D /* ] */) || state.eat(0x7D /* } */)) {\n      state.raise(\"Lone quantifier brackets\");\n    }\n  }\n  if (state.maxBackReference > state.numCapturingParens) {\n    state.raise(\"Invalid escape\");\n  }\n  for (var i = 0, list = state.backReferenceNames; i < list.length; i += 1) {\n    var name = list[i];\n\n    if (state.groupNames.indexOf(name) === -1) {\n      state.raise(\"Invalid named capture referenced\");\n    }\n  }\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Disjunction\npp$8.regexp_disjunction = function(state) {\n  this.regexp_alternative(state);\n  while (state.eat(0x7C /* | */)) {\n    this.regexp_alternative(state);\n  }\n\n  // Make the same message as V8.\n  if (this.regexp_eatQuantifier(state, true)) {\n    state.raise(\"Nothing to repeat\");\n  }\n  if (state.eat(0x7B /* { */)) {\n    state.raise(\"Lone quantifier brackets\");\n  }\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Alternative\npp$8.regexp_alternative = function(state) {\n  while (state.pos < state.source.length && this.regexp_eatTerm(state))\n    { }\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Term\npp$8.regexp_eatTerm = function(state) {\n  if (this.regexp_eatAssertion(state)) {\n    // Handle `QuantifiableAssertion Quantifier` alternative.\n    // `state.lastAssertionIsQuantifiable` is true if the last eaten Assertion\n    // is a QuantifiableAssertion.\n    if (state.lastAssertionIsQuantifiable && this.regexp_eatQuantifier(state)) {\n      // Make the same message as V8.\n      if (state.switchU) {\n        state.raise(\"Invalid quantifier\");\n      }\n    }\n    return true\n  }\n\n  if (state.switchU ? this.regexp_eatAtom(state) : this.regexp_eatExtendedAtom(state)) {\n    this.regexp_eatQuantifier(state);\n    return true\n  }\n\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Assertion\npp$8.regexp_eatAssertion = function(state) {\n  var start = state.pos;\n  state.lastAssertionIsQuantifiable = false;\n\n  // ^, $\n  if (state.eat(0x5E /* ^ */) || state.eat(0x24 /* $ */)) {\n    return true\n  }\n\n  // \\b \\B\n  if (state.eat(0x5C /* \\ */)) {\n    if (state.eat(0x42 /* B */) || state.eat(0x62 /* b */)) {\n      return true\n    }\n    state.pos = start;\n  }\n\n  // Lookahead / Lookbehind\n  if (state.eat(0x28 /* ( */) && state.eat(0x3F /* ? */)) {\n    var lookbehind = false;\n    if (this.options.ecmaVersion >= 9) {\n      lookbehind = state.eat(0x3C /* < */);\n    }\n    if (state.eat(0x3D /* = */) || state.eat(0x21 /* ! */)) {\n      this.regexp_disjunction(state);\n      if (!state.eat(0x29 /* ) */)) {\n        state.raise(\"Unterminated group\");\n      }\n      state.lastAssertionIsQuantifiable = !lookbehind;\n      return true\n    }\n  }\n\n  state.pos = start;\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Quantifier\npp$8.regexp_eatQuantifier = function(state, noError) {\n  if ( noError === void 0 ) noError = false;\n\n  if (this.regexp_eatQuantifierPrefix(state, noError)) {\n    state.eat(0x3F /* ? */);\n    return true\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-QuantifierPrefix\npp$8.regexp_eatQuantifierPrefix = function(state, noError) {\n  return (\n    state.eat(0x2A /* * */) ||\n    state.eat(0x2B /* + */) ||\n    state.eat(0x3F /* ? */) ||\n    this.regexp_eatBracedQuantifier(state, noError)\n  )\n};\npp$8.regexp_eatBracedQuantifier = function(state, noError) {\n  var start = state.pos;\n  if (state.eat(0x7B /* { */)) {\n    var min = 0, max = -1;\n    if (this.regexp_eatDecimalDigits(state)) {\n      min = state.lastIntValue;\n      if (state.eat(0x2C /* , */) && this.regexp_eatDecimalDigits(state)) {\n        max = state.lastIntValue;\n      }\n      if (state.eat(0x7D /* } */)) {\n        // SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-term\n        if (max !== -1 && max < min && !noError) {\n          state.raise(\"numbers out of order in {} quantifier\");\n        }\n        return true\n      }\n    }\n    if (state.switchU && !noError) {\n      state.raise(\"Incomplete quantifier\");\n    }\n    state.pos = start;\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Atom\npp$8.regexp_eatAtom = function(state) {\n  return (\n    this.regexp_eatPatternCharacters(state) ||\n    state.eat(0x2E /* . */) ||\n    this.regexp_eatReverseSolidusAtomEscape(state) ||\n    this.regexp_eatCharacterClass(state) ||\n    this.regexp_eatUncapturingGroup(state) ||\n    this.regexp_eatCapturingGroup(state)\n  )\n};\npp$8.regexp_eatReverseSolidusAtomEscape = function(state) {\n  var start = state.pos;\n  if (state.eat(0x5C /* \\ */)) {\n    if (this.regexp_eatAtomEscape(state)) {\n      return true\n    }\n    state.pos = start;\n  }\n  return false\n};\npp$8.regexp_eatUncapturingGroup = function(state) {\n  var start = state.pos;\n  if (state.eat(0x28 /* ( */)) {\n    if (state.eat(0x3F /* ? */) && state.eat(0x3A /* : */)) {\n      this.regexp_disjunction(state);\n      if (state.eat(0x29 /* ) */)) {\n        return true\n      }\n      state.raise(\"Unterminated group\");\n    }\n    state.pos = start;\n  }\n  return false\n};\npp$8.regexp_eatCapturingGroup = function(state) {\n  if (state.eat(0x28 /* ( */)) {\n    if (this.options.ecmaVersion >= 9) {\n      this.regexp_groupSpecifier(state);\n    } else if (state.current() === 0x3F /* ? */) {\n      state.raise(\"Invalid group\");\n    }\n    this.regexp_disjunction(state);\n    if (state.eat(0x29 /* ) */)) {\n      state.numCapturingParens += 1;\n      return true\n    }\n    state.raise(\"Unterminated group\");\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedAtom\npp$8.regexp_eatExtendedAtom = function(state) {\n  return (\n    state.eat(0x2E /* . */) ||\n    this.regexp_eatReverseSolidusAtomEscape(state) ||\n    this.regexp_eatCharacterClass(state) ||\n    this.regexp_eatUncapturingGroup(state) ||\n    this.regexp_eatCapturingGroup(state) ||\n    this.regexp_eatInvalidBracedQuantifier(state) ||\n    this.regexp_eatExtendedPatternCharacter(state)\n  )\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-InvalidBracedQuantifier\npp$8.regexp_eatInvalidBracedQuantifier = function(state) {\n  if (this.regexp_eatBracedQuantifier(state, true)) {\n    state.raise(\"Nothing to repeat\");\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-SyntaxCharacter\npp$8.regexp_eatSyntaxCharacter = function(state) {\n  var ch = state.current();\n  if (isSyntaxCharacter(ch)) {\n    state.lastIntValue = ch;\n    state.advance();\n    return true\n  }\n  return false\n};\nfunction isSyntaxCharacter(ch) {\n  return (\n    ch === 0x24 /* $ */ ||\n    ch >= 0x28 /* ( */ && ch <= 0x2B /* + */ ||\n    ch === 0x2E /* . */ ||\n    ch === 0x3F /* ? */ ||\n    ch >= 0x5B /* [ */ && ch <= 0x5E /* ^ */ ||\n    ch >= 0x7B /* { */ && ch <= 0x7D /* } */\n  )\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-PatternCharacter\n// But eat eager.\npp$8.regexp_eatPatternCharacters = function(state) {\n  var start = state.pos;\n  var ch = 0;\n  while ((ch = state.current()) !== -1 && !isSyntaxCharacter(ch)) {\n    state.advance();\n  }\n  return state.pos !== start\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedPatternCharacter\npp$8.regexp_eatExtendedPatternCharacter = function(state) {\n  var ch = state.current();\n  if (\n    ch !== -1 &&\n    ch !== 0x24 /* $ */ &&\n    !(ch >= 0x28 /* ( */ && ch <= 0x2B /* + */) &&\n    ch !== 0x2E /* . */ &&\n    ch !== 0x3F /* ? */ &&\n    ch !== 0x5B /* [ */ &&\n    ch !== 0x5E /* ^ */ &&\n    ch !== 0x7C /* | */\n  ) {\n    state.advance();\n    return true\n  }\n  return false\n};\n\n// GroupSpecifier ::\n//   [empty]\n//   `?` GroupName\npp$8.regexp_groupSpecifier = function(state) {\n  if (state.eat(0x3F /* ? */)) {\n    if (this.regexp_eatGroupName(state)) {\n      if (state.groupNames.indexOf(state.lastStringValue) !== -1) {\n        state.raise(\"Duplicate capture group name\");\n      }\n      state.groupNames.push(state.lastStringValue);\n      return\n    }\n    state.raise(\"Invalid group\");\n  }\n};\n\n// GroupName ::\n//   `<` RegExpIdentifierName `>`\n// Note: this updates `state.lastStringValue` property with the eaten name.\npp$8.regexp_eatGroupName = function(state) {\n  state.lastStringValue = \"\";\n  if (state.eat(0x3C /* < */)) {\n    if (this.regexp_eatRegExpIdentifierName(state) && state.eat(0x3E /* > */)) {\n      return true\n    }\n    state.raise(\"Invalid capture group name\");\n  }\n  return false\n};\n\n// RegExpIdentifierName ::\n//   RegExpIdentifierStart\n//   RegExpIdentifierName RegExpIdentifierPart\n// Note: this updates `state.lastStringValue` property with the eaten name.\npp$8.regexp_eatRegExpIdentifierName = function(state) {\n  state.lastStringValue = \"\";\n  if (this.regexp_eatRegExpIdentifierStart(state)) {\n    state.lastStringValue += codePointToString(state.lastIntValue);\n    while (this.regexp_eatRegExpIdentifierPart(state)) {\n      state.lastStringValue += codePointToString(state.lastIntValue);\n    }\n    return true\n  }\n  return false\n};\n\n// RegExpIdentifierStart ::\n//   UnicodeIDStart\n//   `$`\n//   `_`\n//   `\\` RegExpUnicodeEscapeSequence[+U]\npp$8.regexp_eatRegExpIdentifierStart = function(state) {\n  var start = state.pos;\n  var forceU = this.options.ecmaVersion >= 11;\n  var ch = state.current(forceU);\n  state.advance(forceU);\n\n  if (ch === 0x5C /* \\ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state, forceU)) {\n    ch = state.lastIntValue;\n  }\n  if (isRegExpIdentifierStart(ch)) {\n    state.lastIntValue = ch;\n    return true\n  }\n\n  state.pos = start;\n  return false\n};\nfunction isRegExpIdentifierStart(ch) {\n  return isIdentifierStart(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */\n}\n\n// RegExpIdentifierPart ::\n//   UnicodeIDContinue\n//   `$`\n//   `_`\n//   `\\` RegExpUnicodeEscapeSequence[+U]\n//   <ZWNJ>\n//   <ZWJ>\npp$8.regexp_eatRegExpIdentifierPart = function(state) {\n  var start = state.pos;\n  var forceU = this.options.ecmaVersion >= 11;\n  var ch = state.current(forceU);\n  state.advance(forceU);\n\n  if (ch === 0x5C /* \\ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state, forceU)) {\n    ch = state.lastIntValue;\n  }\n  if (isRegExpIdentifierPart(ch)) {\n    state.lastIntValue = ch;\n    return true\n  }\n\n  state.pos = start;\n  return false\n};\nfunction isRegExpIdentifierPart(ch) {\n  return isIdentifierChar(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */ || ch === 0x200C /* <ZWNJ> */ || ch === 0x200D /* <ZWJ> */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-AtomEscape\npp$8.regexp_eatAtomEscape = function(state) {\n  if (\n    this.regexp_eatBackReference(state) ||\n    this.regexp_eatCharacterClassEscape(state) ||\n    this.regexp_eatCharacterEscape(state) ||\n    (state.switchN && this.regexp_eatKGroupName(state))\n  ) {\n    return true\n  }\n  if (state.switchU) {\n    // Make the same message as V8.\n    if (state.current() === 0x63 /* c */) {\n      state.raise(\"Invalid unicode escape\");\n    }\n    state.raise(\"Invalid escape\");\n  }\n  return false\n};\npp$8.regexp_eatBackReference = function(state) {\n  var start = state.pos;\n  if (this.regexp_eatDecimalEscape(state)) {\n    var n = state.lastIntValue;\n    if (state.switchU) {\n      // For SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-atomescape\n      if (n > state.maxBackReference) {\n        state.maxBackReference = n;\n      }\n      return true\n    }\n    if (n <= state.numCapturingParens) {\n      return true\n    }\n    state.pos = start;\n  }\n  return false\n};\npp$8.regexp_eatKGroupName = function(state) {\n  if (state.eat(0x6B /* k */)) {\n    if (this.regexp_eatGroupName(state)) {\n      state.backReferenceNames.push(state.lastStringValue);\n      return true\n    }\n    state.raise(\"Invalid named reference\");\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-CharacterEscape\npp$8.regexp_eatCharacterEscape = function(state) {\n  return (\n    this.regexp_eatControlEscape(state) ||\n    this.regexp_eatCControlLetter(state) ||\n    this.regexp_eatZero(state) ||\n    this.regexp_eatHexEscapeSequence(state) ||\n    this.regexp_eatRegExpUnicodeEscapeSequence(state, false) ||\n    (!state.switchU && this.regexp_eatLegacyOctalEscapeSequence(state)) ||\n    this.regexp_eatIdentityEscape(state)\n  )\n};\npp$8.regexp_eatCControlLetter = function(state) {\n  var start = state.pos;\n  if (state.eat(0x63 /* c */)) {\n    if (this.regexp_eatControlLetter(state)) {\n      return true\n    }\n    state.pos = start;\n  }\n  return false\n};\npp$8.regexp_eatZero = function(state) {\n  if (state.current() === 0x30 /* 0 */ && !isDecimalDigit(state.lookahead())) {\n    state.lastIntValue = 0;\n    state.advance();\n    return true\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ControlEscape\npp$8.regexp_eatControlEscape = function(state) {\n  var ch = state.current();\n  if (ch === 0x74 /* t */) {\n    state.lastIntValue = 0x09; /* \\t */\n    state.advance();\n    return true\n  }\n  if (ch === 0x6E /* n */) {\n    state.lastIntValue = 0x0A; /* \\n */\n    state.advance();\n    return true\n  }\n  if (ch === 0x76 /* v */) {\n    state.lastIntValue = 0x0B; /* \\v */\n    state.advance();\n    return true\n  }\n  if (ch === 0x66 /* f */) {\n    state.lastIntValue = 0x0C; /* \\f */\n    state.advance();\n    return true\n  }\n  if (ch === 0x72 /* r */) {\n    state.lastIntValue = 0x0D; /* \\r */\n    state.advance();\n    return true\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ControlLetter\npp$8.regexp_eatControlLetter = function(state) {\n  var ch = state.current();\n  if (isControlLetter(ch)) {\n    state.lastIntValue = ch % 0x20;\n    state.advance();\n    return true\n  }\n  return false\n};\nfunction isControlLetter(ch) {\n  return (\n    (ch >= 0x41 /* A */ && ch <= 0x5A /* Z */) ||\n    (ch >= 0x61 /* a */ && ch <= 0x7A /* z */)\n  )\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-RegExpUnicodeEscapeSequence\npp$8.regexp_eatRegExpUnicodeEscapeSequence = function(state, forceU) {\n  if ( forceU === void 0 ) forceU = false;\n\n  var start = state.pos;\n  var switchU = forceU || state.switchU;\n\n  if (state.eat(0x75 /* u */)) {\n    if (this.regexp_eatFixedHexDigits(state, 4)) {\n      var lead = state.lastIntValue;\n      if (switchU && lead >= 0xD800 && lead <= 0xDBFF) {\n        var leadSurrogateEnd = state.pos;\n        if (state.eat(0x5C /* \\ */) && state.eat(0x75 /* u */) && this.regexp_eatFixedHexDigits(state, 4)) {\n          var trail = state.lastIntValue;\n          if (trail >= 0xDC00 && trail <= 0xDFFF) {\n            state.lastIntValue = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;\n            return true\n          }\n        }\n        state.pos = leadSurrogateEnd;\n        state.lastIntValue = lead;\n      }\n      return true\n    }\n    if (\n      switchU &&\n      state.eat(0x7B /* { */) &&\n      this.regexp_eatHexDigits(state) &&\n      state.eat(0x7D /* } */) &&\n      isValidUnicode(state.lastIntValue)\n    ) {\n      return true\n    }\n    if (switchU) {\n      state.raise(\"Invalid unicode escape\");\n    }\n    state.pos = start;\n  }\n\n  return false\n};\nfunction isValidUnicode(ch) {\n  return ch >= 0 && ch <= 0x10FFFF\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-IdentityEscape\npp$8.regexp_eatIdentityEscape = function(state) {\n  if (state.switchU) {\n    if (this.regexp_eatSyntaxCharacter(state)) {\n      return true\n    }\n    if (state.eat(0x2F /* / */)) {\n      state.lastIntValue = 0x2F; /* / */\n      return true\n    }\n    return false\n  }\n\n  var ch = state.current();\n  if (ch !== 0x63 /* c */ && (!state.switchN || ch !== 0x6B /* k */)) {\n    state.lastIntValue = ch;\n    state.advance();\n    return true\n  }\n\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalEscape\npp$8.regexp_eatDecimalEscape = function(state) {\n  state.lastIntValue = 0;\n  var ch = state.current();\n  if (ch >= 0x31 /* 1 */ && ch <= 0x39 /* 9 */) {\n    do {\n      state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */);\n      state.advance();\n    } while ((ch = state.current()) >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */)\n    return true\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClassEscape\npp$8.regexp_eatCharacterClassEscape = function(state) {\n  var ch = state.current();\n\n  if (isCharacterClassEscape(ch)) {\n    state.lastIntValue = -1;\n    state.advance();\n    return true\n  }\n\n  if (\n    state.switchU &&\n    this.options.ecmaVersion >= 9 &&\n    (ch === 0x50 /* P */ || ch === 0x70 /* p */)\n  ) {\n    state.lastIntValue = -1;\n    state.advance();\n    if (\n      state.eat(0x7B /* { */) &&\n      this.regexp_eatUnicodePropertyValueExpression(state) &&\n      state.eat(0x7D /* } */)\n    ) {\n      return true\n    }\n    state.raise(\"Invalid property name\");\n  }\n\n  return false\n};\nfunction isCharacterClassEscape(ch) {\n  return (\n    ch === 0x64 /* d */ ||\n    ch === 0x44 /* D */ ||\n    ch === 0x73 /* s */ ||\n    ch === 0x53 /* S */ ||\n    ch === 0x77 /* w */ ||\n    ch === 0x57 /* W */\n  )\n}\n\n// UnicodePropertyValueExpression ::\n//   UnicodePropertyName `=` UnicodePropertyValue\n//   LoneUnicodePropertyNameOrValue\npp$8.regexp_eatUnicodePropertyValueExpression = function(state) {\n  var start = state.pos;\n\n  // UnicodePropertyName `=` UnicodePropertyValue\n  if (this.regexp_eatUnicodePropertyName(state) && state.eat(0x3D /* = */)) {\n    var name = state.lastStringValue;\n    if (this.regexp_eatUnicodePropertyValue(state)) {\n      var value = state.lastStringValue;\n      this.regexp_validateUnicodePropertyNameAndValue(state, name, value);\n      return true\n    }\n  }\n  state.pos = start;\n\n  // LoneUnicodePropertyNameOrValue\n  if (this.regexp_eatLoneUnicodePropertyNameOrValue(state)) {\n    var nameOrValue = state.lastStringValue;\n    this.regexp_validateUnicodePropertyNameOrValue(state, nameOrValue);\n    return true\n  }\n  return false\n};\npp$8.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) {\n  if (!has(state.unicodeProperties.nonBinary, name))\n    { state.raise(\"Invalid property name\"); }\n  if (!state.unicodeProperties.nonBinary[name].test(value))\n    { state.raise(\"Invalid property value\"); }\n};\npp$8.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {\n  if (!state.unicodeProperties.binary.test(nameOrValue))\n    { state.raise(\"Invalid property name\"); }\n};\n\n// UnicodePropertyName ::\n//   UnicodePropertyNameCharacters\npp$8.regexp_eatUnicodePropertyName = function(state) {\n  var ch = 0;\n  state.lastStringValue = \"\";\n  while (isUnicodePropertyNameCharacter(ch = state.current())) {\n    state.lastStringValue += codePointToString(ch);\n    state.advance();\n  }\n  return state.lastStringValue !== \"\"\n};\nfunction isUnicodePropertyNameCharacter(ch) {\n  return isControlLetter(ch) || ch === 0x5F /* _ */\n}\n\n// UnicodePropertyValue ::\n//   UnicodePropertyValueCharacters\npp$8.regexp_eatUnicodePropertyValue = function(state) {\n  var ch = 0;\n  state.lastStringValue = \"\";\n  while (isUnicodePropertyValueCharacter(ch = state.current())) {\n    state.lastStringValue += codePointToString(ch);\n    state.advance();\n  }\n  return state.lastStringValue !== \"\"\n};\nfunction isUnicodePropertyValueCharacter(ch) {\n  return isUnicodePropertyNameCharacter(ch) || isDecimalDigit(ch)\n}\n\n// LoneUnicodePropertyNameOrValue ::\n//   UnicodePropertyValueCharacters\npp$8.regexp_eatLoneUnicodePropertyNameOrValue = function(state) {\n  return this.regexp_eatUnicodePropertyValue(state)\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClass\npp$8.regexp_eatCharacterClass = function(state) {\n  if (state.eat(0x5B /* [ */)) {\n    state.eat(0x5E /* ^ */);\n    this.regexp_classRanges(state);\n    if (state.eat(0x5D /* ] */)) {\n      return true\n    }\n    // Unreachable since it threw \"unterminated regular expression\" error before.\n    state.raise(\"Unterminated character class\");\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassRanges\n// https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRanges\n// https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRangesNoDash\npp$8.regexp_classRanges = function(state) {\n  while (this.regexp_eatClassAtom(state)) {\n    var left = state.lastIntValue;\n    if (state.eat(0x2D /* - */) && this.regexp_eatClassAtom(state)) {\n      var right = state.lastIntValue;\n      if (state.switchU && (left === -1 || right === -1)) {\n        state.raise(\"Invalid character class\");\n      }\n      if (left !== -1 && right !== -1 && left > right) {\n        state.raise(\"Range out of order in character class\");\n      }\n    }\n  }\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtom\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtomNoDash\npp$8.regexp_eatClassAtom = function(state) {\n  var start = state.pos;\n\n  if (state.eat(0x5C /* \\ */)) {\n    if (this.regexp_eatClassEscape(state)) {\n      return true\n    }\n    if (state.switchU) {\n      // Make the same message as V8.\n      var ch$1 = state.current();\n      if (ch$1 === 0x63 /* c */ || isOctalDigit(ch$1)) {\n        state.raise(\"Invalid class escape\");\n      }\n      state.raise(\"Invalid escape\");\n    }\n    state.pos = start;\n  }\n\n  var ch = state.current();\n  if (ch !== 0x5D /* ] */) {\n    state.lastIntValue = ch;\n    state.advance();\n    return true\n  }\n\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassEscape\npp$8.regexp_eatClassEscape = function(state) {\n  var start = state.pos;\n\n  if (state.eat(0x62 /* b */)) {\n    state.lastIntValue = 0x08; /* <BS> */\n    return true\n  }\n\n  if (state.switchU && state.eat(0x2D /* - */)) {\n    state.lastIntValue = 0x2D; /* - */\n    return true\n  }\n\n  if (!state.switchU && state.eat(0x63 /* c */)) {\n    if (this.regexp_eatClassControlLetter(state)) {\n      return true\n    }\n    state.pos = start;\n  }\n\n  return (\n    this.regexp_eatCharacterClassEscape(state) ||\n    this.regexp_eatCharacterEscape(state)\n  )\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassControlLetter\npp$8.regexp_eatClassControlLetter = function(state) {\n  var ch = state.current();\n  if (isDecimalDigit(ch) || ch === 0x5F /* _ */) {\n    state.lastIntValue = ch % 0x20;\n    state.advance();\n    return true\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence\npp$8.regexp_eatHexEscapeSequence = function(state) {\n  var start = state.pos;\n  if (state.eat(0x78 /* x */)) {\n    if (this.regexp_eatFixedHexDigits(state, 2)) {\n      return true\n    }\n    if (state.switchU) {\n      state.raise(\"Invalid escape\");\n    }\n    state.pos = start;\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalDigits\npp$8.regexp_eatDecimalDigits = function(state) {\n  var start = state.pos;\n  var ch = 0;\n  state.lastIntValue = 0;\n  while (isDecimalDigit(ch = state.current())) {\n    state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */);\n    state.advance();\n  }\n  return state.pos !== start\n};\nfunction isDecimalDigit(ch) {\n  return ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigits\npp$8.regexp_eatHexDigits = function(state) {\n  var start = state.pos;\n  var ch = 0;\n  state.lastIntValue = 0;\n  while (isHexDigit(ch = state.current())) {\n    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);\n    state.advance();\n  }\n  return state.pos !== start\n};\nfunction isHexDigit(ch) {\n  return (\n    (ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */) ||\n    (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) ||\n    (ch >= 0x61 /* a */ && ch <= 0x66 /* f */)\n  )\n}\nfunction hexToInt(ch) {\n  if (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) {\n    return 10 + (ch - 0x41 /* A */)\n  }\n  if (ch >= 0x61 /* a */ && ch <= 0x66 /* f */) {\n    return 10 + (ch - 0x61 /* a */)\n  }\n  return ch - 0x30 /* 0 */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-LegacyOctalEscapeSequence\n// Allows only 0-377(octal) i.e. 0-255(decimal).\npp$8.regexp_eatLegacyOctalEscapeSequence = function(state) {\n  if (this.regexp_eatOctalDigit(state)) {\n    var n1 = state.lastIntValue;\n    if (this.regexp_eatOctalDigit(state)) {\n      var n2 = state.lastIntValue;\n      if (n1 <= 3 && this.regexp_eatOctalDigit(state)) {\n        state.lastIntValue = n1 * 64 + n2 * 8 + state.lastIntValue;\n      } else {\n        state.lastIntValue = n1 * 8 + n2;\n      }\n    } else {\n      state.lastIntValue = n1;\n    }\n    return true\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-OctalDigit\npp$8.regexp_eatOctalDigit = function(state) {\n  var ch = state.current();\n  if (isOctalDigit(ch)) {\n    state.lastIntValue = ch - 0x30; /* 0 */\n    state.advance();\n    return true\n  }\n  state.lastIntValue = 0;\n  return false\n};\nfunction isOctalDigit(ch) {\n  return ch >= 0x30 /* 0 */ && ch <= 0x37 /* 7 */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Hex4Digits\n// https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigit\n// And HexDigit HexDigit in https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence\npp$8.regexp_eatFixedHexDigits = function(state, length) {\n  var start = state.pos;\n  state.lastIntValue = 0;\n  for (var i = 0; i < length; ++i) {\n    var ch = state.current();\n    if (!isHexDigit(ch)) {\n      state.pos = start;\n      return false\n    }\n    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);\n    state.advance();\n  }\n  return true\n};\n\n// Object type used to represent tokens. Note that normally, tokens\n// simply exist as properties on the parser object. This is only\n// used for the onToken callback and the external tokenizer.\n\nvar Token = function Token(p) {\n  this.type = p.type;\n  this.value = p.value;\n  this.start = p.start;\n  this.end = p.end;\n  if (p.options.locations)\n    { this.loc = new SourceLocation(p, p.startLoc, p.endLoc); }\n  if (p.options.ranges)\n    { this.range = [p.start, p.end]; }\n};\n\n// ## Tokenizer\n\nvar pp$9 = Parser.prototype;\n\n// Move to the next token\n\npp$9.next = function(ignoreEscapeSequenceInKeyword) {\n  if (!ignoreEscapeSequenceInKeyword && this.type.keyword && this.containsEsc)\n    { this.raiseRecoverable(this.start, \"Escape sequence in keyword \" + this.type.keyword); }\n  if (this.options.onToken)\n    { this.options.onToken(new Token(this)); }\n\n  this.lastTokEnd = this.end;\n  this.lastTokStart = this.start;\n  this.lastTokEndLoc = this.endLoc;\n  this.lastTokStartLoc = this.startLoc;\n  this.nextToken();\n};\n\npp$9.getToken = function() {\n  this.next();\n  return new Token(this)\n};\n\n// If we're in an ES6 environment, make parsers iterable\nif (typeof Symbol !== \"undefined\")\n  { pp$9[Symbol.iterator] = function() {\n    var this$1 = this;\n\n    return {\n      next: function () {\n        var token = this$1.getToken();\n        return {\n          done: token.type === types.eof,\n          value: token\n        }\n      }\n    }\n  }; }\n\n// Toggle strict mode. Re-reads the next number or string to please\n// pedantic tests (`\"use strict\"; 010;` should fail).\n\npp$9.curContext = function() {\n  return this.context[this.context.length - 1]\n};\n\n// Read a single token, updating the parser object's token-related\n// properties.\n\npp$9.nextToken = function() {\n  var curContext = this.curContext();\n  if (!curContext || !curContext.preserveSpace) { this.skipSpace(); }\n\n  this.start = this.pos;\n  if (this.options.locations) { this.startLoc = this.curPosition(); }\n  if (this.pos >= this.input.length) { return this.finishToken(types.eof) }\n\n  if (curContext.override) { return curContext.override(this) }\n  else { this.readToken(this.fullCharCodeAtPos()); }\n};\n\npp$9.readToken = function(code) {\n  // Identifier or keyword. '\\uXXXX' sequences are allowed in\n  // identifiers, so '\\' also dispatches to that.\n  if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\\' */)\n    { return this.readWord() }\n\n  return this.getTokenFromCode(code)\n};\n\npp$9.fullCharCodeAtPos = function() {\n  var code = this.input.charCodeAt(this.pos);\n  if (code <= 0xd7ff || code >= 0xe000) { return code }\n  var next = this.input.charCodeAt(this.pos + 1);\n  return (code << 10) + next - 0x35fdc00\n};\n\npp$9.skipBlockComment = function() {\n  var startLoc = this.options.onComment && this.curPosition();\n  var start = this.pos, end = this.input.indexOf(\"*/\", this.pos += 2);\n  if (end === -1) { this.raise(this.pos - 2, \"Unterminated comment\"); }\n  this.pos = end + 2;\n  if (this.options.locations) {\n    lineBreakG.lastIndex = start;\n    var match;\n    while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {\n      ++this.curLine;\n      this.lineStart = match.index + match[0].length;\n    }\n  }\n  if (this.options.onComment)\n    { this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,\n                           startLoc, this.curPosition()); }\n};\n\npp$9.skipLineComment = function(startSkip) {\n  var start = this.pos;\n  var startLoc = this.options.onComment && this.curPosition();\n  var ch = this.input.charCodeAt(this.pos += startSkip);\n  while (this.pos < this.input.length && !isNewLine(ch)) {\n    ch = this.input.charCodeAt(++this.pos);\n  }\n  if (this.options.onComment)\n    { this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,\n                           startLoc, this.curPosition()); }\n};\n\n// Called at the start of the parse and after every token. Skips\n// whitespace and comments, and.\n\npp$9.skipSpace = function() {\n  loop: while (this.pos < this.input.length) {\n    var ch = this.input.charCodeAt(this.pos);\n    switch (ch) {\n    case 32: case 160: // ' '\n      ++this.pos;\n      break\n    case 13:\n      if (this.input.charCodeAt(this.pos + 1) === 10) {\n        ++this.pos;\n      }\n    case 10: case 8232: case 8233:\n      ++this.pos;\n      if (this.options.locations) {\n        ++this.curLine;\n        this.lineStart = this.pos;\n      }\n      break\n    case 47: // '/'\n      switch (this.input.charCodeAt(this.pos + 1)) {\n      case 42: // '*'\n        this.skipBlockComment();\n        break\n      case 47:\n        this.skipLineComment(2);\n        break\n      default:\n        break loop\n      }\n      break\n    default:\n      if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {\n        ++this.pos;\n      } else {\n        break loop\n      }\n    }\n  }\n};\n\n// Called at the end of every token. Sets `end`, `val`, and\n// maintains `context` and `exprAllowed`, and skips the space after\n// the token, so that the next one's `start` will point at the\n// right position.\n\npp$9.finishToken = function(type, val) {\n  this.end = this.pos;\n  if (this.options.locations) { this.endLoc = this.curPosition(); }\n  var prevType = this.type;\n  this.type = type;\n  this.value = val;\n\n  this.updateContext(prevType);\n};\n\n// ### Token reading\n\n// This is the function that is called to fetch the next token. It\n// is somewhat obscure, because it works in character codes rather\n// than characters, and because operator parsing has been inlined\n// into it.\n//\n// All in the name of speed.\n//\npp$9.readToken_dot = function() {\n  var next = this.input.charCodeAt(this.pos + 1);\n  if (next >= 48 && next <= 57) { return this.readNumber(true) }\n  var next2 = this.input.charCodeAt(this.pos + 2);\n  if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'\n    this.pos += 3;\n    return this.finishToken(types.ellipsis)\n  } else {\n    ++this.pos;\n    return this.finishToken(types.dot)\n  }\n};\n\npp$9.readToken_slash = function() { // '/'\n  var next = this.input.charCodeAt(this.pos + 1);\n  if (this.exprAllowed) { ++this.pos; return this.readRegexp() }\n  if (next === 61) { return this.finishOp(types.assign, 2) }\n  return this.finishOp(types.slash, 1)\n};\n\npp$9.readToken_mult_modulo_exp = function(code) { // '%*'\n  var next = this.input.charCodeAt(this.pos + 1);\n  var size = 1;\n  var tokentype = code === 42 ? types.star : types.modulo;\n\n  // exponentiation operator ** and **=\n  if (this.options.ecmaVersion >= 7 && code === 42 && next === 42) {\n    ++size;\n    tokentype = types.starstar;\n    next = this.input.charCodeAt(this.pos + 2);\n  }\n\n  if (next === 61) { return this.finishOp(types.assign, size + 1) }\n  return this.finishOp(tokentype, size)\n};\n\npp$9.readToken_pipe_amp = function(code) { // '|&'\n  var next = this.input.charCodeAt(this.pos + 1);\n  if (next === code) { return this.finishOp(code === 124 ? types.logicalOR : types.logicalAND, 2) }\n  if (next === 61) { return this.finishOp(types.assign, 2) }\n  return this.finishOp(code === 124 ? types.bitwiseOR : types.bitwiseAND, 1)\n};\n\npp$9.readToken_caret = function() { // '^'\n  var next = this.input.charCodeAt(this.pos + 1);\n  if (next === 61) { return this.finishOp(types.assign, 2) }\n  return this.finishOp(types.bitwiseXOR, 1)\n};\n\npp$9.readToken_plus_min = function(code) { // '+-'\n  var next = this.input.charCodeAt(this.pos + 1);\n  if (next === code) {\n    if (next === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 &&\n        (this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd, this.pos)))) {\n      // A `-->` line comment\n      this.skipLineComment(3);\n      this.skipSpace();\n      return this.nextToken()\n    }\n    return this.finishOp(types.incDec, 2)\n  }\n  if (next === 61) { return this.finishOp(types.assign, 2) }\n  return this.finishOp(types.plusMin, 1)\n};\n\npp$9.readToken_lt_gt = function(code) { // '<>'\n  var next = this.input.charCodeAt(this.pos + 1);\n  var size = 1;\n  if (next === code) {\n    size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;\n    if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types.assign, size + 1) }\n    return this.finishOp(types.bitShift, size)\n  }\n  if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 &&\n      this.input.charCodeAt(this.pos + 3) === 45) {\n    // `<!--`, an XML-style comment that should be interpreted as a line comment\n    this.skipLineComment(4);\n    this.skipSpace();\n    return this.nextToken()\n  }\n  if (next === 61) { size = 2; }\n  return this.finishOp(types.relational, size)\n};\n\npp$9.readToken_eq_excl = function(code) { // '=!'\n  var next = this.input.charCodeAt(this.pos + 1);\n  if (next === 61) { return this.finishOp(types.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2) }\n  if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'\n    this.pos += 2;\n    return this.finishToken(types.arrow)\n  }\n  return this.finishOp(code === 61 ? types.eq : types.prefix, 1)\n};\n\npp$9.readToken_question = function() { // '?'\n  if (this.options.ecmaVersion >= 11) {\n    var next = this.input.charCodeAt(this.pos + 1);\n    if (next === 63) { return this.finishOp(types.coalesce, 2) }\n  }\n  return this.finishOp(types.question, 1)\n};\n\npp$9.getTokenFromCode = function(code) {\n  switch (code) {\n  // The interpretation of a dot depends on whether it is followed\n  // by a digit or another two dots.\n  case 46: // '.'\n    return this.readToken_dot()\n\n  // Punctuation tokens.\n  case 40: ++this.pos; return this.finishToken(types.parenL)\n  case 41: ++this.pos; return this.finishToken(types.parenR)\n  case 59: ++this.pos; return this.finishToken(types.semi)\n  case 44: ++this.pos; return this.finishToken(types.comma)\n  case 91: ++this.pos; return this.finishToken(types.bracketL)\n  case 93: ++this.pos; return this.finishToken(types.bracketR)\n  case 123: ++this.pos; return this.finishToken(types.braceL)\n  case 125: ++this.pos; return this.finishToken(types.braceR)\n  case 58: ++this.pos; return this.finishToken(types.colon)\n\n  case 96: // '`'\n    if (this.options.ecmaVersion < 6) { break }\n    ++this.pos;\n    return this.finishToken(types.backQuote)\n\n  case 48: // '0'\n    var next = this.input.charCodeAt(this.pos + 1);\n    if (next === 120 || next === 88) { return this.readRadixNumber(16) } // '0x', '0X' - hex number\n    if (this.options.ecmaVersion >= 6) {\n      if (next === 111 || next === 79) { return this.readRadixNumber(8) } // '0o', '0O' - octal number\n      if (next === 98 || next === 66) { return this.readRadixNumber(2) } // '0b', '0B' - binary number\n    }\n\n  // Anything else beginning with a digit is an integer, octal\n  // number, or float.\n  case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9\n    return this.readNumber(false)\n\n  // Quotes produce strings.\n  case 34: case 39: // '\"', \"'\"\n    return this.readString(code)\n\n  // Operators are parsed inline in tiny state machines. '=' (61) is\n  // often referred to. `finishOp` simply skips the amount of\n  // characters it is given as second argument, and returns a token\n  // of the type given by its first argument.\n\n  case 47: // '/'\n    return this.readToken_slash()\n\n  case 37: case 42: // '%*'\n    return this.readToken_mult_modulo_exp(code)\n\n  case 124: case 38: // '|&'\n    return this.readToken_pipe_amp(code)\n\n  case 94: // '^'\n    return this.readToken_caret()\n\n  case 43: case 45: // '+-'\n    return this.readToken_plus_min(code)\n\n  case 60: case 62: // '<>'\n    return this.readToken_lt_gt(code)\n\n  case 61: case 33: // '=!'\n    return this.readToken_eq_excl(code)\n\n  case 63: // '?'\n    return this.readToken_question()\n\n  case 126: // '~'\n    return this.finishOp(types.prefix, 1)\n  }\n\n  this.raise(this.pos, \"Unexpected character '\" + codePointToString$1(code) + \"'\");\n};\n\npp$9.finishOp = function(type, size) {\n  var str = this.input.slice(this.pos, this.pos + size);\n  this.pos += size;\n  return this.finishToken(type, str)\n};\n\npp$9.readRegexp = function() {\n  var escaped, inClass, start = this.pos;\n  for (;;) {\n    if (this.pos >= this.input.length) { this.raise(start, \"Unterminated regular expression\"); }\n    var ch = this.input.charAt(this.pos);\n    if (lineBreak.test(ch)) { this.raise(start, \"Unterminated regular expression\"); }\n    if (!escaped) {\n      if (ch === \"[\") { inClass = true; }\n      else if (ch === \"]\" && inClass) { inClass = false; }\n      else if (ch === \"/\" && !inClass) { break }\n      escaped = ch === \"\\\\\";\n    } else { escaped = false; }\n    ++this.pos;\n  }\n  var pattern = this.input.slice(start, this.pos);\n  ++this.pos;\n  var flagsStart = this.pos;\n  var flags = this.readWord1();\n  if (this.containsEsc) { this.unexpected(flagsStart); }\n\n  // Validate pattern\n  var state = this.regexpState || (this.regexpState = new RegExpValidationState(this));\n  state.reset(start, pattern, flags);\n  this.validateRegExpFlags(state);\n  this.validateRegExpPattern(state);\n\n  // Create Literal#value property value.\n  var value = null;\n  try {\n    value = new RegExp(pattern, flags);\n  } catch (e) {\n    // ESTree requires null if it failed to instantiate RegExp object.\n    // https://github.com/estree/estree/blob/a27003adf4fd7bfad44de9cef372a2eacd527b1c/es5.md#regexpliteral\n  }\n\n  return this.finishToken(types.regexp, {pattern: pattern, flags: flags, value: value})\n};\n\n// Read an integer in the given radix. Return null if zero digits\n// were read, the integer value otherwise. When `len` is given, this\n// will return `null` unless the integer has exactly `len` digits.\n\npp$9.readInt = function(radix, len) {\n  var start = this.pos, total = 0;\n  for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {\n    var code = this.input.charCodeAt(this.pos), val = (void 0);\n    if (code >= 97) { val = code - 97 + 10; } // a\n    else if (code >= 65) { val = code - 65 + 10; } // A\n    else if (code >= 48 && code <= 57) { val = code - 48; } // 0-9\n    else { val = Infinity; }\n    if (val >= radix) { break }\n    ++this.pos;\n    total = total * radix + val;\n  }\n  if (this.pos === start || len != null && this.pos - start !== len) { return null }\n\n  return total\n};\n\npp$9.readRadixNumber = function(radix) {\n  var start = this.pos;\n  this.pos += 2; // 0x\n  var val = this.readInt(radix);\n  if (val == null) { this.raise(this.start + 2, \"Expected number in radix \" + radix); }\n  if (this.options.ecmaVersion >= 11 && this.input.charCodeAt(this.pos) === 110) {\n    val = typeof BigInt !== \"undefined\" ? BigInt(this.input.slice(start, this.pos)) : null;\n    ++this.pos;\n  } else if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, \"Identifier directly after number\"); }\n  return this.finishToken(types.num, val)\n};\n\n// Read an integer, octal integer, or floating-point number.\n\npp$9.readNumber = function(startsWithDot) {\n  var start = this.pos;\n  if (!startsWithDot && this.readInt(10) === null) { this.raise(start, \"Invalid number\"); }\n  var octal = this.pos - start >= 2 && this.input.charCodeAt(start) === 48;\n  if (octal && this.strict) { this.raise(start, \"Invalid number\"); }\n  var next = this.input.charCodeAt(this.pos);\n  if (!octal && !startsWithDot && this.options.ecmaVersion >= 11 && next === 110) {\n    var str$1 = this.input.slice(start, this.pos);\n    var val$1 = typeof BigInt !== \"undefined\" ? BigInt(str$1) : null;\n    ++this.pos;\n    if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, \"Identifier directly after number\"); }\n    return this.finishToken(types.num, val$1)\n  }\n  if (octal && /[89]/.test(this.input.slice(start, this.pos))) { octal = false; }\n  if (next === 46 && !octal) { // '.'\n    ++this.pos;\n    this.readInt(10);\n    next = this.input.charCodeAt(this.pos);\n  }\n  if ((next === 69 || next === 101) && !octal) { // 'eE'\n    next = this.input.charCodeAt(++this.pos);\n    if (next === 43 || next === 45) { ++this.pos; } // '+-'\n    if (this.readInt(10) === null) { this.raise(start, \"Invalid number\"); }\n  }\n  if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, \"Identifier directly after number\"); }\n\n  var str = this.input.slice(start, this.pos);\n  var val = octal ? parseInt(str, 8) : parseFloat(str);\n  return this.finishToken(types.num, val)\n};\n\n// Read a string value, interpreting backslash-escapes.\n\npp$9.readCodePoint = function() {\n  var ch = this.input.charCodeAt(this.pos), code;\n\n  if (ch === 123) { // '{'\n    if (this.options.ecmaVersion < 6) { this.unexpected(); }\n    var codePos = ++this.pos;\n    code = this.readHexChar(this.input.indexOf(\"}\", this.pos) - this.pos);\n    ++this.pos;\n    if (code > 0x10FFFF) { this.invalidStringToken(codePos, \"Code point out of bounds\"); }\n  } else {\n    code = this.readHexChar(4);\n  }\n  return code\n};\n\nfunction codePointToString$1(code) {\n  // UTF-16 Decoding\n  if (code <= 0xFFFF) { return String.fromCharCode(code) }\n  code -= 0x10000;\n  return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00)\n}\n\npp$9.readString = function(quote) {\n  var out = \"\", chunkStart = ++this.pos;\n  for (;;) {\n    if (this.pos >= this.input.length) { this.raise(this.start, \"Unterminated string constant\"); }\n    var ch = this.input.charCodeAt(this.pos);\n    if (ch === quote) { break }\n    if (ch === 92) { // '\\'\n      out += this.input.slice(chunkStart, this.pos);\n      out += this.readEscapedChar(false);\n      chunkStart = this.pos;\n    } else {\n      if (isNewLine(ch, this.options.ecmaVersion >= 10)) { this.raise(this.start, \"Unterminated string constant\"); }\n      ++this.pos;\n    }\n  }\n  out += this.input.slice(chunkStart, this.pos++);\n  return this.finishToken(types.string, out)\n};\n\n// Reads template string tokens.\n\nvar INVALID_TEMPLATE_ESCAPE_ERROR = {};\n\npp$9.tryReadTemplateToken = function() {\n  this.inTemplateElement = true;\n  try {\n    this.readTmplToken();\n  } catch (err) {\n    if (err === INVALID_TEMPLATE_ESCAPE_ERROR) {\n      this.readInvalidTemplateToken();\n    } else {\n      throw err\n    }\n  }\n\n  this.inTemplateElement = false;\n};\n\npp$9.invalidStringToken = function(position, message) {\n  if (this.inTemplateElement && this.options.ecmaVersion >= 9) {\n    throw INVALID_TEMPLATE_ESCAPE_ERROR\n  } else {\n    this.raise(position, message);\n  }\n};\n\npp$9.readTmplToken = function() {\n  var out = \"\", chunkStart = this.pos;\n  for (;;) {\n    if (this.pos >= this.input.length) { this.raise(this.start, \"Unterminated template\"); }\n    var ch = this.input.charCodeAt(this.pos);\n    if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) { // '`', '${'\n      if (this.pos === this.start && (this.type === types.template || this.type === types.invalidTemplate)) {\n        if (ch === 36) {\n          this.pos += 2;\n          return this.finishToken(types.dollarBraceL)\n        } else {\n          ++this.pos;\n          return this.finishToken(types.backQuote)\n        }\n      }\n      out += this.input.slice(chunkStart, this.pos);\n      return this.finishToken(types.template, out)\n    }\n    if (ch === 92) { // '\\'\n      out += this.input.slice(chunkStart, this.pos);\n      out += this.readEscapedChar(true);\n      chunkStart = this.pos;\n    } else if (isNewLine(ch)) {\n      out += this.input.slice(chunkStart, this.pos);\n      ++this.pos;\n      switch (ch) {\n      case 13:\n        if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; }\n      case 10:\n        out += \"\\n\";\n        break\n      default:\n        out += String.fromCharCode(ch);\n        break\n      }\n      if (this.options.locations) {\n        ++this.curLine;\n        this.lineStart = this.pos;\n      }\n      chunkStart = this.pos;\n    } else {\n      ++this.pos;\n    }\n  }\n};\n\n// Reads a template token to search for the end, without validating any escape sequences\npp$9.readInvalidTemplateToken = function() {\n  for (; this.pos < this.input.length; this.pos++) {\n    switch (this.input[this.pos]) {\n    case \"\\\\\":\n      ++this.pos;\n      break\n\n    case \"$\":\n      if (this.input[this.pos + 1] !== \"{\") {\n        break\n      }\n    // falls through\n\n    case \"`\":\n      return this.finishToken(types.invalidTemplate, this.input.slice(this.start, this.pos))\n\n    // no default\n    }\n  }\n  this.raise(this.start, \"Unterminated template\");\n};\n\n// Used to read escaped characters\n\npp$9.readEscapedChar = function(inTemplate) {\n  var ch = this.input.charCodeAt(++this.pos);\n  ++this.pos;\n  switch (ch) {\n  case 110: return \"\\n\" // 'n' -> '\\n'\n  case 114: return \"\\r\" // 'r' -> '\\r'\n  case 120: return String.fromCharCode(this.readHexChar(2)) // 'x'\n  case 117: return codePointToString$1(this.readCodePoint()) // 'u'\n  case 116: return \"\\t\" // 't' -> '\\t'\n  case 98: return \"\\b\" // 'b' -> '\\b'\n  case 118: return \"\\u000b\" // 'v' -> '\\u000b'\n  case 102: return \"\\f\" // 'f' -> '\\f'\n  case 13: if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; } // '\\r\\n'\n  case 10: // ' \\n'\n    if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }\n    return \"\"\n  case 56:\n  case 57:\n    if (inTemplate) {\n      var codePos = this.pos - 1;\n\n      this.invalidStringToken(\n        codePos,\n        \"Invalid escape sequence in template string\"\n      );\n\n      return null\n    }\n  default:\n    if (ch >= 48 && ch <= 55) {\n      var octalStr = this.input.substr(this.pos - 1, 3).match(/^[0-7]+/)[0];\n      var octal = parseInt(octalStr, 8);\n      if (octal > 255) {\n        octalStr = octalStr.slice(0, -1);\n        octal = parseInt(octalStr, 8);\n      }\n      this.pos += octalStr.length - 1;\n      ch = this.input.charCodeAt(this.pos);\n      if ((octalStr !== \"0\" || ch === 56 || ch === 57) && (this.strict || inTemplate)) {\n        this.invalidStringToken(\n          this.pos - 1 - octalStr.length,\n          inTemplate\n            ? \"Octal literal in template string\"\n            : \"Octal literal in strict mode\"\n        );\n      }\n      return String.fromCharCode(octal)\n    }\n    if (isNewLine(ch)) {\n      // Unicode new line characters after \\ get removed from output in both\n      // template literals and strings\n      return \"\"\n    }\n    return String.fromCharCode(ch)\n  }\n};\n\n// Used to read character escape sequences ('\\x', '\\u', '\\U').\n\npp$9.readHexChar = function(len) {\n  var codePos = this.pos;\n  var n = this.readInt(16, len);\n  if (n === null) { this.invalidStringToken(codePos, \"Bad character escape sequence\"); }\n  return n\n};\n\n// Read an identifier, and return it as a string. Sets `this.containsEsc`\n// to whether the word contained a '\\u' escape.\n//\n// Incrementally adds only escaped chars, adding other chunks as-is\n// as a micro-optimization.\n\npp$9.readWord1 = function() {\n  this.containsEsc = false;\n  var word = \"\", first = true, chunkStart = this.pos;\n  var astral = this.options.ecmaVersion >= 6;\n  while (this.pos < this.input.length) {\n    var ch = this.fullCharCodeAtPos();\n    if (isIdentifierChar(ch, astral)) {\n      this.pos += ch <= 0xffff ? 1 : 2;\n    } else if (ch === 92) { // \"\\\"\n      this.containsEsc = true;\n      word += this.input.slice(chunkStart, this.pos);\n      var escStart = this.pos;\n      if (this.input.charCodeAt(++this.pos) !== 117) // \"u\"\n        { this.invalidStringToken(this.pos, \"Expecting Unicode escape sequence \\\\uXXXX\"); }\n      ++this.pos;\n      var esc = this.readCodePoint();\n      if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))\n        { this.invalidStringToken(escStart, \"Invalid Unicode escape\"); }\n      word += codePointToString$1(esc);\n      chunkStart = this.pos;\n    } else {\n      break\n    }\n    first = false;\n  }\n  return word + this.input.slice(chunkStart, this.pos)\n};\n\n// Read an identifier or keyword token. Will check for reserved\n// words when necessary.\n\npp$9.readWord = function() {\n  var word = this.readWord1();\n  var type = types.name;\n  if (this.keywords.test(word)) {\n    type = keywords$1$1[word];\n  }\n  return this.finishToken(type, word)\n};\n\n// Acorn is a tiny, fast JavaScript parser written in JavaScript.\n\nvar version$5 = \"7.1.0\";\n\nParser.acorn = {\n  Parser: Parser,\n  version: version$5,\n  defaultOptions: defaultOptions$1,\n  Position: Position,\n  SourceLocation: SourceLocation,\n  getLineInfo: getLineInfo,\n  Node: Node,\n  TokenType: TokenType,\n  tokTypes: types,\n  keywordTypes: keywords$1$1,\n  TokContext: TokContext,\n  tokContexts: types$1,\n  isIdentifierChar: isIdentifierChar,\n  isIdentifierStart: isIdentifierStart,\n  Token: Token,\n  isNewLine: isNewLine,\n  lineBreak: lineBreak,\n  lineBreakG: lineBreakG,\n  nonASCIIwhitespace: nonASCIIwhitespace\n};\n\n// The main exported interface (under `self.acorn` when in the\n// browser) is a `parse` function that takes a code string and\n// returns an abstract syntax tree as specified by [Mozilla parser\n// API][api].\n//\n// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API\n\nfunction parse$1(input, options) {\n  return Parser.parse(input, options)\n}\n\n// This function tries to parse a single expression at a given\n// offset in a string. Useful for parsing mixed-language formats\n// that embed JavaScript expressions.\n\nfunction parseExpressionAt(input, pos, options) {\n  return Parser.parseExpressionAt(input, pos, options)\n}\n\n// Acorn is organized as a tokenizer and a recursive-descent parser.\n// The `tokenizer` export provides an interface to the tokenizer.\n\nfunction tokenizer(input, options) {\n  return Parser.tokenizer(input, options)\n}\n\nvar acorn = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  Node: Node,\n  Parser: Parser,\n  Position: Position,\n  SourceLocation: SourceLocation,\n  TokContext: TokContext,\n  Token: Token,\n  TokenType: TokenType,\n  defaultOptions: defaultOptions$1,\n  getLineInfo: getLineInfo,\n  isIdentifierChar: isIdentifierChar,\n  isIdentifierStart: isIdentifierStart,\n  isNewLine: isNewLine,\n  keywordTypes: keywords$1$1,\n  lineBreak: lineBreak,\n  lineBreakG: lineBreakG,\n  nonASCIIwhitespace: nonASCIIwhitespace,\n  parse: parse$1,\n  parseExpressionAt: parseExpressionAt,\n  tokContexts: types$1,\n  tokTypes: types,\n  tokenizer: tokenizer,\n  version: version$5\n});\n\nvar xhtml = {\n  quot: '\\u0022',\n  amp: '&',\n  apos: '\\u0027',\n  lt: '<',\n  gt: '>',\n  nbsp: '\\u00A0',\n  iexcl: '\\u00A1',\n  cent: '\\u00A2',\n  pound: '\\u00A3',\n  curren: '\\u00A4',\n  yen: '\\u00A5',\n  brvbar: '\\u00A6',\n  sect: '\\u00A7',\n  uml: '\\u00A8',\n  copy: '\\u00A9',\n  ordf: '\\u00AA',\n  laquo: '\\u00AB',\n  not: '\\u00AC',\n  shy: '\\u00AD',\n  reg: '\\u00AE',\n  macr: '\\u00AF',\n  deg: '\\u00B0',\n  plusmn: '\\u00B1',\n  sup2: '\\u00B2',\n  sup3: '\\u00B3',\n  acute: '\\u00B4',\n  micro: '\\u00B5',\n  para: '\\u00B6',\n  middot: '\\u00B7',\n  cedil: '\\u00B8',\n  sup1: '\\u00B9',\n  ordm: '\\u00BA',\n  raquo: '\\u00BB',\n  frac14: '\\u00BC',\n  frac12: '\\u00BD',\n  frac34: '\\u00BE',\n  iquest: '\\u00BF',\n  Agrave: '\\u00C0',\n  Aacute: '\\u00C1',\n  Acirc: '\\u00C2',\n  Atilde: '\\u00C3',\n  Auml: '\\u00C4',\n  Aring: '\\u00C5',\n  AElig: '\\u00C6',\n  Ccedil: '\\u00C7',\n  Egrave: '\\u00C8',\n  Eacute: '\\u00C9',\n  Ecirc: '\\u00CA',\n  Euml: '\\u00CB',\n  Igrave: '\\u00CC',\n  Iacute: '\\u00CD',\n  Icirc: '\\u00CE',\n  Iuml: '\\u00CF',\n  ETH: '\\u00D0',\n  Ntilde: '\\u00D1',\n  Ograve: '\\u00D2',\n  Oacute: '\\u00D3',\n  Ocirc: '\\u00D4',\n  Otilde: '\\u00D5',\n  Ouml: '\\u00D6',\n  times: '\\u00D7',\n  Oslash: '\\u00D8',\n  Ugrave: '\\u00D9',\n  Uacute: '\\u00DA',\n  Ucirc: '\\u00DB',\n  Uuml: '\\u00DC',\n  Yacute: '\\u00DD',\n  THORN: '\\u00DE',\n  szlig: '\\u00DF',\n  agrave: '\\u00E0',\n  aacute: '\\u00E1',\n  acirc: '\\u00E2',\n  atilde: '\\u00E3',\n  auml: '\\u00E4',\n  aring: '\\u00E5',\n  aelig: '\\u00E6',\n  ccedil: '\\u00E7',\n  egrave: '\\u00E8',\n  eacute: '\\u00E9',\n  ecirc: '\\u00EA',\n  euml: '\\u00EB',\n  igrave: '\\u00EC',\n  iacute: '\\u00ED',\n  icirc: '\\u00EE',\n  iuml: '\\u00EF',\n  eth: '\\u00F0',\n  ntilde: '\\u00F1',\n  ograve: '\\u00F2',\n  oacute: '\\u00F3',\n  ocirc: '\\u00F4',\n  otilde: '\\u00F5',\n  ouml: '\\u00F6',\n  divide: '\\u00F7',\n  oslash: '\\u00F8',\n  ugrave: '\\u00F9',\n  uacute: '\\u00FA',\n  ucirc: '\\u00FB',\n  uuml: '\\u00FC',\n  yacute: '\\u00FD',\n  thorn: '\\u00FE',\n  yuml: '\\u00FF',\n  OElig: '\\u0152',\n  oelig: '\\u0153',\n  Scaron: '\\u0160',\n  scaron: '\\u0161',\n  Yuml: '\\u0178',\n  fnof: '\\u0192',\n  circ: '\\u02C6',\n  tilde: '\\u02DC',\n  Alpha: '\\u0391',\n  Beta: '\\u0392',\n  Gamma: '\\u0393',\n  Delta: '\\u0394',\n  Epsilon: '\\u0395',\n  Zeta: '\\u0396',\n  Eta: '\\u0397',\n  Theta: '\\u0398',\n  Iota: '\\u0399',\n  Kappa: '\\u039A',\n  Lambda: '\\u039B',\n  Mu: '\\u039C',\n  Nu: '\\u039D',\n  Xi: '\\u039E',\n  Omicron: '\\u039F',\n  Pi: '\\u03A0',\n  Rho: '\\u03A1',\n  Sigma: '\\u03A3',\n  Tau: '\\u03A4',\n  Upsilon: '\\u03A5',\n  Phi: '\\u03A6',\n  Chi: '\\u03A7',\n  Psi: '\\u03A8',\n  Omega: '\\u03A9',\n  alpha: '\\u03B1',\n  beta: '\\u03B2',\n  gamma: '\\u03B3',\n  delta: '\\u03B4',\n  epsilon: '\\u03B5',\n  zeta: '\\u03B6',\n  eta: '\\u03B7',\n  theta: '\\u03B8',\n  iota: '\\u03B9',\n  kappa: '\\u03BA',\n  lambda: '\\u03BB',\n  mu: '\\u03BC',\n  nu: '\\u03BD',\n  xi: '\\u03BE',\n  omicron: '\\u03BF',\n  pi: '\\u03C0',\n  rho: '\\u03C1',\n  sigmaf: '\\u03C2',\n  sigma: '\\u03C3',\n  tau: '\\u03C4',\n  upsilon: '\\u03C5',\n  phi: '\\u03C6',\n  chi: '\\u03C7',\n  psi: '\\u03C8',\n  omega: '\\u03C9',\n  thetasym: '\\u03D1',\n  upsih: '\\u03D2',\n  piv: '\\u03D6',\n  ensp: '\\u2002',\n  emsp: '\\u2003',\n  thinsp: '\\u2009',\n  zwnj: '\\u200C',\n  zwj: '\\u200D',\n  lrm: '\\u200E',\n  rlm: '\\u200F',\n  ndash: '\\u2013',\n  mdash: '\\u2014',\n  lsquo: '\\u2018',\n  rsquo: '\\u2019',\n  sbquo: '\\u201A',\n  ldquo: '\\u201C',\n  rdquo: '\\u201D',\n  bdquo: '\\u201E',\n  dagger: '\\u2020',\n  Dagger: '\\u2021',\n  bull: '\\u2022',\n  hellip: '\\u2026',\n  permil: '\\u2030',\n  prime: '\\u2032',\n  Prime: '\\u2033',\n  lsaquo: '\\u2039',\n  rsaquo: '\\u203A',\n  oline: '\\u203E',\n  frasl: '\\u2044',\n  euro: '\\u20AC',\n  image: '\\u2111',\n  weierp: '\\u2118',\n  real: '\\u211C',\n  trade: '\\u2122',\n  alefsym: '\\u2135',\n  larr: '\\u2190',\n  uarr: '\\u2191',\n  rarr: '\\u2192',\n  darr: '\\u2193',\n  harr: '\\u2194',\n  crarr: '\\u21B5',\n  lArr: '\\u21D0',\n  uArr: '\\u21D1',\n  rArr: '\\u21D2',\n  dArr: '\\u21D3',\n  hArr: '\\u21D4',\n  forall: '\\u2200',\n  part: '\\u2202',\n  exist: '\\u2203',\n  empty: '\\u2205',\n  nabla: '\\u2207',\n  isin: '\\u2208',\n  notin: '\\u2209',\n  ni: '\\u220B',\n  prod: '\\u220F',\n  sum: '\\u2211',\n  minus: '\\u2212',\n  lowast: '\\u2217',\n  radic: '\\u221A',\n  prop: '\\u221D',\n  infin: '\\u221E',\n  ang: '\\u2220',\n  and: '\\u2227',\n  or: '\\u2228',\n  cap: '\\u2229',\n  cup: '\\u222A',\n  'int': '\\u222B',\n  there4: '\\u2234',\n  sim: '\\u223C',\n  cong: '\\u2245',\n  asymp: '\\u2248',\n  ne: '\\u2260',\n  equiv: '\\u2261',\n  le: '\\u2264',\n  ge: '\\u2265',\n  sub: '\\u2282',\n  sup: '\\u2283',\n  nsub: '\\u2284',\n  sube: '\\u2286',\n  supe: '\\u2287',\n  oplus: '\\u2295',\n  otimes: '\\u2297',\n  perp: '\\u22A5',\n  sdot: '\\u22C5',\n  lceil: '\\u2308',\n  rceil: '\\u2309',\n  lfloor: '\\u230A',\n  rfloor: '\\u230B',\n  lang: '\\u2329',\n  rang: '\\u232A',\n  loz: '\\u25CA',\n  spades: '\\u2660',\n  clubs: '\\u2663',\n  hearts: '\\u2665',\n  diams: '\\u2666'\n};\n\nvar acorn$1 = getCjsExportFromNamespace(acorn);\n\nvar acornJsx = createCommonjsModule(function (module) {\n\n\n\nconst hexNumber = /^[\\da-fA-F]+$/;\nconst decimalNumber = /^\\d+$/;\n\n// The map to `acorn-jsx` tokens from `acorn` namespace objects.\nconst acornJsxMap = new WeakMap();\n\n// Get the original tokens for the given `acorn` namespace object.\nfunction getJsxTokens(acorn) {\n  acorn = acorn.Parser.acorn || acorn;\n  let acornJsx = acornJsxMap.get(acorn);\n  if (!acornJsx) {\n    const tt = acorn.tokTypes;\n    const TokContext = acorn.TokContext;\n    const TokenType = acorn.TokenType;\n    const tc_oTag = new TokContext('<tag', false);\n    const tc_cTag = new TokContext('</tag', false);\n    const tc_expr = new TokContext('<tag>...</tag>', true, true);\n    const tokContexts = {\n      tc_oTag: tc_oTag,\n      tc_cTag: tc_cTag,\n      tc_expr: tc_expr\n    };\n    const tokTypes = {\n      jsxName: new TokenType('jsxName'),\n      jsxText: new TokenType('jsxText', {beforeExpr: true}),\n      jsxTagStart: new TokenType('jsxTagStart'),\n      jsxTagEnd: new TokenType('jsxTagEnd')\n    };\n\n    tokTypes.jsxTagStart.updateContext = function() {\n      this.context.push(tc_expr); // treat as beginning of JSX expression\n      this.context.push(tc_oTag); // start opening tag context\n      this.exprAllowed = false;\n    };\n    tokTypes.jsxTagEnd.updateContext = function(prevType) {\n      let out = this.context.pop();\n      if (out === tc_oTag && prevType === tt.slash || out === tc_cTag) {\n        this.context.pop();\n        this.exprAllowed = this.curContext() === tc_expr;\n      } else {\n        this.exprAllowed = true;\n      }\n    };\n\n    acornJsx = { tokContexts: tokContexts, tokTypes: tokTypes };\n    acornJsxMap.set(acorn, acornJsx);\n  }\n\n  return acornJsx;\n}\n\n// Transforms JSX element name to string.\n\nfunction getQualifiedJSXName(object) {\n  if (!object)\n    return object;\n\n  if (object.type === 'JSXIdentifier')\n    return object.name;\n\n  if (object.type === 'JSXNamespacedName')\n    return object.namespace.name + ':' + object.name.name;\n\n  if (object.type === 'JSXMemberExpression')\n    return getQualifiedJSXName(object.object) + '.' +\n    getQualifiedJSXName(object.property);\n}\n\nmodule.exports = function(options) {\n  options = options || {};\n  return function(Parser) {\n    return plugin({\n      allowNamespaces: options.allowNamespaces !== false,\n      allowNamespacedObjects: !!options.allowNamespacedObjects\n    }, Parser);\n  };\n};\n\n// This is `tokTypes` of the peer dep.\n// This can be different instances from the actual `tokTypes` this plugin uses.\nObject.defineProperty(module.exports, \"tokTypes\", {\n  get: function get_tokTypes() {\n    return getJsxTokens(acorn$1).tokTypes;\n  },\n  configurable: true,\n  enumerable: true\n});\n\nfunction plugin(options, Parser) {\n  const acorn = Parser.acorn || acorn$1;\n  const acornJsx = getJsxTokens(acorn);\n  const tt = acorn.tokTypes;\n  const tok = acornJsx.tokTypes;\n  const tokContexts = acorn.tokContexts;\n  const tc_oTag = acornJsx.tokContexts.tc_oTag;\n  const tc_cTag = acornJsx.tokContexts.tc_cTag;\n  const tc_expr = acornJsx.tokContexts.tc_expr;\n  const isNewLine = acorn.isNewLine;\n  const isIdentifierStart = acorn.isIdentifierStart;\n  const isIdentifierChar = acorn.isIdentifierChar;\n\n  return class extends Parser {\n    // Expose actual `tokTypes` and `tokContexts` to other plugins.\n    static get acornJsx() {\n      return acornJsx;\n    }\n\n    // Reads inline JSX contents token.\n    jsx_readToken() {\n      let out = '', chunkStart = this.pos;\n      for (;;) {\n        if (this.pos >= this.input.length)\n          this.raise(this.start, 'Unterminated JSX contents');\n        let ch = this.input.charCodeAt(this.pos);\n\n        switch (ch) {\n        case 60: // '<'\n        case 123: // '{'\n          if (this.pos === this.start) {\n            if (ch === 60 && this.exprAllowed) {\n              ++this.pos;\n              return this.finishToken(tok.jsxTagStart);\n            }\n            return this.getTokenFromCode(ch);\n          }\n          out += this.input.slice(chunkStart, this.pos);\n          return this.finishToken(tok.jsxText, out);\n\n        case 38: // '&'\n          out += this.input.slice(chunkStart, this.pos);\n          out += this.jsx_readEntity();\n          chunkStart = this.pos;\n          break;\n\n        case 62: // '>'\n        case 125: // '}'\n          this.raise(\n            this.pos,\n            \"Unexpected token `\" + this.input[this.pos] + \"`. Did you mean `\" +\n              (ch === 62 ? \"&gt;\" : \"&rbrace;\") + \"` or \" + \"`{\\\"\" + this.input[this.pos] + \"\\\"}\" + \"`?\"\n          );\n\n        default:\n          if (isNewLine(ch)) {\n            out += this.input.slice(chunkStart, this.pos);\n            out += this.jsx_readNewLine(true);\n            chunkStart = this.pos;\n          } else {\n            ++this.pos;\n          }\n        }\n      }\n    }\n\n    jsx_readNewLine(normalizeCRLF) {\n      let ch = this.input.charCodeAt(this.pos);\n      let out;\n      ++this.pos;\n      if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {\n        ++this.pos;\n        out = normalizeCRLF ? '\\n' : '\\r\\n';\n      } else {\n        out = String.fromCharCode(ch);\n      }\n      if (this.options.locations) {\n        ++this.curLine;\n        this.lineStart = this.pos;\n      }\n\n      return out;\n    }\n\n    jsx_readString(quote) {\n      let out = '', chunkStart = ++this.pos;\n      for (;;) {\n        if (this.pos >= this.input.length)\n          this.raise(this.start, 'Unterminated string constant');\n        let ch = this.input.charCodeAt(this.pos);\n        if (ch === quote) break;\n        if (ch === 38) { // '&'\n          out += this.input.slice(chunkStart, this.pos);\n          out += this.jsx_readEntity();\n          chunkStart = this.pos;\n        } else if (isNewLine(ch)) {\n          out += this.input.slice(chunkStart, this.pos);\n          out += this.jsx_readNewLine(false);\n          chunkStart = this.pos;\n        } else {\n          ++this.pos;\n        }\n      }\n      out += this.input.slice(chunkStart, this.pos++);\n      return this.finishToken(tt.string, out);\n    }\n\n    jsx_readEntity() {\n      let str = '', count = 0, entity;\n      let ch = this.input[this.pos];\n      if (ch !== '&')\n        this.raise(this.pos, 'Entity must start with an ampersand');\n      let startPos = ++this.pos;\n      while (this.pos < this.input.length && count++ < 10) {\n        ch = this.input[this.pos++];\n        if (ch === ';') {\n          if (str[0] === '#') {\n            if (str[1] === 'x') {\n              str = str.substr(2);\n              if (hexNumber.test(str))\n                entity = String.fromCharCode(parseInt(str, 16));\n            } else {\n              str = str.substr(1);\n              if (decimalNumber.test(str))\n                entity = String.fromCharCode(parseInt(str, 10));\n            }\n          } else {\n            entity = xhtml[str];\n          }\n          break;\n        }\n        str += ch;\n      }\n      if (!entity) {\n        this.pos = startPos;\n        return '&';\n      }\n      return entity;\n    }\n\n    // Read a JSX identifier (valid tag or attribute name).\n    //\n    // Optimized version since JSX identifiers can't contain\n    // escape characters and so can be read as single slice.\n    // Also assumes that first character was already checked\n    // by isIdentifierStart in readToken.\n\n    jsx_readWord() {\n      let ch, start = this.pos;\n      do {\n        ch = this.input.charCodeAt(++this.pos);\n      } while (isIdentifierChar(ch) || ch === 45); // '-'\n      return this.finishToken(tok.jsxName, this.input.slice(start, this.pos));\n    }\n\n    // Parse next token as JSX identifier\n\n    jsx_parseIdentifier() {\n      let node = this.startNode();\n      if (this.type === tok.jsxName)\n        node.name = this.value;\n      else if (this.type.keyword)\n        node.name = this.type.keyword;\n      else\n        this.unexpected();\n      this.next();\n      return this.finishNode(node, 'JSXIdentifier');\n    }\n\n    // Parse namespaced identifier.\n\n    jsx_parseNamespacedName() {\n      let startPos = this.start, startLoc = this.startLoc;\n      let name = this.jsx_parseIdentifier();\n      if (!options.allowNamespaces || !this.eat(tt.colon)) return name;\n      var node = this.startNodeAt(startPos, startLoc);\n      node.namespace = name;\n      node.name = this.jsx_parseIdentifier();\n      return this.finishNode(node, 'JSXNamespacedName');\n    }\n\n    // Parses element name in any form - namespaced, member\n    // or single identifier.\n\n    jsx_parseElementName() {\n      if (this.type === tok.jsxTagEnd) return '';\n      let startPos = this.start, startLoc = this.startLoc;\n      let node = this.jsx_parseNamespacedName();\n      if (this.type === tt.dot && node.type === 'JSXNamespacedName' && !options.allowNamespacedObjects) {\n        this.unexpected();\n      }\n      while (this.eat(tt.dot)) {\n        let newNode = this.startNodeAt(startPos, startLoc);\n        newNode.object = node;\n        newNode.property = this.jsx_parseIdentifier();\n        node = this.finishNode(newNode, 'JSXMemberExpression');\n      }\n      return node;\n    }\n\n    // Parses any type of JSX attribute value.\n\n    jsx_parseAttributeValue() {\n      switch (this.type) {\n      case tt.braceL:\n        let node = this.jsx_parseExpressionContainer();\n        if (node.expression.type === 'JSXEmptyExpression')\n          this.raise(node.start, 'JSX attributes must only be assigned a non-empty expression');\n        return node;\n\n      case tok.jsxTagStart:\n      case tt.string:\n        return this.parseExprAtom();\n\n      default:\n        this.raise(this.start, 'JSX value should be either an expression or a quoted JSX text');\n      }\n    }\n\n    // JSXEmptyExpression is unique type since it doesn't actually parse anything,\n    // and so it should start at the end of last read token (left brace) and finish\n    // at the beginning of the next one (right brace).\n\n    jsx_parseEmptyExpression() {\n      let node = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);\n      return this.finishNodeAt(node, 'JSXEmptyExpression', this.start, this.startLoc);\n    }\n\n    // Parses JSX expression enclosed into curly brackets.\n\n    jsx_parseExpressionContainer() {\n      let node = this.startNode();\n      this.next();\n      node.expression = this.type === tt.braceR\n        ? this.jsx_parseEmptyExpression()\n        : this.parseExpression();\n      this.expect(tt.braceR);\n      return this.finishNode(node, 'JSXExpressionContainer');\n    }\n\n    // Parses following JSX attribute name-value pair.\n\n    jsx_parseAttribute() {\n      let node = this.startNode();\n      if (this.eat(tt.braceL)) {\n        this.expect(tt.ellipsis);\n        node.argument = this.parseMaybeAssign();\n        this.expect(tt.braceR);\n        return this.finishNode(node, 'JSXSpreadAttribute');\n      }\n      node.name = this.jsx_parseNamespacedName();\n      node.value = this.eat(tt.eq) ? this.jsx_parseAttributeValue() : null;\n      return this.finishNode(node, 'JSXAttribute');\n    }\n\n    // Parses JSX opening tag starting after '<'.\n\n    jsx_parseOpeningElementAt(startPos, startLoc) {\n      let node = this.startNodeAt(startPos, startLoc);\n      node.attributes = [];\n      let nodeName = this.jsx_parseElementName();\n      if (nodeName) node.name = nodeName;\n      while (this.type !== tt.slash && this.type !== tok.jsxTagEnd)\n        node.attributes.push(this.jsx_parseAttribute());\n      node.selfClosing = this.eat(tt.slash);\n      this.expect(tok.jsxTagEnd);\n      return this.finishNode(node, nodeName ? 'JSXOpeningElement' : 'JSXOpeningFragment');\n    }\n\n    // Parses JSX closing tag starting after '</'.\n\n    jsx_parseClosingElementAt(startPos, startLoc) {\n      let node = this.startNodeAt(startPos, startLoc);\n      let nodeName = this.jsx_parseElementName();\n      if (nodeName) node.name = nodeName;\n      this.expect(tok.jsxTagEnd);\n      return this.finishNode(node, nodeName ? 'JSXClosingElement' : 'JSXClosingFragment');\n    }\n\n    // Parses entire JSX element, including it's opening tag\n    // (starting after '<'), attributes, contents and closing tag.\n\n    jsx_parseElementAt(startPos, startLoc) {\n      let node = this.startNodeAt(startPos, startLoc);\n      let children = [];\n      let openingElement = this.jsx_parseOpeningElementAt(startPos, startLoc);\n      let closingElement = null;\n\n      if (!openingElement.selfClosing) {\n        contents: for (;;) {\n          switch (this.type) {\n          case tok.jsxTagStart:\n            startPos = this.start; startLoc = this.startLoc;\n            this.next();\n            if (this.eat(tt.slash)) {\n              closingElement = this.jsx_parseClosingElementAt(startPos, startLoc);\n              break contents;\n            }\n            children.push(this.jsx_parseElementAt(startPos, startLoc));\n            break;\n\n          case tok.jsxText:\n            children.push(this.parseExprAtom());\n            break;\n\n          case tt.braceL:\n            children.push(this.jsx_parseExpressionContainer());\n            break;\n\n          default:\n            this.unexpected();\n          }\n        }\n        if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {\n          this.raise(\n            closingElement.start,\n            'Expected corresponding JSX closing tag for <' + getQualifiedJSXName(openingElement.name) + '>');\n        }\n      }\n      let fragmentOrElement = openingElement.name ? 'Element' : 'Fragment';\n\n      node['opening' + fragmentOrElement] = openingElement;\n      node['closing' + fragmentOrElement] = closingElement;\n      node.children = children;\n      if (this.type === tt.relational && this.value === \"<\") {\n        this.raise(this.start, \"Adjacent JSX elements must be wrapped in an enclosing tag\");\n      }\n      return this.finishNode(node, 'JSX' + fragmentOrElement);\n    }\n\n    // Parse JSX text\n\n    jsx_parseText() {\n      let node = this.parseLiteral(this.value);\n      node.type = \"JSXText\";\n      return node;\n    }\n\n    // Parses entire JSX element from current position.\n\n    jsx_parseElement() {\n      let startPos = this.start, startLoc = this.startLoc;\n      this.next();\n      return this.jsx_parseElementAt(startPos, startLoc);\n    }\n\n    parseExprAtom(refShortHandDefaultPos) {\n      if (this.type === tok.jsxText)\n        return this.jsx_parseText();\n      else if (this.type === tok.jsxTagStart)\n        return this.jsx_parseElement();\n      else\n        return super.parseExprAtom(refShortHandDefaultPos);\n    }\n\n    readToken(code) {\n      let context = this.curContext();\n\n      if (context === tc_expr) return this.jsx_readToken();\n\n      if (context === tc_oTag || context === tc_cTag) {\n        if (isIdentifierStart(code)) return this.jsx_readWord();\n\n        if (code == 62) {\n          ++this.pos;\n          return this.finishToken(tok.jsxTagEnd);\n        }\n\n        if ((code === 34 || code === 39) && context == tc_oTag)\n          return this.jsx_readString(code);\n      }\n\n      if (code === 60 && this.exprAllowed && this.input.charCodeAt(this.pos + 1) !== 33) {\n        ++this.pos;\n        return this.finishToken(tok.jsxTagStart);\n      }\n      return super.readToken(code);\n    }\n\n    updateContext(prevType) {\n      if (this.type == tt.braceL) {\n        var curContext = this.curContext();\n        if (curContext == tc_oTag) this.context.push(tokContexts.b_expr);\n        else if (curContext == tc_expr) this.context.push(tokContexts.b_tmpl);\n        else super.updateContext(prevType);\n        this.exprAllowed = true;\n      } else if (this.type === tt.slash && prevType === tok.jsxTagStart) {\n        this.context.length -= 2; // do not consider JSX expr -> JSX open tag -> ... anymore\n        this.context.push(tc_cTag); // reconsider as closing tag context\n        this.exprAllowed = false;\n      } else {\n        return super.updateContext(prevType);\n      }\n    }\n  };\n}\n});\n\n/**\n * @fileoverview The AST node types produced by the parser.\n * @author Nicholas C. Zakas\n */\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n// None!\n\n//------------------------------------------------------------------------------\n// Public\n//------------------------------------------------------------------------------\n\nvar astNodeTypes = {\n    AssignmentExpression: \"AssignmentExpression\",\n    AssignmentPattern: \"AssignmentPattern\",\n    ArrayExpression: \"ArrayExpression\",\n    ArrayPattern: \"ArrayPattern\",\n    ArrowFunctionExpression: \"ArrowFunctionExpression\",\n    AwaitExpression: \"AwaitExpression\",\n    BlockStatement: \"BlockStatement\",\n    BinaryExpression: \"BinaryExpression\",\n    BreakStatement: \"BreakStatement\",\n    CallExpression: \"CallExpression\",\n    CatchClause: \"CatchClause\",\n    ClassBody: \"ClassBody\",\n    ClassDeclaration: \"ClassDeclaration\",\n    ClassExpression: \"ClassExpression\",\n    ConditionalExpression: \"ConditionalExpression\",\n    ContinueStatement: \"ContinueStatement\",\n    DoWhileStatement: \"DoWhileStatement\",\n    DebuggerStatement: \"DebuggerStatement\",\n    EmptyStatement: \"EmptyStatement\",\n    ExpressionStatement: \"ExpressionStatement\",\n    ForStatement: \"ForStatement\",\n    ForInStatement: \"ForInStatement\",\n    ForOfStatement: \"ForOfStatement\",\n    FunctionDeclaration: \"FunctionDeclaration\",\n    FunctionExpression: \"FunctionExpression\",\n    Identifier: \"Identifier\",\n    IfStatement: \"IfStatement\",\n    Literal: \"Literal\",\n    LabeledStatement: \"LabeledStatement\",\n    LogicalExpression: \"LogicalExpression\",\n    MemberExpression: \"MemberExpression\",\n    MetaProperty: \"MetaProperty\",\n    MethodDefinition: \"MethodDefinition\",\n    NewExpression: \"NewExpression\",\n    ObjectExpression: \"ObjectExpression\",\n    ObjectPattern: \"ObjectPattern\",\n    Program: \"Program\",\n    Property: \"Property\",\n    RestElement: \"RestElement\",\n    ReturnStatement: \"ReturnStatement\",\n    SequenceExpression: \"SequenceExpression\",\n    SpreadElement: \"SpreadElement\",\n    Super: \"Super\",\n    SwitchCase: \"SwitchCase\",\n    SwitchStatement: \"SwitchStatement\",\n    TaggedTemplateExpression: \"TaggedTemplateExpression\",\n    TemplateElement: \"TemplateElement\",\n    TemplateLiteral: \"TemplateLiteral\",\n    ThisExpression: \"ThisExpression\",\n    ThrowStatement: \"ThrowStatement\",\n    TryStatement: \"TryStatement\",\n    UnaryExpression: \"UnaryExpression\",\n    UpdateExpression: \"UpdateExpression\",\n    VariableDeclaration: \"VariableDeclaration\",\n    VariableDeclarator: \"VariableDeclarator\",\n    WhileStatement: \"WhileStatement\",\n    WithStatement: \"WithStatement\",\n    YieldExpression: \"YieldExpression\",\n    JSXIdentifier: \"JSXIdentifier\",\n    JSXNamespacedName: \"JSXNamespacedName\",\n    JSXMemberExpression: \"JSXMemberExpression\",\n    JSXEmptyExpression: \"JSXEmptyExpression\",\n    JSXExpressionContainer: \"JSXExpressionContainer\",\n    JSXElement: \"JSXElement\",\n    JSXClosingElement: \"JSXClosingElement\",\n    JSXOpeningElement: \"JSXOpeningElement\",\n    JSXAttribute: \"JSXAttribute\",\n    JSXSpreadAttribute: \"JSXSpreadAttribute\",\n    JSXText: \"JSXText\",\n    ExportDefaultDeclaration: \"ExportDefaultDeclaration\",\n    ExportNamedDeclaration: \"ExportNamedDeclaration\",\n    ExportAllDeclaration: \"ExportAllDeclaration\",\n    ExportSpecifier: \"ExportSpecifier\",\n    ImportDeclaration: \"ImportDeclaration\",\n    ImportSpecifier: \"ImportSpecifier\",\n    ImportDefaultSpecifier: \"ImportDefaultSpecifier\",\n    ImportNamespaceSpecifier: \"ImportNamespaceSpecifier\"\n};\n\n/**\n * @fileoverview Translates tokens between Acorn format and Esprima format.\n * @author Nicholas C. Zakas\n */\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n// none!\n\n//------------------------------------------------------------------------------\n// Private\n//------------------------------------------------------------------------------\n\n\n// Esprima Token Types\nconst Token$1 = {\n    Boolean: \"Boolean\",\n    EOF: \"<end>\",\n    Identifier: \"Identifier\",\n    Keyword: \"Keyword\",\n    Null: \"Null\",\n    Numeric: \"Numeric\",\n    Punctuator: \"Punctuator\",\n    String: \"String\",\n    RegularExpression: \"RegularExpression\",\n    Template: \"Template\",\n    JSXIdentifier: \"JSXIdentifier\",\n    JSXText: \"JSXText\"\n};\n\n/**\n * Converts part of a template into an Esprima token.\n * @param {AcornToken[]} tokens The Acorn tokens representing the template.\n * @param {string} code The source code.\n * @returns {EsprimaToken} The Esprima equivalent of the template token.\n * @private\n */\nfunction convertTemplatePart(tokens, code) {\n    const firstToken = tokens[0],\n        lastTemplateToken = tokens[tokens.length - 1];\n\n    const token = {\n        type: Token$1.Template,\n        value: code.slice(firstToken.start, lastTemplateToken.end)\n    };\n\n    if (firstToken.loc) {\n        token.loc = {\n            start: firstToken.loc.start,\n            end: lastTemplateToken.loc.end\n        };\n    }\n\n    if (firstToken.range) {\n        token.start = firstToken.range[0];\n        token.end = lastTemplateToken.range[1];\n        token.range = [token.start, token.end];\n    }\n\n    return token;\n}\n\n/**\n * Contains logic to translate Acorn tokens into Esprima tokens.\n * @param {Object} acornTokTypes The Acorn token types.\n * @param {string} code The source code Acorn is parsing. This is necessary\n *      to correct the \"value\" property of some tokens.\n * @constructor\n */\nfunction TokenTranslator(acornTokTypes, code) {\n\n    // token types\n    this._acornTokTypes = acornTokTypes;\n\n    // token buffer for templates\n    this._tokens = [];\n\n    // track the last curly brace\n    this._curlyBrace = null;\n\n    // the source code\n    this._code = code;\n\n}\n\nTokenTranslator.prototype = {\n    constructor: TokenTranslator,\n\n    /**\n     * Translates a single Esprima token to a single Acorn token. This may be\n     * inaccurate due to how templates are handled differently in Esprima and\n     * Acorn, but should be accurate for all other tokens.\n     * @param {AcornToken} token The Acorn token to translate.\n     * @param {Object} extra Espree extra object.\n     * @returns {EsprimaToken} The Esprima version of the token.\n     */\n    translate(token, extra) {\n\n        const type = token.type,\n            tt = this._acornTokTypes;\n\n        if (type === tt.name) {\n            token.type = Token$1.Identifier;\n\n            // TODO: See if this is an Acorn bug\n            if (token.value === \"static\") {\n                token.type = Token$1.Keyword;\n            }\n\n            if (extra.ecmaVersion > 5 && (token.value === \"yield\" || token.value === \"let\")) {\n                token.type = Token$1.Keyword;\n            }\n\n        } else if (type === tt.semi || type === tt.comma ||\n                 type === tt.parenL || type === tt.parenR ||\n                 type === tt.braceL || type === tt.braceR ||\n                 type === tt.dot || type === tt.bracketL ||\n                 type === tt.colon || type === tt.question ||\n                 type === tt.bracketR || type === tt.ellipsis ||\n                 type === tt.arrow || type === tt.jsxTagStart ||\n                 type === tt.incDec || type === tt.starstar ||\n                 type === tt.jsxTagEnd || type === tt.prefix ||\n                 (type.binop && !type.keyword) ||\n                 type.isAssign) {\n\n            token.type = Token$1.Punctuator;\n            token.value = this._code.slice(token.start, token.end);\n        } else if (type === tt.jsxName) {\n            token.type = Token$1.JSXIdentifier;\n        } else if (type.label === \"jsxText\" || type === tt.jsxAttrValueToken) {\n            token.type = Token$1.JSXText;\n        } else if (type.keyword) {\n            if (type.keyword === \"true\" || type.keyword === \"false\") {\n                token.type = Token$1.Boolean;\n            } else if (type.keyword === \"null\") {\n                token.type = Token$1.Null;\n            } else {\n                token.type = Token$1.Keyword;\n            }\n        } else if (type === tt.num) {\n            token.type = Token$1.Numeric;\n            token.value = this._code.slice(token.start, token.end);\n        } else if (type === tt.string) {\n\n            if (extra.jsxAttrValueToken) {\n                extra.jsxAttrValueToken = false;\n                token.type = Token$1.JSXText;\n            } else {\n                token.type = Token$1.String;\n            }\n\n            token.value = this._code.slice(token.start, token.end);\n        } else if (type === tt.regexp) {\n            token.type = Token$1.RegularExpression;\n            const value = token.value;\n\n            token.regex = {\n                flags: value.flags,\n                pattern: value.pattern\n            };\n            token.value = `/${value.pattern}/${value.flags}`;\n        }\n\n        return token;\n    },\n\n    /**\n     * Function to call during Acorn's onToken handler.\n     * @param {AcornToken} token The Acorn token.\n     * @param {Object} extra The Espree extra object.\n     * @returns {void}\n     */\n    onToken(token, extra) {\n\n        const that = this,\n            tt = this._acornTokTypes,\n            tokens = extra.tokens,\n            templateTokens = this._tokens;\n\n        /**\n         * Flushes the buffered template tokens and resets the template\n         * tracking.\n         * @returns {void}\n         * @private\n         */\n        function translateTemplateTokens() {\n            tokens.push(convertTemplatePart(that._tokens, that._code));\n            that._tokens = [];\n        }\n\n        if (token.type === tt.eof) {\n\n            // might be one last curlyBrace\n            if (this._curlyBrace) {\n                tokens.push(this.translate(this._curlyBrace, extra));\n            }\n\n            return;\n        }\n\n        if (token.type === tt.backQuote) {\n\n            // if there's already a curly, it's not part of the template\n            if (this._curlyBrace) {\n                tokens.push(this.translate(this._curlyBrace, extra));\n                this._curlyBrace = null;\n            }\n\n            templateTokens.push(token);\n\n            // it's the end\n            if (templateTokens.length > 1) {\n                translateTemplateTokens();\n            }\n\n            return;\n        }\n        if (token.type === tt.dollarBraceL) {\n            templateTokens.push(token);\n            translateTemplateTokens();\n            return;\n        }\n        if (token.type === tt.braceR) {\n\n            // if there's already a curly, it's not part of the template\n            if (this._curlyBrace) {\n                tokens.push(this.translate(this._curlyBrace, extra));\n            }\n\n            // store new curly for later\n            this._curlyBrace = token;\n            return;\n        }\n        if (token.type === tt.template || token.type === tt.invalidTemplate) {\n            if (this._curlyBrace) {\n                templateTokens.push(this._curlyBrace);\n                this._curlyBrace = null;\n            }\n\n            templateTokens.push(token);\n            return;\n        }\n\n        if (this._curlyBrace) {\n            tokens.push(this.translate(this._curlyBrace, extra));\n            this._curlyBrace = null;\n        }\n\n        tokens.push(this.translate(token, extra));\n    }\n};\n\n//------------------------------------------------------------------------------\n// Public\n//------------------------------------------------------------------------------\n\nvar tokenTranslator = TokenTranslator;\n\n/**\n * @fileoverview A collection of methods for processing Espree's options.\n * @author Kai Cataldo\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst DEFAULT_ECMA_VERSION = 5;\nconst SUPPORTED_VERSIONS = [\n    3,\n    5,\n    6,\n    7,\n    8,\n    9,\n    10,\n    11\n];\n\n/**\n * Normalize ECMAScript version from the initial config\n * @param {number} ecmaVersion ECMAScript version from the initial config\n * @throws {Error} throws an error if the ecmaVersion is invalid.\n * @returns {number} normalized ECMAScript version\n */\nfunction normalizeEcmaVersion(ecmaVersion = DEFAULT_ECMA_VERSION) {\n    if (typeof ecmaVersion !== \"number\") {\n        throw new Error(`ecmaVersion must be a number. Received value of type ${typeof ecmaVersion} instead.`);\n    }\n\n    let version = ecmaVersion;\n\n    // Calculate ECMAScript edition number from official year version starting with\n    // ES2015, which corresponds with ES6 (or a difference of 2009).\n    if (version >= 2015) {\n        version -= 2009;\n    }\n\n    if (!SUPPORTED_VERSIONS.includes(version)) {\n        throw new Error(\"Invalid ecmaVersion.\");\n    }\n\n    return version;\n}\n\n/**\n * Normalize sourceType from the initial config\n * @param {string} sourceType to normalize\n * @throws {Error} throw an error if sourceType is invalid\n * @returns {string} normalized sourceType\n */\nfunction normalizeSourceType(sourceType = \"script\") {\n    if (sourceType === \"script\" || sourceType === \"module\") {\n        return sourceType;\n    }\n    throw new Error(\"Invalid sourceType.\");\n}\n\n/**\n * Normalize parserOptions\n * @param {Object} options the parser options to normalize\n * @throws {Error} throw an error if found invalid option.\n * @returns {Object} normalized options\n */\nfunction normalizeOptions(options) {\n    const ecmaVersion = normalizeEcmaVersion(options.ecmaVersion);\n    const sourceType = normalizeSourceType(options.sourceType);\n    const ranges = options.range === true;\n    const locations = options.loc === true;\n\n    if (sourceType === \"module\" && ecmaVersion < 6) {\n        throw new Error(\"sourceType 'module' is not supported when ecmaVersion < 2015. Consider adding `{ ecmaVersion: 2015 }` to the parser options.\");\n    }\n    return Object.assign({}, options, { ecmaVersion, sourceType, ranges, locations });\n}\n\n/**\n * Get the latest ECMAScript version supported by Espree.\n * @returns {number} The latest ECMAScript version.\n */\nfunction getLatestEcmaVersion() {\n    return SUPPORTED_VERSIONS[SUPPORTED_VERSIONS.length - 1];\n}\n\n/**\n * Get the list of ECMAScript versions supported by Espree.\n * @returns {number[]} An array containing the supported ECMAScript versions.\n */\nfunction getSupportedEcmaVersions() {\n    return [...SUPPORTED_VERSIONS];\n}\n\n//------------------------------------------------------------------------------\n// Public\n//------------------------------------------------------------------------------\n\nvar options = {\n    normalizeOptions,\n    getLatestEcmaVersion,\n    getSupportedEcmaVersions\n};\n\n/* eslint-disable no-param-reassign*/\n\nconst { normalizeOptions: normalizeOptions$1 } = options;\n\nconst STATE = Symbol(\"espree's internal state\");\nconst ESPRIMA_FINISH_NODE = Symbol(\"espree's esprimaFinishNode\");\n\n\n/**\n * Converts an Acorn comment to a Esprima comment.\n * @param {boolean} block True if it's a block comment, false if not.\n * @param {string} text The text of the comment.\n * @param {int} start The index at which the comment starts.\n * @param {int} end The index at which the comment ends.\n * @param {Location} startLoc The location at which the comment starts.\n * @param {Location} endLoc The location at which the comment ends.\n * @returns {Object} The comment object.\n * @private\n */\nfunction convertAcornCommentToEsprimaComment(block, text, start, end, startLoc, endLoc) {\n    const comment = {\n        type: block ? \"Block\" : \"Line\",\n        value: text\n    };\n\n    if (typeof start === \"number\") {\n        comment.start = start;\n        comment.end = end;\n        comment.range = [start, end];\n    }\n\n    if (typeof startLoc === \"object\") {\n        comment.loc = {\n            start: startLoc,\n            end: endLoc\n        };\n    }\n\n    return comment;\n}\n\nvar espree = () => Parser => {\n    const tokTypes = Object.assign({}, Parser.acorn.tokTypes);\n\n    if (Parser.acornJsx) {\n        Object.assign(tokTypes, Parser.acornJsx.tokTypes);\n    }\n\n    return class Espree extends Parser {\n        constructor(opts, code) {\n            if (typeof opts !== \"object\" || opts === null) {\n                opts = {};\n            }\n            if (typeof code !== \"string\" && !(code instanceof String)) {\n                code = String(code);\n            }\n\n            const options = normalizeOptions$1(opts);\n            const ecmaFeatures = options.ecmaFeatures || {};\n            const tokenTranslator$1 =\n                options.tokens === true\n                    ? new tokenTranslator(tokTypes, code)\n                    : null;\n\n            // Initialize acorn parser.\n            super({\n\n                // TODO: use {...options} when spread is supported(Node.js >= 8.3.0).\n                ecmaVersion: options.ecmaVersion,\n                sourceType: options.sourceType,\n                ranges: options.ranges,\n                locations: options.locations,\n\n                // Truthy value is true for backward compatibility.\n                allowReturnOutsideFunction: Boolean(ecmaFeatures.globalReturn),\n\n                // Collect tokens\n                onToken: token => {\n                    if (tokenTranslator$1) {\n\n                        // Use `tokens`, `ecmaVersion`, and `jsxAttrValueToken` in the state.\n                        tokenTranslator$1.onToken(token, this[STATE]);\n                    }\n                    if (token.type !== tokTypes.eof) {\n                        this[STATE].lastToken = token;\n                    }\n                },\n\n                // Collect comments\n                onComment: (block, text, start, end, startLoc, endLoc) => {\n                    if (this[STATE].comments) {\n                        const comment = convertAcornCommentToEsprimaComment(block, text, start, end, startLoc, endLoc);\n\n                        this[STATE].comments.push(comment);\n                    }\n                }\n            }, code);\n\n            // Initialize internal state.\n            this[STATE] = {\n                tokens: tokenTranslator$1 ? [] : null,\n                comments: options.comment === true ? [] : null,\n                impliedStrict: ecmaFeatures.impliedStrict === true && this.options.ecmaVersion >= 5,\n                ecmaVersion: this.options.ecmaVersion,\n                jsxAttrValueToken: false,\n                lastToken: null\n            };\n        }\n\n        tokenize() {\n            do {\n                this.next();\n            } while (this.type !== tokTypes.eof);\n\n            // Consume the final eof token\n            this.next();\n\n            const extra = this[STATE];\n            const tokens = extra.tokens;\n\n            if (extra.comments) {\n                tokens.comments = extra.comments;\n            }\n\n            return tokens;\n        }\n\n        finishNode(...args) {\n            const result = super.finishNode(...args);\n\n            return this[ESPRIMA_FINISH_NODE](result);\n        }\n\n        finishNodeAt(...args) {\n            const result = super.finishNodeAt(...args);\n\n            return this[ESPRIMA_FINISH_NODE](result);\n        }\n\n        parse() {\n            const extra = this[STATE];\n            const program = super.parse();\n\n            program.sourceType = this.options.sourceType;\n\n            if (extra.comments) {\n                program.comments = extra.comments;\n            }\n            if (extra.tokens) {\n                program.tokens = extra.tokens;\n            }\n\n            /*\n             * Adjust opening and closing position of program to match Esprima.\n             * Acorn always starts programs at range 0 whereas Esprima starts at the\n             * first AST node's start (the only real difference is when there's leading\n             * whitespace or leading comments). Acorn also counts trailing whitespace\n             * as part of the program whereas Esprima only counts up to the last token.\n             */\n            if (program.range) {\n                program.range[0] = program.body.length ? program.body[0].range[0] : program.range[0];\n                program.range[1] = extra.lastToken ? extra.lastToken.range[1] : program.range[1];\n            }\n            if (program.loc) {\n                program.loc.start = program.body.length ? program.body[0].loc.start : program.loc.start;\n                program.loc.end = extra.lastToken ? extra.lastToken.loc.end : program.loc.end;\n            }\n\n            return program;\n        }\n\n        parseTopLevel(node) {\n            if (this[STATE].impliedStrict) {\n                this.strict = true;\n            }\n            return super.parseTopLevel(node);\n        }\n\n        /**\n         * Overwrites the default raise method to throw Esprima-style errors.\n         * @param {int} pos The position of the error.\n         * @param {string} message The error message.\n         * @throws {SyntaxError} A syntax error.\n         * @returns {void}\n         */\n        raise(pos, message) {\n            const loc = Parser.acorn.getLineInfo(this.input, pos);\n            const err = new SyntaxError(message);\n\n            err.index = pos;\n            err.lineNumber = loc.line;\n            err.column = loc.column + 1; // acorn uses 0-based columns\n            throw err;\n        }\n\n        /**\n         * Overwrites the default raise method to throw Esprima-style errors.\n         * @param {int} pos The position of the error.\n         * @param {string} message The error message.\n         * @throws {SyntaxError} A syntax error.\n         * @returns {void}\n         */\n        raiseRecoverable(pos, message) {\n            this.raise(pos, message);\n        }\n\n        /**\n         * Overwrites the default unexpected method to throw Esprima-style errors.\n         * @param {int} pos The position of the error.\n         * @throws {SyntaxError} A syntax error.\n         * @returns {void}\n         */\n        unexpected(pos) {\n            let message = \"Unexpected token\";\n\n            if (pos !== null && pos !== void 0) {\n                this.pos = pos;\n\n                if (this.options.locations) {\n                    while (this.pos < this.lineStart) {\n                        this.lineStart = this.input.lastIndexOf(\"\\n\", this.lineStart - 2) + 1;\n                        --this.curLine;\n                    }\n                }\n\n                this.nextToken();\n            }\n\n            if (this.end > this.start) {\n                message += ` ${this.input.slice(this.start, this.end)}`;\n            }\n\n            this.raise(this.start, message);\n        }\n\n        /*\n        * Esprima-FB represents JSX strings as tokens called \"JSXText\", but Acorn-JSX\n        * uses regular tt.string without any distinction between this and regular JS\n        * strings. As such, we intercept an attempt to read a JSX string and set a flag\n        * on extra so that when tokens are converted, the next token will be switched\n        * to JSXText via onToken.\n        */\n        jsx_readString(quote) { // eslint-disable-line camelcase\n            const result = super.jsx_readString(quote);\n\n            if (this.type === tokTypes.string) {\n                this[STATE].jsxAttrValueToken = true;\n            }\n            return result;\n        }\n\n        /**\n         * Performs last-minute Esprima-specific compatibility checks and fixes.\n         * @param {ASTNode} result The node to check.\n         * @returns {ASTNode} The finished node.\n         */\n        [ESPRIMA_FINISH_NODE](result) {\n\n            // Acorn doesn't count the opening and closing backticks as part of templates\n            // so we have to adjust ranges/locations appropriately.\n            if (result.type === \"TemplateElement\") {\n\n                // additional adjustment needed if ${ is the last token\n                const terminalDollarBraceL = this.input.slice(result.end, result.end + 2) === \"${\";\n\n                if (result.range) {\n                    result.range[0]--;\n                    result.range[1] += (terminalDollarBraceL ? 2 : 1);\n                }\n\n                if (result.loc) {\n                    result.loc.start.column--;\n                    result.loc.end.column += (terminalDollarBraceL ? 2 : 1);\n                }\n            }\n\n            if (result.type.indexOf(\"Function\") > -1 && !result.generator) {\n                result.generator = false;\n            }\n\n            return result;\n        }\n    };\n};\n\nvar name$4 = \"espree\";\nvar description$4 = \"An Esprima-compatible JavaScript parser built on Acorn\";\nvar author$1 = \"Nicholas C. Zakas <nicholas+npm@nczconsulting.com>\";\nvar homepage$4 = \"https://github.com/eslint/espree\";\nvar main$4 = \"espree.js\";\nvar version$6 = \"6.2.1\";\nvar files$2 = [\n\t\"lib\",\n\t\"espree.js\"\n];\nvar engines$4 = {\n\tnode: \">=6.0.0\"\n};\nvar repository$4 = \"eslint/espree\";\nvar bugs$2 = {\n\turl: \"http://github.com/eslint/espree.git\"\n};\nvar license$4 = \"BSD-2-Clause\";\nvar dependencies$3 = {\n\tacorn: \"^7.1.1\",\n\t\"acorn-jsx\": \"^5.2.0\",\n\t\"eslint-visitor-keys\": \"^1.1.0\"\n};\nvar devDependencies$4 = {\n\tbrowserify: \"^16.5.0\",\n\tchai: \"^4.2.0\",\n\teslint: \"^6.0.1\",\n\t\"eslint-config-eslint\": \"^5.0.1\",\n\t\"eslint-plugin-node\": \"^9.1.0\",\n\t\"eslint-release\": \"^1.0.0\",\n\tesprima: \"latest\",\n\t\"esprima-fb\": \"^8001.2001.0-dev-harmony-fb\",\n\t\"json-diff\": \"^0.5.4\",\n\tleche: \"^2.3.0\",\n\tmocha: \"^6.2.0\",\n\tnyc: \"^14.1.1\",\n\tregenerate: \"^1.4.0\",\n\tshelljs: \"^0.3.0\",\n\t\"shelljs-nodecli\": \"^0.1.1\",\n\t\"unicode-6.3.0\": \"^0.7.5\"\n};\nvar keywords$2 = [\n\t\"ast\",\n\t\"ecmascript\",\n\t\"javascript\",\n\t\"parser\",\n\t\"syntax\",\n\t\"acorn\"\n];\nvar scripts$4 = {\n\t\"generate-regex\": \"node tools/generate-identifier-regex.js\",\n\ttest: \"npm run-script lint && node Makefile.js test\",\n\tlint: \"node Makefile.js lint\",\n\tbrowserify: \"node Makefile.js browserify\",\n\t\"generate-release\": \"eslint-generate-release\",\n\t\"generate-alpharelease\": \"eslint-generate-prerelease alpha\",\n\t\"generate-betarelease\": \"eslint-generate-prerelease beta\",\n\t\"generate-rcrelease\": \"eslint-generate-prerelease rc\",\n\t\"publish-release\": \"eslint-publish-release\"\n};\nvar _package$8 = {\n\tname: name$4,\n\tdescription: description$4,\n\tauthor: author$1,\n\thomepage: homepage$4,\n\tmain: main$4,\n\tversion: version$6,\n\tfiles: files$2,\n\tengines: engines$4,\n\trepository: repository$4,\n\tbugs: bugs$2,\n\tlicense: license$4,\n\tdependencies: dependencies$3,\n\tdevDependencies: devDependencies$4,\n\tkeywords: keywords$2,\n\tscripts: scripts$4\n};\n\nvar _package$9 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  name: name$4,\n  description: description$4,\n  author: author$1,\n  homepage: homepage$4,\n  main: main$4,\n  version: version$6,\n  files: files$2,\n  engines: engines$4,\n  repository: repository$4,\n  bugs: bugs$2,\n  license: license$4,\n  dependencies: dependencies$3,\n  devDependencies: devDependencies$4,\n  keywords: keywords$2,\n  scripts: scripts$4,\n  'default': _package$8\n});\n\nvar require$$1$2 = getCjsExportFromNamespace(_package$9);\n\nconst { getLatestEcmaVersion: getLatestEcmaVersion$1, getSupportedEcmaVersions: getSupportedEcmaVersions$1 } = options;\n\n// To initialize lazily.\nconst parsers = {\n    _regular: null,\n    _jsx: null,\n\n    get regular() {\n        if (this._regular === null) {\n            this._regular = acorn$1.Parser.extend(espree());\n        }\n        return this._regular;\n    },\n\n    get jsx() {\n        if (this._jsx === null) {\n            this._jsx = acorn$1.Parser.extend(acornJsx(), espree());\n        }\n        return this._jsx;\n    },\n\n    get(options) {\n        const useJsx = Boolean(\n            options &&\n            options.ecmaFeatures &&\n            options.ecmaFeatures.jsx\n        );\n\n        return useJsx ? this.jsx : this.regular;\n    }\n};\n\n//------------------------------------------------------------------------------\n// Tokenizer\n//------------------------------------------------------------------------------\n\n/**\n * Tokenizes the given code.\n * @param {string} code The code to tokenize.\n * @param {Object} options Options defining how to tokenize.\n * @returns {Token[]} An array of tokens.\n * @throws {SyntaxError} If the input code is invalid.\n * @private\n */\nfunction tokenize(code, options) {\n    const Parser = parsers.get(options);\n\n    // Ensure to collect tokens.\n    if (!options || options.tokens !== true) {\n        options = Object.assign({}, options, { tokens: true }); // eslint-disable-line no-param-reassign\n    }\n\n    return new Parser(options, code).tokenize();\n}\n\n//------------------------------------------------------------------------------\n// Parser\n//------------------------------------------------------------------------------\n\n/**\n * Parses the given code.\n * @param {string} code The code to tokenize.\n * @param {Object} options Options defining how to tokenize.\n * @returns {ASTNode} The \"Program\" AST node.\n * @throws {SyntaxError} If the input code is invalid.\n */\nfunction parse$2(code, options) {\n    const Parser = parsers.get(options);\n\n    return new Parser(options, code).parse();\n}\n\n//------------------------------------------------------------------------------\n// Public\n//------------------------------------------------------------------------------\n\nvar version$7 = require$$1$2.version;\n\nvar tokenize_1 = tokenize;\n\nvar parse_1 = parse$2;\n\n// Deep copy.\n/* istanbul ignore next */\nvar Syntax$3 = (function() {\n    let name,\n        types = {};\n\n    if (typeof Object.create === \"function\") {\n        types = Object.create(null);\n    }\n\n    for (name in astNodeTypes) {\n        if (Object.hasOwnProperty.call(astNodeTypes, name)) {\n            types[name] = astNodeTypes[name];\n        }\n    }\n\n    if (typeof Object.freeze === \"function\") {\n        Object.freeze(types);\n    }\n\n    return types;\n}());\n\n/* istanbul ignore next */\nvar VisitorKeys = (function() {\n    return lib$1.KEYS;\n}());\n\nvar latestEcmaVersion = getLatestEcmaVersion$1();\n\nvar supportedEcmaVersions = getSupportedEcmaVersions$1();\n\nvar espree_1 = {\n\tversion: version$7,\n\ttokenize: tokenize_1,\n\tparse: parse_1,\n\tSyntax: Syntax$3,\n\tVisitorKeys: VisitorKeys,\n\tlatestEcmaVersion: latestEcmaVersion,\n\tsupportedEcmaVersions: supportedEcmaVersions\n};\n\nvar lodash = createCommonjsModule(function (module, exports) {\n(function() {\n\n  /** Used as a safe reference for `undefined` in pre-ES5 environments. */\n  var undefined$1;\n\n  /** Used as the semantic version number. */\n  var VERSION = '4.17.15';\n\n  /** Used as the size to enable large array optimizations. */\n  var LARGE_ARRAY_SIZE = 200;\n\n  /** Error message constants. */\n  var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',\n      FUNC_ERROR_TEXT = 'Expected a function';\n\n  /** Used to stand-in for `undefined` hash values. */\n  var HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n  /** Used as the maximum memoize cache size. */\n  var MAX_MEMOIZE_SIZE = 500;\n\n  /** Used as the internal argument placeholder. */\n  var PLACEHOLDER = '__lodash_placeholder__';\n\n  /** Used to compose bitmasks for cloning. */\n  var CLONE_DEEP_FLAG = 1,\n      CLONE_FLAT_FLAG = 2,\n      CLONE_SYMBOLS_FLAG = 4;\n\n  /** Used to compose bitmasks for value comparisons. */\n  var COMPARE_PARTIAL_FLAG = 1,\n      COMPARE_UNORDERED_FLAG = 2;\n\n  /** Used to compose bitmasks for function metadata. */\n  var WRAP_BIND_FLAG = 1,\n      WRAP_BIND_KEY_FLAG = 2,\n      WRAP_CURRY_BOUND_FLAG = 4,\n      WRAP_CURRY_FLAG = 8,\n      WRAP_CURRY_RIGHT_FLAG = 16,\n      WRAP_PARTIAL_FLAG = 32,\n      WRAP_PARTIAL_RIGHT_FLAG = 64,\n      WRAP_ARY_FLAG = 128,\n      WRAP_REARG_FLAG = 256,\n      WRAP_FLIP_FLAG = 512;\n\n  /** Used as default options for `_.truncate`. */\n  var DEFAULT_TRUNC_LENGTH = 30,\n      DEFAULT_TRUNC_OMISSION = '...';\n\n  /** Used to detect hot functions by number of calls within a span of milliseconds. */\n  var HOT_COUNT = 800,\n      HOT_SPAN = 16;\n\n  /** Used to indicate the type of lazy iteratees. */\n  var LAZY_FILTER_FLAG = 1,\n      LAZY_MAP_FLAG = 2,\n      LAZY_WHILE_FLAG = 3;\n\n  /** Used as references for various `Number` constants. */\n  var INFINITY = 1 / 0,\n      MAX_SAFE_INTEGER = 9007199254740991,\n      MAX_INTEGER = 1.7976931348623157e+308,\n      NAN = 0 / 0;\n\n  /** Used as references for the maximum length and index of an array. */\n  var MAX_ARRAY_LENGTH = 4294967295,\n      MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,\n      HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;\n\n  /** Used to associate wrap methods with their bit flags. */\n  var wrapFlags = [\n    ['ary', WRAP_ARY_FLAG],\n    ['bind', WRAP_BIND_FLAG],\n    ['bindKey', WRAP_BIND_KEY_FLAG],\n    ['curry', WRAP_CURRY_FLAG],\n    ['curryRight', WRAP_CURRY_RIGHT_FLAG],\n    ['flip', WRAP_FLIP_FLAG],\n    ['partial', WRAP_PARTIAL_FLAG],\n    ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],\n    ['rearg', WRAP_REARG_FLAG]\n  ];\n\n  /** `Object#toString` result references. */\n  var argsTag = '[object Arguments]',\n      arrayTag = '[object Array]',\n      asyncTag = '[object AsyncFunction]',\n      boolTag = '[object Boolean]',\n      dateTag = '[object Date]',\n      domExcTag = '[object DOMException]',\n      errorTag = '[object Error]',\n      funcTag = '[object Function]',\n      genTag = '[object GeneratorFunction]',\n      mapTag = '[object Map]',\n      numberTag = '[object Number]',\n      nullTag = '[object Null]',\n      objectTag = '[object Object]',\n      promiseTag = '[object Promise]',\n      proxyTag = '[object Proxy]',\n      regexpTag = '[object RegExp]',\n      setTag = '[object Set]',\n      stringTag = '[object String]',\n      symbolTag = '[object Symbol]',\n      undefinedTag = '[object Undefined]',\n      weakMapTag = '[object WeakMap]',\n      weakSetTag = '[object WeakSet]';\n\n  var arrayBufferTag = '[object ArrayBuffer]',\n      dataViewTag = '[object DataView]',\n      float32Tag = '[object Float32Array]',\n      float64Tag = '[object Float64Array]',\n      int8Tag = '[object Int8Array]',\n      int16Tag = '[object Int16Array]',\n      int32Tag = '[object Int32Array]',\n      uint8Tag = '[object Uint8Array]',\n      uint8ClampedTag = '[object Uint8ClampedArray]',\n      uint16Tag = '[object Uint16Array]',\n      uint32Tag = '[object Uint32Array]';\n\n  /** Used to match empty string literals in compiled template source. */\n  var reEmptyStringLeading = /\\b__p \\+= '';/g,\n      reEmptyStringMiddle = /\\b(__p \\+=) '' \\+/g,\n      reEmptyStringTrailing = /(__e\\(.*?\\)|\\b__t\\)) \\+\\n'';/g;\n\n  /** Used to match HTML entities and HTML characters. */\n  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,\n      reUnescapedHtml = /[&<>\"']/g,\n      reHasEscapedHtml = RegExp(reEscapedHtml.source),\n      reHasUnescapedHtml = RegExp(reUnescapedHtml.source);\n\n  /** Used to match template delimiters. */\n  var reEscape = /<%-([\\s\\S]+?)%>/g,\n      reEvaluate = /<%([\\s\\S]+?)%>/g,\n      reInterpolate = /<%=([\\s\\S]+?)%>/g;\n\n  /** Used to match property names within property paths. */\n  var reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n      reIsPlainProp = /^\\w*$/,\n      rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n  /**\n   * Used to match `RegExp`\n   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n   */\n  var reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g,\n      reHasRegExpChar = RegExp(reRegExpChar.source);\n\n  /** Used to match leading and trailing whitespace. */\n  var reTrim = /^\\s+|\\s+$/g,\n      reTrimStart = /^\\s+/,\n      reTrimEnd = /\\s+$/;\n\n  /** Used to match wrap detail comments. */\n  var reWrapComment = /\\{(?:\\n\\/\\* \\[wrapped with .+\\] \\*\\/)?\\n?/,\n      reWrapDetails = /\\{\\n\\/\\* \\[wrapped with (.+)\\] \\*/,\n      reSplitDetails = /,? & /;\n\n  /** Used to match words composed of alphanumeric characters. */\n  var reAsciiWord = /[^\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7f]+/g;\n\n  /** Used to match backslashes in property paths. */\n  var reEscapeChar = /\\\\(\\\\)?/g;\n\n  /**\n   * Used to match\n   * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).\n   */\n  var reEsTemplate = /\\$\\{([^\\\\}]*(?:\\\\.[^\\\\}]*)*)\\}/g;\n\n  /** Used to match `RegExp` flags from their coerced string values. */\n  var reFlags = /\\w*$/;\n\n  /** Used to detect bad signed hexadecimal string values. */\n  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n  /** Used to detect binary string values. */\n  var reIsBinary = /^0b[01]+$/i;\n\n  /** Used to detect host constructors (Safari). */\n  var reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n  /** Used to detect octal string values. */\n  var reIsOctal = /^0o[0-7]+$/i;\n\n  /** Used to detect unsigned integer values. */\n  var reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n  /** Used to match Latin Unicode letters (excluding mathematical operators). */\n  var reLatin = /[\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\xff\\u0100-\\u017f]/g;\n\n  /** Used to ensure capturing order of template delimiters. */\n  var reNoMatch = /($^)/;\n\n  /** Used to match unescaped characters in compiled string literals. */\n  var reUnescapedString = /['\\n\\r\\u2028\\u2029\\\\]/g;\n\n  /** Used to compose unicode character classes. */\n  var rsAstralRange = '\\\\ud800-\\\\udfff',\n      rsComboMarksRange = '\\\\u0300-\\\\u036f',\n      reComboHalfMarksRange = '\\\\ufe20-\\\\ufe2f',\n      rsComboSymbolsRange = '\\\\u20d0-\\\\u20ff',\n      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,\n      rsDingbatRange = '\\\\u2700-\\\\u27bf',\n      rsLowerRange = 'a-z\\\\xdf-\\\\xf6\\\\xf8-\\\\xff',\n      rsMathOpRange = '\\\\xac\\\\xb1\\\\xd7\\\\xf7',\n      rsNonCharRange = '\\\\x00-\\\\x2f\\\\x3a-\\\\x40\\\\x5b-\\\\x60\\\\x7b-\\\\xbf',\n      rsPunctuationRange = '\\\\u2000-\\\\u206f',\n      rsSpaceRange = ' \\\\t\\\\x0b\\\\f\\\\xa0\\\\ufeff\\\\n\\\\r\\\\u2028\\\\u2029\\\\u1680\\\\u180e\\\\u2000\\\\u2001\\\\u2002\\\\u2003\\\\u2004\\\\u2005\\\\u2006\\\\u2007\\\\u2008\\\\u2009\\\\u200a\\\\u202f\\\\u205f\\\\u3000',\n      rsUpperRange = 'A-Z\\\\xc0-\\\\xd6\\\\xd8-\\\\xde',\n      rsVarRange = '\\\\ufe0e\\\\ufe0f',\n      rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;\n\n  /** Used to compose unicode capture groups. */\n  var rsApos = \"['\\u2019]\",\n      rsAstral = '[' + rsAstralRange + ']',\n      rsBreak = '[' + rsBreakRange + ']',\n      rsCombo = '[' + rsComboRange + ']',\n      rsDigits = '\\\\d+',\n      rsDingbat = '[' + rsDingbatRange + ']',\n      rsLower = '[' + rsLowerRange + ']',\n      rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',\n      rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n      rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n      rsNonAstral = '[^' + rsAstralRange + ']',\n      rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n      rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n      rsUpper = '[' + rsUpperRange + ']',\n      rsZWJ = '\\\\u200d';\n\n  /** Used to compose unicode regexes. */\n  var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',\n      rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',\n      rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',\n      rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',\n      reOptMod = rsModifier + '?',\n      rsOptVar = '[' + rsVarRange + ']?',\n      rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n      rsOrdLower = '\\\\d*(?:1st|2nd|3rd|(?![123])\\\\dth)(?=\\\\b|[A-Z_])',\n      rsOrdUpper = '\\\\d*(?:1ST|2ND|3RD|(?![123])\\\\dTH)(?=\\\\b|[a-z_])',\n      rsSeq = rsOptVar + reOptMod + rsOptJoin,\n      rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,\n      rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\n\n  /** Used to match apostrophes. */\n  var reApos = RegExp(rsApos, 'g');\n\n  /**\n   * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and\n   * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).\n   */\n  var reComboMark = RegExp(rsCombo, 'g');\n\n  /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\n  var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');\n\n  /** Used to match complex or compound words. */\n  var reUnicodeWord = RegExp([\n    rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',\n    rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',\n    rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,\n    rsUpper + '+' + rsOptContrUpper,\n    rsOrdUpper,\n    rsOrdLower,\n    rsDigits,\n    rsEmoji\n  ].join('|'), 'g');\n\n  /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */\n  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');\n\n  /** Used to detect strings that need a more robust regexp to match words. */\n  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;\n\n  /** Used to assign default `context` object properties. */\n  var contextProps = [\n    'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',\n    'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',\n    'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',\n    'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',\n    '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'\n  ];\n\n  /** Used to make template sourceURLs easier to identify. */\n  var templateCounter = -1;\n\n  /** Used to identify `toStringTag` values of typed arrays. */\n  var typedArrayTags = {};\n  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\n  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\n  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\n  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\n  typedArrayTags[uint32Tag] = true;\n  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =\n  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\n  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\n  typedArrayTags[errorTag] = typedArrayTags[funcTag] =\n  typedArrayTags[mapTag] = typedArrayTags[numberTag] =\n  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =\n  typedArrayTags[setTag] = typedArrayTags[stringTag] =\n  typedArrayTags[weakMapTag] = false;\n\n  /** Used to identify `toStringTag` values supported by `_.clone`. */\n  var cloneableTags = {};\n  cloneableTags[argsTag] = cloneableTags[arrayTag] =\n  cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\n  cloneableTags[boolTag] = cloneableTags[dateTag] =\n  cloneableTags[float32Tag] = cloneableTags[float64Tag] =\n  cloneableTags[int8Tag] = cloneableTags[int16Tag] =\n  cloneableTags[int32Tag] = cloneableTags[mapTag] =\n  cloneableTags[numberTag] = cloneableTags[objectTag] =\n  cloneableTags[regexpTag] = cloneableTags[setTag] =\n  cloneableTags[stringTag] = cloneableTags[symbolTag] =\n  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\n  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\n  cloneableTags[errorTag] = cloneableTags[funcTag] =\n  cloneableTags[weakMapTag] = false;\n\n  /** Used to map Latin Unicode letters to basic Latin letters. */\n  var deburredLetters = {\n    // Latin-1 Supplement block.\n    '\\xc0': 'A',  '\\xc1': 'A', '\\xc2': 'A', '\\xc3': 'A', '\\xc4': 'A', '\\xc5': 'A',\n    '\\xe0': 'a',  '\\xe1': 'a', '\\xe2': 'a', '\\xe3': 'a', '\\xe4': 'a', '\\xe5': 'a',\n    '\\xc7': 'C',  '\\xe7': 'c',\n    '\\xd0': 'D',  '\\xf0': 'd',\n    '\\xc8': 'E',  '\\xc9': 'E', '\\xca': 'E', '\\xcb': 'E',\n    '\\xe8': 'e',  '\\xe9': 'e', '\\xea': 'e', '\\xeb': 'e',\n    '\\xcc': 'I',  '\\xcd': 'I', '\\xce': 'I', '\\xcf': 'I',\n    '\\xec': 'i',  '\\xed': 'i', '\\xee': 'i', '\\xef': 'i',\n    '\\xd1': 'N',  '\\xf1': 'n',\n    '\\xd2': 'O',  '\\xd3': 'O', '\\xd4': 'O', '\\xd5': 'O', '\\xd6': 'O', '\\xd8': 'O',\n    '\\xf2': 'o',  '\\xf3': 'o', '\\xf4': 'o', '\\xf5': 'o', '\\xf6': 'o', '\\xf8': 'o',\n    '\\xd9': 'U',  '\\xda': 'U', '\\xdb': 'U', '\\xdc': 'U',\n    '\\xf9': 'u',  '\\xfa': 'u', '\\xfb': 'u', '\\xfc': 'u',\n    '\\xdd': 'Y',  '\\xfd': 'y', '\\xff': 'y',\n    '\\xc6': 'Ae', '\\xe6': 'ae',\n    '\\xde': 'Th', '\\xfe': 'th',\n    '\\xdf': 'ss',\n    // Latin Extended-A block.\n    '\\u0100': 'A',  '\\u0102': 'A', '\\u0104': 'A',\n    '\\u0101': 'a',  '\\u0103': 'a', '\\u0105': 'a',\n    '\\u0106': 'C',  '\\u0108': 'C', '\\u010a': 'C', '\\u010c': 'C',\n    '\\u0107': 'c',  '\\u0109': 'c', '\\u010b': 'c', '\\u010d': 'c',\n    '\\u010e': 'D',  '\\u0110': 'D', '\\u010f': 'd', '\\u0111': 'd',\n    '\\u0112': 'E',  '\\u0114': 'E', '\\u0116': 'E', '\\u0118': 'E', '\\u011a': 'E',\n    '\\u0113': 'e',  '\\u0115': 'e', '\\u0117': 'e', '\\u0119': 'e', '\\u011b': 'e',\n    '\\u011c': 'G',  '\\u011e': 'G', '\\u0120': 'G', '\\u0122': 'G',\n    '\\u011d': 'g',  '\\u011f': 'g', '\\u0121': 'g', '\\u0123': 'g',\n    '\\u0124': 'H',  '\\u0126': 'H', '\\u0125': 'h', '\\u0127': 'h',\n    '\\u0128': 'I',  '\\u012a': 'I', '\\u012c': 'I', '\\u012e': 'I', '\\u0130': 'I',\n    '\\u0129': 'i',  '\\u012b': 'i', '\\u012d': 'i', '\\u012f': 'i', '\\u0131': 'i',\n    '\\u0134': 'J',  '\\u0135': 'j',\n    '\\u0136': 'K',  '\\u0137': 'k', '\\u0138': 'k',\n    '\\u0139': 'L',  '\\u013b': 'L', '\\u013d': 'L', '\\u013f': 'L', '\\u0141': 'L',\n    '\\u013a': 'l',  '\\u013c': 'l', '\\u013e': 'l', '\\u0140': 'l', '\\u0142': 'l',\n    '\\u0143': 'N',  '\\u0145': 'N', '\\u0147': 'N', '\\u014a': 'N',\n    '\\u0144': 'n',  '\\u0146': 'n', '\\u0148': 'n', '\\u014b': 'n',\n    '\\u014c': 'O',  '\\u014e': 'O', '\\u0150': 'O',\n    '\\u014d': 'o',  '\\u014f': 'o', '\\u0151': 'o',\n    '\\u0154': 'R',  '\\u0156': 'R', '\\u0158': 'R',\n    '\\u0155': 'r',  '\\u0157': 'r', '\\u0159': 'r',\n    '\\u015a': 'S',  '\\u015c': 'S', '\\u015e': 'S', '\\u0160': 'S',\n    '\\u015b': 's',  '\\u015d': 's', '\\u015f': 's', '\\u0161': 's',\n    '\\u0162': 'T',  '\\u0164': 'T', '\\u0166': 'T',\n    '\\u0163': 't',  '\\u0165': 't', '\\u0167': 't',\n    '\\u0168': 'U',  '\\u016a': 'U', '\\u016c': 'U', '\\u016e': 'U', '\\u0170': 'U', '\\u0172': 'U',\n    '\\u0169': 'u',  '\\u016b': 'u', '\\u016d': 'u', '\\u016f': 'u', '\\u0171': 'u', '\\u0173': 'u',\n    '\\u0174': 'W',  '\\u0175': 'w',\n    '\\u0176': 'Y',  '\\u0177': 'y', '\\u0178': 'Y',\n    '\\u0179': 'Z',  '\\u017b': 'Z', '\\u017d': 'Z',\n    '\\u017a': 'z',  '\\u017c': 'z', '\\u017e': 'z',\n    '\\u0132': 'IJ', '\\u0133': 'ij',\n    '\\u0152': 'Oe', '\\u0153': 'oe',\n    '\\u0149': \"'n\", '\\u017f': 's'\n  };\n\n  /** Used to map characters to HTML entities. */\n  var htmlEscapes = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;'\n  };\n\n  /** Used to map HTML entities to characters. */\n  var htmlUnescapes = {\n    '&amp;': '&',\n    '&lt;': '<',\n    '&gt;': '>',\n    '&quot;': '\"',\n    '&#39;': \"'\"\n  };\n\n  /** Used to escape characters for inclusion in compiled string literals. */\n  var stringEscapes = {\n    '\\\\': '\\\\',\n    \"'\": \"'\",\n    '\\n': 'n',\n    '\\r': 'r',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  /** Built-in method references without a dependency on `root`. */\n  var freeParseFloat = parseFloat,\n      freeParseInt = parseInt;\n\n  /** Detect free variable `global` from Node.js. */\n  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n  /** Detect free variable `self`. */\n  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n  /** Used as a reference to the global object. */\n  var root = freeGlobal || freeSelf || Function('return this')();\n\n  /** Detect free variable `exports`. */\n  var freeExports =  exports && !exports.nodeType && exports;\n\n  /** Detect free variable `module`. */\n  var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;\n\n  /** Detect the popular CommonJS extension `module.exports`. */\n  var moduleExports = freeModule && freeModule.exports === freeExports;\n\n  /** Detect free variable `process` from Node.js. */\n  var freeProcess = moduleExports && freeGlobal.process;\n\n  /** Used to access faster Node.js helpers. */\n  var nodeUtil = (function() {\n    try {\n      // Use `util.types` for Node.js 10+.\n      var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n      if (types) {\n        return types;\n      }\n\n      // Legacy `process.binding('util')` for Node.js < 10.\n      return freeProcess && freeProcess.binding && freeProcess.binding('util');\n    } catch (e) {}\n  }());\n\n  /* Node.js helper references. */\n  var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,\n      nodeIsDate = nodeUtil && nodeUtil.isDate,\n      nodeIsMap = nodeUtil && nodeUtil.isMap,\n      nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,\n      nodeIsSet = nodeUtil && nodeUtil.isSet,\n      nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * A faster alternative to `Function#apply`, this function invokes `func`\n   * with the `this` binding of `thisArg` and the arguments of `args`.\n   *\n   * @private\n   * @param {Function} func The function to invoke.\n   * @param {*} thisArg The `this` binding of `func`.\n   * @param {Array} args The arguments to invoke `func` with.\n   * @returns {*} Returns the result of `func`.\n   */\n  function apply(func, thisArg, args) {\n    switch (args.length) {\n      case 0: return func.call(thisArg);\n      case 1: return func.call(thisArg, args[0]);\n      case 2: return func.call(thisArg, args[0], args[1]);\n      case 3: return func.call(thisArg, args[0], args[1], args[2]);\n    }\n    return func.apply(thisArg, args);\n  }\n\n  /**\n   * A specialized version of `baseAggregator` for arrays.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} setter The function to set `accumulator` values.\n   * @param {Function} iteratee The iteratee to transform keys.\n   * @param {Object} accumulator The initial aggregated object.\n   * @returns {Function} Returns `accumulator`.\n   */\n  function arrayAggregator(array, setter, iteratee, accumulator) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      var value = array[index];\n      setter(accumulator, value, iteratee(value), array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.forEach` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayEach(array, iteratee) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (iteratee(array[index], index, array) === false) {\n        break;\n      }\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.forEachRight` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayEachRight(array, iteratee) {\n    var length = array == null ? 0 : array.length;\n\n    while (length--) {\n      if (iteratee(array[length], length, array) === false) {\n        break;\n      }\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.every` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {boolean} Returns `true` if all elements pass the predicate check,\n   *  else `false`.\n   */\n  function arrayEvery(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (!predicate(array[index], index, array)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * A specialized version of `_.filter` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {Array} Returns the new filtered array.\n   */\n  function arrayFilter(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length,\n        resIndex = 0,\n        result = [];\n\n    while (++index < length) {\n      var value = array[index];\n      if (predicate(value, index, array)) {\n        result[resIndex++] = value;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * A specialized version of `_.includes` for arrays without support for\n   * specifying an index to search from.\n   *\n   * @private\n   * @param {Array} [array] The array to inspect.\n   * @param {*} target The value to search for.\n   * @returns {boolean} Returns `true` if `target` is found, else `false`.\n   */\n  function arrayIncludes(array, value) {\n    var length = array == null ? 0 : array.length;\n    return !!length && baseIndexOf(array, value, 0) > -1;\n  }\n\n  /**\n   * This function is like `arrayIncludes` except that it accepts a comparator.\n   *\n   * @private\n   * @param {Array} [array] The array to inspect.\n   * @param {*} target The value to search for.\n   * @param {Function} comparator The comparator invoked per element.\n   * @returns {boolean} Returns `true` if `target` is found, else `false`.\n   */\n  function arrayIncludesWith(array, value, comparator) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (comparator(value, array[index])) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * A specialized version of `_.map` for arrays without support for iteratee\n   * shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns the new mapped array.\n   */\n  function arrayMap(array, iteratee) {\n    var index = -1,\n        length = array == null ? 0 : array.length,\n        result = Array(length);\n\n    while (++index < length) {\n      result[index] = iteratee(array[index], index, array);\n    }\n    return result;\n  }\n\n  /**\n   * Appends the elements of `values` to `array`.\n   *\n   * @private\n   * @param {Array} array The array to modify.\n   * @param {Array} values The values to append.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayPush(array, values) {\n    var index = -1,\n        length = values.length,\n        offset = array.length;\n\n    while (++index < length) {\n      array[offset + index] = values[index];\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.reduce` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} [accumulator] The initial value.\n   * @param {boolean} [initAccum] Specify using the first element of `array` as\n   *  the initial value.\n   * @returns {*} Returns the accumulated value.\n   */\n  function arrayReduce(array, iteratee, accumulator, initAccum) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    if (initAccum && length) {\n      accumulator = array[++index];\n    }\n    while (++index < length) {\n      accumulator = iteratee(accumulator, array[index], index, array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.reduceRight` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} [accumulator] The initial value.\n   * @param {boolean} [initAccum] Specify using the last element of `array` as\n   *  the initial value.\n   * @returns {*} Returns the accumulated value.\n   */\n  function arrayReduceRight(array, iteratee, accumulator, initAccum) {\n    var length = array == null ? 0 : array.length;\n    if (initAccum && length) {\n      accumulator = array[--length];\n    }\n    while (length--) {\n      accumulator = iteratee(accumulator, array[length], length, array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.some` for arrays without support for iteratee\n   * shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {boolean} Returns `true` if any element passes the predicate check,\n   *  else `false`.\n   */\n  function arraySome(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (predicate(array[index], index, array)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Gets the size of an ASCII `string`.\n   *\n   * @private\n   * @param {string} string The string inspect.\n   * @returns {number} Returns the string size.\n   */\n  var asciiSize = baseProperty('length');\n\n  /**\n   * Converts an ASCII `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function asciiToArray(string) {\n    return string.split('');\n  }\n\n  /**\n   * Splits an ASCII `string` into an array of its words.\n   *\n   * @private\n   * @param {string} The string to inspect.\n   * @returns {Array} Returns the words of `string`.\n   */\n  function asciiWords(string) {\n    return string.match(reAsciiWord) || [];\n  }\n\n  /**\n   * The base implementation of methods like `_.findKey` and `_.findLastKey`,\n   * without support for iteratee shorthands, which iterates over `collection`\n   * using `eachFunc`.\n   *\n   * @private\n   * @param {Array|Object} collection The collection to inspect.\n   * @param {Function} predicate The function invoked per iteration.\n   * @param {Function} eachFunc The function to iterate over `collection`.\n   * @returns {*} Returns the found element or its key, else `undefined`.\n   */\n  function baseFindKey(collection, predicate, eachFunc) {\n    var result;\n    eachFunc(collection, function(value, key, collection) {\n      if (predicate(value, key, collection)) {\n        result = key;\n        return false;\n      }\n    });\n    return result;\n  }\n\n  /**\n   * The base implementation of `_.findIndex` and `_.findLastIndex` without\n   * support for iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {Function} predicate The function invoked per iteration.\n   * @param {number} fromIndex The index to search from.\n   * @param {boolean} [fromRight] Specify iterating from right to left.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseFindIndex(array, predicate, fromIndex, fromRight) {\n    var length = array.length,\n        index = fromIndex + (fromRight ? 1 : -1);\n\n    while ((fromRight ? index-- : ++index < length)) {\n      if (predicate(array[index], index, array)) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseIndexOf(array, value, fromIndex) {\n    return value === value\n      ? strictIndexOf(array, value, fromIndex)\n      : baseFindIndex(array, baseIsNaN, fromIndex);\n  }\n\n  /**\n   * This function is like `baseIndexOf` except that it accepts a comparator.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @param {Function} comparator The comparator invoked per element.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseIndexOfWith(array, value, fromIndex, comparator) {\n    var index = fromIndex - 1,\n        length = array.length;\n\n    while (++index < length) {\n      if (comparator(array[index], value)) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * The base implementation of `_.isNaN` without support for number objects.\n   *\n   * @private\n   * @param {*} value The value to check.\n   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n   */\n  function baseIsNaN(value) {\n    return value !== value;\n  }\n\n  /**\n   * The base implementation of `_.mean` and `_.meanBy` without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {number} Returns the mean.\n   */\n  function baseMean(array, iteratee) {\n    var length = array == null ? 0 : array.length;\n    return length ? (baseSum(array, iteratee) / length) : NAN;\n  }\n\n  /**\n   * The base implementation of `_.property` without support for deep paths.\n   *\n   * @private\n   * @param {string} key The key of the property to get.\n   * @returns {Function} Returns the new accessor function.\n   */\n  function baseProperty(key) {\n    return function(object) {\n      return object == null ? undefined$1 : object[key];\n    };\n  }\n\n  /**\n   * The base implementation of `_.propertyOf` without support for deep paths.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @returns {Function} Returns the new accessor function.\n   */\n  function basePropertyOf(object) {\n    return function(key) {\n      return object == null ? undefined$1 : object[key];\n    };\n  }\n\n  /**\n   * The base implementation of `_.reduce` and `_.reduceRight`, without support\n   * for iteratee shorthands, which iterates over `collection` using `eachFunc`.\n   *\n   * @private\n   * @param {Array|Object} collection The collection to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} accumulator The initial value.\n   * @param {boolean} initAccum Specify using the first or last element of\n   *  `collection` as the initial value.\n   * @param {Function} eachFunc The function to iterate over `collection`.\n   * @returns {*} Returns the accumulated value.\n   */\n  function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {\n    eachFunc(collection, function(value, index, collection) {\n      accumulator = initAccum\n        ? (initAccum = false, value)\n        : iteratee(accumulator, value, index, collection);\n    });\n    return accumulator;\n  }\n\n  /**\n   * The base implementation of `_.sortBy` which uses `comparer` to define the\n   * sort order of `array` and replaces criteria objects with their corresponding\n   * values.\n   *\n   * @private\n   * @param {Array} array The array to sort.\n   * @param {Function} comparer The function to define sort order.\n   * @returns {Array} Returns `array`.\n   */\n  function baseSortBy(array, comparer) {\n    var length = array.length;\n\n    array.sort(comparer);\n    while (length--) {\n      array[length] = array[length].value;\n    }\n    return array;\n  }\n\n  /**\n   * The base implementation of `_.sum` and `_.sumBy` without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {number} Returns the sum.\n   */\n  function baseSum(array, iteratee) {\n    var result,\n        index = -1,\n        length = array.length;\n\n    while (++index < length) {\n      var current = iteratee(array[index]);\n      if (current !== undefined$1) {\n        result = result === undefined$1 ? current : (result + current);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * The base implementation of `_.times` without support for iteratee shorthands\n   * or max array length checks.\n   *\n   * @private\n   * @param {number} n The number of times to invoke `iteratee`.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns the array of results.\n   */\n  function baseTimes(n, iteratee) {\n    var index = -1,\n        result = Array(n);\n\n    while (++index < n) {\n      result[index] = iteratee(index);\n    }\n    return result;\n  }\n\n  /**\n   * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array\n   * of key-value pairs for `object` corresponding to the property names of `props`.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @param {Array} props The property names to get values for.\n   * @returns {Object} Returns the key-value pairs.\n   */\n  function baseToPairs(object, props) {\n    return arrayMap(props, function(key) {\n      return [key, object[key]];\n    });\n  }\n\n  /**\n   * The base implementation of `_.unary` without support for storing metadata.\n   *\n   * @private\n   * @param {Function} func The function to cap arguments for.\n   * @returns {Function} Returns the new capped function.\n   */\n  function baseUnary(func) {\n    return function(value) {\n      return func(value);\n    };\n  }\n\n  /**\n   * The base implementation of `_.values` and `_.valuesIn` which creates an\n   * array of `object` property values corresponding to the property names\n   * of `props`.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @param {Array} props The property names to get values for.\n   * @returns {Object} Returns the array of property values.\n   */\n  function baseValues(object, props) {\n    return arrayMap(props, function(key) {\n      return object[key];\n    });\n  }\n\n  /**\n   * Checks if a `cache` value for `key` exists.\n   *\n   * @private\n   * @param {Object} cache The cache to query.\n   * @param {string} key The key of the entry to check.\n   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n   */\n  function cacheHas(cache, key) {\n    return cache.has(key);\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol\n   * that is not found in the character symbols.\n   *\n   * @private\n   * @param {Array} strSymbols The string symbols to inspect.\n   * @param {Array} chrSymbols The character symbols to find.\n   * @returns {number} Returns the index of the first unmatched string symbol.\n   */\n  function charsStartIndex(strSymbols, chrSymbols) {\n    var index = -1,\n        length = strSymbols.length;\n\n    while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n    return index;\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol\n   * that is not found in the character symbols.\n   *\n   * @private\n   * @param {Array} strSymbols The string symbols to inspect.\n   * @param {Array} chrSymbols The character symbols to find.\n   * @returns {number} Returns the index of the last unmatched string symbol.\n   */\n  function charsEndIndex(strSymbols, chrSymbols) {\n    var index = strSymbols.length;\n\n    while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n    return index;\n  }\n\n  /**\n   * Gets the number of `placeholder` occurrences in `array`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} placeholder The placeholder to search for.\n   * @returns {number} Returns the placeholder count.\n   */\n  function countHolders(array, placeholder) {\n    var length = array.length,\n        result = 0;\n\n    while (length--) {\n      if (array[length] === placeholder) {\n        ++result;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A\n   * letters to basic Latin letters.\n   *\n   * @private\n   * @param {string} letter The matched letter to deburr.\n   * @returns {string} Returns the deburred letter.\n   */\n  var deburrLetter = basePropertyOf(deburredLetters);\n\n  /**\n   * Used by `_.escape` to convert characters to HTML entities.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @returns {string} Returns the escaped character.\n   */\n  var escapeHtmlChar = basePropertyOf(htmlEscapes);\n\n  /**\n   * Used by `_.template` to escape characters for inclusion in compiled string literals.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @returns {string} Returns the escaped character.\n   */\n  function escapeStringChar(chr) {\n    return '\\\\' + stringEscapes[chr];\n  }\n\n  /**\n   * Gets the value at `key` of `object`.\n   *\n   * @private\n   * @param {Object} [object] The object to query.\n   * @param {string} key The key of the property to get.\n   * @returns {*} Returns the property value.\n   */\n  function getValue(object, key) {\n    return object == null ? undefined$1 : object[key];\n  }\n\n  /**\n   * Checks if `string` contains Unicode symbols.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {boolean} Returns `true` if a symbol is found, else `false`.\n   */\n  function hasUnicode(string) {\n    return reHasUnicode.test(string);\n  }\n\n  /**\n   * Checks if `string` contains a word composed of Unicode symbols.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {boolean} Returns `true` if a word is found, else `false`.\n   */\n  function hasUnicodeWord(string) {\n    return reHasUnicodeWord.test(string);\n  }\n\n  /**\n   * Converts `iterator` to an array.\n   *\n   * @private\n   * @param {Object} iterator The iterator to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function iteratorToArray(iterator) {\n    var data,\n        result = [];\n\n    while (!(data = iterator.next()).done) {\n      result.push(data.value);\n    }\n    return result;\n  }\n\n  /**\n   * Converts `map` to its key-value pairs.\n   *\n   * @private\n   * @param {Object} map The map to convert.\n   * @returns {Array} Returns the key-value pairs.\n   */\n  function mapToArray(map) {\n    var index = -1,\n        result = Array(map.size);\n\n    map.forEach(function(value, key) {\n      result[++index] = [key, value];\n    });\n    return result;\n  }\n\n  /**\n   * Creates a unary function that invokes `func` with its argument transformed.\n   *\n   * @private\n   * @param {Function} func The function to wrap.\n   * @param {Function} transform The argument transform.\n   * @returns {Function} Returns the new function.\n   */\n  function overArg(func, transform) {\n    return function(arg) {\n      return func(transform(arg));\n    };\n  }\n\n  /**\n   * Replaces all `placeholder` elements in `array` with an internal placeholder\n   * and returns an array of their indexes.\n   *\n   * @private\n   * @param {Array} array The array to modify.\n   * @param {*} placeholder The placeholder to replace.\n   * @returns {Array} Returns the new array of placeholder indexes.\n   */\n  function replaceHolders(array, placeholder) {\n    var index = -1,\n        length = array.length,\n        resIndex = 0,\n        result = [];\n\n    while (++index < length) {\n      var value = array[index];\n      if (value === placeholder || value === PLACEHOLDER) {\n        array[index] = PLACEHOLDER;\n        result[resIndex++] = index;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Converts `set` to an array of its values.\n   *\n   * @private\n   * @param {Object} set The set to convert.\n   * @returns {Array} Returns the values.\n   */\n  function setToArray(set) {\n    var index = -1,\n        result = Array(set.size);\n\n    set.forEach(function(value) {\n      result[++index] = value;\n    });\n    return result;\n  }\n\n  /**\n   * Converts `set` to its value-value pairs.\n   *\n   * @private\n   * @param {Object} set The set to convert.\n   * @returns {Array} Returns the value-value pairs.\n   */\n  function setToPairs(set) {\n    var index = -1,\n        result = Array(set.size);\n\n    set.forEach(function(value) {\n      result[++index] = [value, value];\n    });\n    return result;\n  }\n\n  /**\n   * A specialized version of `_.indexOf` which performs strict equality\n   * comparisons of values, i.e. `===`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function strictIndexOf(array, value, fromIndex) {\n    var index = fromIndex - 1,\n        length = array.length;\n\n    while (++index < length) {\n      if (array[index] === value) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * A specialized version of `_.lastIndexOf` which performs strict equality\n   * comparisons of values, i.e. `===`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function strictLastIndexOf(array, value, fromIndex) {\n    var index = fromIndex + 1;\n    while (index--) {\n      if (array[index] === value) {\n        return index;\n      }\n    }\n    return index;\n  }\n\n  /**\n   * Gets the number of symbols in `string`.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {number} Returns the string size.\n   */\n  function stringSize(string) {\n    return hasUnicode(string)\n      ? unicodeSize(string)\n      : asciiSize(string);\n  }\n\n  /**\n   * Converts `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function stringToArray(string) {\n    return hasUnicode(string)\n      ? unicodeToArray(string)\n      : asciiToArray(string);\n  }\n\n  /**\n   * Used by `_.unescape` to convert HTML entities to characters.\n   *\n   * @private\n   * @param {string} chr The matched character to unescape.\n   * @returns {string} Returns the unescaped character.\n   */\n  var unescapeHtmlChar = basePropertyOf(htmlUnescapes);\n\n  /**\n   * Gets the size of a Unicode `string`.\n   *\n   * @private\n   * @param {string} string The string inspect.\n   * @returns {number} Returns the string size.\n   */\n  function unicodeSize(string) {\n    var result = reUnicode.lastIndex = 0;\n    while (reUnicode.test(string)) {\n      ++result;\n    }\n    return result;\n  }\n\n  /**\n   * Converts a Unicode `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function unicodeToArray(string) {\n    return string.match(reUnicode) || [];\n  }\n\n  /**\n   * Splits a Unicode `string` into an array of its words.\n   *\n   * @private\n   * @param {string} The string to inspect.\n   * @returns {Array} Returns the words of `string`.\n   */\n  function unicodeWords(string) {\n    return string.match(reUnicodeWord) || [];\n  }\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * Create a new pristine `lodash` function using the `context` object.\n   *\n   * @static\n   * @memberOf _\n   * @since 1.1.0\n   * @category Util\n   * @param {Object} [context=root] The context object.\n   * @returns {Function} Returns a new `lodash` function.\n   * @example\n   *\n   * _.mixin({ 'foo': _.constant('foo') });\n   *\n   * var lodash = _.runInContext();\n   * lodash.mixin({ 'bar': lodash.constant('bar') });\n   *\n   * _.isFunction(_.foo);\n   * // => true\n   * _.isFunction(_.bar);\n   * // => false\n   *\n   * lodash.isFunction(lodash.foo);\n   * // => false\n   * lodash.isFunction(lodash.bar);\n   * // => true\n   *\n   * // Create a suped-up `defer` in Node.js.\n   * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;\n   */\n  var runInContext = (function runInContext(context) {\n    context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));\n\n    /** Built-in constructor references. */\n    var Array = context.Array,\n        Date = context.Date,\n        Error = context.Error,\n        Function = context.Function,\n        Math = context.Math,\n        Object = context.Object,\n        RegExp = context.RegExp,\n        String = context.String,\n        TypeError = context.TypeError;\n\n    /** Used for built-in method references. */\n    var arrayProto = Array.prototype,\n        funcProto = Function.prototype,\n        objectProto = Object.prototype;\n\n    /** Used to detect overreaching core-js shims. */\n    var coreJsData = context['__core-js_shared__'];\n\n    /** Used to resolve the decompiled source of functions. */\n    var funcToString = funcProto.toString;\n\n    /** Used to check objects for own properties. */\n    var hasOwnProperty = objectProto.hasOwnProperty;\n\n    /** Used to generate unique IDs. */\n    var idCounter = 0;\n\n    /** Used to detect methods masquerading as native. */\n    var maskSrcKey = (function() {\n      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n      return uid ? ('Symbol(src)_1.' + uid) : '';\n    }());\n\n    /**\n     * Used to resolve the\n     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n     * of values.\n     */\n    var nativeObjectToString = objectProto.toString;\n\n    /** Used to infer the `Object` constructor. */\n    var objectCtorString = funcToString.call(Object);\n\n    /** Used to restore the original `_` reference in `_.noConflict`. */\n    var oldDash = root._;\n\n    /** Used to detect if a method is native. */\n    var reIsNative = RegExp('^' +\n      funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n      .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n    );\n\n    /** Built-in value references. */\n    var Buffer = moduleExports ? context.Buffer : undefined$1,\n        Symbol = context.Symbol,\n        Uint8Array = context.Uint8Array,\n        allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined$1,\n        getPrototype = overArg(Object.getPrototypeOf, Object),\n        objectCreate = Object.create,\n        propertyIsEnumerable = objectProto.propertyIsEnumerable,\n        splice = arrayProto.splice,\n        spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined$1,\n        symIterator = Symbol ? Symbol.iterator : undefined$1,\n        symToStringTag = Symbol ? Symbol.toStringTag : undefined$1;\n\n    var defineProperty = (function() {\n      try {\n        var func = getNative(Object, 'defineProperty');\n        func({}, '', {});\n        return func;\n      } catch (e) {}\n    }());\n\n    /** Mocked built-ins. */\n    var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,\n        ctxNow = Date && Date.now !== root.Date.now && Date.now,\n        ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;\n\n    /* Built-in method references for those with the same name as other `lodash` methods. */\n    var nativeCeil = Math.ceil,\n        nativeFloor = Math.floor,\n        nativeGetSymbols = Object.getOwnPropertySymbols,\n        nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined$1,\n        nativeIsFinite = context.isFinite,\n        nativeJoin = arrayProto.join,\n        nativeKeys = overArg(Object.keys, Object),\n        nativeMax = Math.max,\n        nativeMin = Math.min,\n        nativeNow = Date.now,\n        nativeParseInt = context.parseInt,\n        nativeRandom = Math.random,\n        nativeReverse = arrayProto.reverse;\n\n    /* Built-in method references that are verified to be native. */\n    var DataView = getNative(context, 'DataView'),\n        Map = getNative(context, 'Map'),\n        Promise = getNative(context, 'Promise'),\n        Set = getNative(context, 'Set'),\n        WeakMap = getNative(context, 'WeakMap'),\n        nativeCreate = getNative(Object, 'create');\n\n    /** Used to store function metadata. */\n    var metaMap = WeakMap && new WeakMap;\n\n    /** Used to lookup unminified function names. */\n    var realNames = {};\n\n    /** Used to detect maps, sets, and weakmaps. */\n    var dataViewCtorString = toSource(DataView),\n        mapCtorString = toSource(Map),\n        promiseCtorString = toSource(Promise),\n        setCtorString = toSource(Set),\n        weakMapCtorString = toSource(WeakMap);\n\n    /** Used to convert symbols to primitives and strings. */\n    var symbolProto = Symbol ? Symbol.prototype : undefined$1,\n        symbolValueOf = symbolProto ? symbolProto.valueOf : undefined$1,\n        symbolToString = symbolProto ? symbolProto.toString : undefined$1;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` object which wraps `value` to enable implicit method\n     * chain sequences. Methods that operate on and return arrays, collections,\n     * and functions can be chained together. Methods that retrieve a single value\n     * or may return a primitive value will automatically end the chain sequence\n     * and return the unwrapped value. Otherwise, the value must be unwrapped\n     * with `_#value`.\n     *\n     * Explicit chain sequences, which must be unwrapped with `_#value`, may be\n     * enabled using `_.chain`.\n     *\n     * The execution of chained methods is lazy, that is, it's deferred until\n     * `_#value` is implicitly or explicitly called.\n     *\n     * Lazy evaluation allows several methods to support shortcut fusion.\n     * Shortcut fusion is an optimization to merge iteratee calls; this avoids\n     * the creation of intermediate arrays and can greatly reduce the number of\n     * iteratee executions. Sections of a chain sequence qualify for shortcut\n     * fusion if the section is applied to an array and iteratees accept only\n     * one argument. The heuristic for whether a section qualifies for shortcut\n     * fusion is subject to change.\n     *\n     * Chaining is supported in custom builds as long as the `_#value` method is\n     * directly or indirectly included in the build.\n     *\n     * In addition to lodash methods, wrappers have `Array` and `String` methods.\n     *\n     * The wrapper `Array` methods are:\n     * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`\n     *\n     * The wrapper `String` methods are:\n     * `replace` and `split`\n     *\n     * The wrapper methods that support shortcut fusion are:\n     * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,\n     * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,\n     * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`\n     *\n     * The chainable wrapper methods are:\n     * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,\n     * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,\n     * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,\n     * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,\n     * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,\n     * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,\n     * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,\n     * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,\n     * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,\n     * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,\n     * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,\n     * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,\n     * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,\n     * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,\n     * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,\n     * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,\n     * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,\n     * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,\n     * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,\n     * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,\n     * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,\n     * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,\n     * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,\n     * `zipObject`, `zipObjectDeep`, and `zipWith`\n     *\n     * The wrapper methods that are **not** chainable by default are:\n     * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,\n     * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,\n     * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,\n     * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,\n     * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,\n     * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,\n     * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,\n     * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,\n     * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,\n     * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,\n     * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,\n     * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,\n     * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,\n     * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,\n     * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,\n     * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,\n     * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,\n     * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,\n     * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,\n     * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,\n     * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,\n     * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,\n     * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,\n     * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,\n     * `upperFirst`, `value`, and `words`\n     *\n     * @name _\n     * @constructor\n     * @category Seq\n     * @param {*} value The value to wrap in a `lodash` instance.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var wrapped = _([1, 2, 3]);\n     *\n     * // Returns an unwrapped value.\n     * wrapped.reduce(_.add);\n     * // => 6\n     *\n     * // Returns a wrapped value.\n     * var squares = wrapped.map(square);\n     *\n     * _.isArray(squares);\n     * // => false\n     *\n     * _.isArray(squares.value());\n     * // => true\n     */\n    function lodash(value) {\n      if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {\n        if (value instanceof LodashWrapper) {\n          return value;\n        }\n        if (hasOwnProperty.call(value, '__wrapped__')) {\n          return wrapperClone(value);\n        }\n      }\n      return new LodashWrapper(value);\n    }\n\n    /**\n     * The base implementation of `_.create` without support for assigning\n     * properties to the created object.\n     *\n     * @private\n     * @param {Object} proto The object to inherit from.\n     * @returns {Object} Returns the new object.\n     */\n    var baseCreate = (function() {\n      function object() {}\n      return function(proto) {\n        if (!isObject(proto)) {\n          return {};\n        }\n        if (objectCreate) {\n          return objectCreate(proto);\n        }\n        object.prototype = proto;\n        var result = new object;\n        object.prototype = undefined$1;\n        return result;\n      };\n    }());\n\n    /**\n     * The function whose prototype chain sequence wrappers inherit from.\n     *\n     * @private\n     */\n    function baseLodash() {\n      // No operation performed.\n    }\n\n    /**\n     * The base constructor for creating `lodash` wrapper objects.\n     *\n     * @private\n     * @param {*} value The value to wrap.\n     * @param {boolean} [chainAll] Enable explicit method chain sequences.\n     */\n    function LodashWrapper(value, chainAll) {\n      this.__wrapped__ = value;\n      this.__actions__ = [];\n      this.__chain__ = !!chainAll;\n      this.__index__ = 0;\n      this.__values__ = undefined$1;\n    }\n\n    /**\n     * By default, the template delimiters used by lodash are like those in\n     * embedded Ruby (ERB) as well as ES2015 template strings. Change the\n     * following template settings to use alternative delimiters.\n     *\n     * @static\n     * @memberOf _\n     * @type {Object}\n     */\n    lodash.templateSettings = {\n\n      /**\n       * Used to detect `data` property values to be HTML-escaped.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'escape': reEscape,\n\n      /**\n       * Used to detect code to be evaluated.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'evaluate': reEvaluate,\n\n      /**\n       * Used to detect `data` property values to inject.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'interpolate': reInterpolate,\n\n      /**\n       * Used to reference the data object in the template text.\n       *\n       * @memberOf _.templateSettings\n       * @type {string}\n       */\n      'variable': '',\n\n      /**\n       * Used to import variables into the compiled template.\n       *\n       * @memberOf _.templateSettings\n       * @type {Object}\n       */\n      'imports': {\n\n        /**\n         * A reference to the `lodash` function.\n         *\n         * @memberOf _.templateSettings.imports\n         * @type {Function}\n         */\n        '_': lodash\n      }\n    };\n\n    // Ensure wrappers are instances of `baseLodash`.\n    lodash.prototype = baseLodash.prototype;\n    lodash.prototype.constructor = lodash;\n\n    LodashWrapper.prototype = baseCreate(baseLodash.prototype);\n    LodashWrapper.prototype.constructor = LodashWrapper;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.\n     *\n     * @private\n     * @constructor\n     * @param {*} value The value to wrap.\n     */\n    function LazyWrapper(value) {\n      this.__wrapped__ = value;\n      this.__actions__ = [];\n      this.__dir__ = 1;\n      this.__filtered__ = false;\n      this.__iteratees__ = [];\n      this.__takeCount__ = MAX_ARRAY_LENGTH;\n      this.__views__ = [];\n    }\n\n    /**\n     * Creates a clone of the lazy wrapper object.\n     *\n     * @private\n     * @name clone\n     * @memberOf LazyWrapper\n     * @returns {Object} Returns the cloned `LazyWrapper` object.\n     */\n    function lazyClone() {\n      var result = new LazyWrapper(this.__wrapped__);\n      result.__actions__ = copyArray(this.__actions__);\n      result.__dir__ = this.__dir__;\n      result.__filtered__ = this.__filtered__;\n      result.__iteratees__ = copyArray(this.__iteratees__);\n      result.__takeCount__ = this.__takeCount__;\n      result.__views__ = copyArray(this.__views__);\n      return result;\n    }\n\n    /**\n     * Reverses the direction of lazy iteration.\n     *\n     * @private\n     * @name reverse\n     * @memberOf LazyWrapper\n     * @returns {Object} Returns the new reversed `LazyWrapper` object.\n     */\n    function lazyReverse() {\n      if (this.__filtered__) {\n        var result = new LazyWrapper(this);\n        result.__dir__ = -1;\n        result.__filtered__ = true;\n      } else {\n        result = this.clone();\n        result.__dir__ *= -1;\n      }\n      return result;\n    }\n\n    /**\n     * Extracts the unwrapped value from its lazy wrapper.\n     *\n     * @private\n     * @name value\n     * @memberOf LazyWrapper\n     * @returns {*} Returns the unwrapped value.\n     */\n    function lazyValue() {\n      var array = this.__wrapped__.value(),\n          dir = this.__dir__,\n          isArr = isArray(array),\n          isRight = dir < 0,\n          arrLength = isArr ? array.length : 0,\n          view = getView(0, arrLength, this.__views__),\n          start = view.start,\n          end = view.end,\n          length = end - start,\n          index = isRight ? end : (start - 1),\n          iteratees = this.__iteratees__,\n          iterLength = iteratees.length,\n          resIndex = 0,\n          takeCount = nativeMin(length, this.__takeCount__);\n\n      if (!isArr || (!isRight && arrLength == length && takeCount == length)) {\n        return baseWrapperValue(array, this.__actions__);\n      }\n      var result = [];\n\n      outer:\n      while (length-- && resIndex < takeCount) {\n        index += dir;\n\n        var iterIndex = -1,\n            value = array[index];\n\n        while (++iterIndex < iterLength) {\n          var data = iteratees[iterIndex],\n              iteratee = data.iteratee,\n              type = data.type,\n              computed = iteratee(value);\n\n          if (type == LAZY_MAP_FLAG) {\n            value = computed;\n          } else if (!computed) {\n            if (type == LAZY_FILTER_FLAG) {\n              continue outer;\n            } else {\n              break outer;\n            }\n          }\n        }\n        result[resIndex++] = value;\n      }\n      return result;\n    }\n\n    // Ensure `LazyWrapper` is an instance of `baseLodash`.\n    LazyWrapper.prototype = baseCreate(baseLodash.prototype);\n    LazyWrapper.prototype.constructor = LazyWrapper;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a hash object.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function Hash(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the hash.\n     *\n     * @private\n     * @name clear\n     * @memberOf Hash\n     */\n    function hashClear() {\n      this.__data__ = nativeCreate ? nativeCreate(null) : {};\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the hash.\n     *\n     * @private\n     * @name delete\n     * @memberOf Hash\n     * @param {Object} hash The hash to modify.\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function hashDelete(key) {\n      var result = this.has(key) && delete this.__data__[key];\n      this.size -= result ? 1 : 0;\n      return result;\n    }\n\n    /**\n     * Gets the hash value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf Hash\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function hashGet(key) {\n      var data = this.__data__;\n      if (nativeCreate) {\n        var result = data[key];\n        return result === HASH_UNDEFINED ? undefined$1 : result;\n      }\n      return hasOwnProperty.call(data, key) ? data[key] : undefined$1;\n    }\n\n    /**\n     * Checks if a hash value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf Hash\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function hashHas(key) {\n      var data = this.__data__;\n      return nativeCreate ? (data[key] !== undefined$1) : hasOwnProperty.call(data, key);\n    }\n\n    /**\n     * Sets the hash `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf Hash\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the hash instance.\n     */\n    function hashSet(key, value) {\n      var data = this.__data__;\n      this.size += this.has(key) ? 0 : 1;\n      data[key] = (nativeCreate && value === undefined$1) ? HASH_UNDEFINED : value;\n      return this;\n    }\n\n    // Add methods to `Hash`.\n    Hash.prototype.clear = hashClear;\n    Hash.prototype['delete'] = hashDelete;\n    Hash.prototype.get = hashGet;\n    Hash.prototype.has = hashHas;\n    Hash.prototype.set = hashSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an list cache object.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function ListCache(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the list cache.\n     *\n     * @private\n     * @name clear\n     * @memberOf ListCache\n     */\n    function listCacheClear() {\n      this.__data__ = [];\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the list cache.\n     *\n     * @private\n     * @name delete\n     * @memberOf ListCache\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function listCacheDelete(key) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      if (index < 0) {\n        return false;\n      }\n      var lastIndex = data.length - 1;\n      if (index == lastIndex) {\n        data.pop();\n      } else {\n        splice.call(data, index, 1);\n      }\n      --this.size;\n      return true;\n    }\n\n    /**\n     * Gets the list cache value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf ListCache\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function listCacheGet(key) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      return index < 0 ? undefined$1 : data[index][1];\n    }\n\n    /**\n     * Checks if a list cache value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf ListCache\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function listCacheHas(key) {\n      return assocIndexOf(this.__data__, key) > -1;\n    }\n\n    /**\n     * Sets the list cache `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf ListCache\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the list cache instance.\n     */\n    function listCacheSet(key, value) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      if (index < 0) {\n        ++this.size;\n        data.push([key, value]);\n      } else {\n        data[index][1] = value;\n      }\n      return this;\n    }\n\n    // Add methods to `ListCache`.\n    ListCache.prototype.clear = listCacheClear;\n    ListCache.prototype['delete'] = listCacheDelete;\n    ListCache.prototype.get = listCacheGet;\n    ListCache.prototype.has = listCacheHas;\n    ListCache.prototype.set = listCacheSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a map cache object to store key-value pairs.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function MapCache(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the map.\n     *\n     * @private\n     * @name clear\n     * @memberOf MapCache\n     */\n    function mapCacheClear() {\n      this.size = 0;\n      this.__data__ = {\n        'hash': new Hash,\n        'map': new (Map || ListCache),\n        'string': new Hash\n      };\n    }\n\n    /**\n     * Removes `key` and its value from the map.\n     *\n     * @private\n     * @name delete\n     * @memberOf MapCache\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function mapCacheDelete(key) {\n      var result = getMapData(this, key)['delete'](key);\n      this.size -= result ? 1 : 0;\n      return result;\n    }\n\n    /**\n     * Gets the map value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf MapCache\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function mapCacheGet(key) {\n      return getMapData(this, key).get(key);\n    }\n\n    /**\n     * Checks if a map value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf MapCache\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function mapCacheHas(key) {\n      return getMapData(this, key).has(key);\n    }\n\n    /**\n     * Sets the map `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf MapCache\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the map cache instance.\n     */\n    function mapCacheSet(key, value) {\n      var data = getMapData(this, key),\n          size = data.size;\n\n      data.set(key, value);\n      this.size += data.size == size ? 0 : 1;\n      return this;\n    }\n\n    // Add methods to `MapCache`.\n    MapCache.prototype.clear = mapCacheClear;\n    MapCache.prototype['delete'] = mapCacheDelete;\n    MapCache.prototype.get = mapCacheGet;\n    MapCache.prototype.has = mapCacheHas;\n    MapCache.prototype.set = mapCacheSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     *\n     * Creates an array cache object to store unique values.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [values] The values to cache.\n     */\n    function SetCache(values) {\n      var index = -1,\n          length = values == null ? 0 : values.length;\n\n      this.__data__ = new MapCache;\n      while (++index < length) {\n        this.add(values[index]);\n      }\n    }\n\n    /**\n     * Adds `value` to the array cache.\n     *\n     * @private\n     * @name add\n     * @memberOf SetCache\n     * @alias push\n     * @param {*} value The value to cache.\n     * @returns {Object} Returns the cache instance.\n     */\n    function setCacheAdd(value) {\n      this.__data__.set(value, HASH_UNDEFINED);\n      return this;\n    }\n\n    /**\n     * Checks if `value` is in the array cache.\n     *\n     * @private\n     * @name has\n     * @memberOf SetCache\n     * @param {*} value The value to search for.\n     * @returns {number} Returns `true` if `value` is found, else `false`.\n     */\n    function setCacheHas(value) {\n      return this.__data__.has(value);\n    }\n\n    // Add methods to `SetCache`.\n    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\n    SetCache.prototype.has = setCacheHas;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a stack cache object to store key-value pairs.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function Stack(entries) {\n      var data = this.__data__ = new ListCache(entries);\n      this.size = data.size;\n    }\n\n    /**\n     * Removes all key-value entries from the stack.\n     *\n     * @private\n     * @name clear\n     * @memberOf Stack\n     */\n    function stackClear() {\n      this.__data__ = new ListCache;\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the stack.\n     *\n     * @private\n     * @name delete\n     * @memberOf Stack\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function stackDelete(key) {\n      var data = this.__data__,\n          result = data['delete'](key);\n\n      this.size = data.size;\n      return result;\n    }\n\n    /**\n     * Gets the stack value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf Stack\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function stackGet(key) {\n      return this.__data__.get(key);\n    }\n\n    /**\n     * Checks if a stack value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf Stack\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function stackHas(key) {\n      return this.__data__.has(key);\n    }\n\n    /**\n     * Sets the stack `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf Stack\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the stack cache instance.\n     */\n    function stackSet(key, value) {\n      var data = this.__data__;\n      if (data instanceof ListCache) {\n        var pairs = data.__data__;\n        if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n          pairs.push([key, value]);\n          this.size = ++data.size;\n          return this;\n        }\n        data = this.__data__ = new MapCache(pairs);\n      }\n      data.set(key, value);\n      this.size = data.size;\n      return this;\n    }\n\n    // Add methods to `Stack`.\n    Stack.prototype.clear = stackClear;\n    Stack.prototype['delete'] = stackDelete;\n    Stack.prototype.get = stackGet;\n    Stack.prototype.has = stackHas;\n    Stack.prototype.set = stackSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an array of the enumerable property names of the array-like `value`.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @param {boolean} inherited Specify returning inherited property names.\n     * @returns {Array} Returns the array of property names.\n     */\n    function arrayLikeKeys(value, inherited) {\n      var isArr = isArray(value),\n          isArg = !isArr && isArguments(value),\n          isBuff = !isArr && !isArg && isBuffer(value),\n          isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n          skipIndexes = isArr || isArg || isBuff || isType,\n          result = skipIndexes ? baseTimes(value.length, String) : [],\n          length = result.length;\n\n      for (var key in value) {\n        if ((inherited || hasOwnProperty.call(value, key)) &&\n            !(skipIndexes && (\n               // Safari 9 has enumerable `arguments.length` in strict mode.\n               key == 'length' ||\n               // Node.js 0.10 has enumerable non-index properties on buffers.\n               (isBuff && (key == 'offset' || key == 'parent')) ||\n               // PhantomJS 2 has enumerable non-index properties on typed arrays.\n               (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n               // Skip index properties.\n               isIndex(key, length)\n            ))) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `_.sample` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to sample.\n     * @returns {*} Returns the random element.\n     */\n    function arraySample(array) {\n      var length = array.length;\n      return length ? array[baseRandom(0, length - 1)] : undefined$1;\n    }\n\n    /**\n     * A specialized version of `_.sampleSize` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to sample.\n     * @param {number} n The number of elements to sample.\n     * @returns {Array} Returns the random elements.\n     */\n    function arraySampleSize(array, n) {\n      return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));\n    }\n\n    /**\n     * A specialized version of `_.shuffle` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     */\n    function arrayShuffle(array) {\n      return shuffleSelf(copyArray(array));\n    }\n\n    /**\n     * This function is like `assignValue` except that it doesn't assign\n     * `undefined` values.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {string} key The key of the property to assign.\n     * @param {*} value The value to assign.\n     */\n    function assignMergeValue(object, key, value) {\n      if ((value !== undefined$1 && !eq(object[key], value)) ||\n          (value === undefined$1 && !(key in object))) {\n        baseAssignValue(object, key, value);\n      }\n    }\n\n    /**\n     * Assigns `value` to `key` of `object` if the existing value is not equivalent\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {string} key The key of the property to assign.\n     * @param {*} value The value to assign.\n     */\n    function assignValue(object, key, value) {\n      var objValue = object[key];\n      if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n          (value === undefined$1 && !(key in object))) {\n        baseAssignValue(object, key, value);\n      }\n    }\n\n    /**\n     * Gets the index at which the `key` is found in `array` of key-value pairs.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {*} key The key to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     */\n    function assocIndexOf(array, key) {\n      var length = array.length;\n      while (length--) {\n        if (eq(array[length][0], key)) {\n          return length;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * Aggregates elements of `collection` on `accumulator` with keys transformed\n     * by `iteratee` and values set by `setter`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} setter The function to set `accumulator` values.\n     * @param {Function} iteratee The iteratee to transform keys.\n     * @param {Object} accumulator The initial aggregated object.\n     * @returns {Function} Returns `accumulator`.\n     */\n    function baseAggregator(collection, setter, iteratee, accumulator) {\n      baseEach(collection, function(value, key, collection) {\n        setter(accumulator, value, iteratee(value), collection);\n      });\n      return accumulator;\n    }\n\n    /**\n     * The base implementation of `_.assign` without support for multiple sources\n     * or `customizer` functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @returns {Object} Returns `object`.\n     */\n    function baseAssign(object, source) {\n      return object && copyObject(source, keys(source), object);\n    }\n\n    /**\n     * The base implementation of `_.assignIn` without support for multiple sources\n     * or `customizer` functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @returns {Object} Returns `object`.\n     */\n    function baseAssignIn(object, source) {\n      return object && copyObject(source, keysIn(source), object);\n    }\n\n    /**\n     * The base implementation of `assignValue` and `assignMergeValue` without\n     * value checks.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {string} key The key of the property to assign.\n     * @param {*} value The value to assign.\n     */\n    function baseAssignValue(object, key, value) {\n      if (key == '__proto__' && defineProperty) {\n        defineProperty(object, key, {\n          'configurable': true,\n          'enumerable': true,\n          'value': value,\n          'writable': true\n        });\n      } else {\n        object[key] = value;\n      }\n    }\n\n    /**\n     * The base implementation of `_.at` without support for individual paths.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {string[]} paths The property paths to pick.\n     * @returns {Array} Returns the picked elements.\n     */\n    function baseAt(object, paths) {\n      var index = -1,\n          length = paths.length,\n          result = Array(length),\n          skip = object == null;\n\n      while (++index < length) {\n        result[index] = skip ? undefined$1 : get(object, paths[index]);\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.clamp` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {number} number The number to clamp.\n     * @param {number} [lower] The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the clamped number.\n     */\n    function baseClamp(number, lower, upper) {\n      if (number === number) {\n        if (upper !== undefined$1) {\n          number = number <= upper ? number : upper;\n        }\n        if (lower !== undefined$1) {\n          number = number >= lower ? number : lower;\n        }\n      }\n      return number;\n    }\n\n    /**\n     * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n     * traversed objects.\n     *\n     * @private\n     * @param {*} value The value to clone.\n     * @param {boolean} bitmask The bitmask flags.\n     *  1 - Deep clone\n     *  2 - Flatten inherited properties\n     *  4 - Clone symbols\n     * @param {Function} [customizer] The function to customize cloning.\n     * @param {string} [key] The key of `value`.\n     * @param {Object} [object] The parent object of `value`.\n     * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n     * @returns {*} Returns the cloned value.\n     */\n    function baseClone(value, bitmask, customizer, key, object, stack) {\n      var result,\n          isDeep = bitmask & CLONE_DEEP_FLAG,\n          isFlat = bitmask & CLONE_FLAT_FLAG,\n          isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n      if (customizer) {\n        result = object ? customizer(value, key, object, stack) : customizer(value);\n      }\n      if (result !== undefined$1) {\n        return result;\n      }\n      if (!isObject(value)) {\n        return value;\n      }\n      var isArr = isArray(value);\n      if (isArr) {\n        result = initCloneArray(value);\n        if (!isDeep) {\n          return copyArray(value, result);\n        }\n      } else {\n        var tag = getTag(value),\n            isFunc = tag == funcTag || tag == genTag;\n\n        if (isBuffer(value)) {\n          return cloneBuffer(value, isDeep);\n        }\n        if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n          result = (isFlat || isFunc) ? {} : initCloneObject(value);\n          if (!isDeep) {\n            return isFlat\n              ? copySymbolsIn(value, baseAssignIn(result, value))\n              : copySymbols(value, baseAssign(result, value));\n          }\n        } else {\n          if (!cloneableTags[tag]) {\n            return object ? value : {};\n          }\n          result = initCloneByTag(value, tag, isDeep);\n        }\n      }\n      // Check for circular references and return its corresponding clone.\n      stack || (stack = new Stack);\n      var stacked = stack.get(value);\n      if (stacked) {\n        return stacked;\n      }\n      stack.set(value, result);\n\n      if (isSet(value)) {\n        value.forEach(function(subValue) {\n          result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n        });\n      } else if (isMap(value)) {\n        value.forEach(function(subValue, key) {\n          result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n        });\n      }\n\n      var keysFunc = isFull\n        ? (isFlat ? getAllKeysIn : getAllKeys)\n        : (isFlat ? keysIn : keys);\n\n      var props = isArr ? undefined$1 : keysFunc(value);\n      arrayEach(props || value, function(subValue, key) {\n        if (props) {\n          key = subValue;\n          subValue = value[key];\n        }\n        // Recursively populate clone (susceptible to call stack limits).\n        assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.conforms` which doesn't clone `source`.\n     *\n     * @private\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseConforms(source) {\n      var props = keys(source);\n      return function(object) {\n        return baseConformsTo(object, source, props);\n      };\n    }\n\n    /**\n     * The base implementation of `_.conformsTo` which accepts `props` to check.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n     */\n    function baseConformsTo(object, source, props) {\n      var length = props.length;\n      if (object == null) {\n        return !length;\n      }\n      object = Object(object);\n      while (length--) {\n        var key = props[length],\n            predicate = source[key],\n            value = object[key];\n\n        if ((value === undefined$1 && !(key in object)) || !predicate(value)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * The base implementation of `_.delay` and `_.defer` which accepts `args`\n     * to provide to `func`.\n     *\n     * @private\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @param {Array} args The arguments to provide to `func`.\n     * @returns {number|Object} Returns the timer id or timeout object.\n     */\n    function baseDelay(func, wait, args) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return setTimeout(function() { func.apply(undefined$1, args); }, wait);\n    }\n\n    /**\n     * The base implementation of methods like `_.difference` without support\n     * for excluding multiple arrays or iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Array} values The values to exclude.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     */\n    function baseDifference(array, values, iteratee, comparator) {\n      var index = -1,\n          includes = arrayIncludes,\n          isCommon = true,\n          length = array.length,\n          result = [],\n          valuesLength = values.length;\n\n      if (!length) {\n        return result;\n      }\n      if (iteratee) {\n        values = arrayMap(values, baseUnary(iteratee));\n      }\n      if (comparator) {\n        includes = arrayIncludesWith;\n        isCommon = false;\n      }\n      else if (values.length >= LARGE_ARRAY_SIZE) {\n        includes = cacheHas;\n        isCommon = false;\n        values = new SetCache(values);\n      }\n      outer:\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee == null ? value : iteratee(value);\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (isCommon && computed === computed) {\n          var valuesIndex = valuesLength;\n          while (valuesIndex--) {\n            if (values[valuesIndex] === computed) {\n              continue outer;\n            }\n          }\n          result.push(value);\n        }\n        else if (!includes(values, computed, comparator)) {\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.forEach` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     */\n    var baseEach = createBaseEach(baseForOwn);\n\n    /**\n     * The base implementation of `_.forEachRight` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     */\n    var baseEachRight = createBaseEach(baseForOwnRight, true);\n\n    /**\n     * The base implementation of `_.every` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`\n     */\n    function baseEvery(collection, predicate) {\n      var result = true;\n      baseEach(collection, function(value, index, collection) {\n        result = !!predicate(value, index, collection);\n        return result;\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of methods like `_.max` and `_.min` which accepts a\n     * `comparator` to determine the extremum value.\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} iteratee The iteratee invoked per iteration.\n     * @param {Function} comparator The comparator used to compare values.\n     * @returns {*} Returns the extremum value.\n     */\n    function baseExtremum(array, iteratee, comparator) {\n      var index = -1,\n          length = array.length;\n\n      while (++index < length) {\n        var value = array[index],\n            current = iteratee(value);\n\n        if (current != null && (computed === undefined$1\n              ? (current === current && !isSymbol(current))\n              : comparator(current, computed)\n            )) {\n          var computed = current,\n              result = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.fill` without an iteratee call guard.\n     *\n     * @private\n     * @param {Array} array The array to fill.\n     * @param {*} value The value to fill `array` with.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns `array`.\n     */\n    function baseFill(array, value, start, end) {\n      var length = array.length;\n\n      start = toInteger(start);\n      if (start < 0) {\n        start = -start > length ? 0 : (length + start);\n      }\n      end = (end === undefined$1 || end > length) ? length : toInteger(end);\n      if (end < 0) {\n        end += length;\n      }\n      end = start > end ? 0 : toLength(end);\n      while (start < end) {\n        array[start++] = value;\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.filter` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     */\n    function baseFilter(collection, predicate) {\n      var result = [];\n      baseEach(collection, function(value, index, collection) {\n        if (predicate(value, index, collection)) {\n          result.push(value);\n        }\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.flatten` with support for restricting flattening.\n     *\n     * @private\n     * @param {Array} array The array to flatten.\n     * @param {number} depth The maximum recursion depth.\n     * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n     * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n     * @param {Array} [result=[]] The initial result value.\n     * @returns {Array} Returns the new flattened array.\n     */\n    function baseFlatten(array, depth, predicate, isStrict, result) {\n      var index = -1,\n          length = array.length;\n\n      predicate || (predicate = isFlattenable);\n      result || (result = []);\n\n      while (++index < length) {\n        var value = array[index];\n        if (depth > 0 && predicate(value)) {\n          if (depth > 1) {\n            // Recursively flatten arrays (susceptible to call stack limits).\n            baseFlatten(value, depth - 1, predicate, isStrict, result);\n          } else {\n            arrayPush(result, value);\n          }\n        } else if (!isStrict) {\n          result[result.length] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `baseForOwn` which iterates over `object`\n     * properties returned by `keysFunc` and invokes `iteratee` for each property.\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @returns {Object} Returns `object`.\n     */\n    var baseFor = createBaseFor();\n\n    /**\n     * This function is like `baseFor` except that it iterates over properties\n     * in the opposite order.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @returns {Object} Returns `object`.\n     */\n    var baseForRight = createBaseFor(true);\n\n    /**\n     * The base implementation of `_.forOwn` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForOwn(object, iteratee) {\n      return object && baseFor(object, iteratee, keys);\n    }\n\n    /**\n     * The base implementation of `_.forOwnRight` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForOwnRight(object, iteratee) {\n      return object && baseForRight(object, iteratee, keys);\n    }\n\n    /**\n     * The base implementation of `_.functions` which creates an array of\n     * `object` function property names filtered from `props`.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Array} props The property names to filter.\n     * @returns {Array} Returns the function names.\n     */\n    function baseFunctions(object, props) {\n      return arrayFilter(props, function(key) {\n        return isFunction(object[key]);\n      });\n    }\n\n    /**\n     * The base implementation of `_.get` without support for default values.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to get.\n     * @returns {*} Returns the resolved value.\n     */\n    function baseGet(object, path) {\n      path = castPath(path, object);\n\n      var index = 0,\n          length = path.length;\n\n      while (object != null && index < length) {\n        object = object[toKey(path[index++])];\n      }\n      return (index && index == length) ? object : undefined$1;\n    }\n\n    /**\n     * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n     * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n     * symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @param {Function} symbolsFunc The function to get the symbols of `object`.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function baseGetAllKeys(object, keysFunc, symbolsFunc) {\n      var result = keysFunc(object);\n      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n    }\n\n    /**\n     * The base implementation of `getTag` without fallbacks for buggy environments.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the `toStringTag`.\n     */\n    function baseGetTag(value) {\n      if (value == null) {\n        return value === undefined$1 ? undefinedTag : nullTag;\n      }\n      return (symToStringTag && symToStringTag in Object(value))\n        ? getRawTag(value)\n        : objectToString(value);\n    }\n\n    /**\n     * The base implementation of `_.gt` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than `other`,\n     *  else `false`.\n     */\n    function baseGt(value, other) {\n      return value > other;\n    }\n\n    /**\n     * The base implementation of `_.has` without support for deep paths.\n     *\n     * @private\n     * @param {Object} [object] The object to query.\n     * @param {Array|string} key The key to check.\n     * @returns {boolean} Returns `true` if `key` exists, else `false`.\n     */\n    function baseHas(object, key) {\n      return object != null && hasOwnProperty.call(object, key);\n    }\n\n    /**\n     * The base implementation of `_.hasIn` without support for deep paths.\n     *\n     * @private\n     * @param {Object} [object] The object to query.\n     * @param {Array|string} key The key to check.\n     * @returns {boolean} Returns `true` if `key` exists, else `false`.\n     */\n    function baseHasIn(object, key) {\n      return object != null && key in Object(object);\n    }\n\n    /**\n     * The base implementation of `_.inRange` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {number} number The number to check.\n     * @param {number} start The start of the range.\n     * @param {number} end The end of the range.\n     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n     */\n    function baseInRange(number, start, end) {\n      return number >= nativeMin(start, end) && number < nativeMax(start, end);\n    }\n\n    /**\n     * The base implementation of methods like `_.intersection`, without support\n     * for iteratee shorthands, that accepts an array of arrays to inspect.\n     *\n     * @private\n     * @param {Array} arrays The arrays to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of shared values.\n     */\n    function baseIntersection(arrays, iteratee, comparator) {\n      var includes = comparator ? arrayIncludesWith : arrayIncludes,\n          length = arrays[0].length,\n          othLength = arrays.length,\n          othIndex = othLength,\n          caches = Array(othLength),\n          maxLength = Infinity,\n          result = [];\n\n      while (othIndex--) {\n        var array = arrays[othIndex];\n        if (othIndex && iteratee) {\n          array = arrayMap(array, baseUnary(iteratee));\n        }\n        maxLength = nativeMin(array.length, maxLength);\n        caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))\n          ? new SetCache(othIndex && array)\n          : undefined$1;\n      }\n      array = arrays[0];\n\n      var index = -1,\n          seen = caches[0];\n\n      outer:\n      while (++index < length && result.length < maxLength) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (!(seen\n              ? cacheHas(seen, computed)\n              : includes(result, computed, comparator)\n            )) {\n          othIndex = othLength;\n          while (--othIndex) {\n            var cache = caches[othIndex];\n            if (!(cache\n                  ? cacheHas(cache, computed)\n                  : includes(arrays[othIndex], computed, comparator))\n                ) {\n              continue outer;\n            }\n          }\n          if (seen) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.invert` and `_.invertBy` which inverts\n     * `object` with values transformed by `iteratee` and set by `setter`.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} setter The function to set `accumulator` values.\n     * @param {Function} iteratee The iteratee to transform values.\n     * @param {Object} accumulator The initial inverted object.\n     * @returns {Function} Returns `accumulator`.\n     */\n    function baseInverter(object, setter, iteratee, accumulator) {\n      baseForOwn(object, function(value, key, object) {\n        setter(accumulator, iteratee(value), key, object);\n      });\n      return accumulator;\n    }\n\n    /**\n     * The base implementation of `_.invoke` without support for individual\n     * method arguments.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {Array} args The arguments to invoke the method with.\n     * @returns {*} Returns the result of the invoked method.\n     */\n    function baseInvoke(object, path, args) {\n      path = castPath(path, object);\n      object = parent(object, path);\n      var func = object == null ? object : object[toKey(last(path))];\n      return func == null ? undefined$1 : apply(func, object, args);\n    }\n\n    /**\n     * The base implementation of `_.isArguments`.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n     */\n    function baseIsArguments(value) {\n      return isObjectLike(value) && baseGetTag(value) == argsTag;\n    }\n\n    /**\n     * The base implementation of `_.isArrayBuffer` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n     */\n    function baseIsArrayBuffer(value) {\n      return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;\n    }\n\n    /**\n     * The base implementation of `_.isDate` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n     */\n    function baseIsDate(value) {\n      return isObjectLike(value) && baseGetTag(value) == dateTag;\n    }\n\n    /**\n     * The base implementation of `_.isEqual` which supports partial comparisons\n     * and tracks traversed objects.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @param {boolean} bitmask The bitmask flags.\n     *  1 - Unordered comparison\n     *  2 - Partial comparison\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     */\n    function baseIsEqual(value, other, bitmask, customizer, stack) {\n      if (value === other) {\n        return true;\n      }\n      if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n        return value !== value && other !== other;\n      }\n      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n    }\n\n    /**\n     * A specialized version of `baseIsEqual` for arrays and objects which performs\n     * deep comparisons and tracks traversed objects enabling objects with circular\n     * references to be compared.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n      var objIsArr = isArray(object),\n          othIsArr = isArray(other),\n          objTag = objIsArr ? arrayTag : getTag(object),\n          othTag = othIsArr ? arrayTag : getTag(other);\n\n      objTag = objTag == argsTag ? objectTag : objTag;\n      othTag = othTag == argsTag ? objectTag : othTag;\n\n      var objIsObj = objTag == objectTag,\n          othIsObj = othTag == objectTag,\n          isSameTag = objTag == othTag;\n\n      if (isSameTag && isBuffer(object)) {\n        if (!isBuffer(other)) {\n          return false;\n        }\n        objIsArr = true;\n        objIsObj = false;\n      }\n      if (isSameTag && !objIsObj) {\n        stack || (stack = new Stack);\n        return (objIsArr || isTypedArray(object))\n          ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n          : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n      }\n      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n        var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n            othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n        if (objIsWrapped || othIsWrapped) {\n          var objUnwrapped = objIsWrapped ? object.value() : object,\n              othUnwrapped = othIsWrapped ? other.value() : other;\n\n          stack || (stack = new Stack);\n          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n        }\n      }\n      if (!isSameTag) {\n        return false;\n      }\n      stack || (stack = new Stack);\n      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n    }\n\n    /**\n     * The base implementation of `_.isMap` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n     */\n    function baseIsMap(value) {\n      return isObjectLike(value) && getTag(value) == mapTag;\n    }\n\n    /**\n     * The base implementation of `_.isMatch` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @param {Array} matchData The property names, values, and compare flags to match.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     */\n    function baseIsMatch(object, source, matchData, customizer) {\n      var index = matchData.length,\n          length = index,\n          noCustomizer = !customizer;\n\n      if (object == null) {\n        return !length;\n      }\n      object = Object(object);\n      while (index--) {\n        var data = matchData[index];\n        if ((noCustomizer && data[2])\n              ? data[1] !== object[data[0]]\n              : !(data[0] in object)\n            ) {\n          return false;\n        }\n      }\n      while (++index < length) {\n        data = matchData[index];\n        var key = data[0],\n            objValue = object[key],\n            srcValue = data[1];\n\n        if (noCustomizer && data[2]) {\n          if (objValue === undefined$1 && !(key in object)) {\n            return false;\n          }\n        } else {\n          var stack = new Stack;\n          if (customizer) {\n            var result = customizer(objValue, srcValue, key, object, source, stack);\n          }\n          if (!(result === undefined$1\n                ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)\n                : result\n              )) {\n            return false;\n          }\n        }\n      }\n      return true;\n    }\n\n    /**\n     * The base implementation of `_.isNative` without bad shim checks.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a native function,\n     *  else `false`.\n     */\n    function baseIsNative(value) {\n      if (!isObject(value) || isMasked(value)) {\n        return false;\n      }\n      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n      return pattern.test(toSource(value));\n    }\n\n    /**\n     * The base implementation of `_.isRegExp` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n     */\n    function baseIsRegExp(value) {\n      return isObjectLike(value) && baseGetTag(value) == regexpTag;\n    }\n\n    /**\n     * The base implementation of `_.isSet` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n     */\n    function baseIsSet(value) {\n      return isObjectLike(value) && getTag(value) == setTag;\n    }\n\n    /**\n     * The base implementation of `_.isTypedArray` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n     */\n    function baseIsTypedArray(value) {\n      return isObjectLike(value) &&\n        isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n    }\n\n    /**\n     * The base implementation of `_.iteratee`.\n     *\n     * @private\n     * @param {*} [value=_.identity] The value to convert to an iteratee.\n     * @returns {Function} Returns the iteratee.\n     */\n    function baseIteratee(value) {\n      // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.\n      // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.\n      if (typeof value == 'function') {\n        return value;\n      }\n      if (value == null) {\n        return identity;\n      }\n      if (typeof value == 'object') {\n        return isArray(value)\n          ? baseMatchesProperty(value[0], value[1])\n          : baseMatches(value);\n      }\n      return property(value);\n    }\n\n    /**\n     * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function baseKeys(object) {\n      if (!isPrototype(object)) {\n        return nativeKeys(object);\n      }\n      var result = [];\n      for (var key in Object(object)) {\n        if (hasOwnProperty.call(object, key) && key != 'constructor') {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function baseKeysIn(object) {\n      if (!isObject(object)) {\n        return nativeKeysIn(object);\n      }\n      var isProto = isPrototype(object),\n          result = [];\n\n      for (var key in object) {\n        if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.lt` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than `other`,\n     *  else `false`.\n     */\n    function baseLt(value, other) {\n      return value < other;\n    }\n\n    /**\n     * The base implementation of `_.map` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array} Returns the new mapped array.\n     */\n    function baseMap(collection, iteratee) {\n      var index = -1,\n          result = isArrayLike(collection) ? Array(collection.length) : [];\n\n      baseEach(collection, function(value, key, collection) {\n        result[++index] = iteratee(value, key, collection);\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.matches` which doesn't clone `source`.\n     *\n     * @private\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseMatches(source) {\n      var matchData = getMatchData(source);\n      if (matchData.length == 1 && matchData[0][2]) {\n        return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n      }\n      return function(object) {\n        return object === source || baseIsMatch(object, source, matchData);\n      };\n    }\n\n    /**\n     * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.\n     *\n     * @private\n     * @param {string} path The path of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseMatchesProperty(path, srcValue) {\n      if (isKey(path) && isStrictComparable(srcValue)) {\n        return matchesStrictComparable(toKey(path), srcValue);\n      }\n      return function(object) {\n        var objValue = get(object, path);\n        return (objValue === undefined$1 && objValue === srcValue)\n          ? hasIn(object, path)\n          : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n      };\n    }\n\n    /**\n     * The base implementation of `_.merge` without support for multiple sources.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {number} srcIndex The index of `source`.\n     * @param {Function} [customizer] The function to customize merged values.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     */\n    function baseMerge(object, source, srcIndex, customizer, stack) {\n      if (object === source) {\n        return;\n      }\n      baseFor(source, function(srcValue, key) {\n        stack || (stack = new Stack);\n        if (isObject(srcValue)) {\n          baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n        }\n        else {\n          var newValue = customizer\n            ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n            : undefined$1;\n\n          if (newValue === undefined$1) {\n            newValue = srcValue;\n          }\n          assignMergeValue(object, key, newValue);\n        }\n      }, keysIn);\n    }\n\n    /**\n     * A specialized version of `baseMerge` for arrays and objects which performs\n     * deep merges and tracks traversed objects enabling objects with circular\n     * references to be merged.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {string} key The key of the value to merge.\n     * @param {number} srcIndex The index of `source`.\n     * @param {Function} mergeFunc The function to merge values.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     */\n    function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n      var objValue = safeGet(object, key),\n          srcValue = safeGet(source, key),\n          stacked = stack.get(srcValue);\n\n      if (stacked) {\n        assignMergeValue(object, key, stacked);\n        return;\n      }\n      var newValue = customizer\n        ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n        : undefined$1;\n\n      var isCommon = newValue === undefined$1;\n\n      if (isCommon) {\n        var isArr = isArray(srcValue),\n            isBuff = !isArr && isBuffer(srcValue),\n            isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n        newValue = srcValue;\n        if (isArr || isBuff || isTyped) {\n          if (isArray(objValue)) {\n            newValue = objValue;\n          }\n          else if (isArrayLikeObject(objValue)) {\n            newValue = copyArray(objValue);\n          }\n          else if (isBuff) {\n            isCommon = false;\n            newValue = cloneBuffer(srcValue, true);\n          }\n          else if (isTyped) {\n            isCommon = false;\n            newValue = cloneTypedArray(srcValue, true);\n          }\n          else {\n            newValue = [];\n          }\n        }\n        else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n          newValue = objValue;\n          if (isArguments(objValue)) {\n            newValue = toPlainObject(objValue);\n          }\n          else if (!isObject(objValue) || isFunction(objValue)) {\n            newValue = initCloneObject(srcValue);\n          }\n        }\n        else {\n          isCommon = false;\n        }\n      }\n      if (isCommon) {\n        // Recursively merge objects and arrays (susceptible to call stack limits).\n        stack.set(srcValue, newValue);\n        mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n        stack['delete'](srcValue);\n      }\n      assignMergeValue(object, key, newValue);\n    }\n\n    /**\n     * The base implementation of `_.nth` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {Array} array The array to query.\n     * @param {number} n The index of the element to return.\n     * @returns {*} Returns the nth element of `array`.\n     */\n    function baseNth(array, n) {\n      var length = array.length;\n      if (!length) {\n        return;\n      }\n      n += n < 0 ? length : 0;\n      return isIndex(n, length) ? array[n] : undefined$1;\n    }\n\n    /**\n     * The base implementation of `_.orderBy` without param guards.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.\n     * @param {string[]} orders The sort orders of `iteratees`.\n     * @returns {Array} Returns the new sorted array.\n     */\n    function baseOrderBy(collection, iteratees, orders) {\n      var index = -1;\n      iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(getIteratee()));\n\n      var result = baseMap(collection, function(value, key, collection) {\n        var criteria = arrayMap(iteratees, function(iteratee) {\n          return iteratee(value);\n        });\n        return { 'criteria': criteria, 'index': ++index, 'value': value };\n      });\n\n      return baseSortBy(result, function(object, other) {\n        return compareMultiple(object, other, orders);\n      });\n    }\n\n    /**\n     * The base implementation of `_.pick` without support for individual\n     * property identifiers.\n     *\n     * @private\n     * @param {Object} object The source object.\n     * @param {string[]} paths The property paths to pick.\n     * @returns {Object} Returns the new object.\n     */\n    function basePick(object, paths) {\n      return basePickBy(object, paths, function(value, path) {\n        return hasIn(object, path);\n      });\n    }\n\n    /**\n     * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The source object.\n     * @param {string[]} paths The property paths to pick.\n     * @param {Function} predicate The function invoked per property.\n     * @returns {Object} Returns the new object.\n     */\n    function basePickBy(object, paths, predicate) {\n      var index = -1,\n          length = paths.length,\n          result = {};\n\n      while (++index < length) {\n        var path = paths[index],\n            value = baseGet(object, path);\n\n        if (predicate(value, path)) {\n          baseSet(result, castPath(path, object), value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseProperty` which supports deep paths.\n     *\n     * @private\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new accessor function.\n     */\n    function basePropertyDeep(path) {\n      return function(object) {\n        return baseGet(object, path);\n      };\n    }\n\n    /**\n     * The base implementation of `_.pullAllBy` without support for iteratee\n     * shorthands.\n     *\n     * @private\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns `array`.\n     */\n    function basePullAll(array, values, iteratee, comparator) {\n      var indexOf = comparator ? baseIndexOfWith : baseIndexOf,\n          index = -1,\n          length = values.length,\n          seen = array;\n\n      if (array === values) {\n        values = copyArray(values);\n      }\n      if (iteratee) {\n        seen = arrayMap(array, baseUnary(iteratee));\n      }\n      while (++index < length) {\n        var fromIndex = 0,\n            value = values[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {\n          if (seen !== array) {\n            splice.call(seen, fromIndex, 1);\n          }\n          splice.call(array, fromIndex, 1);\n        }\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.pullAt` without support for individual\n     * indexes or capturing the removed elements.\n     *\n     * @private\n     * @param {Array} array The array to modify.\n     * @param {number[]} indexes The indexes of elements to remove.\n     * @returns {Array} Returns `array`.\n     */\n    function basePullAt(array, indexes) {\n      var length = array ? indexes.length : 0,\n          lastIndex = length - 1;\n\n      while (length--) {\n        var index = indexes[length];\n        if (length == lastIndex || index !== previous) {\n          var previous = index;\n          if (isIndex(index)) {\n            splice.call(array, index, 1);\n          } else {\n            baseUnset(array, index);\n          }\n        }\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.random` without support for returning\n     * floating-point numbers.\n     *\n     * @private\n     * @param {number} lower The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the random number.\n     */\n    function baseRandom(lower, upper) {\n      return lower + nativeFloor(nativeRandom() * (upper - lower + 1));\n    }\n\n    /**\n     * The base implementation of `_.range` and `_.rangeRight` which doesn't\n     * coerce arguments.\n     *\n     * @private\n     * @param {number} start The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} step The value to increment or decrement by.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Array} Returns the range of numbers.\n     */\n    function baseRange(start, end, step, fromRight) {\n      var index = -1,\n          length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),\n          result = Array(length);\n\n      while (length--) {\n        result[fromRight ? length : ++index] = start;\n        start += step;\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.repeat` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {string} string The string to repeat.\n     * @param {number} n The number of times to repeat the string.\n     * @returns {string} Returns the repeated string.\n     */\n    function baseRepeat(string, n) {\n      var result = '';\n      if (!string || n < 1 || n > MAX_SAFE_INTEGER) {\n        return result;\n      }\n      // Leverage the exponentiation by squaring algorithm for a faster repeat.\n      // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.\n      do {\n        if (n % 2) {\n          result += string;\n        }\n        n = nativeFloor(n / 2);\n        if (n) {\n          string += string;\n        }\n      } while (n);\n\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n     *\n     * @private\n     * @param {Function} func The function to apply a rest parameter to.\n     * @param {number} [start=func.length-1] The start position of the rest parameter.\n     * @returns {Function} Returns the new function.\n     */\n    function baseRest(func, start) {\n      return setToString(overRest(func, start, identity), func + '');\n    }\n\n    /**\n     * The base implementation of `_.sample`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to sample.\n     * @returns {*} Returns the random element.\n     */\n    function baseSample(collection) {\n      return arraySample(values(collection));\n    }\n\n    /**\n     * The base implementation of `_.sampleSize` without param guards.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to sample.\n     * @param {number} n The number of elements to sample.\n     * @returns {Array} Returns the random elements.\n     */\n    function baseSampleSize(collection, n) {\n      var array = values(collection);\n      return shuffleSelf(array, baseClamp(n, 0, array.length));\n    }\n\n    /**\n     * The base implementation of `_.set`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @param {Function} [customizer] The function to customize path creation.\n     * @returns {Object} Returns `object`.\n     */\n    function baseSet(object, path, value, customizer) {\n      if (!isObject(object)) {\n        return object;\n      }\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length,\n          lastIndex = length - 1,\n          nested = object;\n\n      while (nested != null && ++index < length) {\n        var key = toKey(path[index]),\n            newValue = value;\n\n        if (index != lastIndex) {\n          var objValue = nested[key];\n          newValue = customizer ? customizer(objValue, key, nested) : undefined$1;\n          if (newValue === undefined$1) {\n            newValue = isObject(objValue)\n              ? objValue\n              : (isIndex(path[index + 1]) ? [] : {});\n          }\n        }\n        assignValue(nested, key, newValue);\n        nested = nested[key];\n      }\n      return object;\n    }\n\n    /**\n     * The base implementation of `setData` without support for hot loop shorting.\n     *\n     * @private\n     * @param {Function} func The function to associate metadata with.\n     * @param {*} data The metadata.\n     * @returns {Function} Returns `func`.\n     */\n    var baseSetData = !metaMap ? identity : function(func, data) {\n      metaMap.set(func, data);\n      return func;\n    };\n\n    /**\n     * The base implementation of `setToString` without support for hot loop shorting.\n     *\n     * @private\n     * @param {Function} func The function to modify.\n     * @param {Function} string The `toString` result.\n     * @returns {Function} Returns `func`.\n     */\n    var baseSetToString = !defineProperty ? identity : function(func, string) {\n      return defineProperty(func, 'toString', {\n        'configurable': true,\n        'enumerable': false,\n        'value': constant(string),\n        'writable': true\n      });\n    };\n\n    /**\n     * The base implementation of `_.shuffle`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     */\n    function baseShuffle(collection) {\n      return shuffleSelf(values(collection));\n    }\n\n    /**\n     * The base implementation of `_.slice` without an iteratee call guard.\n     *\n     * @private\n     * @param {Array} array The array to slice.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function baseSlice(array, start, end) {\n      var index = -1,\n          length = array.length;\n\n      if (start < 0) {\n        start = -start > length ? 0 : (length + start);\n      }\n      end = end > length ? length : end;\n      if (end < 0) {\n        end += length;\n      }\n      length = start > end ? 0 : ((end - start) >>> 0);\n      start >>>= 0;\n\n      var result = Array(length);\n      while (++index < length) {\n        result[index] = array[index + start];\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.some` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     */\n    function baseSome(collection, predicate) {\n      var result;\n\n      baseEach(collection, function(value, index, collection) {\n        result = predicate(value, index, collection);\n        return !result;\n      });\n      return !!result;\n    }\n\n    /**\n     * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which\n     * performs a binary search of `array` to determine the index at which `value`\n     * should be inserted into `array` in order to maintain its sort order.\n     *\n     * @private\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     */\n    function baseSortedIndex(array, value, retHighest) {\n      var low = 0,\n          high = array == null ? low : array.length;\n\n      if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {\n        while (low < high) {\n          var mid = (low + high) >>> 1,\n              computed = array[mid];\n\n          if (computed !== null && !isSymbol(computed) &&\n              (retHighest ? (computed <= value) : (computed < value))) {\n            low = mid + 1;\n          } else {\n            high = mid;\n          }\n        }\n        return high;\n      }\n      return baseSortedIndexBy(array, value, identity, retHighest);\n    }\n\n    /**\n     * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`\n     * which invokes `iteratee` for `value` and each element of `array` to compute\n     * their sort ranking. The iteratee is invoked with one argument; (value).\n     *\n     * @private\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} iteratee The iteratee invoked per element.\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     */\n    function baseSortedIndexBy(array, value, iteratee, retHighest) {\n      value = iteratee(value);\n\n      var low = 0,\n          high = array == null ? 0 : array.length,\n          valIsNaN = value !== value,\n          valIsNull = value === null,\n          valIsSymbol = isSymbol(value),\n          valIsUndefined = value === undefined$1;\n\n      while (low < high) {\n        var mid = nativeFloor((low + high) / 2),\n            computed = iteratee(array[mid]),\n            othIsDefined = computed !== undefined$1,\n            othIsNull = computed === null,\n            othIsReflexive = computed === computed,\n            othIsSymbol = isSymbol(computed);\n\n        if (valIsNaN) {\n          var setLow = retHighest || othIsReflexive;\n        } else if (valIsUndefined) {\n          setLow = othIsReflexive && (retHighest || othIsDefined);\n        } else if (valIsNull) {\n          setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);\n        } else if (valIsSymbol) {\n          setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);\n        } else if (othIsNull || othIsSymbol) {\n          setLow = false;\n        } else {\n          setLow = retHighest ? (computed <= value) : (computed < value);\n        }\n        if (setLow) {\n          low = mid + 1;\n        } else {\n          high = mid;\n        }\n      }\n      return nativeMin(high, MAX_ARRAY_INDEX);\n    }\n\n    /**\n     * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without\n     * support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     */\n    function baseSortedUniq(array, iteratee) {\n      var index = -1,\n          length = array.length,\n          resIndex = 0,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        if (!index || !eq(computed, seen)) {\n          var seen = computed;\n          result[resIndex++] = value === 0 ? 0 : value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.toNumber` which doesn't ensure correct\n     * conversions of binary, hexadecimal, or octal string values.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {number} Returns the number.\n     */\n    function baseToNumber(value) {\n      if (typeof value == 'number') {\n        return value;\n      }\n      if (isSymbol(value)) {\n        return NAN;\n      }\n      return +value;\n    }\n\n    /**\n     * The base implementation of `_.toString` which doesn't convert nullish\n     * values to empty strings.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {string} Returns the string.\n     */\n    function baseToString(value) {\n      // Exit early for strings to avoid a performance hit in some environments.\n      if (typeof value == 'string') {\n        return value;\n      }\n      if (isArray(value)) {\n        // Recursively convert values (susceptible to call stack limits).\n        return arrayMap(value, baseToString) + '';\n      }\n      if (isSymbol(value)) {\n        return symbolToString ? symbolToString.call(value) : '';\n      }\n      var result = (value + '');\n      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n    }\n\n    /**\n     * The base implementation of `_.uniqBy` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     */\n    function baseUniq(array, iteratee, comparator) {\n      var index = -1,\n          includes = arrayIncludes,\n          length = array.length,\n          isCommon = true,\n          result = [],\n          seen = result;\n\n      if (comparator) {\n        isCommon = false;\n        includes = arrayIncludesWith;\n      }\n      else if (length >= LARGE_ARRAY_SIZE) {\n        var set = iteratee ? null : createSet(array);\n        if (set) {\n          return setToArray(set);\n        }\n        isCommon = false;\n        includes = cacheHas;\n        seen = new SetCache;\n      }\n      else {\n        seen = iteratee ? [] : result;\n      }\n      outer:\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (isCommon && computed === computed) {\n          var seenIndex = seen.length;\n          while (seenIndex--) {\n            if (seen[seenIndex] === computed) {\n              continue outer;\n            }\n          }\n          if (iteratee) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n        else if (!includes(seen, computed, comparator)) {\n          if (seen !== result) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.unset`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The property path to unset.\n     * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n     */\n    function baseUnset(object, path) {\n      path = castPath(path, object);\n      object = parent(object, path);\n      return object == null || delete object[toKey(last(path))];\n    }\n\n    /**\n     * The base implementation of `_.update`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to update.\n     * @param {Function} updater The function to produce the updated value.\n     * @param {Function} [customizer] The function to customize path creation.\n     * @returns {Object} Returns `object`.\n     */\n    function baseUpdate(object, path, updater, customizer) {\n      return baseSet(object, path, updater(baseGet(object, path)), customizer);\n    }\n\n    /**\n     * The base implementation of methods like `_.dropWhile` and `_.takeWhile`\n     * without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to query.\n     * @param {Function} predicate The function invoked per iteration.\n     * @param {boolean} [isDrop] Specify dropping elements instead of taking them.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function baseWhile(array, predicate, isDrop, fromRight) {\n      var length = array.length,\n          index = fromRight ? length : -1;\n\n      while ((fromRight ? index-- : ++index < length) &&\n        predicate(array[index], index, array)) {}\n\n      return isDrop\n        ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))\n        : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));\n    }\n\n    /**\n     * The base implementation of `wrapperValue` which returns the result of\n     * performing a sequence of actions on the unwrapped `value`, where each\n     * successive action is supplied the return value of the previous.\n     *\n     * @private\n     * @param {*} value The unwrapped value.\n     * @param {Array} actions Actions to perform to resolve the unwrapped value.\n     * @returns {*} Returns the resolved value.\n     */\n    function baseWrapperValue(value, actions) {\n      var result = value;\n      if (result instanceof LazyWrapper) {\n        result = result.value();\n      }\n      return arrayReduce(actions, function(result, action) {\n        return action.func.apply(action.thisArg, arrayPush([result], action.args));\n      }, result);\n    }\n\n    /**\n     * The base implementation of methods like `_.xor`, without support for\n     * iteratee shorthands, that accepts an array of arrays to inspect.\n     *\n     * @private\n     * @param {Array} arrays The arrays to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of values.\n     */\n    function baseXor(arrays, iteratee, comparator) {\n      var length = arrays.length;\n      if (length < 2) {\n        return length ? baseUniq(arrays[0]) : [];\n      }\n      var index = -1,\n          result = Array(length);\n\n      while (++index < length) {\n        var array = arrays[index],\n            othIndex = -1;\n\n        while (++othIndex < length) {\n          if (othIndex != index) {\n            result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);\n          }\n        }\n      }\n      return baseUniq(baseFlatten(result, 1), iteratee, comparator);\n    }\n\n    /**\n     * This base implementation of `_.zipObject` which assigns values using `assignFunc`.\n     *\n     * @private\n     * @param {Array} props The property identifiers.\n     * @param {Array} values The property values.\n     * @param {Function} assignFunc The function to assign values.\n     * @returns {Object} Returns the new object.\n     */\n    function baseZipObject(props, values, assignFunc) {\n      var index = -1,\n          length = props.length,\n          valsLength = values.length,\n          result = {};\n\n      while (++index < length) {\n        var value = index < valsLength ? values[index] : undefined$1;\n        assignFunc(result, props[index], value);\n      }\n      return result;\n    }\n\n    /**\n     * Casts `value` to an empty array if it's not an array like object.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {Array|Object} Returns the cast array-like object.\n     */\n    function castArrayLikeObject(value) {\n      return isArrayLikeObject(value) ? value : [];\n    }\n\n    /**\n     * Casts `value` to `identity` if it's not a function.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {Function} Returns cast function.\n     */\n    function castFunction(value) {\n      return typeof value == 'function' ? value : identity;\n    }\n\n    /**\n     * Casts `value` to a path array if it's not one.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @param {Object} [object] The object to query keys on.\n     * @returns {Array} Returns the cast property path array.\n     */\n    function castPath(value, object) {\n      if (isArray(value)) {\n        return value;\n      }\n      return isKey(value, object) ? [value] : stringToPath(toString(value));\n    }\n\n    /**\n     * A `baseRest` alias which can be replaced with `identity` by module\n     * replacement plugins.\n     *\n     * @private\n     * @type {Function}\n     * @param {Function} func The function to apply a rest parameter to.\n     * @returns {Function} Returns the new function.\n     */\n    var castRest = baseRest;\n\n    /**\n     * Casts `array` to a slice if it's needed.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {number} start The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the cast slice.\n     */\n    function castSlice(array, start, end) {\n      var length = array.length;\n      end = end === undefined$1 ? length : end;\n      return (!start && end >= length) ? array : baseSlice(array, start, end);\n    }\n\n    /**\n     * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).\n     *\n     * @private\n     * @param {number|Object} id The timer id or timeout object of the timer to clear.\n     */\n    var clearTimeout = ctxClearTimeout || function(id) {\n      return root.clearTimeout(id);\n    };\n\n    /**\n     * Creates a clone of  `buffer`.\n     *\n     * @private\n     * @param {Buffer} buffer The buffer to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Buffer} Returns the cloned buffer.\n     */\n    function cloneBuffer(buffer, isDeep) {\n      if (isDeep) {\n        return buffer.slice();\n      }\n      var length = buffer.length,\n          result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n      buffer.copy(result);\n      return result;\n    }\n\n    /**\n     * Creates a clone of `arrayBuffer`.\n     *\n     * @private\n     * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n     * @returns {ArrayBuffer} Returns the cloned array buffer.\n     */\n    function cloneArrayBuffer(arrayBuffer) {\n      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n      new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n      return result;\n    }\n\n    /**\n     * Creates a clone of `dataView`.\n     *\n     * @private\n     * @param {Object} dataView The data view to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned data view.\n     */\n    function cloneDataView(dataView, isDeep) {\n      var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n      return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n    }\n\n    /**\n     * Creates a clone of `regexp`.\n     *\n     * @private\n     * @param {Object} regexp The regexp to clone.\n     * @returns {Object} Returns the cloned regexp.\n     */\n    function cloneRegExp(regexp) {\n      var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n      result.lastIndex = regexp.lastIndex;\n      return result;\n    }\n\n    /**\n     * Creates a clone of the `symbol` object.\n     *\n     * @private\n     * @param {Object} symbol The symbol object to clone.\n     * @returns {Object} Returns the cloned symbol object.\n     */\n    function cloneSymbol(symbol) {\n      return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n    }\n\n    /**\n     * Creates a clone of `typedArray`.\n     *\n     * @private\n     * @param {Object} typedArray The typed array to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned typed array.\n     */\n    function cloneTypedArray(typedArray, isDeep) {\n      var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n      return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n    }\n\n    /**\n     * Compares values to sort them in ascending order.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {number} Returns the sort order indicator for `value`.\n     */\n    function compareAscending(value, other) {\n      if (value !== other) {\n        var valIsDefined = value !== undefined$1,\n            valIsNull = value === null,\n            valIsReflexive = value === value,\n            valIsSymbol = isSymbol(value);\n\n        var othIsDefined = other !== undefined$1,\n            othIsNull = other === null,\n            othIsReflexive = other === other,\n            othIsSymbol = isSymbol(other);\n\n        if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||\n            (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||\n            (valIsNull && othIsDefined && othIsReflexive) ||\n            (!valIsDefined && othIsReflexive) ||\n            !valIsReflexive) {\n          return 1;\n        }\n        if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||\n            (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||\n            (othIsNull && valIsDefined && valIsReflexive) ||\n            (!othIsDefined && valIsReflexive) ||\n            !othIsReflexive) {\n          return -1;\n        }\n      }\n      return 0;\n    }\n\n    /**\n     * Used by `_.orderBy` to compare multiple properties of a value to another\n     * and stable sort them.\n     *\n     * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,\n     * specify an order of \"desc\" for descending or \"asc\" for ascending sort order\n     * of corresponding values.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {boolean[]|string[]} orders The order to sort by for each property.\n     * @returns {number} Returns the sort order indicator for `object`.\n     */\n    function compareMultiple(object, other, orders) {\n      var index = -1,\n          objCriteria = object.criteria,\n          othCriteria = other.criteria,\n          length = objCriteria.length,\n          ordersLength = orders.length;\n\n      while (++index < length) {\n        var result = compareAscending(objCriteria[index], othCriteria[index]);\n        if (result) {\n          if (index >= ordersLength) {\n            return result;\n          }\n          var order = orders[index];\n          return result * (order == 'desc' ? -1 : 1);\n        }\n      }\n      // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications\n      // that causes it, under certain circumstances, to provide the same value for\n      // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247\n      // for more details.\n      //\n      // This also ensures a stable sort in V8 and other engines.\n      // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.\n      return object.index - other.index;\n    }\n\n    /**\n     * Creates an array that is the composition of partially applied arguments,\n     * placeholders, and provided arguments into a single array of arguments.\n     *\n     * @private\n     * @param {Array} args The provided arguments.\n     * @param {Array} partials The arguments to prepend to those provided.\n     * @param {Array} holders The `partials` placeholder indexes.\n     * @params {boolean} [isCurried] Specify composing for a curried function.\n     * @returns {Array} Returns the new array of composed arguments.\n     */\n    function composeArgs(args, partials, holders, isCurried) {\n      var argsIndex = -1,\n          argsLength = args.length,\n          holdersLength = holders.length,\n          leftIndex = -1,\n          leftLength = partials.length,\n          rangeLength = nativeMax(argsLength - holdersLength, 0),\n          result = Array(leftLength + rangeLength),\n          isUncurried = !isCurried;\n\n      while (++leftIndex < leftLength) {\n        result[leftIndex] = partials[leftIndex];\n      }\n      while (++argsIndex < holdersLength) {\n        if (isUncurried || argsIndex < argsLength) {\n          result[holders[argsIndex]] = args[argsIndex];\n        }\n      }\n      while (rangeLength--) {\n        result[leftIndex++] = args[argsIndex++];\n      }\n      return result;\n    }\n\n    /**\n     * This function is like `composeArgs` except that the arguments composition\n     * is tailored for `_.partialRight`.\n     *\n     * @private\n     * @param {Array} args The provided arguments.\n     * @param {Array} partials The arguments to append to those provided.\n     * @param {Array} holders The `partials` placeholder indexes.\n     * @params {boolean} [isCurried] Specify composing for a curried function.\n     * @returns {Array} Returns the new array of composed arguments.\n     */\n    function composeArgsRight(args, partials, holders, isCurried) {\n      var argsIndex = -1,\n          argsLength = args.length,\n          holdersIndex = -1,\n          holdersLength = holders.length,\n          rightIndex = -1,\n          rightLength = partials.length,\n          rangeLength = nativeMax(argsLength - holdersLength, 0),\n          result = Array(rangeLength + rightLength),\n          isUncurried = !isCurried;\n\n      while (++argsIndex < rangeLength) {\n        result[argsIndex] = args[argsIndex];\n      }\n      var offset = argsIndex;\n      while (++rightIndex < rightLength) {\n        result[offset + rightIndex] = partials[rightIndex];\n      }\n      while (++holdersIndex < holdersLength) {\n        if (isUncurried || argsIndex < argsLength) {\n          result[offset + holders[holdersIndex]] = args[argsIndex++];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Copies the values of `source` to `array`.\n     *\n     * @private\n     * @param {Array} source The array to copy values from.\n     * @param {Array} [array=[]] The array to copy values to.\n     * @returns {Array} Returns `array`.\n     */\n    function copyArray(source, array) {\n      var index = -1,\n          length = source.length;\n\n      array || (array = Array(length));\n      while (++index < length) {\n        array[index] = source[index];\n      }\n      return array;\n    }\n\n    /**\n     * Copies properties of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy properties from.\n     * @param {Array} props The property identifiers to copy.\n     * @param {Object} [object={}] The object to copy properties to.\n     * @param {Function} [customizer] The function to customize copied values.\n     * @returns {Object} Returns `object`.\n     */\n    function copyObject(source, props, object, customizer) {\n      var isNew = !object;\n      object || (object = {});\n\n      var index = -1,\n          length = props.length;\n\n      while (++index < length) {\n        var key = props[index];\n\n        var newValue = customizer\n          ? customizer(object[key], source[key], key, object, source)\n          : undefined$1;\n\n        if (newValue === undefined$1) {\n          newValue = source[key];\n        }\n        if (isNew) {\n          baseAssignValue(object, key, newValue);\n        } else {\n          assignValue(object, key, newValue);\n        }\n      }\n      return object;\n    }\n\n    /**\n     * Copies own symbols of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy symbols from.\n     * @param {Object} [object={}] The object to copy symbols to.\n     * @returns {Object} Returns `object`.\n     */\n    function copySymbols(source, object) {\n      return copyObject(source, getSymbols(source), object);\n    }\n\n    /**\n     * Copies own and inherited symbols of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy symbols from.\n     * @param {Object} [object={}] The object to copy symbols to.\n     * @returns {Object} Returns `object`.\n     */\n    function copySymbolsIn(source, object) {\n      return copyObject(source, getSymbolsIn(source), object);\n    }\n\n    /**\n     * Creates a function like `_.groupBy`.\n     *\n     * @private\n     * @param {Function} setter The function to set accumulator values.\n     * @param {Function} [initializer] The accumulator object initializer.\n     * @returns {Function} Returns the new aggregator function.\n     */\n    function createAggregator(setter, initializer) {\n      return function(collection, iteratee) {\n        var func = isArray(collection) ? arrayAggregator : baseAggregator,\n            accumulator = initializer ? initializer() : {};\n\n        return func(collection, setter, getIteratee(iteratee, 2), accumulator);\n      };\n    }\n\n    /**\n     * Creates a function like `_.assign`.\n     *\n     * @private\n     * @param {Function} assigner The function to assign values.\n     * @returns {Function} Returns the new assigner function.\n     */\n    function createAssigner(assigner) {\n      return baseRest(function(object, sources) {\n        var index = -1,\n            length = sources.length,\n            customizer = length > 1 ? sources[length - 1] : undefined$1,\n            guard = length > 2 ? sources[2] : undefined$1;\n\n        customizer = (assigner.length > 3 && typeof customizer == 'function')\n          ? (length--, customizer)\n          : undefined$1;\n\n        if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n          customizer = length < 3 ? undefined$1 : customizer;\n          length = 1;\n        }\n        object = Object(object);\n        while (++index < length) {\n          var source = sources[index];\n          if (source) {\n            assigner(object, source, index, customizer);\n          }\n        }\n        return object;\n      });\n    }\n\n    /**\n     * Creates a `baseEach` or `baseEachRight` function.\n     *\n     * @private\n     * @param {Function} eachFunc The function to iterate over a collection.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new base function.\n     */\n    function createBaseEach(eachFunc, fromRight) {\n      return function(collection, iteratee) {\n        if (collection == null) {\n          return collection;\n        }\n        if (!isArrayLike(collection)) {\n          return eachFunc(collection, iteratee);\n        }\n        var length = collection.length,\n            index = fromRight ? length : -1,\n            iterable = Object(collection);\n\n        while ((fromRight ? index-- : ++index < length)) {\n          if (iteratee(iterable[index], index, iterable) === false) {\n            break;\n          }\n        }\n        return collection;\n      };\n    }\n\n    /**\n     * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new base function.\n     */\n    function createBaseFor(fromRight) {\n      return function(object, iteratee, keysFunc) {\n        var index = -1,\n            iterable = Object(object),\n            props = keysFunc(object),\n            length = props.length;\n\n        while (length--) {\n          var key = props[fromRight ? length : ++index];\n          if (iteratee(iterable[key], key, iterable) === false) {\n            break;\n          }\n        }\n        return object;\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with the optional `this`\n     * binding of `thisArg`.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createBind(func, bitmask, thisArg) {\n      var isBind = bitmask & WRAP_BIND_FLAG,\n          Ctor = createCtor(func);\n\n      function wrapper() {\n        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n        return fn.apply(isBind ? thisArg : this, arguments);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a function like `_.lowerFirst`.\n     *\n     * @private\n     * @param {string} methodName The name of the `String` case method to use.\n     * @returns {Function} Returns the new case function.\n     */\n    function createCaseFirst(methodName) {\n      return function(string) {\n        string = toString(string);\n\n        var strSymbols = hasUnicode(string)\n          ? stringToArray(string)\n          : undefined$1;\n\n        var chr = strSymbols\n          ? strSymbols[0]\n          : string.charAt(0);\n\n        var trailing = strSymbols\n          ? castSlice(strSymbols, 1).join('')\n          : string.slice(1);\n\n        return chr[methodName]() + trailing;\n      };\n    }\n\n    /**\n     * Creates a function like `_.camelCase`.\n     *\n     * @private\n     * @param {Function} callback The function to combine each word.\n     * @returns {Function} Returns the new compounder function.\n     */\n    function createCompounder(callback) {\n      return function(string) {\n        return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');\n      };\n    }\n\n    /**\n     * Creates a function that produces an instance of `Ctor` regardless of\n     * whether it was invoked as part of a `new` expression or by `call` or `apply`.\n     *\n     * @private\n     * @param {Function} Ctor The constructor to wrap.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createCtor(Ctor) {\n      return function() {\n        // Use a `switch` statement to work with class constructors. See\n        // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist\n        // for more details.\n        var args = arguments;\n        switch (args.length) {\n          case 0: return new Ctor;\n          case 1: return new Ctor(args[0]);\n          case 2: return new Ctor(args[0], args[1]);\n          case 3: return new Ctor(args[0], args[1], args[2]);\n          case 4: return new Ctor(args[0], args[1], args[2], args[3]);\n          case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);\n          case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);\n          case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);\n        }\n        var thisBinding = baseCreate(Ctor.prototype),\n            result = Ctor.apply(thisBinding, args);\n\n        // Mimic the constructor's `return` behavior.\n        // See https://es5.github.io/#x13.2.2 for more details.\n        return isObject(result) ? result : thisBinding;\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to enable currying.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {number} arity The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createCurry(func, bitmask, arity) {\n      var Ctor = createCtor(func);\n\n      function wrapper() {\n        var length = arguments.length,\n            args = Array(length),\n            index = length,\n            placeholder = getHolder(wrapper);\n\n        while (index--) {\n          args[index] = arguments[index];\n        }\n        var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)\n          ? []\n          : replaceHolders(args, placeholder);\n\n        length -= holders.length;\n        if (length < arity) {\n          return createRecurry(\n            func, bitmask, createHybrid, wrapper.placeholder, undefined$1,\n            args, holders, undefined$1, undefined$1, arity - length);\n        }\n        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n        return apply(fn, this, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a `_.find` or `_.findLast` function.\n     *\n     * @private\n     * @param {Function} findIndexFunc The function to find the collection index.\n     * @returns {Function} Returns the new find function.\n     */\n    function createFind(findIndexFunc) {\n      return function(collection, predicate, fromIndex) {\n        var iterable = Object(collection);\n        if (!isArrayLike(collection)) {\n          var iteratee = getIteratee(predicate, 3);\n          collection = keys(collection);\n          predicate = function(key) { return iteratee(iterable[key], key, iterable); };\n        }\n        var index = findIndexFunc(collection, predicate, fromIndex);\n        return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined$1;\n      };\n    }\n\n    /**\n     * Creates a `_.flow` or `_.flowRight` function.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new flow function.\n     */\n    function createFlow(fromRight) {\n      return flatRest(function(funcs) {\n        var length = funcs.length,\n            index = length,\n            prereq = LodashWrapper.prototype.thru;\n\n        if (fromRight) {\n          funcs.reverse();\n        }\n        while (index--) {\n          var func = funcs[index];\n          if (typeof func != 'function') {\n            throw new TypeError(FUNC_ERROR_TEXT);\n          }\n          if (prereq && !wrapper && getFuncName(func) == 'wrapper') {\n            var wrapper = new LodashWrapper([], true);\n          }\n        }\n        index = wrapper ? index : length;\n        while (++index < length) {\n          func = funcs[index];\n\n          var funcName = getFuncName(func),\n              data = funcName == 'wrapper' ? getData(func) : undefined$1;\n\n          if (data && isLaziable(data[0]) &&\n                data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&\n                !data[4].length && data[9] == 1\n              ) {\n            wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);\n          } else {\n            wrapper = (func.length == 1 && isLaziable(func))\n              ? wrapper[funcName]()\n              : wrapper.thru(func);\n          }\n        }\n        return function() {\n          var args = arguments,\n              value = args[0];\n\n          if (wrapper && args.length == 1 && isArray(value)) {\n            return wrapper.plant(value).value();\n          }\n          var index = 0,\n              result = length ? funcs[index].apply(this, args) : value;\n\n          while (++index < length) {\n            result = funcs[index].call(this, result);\n          }\n          return result;\n        };\n      });\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with optional `this`\n     * binding of `thisArg`, partial application, and currying.\n     *\n     * @private\n     * @param {Function|string} func The function or method name to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to prepend to those provided to\n     *  the new function.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [partialsRight] The arguments to append to those provided\n     *  to the new function.\n     * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {\n      var isAry = bitmask & WRAP_ARY_FLAG,\n          isBind = bitmask & WRAP_BIND_FLAG,\n          isBindKey = bitmask & WRAP_BIND_KEY_FLAG,\n          isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),\n          isFlip = bitmask & WRAP_FLIP_FLAG,\n          Ctor = isBindKey ? undefined$1 : createCtor(func);\n\n      function wrapper() {\n        var length = arguments.length,\n            args = Array(length),\n            index = length;\n\n        while (index--) {\n          args[index] = arguments[index];\n        }\n        if (isCurried) {\n          var placeholder = getHolder(wrapper),\n              holdersCount = countHolders(args, placeholder);\n        }\n        if (partials) {\n          args = composeArgs(args, partials, holders, isCurried);\n        }\n        if (partialsRight) {\n          args = composeArgsRight(args, partialsRight, holdersRight, isCurried);\n        }\n        length -= holdersCount;\n        if (isCurried && length < arity) {\n          var newHolders = replaceHolders(args, placeholder);\n          return createRecurry(\n            func, bitmask, createHybrid, wrapper.placeholder, thisArg,\n            args, newHolders, argPos, ary, arity - length\n          );\n        }\n        var thisBinding = isBind ? thisArg : this,\n            fn = isBindKey ? thisBinding[func] : func;\n\n        length = args.length;\n        if (argPos) {\n          args = reorder(args, argPos);\n        } else if (isFlip && length > 1) {\n          args.reverse();\n        }\n        if (isAry && ary < length) {\n          args.length = ary;\n        }\n        if (this && this !== root && this instanceof wrapper) {\n          fn = Ctor || createCtor(fn);\n        }\n        return fn.apply(thisBinding, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a function like `_.invertBy`.\n     *\n     * @private\n     * @param {Function} setter The function to set accumulator values.\n     * @param {Function} toIteratee The function to resolve iteratees.\n     * @returns {Function} Returns the new inverter function.\n     */\n    function createInverter(setter, toIteratee) {\n      return function(object, iteratee) {\n        return baseInverter(object, setter, toIteratee(iteratee), {});\n      };\n    }\n\n    /**\n     * Creates a function that performs a mathematical operation on two values.\n     *\n     * @private\n     * @param {Function} operator The function to perform the operation.\n     * @param {number} [defaultValue] The value used for `undefined` arguments.\n     * @returns {Function} Returns the new mathematical operation function.\n     */\n    function createMathOperation(operator, defaultValue) {\n      return function(value, other) {\n        var result;\n        if (value === undefined$1 && other === undefined$1) {\n          return defaultValue;\n        }\n        if (value !== undefined$1) {\n          result = value;\n        }\n        if (other !== undefined$1) {\n          if (result === undefined$1) {\n            return other;\n          }\n          if (typeof value == 'string' || typeof other == 'string') {\n            value = baseToString(value);\n            other = baseToString(other);\n          } else {\n            value = baseToNumber(value);\n            other = baseToNumber(other);\n          }\n          result = operator(value, other);\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function like `_.over`.\n     *\n     * @private\n     * @param {Function} arrayFunc The function to iterate over iteratees.\n     * @returns {Function} Returns the new over function.\n     */\n    function createOver(arrayFunc) {\n      return flatRest(function(iteratees) {\n        iteratees = arrayMap(iteratees, baseUnary(getIteratee()));\n        return baseRest(function(args) {\n          var thisArg = this;\n          return arrayFunc(iteratees, function(iteratee) {\n            return apply(iteratee, thisArg, args);\n          });\n        });\n      });\n    }\n\n    /**\n     * Creates the padding for `string` based on `length`. The `chars` string\n     * is truncated if the number of characters exceeds `length`.\n     *\n     * @private\n     * @param {number} length The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padding for `string`.\n     */\n    function createPadding(length, chars) {\n      chars = chars === undefined$1 ? ' ' : baseToString(chars);\n\n      var charsLength = chars.length;\n      if (charsLength < 2) {\n        return charsLength ? baseRepeat(chars, length) : chars;\n      }\n      var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));\n      return hasUnicode(chars)\n        ? castSlice(stringToArray(result), 0, length).join('')\n        : result.slice(0, length);\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with the `this` binding\n     * of `thisArg` and `partials` prepended to the arguments it receives.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {Array} partials The arguments to prepend to those provided to\n     *  the new function.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createPartial(func, bitmask, thisArg, partials) {\n      var isBind = bitmask & WRAP_BIND_FLAG,\n          Ctor = createCtor(func);\n\n      function wrapper() {\n        var argsIndex = -1,\n            argsLength = arguments.length,\n            leftIndex = -1,\n            leftLength = partials.length,\n            args = Array(leftLength + argsLength),\n            fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n\n        while (++leftIndex < leftLength) {\n          args[leftIndex] = partials[leftIndex];\n        }\n        while (argsLength--) {\n          args[leftIndex++] = arguments[++argsIndex];\n        }\n        return apply(fn, isBind ? thisArg : this, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a `_.range` or `_.rangeRight` function.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new range function.\n     */\n    function createRange(fromRight) {\n      return function(start, end, step) {\n        if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {\n          end = step = undefined$1;\n        }\n        // Ensure the sign of `-0` is preserved.\n        start = toFinite(start);\n        if (end === undefined$1) {\n          end = start;\n          start = 0;\n        } else {\n          end = toFinite(end);\n        }\n        step = step === undefined$1 ? (start < end ? 1 : -1) : toFinite(step);\n        return baseRange(start, end, step, fromRight);\n      };\n    }\n\n    /**\n     * Creates a function that performs a relational operation on two values.\n     *\n     * @private\n     * @param {Function} operator The function to perform the operation.\n     * @returns {Function} Returns the new relational operation function.\n     */\n    function createRelationalOperation(operator) {\n      return function(value, other) {\n        if (!(typeof value == 'string' && typeof other == 'string')) {\n          value = toNumber(value);\n          other = toNumber(other);\n        }\n        return operator(value, other);\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to continue currying.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {Function} wrapFunc The function to create the `func` wrapper.\n     * @param {*} placeholder The placeholder value.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to prepend to those provided to\n     *  the new function.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {\n      var isCurry = bitmask & WRAP_CURRY_FLAG,\n          newHolders = isCurry ? holders : undefined$1,\n          newHoldersRight = isCurry ? undefined$1 : holders,\n          newPartials = isCurry ? partials : undefined$1,\n          newPartialsRight = isCurry ? undefined$1 : partials;\n\n      bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);\n      bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);\n\n      if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {\n        bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);\n      }\n      var newData = [\n        func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,\n        newHoldersRight, argPos, ary, arity\n      ];\n\n      var result = wrapFunc.apply(undefined$1, newData);\n      if (isLaziable(func)) {\n        setData(result, newData);\n      }\n      result.placeholder = placeholder;\n      return setWrapToString(result, func, bitmask);\n    }\n\n    /**\n     * Creates a function like `_.round`.\n     *\n     * @private\n     * @param {string} methodName The name of the `Math` method to use when rounding.\n     * @returns {Function} Returns the new round function.\n     */\n    function createRound(methodName) {\n      var func = Math[methodName];\n      return function(number, precision) {\n        number = toNumber(number);\n        precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);\n        if (precision && nativeIsFinite(number)) {\n          // Shift with exponential notation to avoid floating-point issues.\n          // See [MDN](https://mdn.io/round#Examples) for more details.\n          var pair = (toString(number) + 'e').split('e'),\n              value = func(pair[0] + 'e' + (+pair[1] + precision));\n\n          pair = (toString(value) + 'e').split('e');\n          return +(pair[0] + 'e' + (+pair[1] - precision));\n        }\n        return func(number);\n      };\n    }\n\n    /**\n     * Creates a set object of `values`.\n     *\n     * @private\n     * @param {Array} values The values to add to the set.\n     * @returns {Object} Returns the new set.\n     */\n    var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {\n      return new Set(values);\n    };\n\n    /**\n     * Creates a `_.toPairs` or `_.toPairsIn` function.\n     *\n     * @private\n     * @param {Function} keysFunc The function to get the keys of a given object.\n     * @returns {Function} Returns the new pairs function.\n     */\n    function createToPairs(keysFunc) {\n      return function(object) {\n        var tag = getTag(object);\n        if (tag == mapTag) {\n          return mapToArray(object);\n        }\n        if (tag == setTag) {\n          return setToPairs(object);\n        }\n        return baseToPairs(object, keysFunc(object));\n      };\n    }\n\n    /**\n     * Creates a function that either curries or invokes `func` with optional\n     * `this` binding and partially applied arguments.\n     *\n     * @private\n     * @param {Function|string} func The function or method name to wrap.\n     * @param {number} bitmask The bitmask flags.\n     *    1 - `_.bind`\n     *    2 - `_.bindKey`\n     *    4 - `_.curry` or `_.curryRight` of a bound function\n     *    8 - `_.curry`\n     *   16 - `_.curryRight`\n     *   32 - `_.partial`\n     *   64 - `_.partialRight`\n     *  128 - `_.rearg`\n     *  256 - `_.ary`\n     *  512 - `_.flip`\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to be partially applied.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {\n      var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;\n      if (!isBindKey && typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var length = partials ? partials.length : 0;\n      if (!length) {\n        bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);\n        partials = holders = undefined$1;\n      }\n      ary = ary === undefined$1 ? ary : nativeMax(toInteger(ary), 0);\n      arity = arity === undefined$1 ? arity : toInteger(arity);\n      length -= holders ? holders.length : 0;\n\n      if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {\n        var partialsRight = partials,\n            holdersRight = holders;\n\n        partials = holders = undefined$1;\n      }\n      var data = isBindKey ? undefined$1 : getData(func);\n\n      var newData = [\n        func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,\n        argPos, ary, arity\n      ];\n\n      if (data) {\n        mergeData(newData, data);\n      }\n      func = newData[0];\n      bitmask = newData[1];\n      thisArg = newData[2];\n      partials = newData[3];\n      holders = newData[4];\n      arity = newData[9] = newData[9] === undefined$1\n        ? (isBindKey ? 0 : func.length)\n        : nativeMax(newData[9] - length, 0);\n\n      if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {\n        bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);\n      }\n      if (!bitmask || bitmask == WRAP_BIND_FLAG) {\n        var result = createBind(func, bitmask, thisArg);\n      } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {\n        result = createCurry(func, bitmask, arity);\n      } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {\n        result = createPartial(func, bitmask, thisArg, partials);\n      } else {\n        result = createHybrid.apply(undefined$1, newData);\n      }\n      var setter = data ? baseSetData : setData;\n      return setWrapToString(setter(result, newData), func, bitmask);\n    }\n\n    /**\n     * Used by `_.defaults` to customize its `_.assignIn` use to assign properties\n     * of source objects to the destination object for all destination properties\n     * that resolve to `undefined`.\n     *\n     * @private\n     * @param {*} objValue The destination value.\n     * @param {*} srcValue The source value.\n     * @param {string} key The key of the property to assign.\n     * @param {Object} object The parent object of `objValue`.\n     * @returns {*} Returns the value to assign.\n     */\n    function customDefaultsAssignIn(objValue, srcValue, key, object) {\n      if (objValue === undefined$1 ||\n          (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n        return srcValue;\n      }\n      return objValue;\n    }\n\n    /**\n     * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source\n     * objects into destination objects that are passed thru.\n     *\n     * @private\n     * @param {*} objValue The destination value.\n     * @param {*} srcValue The source value.\n     * @param {string} key The key of the property to merge.\n     * @param {Object} object The parent object of `objValue`.\n     * @param {Object} source The parent object of `srcValue`.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     * @returns {*} Returns the value to assign.\n     */\n    function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {\n      if (isObject(objValue) && isObject(srcValue)) {\n        // Recursively merge objects and arrays (susceptible to call stack limits).\n        stack.set(srcValue, objValue);\n        baseMerge(objValue, srcValue, undefined$1, customDefaultsMerge, stack);\n        stack['delete'](srcValue);\n      }\n      return objValue;\n    }\n\n    /**\n     * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain\n     * objects.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @param {string} key The key of the property to inspect.\n     * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.\n     */\n    function customOmitClone(value) {\n      return isPlainObject(value) ? undefined$1 : value;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for arrays with support for\n     * partial deep comparisons.\n     *\n     * @private\n     * @param {Array} array The array to compare.\n     * @param {Array} other The other array to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `array` and `other` objects.\n     * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n     */\n    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n          arrLength = array.length,\n          othLength = other.length;\n\n      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(array);\n      if (stacked && stack.get(other)) {\n        return stacked == other;\n      }\n      var index = -1,\n          result = true,\n          seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined$1;\n\n      stack.set(array, other);\n      stack.set(other, array);\n\n      // Ignore non-index properties.\n      while (++index < arrLength) {\n        var arrValue = array[index],\n            othValue = other[index];\n\n        if (customizer) {\n          var compared = isPartial\n            ? customizer(othValue, arrValue, index, other, array, stack)\n            : customizer(arrValue, othValue, index, array, other, stack);\n        }\n        if (compared !== undefined$1) {\n          if (compared) {\n            continue;\n          }\n          result = false;\n          break;\n        }\n        // Recursively compare arrays (susceptible to call stack limits).\n        if (seen) {\n          if (!arraySome(other, function(othValue, othIndex) {\n                if (!cacheHas(seen, othIndex) &&\n                    (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n                  return seen.push(othIndex);\n                }\n              })) {\n            result = false;\n            break;\n          }\n        } else if (!(\n              arrValue === othValue ||\n                equalFunc(arrValue, othValue, bitmask, customizer, stack)\n            )) {\n          result = false;\n          break;\n        }\n      }\n      stack['delete'](array);\n      stack['delete'](other);\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for comparing objects of\n     * the same `toStringTag`.\n     *\n     * **Note:** This function only supports comparing values with tags of\n     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {string} tag The `toStringTag` of the objects to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n      switch (tag) {\n        case dataViewTag:\n          if ((object.byteLength != other.byteLength) ||\n              (object.byteOffset != other.byteOffset)) {\n            return false;\n          }\n          object = object.buffer;\n          other = other.buffer;\n\n        case arrayBufferTag:\n          if ((object.byteLength != other.byteLength) ||\n              !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n            return false;\n          }\n          return true;\n\n        case boolTag:\n        case dateTag:\n        case numberTag:\n          // Coerce booleans to `1` or `0` and dates to milliseconds.\n          // Invalid dates are coerced to `NaN`.\n          return eq(+object, +other);\n\n        case errorTag:\n          return object.name == other.name && object.message == other.message;\n\n        case regexpTag:\n        case stringTag:\n          // Coerce regexes to strings and treat strings, primitives and objects,\n          // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n          // for more details.\n          return object == (other + '');\n\n        case mapTag:\n          var convert = mapToArray;\n\n        case setTag:\n          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n          convert || (convert = setToArray);\n\n          if (object.size != other.size && !isPartial) {\n            return false;\n          }\n          // Assume cyclic values are equal.\n          var stacked = stack.get(object);\n          if (stacked) {\n            return stacked == other;\n          }\n          bitmask |= COMPARE_UNORDERED_FLAG;\n\n          // Recursively compare objects (susceptible to call stack limits).\n          stack.set(object, other);\n          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n          stack['delete'](object);\n          return result;\n\n        case symbolTag:\n          if (symbolValueOf) {\n            return symbolValueOf.call(object) == symbolValueOf.call(other);\n          }\n      }\n      return false;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for objects with support for\n     * partial deep comparisons.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n          objProps = getAllKeys(object),\n          objLength = objProps.length,\n          othProps = getAllKeys(other),\n          othLength = othProps.length;\n\n      if (objLength != othLength && !isPartial) {\n        return false;\n      }\n      var index = objLength;\n      while (index--) {\n        var key = objProps[index];\n        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n          return false;\n        }\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(object);\n      if (stacked && stack.get(other)) {\n        return stacked == other;\n      }\n      var result = true;\n      stack.set(object, other);\n      stack.set(other, object);\n\n      var skipCtor = isPartial;\n      while (++index < objLength) {\n        key = objProps[index];\n        var objValue = object[key],\n            othValue = other[key];\n\n        if (customizer) {\n          var compared = isPartial\n            ? customizer(othValue, objValue, key, other, object, stack)\n            : customizer(objValue, othValue, key, object, other, stack);\n        }\n        // Recursively compare objects (susceptible to call stack limits).\n        if (!(compared === undefined$1\n              ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n              : compared\n            )) {\n          result = false;\n          break;\n        }\n        skipCtor || (skipCtor = key == 'constructor');\n      }\n      if (result && !skipCtor) {\n        var objCtor = object.constructor,\n            othCtor = other.constructor;\n\n        // Non `Object` object instances with different constructors are not equal.\n        if (objCtor != othCtor &&\n            ('constructor' in object && 'constructor' in other) &&\n            !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n              typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n          result = false;\n        }\n      }\n      stack['delete'](object);\n      stack['delete'](other);\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseRest` which flattens the rest array.\n     *\n     * @private\n     * @param {Function} func The function to apply a rest parameter to.\n     * @returns {Function} Returns the new function.\n     */\n    function flatRest(func) {\n      return setToString(overRest(func, undefined$1, flatten), func + '');\n    }\n\n    /**\n     * Creates an array of own enumerable property names and symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function getAllKeys(object) {\n      return baseGetAllKeys(object, keys, getSymbols);\n    }\n\n    /**\n     * Creates an array of own and inherited enumerable property names and\n     * symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function getAllKeysIn(object) {\n      return baseGetAllKeys(object, keysIn, getSymbolsIn);\n    }\n\n    /**\n     * Gets metadata for `func`.\n     *\n     * @private\n     * @param {Function} func The function to query.\n     * @returns {*} Returns the metadata for `func`.\n     */\n    var getData = !metaMap ? noop : function(func) {\n      return metaMap.get(func);\n    };\n\n    /**\n     * Gets the name of `func`.\n     *\n     * @private\n     * @param {Function} func The function to query.\n     * @returns {string} Returns the function name.\n     */\n    function getFuncName(func) {\n      var result = (func.name + ''),\n          array = realNames[result],\n          length = hasOwnProperty.call(realNames, result) ? array.length : 0;\n\n      while (length--) {\n        var data = array[length],\n            otherFunc = data.func;\n        if (otherFunc == null || otherFunc == func) {\n          return data.name;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Gets the argument placeholder value for `func`.\n     *\n     * @private\n     * @param {Function} func The function to inspect.\n     * @returns {*} Returns the placeholder value.\n     */\n    function getHolder(func) {\n      var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;\n      return object.placeholder;\n    }\n\n    /**\n     * Gets the appropriate \"iteratee\" function. If `_.iteratee` is customized,\n     * this function returns the custom method, otherwise it returns `baseIteratee`.\n     * If arguments are provided, the chosen function is invoked with them and\n     * its result is returned.\n     *\n     * @private\n     * @param {*} [value] The value to convert to an iteratee.\n     * @param {number} [arity] The arity of the created iteratee.\n     * @returns {Function} Returns the chosen function or its result.\n     */\n    function getIteratee() {\n      var result = lodash.iteratee || iteratee;\n      result = result === iteratee ? baseIteratee : result;\n      return arguments.length ? result(arguments[0], arguments[1]) : result;\n    }\n\n    /**\n     * Gets the data for `map`.\n     *\n     * @private\n     * @param {Object} map The map to query.\n     * @param {string} key The reference key.\n     * @returns {*} Returns the map data.\n     */\n    function getMapData(map, key) {\n      var data = map.__data__;\n      return isKeyable(key)\n        ? data[typeof key == 'string' ? 'string' : 'hash']\n        : data.map;\n    }\n\n    /**\n     * Gets the property names, values, and compare flags of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the match data of `object`.\n     */\n    function getMatchData(object) {\n      var result = keys(object),\n          length = result.length;\n\n      while (length--) {\n        var key = result[length],\n            value = object[key];\n\n        result[length] = [key, value, isStrictComparable(value)];\n      }\n      return result;\n    }\n\n    /**\n     * Gets the native function at `key` of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {string} key The key of the method to get.\n     * @returns {*} Returns the function if it's native, else `undefined`.\n     */\n    function getNative(object, key) {\n      var value = getValue(object, key);\n      return baseIsNative(value) ? value : undefined$1;\n    }\n\n    /**\n     * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the raw `toStringTag`.\n     */\n    function getRawTag(value) {\n      var isOwn = hasOwnProperty.call(value, symToStringTag),\n          tag = value[symToStringTag];\n\n      try {\n        value[symToStringTag] = undefined$1;\n        var unmasked = true;\n      } catch (e) {}\n\n      var result = nativeObjectToString.call(value);\n      if (unmasked) {\n        if (isOwn) {\n          value[symToStringTag] = tag;\n        } else {\n          delete value[symToStringTag];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array of the own enumerable symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of symbols.\n     */\n    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n      if (object == null) {\n        return [];\n      }\n      object = Object(object);\n      return arrayFilter(nativeGetSymbols(object), function(symbol) {\n        return propertyIsEnumerable.call(object, symbol);\n      });\n    };\n\n    /**\n     * Creates an array of the own and inherited enumerable symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of symbols.\n     */\n    var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n      var result = [];\n      while (object) {\n        arrayPush(result, getSymbols(object));\n        object = getPrototype(object);\n      }\n      return result;\n    };\n\n    /**\n     * Gets the `toStringTag` of `value`.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the `toStringTag`.\n     */\n    var getTag = baseGetTag;\n\n    // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\n    if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n        (Map && getTag(new Map) != mapTag) ||\n        (Promise && getTag(Promise.resolve()) != promiseTag) ||\n        (Set && getTag(new Set) != setTag) ||\n        (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n      getTag = function(value) {\n        var result = baseGetTag(value),\n            Ctor = result == objectTag ? value.constructor : undefined$1,\n            ctorString = Ctor ? toSource(Ctor) : '';\n\n        if (ctorString) {\n          switch (ctorString) {\n            case dataViewCtorString: return dataViewTag;\n            case mapCtorString: return mapTag;\n            case promiseCtorString: return promiseTag;\n            case setCtorString: return setTag;\n            case weakMapCtorString: return weakMapTag;\n          }\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Gets the view, applying any `transforms` to the `start` and `end` positions.\n     *\n     * @private\n     * @param {number} start The start of the view.\n     * @param {number} end The end of the view.\n     * @param {Array} transforms The transformations to apply to the view.\n     * @returns {Object} Returns an object containing the `start` and `end`\n     *  positions of the view.\n     */\n    function getView(start, end, transforms) {\n      var index = -1,\n          length = transforms.length;\n\n      while (++index < length) {\n        var data = transforms[index],\n            size = data.size;\n\n        switch (data.type) {\n          case 'drop':      start += size; break;\n          case 'dropRight': end -= size; break;\n          case 'take':      end = nativeMin(end, start + size); break;\n          case 'takeRight': start = nativeMax(start, end - size); break;\n        }\n      }\n      return { 'start': start, 'end': end };\n    }\n\n    /**\n     * Extracts wrapper details from the `source` body comment.\n     *\n     * @private\n     * @param {string} source The source to inspect.\n     * @returns {Array} Returns the wrapper details.\n     */\n    function getWrapDetails(source) {\n      var match = source.match(reWrapDetails);\n      return match ? match[1].split(reSplitDetails) : [];\n    }\n\n    /**\n     * Checks if `path` exists on `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @param {Function} hasFunc The function to check properties.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     */\n    function hasPath(object, path, hasFunc) {\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length,\n          result = false;\n\n      while (++index < length) {\n        var key = toKey(path[index]);\n        if (!(result = object != null && hasFunc(object, key))) {\n          break;\n        }\n        object = object[key];\n      }\n      if (result || ++index != length) {\n        return result;\n      }\n      length = object == null ? 0 : object.length;\n      return !!length && isLength(length) && isIndex(key, length) &&\n        (isArray(object) || isArguments(object));\n    }\n\n    /**\n     * Initializes an array clone.\n     *\n     * @private\n     * @param {Array} array The array to clone.\n     * @returns {Array} Returns the initialized clone.\n     */\n    function initCloneArray(array) {\n      var length = array.length,\n          result = new array.constructor(length);\n\n      // Add properties assigned by `RegExp#exec`.\n      if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n        result.index = array.index;\n        result.input = array.input;\n      }\n      return result;\n    }\n\n    /**\n     * Initializes an object clone.\n     *\n     * @private\n     * @param {Object} object The object to clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneObject(object) {\n      return (typeof object.constructor == 'function' && !isPrototype(object))\n        ? baseCreate(getPrototype(object))\n        : {};\n    }\n\n    /**\n     * Initializes an object clone based on its `toStringTag`.\n     *\n     * **Note:** This function only supports cloning values with tags of\n     * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.\n     *\n     * @private\n     * @param {Object} object The object to clone.\n     * @param {string} tag The `toStringTag` of the object to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneByTag(object, tag, isDeep) {\n      var Ctor = object.constructor;\n      switch (tag) {\n        case arrayBufferTag:\n          return cloneArrayBuffer(object);\n\n        case boolTag:\n        case dateTag:\n          return new Ctor(+object);\n\n        case dataViewTag:\n          return cloneDataView(object, isDeep);\n\n        case float32Tag: case float64Tag:\n        case int8Tag: case int16Tag: case int32Tag:\n        case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n          return cloneTypedArray(object, isDeep);\n\n        case mapTag:\n          return new Ctor;\n\n        case numberTag:\n        case stringTag:\n          return new Ctor(object);\n\n        case regexpTag:\n          return cloneRegExp(object);\n\n        case setTag:\n          return new Ctor;\n\n        case symbolTag:\n          return cloneSymbol(object);\n      }\n    }\n\n    /**\n     * Inserts wrapper `details` in a comment at the top of the `source` body.\n     *\n     * @private\n     * @param {string} source The source to modify.\n     * @returns {Array} details The details to insert.\n     * @returns {string} Returns the modified source.\n     */\n    function insertWrapDetails(source, details) {\n      var length = details.length;\n      if (!length) {\n        return source;\n      }\n      var lastIndex = length - 1;\n      details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];\n      details = details.join(length > 2 ? ', ' : ' ');\n      return source.replace(reWrapComment, '{\\n/* [wrapped with ' + details + '] */\\n');\n    }\n\n    /**\n     * Checks if `value` is a flattenable `arguments` object or array.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n     */\n    function isFlattenable(value) {\n      return isArray(value) || isArguments(value) ||\n        !!(spreadableSymbol && value && value[spreadableSymbol]);\n    }\n\n    /**\n     * Checks if `value` is a valid array-like index.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n     * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n     */\n    function isIndex(value, length) {\n      var type = typeof value;\n      length = length == null ? MAX_SAFE_INTEGER : length;\n\n      return !!length &&\n        (type == 'number' ||\n          (type != 'symbol' && reIsUint.test(value))) &&\n            (value > -1 && value % 1 == 0 && value < length);\n    }\n\n    /**\n     * Checks if the given arguments are from an iteratee call.\n     *\n     * @private\n     * @param {*} value The potential iteratee value argument.\n     * @param {*} index The potential iteratee index or key argument.\n     * @param {*} object The potential iteratee object argument.\n     * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n     *  else `false`.\n     */\n    function isIterateeCall(value, index, object) {\n      if (!isObject(object)) {\n        return false;\n      }\n      var type = typeof index;\n      if (type == 'number'\n            ? (isArrayLike(object) && isIndex(index, object.length))\n            : (type == 'string' && index in object)\n          ) {\n        return eq(object[index], value);\n      }\n      return false;\n    }\n\n    /**\n     * Checks if `value` is a property name and not a property path.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @param {Object} [object] The object to query keys on.\n     * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n     */\n    function isKey(value, object) {\n      if (isArray(value)) {\n        return false;\n      }\n      var type = typeof value;\n      if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n          value == null || isSymbol(value)) {\n        return true;\n      }\n      return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n        (object != null && value in Object(object));\n    }\n\n    /**\n     * Checks if `value` is suitable for use as unique object key.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n     */\n    function isKeyable(value) {\n      var type = typeof value;\n      return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n        ? (value !== '__proto__')\n        : (value === null);\n    }\n\n    /**\n     * Checks if `func` has a lazy counterpart.\n     *\n     * @private\n     * @param {Function} func The function to check.\n     * @returns {boolean} Returns `true` if `func` has a lazy counterpart,\n     *  else `false`.\n     */\n    function isLaziable(func) {\n      var funcName = getFuncName(func),\n          other = lodash[funcName];\n\n      if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {\n        return false;\n      }\n      if (func === other) {\n        return true;\n      }\n      var data = getData(other);\n      return !!data && func === data[0];\n    }\n\n    /**\n     * Checks if `func` has its source masked.\n     *\n     * @private\n     * @param {Function} func The function to check.\n     * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n     */\n    function isMasked(func) {\n      return !!maskSrcKey && (maskSrcKey in func);\n    }\n\n    /**\n     * Checks if `func` is capable of being masked.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `func` is maskable, else `false`.\n     */\n    var isMaskable = coreJsData ? isFunction : stubFalse;\n\n    /**\n     * Checks if `value` is likely a prototype object.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n     */\n    function isPrototype(value) {\n      var Ctor = value && value.constructor,\n          proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n      return value === proto;\n    }\n\n    /**\n     * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` if suitable for strict\n     *  equality comparisons, else `false`.\n     */\n    function isStrictComparable(value) {\n      return value === value && !isObject(value);\n    }\n\n    /**\n     * A specialized version of `matchesProperty` for source values suitable\n     * for strict equality comparisons, i.e. `===`.\n     *\n     * @private\n     * @param {string} key The key of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function matchesStrictComparable(key, srcValue) {\n      return function(object) {\n        if (object == null) {\n          return false;\n        }\n        return object[key] === srcValue &&\n          (srcValue !== undefined$1 || (key in Object(object)));\n      };\n    }\n\n    /**\n     * A specialized version of `_.memoize` which clears the memoized function's\n     * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n     *\n     * @private\n     * @param {Function} func The function to have its output memoized.\n     * @returns {Function} Returns the new memoized function.\n     */\n    function memoizeCapped(func) {\n      var result = memoize(func, function(key) {\n        if (cache.size === MAX_MEMOIZE_SIZE) {\n          cache.clear();\n        }\n        return key;\n      });\n\n      var cache = result.cache;\n      return result;\n    }\n\n    /**\n     * Merges the function metadata of `source` into `data`.\n     *\n     * Merging metadata reduces the number of wrappers used to invoke a function.\n     * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`\n     * may be applied regardless of execution order. Methods like `_.ary` and\n     * `_.rearg` modify function arguments, making the order in which they are\n     * executed important, preventing the merging of metadata. However, we make\n     * an exception for a safe combined case where curried functions have `_.ary`\n     * and or `_.rearg` applied.\n     *\n     * @private\n     * @param {Array} data The destination metadata.\n     * @param {Array} source The source metadata.\n     * @returns {Array} Returns `data`.\n     */\n    function mergeData(data, source) {\n      var bitmask = data[1],\n          srcBitmask = source[1],\n          newBitmask = bitmask | srcBitmask,\n          isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);\n\n      var isCombo =\n        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||\n        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||\n        ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));\n\n      // Exit early if metadata can't be merged.\n      if (!(isCommon || isCombo)) {\n        return data;\n      }\n      // Use source `thisArg` if available.\n      if (srcBitmask & WRAP_BIND_FLAG) {\n        data[2] = source[2];\n        // Set when currying a bound function.\n        newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;\n      }\n      // Compose partial arguments.\n      var value = source[3];\n      if (value) {\n        var partials = data[3];\n        data[3] = partials ? composeArgs(partials, value, source[4]) : value;\n        data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];\n      }\n      // Compose partial right arguments.\n      value = source[5];\n      if (value) {\n        partials = data[5];\n        data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;\n        data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];\n      }\n      // Use source `argPos` if available.\n      value = source[7];\n      if (value) {\n        data[7] = value;\n      }\n      // Use source `ary` if it's smaller.\n      if (srcBitmask & WRAP_ARY_FLAG) {\n        data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);\n      }\n      // Use source `arity` if one is not provided.\n      if (data[9] == null) {\n        data[9] = source[9];\n      }\n      // Use source `func` and merge bitmasks.\n      data[0] = source[0];\n      data[1] = newBitmask;\n\n      return data;\n    }\n\n    /**\n     * This function is like\n     * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n     * except that it includes inherited enumerable properties.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function nativeKeysIn(object) {\n      var result = [];\n      if (object != null) {\n        for (var key in Object(object)) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Converts `value` to a string using `Object.prototype.toString`.\n     *\n     * @private\n     * @param {*} value The value to convert.\n     * @returns {string} Returns the converted string.\n     */\n    function objectToString(value) {\n      return nativeObjectToString.call(value);\n    }\n\n    /**\n     * A specialized version of `baseRest` which transforms the rest array.\n     *\n     * @private\n     * @param {Function} func The function to apply a rest parameter to.\n     * @param {number} [start=func.length-1] The start position of the rest parameter.\n     * @param {Function} transform The rest array transform.\n     * @returns {Function} Returns the new function.\n     */\n    function overRest(func, start, transform) {\n      start = nativeMax(start === undefined$1 ? (func.length - 1) : start, 0);\n      return function() {\n        var args = arguments,\n            index = -1,\n            length = nativeMax(args.length - start, 0),\n            array = Array(length);\n\n        while (++index < length) {\n          array[index] = args[start + index];\n        }\n        index = -1;\n        var otherArgs = Array(start + 1);\n        while (++index < start) {\n          otherArgs[index] = args[index];\n        }\n        otherArgs[start] = transform(array);\n        return apply(func, this, otherArgs);\n      };\n    }\n\n    /**\n     * Gets the parent value at `path` of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array} path The path to get the parent value of.\n     * @returns {*} Returns the parent value.\n     */\n    function parent(object, path) {\n      return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));\n    }\n\n    /**\n     * Reorder `array` according to the specified indexes where the element at\n     * the first index is assigned as the first element, the element at\n     * the second index is assigned as the second element, and so on.\n     *\n     * @private\n     * @param {Array} array The array to reorder.\n     * @param {Array} indexes The arranged array indexes.\n     * @returns {Array} Returns `array`.\n     */\n    function reorder(array, indexes) {\n      var arrLength = array.length,\n          length = nativeMin(indexes.length, arrLength),\n          oldArray = copyArray(array);\n\n      while (length--) {\n        var index = indexes[length];\n        array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined$1;\n      }\n      return array;\n    }\n\n    /**\n     * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {string} key The key of the property to get.\n     * @returns {*} Returns the property value.\n     */\n    function safeGet(object, key) {\n      if (key === 'constructor' && typeof object[key] === 'function') {\n        return;\n      }\n\n      if (key == '__proto__') {\n        return;\n      }\n\n      return object[key];\n    }\n\n    /**\n     * Sets metadata for `func`.\n     *\n     * **Note:** If this function becomes hot, i.e. is invoked a lot in a short\n     * period of time, it will trip its breaker and transition to an identity\n     * function to avoid garbage collection pauses in V8. See\n     * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)\n     * for more details.\n     *\n     * @private\n     * @param {Function} func The function to associate metadata with.\n     * @param {*} data The metadata.\n     * @returns {Function} Returns `func`.\n     */\n    var setData = shortOut(baseSetData);\n\n    /**\n     * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).\n     *\n     * @private\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @returns {number|Object} Returns the timer id or timeout object.\n     */\n    var setTimeout = ctxSetTimeout || function(func, wait) {\n      return root.setTimeout(func, wait);\n    };\n\n    /**\n     * Sets the `toString` method of `func` to return `string`.\n     *\n     * @private\n     * @param {Function} func The function to modify.\n     * @param {Function} string The `toString` result.\n     * @returns {Function} Returns `func`.\n     */\n    var setToString = shortOut(baseSetToString);\n\n    /**\n     * Sets the `toString` method of `wrapper` to mimic the source of `reference`\n     * with wrapper details in a comment at the top of the source body.\n     *\n     * @private\n     * @param {Function} wrapper The function to modify.\n     * @param {Function} reference The reference function.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @returns {Function} Returns `wrapper`.\n     */\n    function setWrapToString(wrapper, reference, bitmask) {\n      var source = (reference + '');\n      return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));\n    }\n\n    /**\n     * Creates a function that'll short out and invoke `identity` instead\n     * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n     * milliseconds.\n     *\n     * @private\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new shortable function.\n     */\n    function shortOut(func) {\n      var count = 0,\n          lastCalled = 0;\n\n      return function() {\n        var stamp = nativeNow(),\n            remaining = HOT_SPAN - (stamp - lastCalled);\n\n        lastCalled = stamp;\n        if (remaining > 0) {\n          if (++count >= HOT_COUNT) {\n            return arguments[0];\n          }\n        } else {\n          count = 0;\n        }\n        return func.apply(undefined$1, arguments);\n      };\n    }\n\n    /**\n     * A specialized version of `_.shuffle` which mutates and sets the size of `array`.\n     *\n     * @private\n     * @param {Array} array The array to shuffle.\n     * @param {number} [size=array.length] The size of `array`.\n     * @returns {Array} Returns `array`.\n     */\n    function shuffleSelf(array, size) {\n      var index = -1,\n          length = array.length,\n          lastIndex = length - 1;\n\n      size = size === undefined$1 ? length : size;\n      while (++index < size) {\n        var rand = baseRandom(index, lastIndex),\n            value = array[rand];\n\n        array[rand] = array[index];\n        array[index] = value;\n      }\n      array.length = size;\n      return array;\n    }\n\n    /**\n     * Converts `string` to a property path array.\n     *\n     * @private\n     * @param {string} string The string to convert.\n     * @returns {Array} Returns the property path array.\n     */\n    var stringToPath = memoizeCapped(function(string) {\n      var result = [];\n      if (string.charCodeAt(0) === 46 /* . */) {\n        result.push('');\n      }\n      string.replace(rePropName, function(match, number, quote, subString) {\n        result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n      });\n      return result;\n    });\n\n    /**\n     * Converts `value` to a string key if it's not a string or symbol.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {string|symbol} Returns the key.\n     */\n    function toKey(value) {\n      if (typeof value == 'string' || isSymbol(value)) {\n        return value;\n      }\n      var result = (value + '');\n      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n    }\n\n    /**\n     * Converts `func` to its source code.\n     *\n     * @private\n     * @param {Function} func The function to convert.\n     * @returns {string} Returns the source code.\n     */\n    function toSource(func) {\n      if (func != null) {\n        try {\n          return funcToString.call(func);\n        } catch (e) {}\n        try {\n          return (func + '');\n        } catch (e) {}\n      }\n      return '';\n    }\n\n    /**\n     * Updates wrapper `details` based on `bitmask` flags.\n     *\n     * @private\n     * @returns {Array} details The details to modify.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @returns {Array} Returns `details`.\n     */\n    function updateWrapDetails(details, bitmask) {\n      arrayEach(wrapFlags, function(pair) {\n        var value = '_.' + pair[0];\n        if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {\n          details.push(value);\n        }\n      });\n      return details.sort();\n    }\n\n    /**\n     * Creates a clone of `wrapper`.\n     *\n     * @private\n     * @param {Object} wrapper The wrapper to clone.\n     * @returns {Object} Returns the cloned wrapper.\n     */\n    function wrapperClone(wrapper) {\n      if (wrapper instanceof LazyWrapper) {\n        return wrapper.clone();\n      }\n      var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);\n      result.__actions__ = copyArray(wrapper.__actions__);\n      result.__index__  = wrapper.__index__;\n      result.__values__ = wrapper.__values__;\n      return result;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an array of elements split into groups the length of `size`.\n     * If `array` can't be split evenly, the final chunk will be the remaining\n     * elements.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to process.\n     * @param {number} [size=1] The length of each chunk\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the new array of chunks.\n     * @example\n     *\n     * _.chunk(['a', 'b', 'c', 'd'], 2);\n     * // => [['a', 'b'], ['c', 'd']]\n     *\n     * _.chunk(['a', 'b', 'c', 'd'], 3);\n     * // => [['a', 'b', 'c'], ['d']]\n     */\n    function chunk(array, size, guard) {\n      if ((guard ? isIterateeCall(array, size, guard) : size === undefined$1)) {\n        size = 1;\n      } else {\n        size = nativeMax(toInteger(size), 0);\n      }\n      var length = array == null ? 0 : array.length;\n      if (!length || size < 1) {\n        return [];\n      }\n      var index = 0,\n          resIndex = 0,\n          result = Array(nativeCeil(length / size));\n\n      while (index < length) {\n        result[resIndex++] = baseSlice(array, index, (index += size));\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array with all falsey values removed. The values `false`, `null`,\n     * `0`, `\"\"`, `undefined`, and `NaN` are falsey.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to compact.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.compact([0, 1, false, 2, '', 3]);\n     * // => [1, 2, 3]\n     */\n    function compact(array) {\n      var index = -1,\n          length = array == null ? 0 : array.length,\n          resIndex = 0,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index];\n        if (value) {\n          result[resIndex++] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates a new array concatenating `array` with any additional arrays\n     * and/or values.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to concatenate.\n     * @param {...*} [values] The values to concatenate.\n     * @returns {Array} Returns the new concatenated array.\n     * @example\n     *\n     * var array = [1];\n     * var other = _.concat(array, 2, [3], [[4]]);\n     *\n     * console.log(other);\n     * // => [1, 2, 3, [4]]\n     *\n     * console.log(array);\n     * // => [1]\n     */\n    function concat() {\n      var length = arguments.length;\n      if (!length) {\n        return [];\n      }\n      var args = Array(length - 1),\n          array = arguments[0],\n          index = length;\n\n      while (index--) {\n        args[index - 1] = arguments[index];\n      }\n      return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));\n    }\n\n    /**\n     * Creates an array of `array` values not included in the other given arrays\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. The order and references of result values are\n     * determined by the first array.\n     *\n     * **Note:** Unlike `_.pullAll`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.without, _.xor\n     * @example\n     *\n     * _.difference([2, 1], [2, 3]);\n     * // => [1]\n     */\n    var difference = baseRest(function(array, values) {\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))\n        : [];\n    });\n\n    /**\n     * This method is like `_.difference` except that it accepts `iteratee` which\n     * is invoked for each element of `array` and `values` to generate the criterion\n     * by which they're compared. The order and references of result values are\n     * determined by the first array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * **Note:** Unlike `_.pullAllBy`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');\n     * // => [{ 'x': 2 }]\n     */\n    var differenceBy = baseRest(function(array, values) {\n      var iteratee = last(values);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined$1;\n      }\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))\n        : [];\n    });\n\n    /**\n     * This method is like `_.difference` except that it accepts `comparator`\n     * which is invoked to compare elements of `array` to `values`. The order and\n     * references of result values are determined by the first array. The comparator\n     * is invoked with two arguments: (arrVal, othVal).\n     *\n     * **Note:** Unlike `_.pullAllWith`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     *\n     * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);\n     * // => [{ 'x': 2, 'y': 1 }]\n     */\n    var differenceWith = baseRest(function(array, values) {\n      var comparator = last(values);\n      if (isArrayLikeObject(comparator)) {\n        comparator = undefined$1;\n      }\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined$1, comparator)\n        : [];\n    });\n\n    /**\n     * Creates a slice of `array` with `n` elements dropped from the beginning.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to drop.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.drop([1, 2, 3]);\n     * // => [2, 3]\n     *\n     * _.drop([1, 2, 3], 2);\n     * // => [3]\n     *\n     * _.drop([1, 2, 3], 5);\n     * // => []\n     *\n     * _.drop([1, 2, 3], 0);\n     * // => [1, 2, 3]\n     */\n    function drop(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined$1) ? 1 : toInteger(n);\n      return baseSlice(array, n < 0 ? 0 : n, length);\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements dropped from the end.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to drop.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.dropRight([1, 2, 3]);\n     * // => [1, 2]\n     *\n     * _.dropRight([1, 2, 3], 2);\n     * // => [1]\n     *\n     * _.dropRight([1, 2, 3], 5);\n     * // => []\n     *\n     * _.dropRight([1, 2, 3], 0);\n     * // => [1, 2, 3]\n     */\n    function dropRight(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined$1) ? 1 : toInteger(n);\n      n = length - n;\n      return baseSlice(array, 0, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` excluding elements dropped from the end.\n     * Elements are dropped until `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.dropRightWhile(users, function(o) { return !o.active; });\n     * // => objects for ['barney']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.dropRightWhile(users, ['active', false]);\n     * // => objects for ['barney']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.dropRightWhile(users, 'active');\n     * // => objects for ['barney', 'fred', 'pebbles']\n     */\n    function dropRightWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), true, true)\n        : [];\n    }\n\n    /**\n     * Creates a slice of `array` excluding elements dropped from the beginning.\n     * Elements are dropped until `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.dropWhile(users, function(o) { return !o.active; });\n     * // => objects for ['pebbles']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.dropWhile(users, { 'user': 'barney', 'active': false });\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.dropWhile(users, ['active', false]);\n     * // => objects for ['pebbles']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.dropWhile(users, 'active');\n     * // => objects for ['barney', 'fred', 'pebbles']\n     */\n    function dropWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), true)\n        : [];\n    }\n\n    /**\n     * Fills elements of `array` with `value` from `start` up to, but not\n     * including, `end`.\n     *\n     * **Note:** This method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Array\n     * @param {Array} array The array to fill.\n     * @param {*} value The value to fill `array` with.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _.fill(array, 'a');\n     * console.log(array);\n     * // => ['a', 'a', 'a']\n     *\n     * _.fill(Array(3), 2);\n     * // => [2, 2, 2]\n     *\n     * _.fill([4, 6, 8, 10], '*', 1, 3);\n     * // => [4, '*', '*', 10]\n     */\n    function fill(array, value, start, end) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {\n        start = 0;\n        end = length;\n      }\n      return baseFill(array, value, start, end);\n    }\n\n    /**\n     * This method is like `_.find` except that it returns the index of the first\n     * element `predicate` returns truthy for instead of the element itself.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {number} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.findIndex(users, function(o) { return o.user == 'barney'; });\n     * // => 0\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findIndex(users, { 'user': 'fred', 'active': false });\n     * // => 1\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findIndex(users, ['active', false]);\n     * // => 0\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findIndex(users, 'active');\n     * // => 2\n     */\n    function findIndex(array, predicate, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = fromIndex == null ? 0 : toInteger(fromIndex);\n      if (index < 0) {\n        index = nativeMax(length + index, 0);\n      }\n      return baseFindIndex(array, getIteratee(predicate, 3), index);\n    }\n\n    /**\n     * This method is like `_.findIndex` except that it iterates over elements\n     * of `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=array.length-1] The index to search from.\n     * @returns {number} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });\n     * // => 2\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findLastIndex(users, { 'user': 'barney', 'active': true });\n     * // => 0\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findLastIndex(users, ['active', false]);\n     * // => 2\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findLastIndex(users, 'active');\n     * // => 0\n     */\n    function findLastIndex(array, predicate, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = length - 1;\n      if (fromIndex !== undefined$1) {\n        index = toInteger(fromIndex);\n        index = fromIndex < 0\n          ? nativeMax(length + index, 0)\n          : nativeMin(index, length - 1);\n      }\n      return baseFindIndex(array, getIteratee(predicate, 3), index, true);\n    }\n\n    /**\n     * Flattens `array` a single level deep.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * _.flatten([1, [2, [3, [4]], 5]]);\n     * // => [1, 2, [3, [4]], 5]\n     */\n    function flatten(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseFlatten(array, 1) : [];\n    }\n\n    /**\n     * Recursively flattens `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * _.flattenDeep([1, [2, [3, [4]], 5]]);\n     * // => [1, 2, 3, 4, 5]\n     */\n    function flattenDeep(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseFlatten(array, INFINITY) : [];\n    }\n\n    /**\n     * Recursively flatten `array` up to `depth` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.4.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @param {number} [depth=1] The maximum recursion depth.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * var array = [1, [2, [3, [4]], 5]];\n     *\n     * _.flattenDepth(array, 1);\n     * // => [1, 2, [3, [4]], 5]\n     *\n     * _.flattenDepth(array, 2);\n     * // => [1, 2, 3, [4], 5]\n     */\n    function flattenDepth(array, depth) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      depth = depth === undefined$1 ? 1 : toInteger(depth);\n      return baseFlatten(array, depth);\n    }\n\n    /**\n     * The inverse of `_.toPairs`; this method returns an object composed\n     * from key-value `pairs`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} pairs The key-value pairs.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.fromPairs([['a', 1], ['b', 2]]);\n     * // => { 'a': 1, 'b': 2 }\n     */\n    function fromPairs(pairs) {\n      var index = -1,\n          length = pairs == null ? 0 : pairs.length,\n          result = {};\n\n      while (++index < length) {\n        var pair = pairs[index];\n        result[pair[0]] = pair[1];\n      }\n      return result;\n    }\n\n    /**\n     * Gets the first element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @alias first\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {*} Returns the first element of `array`.\n     * @example\n     *\n     * _.head([1, 2, 3]);\n     * // => 1\n     *\n     * _.head([]);\n     * // => undefined\n     */\n    function head(array) {\n      return (array && array.length) ? array[0] : undefined$1;\n    }\n\n    /**\n     * Gets the index at which the first occurrence of `value` is found in `array`\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. If `fromIndex` is negative, it's used as the\n     * offset from the end of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.indexOf([1, 2, 1, 2], 2);\n     * // => 1\n     *\n     * // Search from the `fromIndex`.\n     * _.indexOf([1, 2, 1, 2], 2, 2);\n     * // => 3\n     */\n    function indexOf(array, value, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = fromIndex == null ? 0 : toInteger(fromIndex);\n      if (index < 0) {\n        index = nativeMax(length + index, 0);\n      }\n      return baseIndexOf(array, value, index);\n    }\n\n    /**\n     * Gets all but the last element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.initial([1, 2, 3]);\n     * // => [1, 2]\n     */\n    function initial(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseSlice(array, 0, -1) : [];\n    }\n\n    /**\n     * Creates an array of unique values that are included in all given arrays\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. The order and references of result values are\n     * determined by the first array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * _.intersection([2, 1], [2, 3]);\n     * // => [2]\n     */\n    var intersection = baseRest(function(arrays) {\n      var mapped = arrayMap(arrays, castArrayLikeObject);\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped)\n        : [];\n    });\n\n    /**\n     * This method is like `_.intersection` except that it accepts `iteratee`\n     * which is invoked for each element of each `arrays` to generate the criterion\n     * by which they're compared. The order and references of result values are\n     * determined by the first array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [2.1]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }]\n     */\n    var intersectionBy = baseRest(function(arrays) {\n      var iteratee = last(arrays),\n          mapped = arrayMap(arrays, castArrayLikeObject);\n\n      if (iteratee === last(mapped)) {\n        iteratee = undefined$1;\n      } else {\n        mapped.pop();\n      }\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped, getIteratee(iteratee, 2))\n        : [];\n    });\n\n    /**\n     * This method is like `_.intersection` except that it accepts `comparator`\n     * which is invoked to compare elements of `arrays`. The order and references\n     * of result values are determined by the first array. The comparator is\n     * invoked with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.intersectionWith(objects, others, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }]\n     */\n    var intersectionWith = baseRest(function(arrays) {\n      var comparator = last(arrays),\n          mapped = arrayMap(arrays, castArrayLikeObject);\n\n      comparator = typeof comparator == 'function' ? comparator : undefined$1;\n      if (comparator) {\n        mapped.pop();\n      }\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped, undefined$1, comparator)\n        : [];\n    });\n\n    /**\n     * Converts all elements in `array` into a string separated by `separator`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to convert.\n     * @param {string} [separator=','] The element separator.\n     * @returns {string} Returns the joined string.\n     * @example\n     *\n     * _.join(['a', 'b', 'c'], '~');\n     * // => 'a~b~c'\n     */\n    function join(array, separator) {\n      return array == null ? '' : nativeJoin.call(array, separator);\n    }\n\n    /**\n     * Gets the last element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {*} Returns the last element of `array`.\n     * @example\n     *\n     * _.last([1, 2, 3]);\n     * // => 3\n     */\n    function last(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? array[length - 1] : undefined$1;\n    }\n\n    /**\n     * This method is like `_.indexOf` except that it iterates over elements of\n     * `array` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=array.length-1] The index to search from.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.lastIndexOf([1, 2, 1, 2], 2);\n     * // => 3\n     *\n     * // Search from the `fromIndex`.\n     * _.lastIndexOf([1, 2, 1, 2], 2, 2);\n     * // => 1\n     */\n    function lastIndexOf(array, value, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = length;\n      if (fromIndex !== undefined$1) {\n        index = toInteger(fromIndex);\n        index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);\n      }\n      return value === value\n        ? strictLastIndexOf(array, value, index)\n        : baseFindIndex(array, baseIsNaN, index, true);\n    }\n\n    /**\n     * Gets the element at index `n` of `array`. If `n` is negative, the nth\n     * element from the end is returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.11.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=0] The index of the element to return.\n     * @returns {*} Returns the nth element of `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'd'];\n     *\n     * _.nth(array, 1);\n     * // => 'b'\n     *\n     * _.nth(array, -2);\n     * // => 'c';\n     */\n    function nth(array, n) {\n      return (array && array.length) ? baseNth(array, toInteger(n)) : undefined$1;\n    }\n\n    /**\n     * Removes all given values from `array` using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`\n     * to remove elements from an array by predicate.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {...*} [values] The values to remove.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n     *\n     * _.pull(array, 'a', 'c');\n     * console.log(array);\n     * // => ['b', 'b']\n     */\n    var pull = baseRest(pullAll);\n\n    /**\n     * This method is like `_.pull` except that it accepts an array of values to remove.\n     *\n     * **Note:** Unlike `_.difference`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n     *\n     * _.pullAll(array, ['a', 'c']);\n     * console.log(array);\n     * // => ['b', 'b']\n     */\n    function pullAll(array, values) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values)\n        : array;\n    }\n\n    /**\n     * This method is like `_.pullAll` except that it accepts `iteratee` which is\n     * invoked for each element of `array` and `values` to generate the criterion\n     * by which they're compared. The iteratee is invoked with one argument: (value).\n     *\n     * **Note:** Unlike `_.differenceBy`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];\n     *\n     * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');\n     * console.log(array);\n     * // => [{ 'x': 2 }]\n     */\n    function pullAllBy(array, values, iteratee) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values, getIteratee(iteratee, 2))\n        : array;\n    }\n\n    /**\n     * This method is like `_.pullAll` except that it accepts `comparator` which\n     * is invoked to compare elements of `array` to `values`. The comparator is\n     * invoked with two arguments: (arrVal, othVal).\n     *\n     * **Note:** Unlike `_.differenceWith`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];\n     *\n     * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);\n     * console.log(array);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]\n     */\n    function pullAllWith(array, values, comparator) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values, undefined$1, comparator)\n        : array;\n    }\n\n    /**\n     * Removes elements from `array` corresponding to `indexes` and returns an\n     * array of removed elements.\n     *\n     * **Note:** Unlike `_.at`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {...(number|number[])} [indexes] The indexes of elements to remove.\n     * @returns {Array} Returns the new array of removed elements.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'd'];\n     * var pulled = _.pullAt(array, [1, 3]);\n     *\n     * console.log(array);\n     * // => ['a', 'c']\n     *\n     * console.log(pulled);\n     * // => ['b', 'd']\n     */\n    var pullAt = flatRest(function(array, indexes) {\n      var length = array == null ? 0 : array.length,\n          result = baseAt(array, indexes);\n\n      basePullAt(array, arrayMap(indexes, function(index) {\n        return isIndex(index, length) ? +index : index;\n      }).sort(compareAscending));\n\n      return result;\n    });\n\n    /**\n     * Removes all elements from `array` that `predicate` returns truthy for\n     * and returns an array of the removed elements. The predicate is invoked\n     * with three arguments: (value, index, array).\n     *\n     * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`\n     * to pull elements from an array by value.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new array of removed elements.\n     * @example\n     *\n     * var array = [1, 2, 3, 4];\n     * var evens = _.remove(array, function(n) {\n     *   return n % 2 == 0;\n     * });\n     *\n     * console.log(array);\n     * // => [1, 3]\n     *\n     * console.log(evens);\n     * // => [2, 4]\n     */\n    function remove(array, predicate) {\n      var result = [];\n      if (!(array && array.length)) {\n        return result;\n      }\n      var index = -1,\n          indexes = [],\n          length = array.length;\n\n      predicate = getIteratee(predicate, 3);\n      while (++index < length) {\n        var value = array[index];\n        if (predicate(value, index, array)) {\n          result.push(value);\n          indexes.push(index);\n        }\n      }\n      basePullAt(array, indexes);\n      return result;\n    }\n\n    /**\n     * Reverses `array` so that the first element becomes the last, the second\n     * element becomes the second to last, and so on.\n     *\n     * **Note:** This method mutates `array` and is based on\n     * [`Array#reverse`](https://mdn.io/Array/reverse).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _.reverse(array);\n     * // => [3, 2, 1]\n     *\n     * console.log(array);\n     * // => [3, 2, 1]\n     */\n    function reverse(array) {\n      return array == null ? array : nativeReverse.call(array);\n    }\n\n    /**\n     * Creates a slice of `array` from `start` up to, but not including, `end`.\n     *\n     * **Note:** This method is used instead of\n     * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are\n     * returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to slice.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function slice(array, start, end) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {\n        start = 0;\n        end = length;\n      }\n      else {\n        start = start == null ? 0 : toInteger(start);\n        end = end === undefined$1 ? length : toInteger(end);\n      }\n      return baseSlice(array, start, end);\n    }\n\n    /**\n     * Uses a binary search to determine the lowest index at which `value`\n     * should be inserted into `array` in order to maintain its sort order.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedIndex([30, 50], 40);\n     * // => 1\n     */\n    function sortedIndex(array, value) {\n      return baseSortedIndex(array, value);\n    }\n\n    /**\n     * This method is like `_.sortedIndex` except that it accepts `iteratee`\n     * which is invoked for `value` and each element of `array` to compute their\n     * sort ranking. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * var objects = [{ 'x': 4 }, { 'x': 5 }];\n     *\n     * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n     * // => 0\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sortedIndexBy(objects, { 'x': 4 }, 'x');\n     * // => 0\n     */\n    function sortedIndexBy(array, value, iteratee) {\n      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));\n    }\n\n    /**\n     * This method is like `_.indexOf` except that it performs a binary\n     * search on a sorted `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.sortedIndexOf([4, 5, 5, 5, 6], 5);\n     * // => 1\n     */\n    function sortedIndexOf(array, value) {\n      var length = array == null ? 0 : array.length;\n      if (length) {\n        var index = baseSortedIndex(array, value);\n        if (index < length && eq(array[index], value)) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * This method is like `_.sortedIndex` except that it returns the highest\n     * index at which `value` should be inserted into `array` in order to\n     * maintain its sort order.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedLastIndex([4, 5, 5, 5, 6], 5);\n     * // => 4\n     */\n    function sortedLastIndex(array, value) {\n      return baseSortedIndex(array, value, true);\n    }\n\n    /**\n     * This method is like `_.sortedLastIndex` except that it accepts `iteratee`\n     * which is invoked for `value` and each element of `array` to compute their\n     * sort ranking. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * var objects = [{ 'x': 4 }, { 'x': 5 }];\n     *\n     * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n     * // => 1\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');\n     * // => 1\n     */\n    function sortedLastIndexBy(array, value, iteratee) {\n      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);\n    }\n\n    /**\n     * This method is like `_.lastIndexOf` except that it performs a binary\n     * search on a sorted `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);\n     * // => 3\n     */\n    function sortedLastIndexOf(array, value) {\n      var length = array == null ? 0 : array.length;\n      if (length) {\n        var index = baseSortedIndex(array, value, true) - 1;\n        if (eq(array[index], value)) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * This method is like `_.uniq` except that it's designed and optimized\n     * for sorted arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.sortedUniq([1, 1, 2]);\n     * // => [1, 2]\n     */\n    function sortedUniq(array) {\n      return (array && array.length)\n        ? baseSortedUniq(array)\n        : [];\n    }\n\n    /**\n     * This method is like `_.uniqBy` except that it's designed and optimized\n     * for sorted arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);\n     * // => [1.1, 2.3]\n     */\n    function sortedUniqBy(array, iteratee) {\n      return (array && array.length)\n        ? baseSortedUniq(array, getIteratee(iteratee, 2))\n        : [];\n    }\n\n    /**\n     * Gets all but the first element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.tail([1, 2, 3]);\n     * // => [2, 3]\n     */\n    function tail(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseSlice(array, 1, length) : [];\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements taken from the beginning.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to take.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.take([1, 2, 3]);\n     * // => [1]\n     *\n     * _.take([1, 2, 3], 2);\n     * // => [1, 2]\n     *\n     * _.take([1, 2, 3], 5);\n     * // => [1, 2, 3]\n     *\n     * _.take([1, 2, 3], 0);\n     * // => []\n     */\n    function take(array, n, guard) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      n = (guard || n === undefined$1) ? 1 : toInteger(n);\n      return baseSlice(array, 0, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements taken from the end.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to take.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.takeRight([1, 2, 3]);\n     * // => [3]\n     *\n     * _.takeRight([1, 2, 3], 2);\n     * // => [2, 3]\n     *\n     * _.takeRight([1, 2, 3], 5);\n     * // => [1, 2, 3]\n     *\n     * _.takeRight([1, 2, 3], 0);\n     * // => []\n     */\n    function takeRight(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined$1) ? 1 : toInteger(n);\n      n = length - n;\n      return baseSlice(array, n < 0 ? 0 : n, length);\n    }\n\n    /**\n     * Creates a slice of `array` with elements taken from the end. Elements are\n     * taken until `predicate` returns falsey. The predicate is invoked with\n     * three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.takeRightWhile(users, function(o) { return !o.active; });\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });\n     * // => objects for ['pebbles']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.takeRightWhile(users, ['active', false]);\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.takeRightWhile(users, 'active');\n     * // => []\n     */\n    function takeRightWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), false, true)\n        : [];\n    }\n\n    /**\n     * Creates a slice of `array` with elements taken from the beginning. Elements\n     * are taken until `predicate` returns falsey. The predicate is invoked with\n     * three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.takeWhile(users, function(o) { return !o.active; });\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.takeWhile(users, { 'user': 'barney', 'active': false });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.takeWhile(users, ['active', false]);\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.takeWhile(users, 'active');\n     * // => []\n     */\n    function takeWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3))\n        : [];\n    }\n\n    /**\n     * Creates an array of unique values, in order, from all given arrays using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * _.union([2], [1, 2]);\n     * // => [2, 1]\n     */\n    var union = baseRest(function(arrays) {\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));\n    });\n\n    /**\n     * This method is like `_.union` except that it accepts `iteratee` which is\n     * invoked for each element of each `arrays` to generate the criterion by\n     * which uniqueness is computed. Result values are chosen from the first\n     * array in which the value occurs. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * _.unionBy([2.1], [1.2, 2.3], Math.floor);\n     * // => [2.1, 1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }, { 'x': 2 }]\n     */\n    var unionBy = baseRest(function(arrays) {\n      var iteratee = last(arrays);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined$1;\n      }\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));\n    });\n\n    /**\n     * This method is like `_.union` except that it accepts `comparator` which\n     * is invoked to compare elements of `arrays`. Result values are chosen from\n     * the first array in which the value occurs. The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.unionWith(objects, others, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n     */\n    var unionWith = baseRest(function(arrays) {\n      var comparator = last(arrays);\n      comparator = typeof comparator == 'function' ? comparator : undefined$1;\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined$1, comparator);\n    });\n\n    /**\n     * Creates a duplicate-free version of an array, using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons, in which only the first occurrence of each element\n     * is kept. The order of result values is determined by the order they occur\n     * in the array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.uniq([2, 1, 2]);\n     * // => [2, 1]\n     */\n    function uniq(array) {\n      return (array && array.length) ? baseUniq(array) : [];\n    }\n\n    /**\n     * This method is like `_.uniq` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * uniqueness is computed. The order of result values is determined by the\n     * order they occur in the array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.uniqBy([2.1, 1.2, 2.3], Math.floor);\n     * // => [2.1, 1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }, { 'x': 2 }]\n     */\n    function uniqBy(array, iteratee) {\n      return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];\n    }\n\n    /**\n     * This method is like `_.uniq` except that it accepts `comparator` which\n     * is invoked to compare elements of `array`. The order of result values is\n     * determined by the order they occur in the array.The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.uniqWith(objects, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]\n     */\n    function uniqWith(array, comparator) {\n      comparator = typeof comparator == 'function' ? comparator : undefined$1;\n      return (array && array.length) ? baseUniq(array, undefined$1, comparator) : [];\n    }\n\n    /**\n     * This method is like `_.zip` except that it accepts an array of grouped\n     * elements and creates an array regrouping the elements to their pre-zip\n     * configuration.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.2.0\n     * @category Array\n     * @param {Array} array The array of grouped elements to process.\n     * @returns {Array} Returns the new array of regrouped elements.\n     * @example\n     *\n     * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);\n     * // => [['a', 1, true], ['b', 2, false]]\n     *\n     * _.unzip(zipped);\n     * // => [['a', 'b'], [1, 2], [true, false]]\n     */\n    function unzip(array) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      var length = 0;\n      array = arrayFilter(array, function(group) {\n        if (isArrayLikeObject(group)) {\n          length = nativeMax(group.length, length);\n          return true;\n        }\n      });\n      return baseTimes(length, function(index) {\n        return arrayMap(array, baseProperty(index));\n      });\n    }\n\n    /**\n     * This method is like `_.unzip` except that it accepts `iteratee` to specify\n     * how regrouped values should be combined. The iteratee is invoked with the\n     * elements of each group: (...group).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Array\n     * @param {Array} array The array of grouped elements to process.\n     * @param {Function} [iteratee=_.identity] The function to combine\n     *  regrouped values.\n     * @returns {Array} Returns the new array of regrouped elements.\n     * @example\n     *\n     * var zipped = _.zip([1, 2], [10, 20], [100, 200]);\n     * // => [[1, 10, 100], [2, 20, 200]]\n     *\n     * _.unzipWith(zipped, _.add);\n     * // => [3, 30, 300]\n     */\n    function unzipWith(array, iteratee) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      var result = unzip(array);\n      if (iteratee == null) {\n        return result;\n      }\n      return arrayMap(result, function(group) {\n        return apply(iteratee, undefined$1, group);\n      });\n    }\n\n    /**\n     * Creates an array excluding all given values using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * **Note:** Unlike `_.pull`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...*} [values] The values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.difference, _.xor\n     * @example\n     *\n     * _.without([2, 1, 2, 3], 1, 2);\n     * // => [3]\n     */\n    var without = baseRest(function(array, values) {\n      return isArrayLikeObject(array)\n        ? baseDifference(array, values)\n        : [];\n    });\n\n    /**\n     * Creates an array of unique values that is the\n     * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)\n     * of the given arrays. The order of result values is determined by the order\n     * they occur in the arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.difference, _.without\n     * @example\n     *\n     * _.xor([2, 1], [2, 3]);\n     * // => [1, 3]\n     */\n    var xor = baseRest(function(arrays) {\n      return baseXor(arrayFilter(arrays, isArrayLikeObject));\n    });\n\n    /**\n     * This method is like `_.xor` except that it accepts `iteratee` which is\n     * invoked for each element of each `arrays` to generate the criterion by\n     * which by which they're compared. The order of result values is determined\n     * by the order they occur in the arrays. The iteratee is invoked with one\n     * argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [1.2, 3.4]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 2 }]\n     */\n    var xorBy = baseRest(function(arrays) {\n      var iteratee = last(arrays);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined$1;\n      }\n      return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));\n    });\n\n    /**\n     * This method is like `_.xor` except that it accepts `comparator` which is\n     * invoked to compare elements of `arrays`. The order of result values is\n     * determined by the order they occur in the arrays. The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.xorWith(objects, others, _.isEqual);\n     * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n     */\n    var xorWith = baseRest(function(arrays) {\n      var comparator = last(arrays);\n      comparator = typeof comparator == 'function' ? comparator : undefined$1;\n      return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined$1, comparator);\n    });\n\n    /**\n     * Creates an array of grouped elements, the first of which contains the\n     * first elements of the given arrays, the second of which contains the\n     * second elements of the given arrays, and so on.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to process.\n     * @returns {Array} Returns the new array of grouped elements.\n     * @example\n     *\n     * _.zip(['a', 'b'], [1, 2], [true, false]);\n     * // => [['a', 1, true], ['b', 2, false]]\n     */\n    var zip = baseRest(unzip);\n\n    /**\n     * This method is like `_.fromPairs` except that it accepts two arrays,\n     * one of property identifiers and one of corresponding values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.4.0\n     * @category Array\n     * @param {Array} [props=[]] The property identifiers.\n     * @param {Array} [values=[]] The property values.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.zipObject(['a', 'b'], [1, 2]);\n     * // => { 'a': 1, 'b': 2 }\n     */\n    function zipObject(props, values) {\n      return baseZipObject(props || [], values || [], assignValue);\n    }\n\n    /**\n     * This method is like `_.zipObject` except that it supports property paths.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.1.0\n     * @category Array\n     * @param {Array} [props=[]] The property identifiers.\n     * @param {Array} [values=[]] The property values.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);\n     * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }\n     */\n    function zipObjectDeep(props, values) {\n      return baseZipObject(props || [], values || [], baseSet);\n    }\n\n    /**\n     * This method is like `_.zip` except that it accepts `iteratee` to specify\n     * how grouped values should be combined. The iteratee is invoked with the\n     * elements of each group: (...group).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to process.\n     * @param {Function} [iteratee=_.identity] The function to combine\n     *  grouped values.\n     * @returns {Array} Returns the new array of grouped elements.\n     * @example\n     *\n     * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {\n     *   return a + b + c;\n     * });\n     * // => [111, 222]\n     */\n    var zipWith = baseRest(function(arrays) {\n      var length = arrays.length,\n          iteratee = length > 1 ? arrays[length - 1] : undefined$1;\n\n      iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined$1;\n      return unzipWith(arrays, iteratee);\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` wrapper instance that wraps `value` with explicit method\n     * chain sequences enabled. The result of such sequences must be unwrapped\n     * with `_#value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.3.0\n     * @category Seq\n     * @param {*} value The value to wrap.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36 },\n     *   { 'user': 'fred',    'age': 40 },\n     *   { 'user': 'pebbles', 'age': 1 }\n     * ];\n     *\n     * var youngest = _\n     *   .chain(users)\n     *   .sortBy('age')\n     *   .map(function(o) {\n     *     return o.user + ' is ' + o.age;\n     *   })\n     *   .head()\n     *   .value();\n     * // => 'pebbles is 1'\n     */\n    function chain(value) {\n      var result = lodash(value);\n      result.__chain__ = true;\n      return result;\n    }\n\n    /**\n     * This method invokes `interceptor` and returns `value`. The interceptor\n     * is invoked with one argument; (value). The purpose of this method is to\n     * \"tap into\" a method chain sequence in order to modify intermediate results.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @param {*} value The value to provide to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * _([1, 2, 3])\n     *  .tap(function(array) {\n     *    // Mutate input array.\n     *    array.pop();\n     *  })\n     *  .reverse()\n     *  .value();\n     * // => [2, 1]\n     */\n    function tap(value, interceptor) {\n      interceptor(value);\n      return value;\n    }\n\n    /**\n     * This method is like `_.tap` except that it returns the result of `interceptor`.\n     * The purpose of this method is to \"pass thru\" values replacing intermediate\n     * results in a method chain sequence.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Seq\n     * @param {*} value The value to provide to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @returns {*} Returns the result of `interceptor`.\n     * @example\n     *\n     * _('  abc  ')\n     *  .chain()\n     *  .trim()\n     *  .thru(function(value) {\n     *    return [value];\n     *  })\n     *  .value();\n     * // => ['abc']\n     */\n    function thru(value, interceptor) {\n      return interceptor(value);\n    }\n\n    /**\n     * This method is the wrapper version of `_.at`.\n     *\n     * @name at\n     * @memberOf _\n     * @since 1.0.0\n     * @category Seq\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n     *\n     * _(object).at(['a[0].b.c', 'a[1]']).value();\n     * // => [3, 4]\n     */\n    var wrapperAt = flatRest(function(paths) {\n      var length = paths.length,\n          start = length ? paths[0] : 0,\n          value = this.__wrapped__,\n          interceptor = function(object) { return baseAt(object, paths); };\n\n      if (length > 1 || this.__actions__.length ||\n          !(value instanceof LazyWrapper) || !isIndex(start)) {\n        return this.thru(interceptor);\n      }\n      value = value.slice(start, +start + (length ? 1 : 0));\n      value.__actions__.push({\n        'func': thru,\n        'args': [interceptor],\n        'thisArg': undefined$1\n      });\n      return new LodashWrapper(value, this.__chain__).thru(function(array) {\n        if (length && !array.length) {\n          array.push(undefined$1);\n        }\n        return array;\n      });\n    });\n\n    /**\n     * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.\n     *\n     * @name chain\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 }\n     * ];\n     *\n     * // A sequence without explicit chaining.\n     * _(users).head();\n     * // => { 'user': 'barney', 'age': 36 }\n     *\n     * // A sequence with explicit chaining.\n     * _(users)\n     *   .chain()\n     *   .head()\n     *   .pick('user')\n     *   .value();\n     * // => { 'user': 'barney' }\n     */\n    function wrapperChain() {\n      return chain(this);\n    }\n\n    /**\n     * Executes the chain sequence and returns the wrapped result.\n     *\n     * @name commit\n     * @memberOf _\n     * @since 3.2.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2];\n     * var wrapped = _(array).push(3);\n     *\n     * console.log(array);\n     * // => [1, 2]\n     *\n     * wrapped = wrapped.commit();\n     * console.log(array);\n     * // => [1, 2, 3]\n     *\n     * wrapped.last();\n     * // => 3\n     *\n     * console.log(array);\n     * // => [1, 2, 3]\n     */\n    function wrapperCommit() {\n      return new LodashWrapper(this.value(), this.__chain__);\n    }\n\n    /**\n     * Gets the next value on a wrapped object following the\n     * [iterator protocol](https://mdn.io/iteration_protocols#iterator).\n     *\n     * @name next\n     * @memberOf _\n     * @since 4.0.0\n     * @category Seq\n     * @returns {Object} Returns the next iterator value.\n     * @example\n     *\n     * var wrapped = _([1, 2]);\n     *\n     * wrapped.next();\n     * // => { 'done': false, 'value': 1 }\n     *\n     * wrapped.next();\n     * // => { 'done': false, 'value': 2 }\n     *\n     * wrapped.next();\n     * // => { 'done': true, 'value': undefined }\n     */\n    function wrapperNext() {\n      if (this.__values__ === undefined$1) {\n        this.__values__ = toArray(this.value());\n      }\n      var done = this.__index__ >= this.__values__.length,\n          value = done ? undefined$1 : this.__values__[this.__index__++];\n\n      return { 'done': done, 'value': value };\n    }\n\n    /**\n     * Enables the wrapper to be iterable.\n     *\n     * @name Symbol.iterator\n     * @memberOf _\n     * @since 4.0.0\n     * @category Seq\n     * @returns {Object} Returns the wrapper object.\n     * @example\n     *\n     * var wrapped = _([1, 2]);\n     *\n     * wrapped[Symbol.iterator]() === wrapped;\n     * // => true\n     *\n     * Array.from(wrapped);\n     * // => [1, 2]\n     */\n    function wrapperToIterator() {\n      return this;\n    }\n\n    /**\n     * Creates a clone of the chain sequence planting `value` as the wrapped value.\n     *\n     * @name plant\n     * @memberOf _\n     * @since 3.2.0\n     * @category Seq\n     * @param {*} value The value to plant.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var wrapped = _([1, 2]).map(square);\n     * var other = wrapped.plant([3, 4]);\n     *\n     * other.value();\n     * // => [9, 16]\n     *\n     * wrapped.value();\n     * // => [1, 4]\n     */\n    function wrapperPlant(value) {\n      var result,\n          parent = this;\n\n      while (parent instanceof baseLodash) {\n        var clone = wrapperClone(parent);\n        clone.__index__ = 0;\n        clone.__values__ = undefined$1;\n        if (result) {\n          previous.__wrapped__ = clone;\n        } else {\n          result = clone;\n        }\n        var previous = clone;\n        parent = parent.__wrapped__;\n      }\n      previous.__wrapped__ = value;\n      return result;\n    }\n\n    /**\n     * This method is the wrapper version of `_.reverse`.\n     *\n     * **Note:** This method mutates the wrapped array.\n     *\n     * @name reverse\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _(array).reverse().value()\n     * // => [3, 2, 1]\n     *\n     * console.log(array);\n     * // => [3, 2, 1]\n     */\n    function wrapperReverse() {\n      var value = this.__wrapped__;\n      if (value instanceof LazyWrapper) {\n        var wrapped = value;\n        if (this.__actions__.length) {\n          wrapped = new LazyWrapper(this);\n        }\n        wrapped = wrapped.reverse();\n        wrapped.__actions__.push({\n          'func': thru,\n          'args': [reverse],\n          'thisArg': undefined$1\n        });\n        return new LodashWrapper(wrapped, this.__chain__);\n      }\n      return this.thru(reverse);\n    }\n\n    /**\n     * Executes the chain sequence to resolve the unwrapped value.\n     *\n     * @name value\n     * @memberOf _\n     * @since 0.1.0\n     * @alias toJSON, valueOf\n     * @category Seq\n     * @returns {*} Returns the resolved unwrapped value.\n     * @example\n     *\n     * _([1, 2, 3]).value();\n     * // => [1, 2, 3]\n     */\n    function wrapperValue() {\n      return baseWrapperValue(this.__wrapped__, this.__actions__);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The corresponding value of\n     * each key is the number of times the key was returned by `iteratee`. The\n     * iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.countBy([6.1, 4.2, 6.3], Math.floor);\n     * // => { '4': 1, '6': 2 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.countBy(['one', 'two', 'three'], 'length');\n     * // => { '3': 2, '5': 1 }\n     */\n    var countBy = createAggregator(function(result, value, key) {\n      if (hasOwnProperty.call(result, key)) {\n        ++result[key];\n      } else {\n        baseAssignValue(result, key, 1);\n      }\n    });\n\n    /**\n     * Checks if `predicate` returns truthy for **all** elements of `collection`.\n     * Iteration is stopped once `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index|key, collection).\n     *\n     * **Note:** This method returns `true` for\n     * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because\n     * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of\n     * elements of empty collections.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`.\n     * @example\n     *\n     * _.every([true, 1, null, 'yes'], Boolean);\n     * // => false\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': false },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.every(users, { 'user': 'barney', 'active': false });\n     * // => false\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.every(users, ['active', false]);\n     * // => true\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.every(users, 'active');\n     * // => false\n     */\n    function every(collection, predicate, guard) {\n      var func = isArray(collection) ? arrayEvery : baseEvery;\n      if (guard && isIterateeCall(collection, predicate, guard)) {\n        predicate = undefined$1;\n      }\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Iterates over elements of `collection`, returning an array of all elements\n     * `predicate` returns truthy for. The predicate is invoked with three\n     * arguments: (value, index|key, collection).\n     *\n     * **Note:** Unlike `_.remove`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     * @see _.reject\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * _.filter(users, function(o) { return !o.active; });\n     * // => objects for ['fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.filter(users, { 'age': 36, 'active': true });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.filter(users, ['active', false]);\n     * // => objects for ['fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.filter(users, 'active');\n     * // => objects for ['barney']\n     */\n    function filter(collection, predicate) {\n      var func = isArray(collection) ? arrayFilter : baseFilter;\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Iterates over elements of `collection`, returning the first element\n     * `predicate` returns truthy for. The predicate is invoked with three\n     * arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36, 'active': true },\n     *   { 'user': 'fred',    'age': 40, 'active': false },\n     *   { 'user': 'pebbles', 'age': 1,  'active': true }\n     * ];\n     *\n     * _.find(users, function(o) { return o.age < 40; });\n     * // => object for 'barney'\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.find(users, { 'age': 1, 'active': true });\n     * // => object for 'pebbles'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.find(users, ['active', false]);\n     * // => object for 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.find(users, 'active');\n     * // => object for 'barney'\n     */\n    var find = createFind(findIndex);\n\n    /**\n     * This method is like `_.find` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=collection.length-1] The index to search from.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * _.findLast([1, 2, 3, 4], function(n) {\n     *   return n % 2 == 1;\n     * });\n     * // => 3\n     */\n    var findLast = createFind(findLastIndex);\n\n    /**\n     * Creates a flattened array of values by running each element in `collection`\n     * thru `iteratee` and flattening the mapped results. The iteratee is invoked\n     * with three arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [n, n];\n     * }\n     *\n     * _.flatMap([1, 2], duplicate);\n     * // => [1, 1, 2, 2]\n     */\n    function flatMap(collection, iteratee) {\n      return baseFlatten(map(collection, iteratee), 1);\n    }\n\n    /**\n     * This method is like `_.flatMap` except that it recursively flattens the\n     * mapped results.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [[[n, n]]];\n     * }\n     *\n     * _.flatMapDeep([1, 2], duplicate);\n     * // => [1, 1, 2, 2]\n     */\n    function flatMapDeep(collection, iteratee) {\n      return baseFlatten(map(collection, iteratee), INFINITY);\n    }\n\n    /**\n     * This method is like `_.flatMap` except that it recursively flattens the\n     * mapped results up to `depth` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {number} [depth=1] The maximum recursion depth.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [[[n, n]]];\n     * }\n     *\n     * _.flatMapDepth([1, 2], duplicate, 2);\n     * // => [[1, 1], [2, 2]]\n     */\n    function flatMapDepth(collection, iteratee, depth) {\n      depth = depth === undefined$1 ? 1 : toInteger(depth);\n      return baseFlatten(map(collection, iteratee), depth);\n    }\n\n    /**\n     * Iterates over elements of `collection` and invokes `iteratee` for each element.\n     * The iteratee is invoked with three arguments: (value, index|key, collection).\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * **Note:** As with other \"Collections\" methods, objects with a \"length\"\n     * property are iterated like arrays. To avoid this behavior use `_.forIn`\n     * or `_.forOwn` for object iteration.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @alias each\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     * @see _.forEachRight\n     * @example\n     *\n     * _.forEach([1, 2], function(value) {\n     *   console.log(value);\n     * });\n     * // => Logs `1` then `2`.\n     *\n     * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n     */\n    function forEach(collection, iteratee) {\n      var func = isArray(collection) ? arrayEach : baseEach;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.forEach` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @alias eachRight\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     * @see _.forEach\n     * @example\n     *\n     * _.forEachRight([1, 2], function(value) {\n     *   console.log(value);\n     * });\n     * // => Logs `2` then `1`.\n     */\n    function forEachRight(collection, iteratee) {\n      var func = isArray(collection) ? arrayEachRight : baseEachRight;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The order of grouped values\n     * is determined by the order they occur in `collection`. The corresponding\n     * value of each key is an array of elements responsible for generating the\n     * key. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.groupBy([6.1, 4.2, 6.3], Math.floor);\n     * // => { '4': [4.2], '6': [6.1, 6.3] }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.groupBy(['one', 'two', 'three'], 'length');\n     * // => { '3': ['one', 'two'], '5': ['three'] }\n     */\n    var groupBy = createAggregator(function(result, value, key) {\n      if (hasOwnProperty.call(result, key)) {\n        result[key].push(value);\n      } else {\n        baseAssignValue(result, key, [value]);\n      }\n    });\n\n    /**\n     * Checks if `value` is in `collection`. If `collection` is a string, it's\n     * checked for a substring of `value`, otherwise\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * is used for equality comparisons. If `fromIndex` is negative, it's used as\n     * the offset from the end of `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n     * @returns {boolean} Returns `true` if `value` is found, else `false`.\n     * @example\n     *\n     * _.includes([1, 2, 3], 1);\n     * // => true\n     *\n     * _.includes([1, 2, 3], 1, 2);\n     * // => false\n     *\n     * _.includes({ 'a': 1, 'b': 2 }, 1);\n     * // => true\n     *\n     * _.includes('abcd', 'bc');\n     * // => true\n     */\n    function includes(collection, value, fromIndex, guard) {\n      collection = isArrayLike(collection) ? collection : values(collection);\n      fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;\n\n      var length = collection.length;\n      if (fromIndex < 0) {\n        fromIndex = nativeMax(length + fromIndex, 0);\n      }\n      return isString(collection)\n        ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)\n        : (!!length && baseIndexOf(collection, value, fromIndex) > -1);\n    }\n\n    /**\n     * Invokes the method at `path` of each element in `collection`, returning\n     * an array of the results of each invoked method. Any additional arguments\n     * are provided to each invoked method. If `path` is a function, it's invoked\n     * for, and `this` bound to, each element in `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Array|Function|string} path The path of the method to invoke or\n     *  the function invoked per iteration.\n     * @param {...*} [args] The arguments to invoke each method with.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');\n     * // => [[1, 5, 7], [1, 2, 3]]\n     *\n     * _.invokeMap([123, 456], String.prototype.split, '');\n     * // => [['1', '2', '3'], ['4', '5', '6']]\n     */\n    var invokeMap = baseRest(function(collection, path, args) {\n      var index = -1,\n          isFunc = typeof path == 'function',\n          result = isArrayLike(collection) ? Array(collection.length) : [];\n\n      baseEach(collection, function(value) {\n        result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);\n      });\n      return result;\n    });\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The corresponding value of\n     * each key is the last element responsible for generating the key. The\n     * iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * var array = [\n     *   { 'dir': 'left', 'code': 97 },\n     *   { 'dir': 'right', 'code': 100 }\n     * ];\n     *\n     * _.keyBy(array, function(o) {\n     *   return String.fromCharCode(o.code);\n     * });\n     * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }\n     *\n     * _.keyBy(array, 'dir');\n     * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }\n     */\n    var keyBy = createAggregator(function(result, value, key) {\n      baseAssignValue(result, key, value);\n    });\n\n    /**\n     * Creates an array of values by running each element in `collection` thru\n     * `iteratee`. The iteratee is invoked with three arguments:\n     * (value, index|key, collection).\n     *\n     * Many lodash methods are guarded to work as iteratees for methods like\n     * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.\n     *\n     * The guarded methods are:\n     * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,\n     * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,\n     * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,\n     * `template`, `trim`, `trimEnd`, `trimStart`, and `words`\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new mapped array.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * _.map([4, 8], square);\n     * // => [16, 64]\n     *\n     * _.map({ 'a': 4, 'b': 8 }, square);\n     * // => [16, 64] (iteration order is not guaranteed)\n     *\n     * var users = [\n     *   { 'user': 'barney' },\n     *   { 'user': 'fred' }\n     * ];\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.map(users, 'user');\n     * // => ['barney', 'fred']\n     */\n    function map(collection, iteratee) {\n      var func = isArray(collection) ? arrayMap : baseMap;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.sortBy` except that it allows specifying the sort\n     * orders of the iteratees to sort by. If `orders` is unspecified, all values\n     * are sorted in ascending order. Otherwise, specify an order of \"desc\" for\n     * descending or \"asc\" for ascending sort order of corresponding values.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]\n     *  The iteratees to sort by.\n     * @param {string[]} [orders] The sort orders of `iteratees`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'fred',   'age': 48 },\n     *   { 'user': 'barney', 'age': 34 },\n     *   { 'user': 'fred',   'age': 40 },\n     *   { 'user': 'barney', 'age': 36 }\n     * ];\n     *\n     * // Sort by `user` in ascending order and by `age` in descending order.\n     * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);\n     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n     */\n    function orderBy(collection, iteratees, orders, guard) {\n      if (collection == null) {\n        return [];\n      }\n      if (!isArray(iteratees)) {\n        iteratees = iteratees == null ? [] : [iteratees];\n      }\n      orders = guard ? undefined$1 : orders;\n      if (!isArray(orders)) {\n        orders = orders == null ? [] : [orders];\n      }\n      return baseOrderBy(collection, iteratees, orders);\n    }\n\n    /**\n     * Creates an array of elements split into two groups, the first of which\n     * contains elements `predicate` returns truthy for, the second of which\n     * contains elements `predicate` returns falsey for. The predicate is\n     * invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the array of grouped elements.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36, 'active': false },\n     *   { 'user': 'fred',    'age': 40, 'active': true },\n     *   { 'user': 'pebbles', 'age': 1,  'active': false }\n     * ];\n     *\n     * _.partition(users, function(o) { return o.active; });\n     * // => objects for [['fred'], ['barney', 'pebbles']]\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.partition(users, { 'age': 1, 'active': false });\n     * // => objects for [['pebbles'], ['barney', 'fred']]\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.partition(users, ['active', false]);\n     * // => objects for [['barney', 'pebbles'], ['fred']]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.partition(users, 'active');\n     * // => objects for [['fred'], ['barney', 'pebbles']]\n     */\n    var partition = createAggregator(function(result, value, key) {\n      result[key ? 0 : 1].push(value);\n    }, function() { return [[], []]; });\n\n    /**\n     * Reduces `collection` to a value which is the accumulated result of running\n     * each element in `collection` thru `iteratee`, where each successive\n     * invocation is supplied the return value of the previous. If `accumulator`\n     * is not given, the first element of `collection` is used as the initial\n     * value. The iteratee is invoked with four arguments:\n     * (accumulator, value, index|key, collection).\n     *\n     * Many lodash methods are guarded to work as iteratees for methods like\n     * `_.reduce`, `_.reduceRight`, and `_.transform`.\n     *\n     * The guarded methods are:\n     * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,\n     * and `sortBy`\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @returns {*} Returns the accumulated value.\n     * @see _.reduceRight\n     * @example\n     *\n     * _.reduce([1, 2], function(sum, n) {\n     *   return sum + n;\n     * }, 0);\n     * // => 3\n     *\n     * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n     *   (result[value] || (result[value] = [])).push(key);\n     *   return result;\n     * }, {});\n     * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)\n     */\n    function reduce(collection, iteratee, accumulator) {\n      var func = isArray(collection) ? arrayReduce : baseReduce,\n          initAccum = arguments.length < 3;\n\n      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);\n    }\n\n    /**\n     * This method is like `_.reduce` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @returns {*} Returns the accumulated value.\n     * @see _.reduce\n     * @example\n     *\n     * var array = [[0, 1], [2, 3], [4, 5]];\n     *\n     * _.reduceRight(array, function(flattened, other) {\n     *   return flattened.concat(other);\n     * }, []);\n     * // => [4, 5, 2, 3, 0, 1]\n     */\n    function reduceRight(collection, iteratee, accumulator) {\n      var func = isArray(collection) ? arrayReduceRight : baseReduce,\n          initAccum = arguments.length < 3;\n\n      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);\n    }\n\n    /**\n     * The opposite of `_.filter`; this method returns the elements of `collection`\n     * that `predicate` does **not** return truthy for.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     * @see _.filter\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': false },\n     *   { 'user': 'fred',   'age': 40, 'active': true }\n     * ];\n     *\n     * _.reject(users, function(o) { return !o.active; });\n     * // => objects for ['fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.reject(users, { 'age': 40, 'active': true });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.reject(users, ['active', false]);\n     * // => objects for ['fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.reject(users, 'active');\n     * // => objects for ['barney']\n     */\n    function reject(collection, predicate) {\n      var func = isArray(collection) ? arrayFilter : baseFilter;\n      return func(collection, negate(getIteratee(predicate, 3)));\n    }\n\n    /**\n     * Gets a random element from `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to sample.\n     * @returns {*} Returns the random element.\n     * @example\n     *\n     * _.sample([1, 2, 3, 4]);\n     * // => 2\n     */\n    function sample(collection) {\n      var func = isArray(collection) ? arraySample : baseSample;\n      return func(collection);\n    }\n\n    /**\n     * Gets `n` random elements at unique keys from `collection` up to the\n     * size of `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to sample.\n     * @param {number} [n=1] The number of elements to sample.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the random elements.\n     * @example\n     *\n     * _.sampleSize([1, 2, 3], 2);\n     * // => [3, 1]\n     *\n     * _.sampleSize([1, 2, 3], 4);\n     * // => [2, 3, 1]\n     */\n    function sampleSize(collection, n, guard) {\n      if ((guard ? isIterateeCall(collection, n, guard) : n === undefined$1)) {\n        n = 1;\n      } else {\n        n = toInteger(n);\n      }\n      var func = isArray(collection) ? arraySampleSize : baseSampleSize;\n      return func(collection, n);\n    }\n\n    /**\n     * Creates an array of shuffled values, using a version of the\n     * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     * @example\n     *\n     * _.shuffle([1, 2, 3, 4]);\n     * // => [4, 1, 3, 2]\n     */\n    function shuffle(collection) {\n      var func = isArray(collection) ? arrayShuffle : baseShuffle;\n      return func(collection);\n    }\n\n    /**\n     * Gets the size of `collection` by returning its length for array-like\n     * values or the number of own enumerable string keyed properties for objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to inspect.\n     * @returns {number} Returns the collection size.\n     * @example\n     *\n     * _.size([1, 2, 3]);\n     * // => 3\n     *\n     * _.size({ 'a': 1, 'b': 2 });\n     * // => 2\n     *\n     * _.size('pebbles');\n     * // => 7\n     */\n    function size(collection) {\n      if (collection == null) {\n        return 0;\n      }\n      if (isArrayLike(collection)) {\n        return isString(collection) ? stringSize(collection) : collection.length;\n      }\n      var tag = getTag(collection);\n      if (tag == mapTag || tag == setTag) {\n        return collection.size;\n      }\n      return baseKeys(collection).length;\n    }\n\n    /**\n     * Checks if `predicate` returns truthy for **any** element of `collection`.\n     * Iteration is stopped once `predicate` returns truthy. The predicate is\n     * invoked with three arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     * @example\n     *\n     * _.some([null, 0, 'yes', false], Boolean);\n     * // => true\n     *\n     * var users = [\n     *   { 'user': 'barney', 'active': true },\n     *   { 'user': 'fred',   'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.some(users, { 'user': 'barney', 'active': false });\n     * // => false\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.some(users, ['active', false]);\n     * // => true\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.some(users, 'active');\n     * // => true\n     */\n    function some(collection, predicate, guard) {\n      var func = isArray(collection) ? arraySome : baseSome;\n      if (guard && isIterateeCall(collection, predicate, guard)) {\n        predicate = undefined$1;\n      }\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Creates an array of elements, sorted in ascending order by the results of\n     * running each element in a collection thru each iteratee. This method\n     * performs a stable sort, that is, it preserves the original sort order of\n     * equal elements. The iteratees are invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {...(Function|Function[])} [iteratees=[_.identity]]\n     *  The iteratees to sort by.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'fred',   'age': 48 },\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 },\n     *   { 'user': 'barney', 'age': 34 }\n     * ];\n     *\n     * _.sortBy(users, [function(o) { return o.user; }]);\n     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n     *\n     * _.sortBy(users, ['user', 'age']);\n     * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]\n     */\n    var sortBy = baseRest(function(collection, iteratees) {\n      if (collection == null) {\n        return [];\n      }\n      var length = iteratees.length;\n      if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {\n        iteratees = [];\n      } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {\n        iteratees = [iteratees[0]];\n      }\n      return baseOrderBy(collection, baseFlatten(iteratees, 1), []);\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Gets the timestamp of the number of milliseconds that have elapsed since\n     * the Unix epoch (1 January 1970 00:00:00 UTC).\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Date\n     * @returns {number} Returns the timestamp.\n     * @example\n     *\n     * _.defer(function(stamp) {\n     *   console.log(_.now() - stamp);\n     * }, _.now());\n     * // => Logs the number of milliseconds it took for the deferred invocation.\n     */\n    var now = ctxNow || function() {\n      return root.Date.now();\n    };\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The opposite of `_.before`; this method creates a function that invokes\n     * `func` once it's called `n` or more times.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {number} n The number of calls before `func` is invoked.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var saves = ['profile', 'settings'];\n     *\n     * var done = _.after(saves.length, function() {\n     *   console.log('done saving!');\n     * });\n     *\n     * _.forEach(saves, function(type) {\n     *   asyncSave({ 'type': type, 'complete': done });\n     * });\n     * // => Logs 'done saving!' after the two async saves have completed.\n     */\n    function after(n, func) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      n = toInteger(n);\n      return function() {\n        if (--n < 1) {\n          return func.apply(this, arguments);\n        }\n      };\n    }\n\n    /**\n     * Creates a function that invokes `func`, with up to `n` arguments,\n     * ignoring any additional arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to cap arguments for.\n     * @param {number} [n=func.length] The arity cap.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new capped function.\n     * @example\n     *\n     * _.map(['6', '8', '10'], _.ary(parseInt, 1));\n     * // => [6, 8, 10]\n     */\n    function ary(func, n, guard) {\n      n = guard ? undefined$1 : n;\n      n = (func && n == null) ? func.length : n;\n      return createWrap(func, WRAP_ARY_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, n);\n    }\n\n    /**\n     * Creates a function that invokes `func`, with the `this` binding and arguments\n     * of the created function, while it's called less than `n` times. Subsequent\n     * calls to the created function return the result of the last `func` invocation.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {number} n The number of calls at which `func` is no longer invoked.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * jQuery(element).on('click', _.before(5, addContactToList));\n     * // => Allows adding up to 4 contacts to the list.\n     */\n    function before(n, func) {\n      var result;\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      n = toInteger(n);\n      return function() {\n        if (--n > 0) {\n          result = func.apply(this, arguments);\n        }\n        if (n <= 1) {\n          func = undefined$1;\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of `thisArg`\n     * and `partials` prepended to the arguments it receives.\n     *\n     * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,\n     * may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** Unlike native `Function#bind`, this method doesn't set the \"length\"\n     * property of bound functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to bind.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * function greet(greeting, punctuation) {\n     *   return greeting + ' ' + this.user + punctuation;\n     * }\n     *\n     * var object = { 'user': 'fred' };\n     *\n     * var bound = _.bind(greet, object, 'hi');\n     * bound('!');\n     * // => 'hi fred!'\n     *\n     * // Bound with placeholders.\n     * var bound = _.bind(greet, object, _, '!');\n     * bound('hi');\n     * // => 'hi fred!'\n     */\n    var bind = baseRest(function(func, thisArg, partials) {\n      var bitmask = WRAP_BIND_FLAG;\n      if (partials.length) {\n        var holders = replaceHolders(partials, getHolder(bind));\n        bitmask |= WRAP_PARTIAL_FLAG;\n      }\n      return createWrap(func, bitmask, thisArg, partials, holders);\n    });\n\n    /**\n     * Creates a function that invokes the method at `object[key]` with `partials`\n     * prepended to the arguments it receives.\n     *\n     * This method differs from `_.bind` by allowing bound functions to reference\n     * methods that may be redefined or don't yet exist. See\n     * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)\n     * for more details.\n     *\n     * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.10.0\n     * @category Function\n     * @param {Object} object The object to invoke the method on.\n     * @param {string} key The key of the method.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * var object = {\n     *   'user': 'fred',\n     *   'greet': function(greeting, punctuation) {\n     *     return greeting + ' ' + this.user + punctuation;\n     *   }\n     * };\n     *\n     * var bound = _.bindKey(object, 'greet', 'hi');\n     * bound('!');\n     * // => 'hi fred!'\n     *\n     * object.greet = function(greeting, punctuation) {\n     *   return greeting + 'ya ' + this.user + punctuation;\n     * };\n     *\n     * bound('!');\n     * // => 'hiya fred!'\n     *\n     * // Bound with placeholders.\n     * var bound = _.bindKey(object, 'greet', _, '!');\n     * bound('hi');\n     * // => 'hiya fred!'\n     */\n    var bindKey = baseRest(function(object, key, partials) {\n      var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;\n      if (partials.length) {\n        var holders = replaceHolders(partials, getHolder(bindKey));\n        bitmask |= WRAP_PARTIAL_FLAG;\n      }\n      return createWrap(key, bitmask, object, partials, holders);\n    });\n\n    /**\n     * Creates a function that accepts arguments of `func` and either invokes\n     * `func` returning its result, if at least `arity` number of arguments have\n     * been provided, or returns a function that accepts the remaining `func`\n     * arguments, and so on. The arity of `func` may be specified if `func.length`\n     * is not sufficient.\n     *\n     * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,\n     * may be used as a placeholder for provided arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of curried functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Function\n     * @param {Function} func The function to curry.\n     * @param {number} [arity=func.length] The arity of `func`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new curried function.\n     * @example\n     *\n     * var abc = function(a, b, c) {\n     *   return [a, b, c];\n     * };\n     *\n     * var curried = _.curry(abc);\n     *\n     * curried(1)(2)(3);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2)(3);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2, 3);\n     * // => [1, 2, 3]\n     *\n     * // Curried with placeholders.\n     * curried(1)(_, 3)(2);\n     * // => [1, 2, 3]\n     */\n    function curry(func, arity, guard) {\n      arity = guard ? undefined$1 : arity;\n      var result = createWrap(func, WRAP_CURRY_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, undefined$1, arity);\n      result.placeholder = curry.placeholder;\n      return result;\n    }\n\n    /**\n     * This method is like `_.curry` except that arguments are applied to `func`\n     * in the manner of `_.partialRight` instead of `_.partial`.\n     *\n     * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for provided arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of curried functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to curry.\n     * @param {number} [arity=func.length] The arity of `func`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new curried function.\n     * @example\n     *\n     * var abc = function(a, b, c) {\n     *   return [a, b, c];\n     * };\n     *\n     * var curried = _.curryRight(abc);\n     *\n     * curried(3)(2)(1);\n     * // => [1, 2, 3]\n     *\n     * curried(2, 3)(1);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2, 3);\n     * // => [1, 2, 3]\n     *\n     * // Curried with placeholders.\n     * curried(3)(1, _)(2);\n     * // => [1, 2, 3]\n     */\n    function curryRight(func, arity, guard) {\n      arity = guard ? undefined$1 : arity;\n      var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, undefined$1, arity);\n      result.placeholder = curryRight.placeholder;\n      return result;\n    }\n\n    /**\n     * Creates a debounced function that delays invoking `func` until after `wait`\n     * milliseconds have elapsed since the last time the debounced function was\n     * invoked. The debounced function comes with a `cancel` method to cancel\n     * delayed `func` invocations and a `flush` method to immediately invoke them.\n     * Provide `options` to indicate whether `func` should be invoked on the\n     * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n     * with the last arguments provided to the debounced function. Subsequent\n     * calls to the debounced function return the result of the last `func`\n     * invocation.\n     *\n     * **Note:** If `leading` and `trailing` options are `true`, `func` is\n     * invoked on the trailing edge of the timeout only if the debounced function\n     * is invoked more than once during the `wait` timeout.\n     *\n     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n     * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n     *\n     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n     * for details over the differences between `_.debounce` and `_.throttle`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to debounce.\n     * @param {number} [wait=0] The number of milliseconds to delay.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.leading=false]\n     *  Specify invoking on the leading edge of the timeout.\n     * @param {number} [options.maxWait]\n     *  The maximum time `func` is allowed to be delayed before it's invoked.\n     * @param {boolean} [options.trailing=true]\n     *  Specify invoking on the trailing edge of the timeout.\n     * @returns {Function} Returns the new debounced function.\n     * @example\n     *\n     * // Avoid costly calculations while the window size is in flux.\n     * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n     *\n     * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n     * jQuery(element).on('click', _.debounce(sendMail, 300, {\n     *   'leading': true,\n     *   'trailing': false\n     * }));\n     *\n     * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n     * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n     * var source = new EventSource('/stream');\n     * jQuery(source).on('message', debounced);\n     *\n     * // Cancel the trailing debounced invocation.\n     * jQuery(window).on('popstate', debounced.cancel);\n     */\n    function debounce(func, wait, options) {\n      var lastArgs,\n          lastThis,\n          maxWait,\n          result,\n          timerId,\n          lastCallTime,\n          lastInvokeTime = 0,\n          leading = false,\n          maxing = false,\n          trailing = true;\n\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      wait = toNumber(wait) || 0;\n      if (isObject(options)) {\n        leading = !!options.leading;\n        maxing = 'maxWait' in options;\n        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n        trailing = 'trailing' in options ? !!options.trailing : trailing;\n      }\n\n      function invokeFunc(time) {\n        var args = lastArgs,\n            thisArg = lastThis;\n\n        lastArgs = lastThis = undefined$1;\n        lastInvokeTime = time;\n        result = func.apply(thisArg, args);\n        return result;\n      }\n\n      function leadingEdge(time) {\n        // Reset any `maxWait` timer.\n        lastInvokeTime = time;\n        // Start the timer for the trailing edge.\n        timerId = setTimeout(timerExpired, wait);\n        // Invoke the leading edge.\n        return leading ? invokeFunc(time) : result;\n      }\n\n      function remainingWait(time) {\n        var timeSinceLastCall = time - lastCallTime,\n            timeSinceLastInvoke = time - lastInvokeTime,\n            timeWaiting = wait - timeSinceLastCall;\n\n        return maxing\n          ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n          : timeWaiting;\n      }\n\n      function shouldInvoke(time) {\n        var timeSinceLastCall = time - lastCallTime,\n            timeSinceLastInvoke = time - lastInvokeTime;\n\n        // Either this is the first call, activity has stopped and we're at the\n        // trailing edge, the system time has gone backwards and we're treating\n        // it as the trailing edge, or we've hit the `maxWait` limit.\n        return (lastCallTime === undefined$1 || (timeSinceLastCall >= wait) ||\n          (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n      }\n\n      function timerExpired() {\n        var time = now();\n        if (shouldInvoke(time)) {\n          return trailingEdge(time);\n        }\n        // Restart the timer.\n        timerId = setTimeout(timerExpired, remainingWait(time));\n      }\n\n      function trailingEdge(time) {\n        timerId = undefined$1;\n\n        // Only invoke if we have `lastArgs` which means `func` has been\n        // debounced at least once.\n        if (trailing && lastArgs) {\n          return invokeFunc(time);\n        }\n        lastArgs = lastThis = undefined$1;\n        return result;\n      }\n\n      function cancel() {\n        if (timerId !== undefined$1) {\n          clearTimeout(timerId);\n        }\n        lastInvokeTime = 0;\n        lastArgs = lastCallTime = lastThis = timerId = undefined$1;\n      }\n\n      function flush() {\n        return timerId === undefined$1 ? result : trailingEdge(now());\n      }\n\n      function debounced() {\n        var time = now(),\n            isInvoking = shouldInvoke(time);\n\n        lastArgs = arguments;\n        lastThis = this;\n        lastCallTime = time;\n\n        if (isInvoking) {\n          if (timerId === undefined$1) {\n            return leadingEdge(lastCallTime);\n          }\n          if (maxing) {\n            // Handle invocations in a tight loop.\n            clearTimeout(timerId);\n            timerId = setTimeout(timerExpired, wait);\n            return invokeFunc(lastCallTime);\n          }\n        }\n        if (timerId === undefined$1) {\n          timerId = setTimeout(timerExpired, wait);\n        }\n        return result;\n      }\n      debounced.cancel = cancel;\n      debounced.flush = flush;\n      return debounced;\n    }\n\n    /**\n     * Defers invoking the `func` until the current call stack has cleared. Any\n     * additional arguments are provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to defer.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {number} Returns the timer id.\n     * @example\n     *\n     * _.defer(function(text) {\n     *   console.log(text);\n     * }, 'deferred');\n     * // => Logs 'deferred' after one millisecond.\n     */\n    var defer = baseRest(function(func, args) {\n      return baseDelay(func, 1, args);\n    });\n\n    /**\n     * Invokes `func` after `wait` milliseconds. Any additional arguments are\n     * provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {number} Returns the timer id.\n     * @example\n     *\n     * _.delay(function(text) {\n     *   console.log(text);\n     * }, 1000, 'later');\n     * // => Logs 'later' after one second.\n     */\n    var delay = baseRest(function(func, wait, args) {\n      return baseDelay(func, toNumber(wait) || 0, args);\n    });\n\n    /**\n     * Creates a function that invokes `func` with arguments reversed.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to flip arguments for.\n     * @returns {Function} Returns the new flipped function.\n     * @example\n     *\n     * var flipped = _.flip(function() {\n     *   return _.toArray(arguments);\n     * });\n     *\n     * flipped('a', 'b', 'c', 'd');\n     * // => ['d', 'c', 'b', 'a']\n     */\n    function flip(func) {\n      return createWrap(func, WRAP_FLIP_FLAG);\n    }\n\n    /**\n     * Creates a function that memoizes the result of `func`. If `resolver` is\n     * provided, it determines the cache key for storing the result based on the\n     * arguments provided to the memoized function. By default, the first argument\n     * provided to the memoized function is used as the map cache key. The `func`\n     * is invoked with the `this` binding of the memoized function.\n     *\n     * **Note:** The cache is exposed as the `cache` property on the memoized\n     * function. Its creation may be customized by replacing the `_.memoize.Cache`\n     * constructor with one whose instances implement the\n     * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n     * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to have its output memoized.\n     * @param {Function} [resolver] The function to resolve the cache key.\n     * @returns {Function} Returns the new memoized function.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     * var other = { 'c': 3, 'd': 4 };\n     *\n     * var values = _.memoize(_.values);\n     * values(object);\n     * // => [1, 2]\n     *\n     * values(other);\n     * // => [3, 4]\n     *\n     * object.a = 2;\n     * values(object);\n     * // => [1, 2]\n     *\n     * // Modify the result cache.\n     * values.cache.set(object, ['a', 'b']);\n     * values(object);\n     * // => ['a', 'b']\n     *\n     * // Replace `_.memoize.Cache`.\n     * _.memoize.Cache = WeakMap;\n     */\n    function memoize(func, resolver) {\n      if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var memoized = function() {\n        var args = arguments,\n            key = resolver ? resolver.apply(this, args) : args[0],\n            cache = memoized.cache;\n\n        if (cache.has(key)) {\n          return cache.get(key);\n        }\n        var result = func.apply(this, args);\n        memoized.cache = cache.set(key, result) || cache;\n        return result;\n      };\n      memoized.cache = new (memoize.Cache || MapCache);\n      return memoized;\n    }\n\n    // Expose `MapCache`.\n    memoize.Cache = MapCache;\n\n    /**\n     * Creates a function that negates the result of the predicate `func`. The\n     * `func` predicate is invoked with the `this` binding and arguments of the\n     * created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} predicate The predicate to negate.\n     * @returns {Function} Returns the new negated function.\n     * @example\n     *\n     * function isEven(n) {\n     *   return n % 2 == 0;\n     * }\n     *\n     * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));\n     * // => [1, 3, 5]\n     */\n    function negate(predicate) {\n      if (typeof predicate != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return function() {\n        var args = arguments;\n        switch (args.length) {\n          case 0: return !predicate.call(this);\n          case 1: return !predicate.call(this, args[0]);\n          case 2: return !predicate.call(this, args[0], args[1]);\n          case 3: return !predicate.call(this, args[0], args[1], args[2]);\n        }\n        return !predicate.apply(this, args);\n      };\n    }\n\n    /**\n     * Creates a function that is restricted to invoking `func` once. Repeat calls\n     * to the function return the value of the first invocation. The `func` is\n     * invoked with the `this` binding and arguments of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var initialize = _.once(createApplication);\n     * initialize();\n     * initialize();\n     * // => `createApplication` is invoked once\n     */\n    function once(func) {\n      return before(2, func);\n    }\n\n    /**\n     * Creates a function that invokes `func` with its arguments transformed.\n     *\n     * @static\n     * @since 4.0.0\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to wrap.\n     * @param {...(Function|Function[])} [transforms=[_.identity]]\n     *  The argument transforms.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * function doubled(n) {\n     *   return n * 2;\n     * }\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var func = _.overArgs(function(x, y) {\n     *   return [x, y];\n     * }, [square, doubled]);\n     *\n     * func(9, 3);\n     * // => [81, 6]\n     *\n     * func(10, 5);\n     * // => [100, 10]\n     */\n    var overArgs = castRest(function(func, transforms) {\n      transforms = (transforms.length == 1 && isArray(transforms[0]))\n        ? arrayMap(transforms[0], baseUnary(getIteratee()))\n        : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));\n\n      var funcsLength = transforms.length;\n      return baseRest(function(args) {\n        var index = -1,\n            length = nativeMin(args.length, funcsLength);\n\n        while (++index < length) {\n          args[index] = transforms[index].call(this, args[index]);\n        }\n        return apply(func, this, args);\n      });\n    });\n\n    /**\n     * Creates a function that invokes `func` with `partials` prepended to the\n     * arguments it receives. This method is like `_.bind` except it does **not**\n     * alter the `this` binding.\n     *\n     * The `_.partial.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of partially\n     * applied functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.2.0\n     * @category Function\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * function greet(greeting, name) {\n     *   return greeting + ' ' + name;\n     * }\n     *\n     * var sayHelloTo = _.partial(greet, 'hello');\n     * sayHelloTo('fred');\n     * // => 'hello fred'\n     *\n     * // Partially applied with placeholders.\n     * var greetFred = _.partial(greet, _, 'fred');\n     * greetFred('hi');\n     * // => 'hi fred'\n     */\n    var partial = baseRest(function(func, partials) {\n      var holders = replaceHolders(partials, getHolder(partial));\n      return createWrap(func, WRAP_PARTIAL_FLAG, undefined$1, partials, holders);\n    });\n\n    /**\n     * This method is like `_.partial` except that partially applied arguments\n     * are appended to the arguments it receives.\n     *\n     * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of partially\n     * applied functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Function\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * function greet(greeting, name) {\n     *   return greeting + ' ' + name;\n     * }\n     *\n     * var greetFred = _.partialRight(greet, 'fred');\n     * greetFred('hi');\n     * // => 'hi fred'\n     *\n     * // Partially applied with placeholders.\n     * var sayHelloTo = _.partialRight(greet, 'hello', _);\n     * sayHelloTo('fred');\n     * // => 'hello fred'\n     */\n    var partialRight = baseRest(function(func, partials) {\n      var holders = replaceHolders(partials, getHolder(partialRight));\n      return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined$1, partials, holders);\n    });\n\n    /**\n     * Creates a function that invokes `func` with arguments arranged according\n     * to the specified `indexes` where the argument value at the first index is\n     * provided as the first argument, the argument value at the second index is\n     * provided as the second argument, and so on.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to rearrange arguments for.\n     * @param {...(number|number[])} indexes The arranged argument indexes.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var rearged = _.rearg(function(a, b, c) {\n     *   return [a, b, c];\n     * }, [2, 0, 1]);\n     *\n     * rearged('b', 'c', 'a')\n     * // => ['a', 'b', 'c']\n     */\n    var rearg = flatRest(function(func, indexes) {\n      return createWrap(func, WRAP_REARG_FLAG, undefined$1, undefined$1, undefined$1, indexes);\n    });\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of the\n     * created function and arguments from `start` and beyond provided as\n     * an array.\n     *\n     * **Note:** This method is based on the\n     * [rest parameter](https://mdn.io/rest_parameters).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to apply a rest parameter to.\n     * @param {number} [start=func.length-1] The start position of the rest parameter.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var say = _.rest(function(what, names) {\n     *   return what + ' ' + _.initial(names).join(', ') +\n     *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);\n     * });\n     *\n     * say('hello', 'fred', 'barney', 'pebbles');\n     * // => 'hello fred, barney, & pebbles'\n     */\n    function rest(func, start) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      start = start === undefined$1 ? start : toInteger(start);\n      return baseRest(func, start);\n    }\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of the\n     * create function and an array of arguments much like\n     * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).\n     *\n     * **Note:** This method is based on the\n     * [spread operator](https://mdn.io/spread_operator).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Function\n     * @param {Function} func The function to spread arguments over.\n     * @param {number} [start=0] The start position of the spread.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var say = _.spread(function(who, what) {\n     *   return who + ' says ' + what;\n     * });\n     *\n     * say(['fred', 'hello']);\n     * // => 'fred says hello'\n     *\n     * var numbers = Promise.all([\n     *   Promise.resolve(40),\n     *   Promise.resolve(36)\n     * ]);\n     *\n     * numbers.then(_.spread(function(x, y) {\n     *   return x + y;\n     * }));\n     * // => a Promise of 76\n     */\n    function spread(func, start) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      start = start == null ? 0 : nativeMax(toInteger(start), 0);\n      return baseRest(function(args) {\n        var array = args[start],\n            otherArgs = castSlice(args, 0, start);\n\n        if (array) {\n          arrayPush(otherArgs, array);\n        }\n        return apply(func, this, otherArgs);\n      });\n    }\n\n    /**\n     * Creates a throttled function that only invokes `func` at most once per\n     * every `wait` milliseconds. The throttled function comes with a `cancel`\n     * method to cancel delayed `func` invocations and a `flush` method to\n     * immediately invoke them. Provide `options` to indicate whether `func`\n     * should be invoked on the leading and/or trailing edge of the `wait`\n     * timeout. The `func` is invoked with the last arguments provided to the\n     * throttled function. Subsequent calls to the throttled function return the\n     * result of the last `func` invocation.\n     *\n     * **Note:** If `leading` and `trailing` options are `true`, `func` is\n     * invoked on the trailing edge of the timeout only if the throttled function\n     * is invoked more than once during the `wait` timeout.\n     *\n     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n     * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n     *\n     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n     * for details over the differences between `_.throttle` and `_.debounce`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to throttle.\n     * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.leading=true]\n     *  Specify invoking on the leading edge of the timeout.\n     * @param {boolean} [options.trailing=true]\n     *  Specify invoking on the trailing edge of the timeout.\n     * @returns {Function} Returns the new throttled function.\n     * @example\n     *\n     * // Avoid excessively updating the position while scrolling.\n     * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n     *\n     * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n     * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n     * jQuery(element).on('click', throttled);\n     *\n     * // Cancel the trailing throttled invocation.\n     * jQuery(window).on('popstate', throttled.cancel);\n     */\n    function throttle(func, wait, options) {\n      var leading = true,\n          trailing = true;\n\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      if (isObject(options)) {\n        leading = 'leading' in options ? !!options.leading : leading;\n        trailing = 'trailing' in options ? !!options.trailing : trailing;\n      }\n      return debounce(func, wait, {\n        'leading': leading,\n        'maxWait': wait,\n        'trailing': trailing\n      });\n    }\n\n    /**\n     * Creates a function that accepts up to one argument, ignoring any\n     * additional arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to cap arguments for.\n     * @returns {Function} Returns the new capped function.\n     * @example\n     *\n     * _.map(['6', '8', '10'], _.unary(parseInt));\n     * // => [6, 8, 10]\n     */\n    function unary(func) {\n      return ary(func, 1);\n    }\n\n    /**\n     * Creates a function that provides `value` to `wrapper` as its first\n     * argument. Any additional arguments provided to the function are appended\n     * to those provided to the `wrapper`. The wrapper is invoked with the `this`\n     * binding of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {*} value The value to wrap.\n     * @param {Function} [wrapper=identity] The wrapper function.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var p = _.wrap(_.escape, function(func, text) {\n     *   return '<p>' + func(text) + '</p>';\n     * });\n     *\n     * p('fred, barney, & pebbles');\n     * // => '<p>fred, barney, &amp; pebbles</p>'\n     */\n    function wrap(value, wrapper) {\n      return partial(castFunction(wrapper), value);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Casts `value` as an array if it's not one.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.4.0\n     * @category Lang\n     * @param {*} value The value to inspect.\n     * @returns {Array} Returns the cast array.\n     * @example\n     *\n     * _.castArray(1);\n     * // => [1]\n     *\n     * _.castArray({ 'a': 1 });\n     * // => [{ 'a': 1 }]\n     *\n     * _.castArray('abc');\n     * // => ['abc']\n     *\n     * _.castArray(null);\n     * // => [null]\n     *\n     * _.castArray(undefined);\n     * // => [undefined]\n     *\n     * _.castArray();\n     * // => []\n     *\n     * var array = [1, 2, 3];\n     * console.log(_.castArray(array) === array);\n     * // => true\n     */\n    function castArray() {\n      if (!arguments.length) {\n        return [];\n      }\n      var value = arguments[0];\n      return isArray(value) ? value : [value];\n    }\n\n    /**\n     * Creates a shallow clone of `value`.\n     *\n     * **Note:** This method is loosely based on the\n     * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)\n     * and supports cloning arrays, array buffers, booleans, date objects, maps,\n     * numbers, `Object` objects, regexes, sets, strings, symbols, and typed\n     * arrays. The own enumerable properties of `arguments` objects are cloned\n     * as plain objects. An empty object is returned for uncloneable values such\n     * as error objects, functions, DOM nodes, and WeakMaps.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @returns {*} Returns the cloned value.\n     * @see _.cloneDeep\n     * @example\n     *\n     * var objects = [{ 'a': 1 }, { 'b': 2 }];\n     *\n     * var shallow = _.clone(objects);\n     * console.log(shallow[0] === objects[0]);\n     * // => true\n     */\n    function clone(value) {\n      return baseClone(value, CLONE_SYMBOLS_FLAG);\n    }\n\n    /**\n     * This method is like `_.clone` except that it accepts `customizer` which\n     * is invoked to produce the cloned value. If `customizer` returns `undefined`,\n     * cloning is handled by the method instead. The `customizer` is invoked with\n     * up to four arguments; (value [, index|key, object, stack]).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @param {Function} [customizer] The function to customize cloning.\n     * @returns {*} Returns the cloned value.\n     * @see _.cloneDeepWith\n     * @example\n     *\n     * function customizer(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(false);\n     *   }\n     * }\n     *\n     * var el = _.cloneWith(document.body, customizer);\n     *\n     * console.log(el === document.body);\n     * // => false\n     * console.log(el.nodeName);\n     * // => 'BODY'\n     * console.log(el.childNodes.length);\n     * // => 0\n     */\n    function cloneWith(value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined$1;\n      return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);\n    }\n\n    /**\n     * This method is like `_.clone` except that it recursively clones `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Lang\n     * @param {*} value The value to recursively clone.\n     * @returns {*} Returns the deep cloned value.\n     * @see _.clone\n     * @example\n     *\n     * var objects = [{ 'a': 1 }, { 'b': 2 }];\n     *\n     * var deep = _.cloneDeep(objects);\n     * console.log(deep[0] === objects[0]);\n     * // => false\n     */\n    function cloneDeep(value) {\n      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n    }\n\n    /**\n     * This method is like `_.cloneWith` except that it recursively clones `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to recursively clone.\n     * @param {Function} [customizer] The function to customize cloning.\n     * @returns {*} Returns the deep cloned value.\n     * @see _.cloneWith\n     * @example\n     *\n     * function customizer(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(true);\n     *   }\n     * }\n     *\n     * var el = _.cloneDeepWith(document.body, customizer);\n     *\n     * console.log(el === document.body);\n     * // => false\n     * console.log(el.nodeName);\n     * // => 'BODY'\n     * console.log(el.childNodes.length);\n     * // => 20\n     */\n    function cloneDeepWith(value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined$1;\n      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);\n    }\n\n    /**\n     * Checks if `object` conforms to `source` by invoking the predicate\n     * properties of `source` with the corresponding property values of `object`.\n     *\n     * **Note:** This method is equivalent to `_.conforms` when `source` is\n     * partially applied.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.14.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     *\n     * _.conformsTo(object, { 'b': function(n) { return n > 1; } });\n     * // => true\n     *\n     * _.conformsTo(object, { 'b': function(n) { return n > 2; } });\n     * // => false\n     */\n    function conformsTo(object, source) {\n      return source == null || baseConformsTo(object, source, keys(source));\n    }\n\n    /**\n     * Performs a\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * comparison between two values to determine if they are equivalent.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     * var other = { 'a': 1 };\n     *\n     * _.eq(object, object);\n     * // => true\n     *\n     * _.eq(object, other);\n     * // => false\n     *\n     * _.eq('a', 'a');\n     * // => true\n     *\n     * _.eq('a', Object('a'));\n     * // => false\n     *\n     * _.eq(NaN, NaN);\n     * // => true\n     */\n    function eq(value, other) {\n      return value === other || (value !== value && other !== other);\n    }\n\n    /**\n     * Checks if `value` is greater than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than `other`,\n     *  else `false`.\n     * @see _.lt\n     * @example\n     *\n     * _.gt(3, 1);\n     * // => true\n     *\n     * _.gt(3, 3);\n     * // => false\n     *\n     * _.gt(1, 3);\n     * // => false\n     */\n    var gt = createRelationalOperation(baseGt);\n\n    /**\n     * Checks if `value` is greater than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than or equal to\n     *  `other`, else `false`.\n     * @see _.lte\n     * @example\n     *\n     * _.gte(3, 1);\n     * // => true\n     *\n     * _.gte(3, 3);\n     * // => true\n     *\n     * _.gte(1, 3);\n     * // => false\n     */\n    var gte = createRelationalOperation(function(value, other) {\n      return value >= other;\n    });\n\n    /**\n     * Checks if `value` is likely an `arguments` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n     *  else `false`.\n     * @example\n     *\n     * _.isArguments(function() { return arguments; }());\n     * // => true\n     *\n     * _.isArguments([1, 2, 3]);\n     * // => false\n     */\n    var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n      return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n        !propertyIsEnumerable.call(value, 'callee');\n    };\n\n    /**\n     * Checks if `value` is classified as an `Array` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n     * @example\n     *\n     * _.isArray([1, 2, 3]);\n     * // => true\n     *\n     * _.isArray(document.body.children);\n     * // => false\n     *\n     * _.isArray('abc');\n     * // => false\n     *\n     * _.isArray(_.noop);\n     * // => false\n     */\n    var isArray = Array.isArray;\n\n    /**\n     * Checks if `value` is classified as an `ArrayBuffer` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n     * @example\n     *\n     * _.isArrayBuffer(new ArrayBuffer(2));\n     * // => true\n     *\n     * _.isArrayBuffer(new Array(2));\n     * // => false\n     */\n    var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;\n\n    /**\n     * Checks if `value` is array-like. A value is considered array-like if it's\n     * not a function and has a `value.length` that's an integer greater than or\n     * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n     * @example\n     *\n     * _.isArrayLike([1, 2, 3]);\n     * // => true\n     *\n     * _.isArrayLike(document.body.children);\n     * // => true\n     *\n     * _.isArrayLike('abc');\n     * // => true\n     *\n     * _.isArrayLike(_.noop);\n     * // => false\n     */\n    function isArrayLike(value) {\n      return value != null && isLength(value.length) && !isFunction(value);\n    }\n\n    /**\n     * This method is like `_.isArrayLike` except that it also checks if `value`\n     * is an object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array-like object,\n     *  else `false`.\n     * @example\n     *\n     * _.isArrayLikeObject([1, 2, 3]);\n     * // => true\n     *\n     * _.isArrayLikeObject(document.body.children);\n     * // => true\n     *\n     * _.isArrayLikeObject('abc');\n     * // => false\n     *\n     * _.isArrayLikeObject(_.noop);\n     * // => false\n     */\n    function isArrayLikeObject(value) {\n      return isObjectLike(value) && isArrayLike(value);\n    }\n\n    /**\n     * Checks if `value` is classified as a boolean primitive or object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.\n     * @example\n     *\n     * _.isBoolean(false);\n     * // => true\n     *\n     * _.isBoolean(null);\n     * // => false\n     */\n    function isBoolean(value) {\n      return value === true || value === false ||\n        (isObjectLike(value) && baseGetTag(value) == boolTag);\n    }\n\n    /**\n     * Checks if `value` is a buffer.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n     * @example\n     *\n     * _.isBuffer(new Buffer(2));\n     * // => true\n     *\n     * _.isBuffer(new Uint8Array(2));\n     * // => false\n     */\n    var isBuffer = nativeIsBuffer || stubFalse;\n\n    /**\n     * Checks if `value` is classified as a `Date` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n     * @example\n     *\n     * _.isDate(new Date);\n     * // => true\n     *\n     * _.isDate('Mon April 23 2012');\n     * // => false\n     */\n    var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;\n\n    /**\n     * Checks if `value` is likely a DOM element.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.\n     * @example\n     *\n     * _.isElement(document.body);\n     * // => true\n     *\n     * _.isElement('<body>');\n     * // => false\n     */\n    function isElement(value) {\n      return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);\n    }\n\n    /**\n     * Checks if `value` is an empty object, collection, map, or set.\n     *\n     * Objects are considered empty if they have no own enumerable string keyed\n     * properties.\n     *\n     * Array-like values such as `arguments` objects, arrays, buffers, strings, or\n     * jQuery-like collections are considered empty if they have a `length` of `0`.\n     * Similarly, maps and sets are considered empty if they have a `size` of `0`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is empty, else `false`.\n     * @example\n     *\n     * _.isEmpty(null);\n     * // => true\n     *\n     * _.isEmpty(true);\n     * // => true\n     *\n     * _.isEmpty(1);\n     * // => true\n     *\n     * _.isEmpty([1, 2, 3]);\n     * // => false\n     *\n     * _.isEmpty({ 'a': 1 });\n     * // => false\n     */\n    function isEmpty(value) {\n      if (value == null) {\n        return true;\n      }\n      if (isArrayLike(value) &&\n          (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||\n            isBuffer(value) || isTypedArray(value) || isArguments(value))) {\n        return !value.length;\n      }\n      var tag = getTag(value);\n      if (tag == mapTag || tag == setTag) {\n        return !value.size;\n      }\n      if (isPrototype(value)) {\n        return !baseKeys(value).length;\n      }\n      for (var key in value) {\n        if (hasOwnProperty.call(value, key)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * Performs a deep comparison between two values to determine if they are\n     * equivalent.\n     *\n     * **Note:** This method supports comparing arrays, array buffers, booleans,\n     * date objects, error objects, maps, numbers, `Object` objects, regexes,\n     * sets, strings, symbols, and typed arrays. `Object` objects are compared\n     * by their own, not inherited, enumerable properties. Functions and DOM\n     * nodes are compared by strict equality, i.e. `===`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     * var other = { 'a': 1 };\n     *\n     * _.isEqual(object, other);\n     * // => true\n     *\n     * object === other;\n     * // => false\n     */\n    function isEqual(value, other) {\n      return baseIsEqual(value, other);\n    }\n\n    /**\n     * This method is like `_.isEqual` except that it accepts `customizer` which\n     * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n     * are handled by the method instead. The `customizer` is invoked with up to\n     * six arguments: (objValue, othValue [, index|key, object, other, stack]).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * function isGreeting(value) {\n     *   return /^h(?:i|ello)$/.test(value);\n     * }\n     *\n     * function customizer(objValue, othValue) {\n     *   if (isGreeting(objValue) && isGreeting(othValue)) {\n     *     return true;\n     *   }\n     * }\n     *\n     * var array = ['hello', 'goodbye'];\n     * var other = ['hi', 'goodbye'];\n     *\n     * _.isEqualWith(array, other, customizer);\n     * // => true\n     */\n    function isEqualWith(value, other, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined$1;\n      var result = customizer ? customizer(value, other) : undefined$1;\n      return result === undefined$1 ? baseIsEqual(value, other, undefined$1, customizer) : !!result;\n    }\n\n    /**\n     * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,\n     * `SyntaxError`, `TypeError`, or `URIError` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an error object, else `false`.\n     * @example\n     *\n     * _.isError(new Error);\n     * // => true\n     *\n     * _.isError(Error);\n     * // => false\n     */\n    function isError(value) {\n      if (!isObjectLike(value)) {\n        return false;\n      }\n      var tag = baseGetTag(value);\n      return tag == errorTag || tag == domExcTag ||\n        (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));\n    }\n\n    /**\n     * Checks if `value` is a finite primitive number.\n     *\n     * **Note:** This method is based on\n     * [`Number.isFinite`](https://mdn.io/Number/isFinite).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.\n     * @example\n     *\n     * _.isFinite(3);\n     * // => true\n     *\n     * _.isFinite(Number.MIN_VALUE);\n     * // => true\n     *\n     * _.isFinite(Infinity);\n     * // => false\n     *\n     * _.isFinite('3');\n     * // => false\n     */\n    function isFinite(value) {\n      return typeof value == 'number' && nativeIsFinite(value);\n    }\n\n    /**\n     * Checks if `value` is classified as a `Function` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n     * @example\n     *\n     * _.isFunction(_);\n     * // => true\n     *\n     * _.isFunction(/abc/);\n     * // => false\n     */\n    function isFunction(value) {\n      if (!isObject(value)) {\n        return false;\n      }\n      // The use of `Object#toString` avoids issues with the `typeof` operator\n      // in Safari 9 which returns 'object' for typed arrays and other constructors.\n      var tag = baseGetTag(value);\n      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n    }\n\n    /**\n     * Checks if `value` is an integer.\n     *\n     * **Note:** This method is based on\n     * [`Number.isInteger`](https://mdn.io/Number/isInteger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an integer, else `false`.\n     * @example\n     *\n     * _.isInteger(3);\n     * // => true\n     *\n     * _.isInteger(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isInteger(Infinity);\n     * // => false\n     *\n     * _.isInteger('3');\n     * // => false\n     */\n    function isInteger(value) {\n      return typeof value == 'number' && value == toInteger(value);\n    }\n\n    /**\n     * Checks if `value` is a valid array-like length.\n     *\n     * **Note:** This method is loosely based on\n     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n     * @example\n     *\n     * _.isLength(3);\n     * // => true\n     *\n     * _.isLength(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isLength(Infinity);\n     * // => false\n     *\n     * _.isLength('3');\n     * // => false\n     */\n    function isLength(value) {\n      return typeof value == 'number' &&\n        value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n    }\n\n    /**\n     * Checks if `value` is the\n     * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n     * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n     * @example\n     *\n     * _.isObject({});\n     * // => true\n     *\n     * _.isObject([1, 2, 3]);\n     * // => true\n     *\n     * _.isObject(_.noop);\n     * // => true\n     *\n     * _.isObject(null);\n     * // => false\n     */\n    function isObject(value) {\n      var type = typeof value;\n      return value != null && (type == 'object' || type == 'function');\n    }\n\n    /**\n     * Checks if `value` is object-like. A value is object-like if it's not `null`\n     * and has a `typeof` result of \"object\".\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n     * @example\n     *\n     * _.isObjectLike({});\n     * // => true\n     *\n     * _.isObjectLike([1, 2, 3]);\n     * // => true\n     *\n     * _.isObjectLike(_.noop);\n     * // => false\n     *\n     * _.isObjectLike(null);\n     * // => false\n     */\n    function isObjectLike(value) {\n      return value != null && typeof value == 'object';\n    }\n\n    /**\n     * Checks if `value` is classified as a `Map` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n     * @example\n     *\n     * _.isMap(new Map);\n     * // => true\n     *\n     * _.isMap(new WeakMap);\n     * // => false\n     */\n    var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\n    /**\n     * Performs a partial deep comparison between `object` and `source` to\n     * determine if `object` contains equivalent property values.\n     *\n     * **Note:** This method is equivalent to `_.matches` when `source` is\n     * partially applied.\n     *\n     * Partial comparisons will match empty array and empty object `source`\n     * values against any array or object value, respectively. See `_.isEqual`\n     * for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     *\n     * _.isMatch(object, { 'b': 2 });\n     * // => true\n     *\n     * _.isMatch(object, { 'b': 1 });\n     * // => false\n     */\n    function isMatch(object, source) {\n      return object === source || baseIsMatch(object, source, getMatchData(source));\n    }\n\n    /**\n     * This method is like `_.isMatch` except that it accepts `customizer` which\n     * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n     * are handled by the method instead. The `customizer` is invoked with five\n     * arguments: (objValue, srcValue, index|key, object, source).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * function isGreeting(value) {\n     *   return /^h(?:i|ello)$/.test(value);\n     * }\n     *\n     * function customizer(objValue, srcValue) {\n     *   if (isGreeting(objValue) && isGreeting(srcValue)) {\n     *     return true;\n     *   }\n     * }\n     *\n     * var object = { 'greeting': 'hello' };\n     * var source = { 'greeting': 'hi' };\n     *\n     * _.isMatchWith(object, source, customizer);\n     * // => true\n     */\n    function isMatchWith(object, source, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined$1;\n      return baseIsMatch(object, source, getMatchData(source), customizer);\n    }\n\n    /**\n     * Checks if `value` is `NaN`.\n     *\n     * **Note:** This method is based on\n     * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as\n     * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for\n     * `undefined` and other non-number values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n     * @example\n     *\n     * _.isNaN(NaN);\n     * // => true\n     *\n     * _.isNaN(new Number(NaN));\n     * // => true\n     *\n     * isNaN(undefined);\n     * // => true\n     *\n     * _.isNaN(undefined);\n     * // => false\n     */\n    function isNaN(value) {\n      // An `NaN` primitive is the only value that is not equal to itself.\n      // Perform the `toStringTag` check first to avoid errors with some\n      // ActiveX objects in IE.\n      return isNumber(value) && value != +value;\n    }\n\n    /**\n     * Checks if `value` is a pristine native function.\n     *\n     * **Note:** This method can't reliably detect native functions in the presence\n     * of the core-js package because core-js circumvents this kind of detection.\n     * Despite multiple requests, the core-js maintainer has made it clear: any\n     * attempt to fix the detection will be obstructed. As a result, we're left\n     * with little choice but to throw an error. Unfortunately, this also affects\n     * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),\n     * which rely on core-js.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a native function,\n     *  else `false`.\n     * @example\n     *\n     * _.isNative(Array.prototype.push);\n     * // => true\n     *\n     * _.isNative(_);\n     * // => false\n     */\n    function isNative(value) {\n      if (isMaskable(value)) {\n        throw new Error(CORE_ERROR_TEXT);\n      }\n      return baseIsNative(value);\n    }\n\n    /**\n     * Checks if `value` is `null`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `null`, else `false`.\n     * @example\n     *\n     * _.isNull(null);\n     * // => true\n     *\n     * _.isNull(void 0);\n     * // => false\n     */\n    function isNull(value) {\n      return value === null;\n    }\n\n    /**\n     * Checks if `value` is `null` or `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\n     * @example\n     *\n     * _.isNil(null);\n     * // => true\n     *\n     * _.isNil(void 0);\n     * // => true\n     *\n     * _.isNil(NaN);\n     * // => false\n     */\n    function isNil(value) {\n      return value == null;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Number` primitive or object.\n     *\n     * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are\n     * classified as numbers, use the `_.isFinite` method.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a number, else `false`.\n     * @example\n     *\n     * _.isNumber(3);\n     * // => true\n     *\n     * _.isNumber(Number.MIN_VALUE);\n     * // => true\n     *\n     * _.isNumber(Infinity);\n     * // => true\n     *\n     * _.isNumber('3');\n     * // => false\n     */\n    function isNumber(value) {\n      return typeof value == 'number' ||\n        (isObjectLike(value) && baseGetTag(value) == numberTag);\n    }\n\n    /**\n     * Checks if `value` is a plain object, that is, an object created by the\n     * `Object` constructor or one with a `[[Prototype]]` of `null`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.8.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * _.isPlainObject(new Foo);\n     * // => false\n     *\n     * _.isPlainObject([1, 2, 3]);\n     * // => false\n     *\n     * _.isPlainObject({ 'x': 0, 'y': 0 });\n     * // => true\n     *\n     * _.isPlainObject(Object.create(null));\n     * // => true\n     */\n    function isPlainObject(value) {\n      if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n        return false;\n      }\n      var proto = getPrototype(value);\n      if (proto === null) {\n        return true;\n      }\n      var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n      return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n        funcToString.call(Ctor) == objectCtorString;\n    }\n\n    /**\n     * Checks if `value` is classified as a `RegExp` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n     * @example\n     *\n     * _.isRegExp(/abc/);\n     * // => true\n     *\n     * _.isRegExp('/abc/');\n     * // => false\n     */\n    var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;\n\n    /**\n     * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754\n     * double precision number which isn't the result of a rounded unsafe integer.\n     *\n     * **Note:** This method is based on\n     * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.\n     * @example\n     *\n     * _.isSafeInteger(3);\n     * // => true\n     *\n     * _.isSafeInteger(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isSafeInteger(Infinity);\n     * // => false\n     *\n     * _.isSafeInteger('3');\n     * // => false\n     */\n    function isSafeInteger(value) {\n      return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Set` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n     * @example\n     *\n     * _.isSet(new Set);\n     * // => true\n     *\n     * _.isSet(new WeakSet);\n     * // => false\n     */\n    var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\n    /**\n     * Checks if `value` is classified as a `String` primitive or object.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n     * @example\n     *\n     * _.isString('abc');\n     * // => true\n     *\n     * _.isString(1);\n     * // => false\n     */\n    function isString(value) {\n      return typeof value == 'string' ||\n        (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a `Symbol` primitive or object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n     * @example\n     *\n     * _.isSymbol(Symbol.iterator);\n     * // => true\n     *\n     * _.isSymbol('abc');\n     * // => false\n     */\n    function isSymbol(value) {\n      return typeof value == 'symbol' ||\n        (isObjectLike(value) && baseGetTag(value) == symbolTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a typed array.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n     * @example\n     *\n     * _.isTypedArray(new Uint8Array);\n     * // => true\n     *\n     * _.isTypedArray([]);\n     * // => false\n     */\n    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n    /**\n     * Checks if `value` is `undefined`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.\n     * @example\n     *\n     * _.isUndefined(void 0);\n     * // => true\n     *\n     * _.isUndefined(null);\n     * // => false\n     */\n    function isUndefined(value) {\n      return value === undefined$1;\n    }\n\n    /**\n     * Checks if `value` is classified as a `WeakMap` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.\n     * @example\n     *\n     * _.isWeakMap(new WeakMap);\n     * // => true\n     *\n     * _.isWeakMap(new Map);\n     * // => false\n     */\n    function isWeakMap(value) {\n      return isObjectLike(value) && getTag(value) == weakMapTag;\n    }\n\n    /**\n     * Checks if `value` is classified as a `WeakSet` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.\n     * @example\n     *\n     * _.isWeakSet(new WeakSet);\n     * // => true\n     *\n     * _.isWeakSet(new Set);\n     * // => false\n     */\n    function isWeakSet(value) {\n      return isObjectLike(value) && baseGetTag(value) == weakSetTag;\n    }\n\n    /**\n     * Checks if `value` is less than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than `other`,\n     *  else `false`.\n     * @see _.gt\n     * @example\n     *\n     * _.lt(1, 3);\n     * // => true\n     *\n     * _.lt(3, 3);\n     * // => false\n     *\n     * _.lt(3, 1);\n     * // => false\n     */\n    var lt = createRelationalOperation(baseLt);\n\n    /**\n     * Checks if `value` is less than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than or equal to\n     *  `other`, else `false`.\n     * @see _.gte\n     * @example\n     *\n     * _.lte(1, 3);\n     * // => true\n     *\n     * _.lte(3, 3);\n     * // => true\n     *\n     * _.lte(3, 1);\n     * // => false\n     */\n    var lte = createRelationalOperation(function(value, other) {\n      return value <= other;\n    });\n\n    /**\n     * Converts `value` to an array.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the converted array.\n     * @example\n     *\n     * _.toArray({ 'a': 1, 'b': 2 });\n     * // => [1, 2]\n     *\n     * _.toArray('abc');\n     * // => ['a', 'b', 'c']\n     *\n     * _.toArray(1);\n     * // => []\n     *\n     * _.toArray(null);\n     * // => []\n     */\n    function toArray(value) {\n      if (!value) {\n        return [];\n      }\n      if (isArrayLike(value)) {\n        return isString(value) ? stringToArray(value) : copyArray(value);\n      }\n      if (symIterator && value[symIterator]) {\n        return iteratorToArray(value[symIterator]());\n      }\n      var tag = getTag(value),\n          func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);\n\n      return func(value);\n    }\n\n    /**\n     * Converts `value` to a finite number.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.12.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted number.\n     * @example\n     *\n     * _.toFinite(3.2);\n     * // => 3.2\n     *\n     * _.toFinite(Number.MIN_VALUE);\n     * // => 5e-324\n     *\n     * _.toFinite(Infinity);\n     * // => 1.7976931348623157e+308\n     *\n     * _.toFinite('3.2');\n     * // => 3.2\n     */\n    function toFinite(value) {\n      if (!value) {\n        return value === 0 ? value : 0;\n      }\n      value = toNumber(value);\n      if (value === INFINITY || value === -INFINITY) {\n        var sign = (value < 0 ? -1 : 1);\n        return sign * MAX_INTEGER;\n      }\n      return value === value ? value : 0;\n    }\n\n    /**\n     * Converts `value` to an integer.\n     *\n     * **Note:** This method is loosely based on\n     * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toInteger(3.2);\n     * // => 3\n     *\n     * _.toInteger(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toInteger(Infinity);\n     * // => 1.7976931348623157e+308\n     *\n     * _.toInteger('3.2');\n     * // => 3\n     */\n    function toInteger(value) {\n      var result = toFinite(value),\n          remainder = result % 1;\n\n      return result === result ? (remainder ? result - remainder : result) : 0;\n    }\n\n    /**\n     * Converts `value` to an integer suitable for use as the length of an\n     * array-like object.\n     *\n     * **Note:** This method is based on\n     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toLength(3.2);\n     * // => 3\n     *\n     * _.toLength(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toLength(Infinity);\n     * // => 4294967295\n     *\n     * _.toLength('3.2');\n     * // => 3\n     */\n    function toLength(value) {\n      return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;\n    }\n\n    /**\n     * Converts `value` to a number.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to process.\n     * @returns {number} Returns the number.\n     * @example\n     *\n     * _.toNumber(3.2);\n     * // => 3.2\n     *\n     * _.toNumber(Number.MIN_VALUE);\n     * // => 5e-324\n     *\n     * _.toNumber(Infinity);\n     * // => Infinity\n     *\n     * _.toNumber('3.2');\n     * // => 3.2\n     */\n    function toNumber(value) {\n      if (typeof value == 'number') {\n        return value;\n      }\n      if (isSymbol(value)) {\n        return NAN;\n      }\n      if (isObject(value)) {\n        var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n        value = isObject(other) ? (other + '') : other;\n      }\n      if (typeof value != 'string') {\n        return value === 0 ? value : +value;\n      }\n      value = value.replace(reTrim, '');\n      var isBinary = reIsBinary.test(value);\n      return (isBinary || reIsOctal.test(value))\n        ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n        : (reIsBadHex.test(value) ? NAN : +value);\n    }\n\n    /**\n     * Converts `value` to a plain object flattening inherited enumerable string\n     * keyed properties of `value` to own properties of the plain object.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Object} Returns the converted plain object.\n     * @example\n     *\n     * function Foo() {\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.assign({ 'a': 1 }, new Foo);\n     * // => { 'a': 1, 'b': 2 }\n     *\n     * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n     * // => { 'a': 1, 'b': 2, 'c': 3 }\n     */\n    function toPlainObject(value) {\n      return copyObject(value, keysIn(value));\n    }\n\n    /**\n     * Converts `value` to a safe integer. A safe integer can be compared and\n     * represented correctly.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toSafeInteger(3.2);\n     * // => 3\n     *\n     * _.toSafeInteger(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toSafeInteger(Infinity);\n     * // => 9007199254740991\n     *\n     * _.toSafeInteger('3.2');\n     * // => 3\n     */\n    function toSafeInteger(value) {\n      return value\n        ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)\n        : (value === 0 ? value : 0);\n    }\n\n    /**\n     * Converts `value` to a string. An empty string is returned for `null`\n     * and `undefined` values. The sign of `-0` is preserved.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.toString(null);\n     * // => ''\n     *\n     * _.toString(-0);\n     * // => '-0'\n     *\n     * _.toString([1, 2, 3]);\n     * // => '1,2,3'\n     */\n    function toString(value) {\n      return value == null ? '' : baseToString(value);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Assigns own enumerable string keyed properties of source objects to the\n     * destination object. Source objects are applied from left to right.\n     * Subsequent sources overwrite property assignments of previous sources.\n     *\n     * **Note:** This method mutates `object` and is loosely based on\n     * [`Object.assign`](https://mdn.io/Object/assign).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.10.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.assignIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * function Bar() {\n     *   this.c = 3;\n     * }\n     *\n     * Foo.prototype.b = 2;\n     * Bar.prototype.d = 4;\n     *\n     * _.assign({ 'a': 0 }, new Foo, new Bar);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    var assign = createAssigner(function(object, source) {\n      if (isPrototype(source) || isArrayLike(source)) {\n        copyObject(source, keys(source), object);\n        return;\n      }\n      for (var key in source) {\n        if (hasOwnProperty.call(source, key)) {\n          assignValue(object, key, source[key]);\n        }\n      }\n    });\n\n    /**\n     * This method is like `_.assign` except that it iterates over own and\n     * inherited source properties.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias extend\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.assign\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * function Bar() {\n     *   this.c = 3;\n     * }\n     *\n     * Foo.prototype.b = 2;\n     * Bar.prototype.d = 4;\n     *\n     * _.assignIn({ 'a': 0 }, new Foo, new Bar);\n     * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }\n     */\n    var assignIn = createAssigner(function(object, source) {\n      copyObject(source, keysIn(source), object);\n    });\n\n    /**\n     * This method is like `_.assignIn` except that it accepts `customizer`\n     * which is invoked to produce the assigned values. If `customizer` returns\n     * `undefined`, assignment is handled by the method instead. The `customizer`\n     * is invoked with five arguments: (objValue, srcValue, key, object, source).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias extendWith\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @see _.assignWith\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   return _.isUndefined(objValue) ? srcValue : objValue;\n     * }\n     *\n     * var defaults = _.partialRight(_.assignInWith, customizer);\n     *\n     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {\n      copyObject(source, keysIn(source), object, customizer);\n    });\n\n    /**\n     * This method is like `_.assign` except that it accepts `customizer`\n     * which is invoked to produce the assigned values. If `customizer` returns\n     * `undefined`, assignment is handled by the method instead. The `customizer`\n     * is invoked with five arguments: (objValue, srcValue, key, object, source).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @see _.assignInWith\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   return _.isUndefined(objValue) ? srcValue : objValue;\n     * }\n     *\n     * var defaults = _.partialRight(_.assignWith, customizer);\n     *\n     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var assignWith = createAssigner(function(object, source, srcIndex, customizer) {\n      copyObject(source, keys(source), object, customizer);\n    });\n\n    /**\n     * Creates an array of values corresponding to `paths` of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Array} Returns the picked values.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n     *\n     * _.at(object, ['a[0].b.c', 'a[1]']);\n     * // => [3, 4]\n     */\n    var at = flatRest(baseAt);\n\n    /**\n     * Creates an object that inherits from the `prototype` object. If a\n     * `properties` object is given, its own enumerable string keyed properties\n     * are assigned to the created object.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.3.0\n     * @category Object\n     * @param {Object} prototype The object to inherit from.\n     * @param {Object} [properties] The properties to assign to the object.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * function Shape() {\n     *   this.x = 0;\n     *   this.y = 0;\n     * }\n     *\n     * function Circle() {\n     *   Shape.call(this);\n     * }\n     *\n     * Circle.prototype = _.create(Shape.prototype, {\n     *   'constructor': Circle\n     * });\n     *\n     * var circle = new Circle;\n     * circle instanceof Circle;\n     * // => true\n     *\n     * circle instanceof Shape;\n     * // => true\n     */\n    function create(prototype, properties) {\n      var result = baseCreate(prototype);\n      return properties == null ? result : baseAssign(result, properties);\n    }\n\n    /**\n     * Assigns own and inherited enumerable string keyed properties of source\n     * objects to the destination object for all destination properties that\n     * resolve to `undefined`. Source objects are applied from left to right.\n     * Once a property is set, additional values of the same property are ignored.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.defaultsDeep\n     * @example\n     *\n     * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var defaults = baseRest(function(object, sources) {\n      object = Object(object);\n\n      var index = -1;\n      var length = sources.length;\n      var guard = length > 2 ? sources[2] : undefined$1;\n\n      if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n        length = 1;\n      }\n\n      while (++index < length) {\n        var source = sources[index];\n        var props = keysIn(source);\n        var propsIndex = -1;\n        var propsLength = props.length;\n\n        while (++propsIndex < propsLength) {\n          var key = props[propsIndex];\n          var value = object[key];\n\n          if (value === undefined$1 ||\n              (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n            object[key] = source[key];\n          }\n        }\n      }\n\n      return object;\n    });\n\n    /**\n     * This method is like `_.defaults` except that it recursively assigns\n     * default properties.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.defaults\n     * @example\n     *\n     * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });\n     * // => { 'a': { 'b': 2, 'c': 3 } }\n     */\n    var defaultsDeep = baseRest(function(args) {\n      args.push(undefined$1, customDefaultsMerge);\n      return apply(mergeWith, undefined$1, args);\n    });\n\n    /**\n     * This method is like `_.find` except that it returns the key of the first\n     * element `predicate` returns truthy for instead of the element itself.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {string|undefined} Returns the key of the matched element,\n     *  else `undefined`.\n     * @example\n     *\n     * var users = {\n     *   'barney':  { 'age': 36, 'active': true },\n     *   'fred':    { 'age': 40, 'active': false },\n     *   'pebbles': { 'age': 1,  'active': true }\n     * };\n     *\n     * _.findKey(users, function(o) { return o.age < 40; });\n     * // => 'barney' (iteration order is not guaranteed)\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findKey(users, { 'age': 1, 'active': true });\n     * // => 'pebbles'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findKey(users, ['active', false]);\n     * // => 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findKey(users, 'active');\n     * // => 'barney'\n     */\n    function findKey(object, predicate) {\n      return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);\n    }\n\n    /**\n     * This method is like `_.findKey` except that it iterates over elements of\n     * a collection in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {string|undefined} Returns the key of the matched element,\n     *  else `undefined`.\n     * @example\n     *\n     * var users = {\n     *   'barney':  { 'age': 36, 'active': true },\n     *   'fred':    { 'age': 40, 'active': false },\n     *   'pebbles': { 'age': 1,  'active': true }\n     * };\n     *\n     * _.findLastKey(users, function(o) { return o.age < 40; });\n     * // => returns 'pebbles' assuming `_.findKey` returns 'barney'\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findLastKey(users, { 'age': 36, 'active': true });\n     * // => 'barney'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findLastKey(users, ['active', false]);\n     * // => 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findLastKey(users, 'active');\n     * // => 'pebbles'\n     */\n    function findLastKey(object, predicate) {\n      return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);\n    }\n\n    /**\n     * Iterates over own and inherited enumerable string keyed properties of an\n     * object and invokes `iteratee` for each property. The iteratee is invoked\n     * with three arguments: (value, key, object). Iteratee functions may exit\n     * iteration early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forInRight\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forIn(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).\n     */\n    function forIn(object, iteratee) {\n      return object == null\n        ? object\n        : baseFor(object, getIteratee(iteratee, 3), keysIn);\n    }\n\n    /**\n     * This method is like `_.forIn` except that it iterates over properties of\n     * `object` in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forInRight(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.\n     */\n    function forInRight(object, iteratee) {\n      return object == null\n        ? object\n        : baseForRight(object, getIteratee(iteratee, 3), keysIn);\n    }\n\n    /**\n     * Iterates over own enumerable string keyed properties of an object and\n     * invokes `iteratee` for each property. The iteratee is invoked with three\n     * arguments: (value, key, object). Iteratee functions may exit iteration\n     * early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forOwnRight\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forOwn(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n     */\n    function forOwn(object, iteratee) {\n      return object && baseForOwn(object, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.forOwn` except that it iterates over properties of\n     * `object` in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forOwn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forOwnRight(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.\n     */\n    function forOwnRight(object, iteratee) {\n      return object && baseForOwnRight(object, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * Creates an array of function property names from own enumerable properties\n     * of `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns the function names.\n     * @see _.functionsIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = _.constant('a');\n     *   this.b = _.constant('b');\n     * }\n     *\n     * Foo.prototype.c = _.constant('c');\n     *\n     * _.functions(new Foo);\n     * // => ['a', 'b']\n     */\n    function functions(object) {\n      return object == null ? [] : baseFunctions(object, keys(object));\n    }\n\n    /**\n     * Creates an array of function property names from own and inherited\n     * enumerable properties of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns the function names.\n     * @see _.functions\n     * @example\n     *\n     * function Foo() {\n     *   this.a = _.constant('a');\n     *   this.b = _.constant('b');\n     * }\n     *\n     * Foo.prototype.c = _.constant('c');\n     *\n     * _.functionsIn(new Foo);\n     * // => ['a', 'b', 'c']\n     */\n    function functionsIn(object) {\n      return object == null ? [] : baseFunctions(object, keysIn(object));\n    }\n\n    /**\n     * Gets the value at `path` of `object`. If the resolved value is\n     * `undefined`, the `defaultValue` is returned in its place.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.get(object, 'a[0].b.c');\n     * // => 3\n     *\n     * _.get(object, ['a', '0', 'b', 'c']);\n     * // => 3\n     *\n     * _.get(object, 'a.b.c', 'default');\n     * // => 'default'\n     */\n    function get(object, path, defaultValue) {\n      var result = object == null ? undefined$1 : baseGet(object, path);\n      return result === undefined$1 ? defaultValue : result;\n    }\n\n    /**\n     * Checks if `path` is a direct property of `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     * @example\n     *\n     * var object = { 'a': { 'b': 2 } };\n     * var other = _.create({ 'a': _.create({ 'b': 2 }) });\n     *\n     * _.has(object, 'a');\n     * // => true\n     *\n     * _.has(object, 'a.b');\n     * // => true\n     *\n     * _.has(object, ['a', 'b']);\n     * // => true\n     *\n     * _.has(other, 'a');\n     * // => false\n     */\n    function has(object, path) {\n      return object != null && hasPath(object, path, baseHas);\n    }\n\n    /**\n     * Checks if `path` is a direct or inherited property of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     * @example\n     *\n     * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n     *\n     * _.hasIn(object, 'a');\n     * // => true\n     *\n     * _.hasIn(object, 'a.b');\n     * // => true\n     *\n     * _.hasIn(object, ['a', 'b']);\n     * // => true\n     *\n     * _.hasIn(object, 'b');\n     * // => false\n     */\n    function hasIn(object, path) {\n      return object != null && hasPath(object, path, baseHasIn);\n    }\n\n    /**\n     * Creates an object composed of the inverted keys and values of `object`.\n     * If `object` contains duplicate values, subsequent values overwrite\n     * property assignments of previous values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.7.0\n     * @category Object\n     * @param {Object} object The object to invert.\n     * @returns {Object} Returns the new inverted object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2, 'c': 1 };\n     *\n     * _.invert(object);\n     * // => { '1': 'c', '2': 'b' }\n     */\n    var invert = createInverter(function(result, value, key) {\n      if (value != null &&\n          typeof value.toString != 'function') {\n        value = nativeObjectToString.call(value);\n      }\n\n      result[value] = key;\n    }, constant(identity));\n\n    /**\n     * This method is like `_.invert` except that the inverted object is generated\n     * from the results of running each element of `object` thru `iteratee`. The\n     * corresponding inverted value of each inverted key is an array of keys\n     * responsible for generating the inverted value. The iteratee is invoked\n     * with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.1.0\n     * @category Object\n     * @param {Object} object The object to invert.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Object} Returns the new inverted object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2, 'c': 1 };\n     *\n     * _.invertBy(object);\n     * // => { '1': ['a', 'c'], '2': ['b'] }\n     *\n     * _.invertBy(object, function(value) {\n     *   return 'group' + value;\n     * });\n     * // => { 'group1': ['a', 'c'], 'group2': ['b'] }\n     */\n    var invertBy = createInverter(function(result, value, key) {\n      if (value != null &&\n          typeof value.toString != 'function') {\n        value = nativeObjectToString.call(value);\n      }\n\n      if (hasOwnProperty.call(result, value)) {\n        result[value].push(key);\n      } else {\n        result[value] = [key];\n      }\n    }, getIteratee);\n\n    /**\n     * Invokes the method at `path` of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {*} Returns the result of the invoked method.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };\n     *\n     * _.invoke(object, 'a[0].b.c.slice', 1, 3);\n     * // => [2, 3]\n     */\n    var invoke = baseRest(baseInvoke);\n\n    /**\n     * Creates an array of the own enumerable property names of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects. See the\n     * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n     * for more details.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.keys(new Foo);\n     * // => ['a', 'b'] (iteration order is not guaranteed)\n     *\n     * _.keys('hi');\n     * // => ['0', '1']\n     */\n    function keys(object) {\n      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n    }\n\n    /**\n     * Creates an array of the own and inherited enumerable property names of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.keysIn(new Foo);\n     * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n     */\n    function keysIn(object) {\n      return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n    }\n\n    /**\n     * The opposite of `_.mapValues`; this method creates an object with the\n     * same values as `object` and keys generated by running each own enumerable\n     * string keyed property of `object` thru `iteratee`. The iteratee is invoked\n     * with three arguments: (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns the new mapped object.\n     * @see _.mapValues\n     * @example\n     *\n     * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {\n     *   return key + value;\n     * });\n     * // => { 'a1': 1, 'b2': 2 }\n     */\n    function mapKeys(object, iteratee) {\n      var result = {};\n      iteratee = getIteratee(iteratee, 3);\n\n      baseForOwn(object, function(value, key, object) {\n        baseAssignValue(result, iteratee(value, key, object), value);\n      });\n      return result;\n    }\n\n    /**\n     * Creates an object with the same keys as `object` and values generated\n     * by running each own enumerable string keyed property of `object` thru\n     * `iteratee`. The iteratee is invoked with three arguments:\n     * (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns the new mapped object.\n     * @see _.mapKeys\n     * @example\n     *\n     * var users = {\n     *   'fred':    { 'user': 'fred',    'age': 40 },\n     *   'pebbles': { 'user': 'pebbles', 'age': 1 }\n     * };\n     *\n     * _.mapValues(users, function(o) { return o.age; });\n     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.mapValues(users, 'age');\n     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n     */\n    function mapValues(object, iteratee) {\n      var result = {};\n      iteratee = getIteratee(iteratee, 3);\n\n      baseForOwn(object, function(value, key, object) {\n        baseAssignValue(result, key, iteratee(value, key, object));\n      });\n      return result;\n    }\n\n    /**\n     * This method is like `_.assign` except that it recursively merges own and\n     * inherited enumerable string keyed properties of source objects into the\n     * destination object. Source properties that resolve to `undefined` are\n     * skipped if a destination value exists. Array and plain object properties\n     * are merged recursively. Other objects and value types are overridden by\n     * assignment. Source objects are applied from left to right. Subsequent\n     * sources overwrite property assignments of previous sources.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {\n     *   'a': [{ 'b': 2 }, { 'd': 4 }]\n     * };\n     *\n     * var other = {\n     *   'a': [{ 'c': 3 }, { 'e': 5 }]\n     * };\n     *\n     * _.merge(object, other);\n     * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n     */\n    var merge = createAssigner(function(object, source, srcIndex) {\n      baseMerge(object, source, srcIndex);\n    });\n\n    /**\n     * This method is like `_.merge` except that it accepts `customizer` which\n     * is invoked to produce the merged values of the destination and source\n     * properties. If `customizer` returns `undefined`, merging is handled by the\n     * method instead. The `customizer` is invoked with six arguments:\n     * (objValue, srcValue, key, object, source, stack).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} customizer The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   if (_.isArray(objValue)) {\n     *     return objValue.concat(srcValue);\n     *   }\n     * }\n     *\n     * var object = { 'a': [1], 'b': [2] };\n     * var other = { 'a': [3], 'b': [4] };\n     *\n     * _.mergeWith(object, other, customizer);\n     * // => { 'a': [1, 3], 'b': [2, 4] }\n     */\n    var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\n      baseMerge(object, source, srcIndex, customizer);\n    });\n\n    /**\n     * The opposite of `_.pick`; this method creates an object composed of the\n     * own and inherited enumerable property paths of `object` that are not omitted.\n     *\n     * **Note:** This method is considerably slower than `_.pick`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {...(string|string[])} [paths] The property paths to omit.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.omit(object, ['a', 'c']);\n     * // => { 'b': '2' }\n     */\n    var omit = flatRest(function(object, paths) {\n      var result = {};\n      if (object == null) {\n        return result;\n      }\n      var isDeep = false;\n      paths = arrayMap(paths, function(path) {\n        path = castPath(path, object);\n        isDeep || (isDeep = path.length > 1);\n        return path;\n      });\n      copyObject(object, getAllKeysIn(object), result);\n      if (isDeep) {\n        result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);\n      }\n      var length = paths.length;\n      while (length--) {\n        baseUnset(result, paths[length]);\n      }\n      return result;\n    });\n\n    /**\n     * The opposite of `_.pickBy`; this method creates an object composed of\n     * the own and inherited enumerable string keyed properties of `object` that\n     * `predicate` doesn't return truthy for. The predicate is invoked with two\n     * arguments: (value, key).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {Function} [predicate=_.identity] The function invoked per property.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.omitBy(object, _.isNumber);\n     * // => { 'b': '2' }\n     */\n    function omitBy(object, predicate) {\n      return pickBy(object, negate(getIteratee(predicate)));\n    }\n\n    /**\n     * Creates an object composed of the picked `object` properties.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.pick(object, ['a', 'c']);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    var pick = flatRest(function(object, paths) {\n      return object == null ? {} : basePick(object, paths);\n    });\n\n    /**\n     * Creates an object composed of the `object` properties `predicate` returns\n     * truthy for. The predicate is invoked with two arguments: (value, key).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {Function} [predicate=_.identity] The function invoked per property.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.pickBy(object, _.isNumber);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    function pickBy(object, predicate) {\n      if (object == null) {\n        return {};\n      }\n      var props = arrayMap(getAllKeysIn(object), function(prop) {\n        return [prop];\n      });\n      predicate = getIteratee(predicate);\n      return basePickBy(object, props, function(value, path) {\n        return predicate(value, path[0]);\n      });\n    }\n\n    /**\n     * This method is like `_.get` except that if the resolved value is a\n     * function it's invoked with the `this` binding of its parent object and\n     * its result is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to resolve.\n     * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };\n     *\n     * _.result(object, 'a[0].b.c1');\n     * // => 3\n     *\n     * _.result(object, 'a[0].b.c2');\n     * // => 4\n     *\n     * _.result(object, 'a[0].b.c3', 'default');\n     * // => 'default'\n     *\n     * _.result(object, 'a[0].b.c3', _.constant('default'));\n     * // => 'default'\n     */\n    function result(object, path, defaultValue) {\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length;\n\n      // Ensure the loop is entered when path is empty.\n      if (!length) {\n        length = 1;\n        object = undefined$1;\n      }\n      while (++index < length) {\n        var value = object == null ? undefined$1 : object[toKey(path[index])];\n        if (value === undefined$1) {\n          index = length;\n          value = defaultValue;\n        }\n        object = isFunction(value) ? value.call(object) : value;\n      }\n      return object;\n    }\n\n    /**\n     * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,\n     * it's created. Arrays are created for missing index properties while objects\n     * are created for all other missing properties. Use `_.setWith` to customize\n     * `path` creation.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.set(object, 'a[0].b.c', 4);\n     * console.log(object.a[0].b.c);\n     * // => 4\n     *\n     * _.set(object, ['x', '0', 'y', 'z'], 5);\n     * console.log(object.x[0].y.z);\n     * // => 5\n     */\n    function set(object, path, value) {\n      return object == null ? object : baseSet(object, path, value);\n    }\n\n    /**\n     * This method is like `_.set` except that it accepts `customizer` which is\n     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`\n     * path creation is handled by the method instead. The `customizer` is invoked\n     * with three arguments: (nsValue, key, nsObject).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {};\n     *\n     * _.setWith(object, '[0][1]', 'a', Object);\n     * // => { '0': { '1': 'a' } }\n     */\n    function setWith(object, path, value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined$1;\n      return object == null ? object : baseSet(object, path, value, customizer);\n    }\n\n    /**\n     * Creates an array of own enumerable string keyed-value pairs for `object`\n     * which can be consumed by `_.fromPairs`. If `object` is a map or set, its\n     * entries are returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias entries\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the key-value pairs.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.toPairs(new Foo);\n     * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)\n     */\n    var toPairs = createToPairs(keys);\n\n    /**\n     * Creates an array of own and inherited enumerable string keyed-value pairs\n     * for `object` which can be consumed by `_.fromPairs`. If `object` is a map\n     * or set, its entries are returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias entriesIn\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the key-value pairs.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.toPairsIn(new Foo);\n     * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)\n     */\n    var toPairsIn = createToPairs(keysIn);\n\n    /**\n     * An alternative to `_.reduce`; this method transforms `object` to a new\n     * `accumulator` object which is the result of running each of its own\n     * enumerable string keyed properties thru `iteratee`, with each invocation\n     * potentially mutating the `accumulator` object. If `accumulator` is not\n     * provided, a new object with the same `[[Prototype]]` will be used. The\n     * iteratee is invoked with four arguments: (accumulator, value, key, object).\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The custom accumulator value.\n     * @returns {*} Returns the accumulated value.\n     * @example\n     *\n     * _.transform([2, 3, 4], function(result, n) {\n     *   result.push(n *= n);\n     *   return n % 2 == 0;\n     * }, []);\n     * // => [4, 9]\n     *\n     * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n     *   (result[value] || (result[value] = [])).push(key);\n     * }, {});\n     * // => { '1': ['a', 'c'], '2': ['b'] }\n     */\n    function transform(object, iteratee, accumulator) {\n      var isArr = isArray(object),\n          isArrLike = isArr || isBuffer(object) || isTypedArray(object);\n\n      iteratee = getIteratee(iteratee, 4);\n      if (accumulator == null) {\n        var Ctor = object && object.constructor;\n        if (isArrLike) {\n          accumulator = isArr ? new Ctor : [];\n        }\n        else if (isObject(object)) {\n          accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};\n        }\n        else {\n          accumulator = {};\n        }\n      }\n      (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {\n        return iteratee(accumulator, value, index, object);\n      });\n      return accumulator;\n    }\n\n    /**\n     * Removes the property at `path` of `object`.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to unset.\n     * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 7 } }] };\n     * _.unset(object, 'a[0].b.c');\n     * // => true\n     *\n     * console.log(object);\n     * // => { 'a': [{ 'b': {} }] };\n     *\n     * _.unset(object, ['a', '0', 'b', 'c']);\n     * // => true\n     *\n     * console.log(object);\n     * // => { 'a': [{ 'b': {} }] };\n     */\n    function unset(object, path) {\n      return object == null ? true : baseUnset(object, path);\n    }\n\n    /**\n     * This method is like `_.set` except that accepts `updater` to produce the\n     * value to set. Use `_.updateWith` to customize `path` creation. The `updater`\n     * is invoked with one argument: (value).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {Function} updater The function to produce the updated value.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.update(object, 'a[0].b.c', function(n) { return n * n; });\n     * console.log(object.a[0].b.c);\n     * // => 9\n     *\n     * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });\n     * console.log(object.x[0].y.z);\n     * // => 0\n     */\n    function update(object, path, updater) {\n      return object == null ? object : baseUpdate(object, path, castFunction(updater));\n    }\n\n    /**\n     * This method is like `_.update` except that it accepts `customizer` which is\n     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`\n     * path creation is handled by the method instead. The `customizer` is invoked\n     * with three arguments: (nsValue, key, nsObject).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {Function} updater The function to produce the updated value.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {};\n     *\n     * _.updateWith(object, '[0][1]', _.constant('a'), Object);\n     * // => { '0': { '1': 'a' } }\n     */\n    function updateWith(object, path, updater, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined$1;\n      return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);\n    }\n\n    /**\n     * Creates an array of the own enumerable string keyed property values of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property values.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.values(new Foo);\n     * // => [1, 2] (iteration order is not guaranteed)\n     *\n     * _.values('hi');\n     * // => ['h', 'i']\n     */\n    function values(object) {\n      return object == null ? [] : baseValues(object, keys(object));\n    }\n\n    /**\n     * Creates an array of the own and inherited enumerable string keyed property\n     * values of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property values.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.valuesIn(new Foo);\n     * // => [1, 2, 3] (iteration order is not guaranteed)\n     */\n    function valuesIn(object) {\n      return object == null ? [] : baseValues(object, keysIn(object));\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Clamps `number` within the inclusive `lower` and `upper` bounds.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Number\n     * @param {number} number The number to clamp.\n     * @param {number} [lower] The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the clamped number.\n     * @example\n     *\n     * _.clamp(-10, -5, 5);\n     * // => -5\n     *\n     * _.clamp(10, -5, 5);\n     * // => 5\n     */\n    function clamp(number, lower, upper) {\n      if (upper === undefined$1) {\n        upper = lower;\n        lower = undefined$1;\n      }\n      if (upper !== undefined$1) {\n        upper = toNumber(upper);\n        upper = upper === upper ? upper : 0;\n      }\n      if (lower !== undefined$1) {\n        lower = toNumber(lower);\n        lower = lower === lower ? lower : 0;\n      }\n      return baseClamp(toNumber(number), lower, upper);\n    }\n\n    /**\n     * Checks if `n` is between `start` and up to, but not including, `end`. If\n     * `end` is not specified, it's set to `start` with `start` then set to `0`.\n     * If `start` is greater than `end` the params are swapped to support\n     * negative ranges.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.3.0\n     * @category Number\n     * @param {number} number The number to check.\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n     * @see _.range, _.rangeRight\n     * @example\n     *\n     * _.inRange(3, 2, 4);\n     * // => true\n     *\n     * _.inRange(4, 8);\n     * // => true\n     *\n     * _.inRange(4, 2);\n     * // => false\n     *\n     * _.inRange(2, 2);\n     * // => false\n     *\n     * _.inRange(1.2, 2);\n     * // => true\n     *\n     * _.inRange(5.2, 4);\n     * // => false\n     *\n     * _.inRange(-3, -2, -6);\n     * // => true\n     */\n    function inRange(number, start, end) {\n      start = toFinite(start);\n      if (end === undefined$1) {\n        end = start;\n        start = 0;\n      } else {\n        end = toFinite(end);\n      }\n      number = toNumber(number);\n      return baseInRange(number, start, end);\n    }\n\n    /**\n     * Produces a random number between the inclusive `lower` and `upper` bounds.\n     * If only one argument is provided a number between `0` and the given number\n     * is returned. If `floating` is `true`, or either `lower` or `upper` are\n     * floats, a floating-point number is returned instead of an integer.\n     *\n     * **Note:** JavaScript follows the IEEE-754 standard for resolving\n     * floating-point values which can produce unexpected results.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.7.0\n     * @category Number\n     * @param {number} [lower=0] The lower bound.\n     * @param {number} [upper=1] The upper bound.\n     * @param {boolean} [floating] Specify returning a floating-point number.\n     * @returns {number} Returns the random number.\n     * @example\n     *\n     * _.random(0, 5);\n     * // => an integer between 0 and 5\n     *\n     * _.random(5);\n     * // => also an integer between 0 and 5\n     *\n     * _.random(5, true);\n     * // => a floating-point number between 0 and 5\n     *\n     * _.random(1.2, 5.2);\n     * // => a floating-point number between 1.2 and 5.2\n     */\n    function random(lower, upper, floating) {\n      if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {\n        upper = floating = undefined$1;\n      }\n      if (floating === undefined$1) {\n        if (typeof upper == 'boolean') {\n          floating = upper;\n          upper = undefined$1;\n        }\n        else if (typeof lower == 'boolean') {\n          floating = lower;\n          lower = undefined$1;\n        }\n      }\n      if (lower === undefined$1 && upper === undefined$1) {\n        lower = 0;\n        upper = 1;\n      }\n      else {\n        lower = toFinite(lower);\n        if (upper === undefined$1) {\n          upper = lower;\n          lower = 0;\n        } else {\n          upper = toFinite(upper);\n        }\n      }\n      if (lower > upper) {\n        var temp = lower;\n        lower = upper;\n        upper = temp;\n      }\n      if (floating || lower % 1 || upper % 1) {\n        var rand = nativeRandom();\n        return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);\n      }\n      return baseRandom(lower, upper);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the camel cased string.\n     * @example\n     *\n     * _.camelCase('Foo Bar');\n     * // => 'fooBar'\n     *\n     * _.camelCase('--foo-bar--');\n     * // => 'fooBar'\n     *\n     * _.camelCase('__FOO_BAR__');\n     * // => 'fooBar'\n     */\n    var camelCase = createCompounder(function(result, word, index) {\n      word = word.toLowerCase();\n      return result + (index ? capitalize(word) : word);\n    });\n\n    /**\n     * Converts the first character of `string` to upper case and the remaining\n     * to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to capitalize.\n     * @returns {string} Returns the capitalized string.\n     * @example\n     *\n     * _.capitalize('FRED');\n     * // => 'Fred'\n     */\n    function capitalize(string) {\n      return upperFirst(toString(string).toLowerCase());\n    }\n\n    /**\n     * Deburrs `string` by converting\n     * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)\n     * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)\n     * letters to basic Latin letters and removing\n     * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to deburr.\n     * @returns {string} Returns the deburred string.\n     * @example\n     *\n     * _.deburr('déjà vu');\n     * // => 'deja vu'\n     */\n    function deburr(string) {\n      string = toString(string);\n      return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');\n    }\n\n    /**\n     * Checks if `string` ends with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=string.length] The position to search up to.\n     * @returns {boolean} Returns `true` if `string` ends with `target`,\n     *  else `false`.\n     * @example\n     *\n     * _.endsWith('abc', 'c');\n     * // => true\n     *\n     * _.endsWith('abc', 'b');\n     * // => false\n     *\n     * _.endsWith('abc', 'b', 2);\n     * // => true\n     */\n    function endsWith(string, target, position) {\n      string = toString(string);\n      target = baseToString(target);\n\n      var length = string.length;\n      position = position === undefined$1\n        ? length\n        : baseClamp(toInteger(position), 0, length);\n\n      var end = position;\n      position -= target.length;\n      return position >= 0 && string.slice(position, end) == target;\n    }\n\n    /**\n     * Converts the characters \"&\", \"<\", \">\", '\"', and \"'\" in `string` to their\n     * corresponding HTML entities.\n     *\n     * **Note:** No other characters are escaped. To escape additional\n     * characters use a third-party library like [_he_](https://mths.be/he).\n     *\n     * Though the \">\" character is escaped for symmetry, characters like\n     * \">\" and \"/\" don't need escaping in HTML and have no special meaning\n     * unless they're part of a tag or unquoted attribute value. See\n     * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\n     * (under \"semi-related fun fact\") for more details.\n     *\n     * When working with HTML you should always\n     * [quote attribute values](http://wonko.com/post/html-escaping) to reduce\n     * XSS vectors.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escape('fred, barney, & pebbles');\n     * // => 'fred, barney, &amp; pebbles'\n     */\n    function escape(string) {\n      string = toString(string);\n      return (string && reHasUnescapedHtml.test(string))\n        ? string.replace(reUnescapedHtml, escapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Escapes the `RegExp` special characters \"^\", \"$\", \"\\\", \".\", \"*\", \"+\",\n     * \"?\", \"(\", \")\", \"[\", \"]\", \"{\", \"}\", and \"|\" in `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escapeRegExp('[lodash](https://lodash.com/)');\n     * // => '\\[lodash\\]\\(https://lodash\\.com/\\)'\n     */\n    function escapeRegExp(string) {\n      string = toString(string);\n      return (string && reHasRegExpChar.test(string))\n        ? string.replace(reRegExpChar, '\\\\$&')\n        : string;\n    }\n\n    /**\n     * Converts `string` to\n     * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the kebab cased string.\n     * @example\n     *\n     * _.kebabCase('Foo Bar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('fooBar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('__FOO_BAR__');\n     * // => 'foo-bar'\n     */\n    var kebabCase = createCompounder(function(result, word, index) {\n      return result + (index ? '-' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts `string`, as space separated words, to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the lower cased string.\n     * @example\n     *\n     * _.lowerCase('--Foo-Bar--');\n     * // => 'foo bar'\n     *\n     * _.lowerCase('fooBar');\n     * // => 'foo bar'\n     *\n     * _.lowerCase('__FOO_BAR__');\n     * // => 'foo bar'\n     */\n    var lowerCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts the first character of `string` to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.lowerFirst('Fred');\n     * // => 'fred'\n     *\n     * _.lowerFirst('FRED');\n     * // => 'fRED'\n     */\n    var lowerFirst = createCaseFirst('toLowerCase');\n\n    /**\n     * Pads `string` on the left and right sides if it's shorter than `length`.\n     * Padding characters are truncated if they can't be evenly divided by `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.pad('abc', 8);\n     * // => '  abc   '\n     *\n     * _.pad('abc', 8, '_-');\n     * // => '_-abc_-_'\n     *\n     * _.pad('abc', 3);\n     * // => 'abc'\n     */\n    function pad(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      if (!length || strLength >= length) {\n        return string;\n      }\n      var mid = (length - strLength) / 2;\n      return (\n        createPadding(nativeFloor(mid), chars) +\n        string +\n        createPadding(nativeCeil(mid), chars)\n      );\n    }\n\n    /**\n     * Pads `string` on the right side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padEnd('abc', 6);\n     * // => 'abc   '\n     *\n     * _.padEnd('abc', 6, '_-');\n     * // => 'abc_-_'\n     *\n     * _.padEnd('abc', 3);\n     * // => 'abc'\n     */\n    function padEnd(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      return (length && strLength < length)\n        ? (string + createPadding(length - strLength, chars))\n        : string;\n    }\n\n    /**\n     * Pads `string` on the left side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padStart('abc', 6);\n     * // => '   abc'\n     *\n     * _.padStart('abc', 6, '_-');\n     * // => '_-_abc'\n     *\n     * _.padStart('abc', 3);\n     * // => 'abc'\n     */\n    function padStart(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      return (length && strLength < length)\n        ? (createPadding(length - strLength, chars) + string)\n        : string;\n    }\n\n    /**\n     * Converts `string` to an integer of the specified radix. If `radix` is\n     * `undefined` or `0`, a `radix` of `10` is used unless `value` is a\n     * hexadecimal, in which case a `radix` of `16` is used.\n     *\n     * **Note:** This method aligns with the\n     * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category String\n     * @param {string} string The string to convert.\n     * @param {number} [radix=10] The radix to interpret `value` by.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.parseInt('08');\n     * // => 8\n     *\n     * _.map(['6', '08', '10'], _.parseInt);\n     * // => [6, 8, 10]\n     */\n    function parseInt(string, radix, guard) {\n      if (guard || radix == null) {\n        radix = 0;\n      } else if (radix) {\n        radix = +radix;\n      }\n      return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);\n    }\n\n    /**\n     * Repeats the given string `n` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to repeat.\n     * @param {number} [n=1] The number of times to repeat the string.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the repeated string.\n     * @example\n     *\n     * _.repeat('*', 3);\n     * // => '***'\n     *\n     * _.repeat('abc', 2);\n     * // => 'abcabc'\n     *\n     * _.repeat('abc', 0);\n     * // => ''\n     */\n    function repeat(string, n, guard) {\n      if ((guard ? isIterateeCall(string, n, guard) : n === undefined$1)) {\n        n = 1;\n      } else {\n        n = toInteger(n);\n      }\n      return baseRepeat(toString(string), n);\n    }\n\n    /**\n     * Replaces matches for `pattern` in `string` with `replacement`.\n     *\n     * **Note:** This method is based on\n     * [`String#replace`](https://mdn.io/String/replace).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to modify.\n     * @param {RegExp|string} pattern The pattern to replace.\n     * @param {Function|string} replacement The match replacement.\n     * @returns {string} Returns the modified string.\n     * @example\n     *\n     * _.replace('Hi Fred', 'Fred', 'Barney');\n     * // => 'Hi Barney'\n     */\n    function replace() {\n      var args = arguments,\n          string = toString(args[0]);\n\n      return args.length < 3 ? string : string.replace(args[1], args[2]);\n    }\n\n    /**\n     * Converts `string` to\n     * [snake case](https://en.wikipedia.org/wiki/Snake_case).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the snake cased string.\n     * @example\n     *\n     * _.snakeCase('Foo Bar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('fooBar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('--FOO-BAR--');\n     * // => 'foo_bar'\n     */\n    var snakeCase = createCompounder(function(result, word, index) {\n      return result + (index ? '_' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Splits `string` by `separator`.\n     *\n     * **Note:** This method is based on\n     * [`String#split`](https://mdn.io/String/split).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to split.\n     * @param {RegExp|string} separator The separator pattern to split by.\n     * @param {number} [limit] The length to truncate results to.\n     * @returns {Array} Returns the string segments.\n     * @example\n     *\n     * _.split('a-b-c', '-', 2);\n     * // => ['a', 'b']\n     */\n    function split(string, separator, limit) {\n      if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {\n        separator = limit = undefined$1;\n      }\n      limit = limit === undefined$1 ? MAX_ARRAY_LENGTH : limit >>> 0;\n      if (!limit) {\n        return [];\n      }\n      string = toString(string);\n      if (string && (\n            typeof separator == 'string' ||\n            (separator != null && !isRegExp(separator))\n          )) {\n        separator = baseToString(separator);\n        if (!separator && hasUnicode(string)) {\n          return castSlice(stringToArray(string), 0, limit);\n        }\n      }\n      return string.split(separator, limit);\n    }\n\n    /**\n     * Converts `string` to\n     * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.1.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the start cased string.\n     * @example\n     *\n     * _.startCase('--foo-bar--');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('fooBar');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('__FOO_BAR__');\n     * // => 'FOO BAR'\n     */\n    var startCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + upperFirst(word);\n    });\n\n    /**\n     * Checks if `string` starts with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=0] The position to search from.\n     * @returns {boolean} Returns `true` if `string` starts with `target`,\n     *  else `false`.\n     * @example\n     *\n     * _.startsWith('abc', 'a');\n     * // => true\n     *\n     * _.startsWith('abc', 'b');\n     * // => false\n     *\n     * _.startsWith('abc', 'b', 1);\n     * // => true\n     */\n    function startsWith(string, target, position) {\n      string = toString(string);\n      position = position == null\n        ? 0\n        : baseClamp(toInteger(position), 0, string.length);\n\n      target = baseToString(target);\n      return string.slice(position, position + target.length) == target;\n    }\n\n    /**\n     * Creates a compiled template function that can interpolate data properties\n     * in \"interpolate\" delimiters, HTML-escape interpolated data properties in\n     * \"escape\" delimiters, and execute JavaScript in \"evaluate\" delimiters. Data\n     * properties may be accessed as free variables in the template. If a setting\n     * object is given, it takes precedence over `_.templateSettings` values.\n     *\n     * **Note:** In the development build `_.template` utilizes\n     * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)\n     * for easier debugging.\n     *\n     * For more information on precompiling templates see\n     * [lodash's custom builds documentation](https://lodash.com/custom-builds).\n     *\n     * For more information on Chrome extension sandboxes see\n     * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The template string.\n     * @param {Object} [options={}] The options object.\n     * @param {RegExp} [options.escape=_.templateSettings.escape]\n     *  The HTML \"escape\" delimiter.\n     * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]\n     *  The \"evaluate\" delimiter.\n     * @param {Object} [options.imports=_.templateSettings.imports]\n     *  An object to import into the template as free variables.\n     * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]\n     *  The \"interpolate\" delimiter.\n     * @param {string} [options.sourceURL='lodash.templateSources[n]']\n     *  The sourceURL of the compiled template.\n     * @param {string} [options.variable='obj']\n     *  The data object variable name.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the compiled template function.\n     * @example\n     *\n     * // Use the \"interpolate\" delimiter to create a compiled template.\n     * var compiled = _.template('hello <%= user %>!');\n     * compiled({ 'user': 'fred' });\n     * // => 'hello fred!'\n     *\n     * // Use the HTML \"escape\" delimiter to escape data property values.\n     * var compiled = _.template('<b><%- value %></b>');\n     * compiled({ 'value': '<script>' });\n     * // => '<b>&lt;script&gt;</b>'\n     *\n     * // Use the \"evaluate\" delimiter to execute JavaScript and generate HTML.\n     * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // Use the internal `print` function in \"evaluate\" delimiters.\n     * var compiled = _.template('<% print(\"hello \" + user); %>!');\n     * compiled({ 'user': 'barney' });\n     * // => 'hello barney!'\n     *\n     * // Use the ES template literal delimiter as an \"interpolate\" delimiter.\n     * // Disable support by replacing the \"interpolate\" delimiter.\n     * var compiled = _.template('hello ${ user }!');\n     * compiled({ 'user': 'pebbles' });\n     * // => 'hello pebbles!'\n     *\n     * // Use backslashes to treat delimiters as plain text.\n     * var compiled = _.template('<%= \"\\\\<%- value %\\\\>\" %>');\n     * compiled({ 'value': 'ignored' });\n     * // => '<%- value %>'\n     *\n     * // Use the `imports` option to import `jQuery` as `jq`.\n     * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';\n     * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // Use the `sourceURL` option to specify a custom sourceURL for the template.\n     * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });\n     * compiled(data);\n     * // => Find the source of \"greeting.jst\" under the Sources tab or Resources panel of the web inspector.\n     *\n     * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.\n     * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });\n     * compiled.source;\n     * // => function(data) {\n     * //   var __t, __p = '';\n     * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';\n     * //   return __p;\n     * // }\n     *\n     * // Use custom template delimiters.\n     * _.templateSettings.interpolate = /{{([\\s\\S]+?)}}/g;\n     * var compiled = _.template('hello {{ user }}!');\n     * compiled({ 'user': 'mustache' });\n     * // => 'hello mustache!'\n     *\n     * // Use the `source` property to inline compiled templates for meaningful\n     * // line numbers in error messages and stack traces.\n     * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\\\n     *   var JST = {\\\n     *     \"main\": ' + _.template(mainText).source + '\\\n     *   };\\\n     * ');\n     */\n    function template(string, options, guard) {\n      // Based on John Resig's `tmpl` implementation\n      // (http://ejohn.org/blog/javascript-micro-templating/)\n      // and Laura Doktorova's doT.js (https://github.com/olado/doT).\n      var settings = lodash.templateSettings;\n\n      if (guard && isIterateeCall(string, options, guard)) {\n        options = undefined$1;\n      }\n      string = toString(string);\n      options = assignInWith({}, options, settings, customDefaultsAssignIn);\n\n      var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),\n          importsKeys = keys(imports),\n          importsValues = baseValues(imports, importsKeys);\n\n      var isEscaping,\n          isEvaluating,\n          index = 0,\n          interpolate = options.interpolate || reNoMatch,\n          source = \"__p += '\";\n\n      // Compile the regexp to match each delimiter.\n      var reDelimiters = RegExp(\n        (options.escape || reNoMatch).source + '|' +\n        interpolate.source + '|' +\n        (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +\n        (options.evaluate || reNoMatch).source + '|$'\n      , 'g');\n\n      // Use a sourceURL for easier debugging.\n      // The sourceURL gets injected into the source that's eval-ed, so be careful\n      // with lookup (in case of e.g. prototype pollution), and strip newlines if any.\n      // A newline wouldn't be a valid sourceURL anyway, and it'd enable code injection.\n      var sourceURL = '//# sourceURL=' +\n        (hasOwnProperty.call(options, 'sourceURL')\n          ? (options.sourceURL + '').replace(/[\\r\\n]/g, ' ')\n          : ('lodash.templateSources[' + (++templateCounter) + ']')\n        ) + '\\n';\n\n      string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {\n        interpolateValue || (interpolateValue = esTemplateValue);\n\n        // Escape characters that can't be included in string literals.\n        source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);\n\n        // Replace delimiters with snippets.\n        if (escapeValue) {\n          isEscaping = true;\n          source += \"' +\\n__e(\" + escapeValue + \") +\\n'\";\n        }\n        if (evaluateValue) {\n          isEvaluating = true;\n          source += \"';\\n\" + evaluateValue + \";\\n__p += '\";\n        }\n        if (interpolateValue) {\n          source += \"' +\\n((__t = (\" + interpolateValue + \")) == null ? '' : __t) +\\n'\";\n        }\n        index = offset + match.length;\n\n        // The JS engine embedded in Adobe products needs `match` returned in\n        // order to produce the correct `offset` value.\n        return match;\n      });\n\n      source += \"';\\n\";\n\n      // If `variable` is not specified wrap a with-statement around the generated\n      // code to add the data object to the top of the scope chain.\n      // Like with sourceURL, we take care to not check the option's prototype,\n      // as this configuration is a code injection vector.\n      var variable = hasOwnProperty.call(options, 'variable') && options.variable;\n      if (!variable) {\n        source = 'with (obj) {\\n' + source + '\\n}\\n';\n      }\n      // Cleanup code by stripping empty strings.\n      source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)\n        .replace(reEmptyStringMiddle, '$1')\n        .replace(reEmptyStringTrailing, '$1;');\n\n      // Frame code as the function body.\n      source = 'function(' + (variable || 'obj') + ') {\\n' +\n        (variable\n          ? ''\n          : 'obj || (obj = {});\\n'\n        ) +\n        \"var __t, __p = ''\" +\n        (isEscaping\n           ? ', __e = _.escape'\n           : ''\n        ) +\n        (isEvaluating\n          ? ', __j = Array.prototype.join;\\n' +\n            \"function print() { __p += __j.call(arguments, '') }\\n\"\n          : ';\\n'\n        ) +\n        source +\n        'return __p\\n}';\n\n      var result = attempt(function() {\n        return Function(importsKeys, sourceURL + 'return ' + source)\n          .apply(undefined$1, importsValues);\n      });\n\n      // Provide the compiled function's source by its `toString` method or\n      // the `source` property as a convenience for inlining compiled templates.\n      result.source = source;\n      if (isError(result)) {\n        throw result;\n      }\n      return result;\n    }\n\n    /**\n     * Converts `string`, as a whole, to lower case just like\n     * [String#toLowerCase](https://mdn.io/toLowerCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the lower cased string.\n     * @example\n     *\n     * _.toLower('--Foo-Bar--');\n     * // => '--foo-bar--'\n     *\n     * _.toLower('fooBar');\n     * // => 'foobar'\n     *\n     * _.toLower('__FOO_BAR__');\n     * // => '__foo_bar__'\n     */\n    function toLower(value) {\n      return toString(value).toLowerCase();\n    }\n\n    /**\n     * Converts `string`, as a whole, to upper case just like\n     * [String#toUpperCase](https://mdn.io/toUpperCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the upper cased string.\n     * @example\n     *\n     * _.toUpper('--foo-bar--');\n     * // => '--FOO-BAR--'\n     *\n     * _.toUpper('fooBar');\n     * // => 'FOOBAR'\n     *\n     * _.toUpper('__foo_bar__');\n     * // => '__FOO_BAR__'\n     */\n    function toUpper(value) {\n      return toString(value).toUpperCase();\n    }\n\n    /**\n     * Removes leading and trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trim('  abc  ');\n     * // => 'abc'\n     *\n     * _.trim('-_-abc-_-', '_-');\n     * // => 'abc'\n     *\n     * _.map(['  foo  ', '  bar  '], _.trim);\n     * // => ['foo', 'bar']\n     */\n    function trim(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined$1)) {\n        return string.replace(reTrim, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          chrSymbols = stringToArray(chars),\n          start = charsStartIndex(strSymbols, chrSymbols),\n          end = charsEndIndex(strSymbols, chrSymbols) + 1;\n\n      return castSlice(strSymbols, start, end).join('');\n    }\n\n    /**\n     * Removes trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimEnd('  abc  ');\n     * // => '  abc'\n     *\n     * _.trimEnd('-_-abc-_-', '_-');\n     * // => '-_-abc'\n     */\n    function trimEnd(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined$1)) {\n        return string.replace(reTrimEnd, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;\n\n      return castSlice(strSymbols, 0, end).join('');\n    }\n\n    /**\n     * Removes leading whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimStart('  abc  ');\n     * // => 'abc  '\n     *\n     * _.trimStart('-_-abc-_-', '_-');\n     * // => 'abc-_-'\n     */\n    function trimStart(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined$1)) {\n        return string.replace(reTrimStart, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          start = charsStartIndex(strSymbols, stringToArray(chars));\n\n      return castSlice(strSymbols, start).join('');\n    }\n\n    /**\n     * Truncates `string` if it's longer than the given maximum string length.\n     * The last characters of the truncated string are replaced with the omission\n     * string which defaults to \"...\".\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to truncate.\n     * @param {Object} [options={}] The options object.\n     * @param {number} [options.length=30] The maximum string length.\n     * @param {string} [options.omission='...'] The string to indicate text is omitted.\n     * @param {RegExp|string} [options.separator] The separator pattern to truncate to.\n     * @returns {string} Returns the truncated string.\n     * @example\n     *\n     * _.truncate('hi-diddly-ho there, neighborino');\n     * // => 'hi-diddly-ho there, neighbo...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': ' '\n     * });\n     * // => 'hi-diddly-ho there,...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': /,? +/\n     * });\n     * // => 'hi-diddly-ho there...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'omission': ' [...]'\n     * });\n     * // => 'hi-diddly-ho there, neig [...]'\n     */\n    function truncate(string, options) {\n      var length = DEFAULT_TRUNC_LENGTH,\n          omission = DEFAULT_TRUNC_OMISSION;\n\n      if (isObject(options)) {\n        var separator = 'separator' in options ? options.separator : separator;\n        length = 'length' in options ? toInteger(options.length) : length;\n        omission = 'omission' in options ? baseToString(options.omission) : omission;\n      }\n      string = toString(string);\n\n      var strLength = string.length;\n      if (hasUnicode(string)) {\n        var strSymbols = stringToArray(string);\n        strLength = strSymbols.length;\n      }\n      if (length >= strLength) {\n        return string;\n      }\n      var end = length - stringSize(omission);\n      if (end < 1) {\n        return omission;\n      }\n      var result = strSymbols\n        ? castSlice(strSymbols, 0, end).join('')\n        : string.slice(0, end);\n\n      if (separator === undefined$1) {\n        return result + omission;\n      }\n      if (strSymbols) {\n        end += (result.length - end);\n      }\n      if (isRegExp(separator)) {\n        if (string.slice(end).search(separator)) {\n          var match,\n              substring = result;\n\n          if (!separator.global) {\n            separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');\n          }\n          separator.lastIndex = 0;\n          while ((match = separator.exec(substring))) {\n            var newEnd = match.index;\n          }\n          result = result.slice(0, newEnd === undefined$1 ? end : newEnd);\n        }\n      } else if (string.indexOf(baseToString(separator), end) != end) {\n        var index = result.lastIndexOf(separator);\n        if (index > -1) {\n          result = result.slice(0, index);\n        }\n      }\n      return result + omission;\n    }\n\n    /**\n     * The inverse of `_.escape`; this method converts the HTML entities\n     * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to\n     * their corresponding characters.\n     *\n     * **Note:** No other HTML entities are unescaped. To unescape additional\n     * HTML entities use a third-party library like [_he_](https://mths.be/he).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.6.0\n     * @category String\n     * @param {string} [string=''] The string to unescape.\n     * @returns {string} Returns the unescaped string.\n     * @example\n     *\n     * _.unescape('fred, barney, &amp; pebbles');\n     * // => 'fred, barney, & pebbles'\n     */\n    function unescape(string) {\n      string = toString(string);\n      return (string && reHasEscapedHtml.test(string))\n        ? string.replace(reEscapedHtml, unescapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Converts `string`, as space separated words, to upper case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the upper cased string.\n     * @example\n     *\n     * _.upperCase('--foo-bar');\n     * // => 'FOO BAR'\n     *\n     * _.upperCase('fooBar');\n     * // => 'FOO BAR'\n     *\n     * _.upperCase('__foo_bar__');\n     * // => 'FOO BAR'\n     */\n    var upperCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + word.toUpperCase();\n    });\n\n    /**\n     * Converts the first character of `string` to upper case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.upperFirst('fred');\n     * // => 'Fred'\n     *\n     * _.upperFirst('FRED');\n     * // => 'FRED'\n     */\n    var upperFirst = createCaseFirst('toUpperCase');\n\n    /**\n     * Splits `string` into an array of its words.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {RegExp|string} [pattern] The pattern to match words.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the words of `string`.\n     * @example\n     *\n     * _.words('fred, barney, & pebbles');\n     * // => ['fred', 'barney', 'pebbles']\n     *\n     * _.words('fred, barney, & pebbles', /[^, ]+/g);\n     * // => ['fred', 'barney', '&', 'pebbles']\n     */\n    function words(string, pattern, guard) {\n      string = toString(string);\n      pattern = guard ? undefined$1 : pattern;\n\n      if (pattern === undefined$1) {\n        return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);\n      }\n      return string.match(pattern) || [];\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Attempts to invoke `func`, returning either the result or the caught error\n     * object. Any additional arguments are provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Function} func The function to attempt.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {*} Returns the `func` result or error object.\n     * @example\n     *\n     * // Avoid throwing errors for invalid selectors.\n     * var elements = _.attempt(function(selector) {\n     *   return document.querySelectorAll(selector);\n     * }, '>_>');\n     *\n     * if (_.isError(elements)) {\n     *   elements = [];\n     * }\n     */\n    var attempt = baseRest(function(func, args) {\n      try {\n        return apply(func, undefined$1, args);\n      } catch (e) {\n        return isError(e) ? e : new Error(e);\n      }\n    });\n\n    /**\n     * Binds methods of an object to the object itself, overwriting the existing\n     * method.\n     *\n     * **Note:** This method doesn't set the \"length\" property of bound functions.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {Object} object The object to bind and assign the bound methods to.\n     * @param {...(string|string[])} methodNames The object method names to bind.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var view = {\n     *   'label': 'docs',\n     *   'click': function() {\n     *     console.log('clicked ' + this.label);\n     *   }\n     * };\n     *\n     * _.bindAll(view, ['click']);\n     * jQuery(element).on('click', view.click);\n     * // => Logs 'clicked docs' when clicked.\n     */\n    var bindAll = flatRest(function(object, methodNames) {\n      arrayEach(methodNames, function(key) {\n        key = toKey(key);\n        baseAssignValue(object, key, bind(object[key], object));\n      });\n      return object;\n    });\n\n    /**\n     * Creates a function that iterates over `pairs` and invokes the corresponding\n     * function of the first predicate to return truthy. The predicate-function\n     * pairs are invoked with the `this` binding and arguments of the created\n     * function.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {Array} pairs The predicate-function pairs.\n     * @returns {Function} Returns the new composite function.\n     * @example\n     *\n     * var func = _.cond([\n     *   [_.matches({ 'a': 1 }),           _.constant('matches A')],\n     *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],\n     *   [_.stubTrue,                      _.constant('no match')]\n     * ]);\n     *\n     * func({ 'a': 1, 'b': 2 });\n     * // => 'matches A'\n     *\n     * func({ 'a': 0, 'b': 1 });\n     * // => 'matches B'\n     *\n     * func({ 'a': '1', 'b': '2' });\n     * // => 'no match'\n     */\n    function cond(pairs) {\n      var length = pairs == null ? 0 : pairs.length,\n          toIteratee = getIteratee();\n\n      pairs = !length ? [] : arrayMap(pairs, function(pair) {\n        if (typeof pair[1] != 'function') {\n          throw new TypeError(FUNC_ERROR_TEXT);\n        }\n        return [toIteratee(pair[0]), pair[1]];\n      });\n\n      return baseRest(function(args) {\n        var index = -1;\n        while (++index < length) {\n          var pair = pairs[index];\n          if (apply(pair[0], this, args)) {\n            return apply(pair[1], this, args);\n          }\n        }\n      });\n    }\n\n    /**\n     * Creates a function that invokes the predicate properties of `source` with\n     * the corresponding property values of a given object, returning `true` if\n     * all predicates return truthy, else `false`.\n     *\n     * **Note:** The created function is equivalent to `_.conformsTo` with\n     * `source` partially applied.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 2, 'b': 1 },\n     *   { 'a': 1, 'b': 2 }\n     * ];\n     *\n     * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));\n     * // => [{ 'a': 1, 'b': 2 }]\n     */\n    function conforms(source) {\n      return baseConforms(baseClone(source, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that returns `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Util\n     * @param {*} value The value to return from the new function.\n     * @returns {Function} Returns the new constant function.\n     * @example\n     *\n     * var objects = _.times(2, _.constant({ 'a': 1 }));\n     *\n     * console.log(objects);\n     * // => [{ 'a': 1 }, { 'a': 1 }]\n     *\n     * console.log(objects[0] === objects[1]);\n     * // => true\n     */\n    function constant(value) {\n      return function() {\n        return value;\n      };\n    }\n\n    /**\n     * Checks `value` to determine whether a default value should be returned in\n     * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,\n     * or `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.14.0\n     * @category Util\n     * @param {*} value The value to check.\n     * @param {*} defaultValue The default value.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * _.defaultTo(1, 10);\n     * // => 1\n     *\n     * _.defaultTo(undefined, 10);\n     * // => 10\n     */\n    function defaultTo(value, defaultValue) {\n      return (value == null || value !== value) ? defaultValue : value;\n    }\n\n    /**\n     * Creates a function that returns the result of invoking the given functions\n     * with the `this` binding of the created function, where each successive\n     * invocation is supplied the return value of the previous.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [funcs] The functions to invoke.\n     * @returns {Function} Returns the new composite function.\n     * @see _.flowRight\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flow([_.add, square]);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flow = createFlow();\n\n    /**\n     * This method is like `_.flow` except that it creates a function that\n     * invokes the given functions from right to left.\n     *\n     * @static\n     * @since 3.0.0\n     * @memberOf _\n     * @category Util\n     * @param {...(Function|Function[])} [funcs] The functions to invoke.\n     * @returns {Function} Returns the new composite function.\n     * @see _.flow\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flowRight([square, _.add]);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flowRight = createFlow(true);\n\n    /**\n     * This method returns the first argument it receives.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {*} value Any value.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     *\n     * console.log(_.identity(object) === object);\n     * // => true\n     */\n    function identity(value) {\n      return value;\n    }\n\n    /**\n     * Creates a function that invokes `func` with the arguments of the created\n     * function. If `func` is a property name, the created function returns the\n     * property value for a given element. If `func` is an array or object, the\n     * created function returns `true` for elements that contain the equivalent\n     * source properties, otherwise it returns `false`.\n     *\n     * @static\n     * @since 4.0.0\n     * @memberOf _\n     * @category Util\n     * @param {*} [func=_.identity] The value to convert to a callback.\n     * @returns {Function} Returns the callback.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));\n     * // => [{ 'user': 'barney', 'age': 36, 'active': true }]\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.filter(users, _.iteratee(['user', 'fred']));\n     * // => [{ 'user': 'fred', 'age': 40 }]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.map(users, _.iteratee('user'));\n     * // => ['barney', 'fred']\n     *\n     * // Create custom iteratee shorthands.\n     * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {\n     *   return !_.isRegExp(func) ? iteratee(func) : function(string) {\n     *     return func.test(string);\n     *   };\n     * });\n     *\n     * _.filter(['abc', 'def'], /ef/);\n     * // => ['def']\n     */\n    function iteratee(func) {\n      return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that performs a partial deep comparison between a given\n     * object and `source`, returning `true` if the given object has equivalent\n     * property values, else `false`.\n     *\n     * **Note:** The created function is equivalent to `_.isMatch` with `source`\n     * partially applied.\n     *\n     * Partial comparisons will match empty array and empty object `source`\n     * values against any array or object value, respectively. See `_.isEqual`\n     * for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 1, 'b': 2, 'c': 3 },\n     *   { 'a': 4, 'b': 5, 'c': 6 }\n     * ];\n     *\n     * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));\n     * // => [{ 'a': 4, 'b': 5, 'c': 6 }]\n     */\n    function matches(source) {\n      return baseMatches(baseClone(source, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that performs a partial deep comparison between the\n     * value at `path` of a given object to `srcValue`, returning `true` if the\n     * object value is equivalent, else `false`.\n     *\n     * **Note:** Partial comparisons will match empty array and empty object\n     * `srcValue` values against any array or object value, respectively. See\n     * `_.isEqual` for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Util\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 1, 'b': 2, 'c': 3 },\n     *   { 'a': 4, 'b': 5, 'c': 6 }\n     * ];\n     *\n     * _.find(objects, _.matchesProperty('a', 4));\n     * // => { 'a': 4, 'b': 5, 'c': 6 }\n     */\n    function matchesProperty(path, srcValue) {\n      return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that invokes the method at `path` of a given object.\n     * Any additional arguments are provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Util\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new invoker function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': _.constant(2) } },\n     *   { 'a': { 'b': _.constant(1) } }\n     * ];\n     *\n     * _.map(objects, _.method('a.b'));\n     * // => [2, 1]\n     *\n     * _.map(objects, _.method(['a', 'b']));\n     * // => [2, 1]\n     */\n    var method = baseRest(function(path, args) {\n      return function(object) {\n        return baseInvoke(object, path, args);\n      };\n    });\n\n    /**\n     * The opposite of `_.method`; this method creates a function that invokes\n     * the method at a given path of `object`. Any additional arguments are\n     * provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Util\n     * @param {Object} object The object to query.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new invoker function.\n     * @example\n     *\n     * var array = _.times(3, _.constant),\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.methodOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.methodOf(object));\n     * // => [2, 0]\n     */\n    var methodOf = baseRest(function(object, args) {\n      return function(path) {\n        return baseInvoke(object, path, args);\n      };\n    });\n\n    /**\n     * Adds all own enumerable string keyed function properties of a source\n     * object to the destination object. If `object` is a function, then methods\n     * are added to its prototype as well.\n     *\n     * **Note:** Use `_.runInContext` to create a pristine `lodash` function to\n     * avoid conflicts caused by modifying the original.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {Function|Object} [object=lodash] The destination object.\n     * @param {Object} source The object of functions to add.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.chain=true] Specify whether mixins are chainable.\n     * @returns {Function|Object} Returns `object`.\n     * @example\n     *\n     * function vowels(string) {\n     *   return _.filter(string, function(v) {\n     *     return /[aeiou]/i.test(v);\n     *   });\n     * }\n     *\n     * _.mixin({ 'vowels': vowels });\n     * _.vowels('fred');\n     * // => ['e']\n     *\n     * _('fred').vowels().value();\n     * // => ['e']\n     *\n     * _.mixin({ 'vowels': vowels }, { 'chain': false });\n     * _('fred').vowels();\n     * // => ['e']\n     */\n    function mixin(object, source, options) {\n      var props = keys(source),\n          methodNames = baseFunctions(source, props);\n\n      if (options == null &&\n          !(isObject(source) && (methodNames.length || !props.length))) {\n        options = source;\n        source = object;\n        object = this;\n        methodNames = baseFunctions(source, keys(source));\n      }\n      var chain = !(isObject(options) && 'chain' in options) || !!options.chain,\n          isFunc = isFunction(object);\n\n      arrayEach(methodNames, function(methodName) {\n        var func = source[methodName];\n        object[methodName] = func;\n        if (isFunc) {\n          object.prototype[methodName] = function() {\n            var chainAll = this.__chain__;\n            if (chain || chainAll) {\n              var result = object(this.__wrapped__),\n                  actions = result.__actions__ = copyArray(this.__actions__);\n\n              actions.push({ 'func': func, 'args': arguments, 'thisArg': object });\n              result.__chain__ = chainAll;\n              return result;\n            }\n            return func.apply(object, arrayPush([this.value()], arguments));\n          };\n        }\n      });\n\n      return object;\n    }\n\n    /**\n     * Reverts the `_` variable to its previous value and returns a reference to\n     * the `lodash` function.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @returns {Function} Returns the `lodash` function.\n     * @example\n     *\n     * var lodash = _.noConflict();\n     */\n    function noConflict() {\n      if (root._ === this) {\n        root._ = oldDash;\n      }\n      return this;\n    }\n\n    /**\n     * This method returns `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.3.0\n     * @category Util\n     * @example\n     *\n     * _.times(2, _.noop);\n     * // => [undefined, undefined]\n     */\n    function noop() {\n      // No operation performed.\n    }\n\n    /**\n     * Creates a function that gets the argument at index `n`. If `n` is negative,\n     * the nth argument from the end is returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {number} [n=0] The index of the argument to return.\n     * @returns {Function} Returns the new pass-thru function.\n     * @example\n     *\n     * var func = _.nthArg(1);\n     * func('a', 'b', 'c', 'd');\n     * // => 'b'\n     *\n     * var func = _.nthArg(-2);\n     * func('a', 'b', 'c', 'd');\n     * // => 'c'\n     */\n    function nthArg(n) {\n      n = toInteger(n);\n      return baseRest(function(args) {\n        return baseNth(args, n);\n      });\n    }\n\n    /**\n     * Creates a function that invokes `iteratees` with the arguments it receives\n     * and returns their results.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [iteratees=[_.identity]]\n     *  The iteratees to invoke.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.over([Math.max, Math.min]);\n     *\n     * func(1, 2, 3, 4);\n     * // => [4, 1]\n     */\n    var over = createOver(arrayMap);\n\n    /**\n     * Creates a function that checks if **all** of the `predicates` return\n     * truthy when invoked with the arguments it receives.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [predicates=[_.identity]]\n     *  The predicates to check.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.overEvery([Boolean, isFinite]);\n     *\n     * func('1');\n     * // => true\n     *\n     * func(null);\n     * // => false\n     *\n     * func(NaN);\n     * // => false\n     */\n    var overEvery = createOver(arrayEvery);\n\n    /**\n     * Creates a function that checks if **any** of the `predicates` return\n     * truthy when invoked with the arguments it receives.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [predicates=[_.identity]]\n     *  The predicates to check.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.overSome([Boolean, isFinite]);\n     *\n     * func('1');\n     * // => true\n     *\n     * func(null);\n     * // => true\n     *\n     * func(NaN);\n     * // => false\n     */\n    var overSome = createOver(arraySome);\n\n    /**\n     * Creates a function that returns the value at `path` of a given object.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Util\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new accessor function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': 2 } },\n     *   { 'a': { 'b': 1 } }\n     * ];\n     *\n     * _.map(objects, _.property('a.b'));\n     * // => [2, 1]\n     *\n     * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');\n     * // => [1, 2]\n     */\n    function property(path) {\n      return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n    }\n\n    /**\n     * The opposite of `_.property`; this method creates a function that returns\n     * the value at a given path of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Object} object The object to query.\n     * @returns {Function} Returns the new accessor function.\n     * @example\n     *\n     * var array = [0, 1, 2],\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.propertyOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));\n     * // => [2, 0]\n     */\n    function propertyOf(object) {\n      return function(path) {\n        return object == null ? undefined$1 : baseGet(object, path);\n      };\n    }\n\n    /**\n     * Creates an array of numbers (positive and/or negative) progressing from\n     * `start` up to, but not including, `end`. A step of `-1` is used if a negative\n     * `start` is specified without an `end` or `step`. If `end` is not specified,\n     * it's set to `start` with `start` then set to `0`.\n     *\n     * **Note:** JavaScript follows the IEEE-754 standard for resolving\n     * floating-point values which can produce unexpected results.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the range of numbers.\n     * @see _.inRange, _.rangeRight\n     * @example\n     *\n     * _.range(4);\n     * // => [0, 1, 2, 3]\n     *\n     * _.range(-4);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 5);\n     * // => [1, 2, 3, 4]\n     *\n     * _.range(0, 20, 5);\n     * // => [0, 5, 10, 15]\n     *\n     * _.range(0, -4, -1);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.range(0);\n     * // => []\n     */\n    var range = createRange();\n\n    /**\n     * This method is like `_.range` except that it populates values in\n     * descending order.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the range of numbers.\n     * @see _.inRange, _.range\n     * @example\n     *\n     * _.rangeRight(4);\n     * // => [3, 2, 1, 0]\n     *\n     * _.rangeRight(-4);\n     * // => [-3, -2, -1, 0]\n     *\n     * _.rangeRight(1, 5);\n     * // => [4, 3, 2, 1]\n     *\n     * _.rangeRight(0, 20, 5);\n     * // => [15, 10, 5, 0]\n     *\n     * _.rangeRight(0, -4, -1);\n     * // => [-3, -2, -1, 0]\n     *\n     * _.rangeRight(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.rangeRight(0);\n     * // => []\n     */\n    var rangeRight = createRange(true);\n\n    /**\n     * This method returns a new empty array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {Array} Returns the new empty array.\n     * @example\n     *\n     * var arrays = _.times(2, _.stubArray);\n     *\n     * console.log(arrays);\n     * // => [[], []]\n     *\n     * console.log(arrays[0] === arrays[1]);\n     * // => false\n     */\n    function stubArray() {\n      return [];\n    }\n\n    /**\n     * This method returns `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {boolean} Returns `false`.\n     * @example\n     *\n     * _.times(2, _.stubFalse);\n     * // => [false, false]\n     */\n    function stubFalse() {\n      return false;\n    }\n\n    /**\n     * This method returns a new empty object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {Object} Returns the new empty object.\n     * @example\n     *\n     * var objects = _.times(2, _.stubObject);\n     *\n     * console.log(objects);\n     * // => [{}, {}]\n     *\n     * console.log(objects[0] === objects[1]);\n     * // => false\n     */\n    function stubObject() {\n      return {};\n    }\n\n    /**\n     * This method returns an empty string.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {string} Returns the empty string.\n     * @example\n     *\n     * _.times(2, _.stubString);\n     * // => ['', '']\n     */\n    function stubString() {\n      return '';\n    }\n\n    /**\n     * This method returns `true`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {boolean} Returns `true`.\n     * @example\n     *\n     * _.times(2, _.stubTrue);\n     * // => [true, true]\n     */\n    function stubTrue() {\n      return true;\n    }\n\n    /**\n     * Invokes the iteratee `n` times, returning an array of the results of\n     * each invocation. The iteratee is invoked with one argument; (index).\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {number} n The number of times to invoke `iteratee`.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * _.times(3, String);\n     * // => ['0', '1', '2']\n     *\n     *  _.times(4, _.constant(0));\n     * // => [0, 0, 0, 0]\n     */\n    function times(n, iteratee) {\n      n = toInteger(n);\n      if (n < 1 || n > MAX_SAFE_INTEGER) {\n        return [];\n      }\n      var index = MAX_ARRAY_LENGTH,\n          length = nativeMin(n, MAX_ARRAY_LENGTH);\n\n      iteratee = getIteratee(iteratee);\n      n -= MAX_ARRAY_LENGTH;\n\n      var result = baseTimes(length, iteratee);\n      while (++index < n) {\n        iteratee(index);\n      }\n      return result;\n    }\n\n    /**\n     * Converts `value` to a property path array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the new property path array.\n     * @example\n     *\n     * _.toPath('a.b.c');\n     * // => ['a', 'b', 'c']\n     *\n     * _.toPath('a[0].b.c');\n     * // => ['a', '0', 'b', 'c']\n     */\n    function toPath(value) {\n      if (isArray(value)) {\n        return arrayMap(value, toKey);\n      }\n      return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));\n    }\n\n    /**\n     * Generates a unique ID. If `prefix` is given, the ID is appended to it.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {string} [prefix=''] The value to prefix the ID with.\n     * @returns {string} Returns the unique ID.\n     * @example\n     *\n     * _.uniqueId('contact_');\n     * // => 'contact_104'\n     *\n     * _.uniqueId();\n     * // => '105'\n     */\n    function uniqueId(prefix) {\n      var id = ++idCounter;\n      return toString(prefix) + id;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Adds two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.4.0\n     * @category Math\n     * @param {number} augend The first number in an addition.\n     * @param {number} addend The second number in an addition.\n     * @returns {number} Returns the total.\n     * @example\n     *\n     * _.add(6, 4);\n     * // => 10\n     */\n    var add = createMathOperation(function(augend, addend) {\n      return augend + addend;\n    }, 0);\n\n    /**\n     * Computes `number` rounded up to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round up.\n     * @param {number} [precision=0] The precision to round up to.\n     * @returns {number} Returns the rounded up number.\n     * @example\n     *\n     * _.ceil(4.006);\n     * // => 5\n     *\n     * _.ceil(6.004, 2);\n     * // => 6.01\n     *\n     * _.ceil(6040, -2);\n     * // => 6100\n     */\n    var ceil = createRound('ceil');\n\n    /**\n     * Divide two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {number} dividend The first number in a division.\n     * @param {number} divisor The second number in a division.\n     * @returns {number} Returns the quotient.\n     * @example\n     *\n     * _.divide(6, 4);\n     * // => 1.5\n     */\n    var divide = createMathOperation(function(dividend, divisor) {\n      return dividend / divisor;\n    }, 1);\n\n    /**\n     * Computes `number` rounded down to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round down.\n     * @param {number} [precision=0] The precision to round down to.\n     * @returns {number} Returns the rounded down number.\n     * @example\n     *\n     * _.floor(4.006);\n     * // => 4\n     *\n     * _.floor(0.046, 2);\n     * // => 0.04\n     *\n     * _.floor(4060, -2);\n     * // => 4000\n     */\n    var floor = createRound('floor');\n\n    /**\n     * Computes the maximum value of `array`. If `array` is empty or falsey,\n     * `undefined` is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * _.max([4, 2, 8, 6]);\n     * // => 8\n     *\n     * _.max([]);\n     * // => undefined\n     */\n    function max(array) {\n      return (array && array.length)\n        ? baseExtremum(array, identity, baseGt)\n        : undefined$1;\n    }\n\n    /**\n     * This method is like `_.max` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * the value is ranked. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * var objects = [{ 'n': 1 }, { 'n': 2 }];\n     *\n     * _.maxBy(objects, function(o) { return o.n; });\n     * // => { 'n': 2 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.maxBy(objects, 'n');\n     * // => { 'n': 2 }\n     */\n    function maxBy(array, iteratee) {\n      return (array && array.length)\n        ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)\n        : undefined$1;\n    }\n\n    /**\n     * Computes the mean of the values in `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {number} Returns the mean.\n     * @example\n     *\n     * _.mean([4, 2, 8, 6]);\n     * // => 5\n     */\n    function mean(array) {\n      return baseMean(array, identity);\n    }\n\n    /**\n     * This method is like `_.mean` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the value to be averaged.\n     * The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the mean.\n     * @example\n     *\n     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n     *\n     * _.meanBy(objects, function(o) { return o.n; });\n     * // => 5\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.meanBy(objects, 'n');\n     * // => 5\n     */\n    function meanBy(array, iteratee) {\n      return baseMean(array, getIteratee(iteratee, 2));\n    }\n\n    /**\n     * Computes the minimum value of `array`. If `array` is empty or falsey,\n     * `undefined` is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * _.min([4, 2, 8, 6]);\n     * // => 2\n     *\n     * _.min([]);\n     * // => undefined\n     */\n    function min(array) {\n      return (array && array.length)\n        ? baseExtremum(array, identity, baseLt)\n        : undefined$1;\n    }\n\n    /**\n     * This method is like `_.min` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * the value is ranked. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * var objects = [{ 'n': 1 }, { 'n': 2 }];\n     *\n     * _.minBy(objects, function(o) { return o.n; });\n     * // => { 'n': 1 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.minBy(objects, 'n');\n     * // => { 'n': 1 }\n     */\n    function minBy(array, iteratee) {\n      return (array && array.length)\n        ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)\n        : undefined$1;\n    }\n\n    /**\n     * Multiply two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {number} multiplier The first number in a multiplication.\n     * @param {number} multiplicand The second number in a multiplication.\n     * @returns {number} Returns the product.\n     * @example\n     *\n     * _.multiply(6, 4);\n     * // => 24\n     */\n    var multiply = createMathOperation(function(multiplier, multiplicand) {\n      return multiplier * multiplicand;\n    }, 1);\n\n    /**\n     * Computes `number` rounded to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round.\n     * @param {number} [precision=0] The precision to round to.\n     * @returns {number} Returns the rounded number.\n     * @example\n     *\n     * _.round(4.006);\n     * // => 4\n     *\n     * _.round(4.006, 2);\n     * // => 4.01\n     *\n     * _.round(4060, -2);\n     * // => 4100\n     */\n    var round = createRound('round');\n\n    /**\n     * Subtract two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {number} minuend The first number in a subtraction.\n     * @param {number} subtrahend The second number in a subtraction.\n     * @returns {number} Returns the difference.\n     * @example\n     *\n     * _.subtract(6, 4);\n     * // => 2\n     */\n    var subtract = createMathOperation(function(minuend, subtrahend) {\n      return minuend - subtrahend;\n    }, 0);\n\n    /**\n     * Computes the sum of the values in `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.4.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * _.sum([4, 2, 8, 6]);\n     * // => 20\n     */\n    function sum(array) {\n      return (array && array.length)\n        ? baseSum(array, identity)\n        : 0;\n    }\n\n    /**\n     * This method is like `_.sum` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the value to be summed.\n     * The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n     *\n     * _.sumBy(objects, function(o) { return o.n; });\n     * // => 20\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sumBy(objects, 'n');\n     * // => 20\n     */\n    function sumBy(array, iteratee) {\n      return (array && array.length)\n        ? baseSum(array, getIteratee(iteratee, 2))\n        : 0;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    // Add methods that return wrapped values in chain sequences.\n    lodash.after = after;\n    lodash.ary = ary;\n    lodash.assign = assign;\n    lodash.assignIn = assignIn;\n    lodash.assignInWith = assignInWith;\n    lodash.assignWith = assignWith;\n    lodash.at = at;\n    lodash.before = before;\n    lodash.bind = bind;\n    lodash.bindAll = bindAll;\n    lodash.bindKey = bindKey;\n    lodash.castArray = castArray;\n    lodash.chain = chain;\n    lodash.chunk = chunk;\n    lodash.compact = compact;\n    lodash.concat = concat;\n    lodash.cond = cond;\n    lodash.conforms = conforms;\n    lodash.constant = constant;\n    lodash.countBy = countBy;\n    lodash.create = create;\n    lodash.curry = curry;\n    lodash.curryRight = curryRight;\n    lodash.debounce = debounce;\n    lodash.defaults = defaults;\n    lodash.defaultsDeep = defaultsDeep;\n    lodash.defer = defer;\n    lodash.delay = delay;\n    lodash.difference = difference;\n    lodash.differenceBy = differenceBy;\n    lodash.differenceWith = differenceWith;\n    lodash.drop = drop;\n    lodash.dropRight = dropRight;\n    lodash.dropRightWhile = dropRightWhile;\n    lodash.dropWhile = dropWhile;\n    lodash.fill = fill;\n    lodash.filter = filter;\n    lodash.flatMap = flatMap;\n    lodash.flatMapDeep = flatMapDeep;\n    lodash.flatMapDepth = flatMapDepth;\n    lodash.flatten = flatten;\n    lodash.flattenDeep = flattenDeep;\n    lodash.flattenDepth = flattenDepth;\n    lodash.flip = flip;\n    lodash.flow = flow;\n    lodash.flowRight = flowRight;\n    lodash.fromPairs = fromPairs;\n    lodash.functions = functions;\n    lodash.functionsIn = functionsIn;\n    lodash.groupBy = groupBy;\n    lodash.initial = initial;\n    lodash.intersection = intersection;\n    lodash.intersectionBy = intersectionBy;\n    lodash.intersectionWith = intersectionWith;\n    lodash.invert = invert;\n    lodash.invertBy = invertBy;\n    lodash.invokeMap = invokeMap;\n    lodash.iteratee = iteratee;\n    lodash.keyBy = keyBy;\n    lodash.keys = keys;\n    lodash.keysIn = keysIn;\n    lodash.map = map;\n    lodash.mapKeys = mapKeys;\n    lodash.mapValues = mapValues;\n    lodash.matches = matches;\n    lodash.matchesProperty = matchesProperty;\n    lodash.memoize = memoize;\n    lodash.merge = merge;\n    lodash.mergeWith = mergeWith;\n    lodash.method = method;\n    lodash.methodOf = methodOf;\n    lodash.mixin = mixin;\n    lodash.negate = negate;\n    lodash.nthArg = nthArg;\n    lodash.omit = omit;\n    lodash.omitBy = omitBy;\n    lodash.once = once;\n    lodash.orderBy = orderBy;\n    lodash.over = over;\n    lodash.overArgs = overArgs;\n    lodash.overEvery = overEvery;\n    lodash.overSome = overSome;\n    lodash.partial = partial;\n    lodash.partialRight = partialRight;\n    lodash.partition = partition;\n    lodash.pick = pick;\n    lodash.pickBy = pickBy;\n    lodash.property = property;\n    lodash.propertyOf = propertyOf;\n    lodash.pull = pull;\n    lodash.pullAll = pullAll;\n    lodash.pullAllBy = pullAllBy;\n    lodash.pullAllWith = pullAllWith;\n    lodash.pullAt = pullAt;\n    lodash.range = range;\n    lodash.rangeRight = rangeRight;\n    lodash.rearg = rearg;\n    lodash.reject = reject;\n    lodash.remove = remove;\n    lodash.rest = rest;\n    lodash.reverse = reverse;\n    lodash.sampleSize = sampleSize;\n    lodash.set = set;\n    lodash.setWith = setWith;\n    lodash.shuffle = shuffle;\n    lodash.slice = slice;\n    lodash.sortBy = sortBy;\n    lodash.sortedUniq = sortedUniq;\n    lodash.sortedUniqBy = sortedUniqBy;\n    lodash.split = split;\n    lodash.spread = spread;\n    lodash.tail = tail;\n    lodash.take = take;\n    lodash.takeRight = takeRight;\n    lodash.takeRightWhile = takeRightWhile;\n    lodash.takeWhile = takeWhile;\n    lodash.tap = tap;\n    lodash.throttle = throttle;\n    lodash.thru = thru;\n    lodash.toArray = toArray;\n    lodash.toPairs = toPairs;\n    lodash.toPairsIn = toPairsIn;\n    lodash.toPath = toPath;\n    lodash.toPlainObject = toPlainObject;\n    lodash.transform = transform;\n    lodash.unary = unary;\n    lodash.union = union;\n    lodash.unionBy = unionBy;\n    lodash.unionWith = unionWith;\n    lodash.uniq = uniq;\n    lodash.uniqBy = uniqBy;\n    lodash.uniqWith = uniqWith;\n    lodash.unset = unset;\n    lodash.unzip = unzip;\n    lodash.unzipWith = unzipWith;\n    lodash.update = update;\n    lodash.updateWith = updateWith;\n    lodash.values = values;\n    lodash.valuesIn = valuesIn;\n    lodash.without = without;\n    lodash.words = words;\n    lodash.wrap = wrap;\n    lodash.xor = xor;\n    lodash.xorBy = xorBy;\n    lodash.xorWith = xorWith;\n    lodash.zip = zip;\n    lodash.zipObject = zipObject;\n    lodash.zipObjectDeep = zipObjectDeep;\n    lodash.zipWith = zipWith;\n\n    // Add aliases.\n    lodash.entries = toPairs;\n    lodash.entriesIn = toPairsIn;\n    lodash.extend = assignIn;\n    lodash.extendWith = assignInWith;\n\n    // Add methods to `lodash.prototype`.\n    mixin(lodash, lodash);\n\n    /*------------------------------------------------------------------------*/\n\n    // Add methods that return unwrapped values in chain sequences.\n    lodash.add = add;\n    lodash.attempt = attempt;\n    lodash.camelCase = camelCase;\n    lodash.capitalize = capitalize;\n    lodash.ceil = ceil;\n    lodash.clamp = clamp;\n    lodash.clone = clone;\n    lodash.cloneDeep = cloneDeep;\n    lodash.cloneDeepWith = cloneDeepWith;\n    lodash.cloneWith = cloneWith;\n    lodash.conformsTo = conformsTo;\n    lodash.deburr = deburr;\n    lodash.defaultTo = defaultTo;\n    lodash.divide = divide;\n    lodash.endsWith = endsWith;\n    lodash.eq = eq;\n    lodash.escape = escape;\n    lodash.escapeRegExp = escapeRegExp;\n    lodash.every = every;\n    lodash.find = find;\n    lodash.findIndex = findIndex;\n    lodash.findKey = findKey;\n    lodash.findLast = findLast;\n    lodash.findLastIndex = findLastIndex;\n    lodash.findLastKey = findLastKey;\n    lodash.floor = floor;\n    lodash.forEach = forEach;\n    lodash.forEachRight = forEachRight;\n    lodash.forIn = forIn;\n    lodash.forInRight = forInRight;\n    lodash.forOwn = forOwn;\n    lodash.forOwnRight = forOwnRight;\n    lodash.get = get;\n    lodash.gt = gt;\n    lodash.gte = gte;\n    lodash.has = has;\n    lodash.hasIn = hasIn;\n    lodash.head = head;\n    lodash.identity = identity;\n    lodash.includes = includes;\n    lodash.indexOf = indexOf;\n    lodash.inRange = inRange;\n    lodash.invoke = invoke;\n    lodash.isArguments = isArguments;\n    lodash.isArray = isArray;\n    lodash.isArrayBuffer = isArrayBuffer;\n    lodash.isArrayLike = isArrayLike;\n    lodash.isArrayLikeObject = isArrayLikeObject;\n    lodash.isBoolean = isBoolean;\n    lodash.isBuffer = isBuffer;\n    lodash.isDate = isDate;\n    lodash.isElement = isElement;\n    lodash.isEmpty = isEmpty;\n    lodash.isEqual = isEqual;\n    lodash.isEqualWith = isEqualWith;\n    lodash.isError = isError;\n    lodash.isFinite = isFinite;\n    lodash.isFunction = isFunction;\n    lodash.isInteger = isInteger;\n    lodash.isLength = isLength;\n    lodash.isMap = isMap;\n    lodash.isMatch = isMatch;\n    lodash.isMatchWith = isMatchWith;\n    lodash.isNaN = isNaN;\n    lodash.isNative = isNative;\n    lodash.isNil = isNil;\n    lodash.isNull = isNull;\n    lodash.isNumber = isNumber;\n    lodash.isObject = isObject;\n    lodash.isObjectLike = isObjectLike;\n    lodash.isPlainObject = isPlainObject;\n    lodash.isRegExp = isRegExp;\n    lodash.isSafeInteger = isSafeInteger;\n    lodash.isSet = isSet;\n    lodash.isString = isString;\n    lodash.isSymbol = isSymbol;\n    lodash.isTypedArray = isTypedArray;\n    lodash.isUndefined = isUndefined;\n    lodash.isWeakMap = isWeakMap;\n    lodash.isWeakSet = isWeakSet;\n    lodash.join = join;\n    lodash.kebabCase = kebabCase;\n    lodash.last = last;\n    lodash.lastIndexOf = lastIndexOf;\n    lodash.lowerCase = lowerCase;\n    lodash.lowerFirst = lowerFirst;\n    lodash.lt = lt;\n    lodash.lte = lte;\n    lodash.max = max;\n    lodash.maxBy = maxBy;\n    lodash.mean = mean;\n    lodash.meanBy = meanBy;\n    lodash.min = min;\n    lodash.minBy = minBy;\n    lodash.stubArray = stubArray;\n    lodash.stubFalse = stubFalse;\n    lodash.stubObject = stubObject;\n    lodash.stubString = stubString;\n    lodash.stubTrue = stubTrue;\n    lodash.multiply = multiply;\n    lodash.nth = nth;\n    lodash.noConflict = noConflict;\n    lodash.noop = noop;\n    lodash.now = now;\n    lodash.pad = pad;\n    lodash.padEnd = padEnd;\n    lodash.padStart = padStart;\n    lodash.parseInt = parseInt;\n    lodash.random = random;\n    lodash.reduce = reduce;\n    lodash.reduceRight = reduceRight;\n    lodash.repeat = repeat;\n    lodash.replace = replace;\n    lodash.result = result;\n    lodash.round = round;\n    lodash.runInContext = runInContext;\n    lodash.sample = sample;\n    lodash.size = size;\n    lodash.snakeCase = snakeCase;\n    lodash.some = some;\n    lodash.sortedIndex = sortedIndex;\n    lodash.sortedIndexBy = sortedIndexBy;\n    lodash.sortedIndexOf = sortedIndexOf;\n    lodash.sortedLastIndex = sortedLastIndex;\n    lodash.sortedLastIndexBy = sortedLastIndexBy;\n    lodash.sortedLastIndexOf = sortedLastIndexOf;\n    lodash.startCase = startCase;\n    lodash.startsWith = startsWith;\n    lodash.subtract = subtract;\n    lodash.sum = sum;\n    lodash.sumBy = sumBy;\n    lodash.template = template;\n    lodash.times = times;\n    lodash.toFinite = toFinite;\n    lodash.toInteger = toInteger;\n    lodash.toLength = toLength;\n    lodash.toLower = toLower;\n    lodash.toNumber = toNumber;\n    lodash.toSafeInteger = toSafeInteger;\n    lodash.toString = toString;\n    lodash.toUpper = toUpper;\n    lodash.trim = trim;\n    lodash.trimEnd = trimEnd;\n    lodash.trimStart = trimStart;\n    lodash.truncate = truncate;\n    lodash.unescape = unescape;\n    lodash.uniqueId = uniqueId;\n    lodash.upperCase = upperCase;\n    lodash.upperFirst = upperFirst;\n\n    // Add aliases.\n    lodash.each = forEach;\n    lodash.eachRight = forEachRight;\n    lodash.first = head;\n\n    mixin(lodash, (function() {\n      var source = {};\n      baseForOwn(lodash, function(func, methodName) {\n        if (!hasOwnProperty.call(lodash.prototype, methodName)) {\n          source[methodName] = func;\n        }\n      });\n      return source;\n    }()), { 'chain': false });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The semantic version number.\n     *\n     * @static\n     * @memberOf _\n     * @type {string}\n     */\n    lodash.VERSION = VERSION;\n\n    // Assign default placeholders.\n    arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {\n      lodash[methodName].placeholder = lodash;\n    });\n\n    // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.\n    arrayEach(['drop', 'take'], function(methodName, index) {\n      LazyWrapper.prototype[methodName] = function(n) {\n        n = n === undefined$1 ? 1 : nativeMax(toInteger(n), 0);\n\n        var result = (this.__filtered__ && !index)\n          ? new LazyWrapper(this)\n          : this.clone();\n\n        if (result.__filtered__) {\n          result.__takeCount__ = nativeMin(n, result.__takeCount__);\n        } else {\n          result.__views__.push({\n            'size': nativeMin(n, MAX_ARRAY_LENGTH),\n            'type': methodName + (result.__dir__ < 0 ? 'Right' : '')\n          });\n        }\n        return result;\n      };\n\n      LazyWrapper.prototype[methodName + 'Right'] = function(n) {\n        return this.reverse()[methodName](n).reverse();\n      };\n    });\n\n    // Add `LazyWrapper` methods that accept an `iteratee` value.\n    arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {\n      var type = index + 1,\n          isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;\n\n      LazyWrapper.prototype[methodName] = function(iteratee) {\n        var result = this.clone();\n        result.__iteratees__.push({\n          'iteratee': getIteratee(iteratee, 3),\n          'type': type\n        });\n        result.__filtered__ = result.__filtered__ || isFilter;\n        return result;\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.head` and `_.last`.\n    arrayEach(['head', 'last'], function(methodName, index) {\n      var takeName = 'take' + (index ? 'Right' : '');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this[takeName](1).value()[0];\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.initial` and `_.tail`.\n    arrayEach(['initial', 'tail'], function(methodName, index) {\n      var dropName = 'drop' + (index ? '' : 'Right');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);\n      };\n    });\n\n    LazyWrapper.prototype.compact = function() {\n      return this.filter(identity);\n    };\n\n    LazyWrapper.prototype.find = function(predicate) {\n      return this.filter(predicate).head();\n    };\n\n    LazyWrapper.prototype.findLast = function(predicate) {\n      return this.reverse().find(predicate);\n    };\n\n    LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {\n      if (typeof path == 'function') {\n        return new LazyWrapper(this);\n      }\n      return this.map(function(value) {\n        return baseInvoke(value, path, args);\n      });\n    });\n\n    LazyWrapper.prototype.reject = function(predicate) {\n      return this.filter(negate(getIteratee(predicate)));\n    };\n\n    LazyWrapper.prototype.slice = function(start, end) {\n      start = toInteger(start);\n\n      var result = this;\n      if (result.__filtered__ && (start > 0 || end < 0)) {\n        return new LazyWrapper(result);\n      }\n      if (start < 0) {\n        result = result.takeRight(-start);\n      } else if (start) {\n        result = result.drop(start);\n      }\n      if (end !== undefined$1) {\n        end = toInteger(end);\n        result = end < 0 ? result.dropRight(-end) : result.take(end - start);\n      }\n      return result;\n    };\n\n    LazyWrapper.prototype.takeRightWhile = function(predicate) {\n      return this.reverse().takeWhile(predicate).reverse();\n    };\n\n    LazyWrapper.prototype.toArray = function() {\n      return this.take(MAX_ARRAY_LENGTH);\n    };\n\n    // Add `LazyWrapper` methods to `lodash.prototype`.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),\n          isTaker = /^(?:head|last)$/.test(methodName),\n          lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],\n          retUnwrapped = isTaker || /^find/.test(methodName);\n\n      if (!lodashFunc) {\n        return;\n      }\n      lodash.prototype[methodName] = function() {\n        var value = this.__wrapped__,\n            args = isTaker ? [1] : arguments,\n            isLazy = value instanceof LazyWrapper,\n            iteratee = args[0],\n            useLazy = isLazy || isArray(value);\n\n        var interceptor = function(value) {\n          var result = lodashFunc.apply(lodash, arrayPush([value], args));\n          return (isTaker && chainAll) ? result[0] : result;\n        };\n\n        if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {\n          // Avoid lazy use if the iteratee has a \"length\" value other than `1`.\n          isLazy = useLazy = false;\n        }\n        var chainAll = this.__chain__,\n            isHybrid = !!this.__actions__.length,\n            isUnwrapped = retUnwrapped && !chainAll,\n            onlyLazy = isLazy && !isHybrid;\n\n        if (!retUnwrapped && useLazy) {\n          value = onlyLazy ? value : new LazyWrapper(this);\n          var result = func.apply(value, args);\n          result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined$1 });\n          return new LodashWrapper(result, chainAll);\n        }\n        if (isUnwrapped && onlyLazy) {\n          return func.apply(this, args);\n        }\n        result = this.thru(interceptor);\n        return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;\n      };\n    });\n\n    // Add `Array` methods to `lodash.prototype`.\n    arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {\n      var func = arrayProto[methodName],\n          chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',\n          retUnwrapped = /^(?:pop|shift)$/.test(methodName);\n\n      lodash.prototype[methodName] = function() {\n        var args = arguments;\n        if (retUnwrapped && !this.__chain__) {\n          var value = this.value();\n          return func.apply(isArray(value) ? value : [], args);\n        }\n        return this[chainName](function(value) {\n          return func.apply(isArray(value) ? value : [], args);\n        });\n      };\n    });\n\n    // Map minified method names to their real names.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var lodashFunc = lodash[methodName];\n      if (lodashFunc) {\n        var key = lodashFunc.name + '';\n        if (!hasOwnProperty.call(realNames, key)) {\n          realNames[key] = [];\n        }\n        realNames[key].push({ 'name': methodName, 'func': lodashFunc });\n      }\n    });\n\n    realNames[createHybrid(undefined$1, WRAP_BIND_KEY_FLAG).name] = [{\n      'name': 'wrapper',\n      'func': undefined$1\n    }];\n\n    // Add methods to `LazyWrapper`.\n    LazyWrapper.prototype.clone = lazyClone;\n    LazyWrapper.prototype.reverse = lazyReverse;\n    LazyWrapper.prototype.value = lazyValue;\n\n    // Add chain sequence methods to the `lodash` wrapper.\n    lodash.prototype.at = wrapperAt;\n    lodash.prototype.chain = wrapperChain;\n    lodash.prototype.commit = wrapperCommit;\n    lodash.prototype.next = wrapperNext;\n    lodash.prototype.plant = wrapperPlant;\n    lodash.prototype.reverse = wrapperReverse;\n    lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;\n\n    // Add lazy aliases.\n    lodash.prototype.first = lodash.prototype.head;\n\n    if (symIterator) {\n      lodash.prototype[symIterator] = wrapperToIterator;\n    }\n    return lodash;\n  });\n\n  /*--------------------------------------------------------------------------*/\n\n  // Export lodash.\n  var _ = runInContext();\n\n  // Some AMD build optimizers, like r.js, check for condition patterns like:\n  if (freeModule) {\n    // Export for Node.js.\n    (freeModule.exports = _)._ = _;\n    // Export for CommonJS support.\n    freeExports._ = _;\n  }\n  else {\n    // Export to the global object.\n    root._ = _;\n  }\n}.call(this));\n});\n\nvar builtin = {\n\t\"Array\": false,\n\t\"ArrayBuffer\": false,\n\tAtomics: false,\n\tBigInt: false,\n\tBigInt64Array: false,\n\tBigUint64Array: false,\n\t\"Boolean\": false,\n\tconstructor: false,\n\t\"DataView\": false,\n\t\"Date\": false,\n\t\"decodeURI\": false,\n\t\"decodeURIComponent\": false,\n\t\"encodeURI\": false,\n\t\"encodeURIComponent\": false,\n\t\"Error\": false,\n\t\"escape\": false,\n\t\"eval\": false,\n\t\"EvalError\": false,\n\t\"Float32Array\": false,\n\t\"Float64Array\": false,\n\t\"Function\": false,\n\tglobalThis: false,\n\thasOwnProperty: false,\n\t\"Infinity\": false,\n\t\"Int16Array\": false,\n\t\"Int32Array\": false,\n\t\"Int8Array\": false,\n\t\"isFinite\": false,\n\t\"isNaN\": false,\n\tisPrototypeOf: false,\n\t\"JSON\": false,\n\t\"Map\": false,\n\t\"Math\": false,\n\t\"NaN\": false,\n\t\"Number\": false,\n\t\"Object\": false,\n\t\"parseFloat\": false,\n\t\"parseInt\": false,\n\t\"Promise\": false,\n\tpropertyIsEnumerable: false,\n\t\"Proxy\": false,\n\t\"RangeError\": false,\n\t\"ReferenceError\": false,\n\t\"Reflect\": false,\n\t\"RegExp\": false,\n\t\"Set\": false,\n\tSharedArrayBuffer: false,\n\t\"String\": false,\n\t\"Symbol\": false,\n\t\"SyntaxError\": false,\n\ttoLocaleString: false,\n\ttoString: false,\n\t\"TypeError\": false,\n\t\"Uint16Array\": false,\n\t\"Uint32Array\": false,\n\t\"Uint8Array\": false,\n\t\"Uint8ClampedArray\": false,\n\t\"undefined\": false,\n\t\"unescape\": false,\n\t\"URIError\": false,\n\tvalueOf: false,\n\t\"WeakMap\": false,\n\t\"WeakSet\": false\n};\nvar es5 = {\n\t\"Array\": false,\n\t\"Boolean\": false,\n\tconstructor: false,\n\t\"Date\": false,\n\t\"decodeURI\": false,\n\t\"decodeURIComponent\": false,\n\t\"encodeURI\": false,\n\t\"encodeURIComponent\": false,\n\t\"Error\": false,\n\t\"escape\": false,\n\t\"eval\": false,\n\t\"EvalError\": false,\n\t\"Function\": false,\n\thasOwnProperty: false,\n\t\"Infinity\": false,\n\t\"isFinite\": false,\n\t\"isNaN\": false,\n\tisPrototypeOf: false,\n\t\"JSON\": false,\n\t\"Math\": false,\n\t\"NaN\": false,\n\t\"Number\": false,\n\t\"Object\": false,\n\t\"parseFloat\": false,\n\t\"parseInt\": false,\n\tpropertyIsEnumerable: false,\n\t\"RangeError\": false,\n\t\"ReferenceError\": false,\n\t\"RegExp\": false,\n\t\"String\": false,\n\t\"SyntaxError\": false,\n\ttoLocaleString: false,\n\ttoString: false,\n\t\"TypeError\": false,\n\t\"undefined\": false,\n\t\"unescape\": false,\n\t\"URIError\": false,\n\tvalueOf: false\n};\nvar es2015 = {\n\t\"Array\": false,\n\t\"ArrayBuffer\": false,\n\t\"Boolean\": false,\n\tconstructor: false,\n\t\"DataView\": false,\n\t\"Date\": false,\n\t\"decodeURI\": false,\n\t\"decodeURIComponent\": false,\n\t\"encodeURI\": false,\n\t\"encodeURIComponent\": false,\n\t\"Error\": false,\n\t\"escape\": false,\n\t\"eval\": false,\n\t\"EvalError\": false,\n\t\"Float32Array\": false,\n\t\"Float64Array\": false,\n\t\"Function\": false,\n\thasOwnProperty: false,\n\t\"Infinity\": false,\n\t\"Int16Array\": false,\n\t\"Int32Array\": false,\n\t\"Int8Array\": false,\n\t\"isFinite\": false,\n\t\"isNaN\": false,\n\tisPrototypeOf: false,\n\t\"JSON\": false,\n\t\"Map\": false,\n\t\"Math\": false,\n\t\"NaN\": false,\n\t\"Number\": false,\n\t\"Object\": false,\n\t\"parseFloat\": false,\n\t\"parseInt\": false,\n\t\"Promise\": false,\n\tpropertyIsEnumerable: false,\n\t\"Proxy\": false,\n\t\"RangeError\": false,\n\t\"ReferenceError\": false,\n\t\"Reflect\": false,\n\t\"RegExp\": false,\n\t\"Set\": false,\n\t\"String\": false,\n\t\"Symbol\": false,\n\t\"SyntaxError\": false,\n\ttoLocaleString: false,\n\ttoString: false,\n\t\"TypeError\": false,\n\t\"Uint16Array\": false,\n\t\"Uint32Array\": false,\n\t\"Uint8Array\": false,\n\t\"Uint8ClampedArray\": false,\n\t\"undefined\": false,\n\t\"unescape\": false,\n\t\"URIError\": false,\n\tvalueOf: false,\n\t\"WeakMap\": false,\n\t\"WeakSet\": false\n};\nvar es2017 = {\n\t\"Array\": false,\n\t\"ArrayBuffer\": false,\n\tAtomics: false,\n\t\"Boolean\": false,\n\tconstructor: false,\n\t\"DataView\": false,\n\t\"Date\": false,\n\t\"decodeURI\": false,\n\t\"decodeURIComponent\": false,\n\t\"encodeURI\": false,\n\t\"encodeURIComponent\": false,\n\t\"Error\": false,\n\t\"escape\": false,\n\t\"eval\": false,\n\t\"EvalError\": false,\n\t\"Float32Array\": false,\n\t\"Float64Array\": false,\n\t\"Function\": false,\n\thasOwnProperty: false,\n\t\"Infinity\": false,\n\t\"Int16Array\": false,\n\t\"Int32Array\": false,\n\t\"Int8Array\": false,\n\t\"isFinite\": false,\n\t\"isNaN\": false,\n\tisPrototypeOf: false,\n\t\"JSON\": false,\n\t\"Map\": false,\n\t\"Math\": false,\n\t\"NaN\": false,\n\t\"Number\": false,\n\t\"Object\": false,\n\t\"parseFloat\": false,\n\t\"parseInt\": false,\n\t\"Promise\": false,\n\tpropertyIsEnumerable: false,\n\t\"Proxy\": false,\n\t\"RangeError\": false,\n\t\"ReferenceError\": false,\n\t\"Reflect\": false,\n\t\"RegExp\": false,\n\t\"Set\": false,\n\tSharedArrayBuffer: false,\n\t\"String\": false,\n\t\"Symbol\": false,\n\t\"SyntaxError\": false,\n\ttoLocaleString: false,\n\ttoString: false,\n\t\"TypeError\": false,\n\t\"Uint16Array\": false,\n\t\"Uint32Array\": false,\n\t\"Uint8Array\": false,\n\t\"Uint8ClampedArray\": false,\n\t\"undefined\": false,\n\t\"unescape\": false,\n\t\"URIError\": false,\n\tvalueOf: false,\n\t\"WeakMap\": false,\n\t\"WeakSet\": false\n};\nvar browser = {\n\tAbortController: false,\n\tAbortSignal: false,\n\taddEventListener: false,\n\talert: false,\n\tAnalyserNode: false,\n\tAnimation: false,\n\tAnimationEffectReadOnly: false,\n\tAnimationEffectTiming: false,\n\tAnimationEffectTimingReadOnly: false,\n\tAnimationEvent: false,\n\tAnimationPlaybackEvent: false,\n\tAnimationTimeline: false,\n\tapplicationCache: false,\n\tApplicationCache: false,\n\tApplicationCacheErrorEvent: false,\n\tatob: false,\n\tAttr: false,\n\tAudio: false,\n\tAudioBuffer: false,\n\tAudioBufferSourceNode: false,\n\tAudioContext: false,\n\tAudioDestinationNode: false,\n\tAudioListener: false,\n\tAudioNode: false,\n\tAudioParam: false,\n\tAudioProcessingEvent: false,\n\tAudioScheduledSourceNode: false,\n\t\"AudioWorkletGlobalScope \": false,\n\tAudioWorkletNode: false,\n\tAudioWorkletProcessor: false,\n\tBarProp: false,\n\tBaseAudioContext: false,\n\tBatteryManager: false,\n\tBeforeUnloadEvent: false,\n\tBiquadFilterNode: false,\n\tBlob: false,\n\tBlobEvent: false,\n\tblur: false,\n\tBroadcastChannel: false,\n\tbtoa: false,\n\tBudgetService: false,\n\tByteLengthQueuingStrategy: false,\n\tCache: false,\n\tcaches: false,\n\tCacheStorage: false,\n\tcancelAnimationFrame: false,\n\tcancelIdleCallback: false,\n\tCanvasCaptureMediaStreamTrack: false,\n\tCanvasGradient: false,\n\tCanvasPattern: false,\n\tCanvasRenderingContext2D: false,\n\tChannelMergerNode: false,\n\tChannelSplitterNode: false,\n\tCharacterData: false,\n\tclearInterval: false,\n\tclearTimeout: false,\n\tclientInformation: false,\n\tClipboardEvent: false,\n\tclose: false,\n\tclosed: false,\n\tCloseEvent: false,\n\tComment: false,\n\tCompositionEvent: false,\n\tconfirm: false,\n\tconsole: false,\n\tConstantSourceNode: false,\n\tConvolverNode: false,\n\tCountQueuingStrategy: false,\n\tcreateImageBitmap: false,\n\tCredential: false,\n\tCredentialsContainer: false,\n\tcrypto: false,\n\tCrypto: false,\n\tCryptoKey: false,\n\tCSS: false,\n\tCSSConditionRule: false,\n\tCSSFontFaceRule: false,\n\tCSSGroupingRule: false,\n\tCSSImportRule: false,\n\tCSSKeyframeRule: false,\n\tCSSKeyframesRule: false,\n\tCSSMediaRule: false,\n\tCSSNamespaceRule: false,\n\tCSSPageRule: false,\n\tCSSRule: false,\n\tCSSRuleList: false,\n\tCSSStyleDeclaration: false,\n\tCSSStyleRule: false,\n\tCSSStyleSheet: false,\n\tCSSSupportsRule: false,\n\tCustomElementRegistry: false,\n\tcustomElements: false,\n\tCustomEvent: false,\n\tDataTransfer: false,\n\tDataTransferItem: false,\n\tDataTransferItemList: false,\n\tdefaultstatus: false,\n\tdefaultStatus: false,\n\tDelayNode: false,\n\tDeviceMotionEvent: false,\n\tDeviceOrientationEvent: false,\n\tdevicePixelRatio: false,\n\tdispatchEvent: false,\n\tdocument: false,\n\tDocument: false,\n\tDocumentFragment: false,\n\tDocumentType: false,\n\tDOMError: false,\n\tDOMException: false,\n\tDOMImplementation: false,\n\tDOMMatrix: false,\n\tDOMMatrixReadOnly: false,\n\tDOMParser: false,\n\tDOMPoint: false,\n\tDOMPointReadOnly: false,\n\tDOMQuad: false,\n\tDOMRect: false,\n\tDOMRectReadOnly: false,\n\tDOMStringList: false,\n\tDOMStringMap: false,\n\tDOMTokenList: false,\n\tDragEvent: false,\n\tDynamicsCompressorNode: false,\n\tElement: false,\n\tErrorEvent: false,\n\tevent: false,\n\tEvent: false,\n\tEventSource: false,\n\tEventTarget: false,\n\texternal: false,\n\tfetch: false,\n\tFile: false,\n\tFileList: false,\n\tFileReader: false,\n\tfind: false,\n\tfocus: false,\n\tFocusEvent: false,\n\tFontFace: false,\n\tFontFaceSetLoadEvent: false,\n\tFormData: false,\n\tframeElement: false,\n\tframes: false,\n\tGainNode: false,\n\tGamepad: false,\n\tGamepadButton: false,\n\tGamepadEvent: false,\n\tgetComputedStyle: false,\n\tgetSelection: false,\n\tHashChangeEvent: false,\n\tHeaders: false,\n\thistory: false,\n\tHistory: false,\n\tHTMLAllCollection: false,\n\tHTMLAnchorElement: false,\n\tHTMLAreaElement: false,\n\tHTMLAudioElement: false,\n\tHTMLBaseElement: false,\n\tHTMLBodyElement: false,\n\tHTMLBRElement: false,\n\tHTMLButtonElement: false,\n\tHTMLCanvasElement: false,\n\tHTMLCollection: false,\n\tHTMLContentElement: false,\n\tHTMLDataElement: false,\n\tHTMLDataListElement: false,\n\tHTMLDetailsElement: false,\n\tHTMLDialogElement: false,\n\tHTMLDirectoryElement: false,\n\tHTMLDivElement: false,\n\tHTMLDListElement: false,\n\tHTMLDocument: false,\n\tHTMLElement: false,\n\tHTMLEmbedElement: false,\n\tHTMLFieldSetElement: false,\n\tHTMLFontElement: false,\n\tHTMLFormControlsCollection: false,\n\tHTMLFormElement: false,\n\tHTMLFrameElement: false,\n\tHTMLFrameSetElement: false,\n\tHTMLHeadElement: false,\n\tHTMLHeadingElement: false,\n\tHTMLHRElement: false,\n\tHTMLHtmlElement: false,\n\tHTMLIFrameElement: false,\n\tHTMLImageElement: false,\n\tHTMLInputElement: false,\n\tHTMLLabelElement: false,\n\tHTMLLegendElement: false,\n\tHTMLLIElement: false,\n\tHTMLLinkElement: false,\n\tHTMLMapElement: false,\n\tHTMLMarqueeElement: false,\n\tHTMLMediaElement: false,\n\tHTMLMenuElement: false,\n\tHTMLMetaElement: false,\n\tHTMLMeterElement: false,\n\tHTMLModElement: false,\n\tHTMLObjectElement: false,\n\tHTMLOListElement: false,\n\tHTMLOptGroupElement: false,\n\tHTMLOptionElement: false,\n\tHTMLOptionsCollection: false,\n\tHTMLOutputElement: false,\n\tHTMLParagraphElement: false,\n\tHTMLParamElement: false,\n\tHTMLPictureElement: false,\n\tHTMLPreElement: false,\n\tHTMLProgressElement: false,\n\tHTMLQuoteElement: false,\n\tHTMLScriptElement: false,\n\tHTMLSelectElement: false,\n\tHTMLShadowElement: false,\n\tHTMLSlotElement: false,\n\tHTMLSourceElement: false,\n\tHTMLSpanElement: false,\n\tHTMLStyleElement: false,\n\tHTMLTableCaptionElement: false,\n\tHTMLTableCellElement: false,\n\tHTMLTableColElement: false,\n\tHTMLTableElement: false,\n\tHTMLTableRowElement: false,\n\tHTMLTableSectionElement: false,\n\tHTMLTemplateElement: false,\n\tHTMLTextAreaElement: false,\n\tHTMLTimeElement: false,\n\tHTMLTitleElement: false,\n\tHTMLTrackElement: false,\n\tHTMLUListElement: false,\n\tHTMLUnknownElement: false,\n\tHTMLVideoElement: false,\n\tIDBCursor: false,\n\tIDBCursorWithValue: false,\n\tIDBDatabase: false,\n\tIDBFactory: false,\n\tIDBIndex: false,\n\tIDBKeyRange: false,\n\tIDBObjectStore: false,\n\tIDBOpenDBRequest: false,\n\tIDBRequest: false,\n\tIDBTransaction: false,\n\tIDBVersionChangeEvent: false,\n\tIdleDeadline: false,\n\tIIRFilterNode: false,\n\tImage: false,\n\tImageBitmap: false,\n\tImageBitmapRenderingContext: false,\n\tImageCapture: false,\n\tImageData: false,\n\tindexedDB: false,\n\tinnerHeight: false,\n\tinnerWidth: false,\n\tInputEvent: false,\n\tIntersectionObserver: false,\n\tIntersectionObserverEntry: false,\n\t\"Intl\": false,\n\tisSecureContext: false,\n\tKeyboardEvent: false,\n\tKeyframeEffect: false,\n\tKeyframeEffectReadOnly: false,\n\tlength: false,\n\tlocalStorage: false,\n\tlocation: true,\n\tLocation: false,\n\tlocationbar: false,\n\tmatchMedia: false,\n\tMediaDeviceInfo: false,\n\tMediaDevices: false,\n\tMediaElementAudioSourceNode: false,\n\tMediaEncryptedEvent: false,\n\tMediaError: false,\n\tMediaKeyMessageEvent: false,\n\tMediaKeySession: false,\n\tMediaKeyStatusMap: false,\n\tMediaKeySystemAccess: false,\n\tMediaList: false,\n\tMediaQueryList: false,\n\tMediaQueryListEvent: false,\n\tMediaRecorder: false,\n\tMediaSettingsRange: false,\n\tMediaSource: false,\n\tMediaStream: false,\n\tMediaStreamAudioDestinationNode: false,\n\tMediaStreamAudioSourceNode: false,\n\tMediaStreamEvent: false,\n\tMediaStreamTrack: false,\n\tMediaStreamTrackEvent: false,\n\tmenubar: false,\n\tMessageChannel: false,\n\tMessageEvent: false,\n\tMessagePort: false,\n\tMIDIAccess: false,\n\tMIDIConnectionEvent: false,\n\tMIDIInput: false,\n\tMIDIInputMap: false,\n\tMIDIMessageEvent: false,\n\tMIDIOutput: false,\n\tMIDIOutputMap: false,\n\tMIDIPort: false,\n\tMimeType: false,\n\tMimeTypeArray: false,\n\tMouseEvent: false,\n\tmoveBy: false,\n\tmoveTo: false,\n\tMutationEvent: false,\n\tMutationObserver: false,\n\tMutationRecord: false,\n\tname: false,\n\tNamedNodeMap: false,\n\tNavigationPreloadManager: false,\n\tnavigator: false,\n\tNavigator: false,\n\tNetworkInformation: false,\n\tNode: false,\n\tNodeFilter: false,\n\tNodeIterator: false,\n\tNodeList: false,\n\tNotification: false,\n\tOfflineAudioCompletionEvent: false,\n\tOfflineAudioContext: false,\n\toffscreenBuffering: false,\n\tOffscreenCanvas: true,\n\tonabort: true,\n\tonafterprint: true,\n\tonanimationend: true,\n\tonanimationiteration: true,\n\tonanimationstart: true,\n\tonappinstalled: true,\n\tonauxclick: true,\n\tonbeforeinstallprompt: true,\n\tonbeforeprint: true,\n\tonbeforeunload: true,\n\tonblur: true,\n\toncancel: true,\n\toncanplay: true,\n\toncanplaythrough: true,\n\tonchange: true,\n\tonclick: true,\n\tonclose: true,\n\toncontextmenu: true,\n\toncuechange: true,\n\tondblclick: true,\n\tondevicemotion: true,\n\tondeviceorientation: true,\n\tondeviceorientationabsolute: true,\n\tondrag: true,\n\tondragend: true,\n\tondragenter: true,\n\tondragleave: true,\n\tondragover: true,\n\tondragstart: true,\n\tondrop: true,\n\tondurationchange: true,\n\tonemptied: true,\n\tonended: true,\n\tonerror: true,\n\tonfocus: true,\n\tongotpointercapture: true,\n\tonhashchange: true,\n\toninput: true,\n\toninvalid: true,\n\tonkeydown: true,\n\tonkeypress: true,\n\tonkeyup: true,\n\tonlanguagechange: true,\n\tonload: true,\n\tonloadeddata: true,\n\tonloadedmetadata: true,\n\tonloadstart: true,\n\tonlostpointercapture: true,\n\tonmessage: true,\n\tonmessageerror: true,\n\tonmousedown: true,\n\tonmouseenter: true,\n\tonmouseleave: true,\n\tonmousemove: true,\n\tonmouseout: true,\n\tonmouseover: true,\n\tonmouseup: true,\n\tonmousewheel: true,\n\tonoffline: true,\n\tononline: true,\n\tonpagehide: true,\n\tonpageshow: true,\n\tonpause: true,\n\tonplay: true,\n\tonplaying: true,\n\tonpointercancel: true,\n\tonpointerdown: true,\n\tonpointerenter: true,\n\tonpointerleave: true,\n\tonpointermove: true,\n\tonpointerout: true,\n\tonpointerover: true,\n\tonpointerup: true,\n\tonpopstate: true,\n\tonprogress: true,\n\tonratechange: true,\n\tonrejectionhandled: true,\n\tonreset: true,\n\tonresize: true,\n\tonscroll: true,\n\tonsearch: true,\n\tonseeked: true,\n\tonseeking: true,\n\tonselect: true,\n\tonstalled: true,\n\tonstorage: true,\n\tonsubmit: true,\n\tonsuspend: true,\n\tontimeupdate: true,\n\tontoggle: true,\n\tontransitionend: true,\n\tonunhandledrejection: true,\n\tonunload: true,\n\tonvolumechange: true,\n\tonwaiting: true,\n\tonwheel: true,\n\topen: false,\n\topenDatabase: false,\n\topener: false,\n\tOption: false,\n\torigin: false,\n\tOscillatorNode: false,\n\touterHeight: false,\n\touterWidth: false,\n\tPageTransitionEvent: false,\n\tpageXOffset: false,\n\tpageYOffset: false,\n\tPannerNode: false,\n\tparent: false,\n\tPath2D: false,\n\tPaymentAddress: false,\n\tPaymentRequest: false,\n\tPaymentRequestUpdateEvent: false,\n\tPaymentResponse: false,\n\tperformance: false,\n\tPerformance: false,\n\tPerformanceEntry: false,\n\tPerformanceLongTaskTiming: false,\n\tPerformanceMark: false,\n\tPerformanceMeasure: false,\n\tPerformanceNavigation: false,\n\tPerformanceNavigationTiming: false,\n\tPerformanceObserver: false,\n\tPerformanceObserverEntryList: false,\n\tPerformancePaintTiming: false,\n\tPerformanceResourceTiming: false,\n\tPerformanceTiming: false,\n\tPeriodicWave: false,\n\tPermissions: false,\n\tPermissionStatus: false,\n\tpersonalbar: false,\n\tPhotoCapabilities: false,\n\tPlugin: false,\n\tPluginArray: false,\n\tPointerEvent: false,\n\tPopStateEvent: false,\n\tpostMessage: false,\n\tPresentation: false,\n\tPresentationAvailability: false,\n\tPresentationConnection: false,\n\tPresentationConnectionAvailableEvent: false,\n\tPresentationConnectionCloseEvent: false,\n\tPresentationConnectionList: false,\n\tPresentationReceiver: false,\n\tPresentationRequest: false,\n\tprint: false,\n\tProcessingInstruction: false,\n\tProgressEvent: false,\n\tPromiseRejectionEvent: false,\n\tprompt: false,\n\tPushManager: false,\n\tPushSubscription: false,\n\tPushSubscriptionOptions: false,\n\tqueueMicrotask: false,\n\tRadioNodeList: false,\n\tRange: false,\n\tReadableStream: false,\n\tregisterProcessor: false,\n\tRemotePlayback: false,\n\tremoveEventListener: false,\n\tRequest: false,\n\trequestAnimationFrame: false,\n\trequestIdleCallback: false,\n\tresizeBy: false,\n\tResizeObserver: false,\n\tResizeObserverEntry: false,\n\tresizeTo: false,\n\tResponse: false,\n\tRTCCertificate: false,\n\tRTCDataChannel: false,\n\tRTCDataChannelEvent: false,\n\tRTCDtlsTransport: false,\n\tRTCIceCandidate: false,\n\tRTCIceGatherer: false,\n\tRTCIceTransport: false,\n\tRTCPeerConnection: false,\n\tRTCPeerConnectionIceEvent: false,\n\tRTCRtpContributingSource: false,\n\tRTCRtpReceiver: false,\n\tRTCRtpSender: false,\n\tRTCSctpTransport: false,\n\tRTCSessionDescription: false,\n\tRTCStatsReport: false,\n\tRTCTrackEvent: false,\n\tscreen: false,\n\tScreen: false,\n\tscreenLeft: false,\n\tScreenOrientation: false,\n\tscreenTop: false,\n\tscreenX: false,\n\tscreenY: false,\n\tScriptProcessorNode: false,\n\tscroll: false,\n\tscrollbars: false,\n\tscrollBy: false,\n\tscrollTo: false,\n\tscrollX: false,\n\tscrollY: false,\n\tSecurityPolicyViolationEvent: false,\n\tSelection: false,\n\tself: false,\n\tServiceWorker: false,\n\tServiceWorkerContainer: false,\n\tServiceWorkerRegistration: false,\n\tsessionStorage: false,\n\tsetInterval: false,\n\tsetTimeout: false,\n\tShadowRoot: false,\n\tSharedWorker: false,\n\tSourceBuffer: false,\n\tSourceBufferList: false,\n\tspeechSynthesis: false,\n\tSpeechSynthesisEvent: false,\n\tSpeechSynthesisUtterance: false,\n\tStaticRange: false,\n\tstatus: false,\n\tstatusbar: false,\n\tStereoPannerNode: false,\n\tstop: false,\n\tStorage: false,\n\tStorageEvent: false,\n\tStorageManager: false,\n\tstyleMedia: false,\n\tStyleSheet: false,\n\tStyleSheetList: false,\n\tSubtleCrypto: false,\n\tSVGAElement: false,\n\tSVGAngle: false,\n\tSVGAnimatedAngle: false,\n\tSVGAnimatedBoolean: false,\n\tSVGAnimatedEnumeration: false,\n\tSVGAnimatedInteger: false,\n\tSVGAnimatedLength: false,\n\tSVGAnimatedLengthList: false,\n\tSVGAnimatedNumber: false,\n\tSVGAnimatedNumberList: false,\n\tSVGAnimatedPreserveAspectRatio: false,\n\tSVGAnimatedRect: false,\n\tSVGAnimatedString: false,\n\tSVGAnimatedTransformList: false,\n\tSVGAnimateElement: false,\n\tSVGAnimateMotionElement: false,\n\tSVGAnimateTransformElement: false,\n\tSVGAnimationElement: false,\n\tSVGCircleElement: false,\n\tSVGClipPathElement: false,\n\tSVGComponentTransferFunctionElement: false,\n\tSVGDefsElement: false,\n\tSVGDescElement: false,\n\tSVGDiscardElement: false,\n\tSVGElement: false,\n\tSVGEllipseElement: false,\n\tSVGFEBlendElement: false,\n\tSVGFEColorMatrixElement: false,\n\tSVGFEComponentTransferElement: false,\n\tSVGFECompositeElement: false,\n\tSVGFEConvolveMatrixElement: false,\n\tSVGFEDiffuseLightingElement: false,\n\tSVGFEDisplacementMapElement: false,\n\tSVGFEDistantLightElement: false,\n\tSVGFEDropShadowElement: false,\n\tSVGFEFloodElement: false,\n\tSVGFEFuncAElement: false,\n\tSVGFEFuncBElement: false,\n\tSVGFEFuncGElement: false,\n\tSVGFEFuncRElement: false,\n\tSVGFEGaussianBlurElement: false,\n\tSVGFEImageElement: false,\n\tSVGFEMergeElement: false,\n\tSVGFEMergeNodeElement: false,\n\tSVGFEMorphologyElement: false,\n\tSVGFEOffsetElement: false,\n\tSVGFEPointLightElement: false,\n\tSVGFESpecularLightingElement: false,\n\tSVGFESpotLightElement: false,\n\tSVGFETileElement: false,\n\tSVGFETurbulenceElement: false,\n\tSVGFilterElement: false,\n\tSVGForeignObjectElement: false,\n\tSVGGElement: false,\n\tSVGGeometryElement: false,\n\tSVGGradientElement: false,\n\tSVGGraphicsElement: false,\n\tSVGImageElement: false,\n\tSVGLength: false,\n\tSVGLengthList: false,\n\tSVGLinearGradientElement: false,\n\tSVGLineElement: false,\n\tSVGMarkerElement: false,\n\tSVGMaskElement: false,\n\tSVGMatrix: false,\n\tSVGMetadataElement: false,\n\tSVGMPathElement: false,\n\tSVGNumber: false,\n\tSVGNumberList: false,\n\tSVGPathElement: false,\n\tSVGPatternElement: false,\n\tSVGPoint: false,\n\tSVGPointList: false,\n\tSVGPolygonElement: false,\n\tSVGPolylineElement: false,\n\tSVGPreserveAspectRatio: false,\n\tSVGRadialGradientElement: false,\n\tSVGRect: false,\n\tSVGRectElement: false,\n\tSVGScriptElement: false,\n\tSVGSetElement: false,\n\tSVGStopElement: false,\n\tSVGStringList: false,\n\tSVGStyleElement: false,\n\tSVGSVGElement: false,\n\tSVGSwitchElement: false,\n\tSVGSymbolElement: false,\n\tSVGTextContentElement: false,\n\tSVGTextElement: false,\n\tSVGTextPathElement: false,\n\tSVGTextPositioningElement: false,\n\tSVGTitleElement: false,\n\tSVGTransform: false,\n\tSVGTransformList: false,\n\tSVGTSpanElement: false,\n\tSVGUnitTypes: false,\n\tSVGUseElement: false,\n\tSVGViewElement: false,\n\tTaskAttributionTiming: false,\n\tText: false,\n\tTextDecoder: false,\n\tTextEncoder: false,\n\tTextEvent: false,\n\tTextMetrics: false,\n\tTextTrack: false,\n\tTextTrackCue: false,\n\tTextTrackCueList: false,\n\tTextTrackList: false,\n\tTimeRanges: false,\n\ttoolbar: false,\n\ttop: false,\n\tTouch: false,\n\tTouchEvent: false,\n\tTouchList: false,\n\tTrackEvent: false,\n\tTransitionEvent: false,\n\tTreeWalker: false,\n\tUIEvent: false,\n\tURL: false,\n\tURLSearchParams: false,\n\tValidityState: false,\n\tvisualViewport: false,\n\tVisualViewport: false,\n\tVTTCue: false,\n\tWaveShaperNode: false,\n\tWebAssembly: false,\n\tWebGL2RenderingContext: false,\n\tWebGLActiveInfo: false,\n\tWebGLBuffer: false,\n\tWebGLContextEvent: false,\n\tWebGLFramebuffer: false,\n\tWebGLProgram: false,\n\tWebGLQuery: false,\n\tWebGLRenderbuffer: false,\n\tWebGLRenderingContext: false,\n\tWebGLSampler: false,\n\tWebGLShader: false,\n\tWebGLShaderPrecisionFormat: false,\n\tWebGLSync: false,\n\tWebGLTexture: false,\n\tWebGLTransformFeedback: false,\n\tWebGLUniformLocation: false,\n\tWebGLVertexArrayObject: false,\n\tWebSocket: false,\n\tWheelEvent: false,\n\twindow: false,\n\tWindow: false,\n\tWorker: false,\n\tWritableStream: false,\n\tXMLDocument: false,\n\tXMLHttpRequest: false,\n\tXMLHttpRequestEventTarget: false,\n\tXMLHttpRequestUpload: false,\n\tXMLSerializer: false,\n\tXPathEvaluator: false,\n\tXPathExpression: false,\n\tXPathResult: false,\n\tXSLTProcessor: false\n};\nvar worker = {\n\taddEventListener: false,\n\tapplicationCache: false,\n\tatob: false,\n\tBlob: false,\n\tBroadcastChannel: false,\n\tbtoa: false,\n\tCache: false,\n\tcaches: false,\n\tclearInterval: false,\n\tclearTimeout: false,\n\tclose: true,\n\tconsole: false,\n\tfetch: false,\n\tFileReaderSync: false,\n\tFormData: false,\n\tHeaders: false,\n\tIDBCursor: false,\n\tIDBCursorWithValue: false,\n\tIDBDatabase: false,\n\tIDBFactory: false,\n\tIDBIndex: false,\n\tIDBKeyRange: false,\n\tIDBObjectStore: false,\n\tIDBOpenDBRequest: false,\n\tIDBRequest: false,\n\tIDBTransaction: false,\n\tIDBVersionChangeEvent: false,\n\tImageData: false,\n\timportScripts: true,\n\tindexedDB: false,\n\tlocation: false,\n\tMessageChannel: false,\n\tMessagePort: false,\n\tname: false,\n\tnavigator: false,\n\tNotification: false,\n\tonclose: true,\n\tonconnect: true,\n\tonerror: true,\n\tonlanguagechange: true,\n\tonmessage: true,\n\tonoffline: true,\n\tononline: true,\n\tonrejectionhandled: true,\n\tonunhandledrejection: true,\n\tperformance: false,\n\tPerformance: false,\n\tPerformanceEntry: false,\n\tPerformanceMark: false,\n\tPerformanceMeasure: false,\n\tPerformanceNavigation: false,\n\tPerformanceResourceTiming: false,\n\tPerformanceTiming: false,\n\tpostMessage: true,\n\t\"Promise\": false,\n\tqueueMicrotask: false,\n\tremoveEventListener: false,\n\tRequest: false,\n\tResponse: false,\n\tself: true,\n\tServiceWorkerRegistration: false,\n\tsetInterval: false,\n\tsetTimeout: false,\n\tTextDecoder: false,\n\tTextEncoder: false,\n\tURL: false,\n\tURLSearchParams: false,\n\tWebSocket: false,\n\tWorker: false,\n\tWorkerGlobalScope: false,\n\tXMLHttpRequest: false\n};\nvar node = {\n\t__dirname: false,\n\t__filename: false,\n\tBuffer: false,\n\tclearImmediate: false,\n\tclearInterval: false,\n\tclearTimeout: false,\n\tconsole: false,\n\texports: true,\n\tglobal: false,\n\t\"Intl\": false,\n\tmodule: false,\n\tprocess: false,\n\tqueueMicrotask: false,\n\trequire: false,\n\tsetImmediate: false,\n\tsetInterval: false,\n\tsetTimeout: false,\n\tTextDecoder: false,\n\tTextEncoder: false,\n\tURL: false,\n\tURLSearchParams: false\n};\nvar nodeBuiltin = {\n\tBuffer: false,\n\tclearImmediate: false,\n\tclearInterval: false,\n\tclearTimeout: false,\n\tconsole: false,\n\tglobal: false,\n\t\"Intl\": false,\n\tprocess: false,\n\tqueueMicrotask: false,\n\tsetImmediate: false,\n\tsetInterval: false,\n\tsetTimeout: false,\n\tTextDecoder: false,\n\tTextEncoder: false,\n\tURL: false,\n\tURLSearchParams: false\n};\nvar commonjs = {\n\texports: true,\n\tglobal: false,\n\tmodule: false,\n\trequire: false\n};\nvar amd = {\n\tdefine: false,\n\trequire: false\n};\nvar mocha = {\n\tafter: false,\n\tafterEach: false,\n\tbefore: false,\n\tbeforeEach: false,\n\tcontext: false,\n\tdescribe: false,\n\tit: false,\n\tmocha: false,\n\trun: false,\n\tsetup: false,\n\tspecify: false,\n\tsuite: false,\n\tsuiteSetup: false,\n\tsuiteTeardown: false,\n\tteardown: false,\n\ttest: false,\n\txcontext: false,\n\txdescribe: false,\n\txit: false,\n\txspecify: false\n};\nvar jasmine = {\n\tafterAll: false,\n\tafterEach: false,\n\tbeforeAll: false,\n\tbeforeEach: false,\n\tdescribe: false,\n\texpect: false,\n\texpectAsync: false,\n\tfail: false,\n\tfdescribe: false,\n\tfit: false,\n\tit: false,\n\tjasmine: false,\n\tpending: false,\n\truns: false,\n\tspyOn: false,\n\tspyOnAllFunctions: false,\n\tspyOnProperty: false,\n\twaits: false,\n\twaitsFor: false,\n\txdescribe: false,\n\txit: false\n};\nvar jest = {\n\tafterAll: false,\n\tafterEach: false,\n\tbeforeAll: false,\n\tbeforeEach: false,\n\tdescribe: false,\n\texpect: false,\n\tfdescribe: false,\n\tfit: false,\n\tit: false,\n\tjest: false,\n\tpit: false,\n\trequire: false,\n\ttest: false,\n\txdescribe: false,\n\txit: false,\n\txtest: false\n};\nvar qunit = {\n\tasyncTest: false,\n\tdeepEqual: false,\n\tequal: false,\n\texpect: false,\n\tmodule: false,\n\tnotDeepEqual: false,\n\tnotEqual: false,\n\tnotOk: false,\n\tnotPropEqual: false,\n\tnotStrictEqual: false,\n\tok: false,\n\tpropEqual: false,\n\tQUnit: false,\n\traises: false,\n\tstart: false,\n\tstop: false,\n\tstrictEqual: false,\n\ttest: false,\n\tthrows: false\n};\nvar phantomjs = {\n\tconsole: true,\n\texports: true,\n\tphantom: true,\n\trequire: true,\n\tWebPage: true\n};\nvar couch = {\n\temit: false,\n\texports: false,\n\tgetRow: false,\n\tlog: false,\n\tmodule: false,\n\tprovides: false,\n\trequire: false,\n\trespond: false,\n\tsend: false,\n\tstart: false,\n\tsum: false\n};\nvar rhino = {\n\tdefineClass: false,\n\tdeserialize: false,\n\tgc: false,\n\thelp: false,\n\timportClass: false,\n\timportPackage: false,\n\tjava: false,\n\tload: false,\n\tloadClass: false,\n\tPackages: false,\n\tprint: false,\n\tquit: false,\n\treadFile: false,\n\treadUrl: false,\n\trunCommand: false,\n\tseal: false,\n\tserialize: false,\n\tspawn: false,\n\tsync: false,\n\ttoint32: false,\n\tversion: false\n};\nvar nashorn = {\n\t__DIR__: false,\n\t__FILE__: false,\n\t__LINE__: false,\n\tcom: false,\n\tedu: false,\n\texit: false,\n\tjava: false,\n\tJava: false,\n\tjavafx: false,\n\tJavaImporter: false,\n\tjavax: false,\n\tJSAdapter: false,\n\tload: false,\n\tloadWithNewGlobal: false,\n\torg: false,\n\tPackages: false,\n\tprint: false,\n\tquit: false\n};\nvar wsh = {\n\tActiveXObject: true,\n\tCollectGarbage: true,\n\tDebug: true,\n\tEnumerator: true,\n\tGetObject: true,\n\tRuntimeObject: true,\n\tScriptEngine: true,\n\tScriptEngineBuildVersion: true,\n\tScriptEngineMajorVersion: true,\n\tScriptEngineMinorVersion: true,\n\tVBArray: true,\n\tWScript: true,\n\tWSH: true,\n\tXDomainRequest: true\n};\nvar jquery = {\n\t$: false,\n\tjQuery: false\n};\nvar yui = {\n\tYAHOO: false,\n\tYAHOO_config: false,\n\tYUI: false,\n\tYUI_config: false\n};\nvar shelljs = {\n\tcat: false,\n\tcd: false,\n\tchmod: false,\n\tconfig: false,\n\tcp: false,\n\tdirs: false,\n\techo: false,\n\tenv: false,\n\terror: false,\n\texec: false,\n\texit: false,\n\tfind: false,\n\tgrep: false,\n\tln: false,\n\tls: false,\n\tmkdir: false,\n\tmv: false,\n\tpopd: false,\n\tpushd: false,\n\tpwd: false,\n\trm: false,\n\tsed: false,\n\tset: false,\n\ttarget: false,\n\ttempdir: false,\n\ttest: false,\n\ttouch: false,\n\twhich: false\n};\nvar prototypejs = {\n\t$: false,\n\t$$: false,\n\t$A: false,\n\t$break: false,\n\t$continue: false,\n\t$F: false,\n\t$H: false,\n\t$R: false,\n\t$w: false,\n\tAbstract: false,\n\tAjax: false,\n\tAutocompleter: false,\n\tBuilder: false,\n\tClass: false,\n\tControl: false,\n\tDraggable: false,\n\tDraggables: false,\n\tDroppables: false,\n\tEffect: false,\n\tElement: false,\n\tEnumerable: false,\n\tEvent: false,\n\tField: false,\n\tForm: false,\n\tHash: false,\n\tInsertion: false,\n\tObjectRange: false,\n\tPeriodicalExecuter: false,\n\tPosition: false,\n\tPrototype: false,\n\tScriptaculous: false,\n\tSelector: false,\n\tSortable: false,\n\tSortableObserver: false,\n\tSound: false,\n\tTemplate: false,\n\tToggle: false,\n\tTry: false\n};\nvar meteor = {\n\t_: false,\n\t$: false,\n\tAccounts: false,\n\tAccountsClient: false,\n\tAccountsCommon: false,\n\tAccountsServer: false,\n\tApp: false,\n\tAssets: false,\n\tBlaze: false,\n\tcheck: false,\n\tCordova: false,\n\tDDP: false,\n\tDDPRateLimiter: false,\n\tDDPServer: false,\n\tDeps: false,\n\tEJSON: false,\n\tEmail: false,\n\tHTTP: false,\n\tLog: false,\n\tMatch: false,\n\tMeteor: false,\n\tMongo: false,\n\tMongoInternals: false,\n\tNpm: false,\n\tPackage: false,\n\tPlugin: false,\n\tprocess: false,\n\tRandom: false,\n\tReactiveDict: false,\n\tReactiveVar: false,\n\tRouter: false,\n\tServiceConfiguration: false,\n\tSession: false,\n\tshare: false,\n\tSpacebars: false,\n\tTemplate: false,\n\tTinytest: false,\n\tTracker: false,\n\tUI: false,\n\tUtils: false,\n\tWebApp: false,\n\tWebAppInternals: false\n};\nvar mongo = {\n\t_isWindows: false,\n\t_rand: false,\n\tBulkWriteResult: false,\n\tcat: false,\n\tcd: false,\n\tconnect: false,\n\tdb: false,\n\tgetHostName: false,\n\tgetMemInfo: false,\n\thostname: false,\n\tISODate: false,\n\tlistFiles: false,\n\tload: false,\n\tls: false,\n\tmd5sumFile: false,\n\tmkdir: false,\n\tMongo: false,\n\tNumberInt: false,\n\tNumberLong: false,\n\tObjectId: false,\n\tPlanCache: false,\n\tprint: false,\n\tprintjson: false,\n\tpwd: false,\n\tquit: false,\n\tremoveFile: false,\n\trs: false,\n\tsh: false,\n\tUUID: false,\n\tversion: false,\n\tWriteResult: false\n};\nvar applescript = {\n\t$: false,\n\tApplication: false,\n\tAutomation: false,\n\tconsole: false,\n\tdelay: false,\n\tLibrary: false,\n\tObjC: false,\n\tObjectSpecifier: false,\n\tPath: false,\n\tProgress: false,\n\tRef: false\n};\nvar serviceworker = {\n\taddEventListener: false,\n\tapplicationCache: false,\n\tatob: false,\n\tBlob: false,\n\tBroadcastChannel: false,\n\tbtoa: false,\n\tCache: false,\n\tcaches: false,\n\tCacheStorage: false,\n\tclearInterval: false,\n\tclearTimeout: false,\n\tClient: false,\n\tclients: false,\n\tClients: false,\n\tclose: true,\n\tconsole: false,\n\tExtendableEvent: false,\n\tExtendableMessageEvent: false,\n\tfetch: false,\n\tFetchEvent: false,\n\tFileReaderSync: false,\n\tFormData: false,\n\tHeaders: false,\n\tIDBCursor: false,\n\tIDBCursorWithValue: false,\n\tIDBDatabase: false,\n\tIDBFactory: false,\n\tIDBIndex: false,\n\tIDBKeyRange: false,\n\tIDBObjectStore: false,\n\tIDBOpenDBRequest: false,\n\tIDBRequest: false,\n\tIDBTransaction: false,\n\tIDBVersionChangeEvent: false,\n\tImageData: false,\n\timportScripts: false,\n\tindexedDB: false,\n\tlocation: false,\n\tMessageChannel: false,\n\tMessagePort: false,\n\tname: false,\n\tnavigator: false,\n\tNotification: false,\n\tonclose: true,\n\tonconnect: true,\n\tonerror: true,\n\tonfetch: true,\n\toninstall: true,\n\tonlanguagechange: true,\n\tonmessage: true,\n\tonmessageerror: true,\n\tonnotificationclick: true,\n\tonnotificationclose: true,\n\tonoffline: true,\n\tononline: true,\n\tonpush: true,\n\tonpushsubscriptionchange: true,\n\tonrejectionhandled: true,\n\tonsync: true,\n\tonunhandledrejection: true,\n\tperformance: false,\n\tPerformance: false,\n\tPerformanceEntry: false,\n\tPerformanceMark: false,\n\tPerformanceMeasure: false,\n\tPerformanceNavigation: false,\n\tPerformanceResourceTiming: false,\n\tPerformanceTiming: false,\n\tpostMessage: true,\n\t\"Promise\": false,\n\tqueueMicrotask: false,\n\tregistration: false,\n\tremoveEventListener: false,\n\tRequest: false,\n\tResponse: false,\n\tself: false,\n\tServiceWorker: false,\n\tServiceWorkerContainer: false,\n\tServiceWorkerGlobalScope: false,\n\tServiceWorkerMessageEvent: false,\n\tServiceWorkerRegistration: false,\n\tsetInterval: false,\n\tsetTimeout: false,\n\tskipWaiting: false,\n\tTextDecoder: false,\n\tTextEncoder: false,\n\tURL: false,\n\tURLSearchParams: false,\n\tWebSocket: false,\n\tWindowClient: false,\n\tWorker: false,\n\tWorkerGlobalScope: false,\n\tXMLHttpRequest: false\n};\nvar atomtest = {\n\tadvanceClock: false,\n\tfakeClearInterval: false,\n\tfakeClearTimeout: false,\n\tfakeSetInterval: false,\n\tfakeSetTimeout: false,\n\tresetTimeouts: false,\n\twaitsForPromise: false\n};\nvar embertest = {\n\tandThen: false,\n\tclick: false,\n\tcurrentPath: false,\n\tcurrentRouteName: false,\n\tcurrentURL: false,\n\tfillIn: false,\n\tfind: false,\n\tfindAll: false,\n\tfindWithAssert: false,\n\tkeyEvent: false,\n\tpauseTest: false,\n\tresumeTest: false,\n\ttriggerEvent: false,\n\tvisit: false,\n\twait: false\n};\nvar protractor = {\n\t$: false,\n\t$$: false,\n\tbrowser: false,\n\tby: false,\n\tBy: false,\n\tDartObject: false,\n\telement: false,\n\tprotractor: false\n};\nvar webextensions = {\n\tbrowser: false,\n\tchrome: false,\n\topr: false\n};\nvar greasemonkey = {\n\tcloneInto: false,\n\tcreateObjectIn: false,\n\texportFunction: false,\n\tGM: false,\n\tGM_addStyle: false,\n\tGM_deleteValue: false,\n\tGM_getResourceText: false,\n\tGM_getResourceURL: false,\n\tGM_getValue: false,\n\tGM_info: false,\n\tGM_listValues: false,\n\tGM_log: false,\n\tGM_openInTab: false,\n\tGM_registerMenuCommand: false,\n\tGM_setClipboard: false,\n\tGM_setValue: false,\n\tGM_xmlhttpRequest: false,\n\tunsafeWindow: false\n};\nvar devtools = {\n\t$: false,\n\t$_: false,\n\t$$: false,\n\t$0: false,\n\t$1: false,\n\t$2: false,\n\t$3: false,\n\t$4: false,\n\t$x: false,\n\tchrome: false,\n\tclear: false,\n\tcopy: false,\n\tdebug: false,\n\tdir: false,\n\tdirxml: false,\n\tgetEventListeners: false,\n\tinspect: false,\n\tkeys: false,\n\tmonitor: false,\n\tmonitorEvents: false,\n\tprofile: false,\n\tprofileEnd: false,\n\tqueryObjects: false,\n\ttable: false,\n\tundebug: false,\n\tunmonitor: false,\n\tunmonitorEvents: false,\n\tvalues: false\n};\nvar globals = {\n\tbuiltin: builtin,\n\tes5: es5,\n\tes2015: es2015,\n\tes2017: es2017,\n\tbrowser: browser,\n\tworker: worker,\n\tnode: node,\n\tnodeBuiltin: nodeBuiltin,\n\tcommonjs: commonjs,\n\tamd: amd,\n\tmocha: mocha,\n\tjasmine: jasmine,\n\tjest: jest,\n\tqunit: qunit,\n\tphantomjs: phantomjs,\n\tcouch: couch,\n\trhino: rhino,\n\tnashorn: nashorn,\n\twsh: wsh,\n\tjquery: jquery,\n\tyui: yui,\n\tshelljs: shelljs,\n\tprototypejs: prototypejs,\n\tmeteor: meteor,\n\tmongo: mongo,\n\tapplescript: applescript,\n\tserviceworker: serviceworker,\n\tatomtest: atomtest,\n\tembertest: embertest,\n\tprotractor: protractor,\n\t\"shared-node-browser\": {\n\tclearInterval: false,\n\tclearTimeout: false,\n\tconsole: false,\n\tsetInterval: false,\n\tsetTimeout: false,\n\tURL: false,\n\tURLSearchParams: false\n},\n\twebextensions: webextensions,\n\tgreasemonkey: greasemonkey,\n\tdevtools: devtools\n};\n\nvar globals$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  builtin: builtin,\n  es5: es5,\n  es2015: es2015,\n  es2017: es2017,\n  browser: browser,\n  worker: worker,\n  node: node,\n  nodeBuiltin: nodeBuiltin,\n  commonjs: commonjs,\n  amd: amd,\n  mocha: mocha,\n  jasmine: jasmine,\n  jest: jest,\n  qunit: qunit,\n  phantomjs: phantomjs,\n  couch: couch,\n  rhino: rhino,\n  nashorn: nashorn,\n  wsh: wsh,\n  jquery: jquery,\n  yui: yui,\n  shelljs: shelljs,\n  prototypejs: prototypejs,\n  meteor: meteor,\n  mongo: mongo,\n  applescript: applescript,\n  serviceworker: serviceworker,\n  atomtest: atomtest,\n  embertest: embertest,\n  protractor: protractor,\n  webextensions: webextensions,\n  greasemonkey: greasemonkey,\n  devtools: devtools,\n  'default': globals\n});\n\nvar require$$0$1 = getCjsExportFromNamespace(globals$1);\n\nvar globals$2 = require$$0$1;\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Get the object that has differentce.\n * @param {Record<string,boolean>} current The newer object.\n * @param {Record<string,boolean>} prev The older object.\n * @returns {Record<string,boolean>} The difference object.\n */\nfunction getDiff(current, prev) {\n    const retv = {};\n\n    for (const [key, value] of Object.entries(current)) {\n        if (!Object.hasOwnProperty.call(prev, key)) {\n            retv[key] = value;\n        }\n    }\n\n    return retv;\n}\n\nconst newGlobals2015 = getDiff(globals$2.es2015, globals$2.es5); // 19 variables such as Promise, Map, ...\nconst newGlobals2017 = {\n    Atomics: false,\n    SharedArrayBuffer: false\n};\nconst newGlobals2020 = {\n    BigInt: false,\n    BigInt64Array: false,\n    BigUint64Array: false\n};\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/** @type {Map<string, import(\"../lib/shared/types\").Environment>} */\nvar environments = new Map(Object.entries({\n\n    // Language\n    builtin: {\n        globals: globals$2.es5\n    },\n    es6: {\n        globals: newGlobals2015,\n        parserOptions: {\n            ecmaVersion: 6\n        }\n    },\n    es2015: {\n        globals: newGlobals2015,\n        parserOptions: {\n            ecmaVersion: 6\n        }\n    },\n    es2017: {\n        globals: { ...newGlobals2015, ...newGlobals2017 },\n        parserOptions: {\n            ecmaVersion: 8\n        }\n    },\n    es2020: {\n        globals: { ...newGlobals2015, ...newGlobals2017, ...newGlobals2020 },\n        parserOptions: {\n            ecmaVersion: 11\n        }\n    },\n\n    // Platforms\n    browser: {\n        globals: globals$2.browser\n    },\n    node: {\n        globals: globals$2.node,\n        parserOptions: {\n            ecmaFeatures: {\n                globalReturn: true\n            }\n        }\n    },\n    \"shared-node-browser\": {\n        globals: globals$2[\"shared-node-browser\"]\n    },\n    worker: {\n        globals: globals$2.worker\n    },\n    serviceworker: {\n        globals: globals$2.serviceworker\n    },\n\n    // Frameworks\n    commonjs: {\n        globals: globals$2.commonjs,\n        parserOptions: {\n            ecmaFeatures: {\n                globalReturn: true\n            }\n        }\n    },\n    amd: {\n        globals: globals$2.amd\n    },\n    mocha: {\n        globals: globals$2.mocha\n    },\n    jasmine: {\n        globals: globals$2.jasmine\n    },\n    jest: {\n        globals: globals$2.jest\n    },\n    phantomjs: {\n        globals: globals$2.phantomjs\n    },\n    jquery: {\n        globals: globals$2.jquery\n    },\n    qunit: {\n        globals: globals$2.qunit\n    },\n    prototypejs: {\n        globals: globals$2.prototypejs\n    },\n    shelljs: {\n        globals: globals$2.shelljs\n    },\n    meteor: {\n        globals: globals$2.meteor\n    },\n    mongo: {\n        globals: globals$2.mongo\n    },\n    protractor: {\n        globals: globals$2.protractor\n    },\n    applescript: {\n        globals: globals$2.applescript\n    },\n    nashorn: {\n        globals: globals$2.nashorn\n    },\n    atomtest: {\n        globals: globals$2.atomtest\n    },\n    embertest: {\n        globals: globals$2.embertest\n    },\n    webextensions: {\n        globals: globals$2.webextensions\n    },\n    greasemonkey: {\n        globals: globals$2.greasemonkey\n    }\n}));\n\n/**\n * @fileoverview Common utils for AST.\n *\n * This file contains only shared items for core and rules.\n * If you make a utility for rules, please see `../rules/utils/ast-utils.js`.\n *\n * @author Toru Nagashima <https://github.com/mysticatea>\n */\n\nconst breakableTypePattern = /^(?:(?:Do)?While|For(?:In|Of)?|Switch)Statement$/u;\nconst lineBreakPattern = /\\r\\n|[\\r\\n\\u2028\\u2029]/u;\nconst shebangPattern = /^#!([^\\r\\n]+)/u;\n\n/**\n * Creates a version of the `lineBreakPattern` regex with the global flag.\n * Global regexes are mutable, so this needs to be a function instead of a constant.\n * @returns {RegExp} A global regular expression that matches line terminators\n */\nfunction createGlobalLinebreakMatcher() {\n    return new RegExp(lineBreakPattern.source, \"gu\");\n}\n\nvar astUtils = {\n    breakableTypePattern,\n    lineBreakPattern,\n    createGlobalLinebreakMatcher,\n    shebangPattern\n};\n\n/**\n * @fileoverview Defines a schema for configs.\n * @author Sylvan Mably\n */\n\nconst baseConfigProperties = {\n    $schema: { type: \"string\" },\n    env: { type: \"object\" },\n    extends: { $ref: \"#/definitions/stringOrStrings\" },\n    globals: { type: \"object\" },\n    overrides: {\n        type: \"array\",\n        items: { $ref: \"#/definitions/overrideConfig\" },\n        additionalItems: false\n    },\n    parser: { type: [\"string\", \"null\"] },\n    parserOptions: { type: \"object\" },\n    plugins: { type: \"array\" },\n    processor: { type: \"string\" },\n    rules: { type: \"object\" },\n    settings: { type: \"object\" },\n    noInlineConfig: { type: \"boolean\" },\n    reportUnusedDisableDirectives: { type: \"boolean\" },\n\n    ecmaFeatures: { type: \"object\" } // deprecated; logs a warning when used\n};\n\nconst configSchema = {\n    definitions: {\n        stringOrStrings: {\n            oneOf: [\n                { type: \"string\" },\n                {\n                    type: \"array\",\n                    items: { type: \"string\" },\n                    additionalItems: false\n                }\n            ]\n        },\n        stringOrStringsRequired: {\n            oneOf: [\n                { type: \"string\" },\n                {\n                    type: \"array\",\n                    items: { type: \"string\" },\n                    additionalItems: false,\n                    minItems: 1\n                }\n            ]\n        },\n\n        // Config at top-level.\n        objectConfig: {\n            type: \"object\",\n            properties: {\n                root: { type: \"boolean\" },\n                ignorePatterns: { $ref: \"#/definitions/stringOrStrings\" },\n                ...baseConfigProperties\n            },\n            additionalProperties: false\n        },\n\n        // Config in `overrides`.\n        overrideConfig: {\n            type: \"object\",\n            properties: {\n                excludedFiles: { $ref: \"#/definitions/stringOrStrings\" },\n                files: { $ref: \"#/definitions/stringOrStringsRequired\" },\n                ...baseConfigProperties\n            },\n            required: [\"files\"],\n            additionalProperties: false\n        }\n    },\n\n    $ref: \"#/definitions/objectConfig\"\n};\n\nvar configSchema_1 = configSchema;\n\n/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar w = d * 7;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nvar ms = function(val, options) {\n  options = options || {};\n  var type = typeof val;\n  if (type === 'string' && val.length > 0) {\n    return parse$3(val);\n  } else if (type === 'number' && isFinite(val)) {\n    return options.long ? fmtLong(val) : fmtShort(val);\n  }\n  throw new Error(\n    'val is not a non-empty string or a valid number. val=' +\n      JSON.stringify(val)\n  );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse$3(str) {\n  str = String(str);\n  if (str.length > 100) {\n    return;\n  }\n  var match = /^(-?(?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(\n    str\n  );\n  if (!match) {\n    return;\n  }\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'weeks':\n    case 'week':\n    case 'w':\n      return n * w;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return Math.round(ms / d) + 'd';\n  }\n  if (msAbs >= h) {\n    return Math.round(ms / h) + 'h';\n  }\n  if (msAbs >= m) {\n    return Math.round(ms / m) + 'm';\n  }\n  if (msAbs >= s) {\n    return Math.round(ms / s) + 's';\n  }\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return plural(ms, msAbs, d, 'day');\n  }\n  if (msAbs >= h) {\n    return plural(ms, msAbs, h, 'hour');\n  }\n  if (msAbs >= m) {\n    return plural(ms, msAbs, m, 'minute');\n  }\n  if (msAbs >= s) {\n    return plural(ms, msAbs, s, 'second');\n  }\n  return ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, msAbs, n, name) {\n  var isPlural = msAbs >= n * 1.5;\n  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');\n}\n\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n */\n\nfunction setup(env) {\n\tcreateDebug.debug = createDebug;\n\tcreateDebug.default = createDebug;\n\tcreateDebug.coerce = coerce;\n\tcreateDebug.disable = disable;\n\tcreateDebug.enable = enable;\n\tcreateDebug.enabled = enabled;\n\tcreateDebug.humanize = ms;\n\n\tObject.keys(env).forEach(key => {\n\t\tcreateDebug[key] = env[key];\n\t});\n\n\t/**\n\t* Active `debug` instances.\n\t*/\n\tcreateDebug.instances = [];\n\n\t/**\n\t* The currently active debug mode names, and names to skip.\n\t*/\n\n\tcreateDebug.names = [];\n\tcreateDebug.skips = [];\n\n\t/**\n\t* Map of special \"%n\" handling functions, for the debug \"format\" argument.\n\t*\n\t* Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n\t*/\n\tcreateDebug.formatters = {};\n\n\t/**\n\t* Selects a color for a debug namespace\n\t* @param {String} namespace The namespace string for the for the debug instance to be colored\n\t* @return {Number|String} An ANSI color code for the given namespace\n\t* @api private\n\t*/\n\tfunction selectColor(namespace) {\n\t\tlet hash = 0;\n\n\t\tfor (let i = 0; i < namespace.length; i++) {\n\t\t\thash = ((hash << 5) - hash) + namespace.charCodeAt(i);\n\t\t\thash |= 0; // Convert to 32bit integer\n\t\t}\n\n\t\treturn createDebug.colors[Math.abs(hash) % createDebug.colors.length];\n\t}\n\tcreateDebug.selectColor = selectColor;\n\n\t/**\n\t* Create a debugger with the given `namespace`.\n\t*\n\t* @param {String} namespace\n\t* @return {Function}\n\t* @api public\n\t*/\n\tfunction createDebug(namespace) {\n\t\tlet prevTime;\n\n\t\tfunction debug(...args) {\n\t\t\t// Disabled?\n\t\t\tif (!debug.enabled) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst self = debug;\n\n\t\t\t// Set `diff` timestamp\n\t\t\tconst curr = Number(new Date());\n\t\t\tconst ms = curr - (prevTime || curr);\n\t\t\tself.diff = ms;\n\t\t\tself.prev = prevTime;\n\t\t\tself.curr = curr;\n\t\t\tprevTime = curr;\n\n\t\t\targs[0] = createDebug.coerce(args[0]);\n\n\t\t\tif (typeof args[0] !== 'string') {\n\t\t\t\t// Anything else let's inspect with %O\n\t\t\t\targs.unshift('%O');\n\t\t\t}\n\n\t\t\t// Apply any `formatters` transformations\n\t\t\tlet index = 0;\n\t\t\targs[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {\n\t\t\t\t// If we encounter an escaped % then don't increase the array index\n\t\t\t\tif (match === '%%') {\n\t\t\t\t\treturn match;\n\t\t\t\t}\n\t\t\t\tindex++;\n\t\t\t\tconst formatter = createDebug.formatters[format];\n\t\t\t\tif (typeof formatter === 'function') {\n\t\t\t\t\tconst val = args[index];\n\t\t\t\t\tmatch = formatter.call(self, val);\n\n\t\t\t\t\t// Now we need to remove `args[index]` since it's inlined in the `format`\n\t\t\t\t\targs.splice(index, 1);\n\t\t\t\t\tindex--;\n\t\t\t\t}\n\t\t\t\treturn match;\n\t\t\t});\n\n\t\t\t// Apply env-specific formatting (colors, etc.)\n\t\t\tcreateDebug.formatArgs.call(self, args);\n\n\t\t\tconst logFn = self.log || createDebug.log;\n\t\t\tlogFn.apply(self, args);\n\t\t}\n\n\t\tdebug.namespace = namespace;\n\t\tdebug.enabled = createDebug.enabled(namespace);\n\t\tdebug.useColors = createDebug.useColors();\n\t\tdebug.color = selectColor(namespace);\n\t\tdebug.destroy = destroy;\n\t\tdebug.extend = extend;\n\t\t// Debug.formatArgs = formatArgs;\n\t\t// debug.rawLog = rawLog;\n\n\t\t// env-specific initialization logic for debug instances\n\t\tif (typeof createDebug.init === 'function') {\n\t\t\tcreateDebug.init(debug);\n\t\t}\n\n\t\tcreateDebug.instances.push(debug);\n\n\t\treturn debug;\n\t}\n\n\tfunction destroy() {\n\t\tconst index = createDebug.instances.indexOf(this);\n\t\tif (index !== -1) {\n\t\t\tcreateDebug.instances.splice(index, 1);\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n\n\tfunction extend(namespace, delimiter) {\n\t\tconst newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);\n\t\tnewDebug.log = this.log;\n\t\treturn newDebug;\n\t}\n\n\t/**\n\t* Enables a debug mode by namespaces. This can include modes\n\t* separated by a colon and wildcards.\n\t*\n\t* @param {String} namespaces\n\t* @api public\n\t*/\n\tfunction enable(namespaces) {\n\t\tcreateDebug.save(namespaces);\n\n\t\tcreateDebug.names = [];\n\t\tcreateDebug.skips = [];\n\n\t\tlet i;\n\t\tconst split = (typeof namespaces === 'string' ? namespaces : '').split(/[\\s,]+/);\n\t\tconst len = split.length;\n\n\t\tfor (i = 0; i < len; i++) {\n\t\t\tif (!split[i]) {\n\t\t\t\t// ignore empty strings\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tnamespaces = split[i].replace(/\\*/g, '.*?');\n\n\t\t\tif (namespaces[0] === '-') {\n\t\t\t\tcreateDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n\t\t\t} else {\n\t\t\t\tcreateDebug.names.push(new RegExp('^' + namespaces + '$'));\n\t\t\t}\n\t\t}\n\n\t\tfor (i = 0; i < createDebug.instances.length; i++) {\n\t\t\tconst instance = createDebug.instances[i];\n\t\t\tinstance.enabled = createDebug.enabled(instance.namespace);\n\t\t}\n\t}\n\n\t/**\n\t* Disable debug output.\n\t*\n\t* @return {String} namespaces\n\t* @api public\n\t*/\n\tfunction disable() {\n\t\tconst namespaces = [\n\t\t\t...createDebug.names.map(toNamespace),\n\t\t\t...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)\n\t\t].join(',');\n\t\tcreateDebug.enable('');\n\t\treturn namespaces;\n\t}\n\n\t/**\n\t* Returns true if the given mode name is enabled, false otherwise.\n\t*\n\t* @param {String} name\n\t* @return {Boolean}\n\t* @api public\n\t*/\n\tfunction enabled(name) {\n\t\tif (name[name.length - 1] === '*') {\n\t\t\treturn true;\n\t\t}\n\n\t\tlet i;\n\t\tlet len;\n\n\t\tfor (i = 0, len = createDebug.skips.length; i < len; i++) {\n\t\t\tif (createDebug.skips[i].test(name)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\tfor (i = 0, len = createDebug.names.length; i < len; i++) {\n\t\t\tif (createDebug.names[i].test(name)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t* Convert regexp to namespace\n\t*\n\t* @param {RegExp} regxep\n\t* @return {String} namespace\n\t* @api private\n\t*/\n\tfunction toNamespace(regexp) {\n\t\treturn regexp.toString()\n\t\t\t.substring(2, regexp.toString().length - 2)\n\t\t\t.replace(/\\.\\*\\?$/, '*');\n\t}\n\n\t/**\n\t* Coerce `val`.\n\t*\n\t* @param {Mixed} val\n\t* @return {Mixed}\n\t* @api private\n\t*/\n\tfunction coerce(val) {\n\t\tif (val instanceof Error) {\n\t\t\treturn val.stack || val.message;\n\t\t}\n\t\treturn val;\n\t}\n\n\tcreateDebug.enable(createDebug.load());\n\n\treturn createDebug;\n}\n\nvar common$1 = setup;\n\nvar browser$1 = createCommonjsModule(function (module, exports) {\n/* eslint-env browser */\n\n/**\n * This is the web browser implementation of `debug()`.\n */\n\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n\t'#0000CC',\n\t'#0000FF',\n\t'#0033CC',\n\t'#0033FF',\n\t'#0066CC',\n\t'#0066FF',\n\t'#0099CC',\n\t'#0099FF',\n\t'#00CC00',\n\t'#00CC33',\n\t'#00CC66',\n\t'#00CC99',\n\t'#00CCCC',\n\t'#00CCFF',\n\t'#3300CC',\n\t'#3300FF',\n\t'#3333CC',\n\t'#3333FF',\n\t'#3366CC',\n\t'#3366FF',\n\t'#3399CC',\n\t'#3399FF',\n\t'#33CC00',\n\t'#33CC33',\n\t'#33CC66',\n\t'#33CC99',\n\t'#33CCCC',\n\t'#33CCFF',\n\t'#6600CC',\n\t'#6600FF',\n\t'#6633CC',\n\t'#6633FF',\n\t'#66CC00',\n\t'#66CC33',\n\t'#9900CC',\n\t'#9900FF',\n\t'#9933CC',\n\t'#9933FF',\n\t'#99CC00',\n\t'#99CC33',\n\t'#CC0000',\n\t'#CC0033',\n\t'#CC0066',\n\t'#CC0099',\n\t'#CC00CC',\n\t'#CC00FF',\n\t'#CC3300',\n\t'#CC3333',\n\t'#CC3366',\n\t'#CC3399',\n\t'#CC33CC',\n\t'#CC33FF',\n\t'#CC6600',\n\t'#CC6633',\n\t'#CC9900',\n\t'#CC9933',\n\t'#CCCC00',\n\t'#CCCC33',\n\t'#FF0000',\n\t'#FF0033',\n\t'#FF0066',\n\t'#FF0099',\n\t'#FF00CC',\n\t'#FF00FF',\n\t'#FF3300',\n\t'#FF3333',\n\t'#FF3366',\n\t'#FF3399',\n\t'#FF33CC',\n\t'#FF33FF',\n\t'#FF6600',\n\t'#FF6633',\n\t'#FF9900',\n\t'#FF9933',\n\t'#FFCC00',\n\t'#FFCC33'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\n// eslint-disable-next-line complexity\nfunction useColors() {\n\t// NB: In an Electron preload script, document will be defined but not fully\n\t// initialized. Since we know we're in Chrome, we'll just detect this case\n\t// explicitly\n\tif (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {\n\t\treturn true;\n\t}\n\n\t// Internet Explorer and Edge do not support colors.\n\tif (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\\/(\\d+)/)) {\n\t\treturn false;\n\t}\n\n\t// Is webkit? http://stackoverflow.com/a/16459606/376773\n\t// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n\treturn (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||\n\t\t// Is firebug? http://stackoverflow.com/a/398120/376773\n\t\t(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||\n\t\t// Is firefox >= v31?\n\t\t// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n\t\t// Double check webkit in userAgent just in case we are in a worker\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n\targs[0] = (this.useColors ? '%c' : '') +\n\t\tthis.namespace +\n\t\t(this.useColors ? ' %c' : ' ') +\n\t\targs[0] +\n\t\t(this.useColors ? '%c ' : ' ') +\n\t\t'+' + module.exports.humanize(this.diff);\n\n\tif (!this.useColors) {\n\t\treturn;\n\t}\n\n\tconst c = 'color: ' + this.color;\n\targs.splice(1, 0, c, 'color: inherit');\n\n\t// The final \"%c\" is somewhat tricky, because there could be other\n\t// arguments passed either before or after the %c, so we need to\n\t// figure out the correct index to insert the CSS into\n\tlet index = 0;\n\tlet lastC = 0;\n\targs[0].replace(/%[a-zA-Z%]/g, match => {\n\t\tif (match === '%%') {\n\t\t\treturn;\n\t\t}\n\t\tindex++;\n\t\tif (match === '%c') {\n\t\t\t// We only are interested in the *last* %c\n\t\t\t// (the user may have provided their own)\n\t\t\tlastC = index;\n\t\t}\n\t});\n\n\targs.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\nfunction log(...args) {\n\t// This hackery is required for IE8/9, where\n\t// the `console.log` function doesn't have 'apply'\n\treturn typeof console === 'object' &&\n\t\tconsole.log &&\n\t\tconsole.log(...args);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\nfunction save(namespaces) {\n\ttry {\n\t\tif (namespaces) {\n\t\t\texports.storage.setItem('debug', namespaces);\n\t\t} else {\n\t\t\texports.storage.removeItem('debug');\n\t\t}\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\nfunction load() {\n\tlet r;\n\ttry {\n\t\tr = exports.storage.getItem('debug');\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n\n\t// If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n\tif (!r && typeof process !== 'undefined' && 'env' in process) {\n\t\tr = process.env.DEBUG;\n\t}\n\n\treturn r;\n}\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n\ttry {\n\t\t// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context\n\t\t// The Browser also has localStorage in the global context.\n\t\treturn localStorage;\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\nmodule.exports = common$1(exports);\n\nconst {formatters} = module.exports;\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nformatters.j = function (v) {\n\ttry {\n\t\treturn JSON.stringify(v);\n\t} catch (error) {\n\t\treturn '[UnexpectedJSONParseError]: ' + error.message;\n\t}\n};\n});\nvar browser_1 = browser$1.log;\nvar browser_2 = browser$1.formatArgs;\nvar browser_3 = browser$1.save;\nvar browser_4 = browser$1.load;\nvar browser_5 = browser$1.useColors;\nvar browser_6 = browser$1.storage;\nvar browser_7 = browser$1.colors;\n\nvar hasFlag$1 = (flag, argv) => {\n\targv = argv || process.argv;\n\tconst prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');\n\tconst pos = argv.indexOf(prefix + flag);\n\tconst terminatorPos = argv.indexOf('--');\n\treturn pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);\n};\n\nconst env$1 = process.env;\n\nlet forceColor$1;\nif (hasFlag$1('no-color') ||\n\thasFlag$1('no-colors') ||\n\thasFlag$1('color=false')) {\n\tforceColor$1 = false;\n} else if (hasFlag$1('color') ||\n\thasFlag$1('colors') ||\n\thasFlag$1('color=true') ||\n\thasFlag$1('color=always')) {\n\tforceColor$1 = true;\n}\nif ('FORCE_COLOR' in env$1) {\n\tforceColor$1 = env$1.FORCE_COLOR.length === 0 || parseInt(env$1.FORCE_COLOR, 10) !== 0;\n}\n\nfunction translateLevel$1(level) {\n\tif (level === 0) {\n\t\treturn false;\n\t}\n\n\treturn {\n\t\tlevel,\n\t\thasBasic: true,\n\t\thas256: level >= 2,\n\t\thas16m: level >= 3\n\t};\n}\n\nfunction supportsColor$1(stream) {\n\tif (forceColor$1 === false) {\n\t\treturn 0;\n\t}\n\n\tif (hasFlag$1('color=16m') ||\n\t\thasFlag$1('color=full') ||\n\t\thasFlag$1('color=truecolor')) {\n\t\treturn 3;\n\t}\n\n\tif (hasFlag$1('color=256')) {\n\t\treturn 2;\n\t}\n\n\tif (stream && !stream.isTTY && forceColor$1 !== true) {\n\t\treturn 0;\n\t}\n\n\tconst min = forceColor$1 ? 1 : 0;\n\n\tif (process.platform === 'win32') {\n\t\t// Node.js 7.5.0 is the first version of Node.js to include a patch to\n\t\t// libuv that enables 256 color output on Windows. Anything earlier and it\n\t\t// won't work. However, here we target Node.js 8 at minimum as it is an LTS\n\t\t// release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows\n\t\t// release that supports 256 colors. Windows 10 build 14931 is the first release\n\t\t// that supports 16m/TrueColor.\n\t\tconst osRelease = os.release().split('.');\n\t\tif (\n\t\t\tNumber(process.versions.node.split('.')[0]) >= 8 &&\n\t\t\tNumber(osRelease[0]) >= 10 &&\n\t\t\tNumber(osRelease[2]) >= 10586\n\t\t) {\n\t\t\treturn Number(osRelease[2]) >= 14931 ? 3 : 2;\n\t\t}\n\n\t\treturn 1;\n\t}\n\n\tif ('CI' in env$1) {\n\t\tif (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env$1) || env$1.CI_NAME === 'codeship') {\n\t\t\treturn 1;\n\t\t}\n\n\t\treturn min;\n\t}\n\n\tif ('TEAMCITY_VERSION' in env$1) {\n\t\treturn /^(9\\.(0*[1-9]\\d*)\\.|\\d{2,}\\.)/.test(env$1.TEAMCITY_VERSION) ? 1 : 0;\n\t}\n\n\tif (env$1.COLORTERM === 'truecolor') {\n\t\treturn 3;\n\t}\n\n\tif ('TERM_PROGRAM' in env$1) {\n\t\tconst version = parseInt((env$1.TERM_PROGRAM_VERSION || '').split('.')[0], 10);\n\n\t\tswitch (env$1.TERM_PROGRAM) {\n\t\t\tcase 'iTerm.app':\n\t\t\t\treturn version >= 3 ? 3 : 2;\n\t\t\tcase 'Apple_Terminal':\n\t\t\t\treturn 2;\n\t\t\t// No default\n\t\t}\n\t}\n\n\tif (/-256(color)?$/i.test(env$1.TERM)) {\n\t\treturn 2;\n\t}\n\n\tif (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env$1.TERM)) {\n\t\treturn 1;\n\t}\n\n\tif ('COLORTERM' in env$1) {\n\t\treturn 1;\n\t}\n\n\tif (env$1.TERM === 'dumb') {\n\t\treturn min;\n\t}\n\n\treturn min;\n}\n\nfunction getSupportLevel$1(stream) {\n\tconst level = supportsColor$1(stream);\n\treturn translateLevel$1(level);\n}\n\nvar supportsColor_1$1 = {\n\tsupportsColor: getSupportLevel$1,\n\tstdout: getSupportLevel$1(process.stdout),\n\tstderr: getSupportLevel$1(process.stderr)\n};\n\nvar node$1 = createCommonjsModule(function (module, exports) {\n/**\n * Module dependencies.\n */\n\n\n\n\n/**\n * This is the Node.js implementation of `debug()`.\n */\n\nexports.init = init;\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\n\n/**\n * Colors.\n */\n\nexports.colors = [6, 2, 3, 4, 5, 1];\n\ntry {\n\t// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)\n\t// eslint-disable-next-line import/no-extraneous-dependencies\n\tconst supportsColor = supportsColor_1$1;\n\n\tif (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {\n\t\texports.colors = [\n\t\t\t20,\n\t\t\t21,\n\t\t\t26,\n\t\t\t27,\n\t\t\t32,\n\t\t\t33,\n\t\t\t38,\n\t\t\t39,\n\t\t\t40,\n\t\t\t41,\n\t\t\t42,\n\t\t\t43,\n\t\t\t44,\n\t\t\t45,\n\t\t\t56,\n\t\t\t57,\n\t\t\t62,\n\t\t\t63,\n\t\t\t68,\n\t\t\t69,\n\t\t\t74,\n\t\t\t75,\n\t\t\t76,\n\t\t\t77,\n\t\t\t78,\n\t\t\t79,\n\t\t\t80,\n\t\t\t81,\n\t\t\t92,\n\t\t\t93,\n\t\t\t98,\n\t\t\t99,\n\t\t\t112,\n\t\t\t113,\n\t\t\t128,\n\t\t\t129,\n\t\t\t134,\n\t\t\t135,\n\t\t\t148,\n\t\t\t149,\n\t\t\t160,\n\t\t\t161,\n\t\t\t162,\n\t\t\t163,\n\t\t\t164,\n\t\t\t165,\n\t\t\t166,\n\t\t\t167,\n\t\t\t168,\n\t\t\t169,\n\t\t\t170,\n\t\t\t171,\n\t\t\t172,\n\t\t\t173,\n\t\t\t178,\n\t\t\t179,\n\t\t\t184,\n\t\t\t185,\n\t\t\t196,\n\t\t\t197,\n\t\t\t198,\n\t\t\t199,\n\t\t\t200,\n\t\t\t201,\n\t\t\t202,\n\t\t\t203,\n\t\t\t204,\n\t\t\t205,\n\t\t\t206,\n\t\t\t207,\n\t\t\t208,\n\t\t\t209,\n\t\t\t214,\n\t\t\t215,\n\t\t\t220,\n\t\t\t221\n\t\t];\n\t}\n} catch (error) {\n\t// Swallow - we only care if `supports-color` is available; it doesn't have to be.\n}\n\n/**\n * Build up the default `inspectOpts` object from the environment variables.\n *\n *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js\n */\n\nexports.inspectOpts = Object.keys(process.env).filter(key => {\n\treturn /^debug_/i.test(key);\n}).reduce((obj, key) => {\n\t// Camel-case\n\tconst prop = key\n\t\t.substring(6)\n\t\t.toLowerCase()\n\t\t.replace(/_([a-z])/g, (_, k) => {\n\t\t\treturn k.toUpperCase();\n\t\t});\n\n\t// Coerce string value into JS value\n\tlet val = process.env[key];\n\tif (/^(yes|on|true|enabled)$/i.test(val)) {\n\t\tval = true;\n\t} else if (/^(no|off|false|disabled)$/i.test(val)) {\n\t\tval = false;\n\t} else if (val === 'null') {\n\t\tval = null;\n\t} else {\n\t\tval = Number(val);\n\t}\n\n\tobj[prop] = val;\n\treturn obj;\n}, {});\n\n/**\n * Is stdout a TTY? Colored output is enabled when `true`.\n */\n\nfunction useColors() {\n\treturn 'colors' in exports.inspectOpts ?\n\t\tBoolean(exports.inspectOpts.colors) :\n\t\ttty.isatty(process.stderr.fd);\n}\n\n/**\n * Adds ANSI color escape codes if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n\tconst {namespace: name, useColors} = this;\n\n\tif (useColors) {\n\t\tconst c = this.color;\n\t\tconst colorCode = '\\u001B[3' + (c < 8 ? c : '8;5;' + c);\n\t\tconst prefix = `  ${colorCode};1m${name} \\u001B[0m`;\n\n\t\targs[0] = prefix + args[0].split('\\n').join('\\n' + prefix);\n\t\targs.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\\u001B[0m');\n\t} else {\n\t\targs[0] = getDate() + name + ' ' + args[0];\n\t}\n}\n\nfunction getDate() {\n\tif (exports.inspectOpts.hideDate) {\n\t\treturn '';\n\t}\n\treturn new Date().toISOString() + ' ';\n}\n\n/**\n * Invokes `util.format()` with the specified arguments and writes to stderr.\n */\n\nfunction log(...args) {\n\treturn process.stderr.write(util$2.format(...args) + '\\n');\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\nfunction save(namespaces) {\n\tif (namespaces) {\n\t\tprocess.env.DEBUG = namespaces;\n\t} else {\n\t\t// If you set a process.env field to null or undefined, it gets cast to the\n\t\t// string 'null' or 'undefined'. Just delete instead.\n\t\tdelete process.env.DEBUG;\n\t}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n\treturn process.env.DEBUG;\n}\n\n/**\n * Init logic for `debug` instances.\n *\n * Create a new `inspectOpts` object in case `useColors` is set\n * differently for a particular `debug` instance.\n */\n\nfunction init(debug) {\n\tdebug.inspectOpts = {};\n\n\tconst keys = Object.keys(exports.inspectOpts);\n\tfor (let i = 0; i < keys.length; i++) {\n\t\tdebug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];\n\t}\n}\n\nmodule.exports = common$1(exports);\n\nconst {formatters} = module.exports;\n\n/**\n * Map %o to `util.inspect()`, all on a single line.\n */\n\nformatters.o = function (v) {\n\tthis.inspectOpts.colors = this.useColors;\n\treturn util$2.inspect(v, this.inspectOpts)\n\t\t.replace(/\\s*\\n\\s*/g, ' ');\n};\n\n/**\n * Map %O to `util.inspect()`, allowing multiple lines if needed.\n */\n\nformatters.O = function (v) {\n\tthis.inspectOpts.colors = this.useColors;\n\treturn util$2.inspect(v, this.inspectOpts);\n};\n});\nvar node_1 = node$1.init;\nvar node_2 = node$1.log;\nvar node_3 = node$1.formatArgs;\nvar node_4 = node$1.save;\nvar node_5 = node$1.load;\nvar node_6 = node$1.useColors;\nvar node_7 = node$1.colors;\nvar node_8 = node$1.inspectOpts;\n\nvar src = createCommonjsModule(function (module) {\n/**\n * Detect Electron renderer / nwjs process, which is node, but we should\n * treat as a browser.\n */\n\nif (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {\n\tmodule.exports = browser$1;\n} else {\n\tmodule.exports = node$1;\n}\n});\n\nconst debug = src(\"eslint:rules\");\n\n/** @typedef {import(\"./types\").Rule} Rule */\n\n/**\n * The `Map` object that loads each rule when it's accessed.\n * @example\n * const rules = new LazyLoadingRuleMap([\n *     [\"eqeqeq\", () => require(\"eqeqeq\")],\n *     [\"semi\", () => require(\"semi\")],\n *     [\"no-unused-vars\", () => require(\"no-unused-vars\")],\n * ])\n *\n * rules.get(\"semi\") // call `() => require(\"semi\")` here.\n *\n * @extends {Map<string, () => Rule>}\n */\nclass LazyLoadingRuleMap extends Map {\n\n    /**\n     * Initialize this map.\n     * @param {Array<[string, function(): Rule]>} loaders The rule loaders.\n     */\n    constructor(loaders) {\n        let remaining = loaders.length;\n\n        super(\n            debug.enabled\n                ? loaders.map(([ruleId, load]) => {\n                    let cache = null;\n\n                    return [\n                        ruleId,\n                        () => {\n                            if (!cache) {\n                                debug(\"Loading rule %o (remaining=%d)\", ruleId, --remaining);\n                                cache = load();\n                            }\n                            return cache;\n                        }\n                    ];\n                })\n                : loaders\n        );\n\n        // `super(...iterable)` uses `this.set()`, so disable it here.\n        Object.defineProperty(LazyLoadingRuleMap.prototype, \"set\", {\n            configurable: true,\n            value: void 0\n        });\n    }\n\n    /**\n     * Get a rule.\n     * Each rule will be loaded on the first access.\n     * @param {string} ruleId The rule ID to get.\n     * @returns {Rule|undefined} The rule.\n     */\n    get(ruleId) {\n        const load = super.get(ruleId);\n\n        return load && load();\n    }\n\n    /**\n     * Iterate rules.\n     * @returns {IterableIterator<Rule>} Rules.\n     */\n    *values() {\n        for (const load of super.values()) {\n            yield load();\n        }\n    }\n\n    /**\n     * Iterate rules.\n     * @returns {IterableIterator<[string, Rule]>} Rules.\n     */\n    *entries() {\n        for (const [ruleId, load] of super.entries()) {\n            yield [ruleId, load()];\n        }\n    }\n\n    /**\n     * Call a function with each rule.\n     * @param {Function} callbackFn The callback function.\n     * @param {any} [thisArg] The object to pass to `this` of the callback function.\n     * @returns {void}\n     */\n    forEach(callbackFn, thisArg) {\n        for (const [ruleId, load] of super.entries()) {\n            callbackFn.call(thisArg, load(), ruleId, this);\n        }\n    }\n}\n\n// Forbid mutation.\nObject.defineProperties(LazyLoadingRuleMap.prototype, {\n    clear: { configurable: true, value: void 0 },\n    delete: { configurable: true, value: void 0 },\n    [Symbol.iterator]: {\n        configurable: true,\n        writable: true,\n        value: LazyLoadingRuleMap.prototype.entries\n    }\n});\n\nvar lazyLoadingRuleMap = { LazyLoadingRuleMap };\n\nvar ast = createCommonjsModule(function (module) {\n/*\n  Copyright (C) 2013 Yusuke Suzuki <utatane.tea@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n(function () {\n\n    function isExpression(node) {\n        if (node == null) { return false; }\n        switch (node.type) {\n            case 'ArrayExpression':\n            case 'AssignmentExpression':\n            case 'BinaryExpression':\n            case 'CallExpression':\n            case 'ConditionalExpression':\n            case 'FunctionExpression':\n            case 'Identifier':\n            case 'Literal':\n            case 'LogicalExpression':\n            case 'MemberExpression':\n            case 'NewExpression':\n            case 'ObjectExpression':\n            case 'SequenceExpression':\n            case 'ThisExpression':\n            case 'UnaryExpression':\n            case 'UpdateExpression':\n                return true;\n        }\n        return false;\n    }\n\n    function isIterationStatement(node) {\n        if (node == null) { return false; }\n        switch (node.type) {\n            case 'DoWhileStatement':\n            case 'ForInStatement':\n            case 'ForStatement':\n            case 'WhileStatement':\n                return true;\n        }\n        return false;\n    }\n\n    function isStatement(node) {\n        if (node == null) { return false; }\n        switch (node.type) {\n            case 'BlockStatement':\n            case 'BreakStatement':\n            case 'ContinueStatement':\n            case 'DebuggerStatement':\n            case 'DoWhileStatement':\n            case 'EmptyStatement':\n            case 'ExpressionStatement':\n            case 'ForInStatement':\n            case 'ForStatement':\n            case 'IfStatement':\n            case 'LabeledStatement':\n            case 'ReturnStatement':\n            case 'SwitchStatement':\n            case 'ThrowStatement':\n            case 'TryStatement':\n            case 'VariableDeclaration':\n            case 'WhileStatement':\n            case 'WithStatement':\n                return true;\n        }\n        return false;\n    }\n\n    function isSourceElement(node) {\n      return isStatement(node) || node != null && node.type === 'FunctionDeclaration';\n    }\n\n    function trailingStatement(node) {\n        switch (node.type) {\n        case 'IfStatement':\n            if (node.alternate != null) {\n                return node.alternate;\n            }\n            return node.consequent;\n\n        case 'LabeledStatement':\n        case 'ForStatement':\n        case 'ForInStatement':\n        case 'WhileStatement':\n        case 'WithStatement':\n            return node.body;\n        }\n        return null;\n    }\n\n    function isProblematicIfStatement(node) {\n        var current;\n\n        if (node.type !== 'IfStatement') {\n            return false;\n        }\n        if (node.alternate == null) {\n            return false;\n        }\n        current = node.consequent;\n        do {\n            if (current.type === 'IfStatement') {\n                if (current.alternate == null)  {\n                    return true;\n                }\n            }\n            current = trailingStatement(current);\n        } while (current);\n\n        return false;\n    }\n\n    module.exports = {\n        isExpression: isExpression,\n        isStatement: isStatement,\n        isIterationStatement: isIterationStatement,\n        isSourceElement: isSourceElement,\n        isProblematicIfStatement: isProblematicIfStatement,\n\n        trailingStatement: trailingStatement\n    };\n}());\n/* vim: set sw=4 ts=4 et tw=80 : */\n});\nvar ast_1 = ast.isExpression;\nvar ast_2 = ast.isStatement;\nvar ast_3 = ast.isIterationStatement;\nvar ast_4 = ast.isSourceElement;\nvar ast_5 = ast.isProblematicIfStatement;\nvar ast_6 = ast.trailingStatement;\n\nvar code = createCommonjsModule(function (module) {\n/*\n  Copyright (C) 2013-2014 Yusuke Suzuki <utatane.tea@gmail.com>\n  Copyright (C) 2014 Ivan Nikulin <ifaaan@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n(function () {\n\n    var ES6Regex, ES5Regex, NON_ASCII_WHITESPACES, IDENTIFIER_START, IDENTIFIER_PART, ch;\n\n    // See `tools/generate-identifier-regex.js`.\n    ES5Regex = {\n        // ECMAScript 5.1/Unicode v9.0.0 NonAsciiIdentifierStart:\n        NonAsciiIdentifierStart: /[\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B4\\u08B6-\\u08BD\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C60\\u0C61\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u1884\\u1887-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1C80-\\u1C88\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AE\\uA7B0-\\uA7B7\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]/,\n        // ECMAScript 5.1/Unicode v9.0.0 NonAsciiIdentifierPart:\n        NonAsciiIdentifierPart: /[\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0300-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u0483-\\u0487\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0610-\\u061A\\u0620-\\u0669\\u066E-\\u06D3\\u06D5-\\u06DC\\u06DF-\\u06E8\\u06EA-\\u06FC\\u06FF\\u0710-\\u074A\\u074D-\\u07B1\\u07C0-\\u07F5\\u07FA\\u0800-\\u082D\\u0840-\\u085B\\u08A0-\\u08B4\\u08B6-\\u08BD\\u08D4-\\u08E1\\u08E3-\\u0963\\u0966-\\u096F\\u0971-\\u0983\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BC-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CE\\u09D7\\u09DC\\u09DD\\u09DF-\\u09E3\\u09E6-\\u09F1\\u0A01-\\u0A03\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A59-\\u0A5C\\u0A5E\\u0A66-\\u0A75\\u0A81-\\u0A83\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABC-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AD0\\u0AE0-\\u0AE3\\u0AE6-\\u0AEF\\u0AF9\\u0B01-\\u0B03\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3C-\\u0B44\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B5C\\u0B5D\\u0B5F-\\u0B63\\u0B66-\\u0B6F\\u0B71\\u0B82\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD0\\u0BD7\\u0BE6-\\u0BEF\\u0C00-\\u0C03\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C58-\\u0C5A\\u0C60-\\u0C63\\u0C66-\\u0C6F\\u0C80-\\u0C83\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBC-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0CDE\\u0CE0-\\u0CE3\\u0CE6-\\u0CEF\\u0CF1\\u0CF2\\u0D01-\\u0D03\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D-\\u0D44\\u0D46-\\u0D48\\u0D4A-\\u0D4E\\u0D54-\\u0D57\\u0D5F-\\u0D63\\u0D66-\\u0D6F\\u0D7A-\\u0D7F\\u0D82\\u0D83\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDF\\u0DE6-\\u0DEF\\u0DF2\\u0DF3\\u0E01-\\u0E3A\\u0E40-\\u0E4E\\u0E50-\\u0E59\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB9\\u0EBB-\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EC8-\\u0ECD\\u0ED0-\\u0ED9\\u0EDC-\\u0EDF\\u0F00\\u0F18\\u0F19\\u0F20-\\u0F29\\u0F35\\u0F37\\u0F39\\u0F3E-\\u0F47\\u0F49-\\u0F6C\\u0F71-\\u0F84\\u0F86-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u1000-\\u1049\\u1050-\\u109D\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u135D-\\u135F\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1714\\u1720-\\u1734\\u1740-\\u1753\\u1760-\\u176C\\u176E-\\u1770\\u1772\\u1773\\u1780-\\u17D3\\u17D7\\u17DC\\u17DD\\u17E0-\\u17E9\\u180B-\\u180D\\u1810-\\u1819\\u1820-\\u1877\\u1880-\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1920-\\u192B\\u1930-\\u193B\\u1946-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u19D0-\\u19D9\\u1A00-\\u1A1B\\u1A20-\\u1A5E\\u1A60-\\u1A7C\\u1A7F-\\u1A89\\u1A90-\\u1A99\\u1AA7\\u1AB0-\\u1ABD\\u1B00-\\u1B4B\\u1B50-\\u1B59\\u1B6B-\\u1B73\\u1B80-\\u1BF3\\u1C00-\\u1C37\\u1C40-\\u1C49\\u1C4D-\\u1C7D\\u1C80-\\u1C88\\u1CD0-\\u1CD2\\u1CD4-\\u1CF6\\u1CF8\\u1CF9\\u1D00-\\u1DF5\\u1DFB-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u200C\\u200D\\u203F\\u2040\\u2054\\u2071\\u207F\\u2090-\\u209C\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D7F-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2DE0-\\u2DFF\\u2E2F\\u3005-\\u3007\\u3021-\\u302F\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u3099\\u309A\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA62B\\uA640-\\uA66F\\uA674-\\uA67D\\uA67F-\\uA6F1\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AE\\uA7B0-\\uA7B7\\uA7F7-\\uA827\\uA840-\\uA873\\uA880-\\uA8C5\\uA8D0-\\uA8D9\\uA8E0-\\uA8F7\\uA8FB\\uA8FD\\uA900-\\uA92D\\uA930-\\uA953\\uA960-\\uA97C\\uA980-\\uA9C0\\uA9CF-\\uA9D9\\uA9E0-\\uA9FE\\uAA00-\\uAA36\\uAA40-\\uAA4D\\uAA50-\\uAA59\\uAA60-\\uAA76\\uAA7A-\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEF\\uAAF2-\\uAAF6\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABEA\\uABEC\\uABED\\uABF0-\\uABF9\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE00-\\uFE0F\\uFE20-\\uFE2F\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF10-\\uFF19\\uFF21-\\uFF3A\\uFF3F\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]/\n    };\n\n    ES6Regex = {\n        // ECMAScript 6/Unicode v9.0.0 NonAsciiIdentifierStart:\n        NonAsciiIdentifierStart: /[\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B4\\u08B6-\\u08BD\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C60\\u0C61\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1C80-\\u1C88\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2118-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309B-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AE\\uA7B0-\\uA7B7\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDD40-\\uDD74\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDF00-\\uDF1F\\uDF30-\\uDF4A\\uDF50-\\uDF75\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF\\uDFD1-\\uDFD5]|\\uD801[\\uDC00-\\uDC9D\\uDCB0-\\uDCD3\\uDCD8-\\uDCFB\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC60-\\uDC76\\uDC80-\\uDC9E\\uDCE0-\\uDCF2\\uDCF4\\uDCF5\\uDD00-\\uDD15\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBE\\uDDBF\\uDE00\\uDE10-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE33\\uDE60-\\uDE7C\\uDE80-\\uDE9C\\uDEC0-\\uDEC7\\uDEC9-\\uDEE4\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF60-\\uDF72\\uDF80-\\uDF91]|\\uD803[\\uDC00-\\uDC48\\uDC80-\\uDCB2\\uDCC0-\\uDCF2]|\\uD804[\\uDC03-\\uDC37\\uDC83-\\uDCAF\\uDCD0-\\uDCE8\\uDD03-\\uDD26\\uDD50-\\uDD72\\uDD76\\uDD83-\\uDDB2\\uDDC1-\\uDDC4\\uDDDA\\uDDDC\\uDE00-\\uDE11\\uDE13-\\uDE2B\\uDE80-\\uDE86\\uDE88\\uDE8A-\\uDE8D\\uDE8F-\\uDE9D\\uDE9F-\\uDEA8\\uDEB0-\\uDEDE\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3D\\uDF50\\uDF5D-\\uDF61]|\\uD805[\\uDC00-\\uDC34\\uDC47-\\uDC4A\\uDC80-\\uDCAF\\uDCC4\\uDCC5\\uDCC7\\uDD80-\\uDDAE\\uDDD8-\\uDDDB\\uDE00-\\uDE2F\\uDE44\\uDE80-\\uDEAA\\uDF00-\\uDF19]|\\uD806[\\uDCA0-\\uDCDF\\uDCFF\\uDEC0-\\uDEF8]|\\uD807[\\uDC00-\\uDC08\\uDC0A-\\uDC2E\\uDC40\\uDC72-\\uDC8F]|\\uD808[\\uDC00-\\uDF99]|\\uD809[\\uDC00-\\uDC6E\\uDC80-\\uDD43]|[\\uD80C\\uD81C-\\uD820\\uD840-\\uD868\\uD86A-\\uD86C\\uD86F-\\uD872][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD811[\\uDC00-\\uDE46]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDED0-\\uDEED\\uDF00-\\uDF2F\\uDF40-\\uDF43\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDF00-\\uDF44\\uDF50\\uDF93-\\uDF9F\\uDFE0]|\\uD821[\\uDC00-\\uDFEC]|\\uD822[\\uDC00-\\uDEF2]|\\uD82C[\\uDC00\\uDC01]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99]|\\uD835[\\uDC00-\\uDC54\\uDC56-\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD1E-\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD52-\\uDEA5\\uDEA8-\\uDEC0\\uDEC2-\\uDEDA\\uDEDC-\\uDEFA\\uDEFC-\\uDF14\\uDF16-\\uDF34\\uDF36-\\uDF4E\\uDF50-\\uDF6E\\uDF70-\\uDF88\\uDF8A-\\uDFA8\\uDFAA-\\uDFC2\\uDFC4-\\uDFCB]|\\uD83A[\\uDC00-\\uDCC4\\uDD00-\\uDD43]|\\uD83B[\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD869[\\uDC00-\\uDED6\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF34\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D\\uDC20-\\uDFFF]|\\uD873[\\uDC00-\\uDEA1]|\\uD87E[\\uDC00-\\uDE1D]/,\n        // ECMAScript 6/Unicode v9.0.0 NonAsciiIdentifierPart:\n        NonAsciiIdentifierPart: /[\\xAA\\xB5\\xB7\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0300-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u0483-\\u0487\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0610-\\u061A\\u0620-\\u0669\\u066E-\\u06D3\\u06D5-\\u06DC\\u06DF-\\u06E8\\u06EA-\\u06FC\\u06FF\\u0710-\\u074A\\u074D-\\u07B1\\u07C0-\\u07F5\\u07FA\\u0800-\\u082D\\u0840-\\u085B\\u08A0-\\u08B4\\u08B6-\\u08BD\\u08D4-\\u08E1\\u08E3-\\u0963\\u0966-\\u096F\\u0971-\\u0983\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BC-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CE\\u09D7\\u09DC\\u09DD\\u09DF-\\u09E3\\u09E6-\\u09F1\\u0A01-\\u0A03\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A59-\\u0A5C\\u0A5E\\u0A66-\\u0A75\\u0A81-\\u0A83\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABC-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AD0\\u0AE0-\\u0AE3\\u0AE6-\\u0AEF\\u0AF9\\u0B01-\\u0B03\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3C-\\u0B44\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B5C\\u0B5D\\u0B5F-\\u0B63\\u0B66-\\u0B6F\\u0B71\\u0B82\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD0\\u0BD7\\u0BE6-\\u0BEF\\u0C00-\\u0C03\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C58-\\u0C5A\\u0C60-\\u0C63\\u0C66-\\u0C6F\\u0C80-\\u0C83\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBC-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0CDE\\u0CE0-\\u0CE3\\u0CE6-\\u0CEF\\u0CF1\\u0CF2\\u0D01-\\u0D03\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D-\\u0D44\\u0D46-\\u0D48\\u0D4A-\\u0D4E\\u0D54-\\u0D57\\u0D5F-\\u0D63\\u0D66-\\u0D6F\\u0D7A-\\u0D7F\\u0D82\\u0D83\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDF\\u0DE6-\\u0DEF\\u0DF2\\u0DF3\\u0E01-\\u0E3A\\u0E40-\\u0E4E\\u0E50-\\u0E59\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB9\\u0EBB-\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EC8-\\u0ECD\\u0ED0-\\u0ED9\\u0EDC-\\u0EDF\\u0F00\\u0F18\\u0F19\\u0F20-\\u0F29\\u0F35\\u0F37\\u0F39\\u0F3E-\\u0F47\\u0F49-\\u0F6C\\u0F71-\\u0F84\\u0F86-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u1000-\\u1049\\u1050-\\u109D\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u135D-\\u135F\\u1369-\\u1371\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1714\\u1720-\\u1734\\u1740-\\u1753\\u1760-\\u176C\\u176E-\\u1770\\u1772\\u1773\\u1780-\\u17D3\\u17D7\\u17DC\\u17DD\\u17E0-\\u17E9\\u180B-\\u180D\\u1810-\\u1819\\u1820-\\u1877\\u1880-\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1920-\\u192B\\u1930-\\u193B\\u1946-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u19D0-\\u19DA\\u1A00-\\u1A1B\\u1A20-\\u1A5E\\u1A60-\\u1A7C\\u1A7F-\\u1A89\\u1A90-\\u1A99\\u1AA7\\u1AB0-\\u1ABD\\u1B00-\\u1B4B\\u1B50-\\u1B59\\u1B6B-\\u1B73\\u1B80-\\u1BF3\\u1C00-\\u1C37\\u1C40-\\u1C49\\u1C4D-\\u1C7D\\u1C80-\\u1C88\\u1CD0-\\u1CD2\\u1CD4-\\u1CF6\\u1CF8\\u1CF9\\u1D00-\\u1DF5\\u1DFB-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u200C\\u200D\\u203F\\u2040\\u2054\\u2071\\u207F\\u2090-\\u209C\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2118-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D7F-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2DE0-\\u2DFF\\u3005-\\u3007\\u3021-\\u302F\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u3099-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA62B\\uA640-\\uA66F\\uA674-\\uA67D\\uA67F-\\uA6F1\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AE\\uA7B0-\\uA7B7\\uA7F7-\\uA827\\uA840-\\uA873\\uA880-\\uA8C5\\uA8D0-\\uA8D9\\uA8E0-\\uA8F7\\uA8FB\\uA8FD\\uA900-\\uA92D\\uA930-\\uA953\\uA960-\\uA97C\\uA980-\\uA9C0\\uA9CF-\\uA9D9\\uA9E0-\\uA9FE\\uAA00-\\uAA36\\uAA40-\\uAA4D\\uAA50-\\uAA59\\uAA60-\\uAA76\\uAA7A-\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEF\\uAAF2-\\uAAF6\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABEA\\uABEC\\uABED\\uABF0-\\uABF9\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE00-\\uFE0F\\uFE20-\\uFE2F\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF10-\\uFF19\\uFF21-\\uFF3A\\uFF3F\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDD40-\\uDD74\\uDDFD\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDEE0\\uDF00-\\uDF1F\\uDF30-\\uDF4A\\uDF50-\\uDF7A\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF\\uDFD1-\\uDFD5]|\\uD801[\\uDC00-\\uDC9D\\uDCA0-\\uDCA9\\uDCB0-\\uDCD3\\uDCD8-\\uDCFB\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC60-\\uDC76\\uDC80-\\uDC9E\\uDCE0-\\uDCF2\\uDCF4\\uDCF5\\uDD00-\\uDD15\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBE\\uDDBF\\uDE00-\\uDE03\\uDE05\\uDE06\\uDE0C-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE33\\uDE38-\\uDE3A\\uDE3F\\uDE60-\\uDE7C\\uDE80-\\uDE9C\\uDEC0-\\uDEC7\\uDEC9-\\uDEE6\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF60-\\uDF72\\uDF80-\\uDF91]|\\uD803[\\uDC00-\\uDC48\\uDC80-\\uDCB2\\uDCC0-\\uDCF2]|\\uD804[\\uDC00-\\uDC46\\uDC66-\\uDC6F\\uDC7F-\\uDCBA\\uDCD0-\\uDCE8\\uDCF0-\\uDCF9\\uDD00-\\uDD34\\uDD36-\\uDD3F\\uDD50-\\uDD73\\uDD76\\uDD80-\\uDDC4\\uDDCA-\\uDDCC\\uDDD0-\\uDDDA\\uDDDC\\uDE00-\\uDE11\\uDE13-\\uDE37\\uDE3E\\uDE80-\\uDE86\\uDE88\\uDE8A-\\uDE8D\\uDE8F-\\uDE9D\\uDE9F-\\uDEA8\\uDEB0-\\uDEEA\\uDEF0-\\uDEF9\\uDF00-\\uDF03\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3C-\\uDF44\\uDF47\\uDF48\\uDF4B-\\uDF4D\\uDF50\\uDF57\\uDF5D-\\uDF63\\uDF66-\\uDF6C\\uDF70-\\uDF74]|\\uD805[\\uDC00-\\uDC4A\\uDC50-\\uDC59\\uDC80-\\uDCC5\\uDCC7\\uDCD0-\\uDCD9\\uDD80-\\uDDB5\\uDDB8-\\uDDC0\\uDDD8-\\uDDDD\\uDE00-\\uDE40\\uDE44\\uDE50-\\uDE59\\uDE80-\\uDEB7\\uDEC0-\\uDEC9\\uDF00-\\uDF19\\uDF1D-\\uDF2B\\uDF30-\\uDF39]|\\uD806[\\uDCA0-\\uDCE9\\uDCFF\\uDEC0-\\uDEF8]|\\uD807[\\uDC00-\\uDC08\\uDC0A-\\uDC36\\uDC38-\\uDC40\\uDC50-\\uDC59\\uDC72-\\uDC8F\\uDC92-\\uDCA7\\uDCA9-\\uDCB6]|\\uD808[\\uDC00-\\uDF99]|\\uD809[\\uDC00-\\uDC6E\\uDC80-\\uDD43]|[\\uD80C\\uD81C-\\uD820\\uD840-\\uD868\\uD86A-\\uD86C\\uD86F-\\uD872][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD811[\\uDC00-\\uDE46]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDE60-\\uDE69\\uDED0-\\uDEED\\uDEF0-\\uDEF4\\uDF00-\\uDF36\\uDF40-\\uDF43\\uDF50-\\uDF59\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDF00-\\uDF44\\uDF50-\\uDF7E\\uDF8F-\\uDF9F\\uDFE0]|\\uD821[\\uDC00-\\uDFEC]|\\uD822[\\uDC00-\\uDEF2]|\\uD82C[\\uDC00\\uDC01]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99\\uDC9D\\uDC9E]|\\uD834[\\uDD65-\\uDD69\\uDD6D-\\uDD72\\uDD7B-\\uDD82\\uDD85-\\uDD8B\\uDDAA-\\uDDAD\\uDE42-\\uDE44]|\\uD835[\\uDC00-\\uDC54\\uDC56-\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD1E-\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD52-\\uDEA5\\uDEA8-\\uDEC0\\uDEC2-\\uDEDA\\uDEDC-\\uDEFA\\uDEFC-\\uDF14\\uDF16-\\uDF34\\uDF36-\\uDF4E\\uDF50-\\uDF6E\\uDF70-\\uDF88\\uDF8A-\\uDFA8\\uDFAA-\\uDFC2\\uDFC4-\\uDFCB\\uDFCE-\\uDFFF]|\\uD836[\\uDE00-\\uDE36\\uDE3B-\\uDE6C\\uDE75\\uDE84\\uDE9B-\\uDE9F\\uDEA1-\\uDEAF]|\\uD838[\\uDC00-\\uDC06\\uDC08-\\uDC18\\uDC1B-\\uDC21\\uDC23\\uDC24\\uDC26-\\uDC2A]|\\uD83A[\\uDC00-\\uDCC4\\uDCD0-\\uDCD6\\uDD00-\\uDD4A\\uDD50-\\uDD59]|\\uD83B[\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD869[\\uDC00-\\uDED6\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF34\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D\\uDC20-\\uDFFF]|\\uD873[\\uDC00-\\uDEA1]|\\uD87E[\\uDC00-\\uDE1D]|\\uDB40[\\uDD00-\\uDDEF]/\n    };\n\n    function isDecimalDigit(ch) {\n        return 0x30 <= ch && ch <= 0x39;  // 0..9\n    }\n\n    function isHexDigit(ch) {\n        return 0x30 <= ch && ch <= 0x39 ||  // 0..9\n            0x61 <= ch && ch <= 0x66 ||     // a..f\n            0x41 <= ch && ch <= 0x46;       // A..F\n    }\n\n    function isOctalDigit(ch) {\n        return ch >= 0x30 && ch <= 0x37;  // 0..7\n    }\n\n    // 7.2 White Space\n\n    NON_ASCII_WHITESPACES = [\n        0x1680,\n        0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A,\n        0x202F, 0x205F,\n        0x3000,\n        0xFEFF\n    ];\n\n    function isWhiteSpace(ch) {\n        return ch === 0x20 || ch === 0x09 || ch === 0x0B || ch === 0x0C || ch === 0xA0 ||\n            ch >= 0x1680 && NON_ASCII_WHITESPACES.indexOf(ch) >= 0;\n    }\n\n    // 7.3 Line Terminators\n\n    function isLineTerminator(ch) {\n        return ch === 0x0A || ch === 0x0D || ch === 0x2028 || ch === 0x2029;\n    }\n\n    // 7.6 Identifier Names and Identifiers\n\n    function fromCodePoint(cp) {\n        if (cp <= 0xFFFF) { return String.fromCharCode(cp); }\n        var cu1 = String.fromCharCode(Math.floor((cp - 0x10000) / 0x400) + 0xD800);\n        var cu2 = String.fromCharCode(((cp - 0x10000) % 0x400) + 0xDC00);\n        return cu1 + cu2;\n    }\n\n    IDENTIFIER_START = new Array(0x80);\n    for(ch = 0; ch < 0x80; ++ch) {\n        IDENTIFIER_START[ch] =\n            ch >= 0x61 && ch <= 0x7A ||  // a..z\n            ch >= 0x41 && ch <= 0x5A ||  // A..Z\n            ch === 0x24 || ch === 0x5F;  // $ (dollar) and _ (underscore)\n    }\n\n    IDENTIFIER_PART = new Array(0x80);\n    for(ch = 0; ch < 0x80; ++ch) {\n        IDENTIFIER_PART[ch] =\n            ch >= 0x61 && ch <= 0x7A ||  // a..z\n            ch >= 0x41 && ch <= 0x5A ||  // A..Z\n            ch >= 0x30 && ch <= 0x39 ||  // 0..9\n            ch === 0x24 || ch === 0x5F;  // $ (dollar) and _ (underscore)\n    }\n\n    function isIdentifierStartES5(ch) {\n        return ch < 0x80 ? IDENTIFIER_START[ch] : ES5Regex.NonAsciiIdentifierStart.test(fromCodePoint(ch));\n    }\n\n    function isIdentifierPartES5(ch) {\n        return ch < 0x80 ? IDENTIFIER_PART[ch] : ES5Regex.NonAsciiIdentifierPart.test(fromCodePoint(ch));\n    }\n\n    function isIdentifierStartES6(ch) {\n        return ch < 0x80 ? IDENTIFIER_START[ch] : ES6Regex.NonAsciiIdentifierStart.test(fromCodePoint(ch));\n    }\n\n    function isIdentifierPartES6(ch) {\n        return ch < 0x80 ? IDENTIFIER_PART[ch] : ES6Regex.NonAsciiIdentifierPart.test(fromCodePoint(ch));\n    }\n\n    module.exports = {\n        isDecimalDigit: isDecimalDigit,\n        isHexDigit: isHexDigit,\n        isOctalDigit: isOctalDigit,\n        isWhiteSpace: isWhiteSpace,\n        isLineTerminator: isLineTerminator,\n        isIdentifierStartES5: isIdentifierStartES5,\n        isIdentifierPartES5: isIdentifierPartES5,\n        isIdentifierStartES6: isIdentifierStartES6,\n        isIdentifierPartES6: isIdentifierPartES6\n    };\n}());\n/* vim: set sw=4 ts=4 et tw=80 : */\n});\nvar code_1 = code.isDecimalDigit;\nvar code_2 = code.isHexDigit;\nvar code_3 = code.isOctalDigit;\nvar code_4 = code.isWhiteSpace;\nvar code_5 = code.isLineTerminator;\nvar code_6 = code.isIdentifierStartES5;\nvar code_7 = code.isIdentifierPartES5;\nvar code_8 = code.isIdentifierStartES6;\nvar code_9 = code.isIdentifierPartES6;\n\nvar keyword = createCommonjsModule(function (module) {\n/*\n  Copyright (C) 2013 Yusuke Suzuki <utatane.tea@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n(function () {\n\n    var code$1 = code;\n\n    function isStrictModeReservedWordES6(id) {\n        switch (id) {\n        case 'implements':\n        case 'interface':\n        case 'package':\n        case 'private':\n        case 'protected':\n        case 'public':\n        case 'static':\n        case 'let':\n            return true;\n        default:\n            return false;\n        }\n    }\n\n    function isKeywordES5(id, strict) {\n        // yield should not be treated as keyword under non-strict mode.\n        if (!strict && id === 'yield') {\n            return false;\n        }\n        return isKeywordES6(id, strict);\n    }\n\n    function isKeywordES6(id, strict) {\n        if (strict && isStrictModeReservedWordES6(id)) {\n            return true;\n        }\n\n        switch (id.length) {\n        case 2:\n            return (id === 'if') || (id === 'in') || (id === 'do');\n        case 3:\n            return (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try');\n        case 4:\n            return (id === 'this') || (id === 'else') || (id === 'case') ||\n                (id === 'void') || (id === 'with') || (id === 'enum');\n        case 5:\n            return (id === 'while') || (id === 'break') || (id === 'catch') ||\n                (id === 'throw') || (id === 'const') || (id === 'yield') ||\n                (id === 'class') || (id === 'super');\n        case 6:\n            return (id === 'return') || (id === 'typeof') || (id === 'delete') ||\n                (id === 'switch') || (id === 'export') || (id === 'import');\n        case 7:\n            return (id === 'default') || (id === 'finally') || (id === 'extends');\n        case 8:\n            return (id === 'function') || (id === 'continue') || (id === 'debugger');\n        case 10:\n            return (id === 'instanceof');\n        default:\n            return false;\n        }\n    }\n\n    function isReservedWordES5(id, strict) {\n        return id === 'null' || id === 'true' || id === 'false' || isKeywordES5(id, strict);\n    }\n\n    function isReservedWordES6(id, strict) {\n        return id === 'null' || id === 'true' || id === 'false' || isKeywordES6(id, strict);\n    }\n\n    function isRestrictedWord(id) {\n        return id === 'eval' || id === 'arguments';\n    }\n\n    function isIdentifierNameES5(id) {\n        var i, iz, ch;\n\n        if (id.length === 0) { return false; }\n\n        ch = id.charCodeAt(0);\n        if (!code$1.isIdentifierStartES5(ch)) {\n            return false;\n        }\n\n        for (i = 1, iz = id.length; i < iz; ++i) {\n            ch = id.charCodeAt(i);\n            if (!code$1.isIdentifierPartES5(ch)) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    function decodeUtf16(lead, trail) {\n        return (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;\n    }\n\n    function isIdentifierNameES6(id) {\n        var i, iz, ch, lowCh, check;\n\n        if (id.length === 0) { return false; }\n\n        check = code$1.isIdentifierStartES6;\n        for (i = 0, iz = id.length; i < iz; ++i) {\n            ch = id.charCodeAt(i);\n            if (0xD800 <= ch && ch <= 0xDBFF) {\n                ++i;\n                if (i >= iz) { return false; }\n                lowCh = id.charCodeAt(i);\n                if (!(0xDC00 <= lowCh && lowCh <= 0xDFFF)) {\n                    return false;\n                }\n                ch = decodeUtf16(ch, lowCh);\n            }\n            if (!check(ch)) {\n                return false;\n            }\n            check = code$1.isIdentifierPartES6;\n        }\n        return true;\n    }\n\n    function isIdentifierES5(id, strict) {\n        return isIdentifierNameES5(id) && !isReservedWordES5(id, strict);\n    }\n\n    function isIdentifierES6(id, strict) {\n        return isIdentifierNameES6(id) && !isReservedWordES6(id, strict);\n    }\n\n    module.exports = {\n        isKeywordES5: isKeywordES5,\n        isKeywordES6: isKeywordES6,\n        isReservedWordES5: isReservedWordES5,\n        isReservedWordES6: isReservedWordES6,\n        isRestrictedWord: isRestrictedWord,\n        isIdentifierNameES5: isIdentifierNameES5,\n        isIdentifierNameES6: isIdentifierNameES6,\n        isIdentifierES5: isIdentifierES5,\n        isIdentifierES6: isIdentifierES6\n    };\n}());\n/* vim: set sw=4 ts=4 et tw=80 : */\n});\nvar keyword_1 = keyword.isKeywordES5;\nvar keyword_2 = keyword.isKeywordES6;\nvar keyword_3 = keyword.isReservedWordES5;\nvar keyword_4 = keyword.isReservedWordES6;\nvar keyword_5 = keyword.isRestrictedWord;\nvar keyword_6 = keyword.isIdentifierNameES5;\nvar keyword_7 = keyword.isIdentifierNameES6;\nvar keyword_8 = keyword.isIdentifierES5;\nvar keyword_9 = keyword.isIdentifierES6;\n\nvar utils = createCommonjsModule(function (module, exports) {\n/*\n  Copyright (C) 2013 Yusuke Suzuki <utatane.tea@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n\n(function () {\n\n    exports.ast = ast;\n    exports.code = code;\n    exports.keyword = keyword;\n}());\n/* vim: set sw=4 ts=4 et tw=80 : */\n});\nvar utils_1 = utils.ast;\nvar utils_2 = utils.code;\nvar utils_3 = utils.keyword;\n\nvar astUtils$1 = createCommonjsModule(function (module) {\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\nconst {\n    breakableTypePattern,\n    createGlobalLinebreakMatcher,\n    lineBreakPattern,\n    shebangPattern\n} = astUtils;\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst anyFunctionPattern = /^(?:Function(?:Declaration|Expression)|ArrowFunctionExpression)$/u;\nconst anyLoopPattern = /^(?:DoWhile|For|ForIn|ForOf|While)Statement$/u;\nconst arrayOrTypedArrayPattern = /Array$/u;\nconst arrayMethodPattern = /^(?:every|filter|find|findIndex|forEach|map|some)$/u;\nconst bindOrCallOrApplyPattern = /^(?:bind|call|apply)$/u;\nconst thisTagPattern = /^[\\s*]*@this/mu;\n\n\nconst COMMENTS_IGNORE_PATTERN = /^\\s*(?:eslint|jshint\\s+|jslint\\s+|istanbul\\s+|globals?\\s+|exported\\s+|jscs)/u;\nconst LINEBREAKS = new Set([\"\\r\\n\", \"\\r\", \"\\n\", \"\\u2028\", \"\\u2029\"]);\n\n// A set of node types that can contain a list of statements\nconst STATEMENT_LIST_PARENTS = new Set([\"Program\", \"BlockStatement\", \"SwitchCase\"]);\n\nconst DECIMAL_INTEGER_PATTERN = /^(0|[1-9]\\d*)$/u;\nconst OCTAL_ESCAPE_PATTERN = /^(?:[^\\\\]|\\\\[^0-7]|\\\\0(?![0-9]))*\\\\(?:[1-7]|0[0-9])/u;\n\n/**\n * Checks reference if is non initializer and writable.\n * @param {Reference} reference A reference to check.\n * @param {int} index The index of the reference in the references.\n * @param {Reference[]} references The array that the reference belongs to.\n * @returns {boolean} Success/Failure\n * @private\n */\nfunction isModifyingReference(reference, index, references) {\n    const identifier = reference.identifier;\n\n    /*\n     * Destructuring assignments can have multiple default value, so\n     * possibly there are multiple writeable references for the same\n     * identifier.\n     */\n    const modifyingDifferentIdentifier = index === 0 ||\n        references[index - 1].identifier !== identifier;\n\n    return (identifier &&\n        reference.init === false &&\n        reference.isWrite() &&\n        modifyingDifferentIdentifier\n    );\n}\n\n/**\n * Checks whether the given string starts with uppercase or not.\n * @param {string} s The string to check.\n * @returns {boolean} `true` if the string starts with uppercase.\n */\nfunction startsWithUpperCase(s) {\n    return s[0] !== s[0].toLocaleLowerCase();\n}\n\n/**\n * Checks whether or not a node is a constructor.\n * @param {ASTNode} node A function node to check.\n * @returns {boolean} Wehether or not a node is a constructor.\n */\nfunction isES5Constructor(node) {\n    return (node.id && startsWithUpperCase(node.id.name));\n}\n\n/**\n * Finds a function node from ancestors of a node.\n * @param {ASTNode} node A start node to find.\n * @returns {Node|null} A found function node.\n */\nfunction getUpperFunction(node) {\n    for (let currentNode = node; currentNode; currentNode = currentNode.parent) {\n        if (anyFunctionPattern.test(currentNode.type)) {\n            return currentNode;\n        }\n    }\n    return null;\n}\n\n/**\n * Checks whether a given node is a function node or not.\n * The following types are function nodes:\n *\n * - ArrowFunctionExpression\n * - FunctionDeclaration\n * - FunctionExpression\n * @param {ASTNode|null} node A node to check.\n * @returns {boolean} `true` if the node is a function node.\n */\nfunction isFunction(node) {\n    return Boolean(node && anyFunctionPattern.test(node.type));\n}\n\n/**\n * Checks whether a given node is a loop node or not.\n * The following types are loop nodes:\n *\n * - DoWhileStatement\n * - ForInStatement\n * - ForOfStatement\n * - ForStatement\n * - WhileStatement\n * @param {ASTNode|null} node A node to check.\n * @returns {boolean} `true` if the node is a loop node.\n */\nfunction isLoop(node) {\n    return Boolean(node && anyLoopPattern.test(node.type));\n}\n\n/**\n * Checks whether the given node is in a loop or not.\n * @param {ASTNode} node The node to check.\n * @returns {boolean} `true` if the node is in a loop.\n */\nfunction isInLoop(node) {\n    for (let currentNode = node; currentNode && !isFunction(currentNode); currentNode = currentNode.parent) {\n        if (isLoop(currentNode)) {\n            return true;\n        }\n    }\n\n    return false;\n}\n\n/**\n * Checks whether or not a node is `null` or `undefined`.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} Whether or not the node is a `null` or `undefined`.\n * @public\n */\nfunction isNullOrUndefined(node) {\n    return (\n        module.exports.isNullLiteral(node) ||\n        (node.type === \"Identifier\" && node.name === \"undefined\") ||\n        (node.type === \"UnaryExpression\" && node.operator === \"void\")\n    );\n}\n\n/**\n * Checks whether or not a node is callee.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} Whether or not the node is callee.\n */\nfunction isCallee(node) {\n    return node.parent.type === \"CallExpression\" && node.parent.callee === node;\n}\n\n/**\n * Checks whether or not a node is `Reflect.apply`.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} Whether or not the node is a `Reflect.apply`.\n */\nfunction isReflectApply(node) {\n    return (\n        node.type === \"MemberExpression\" &&\n        node.object.type === \"Identifier\" &&\n        node.object.name === \"Reflect\" &&\n        node.property.type === \"Identifier\" &&\n        node.property.name === \"apply\" &&\n        node.computed === false\n    );\n}\n\n/**\n * Checks whether or not a node is `Array.from`.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} Whether or not the node is a `Array.from`.\n */\nfunction isArrayFromMethod(node) {\n    return (\n        node.type === \"MemberExpression\" &&\n        node.object.type === \"Identifier\" &&\n        arrayOrTypedArrayPattern.test(node.object.name) &&\n        node.property.type === \"Identifier\" &&\n        node.property.name === \"from\" &&\n        node.computed === false\n    );\n}\n\n/**\n * Checks whether or not a node is a method which has `thisArg`.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} Whether or not the node is a method which has `thisArg`.\n */\nfunction isMethodWhichHasThisArg(node) {\n    for (\n        let currentNode = node;\n        currentNode.type === \"MemberExpression\" && !currentNode.computed;\n        currentNode = currentNode.property\n    ) {\n        if (currentNode.property.type === \"Identifier\") {\n            return arrayMethodPattern.test(currentNode.property.name);\n        }\n    }\n\n    return false;\n}\n\n/**\n * Creates the negate function of the given function.\n * @param {Function} f The function to negate.\n * @returns {Function} Negated function.\n */\nfunction negate(f) {\n    return token => !f(token);\n}\n\n/**\n * Checks whether or not a node has a `@this` tag in its comments.\n * @param {ASTNode} node A node to check.\n * @param {SourceCode} sourceCode A SourceCode instance to get comments.\n * @returns {boolean} Whether or not the node has a `@this` tag in its comments.\n */\nfunction hasJSDocThisTag(node, sourceCode) {\n    const jsdocComment = sourceCode.getJSDocComment(node);\n\n    if (jsdocComment && thisTagPattern.test(jsdocComment.value)) {\n        return true;\n    }\n\n    // Checks `@this` in its leading comments for callbacks,\n    // because callbacks don't have its JSDoc comment.\n    // e.g.\n    //     sinon.test(/* @this sinon.Sandbox */function() { this.spy(); });\n    return sourceCode.getCommentsBefore(node).some(comment => thisTagPattern.test(comment.value));\n}\n\n/**\n * Determines if a node is surrounded by parentheses.\n * @param {SourceCode} sourceCode The ESLint source code object\n * @param {ASTNode} node The node to be checked.\n * @returns {boolean} True if the node is parenthesised.\n * @private\n */\nfunction isParenthesised(sourceCode, node) {\n    const previousToken = sourceCode.getTokenBefore(node),\n        nextToken = sourceCode.getTokenAfter(node);\n\n    return Boolean(previousToken && nextToken) &&\n        previousToken.value === \"(\" && previousToken.range[1] <= node.range[0] &&\n        nextToken.value === \")\" && nextToken.range[0] >= node.range[1];\n}\n\n/**\n * Checks if the given token is an arrow token or not.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the token is an arrow token.\n */\nfunction isArrowToken(token) {\n    return token.value === \"=>\" && token.type === \"Punctuator\";\n}\n\n/**\n * Checks if the given token is a comma token or not.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the token is a comma token.\n */\nfunction isCommaToken(token) {\n    return token.value === \",\" && token.type === \"Punctuator\";\n}\n\n/**\n * Checks if the given token is a dot token or not.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the token is a dot token.\n */\nfunction isDotToken(token) {\n    return token.value === \".\" && token.type === \"Punctuator\";\n}\n\n/**\n * Checks if the given token is a semicolon token or not.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the token is a semicolon token.\n */\nfunction isSemicolonToken(token) {\n    return token.value === \";\" && token.type === \"Punctuator\";\n}\n\n/**\n * Checks if the given token is a colon token or not.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the token is a colon token.\n */\nfunction isColonToken(token) {\n    return token.value === \":\" && token.type === \"Punctuator\";\n}\n\n/**\n * Checks if the given token is an opening parenthesis token or not.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the token is an opening parenthesis token.\n */\nfunction isOpeningParenToken(token) {\n    return token.value === \"(\" && token.type === \"Punctuator\";\n}\n\n/**\n * Checks if the given token is a closing parenthesis token or not.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the token is a closing parenthesis token.\n */\nfunction isClosingParenToken(token) {\n    return token.value === \")\" && token.type === \"Punctuator\";\n}\n\n/**\n * Checks if the given token is an opening square bracket token or not.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the token is an opening square bracket token.\n */\nfunction isOpeningBracketToken(token) {\n    return token.value === \"[\" && token.type === \"Punctuator\";\n}\n\n/**\n * Checks if the given token is a closing square bracket token or not.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the token is a closing square bracket token.\n */\nfunction isClosingBracketToken(token) {\n    return token.value === \"]\" && token.type === \"Punctuator\";\n}\n\n/**\n * Checks if the given token is an opening brace token or not.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the token is an opening brace token.\n */\nfunction isOpeningBraceToken(token) {\n    return token.value === \"{\" && token.type === \"Punctuator\";\n}\n\n/**\n * Checks if the given token is a closing brace token or not.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the token is a closing brace token.\n */\nfunction isClosingBraceToken(token) {\n    return token.value === \"}\" && token.type === \"Punctuator\";\n}\n\n/**\n * Checks if the given token is a comment token or not.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the token is a comment token.\n */\nfunction isCommentToken(token) {\n    return token.type === \"Line\" || token.type === \"Block\" || token.type === \"Shebang\";\n}\n\n/**\n * Checks if the given token is a keyword token or not.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the token is a keyword token.\n */\nfunction isKeywordToken(token) {\n    return token.type === \"Keyword\";\n}\n\n/**\n * Gets the `(` token of the given function node.\n * @param {ASTNode} node The function node to get.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {Token} `(` token.\n */\nfunction getOpeningParenOfParams(node, sourceCode) {\n    return node.id\n        ? sourceCode.getTokenAfter(node.id, isOpeningParenToken)\n        : sourceCode.getFirstToken(node, isOpeningParenToken);\n}\n\n/**\n * Checks whether or not the tokens of two given nodes are same.\n * @param {ASTNode} left A node 1 to compare.\n * @param {ASTNode} right A node 2 to compare.\n * @param {SourceCode} sourceCode The ESLint source code object.\n * @returns {boolean} the source code for the given node.\n */\nfunction equalTokens(left, right, sourceCode) {\n    const tokensL = sourceCode.getTokens(left);\n    const tokensR = sourceCode.getTokens(right);\n\n    if (tokensL.length !== tokensR.length) {\n        return false;\n    }\n    for (let i = 0; i < tokensL.length; ++i) {\n        if (tokensL[i].type !== tokensR[i].type ||\n            tokensL[i].value !== tokensR[i].value\n        ) {\n            return false;\n        }\n    }\n\n    return true;\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nmodule.exports = {\n    COMMENTS_IGNORE_PATTERN,\n    LINEBREAKS,\n    LINEBREAK_MATCHER: lineBreakPattern,\n    SHEBANG_MATCHER: shebangPattern,\n    STATEMENT_LIST_PARENTS,\n\n    /**\n     * Determines whether two adjacent tokens are on the same line.\n     * @param {Object} left The left token object.\n     * @param {Object} right The right token object.\n     * @returns {boolean} Whether or not the tokens are on the same line.\n     * @public\n     */\n    isTokenOnSameLine(left, right) {\n        return left.loc.end.line === right.loc.start.line;\n    },\n\n    isNullOrUndefined,\n    isCallee,\n    isES5Constructor,\n    getUpperFunction,\n    isFunction,\n    isLoop,\n    isInLoop,\n    isArrayFromMethod,\n    isParenthesised,\n    createGlobalLinebreakMatcher,\n    equalTokens,\n\n    isArrowToken,\n    isClosingBraceToken,\n    isClosingBracketToken,\n    isClosingParenToken,\n    isColonToken,\n    isCommaToken,\n    isCommentToken,\n    isDotToken,\n    isKeywordToken,\n    isNotClosingBraceToken: negate(isClosingBraceToken),\n    isNotClosingBracketToken: negate(isClosingBracketToken),\n    isNotClosingParenToken: negate(isClosingParenToken),\n    isNotColonToken: negate(isColonToken),\n    isNotCommaToken: negate(isCommaToken),\n    isNotDotToken: negate(isDotToken),\n    isNotOpeningBraceToken: negate(isOpeningBraceToken),\n    isNotOpeningBracketToken: negate(isOpeningBracketToken),\n    isNotOpeningParenToken: negate(isOpeningParenToken),\n    isNotSemicolonToken: negate(isSemicolonToken),\n    isOpeningBraceToken,\n    isOpeningBracketToken,\n    isOpeningParenToken,\n    isSemicolonToken,\n\n    /**\n     * Checks whether or not a given node is a string literal.\n     * @param {ASTNode} node A node to check.\n     * @returns {boolean} `true` if the node is a string literal.\n     */\n    isStringLiteral(node) {\n        return (\n            (node.type === \"Literal\" && typeof node.value === \"string\") ||\n            node.type === \"TemplateLiteral\"\n        );\n    },\n\n    /**\n     * Checks whether a given node is a breakable statement or not.\n     * The node is breakable if the node is one of the following type:\n     *\n     * - DoWhileStatement\n     * - ForInStatement\n     * - ForOfStatement\n     * - ForStatement\n     * - SwitchStatement\n     * - WhileStatement\n     * @param {ASTNode} node A node to check.\n     * @returns {boolean} `true` if the node is breakable.\n     */\n    isBreakableStatement(node) {\n        return breakableTypePattern.test(node.type);\n    },\n\n    /**\n     * Gets references which are non initializer and writable.\n     * @param {Reference[]} references An array of references.\n     * @returns {Reference[]} An array of only references which are non initializer and writable.\n     * @public\n     */\n    getModifyingReferences(references) {\n        return references.filter(isModifyingReference);\n    },\n\n    /**\n     * Validate that a string passed in is surrounded by the specified character\n     * @param  {string} val The text to check.\n     * @param  {string} character The character to see if it's surrounded by.\n     * @returns {boolean} True if the text is surrounded by the character, false if not.\n     * @private\n     */\n    isSurroundedBy(val, character) {\n        return val[0] === character && val[val.length - 1] === character;\n    },\n\n    /**\n     * Returns whether the provided node is an ESLint directive comment or not\n     * @param {Line|Block} node The comment token to be checked\n     * @returns {boolean} `true` if the node is an ESLint directive comment\n     */\n    isDirectiveComment(node) {\n        const comment = node.value.trim();\n\n        return (\n            node.type === \"Line\" && comment.indexOf(\"eslint-\") === 0 ||\n            node.type === \"Block\" && (\n                comment.indexOf(\"global \") === 0 ||\n                comment.indexOf(\"eslint \") === 0 ||\n                comment.indexOf(\"eslint-\") === 0\n            )\n        );\n    },\n\n    /**\n     * Gets the trailing statement of a given node.\n     *\n     *     if (code)\n     *         consequent;\n     *\n     * When taking this `IfStatement`, returns `consequent;` statement.\n     * @param {ASTNode} A node to get.\n     * @returns {ASTNode|null} The trailing statement's node.\n     */\n    getTrailingStatement: utils.ast.trailingStatement,\n\n    /**\n     * Finds the variable by a given name in a given scope and its upper scopes.\n     * @param {eslint-scope.Scope} initScope A scope to start find.\n     * @param {string} name A variable name to find.\n     * @returns {eslint-scope.Variable|null} A found variable or `null`.\n     */\n    getVariableByName(initScope, name) {\n        let scope = initScope;\n\n        while (scope) {\n            const variable = scope.set.get(name);\n\n            if (variable) {\n                return variable;\n            }\n\n            scope = scope.upper;\n        }\n\n        return null;\n    },\n\n    /**\n     * Checks whether or not a given function node is the default `this` binding.\n     *\n     * First, this checks the node:\n     *\n     * - The function name does not start with uppercase. It's a convention to capitalize the names\n     *   of constructor functions. This check is not performed if `capIsConstructor` is set to `false`.\n     * - The function does not have a JSDoc comment that has a @this tag.\n     *\n     * Next, this checks the location of the node.\n     * If the location is below, this judges `this` is valid.\n     *\n     * - The location is not on an object literal.\n     * - The location is not assigned to a variable which starts with an uppercase letter. Applies to anonymous\n     *   functions only, as the name of the variable is considered to be the name of the function in this case.\n     *   This check is not performed if `capIsConstructor` is set to `false`.\n     * - The location is not on an ES2015 class.\n     * - Its `bind`/`call`/`apply` method is not called directly.\n     * - The function is not a callback of array methods (such as `.forEach()`) if `thisArg` is given.\n     * @param {ASTNode} node A function node to check.\n     * @param {SourceCode} sourceCode A SourceCode instance to get comments.\n     * @param {boolean} [capIsConstructor = true] `false` disables the assumption that functions which name starts\n     * with an uppercase or are assigned to a variable which name starts with an uppercase are constructors.\n     * @returns {boolean} The function node is the default `this` binding.\n     */\n    isDefaultThisBinding(node, sourceCode, { capIsConstructor = true } = {}) {\n        if (\n            (capIsConstructor && isES5Constructor(node)) ||\n            hasJSDocThisTag(node, sourceCode)\n        ) {\n            return false;\n        }\n        const isAnonymous = node.id === null;\n        let currentNode = node;\n\n        while (currentNode) {\n            const parent = currentNode.parent;\n\n            switch (parent.type) {\n\n                /*\n                 * Looks up the destination.\n                 * e.g., obj.foo = nativeFoo || function foo() { ... };\n                 */\n                case \"LogicalExpression\":\n                case \"ConditionalExpression\":\n                    currentNode = parent;\n                    break;\n\n                /*\n                 * If the upper function is IIFE, checks the destination of the return value.\n                 * e.g.\n                 *   obj.foo = (function() {\n                 *     // setup...\n                 *     return function foo() { ... };\n                 *   })();\n                 *   obj.foo = (() =>\n                 *     function foo() { ... }\n                 *   )();\n                 */\n                case \"ReturnStatement\": {\n                    const func = getUpperFunction(parent);\n\n                    if (func === null || !isCallee(func)) {\n                        return true;\n                    }\n                    currentNode = func.parent;\n                    break;\n                }\n                case \"ArrowFunctionExpression\":\n                    if (currentNode !== parent.body || !isCallee(parent)) {\n                        return true;\n                    }\n                    currentNode = parent.parent;\n                    break;\n\n                /*\n                 * e.g.\n                 *   var obj = { foo() { ... } };\n                 *   var obj = { foo: function() { ... } };\n                 *   class A { constructor() { ... } }\n                 *   class A { foo() { ... } }\n                 *   class A { get foo() { ... } }\n                 *   class A { set foo() { ... } }\n                 *   class A { static foo() { ... } }\n                 */\n                case \"Property\":\n                case \"MethodDefinition\":\n                    return parent.value !== currentNode;\n\n                /*\n                 * e.g.\n                 *   obj.foo = function foo() { ... };\n                 *   Foo = function() { ... };\n                 *   [obj.foo = function foo() { ... }] = a;\n                 *   [Foo = function() { ... }] = a;\n                 */\n                case \"AssignmentExpression\":\n                case \"AssignmentPattern\":\n                    if (parent.left.type === \"MemberExpression\") {\n                        return false;\n                    }\n                    if (\n                        capIsConstructor &&\n                        isAnonymous &&\n                        parent.left.type === \"Identifier\" &&\n                        startsWithUpperCase(parent.left.name)\n                    ) {\n                        return false;\n                    }\n                    return true;\n\n                /*\n                 * e.g.\n                 *   var Foo = function() { ... };\n                 */\n                case \"VariableDeclarator\":\n                    return !(\n                        capIsConstructor &&\n                        isAnonymous &&\n                        parent.init === currentNode &&\n                        parent.id.type === \"Identifier\" &&\n                        startsWithUpperCase(parent.id.name)\n                    );\n\n                /*\n                 * e.g.\n                 *   var foo = function foo() { ... }.bind(obj);\n                 *   (function foo() { ... }).call(obj);\n                 *   (function foo() { ... }).apply(obj, []);\n                 */\n                case \"MemberExpression\":\n                    return (\n                        parent.object !== currentNode ||\n                        parent.property.type !== \"Identifier\" ||\n                        !bindOrCallOrApplyPattern.test(parent.property.name) ||\n                        !isCallee(parent) ||\n                        parent.parent.arguments.length === 0 ||\n                        isNullOrUndefined(parent.parent.arguments[0])\n                    );\n\n                /*\n                 * e.g.\n                 *   Reflect.apply(function() {}, obj, []);\n                 *   Array.from([], function() {}, obj);\n                 *   list.forEach(function() {}, obj);\n                 */\n                case \"CallExpression\":\n                    if (isReflectApply(parent.callee)) {\n                        return (\n                            parent.arguments.length !== 3 ||\n                            parent.arguments[0] !== currentNode ||\n                            isNullOrUndefined(parent.arguments[1])\n                        );\n                    }\n                    if (isArrayFromMethod(parent.callee)) {\n                        return (\n                            parent.arguments.length !== 3 ||\n                            parent.arguments[1] !== currentNode ||\n                            isNullOrUndefined(parent.arguments[2])\n                        );\n                    }\n                    if (isMethodWhichHasThisArg(parent.callee)) {\n                        return (\n                            parent.arguments.length !== 2 ||\n                            parent.arguments[0] !== currentNode ||\n                            isNullOrUndefined(parent.arguments[1])\n                        );\n                    }\n                    return true;\n\n                // Otherwise `this` is default.\n                default:\n                    return true;\n            }\n        }\n\n        /* istanbul ignore next */\n        return true;\n    },\n\n    /**\n     * Get the precedence level based on the node type\n     * @param {ASTNode} node node to evaluate\n     * @returns {int} precedence level\n     * @private\n     */\n    getPrecedence(node) {\n        switch (node.type) {\n            case \"SequenceExpression\":\n                return 0;\n\n            case \"AssignmentExpression\":\n            case \"ArrowFunctionExpression\":\n            case \"YieldExpression\":\n                return 1;\n\n            case \"ConditionalExpression\":\n                return 3;\n\n            case \"LogicalExpression\":\n                switch (node.operator) {\n                    case \"||\":\n                        return 4;\n                    case \"&&\":\n                        return 5;\n\n                    // no default\n                }\n\n                /* falls through */\n\n            case \"BinaryExpression\":\n\n                switch (node.operator) {\n                    case \"|\":\n                        return 6;\n                    case \"^\":\n                        return 7;\n                    case \"&\":\n                        return 8;\n                    case \"==\":\n                    case \"!=\":\n                    case \"===\":\n                    case \"!==\":\n                        return 9;\n                    case \"<\":\n                    case \"<=\":\n                    case \">\":\n                    case \">=\":\n                    case \"in\":\n                    case \"instanceof\":\n                        return 10;\n                    case \"<<\":\n                    case \">>\":\n                    case \">>>\":\n                        return 11;\n                    case \"+\":\n                    case \"-\":\n                        return 12;\n                    case \"*\":\n                    case \"/\":\n                    case \"%\":\n                        return 13;\n                    case \"**\":\n                        return 15;\n\n                    // no default\n                }\n\n                /* falls through */\n\n            case \"UnaryExpression\":\n            case \"AwaitExpression\":\n                return 16;\n\n            case \"UpdateExpression\":\n                return 17;\n\n            case \"CallExpression\":\n            case \"ImportExpression\":\n                return 18;\n\n            case \"NewExpression\":\n                return 19;\n\n            default:\n                return 20;\n        }\n    },\n\n    /**\n     * Checks whether the given node is an empty block node or not.\n     * @param {ASTNode|null} node The node to check.\n     * @returns {boolean} `true` if the node is an empty block.\n     */\n    isEmptyBlock(node) {\n        return Boolean(node && node.type === \"BlockStatement\" && node.body.length === 0);\n    },\n\n    /**\n     * Checks whether the given node is an empty function node or not.\n     * @param {ASTNode|null} node The node to check.\n     * @returns {boolean} `true` if the node is an empty function.\n     */\n    isEmptyFunction(node) {\n        return isFunction(node) && module.exports.isEmptyBlock(node.body);\n    },\n\n    /**\n     * Gets the property name of a given node.\n     * The node can be a MemberExpression, a Property, or a MethodDefinition.\n     *\n     * If the name is dynamic, this returns `null`.\n     *\n     * For examples:\n     *\n     *     a.b           // => \"b\"\n     *     a[\"b\"]        // => \"b\"\n     *     a['b']        // => \"b\"\n     *     a[`b`]        // => \"b\"\n     *     a[100]        // => \"100\"\n     *     a[b]          // => null\n     *     a[\"a\" + \"b\"]  // => null\n     *     a[tag`b`]     // => null\n     *     a[`${b}`]     // => null\n     *\n     *     let a = {b: 1}            // => \"b\"\n     *     let a = {[\"b\"]: 1}        // => \"b\"\n     *     let a = {['b']: 1}        // => \"b\"\n     *     let a = {[`b`]: 1}        // => \"b\"\n     *     let a = {[100]: 1}        // => \"100\"\n     *     let a = {[b]: 1}          // => null\n     *     let a = {[\"a\" + \"b\"]: 1}  // => null\n     *     let a = {[tag`b`]: 1}     // => null\n     *     let a = {[`${b}`]: 1}     // => null\n     * @param {ASTNode} node The node to get.\n     * @returns {string|null} The property name if static. Otherwise, null.\n     */\n    getStaticPropertyName(node) {\n        let prop;\n\n        switch (node && node.type) {\n            case \"Property\":\n            case \"MethodDefinition\":\n                prop = node.key;\n                break;\n\n            case \"MemberExpression\":\n                prop = node.property;\n                break;\n\n            // no default\n        }\n\n        switch (prop && prop.type) {\n            case \"Literal\":\n                return String(prop.value);\n\n            case \"TemplateLiteral\":\n                if (prop.expressions.length === 0 && prop.quasis.length === 1) {\n                    return prop.quasis[0].value.cooked;\n                }\n                break;\n\n            case \"Identifier\":\n                if (!node.computed) {\n                    return prop.name;\n                }\n                break;\n\n            // no default\n        }\n\n        return null;\n    },\n\n    /**\n     * Get directives from directive prologue of a Program or Function node.\n     * @param {ASTNode} node The node to check.\n     * @returns {ASTNode[]} The directives found in the directive prologue.\n     */\n    getDirectivePrologue(node) {\n        const directives = [];\n\n        // Directive prologues only occur at the top of files or functions.\n        if (\n            node.type === \"Program\" ||\n            node.type === \"FunctionDeclaration\" ||\n            node.type === \"FunctionExpression\" ||\n\n            /*\n             * Do not check arrow functions with implicit return.\n             * `() => \"use strict\";` returns the string `\"use strict\"`.\n             */\n            (node.type === \"ArrowFunctionExpression\" && node.body.type === \"BlockStatement\")\n        ) {\n            const statements = node.type === \"Program\" ? node.body : node.body.body;\n\n            for (const statement of statements) {\n                if (\n                    statement.type === \"ExpressionStatement\" &&\n                    statement.expression.type === \"Literal\"\n                ) {\n                    directives.push(statement);\n                } else {\n                    break;\n                }\n            }\n        }\n\n        return directives;\n    },\n\n\n    /**\n     * Determines whether this node is a decimal integer literal. If a node is a decimal integer literal, a dot added\n     * after the node will be parsed as a decimal point, rather than a property-access dot.\n     * @param {ASTNode} node The node to check.\n     * @returns {boolean} `true` if this node is a decimal integer.\n     * @example\n     *\n     * 5       // true\n     * 5.      // false\n     * 5.0     // false\n     * 05      // false\n     * 0x5     // false\n     * 0b101   // false\n     * 0o5     // false\n     * 5e0     // false\n     * '5'     // false\n     */\n    isDecimalInteger(node) {\n        return node.type === \"Literal\" && typeof node.value === \"number\" &&\n            DECIMAL_INTEGER_PATTERN.test(node.raw);\n    },\n\n    /**\n     * Determines whether this token is a decimal integer numeric token.\n     * This is similar to isDecimalInteger(), but for tokens.\n     * @param {Token} token The token to check.\n     * @returns {boolean} `true` if this token is a decimal integer.\n     */\n    isDecimalIntegerNumericToken(token) {\n        return token.type === \"Numeric\" && DECIMAL_INTEGER_PATTERN.test(token.value);\n    },\n\n    /**\n     * Gets the name and kind of the given function node.\n     *\n     * - `function foo() {}`  .................... `function 'foo'`\n     * - `(function foo() {})`  .................. `function 'foo'`\n     * - `(function() {})`  ...................... `function`\n     * - `function* foo() {}`  ................... `generator function 'foo'`\n     * - `(function* foo() {})`  ................. `generator function 'foo'`\n     * - `(function*() {})`  ..................... `generator function`\n     * - `() => {}`  ............................. `arrow function`\n     * - `async () => {}`  ....................... `async arrow function`\n     * - `({ foo: function foo() {} })`  ......... `method 'foo'`\n     * - `({ foo: function() {} })`  ............. `method 'foo'`\n     * - `({ ['foo']: function() {} })`  ......... `method 'foo'`\n     * - `({ [foo]: function() {} })`  ........... `method`\n     * - `({ foo() {} })`  ....................... `method 'foo'`\n     * - `({ foo: function* foo() {} })`  ........ `generator method 'foo'`\n     * - `({ foo: function*() {} })`  ............ `generator method 'foo'`\n     * - `({ ['foo']: function*() {} })`  ........ `generator method 'foo'`\n     * - `({ [foo]: function*() {} })`  .......... `generator method`\n     * - `({ *foo() {} })`  ...................... `generator method 'foo'`\n     * - `({ foo: async function foo() {} })`  ... `async method 'foo'`\n     * - `({ foo: async function() {} })`  ....... `async method 'foo'`\n     * - `({ ['foo']: async function() {} })`  ... `async method 'foo'`\n     * - `({ [foo]: async function() {} })`  ..... `async method`\n     * - `({ async foo() {} })`  ................. `async method 'foo'`\n     * - `({ get foo() {} })`  ................... `getter 'foo'`\n     * - `({ set foo(a) {} })`  .................. `setter 'foo'`\n     * - `class A { constructor() {} }`  ......... `constructor`\n     * - `class A { foo() {} }`  ................. `method 'foo'`\n     * - `class A { *foo() {} }`  ................ `generator method 'foo'`\n     * - `class A { async foo() {} }`  ........... `async method 'foo'`\n     * - `class A { ['foo']() {} }`  ............. `method 'foo'`\n     * - `class A { *['foo']() {} }`  ............ `generator method 'foo'`\n     * - `class A { async ['foo']() {} }`  ....... `async method 'foo'`\n     * - `class A { [foo]() {} }`  ............... `method`\n     * - `class A { *[foo]() {} }`  .............. `generator method`\n     * - `class A { async [foo]() {} }`  ......... `async method`\n     * - `class A { get foo() {} }`  ............. `getter 'foo'`\n     * - `class A { set foo(a) {} }`  ............ `setter 'foo'`\n     * - `class A { static foo() {} }`  .......... `static method 'foo'`\n     * - `class A { static *foo() {} }`  ......... `static generator method 'foo'`\n     * - `class A { static async foo() {} }`  .... `static async method 'foo'`\n     * - `class A { static get foo() {} }`  ...... `static getter 'foo'`\n     * - `class A { static set foo(a) {} }`  ..... `static setter 'foo'`\n     * @param {ASTNode} node The function node to get.\n     * @returns {string} The name and kind of the function node.\n     */\n    getFunctionNameWithKind(node) {\n        const parent = node.parent;\n        const tokens = [];\n\n        if (parent.type === \"MethodDefinition\" && parent.static) {\n            tokens.push(\"static\");\n        }\n        if (node.async) {\n            tokens.push(\"async\");\n        }\n        if (node.generator) {\n            tokens.push(\"generator\");\n        }\n\n        if (node.type === \"ArrowFunctionExpression\") {\n            tokens.push(\"arrow\", \"function\");\n        } else if (parent.type === \"Property\" || parent.type === \"MethodDefinition\") {\n            if (parent.kind === \"constructor\") {\n                return \"constructor\";\n            }\n            if (parent.kind === \"get\") {\n                tokens.push(\"getter\");\n            } else if (parent.kind === \"set\") {\n                tokens.push(\"setter\");\n            } else {\n                tokens.push(\"method\");\n            }\n        } else {\n            tokens.push(\"function\");\n        }\n\n        if (node.id) {\n            tokens.push(`'${node.id.name}'`);\n        } else {\n            const name = module.exports.getStaticPropertyName(parent);\n\n            if (name !== null) {\n                tokens.push(`'${name}'`);\n            }\n        }\n\n        return tokens.join(\" \");\n    },\n\n    /**\n     * Gets the location of the given function node for reporting.\n     *\n     * - `function foo() {}`\n     *    ^^^^^^^^^^^^\n     * - `(function foo() {})`\n     *     ^^^^^^^^^^^^\n     * - `(function() {})`\n     *     ^^^^^^^^\n     * - `function* foo() {}`\n     *    ^^^^^^^^^^^^^\n     * - `(function* foo() {})`\n     *     ^^^^^^^^^^^^^\n     * - `(function*() {})`\n     *     ^^^^^^^^^\n     * - `() => {}`\n     *       ^^\n     * - `async () => {}`\n     *             ^^\n     * - `({ foo: function foo() {} })`\n     *       ^^^^^^^^^^^^^^^^^\n     * - `({ foo: function() {} })`\n     *       ^^^^^^^^^^^^^\n     * - `({ ['foo']: function() {} })`\n     *       ^^^^^^^^^^^^^^^^^\n     * - `({ [foo]: function() {} })`\n     *       ^^^^^^^^^^^^^^^\n     * - `({ foo() {} })`\n     *       ^^^\n     * - `({ foo: function* foo() {} })`\n     *       ^^^^^^^^^^^^^^^^^^\n     * - `({ foo: function*() {} })`\n     *       ^^^^^^^^^^^^^^\n     * - `({ ['foo']: function*() {} })`\n     *       ^^^^^^^^^^^^^^^^^^\n     * - `({ [foo]: function*() {} })`\n     *       ^^^^^^^^^^^^^^^^\n     * - `({ *foo() {} })`\n     *       ^^^^\n     * - `({ foo: async function foo() {} })`\n     *       ^^^^^^^^^^^^^^^^^^^^^^^\n     * - `({ foo: async function() {} })`\n     *       ^^^^^^^^^^^^^^^^^^^\n     * - `({ ['foo']: async function() {} })`\n     *       ^^^^^^^^^^^^^^^^^^^^^^^\n     * - `({ [foo]: async function() {} })`\n     *       ^^^^^^^^^^^^^^^^^^^^^\n     * - `({ async foo() {} })`\n     *       ^^^^^^^^^\n     * - `({ get foo() {} })`\n     *       ^^^^^^^\n     * - `({ set foo(a) {} })`\n     *       ^^^^^^^\n     * - `class A { constructor() {} }`\n     *              ^^^^^^^^^^^\n     * - `class A { foo() {} }`\n     *              ^^^\n     * - `class A { *foo() {} }`\n     *              ^^^^\n     * - `class A { async foo() {} }`\n     *              ^^^^^^^^^\n     * - `class A { ['foo']() {} }`\n     *              ^^^^^^^\n     * - `class A { *['foo']() {} }`\n     *              ^^^^^^^^\n     * - `class A { async ['foo']() {} }`\n     *              ^^^^^^^^^^^^^\n     * - `class A { [foo]() {} }`\n     *              ^^^^^\n     * - `class A { *[foo]() {} }`\n     *              ^^^^^^\n     * - `class A { async [foo]() {} }`\n     *              ^^^^^^^^^^^\n     * - `class A { get foo() {} }`\n     *              ^^^^^^^\n     * - `class A { set foo(a) {} }`\n     *              ^^^^^^^\n     * - `class A { static foo() {} }`\n     *              ^^^^^^^^^^\n     * - `class A { static *foo() {} }`\n     *              ^^^^^^^^^^^\n     * - `class A { static async foo() {} }`\n     *              ^^^^^^^^^^^^^^^^\n     * - `class A { static get foo() {} }`\n     *              ^^^^^^^^^^^^^^\n     * - `class A { static set foo(a) {} }`\n     *              ^^^^^^^^^^^^^^\n     * @param {ASTNode} node The function node to get.\n     * @param {SourceCode} sourceCode The source code object to get tokens.\n     * @returns {string} The location of the function node for reporting.\n     */\n    getFunctionHeadLoc(node, sourceCode) {\n        const parent = node.parent;\n        let start = null;\n        let end = null;\n\n        if (node.type === \"ArrowFunctionExpression\") {\n            const arrowToken = sourceCode.getTokenBefore(node.body, isArrowToken);\n\n            start = arrowToken.loc.start;\n            end = arrowToken.loc.end;\n        } else if (parent.type === \"Property\" || parent.type === \"MethodDefinition\") {\n            start = parent.loc.start;\n            end = getOpeningParenOfParams(node, sourceCode).loc.start;\n        } else {\n            start = node.loc.start;\n            end = getOpeningParenOfParams(node, sourceCode).loc.start;\n        }\n\n        return {\n            start: Object.assign({}, start),\n            end: Object.assign({}, end)\n        };\n    },\n\n    /**\n     * Gets next location when the result is not out of bound, otherwise returns null.\n     * @param {SourceCode} sourceCode The sourceCode\n     * @param {{line: number, column: number}} location The location\n     * @returns {{line: number, column: number} | null} Next location\n     */\n    getNextLocation(sourceCode, location) {\n        const index = sourceCode.getIndexFromLoc(location);\n\n        // Avoid out of bound location\n        if (index + 1 > sourceCode.text.length) {\n            return null;\n        }\n\n        return sourceCode.getLocFromIndex(index + 1);\n    },\n\n    /**\n     * Gets the parenthesized text of a node. This is similar to sourceCode.getText(node), but it also includes any parentheses\n     * surrounding the node.\n     * @param {SourceCode} sourceCode The source code object\n     * @param {ASTNode} node An expression node\n     * @returns {string} The text representing the node, with all surrounding parentheses included\n     */\n    getParenthesisedText(sourceCode, node) {\n        let leftToken = sourceCode.getFirstToken(node);\n        let rightToken = sourceCode.getLastToken(node);\n\n        while (\n            sourceCode.getTokenBefore(leftToken) &&\n            sourceCode.getTokenBefore(leftToken).type === \"Punctuator\" &&\n            sourceCode.getTokenBefore(leftToken).value === \"(\" &&\n            sourceCode.getTokenAfter(rightToken) &&\n            sourceCode.getTokenAfter(rightToken).type === \"Punctuator\" &&\n            sourceCode.getTokenAfter(rightToken).value === \")\"\n        ) {\n            leftToken = sourceCode.getTokenBefore(leftToken);\n            rightToken = sourceCode.getTokenAfter(rightToken);\n        }\n\n        return sourceCode.getText().slice(leftToken.range[0], rightToken.range[1]);\n    },\n\n    /*\n     * Determine if a node has a possiblity to be an Error object\n     * @param  {ASTNode} node  ASTNode to check\n     * @returns {boolean} True if there is a chance it contains an Error obj\n     */\n    couldBeError(node) {\n        switch (node.type) {\n            case \"Identifier\":\n            case \"CallExpression\":\n            case \"NewExpression\":\n            case \"MemberExpression\":\n            case \"TaggedTemplateExpression\":\n            case \"YieldExpression\":\n            case \"AwaitExpression\":\n                return true; // possibly an error object.\n\n            case \"AssignmentExpression\":\n                return module.exports.couldBeError(node.right);\n\n            case \"SequenceExpression\": {\n                const exprs = node.expressions;\n\n                return exprs.length !== 0 && module.exports.couldBeError(exprs[exprs.length - 1]);\n            }\n\n            case \"LogicalExpression\":\n                return module.exports.couldBeError(node.left) || module.exports.couldBeError(node.right);\n\n            case \"ConditionalExpression\":\n                return module.exports.couldBeError(node.consequent) || module.exports.couldBeError(node.alternate);\n\n            default:\n                return false;\n        }\n    },\n\n    /**\n     * Determines whether the given node is a `null` literal.\n     * @param {ASTNode} node The node to check\n     * @returns {boolean} `true` if the node is a `null` literal\n     */\n    isNullLiteral(node) {\n\n        /*\n         * Checking `node.value === null` does not guarantee that a literal is a null literal.\n         * When parsing values that cannot be represented in the current environment (e.g. unicode\n         * regexes in Node 4), `node.value` is set to `null` because it wouldn't be possible to\n         * set `node.value` to a unicode regex. To make sure a literal is actually `null`, check\n         * `node.regex` instead. Also see: https://github.com/eslint/eslint/issues/8020\n         */\n        return node.type === \"Literal\" && node.value === null && !node.regex && !node.bigint;\n    },\n\n    /**\n     * Determines whether two tokens can safely be placed next to each other without merging into a single token\n     * @param {Token|string} leftValue The left token. If this is a string, it will be tokenized and the last token will be used.\n     * @param {Token|string} rightValue The right token. If this is a string, it will be tokenized and the first token will be used.\n     * @returns {boolean} If the tokens cannot be safely placed next to each other, returns `false`. If the tokens can be placed\n     * next to each other, behavior is undefined (although it should return `true` in most cases).\n     */\n    canTokensBeAdjacent(leftValue, rightValue) {\n        let leftToken;\n\n        if (typeof leftValue === \"string\") {\n            const leftTokens = espree_1.tokenize(leftValue, { ecmaVersion: 2015 });\n\n            leftToken = leftTokens[leftTokens.length - 1];\n        } else {\n            leftToken = leftValue;\n        }\n\n        const rightToken = typeof rightValue === \"string\" ? espree_1.tokenize(rightValue, { ecmaVersion: 2015 })[0] : rightValue;\n\n        if (leftToken.type === \"Punctuator\" || rightToken.type === \"Punctuator\") {\n            if (leftToken.type === \"Punctuator\" && rightToken.type === \"Punctuator\") {\n                const PLUS_TOKENS = new Set([\"+\", \"++\"]);\n                const MINUS_TOKENS = new Set([\"-\", \"--\"]);\n\n                return !(\n                    PLUS_TOKENS.has(leftToken.value) && PLUS_TOKENS.has(rightToken.value) ||\n                    MINUS_TOKENS.has(leftToken.value) && MINUS_TOKENS.has(rightToken.value)\n                );\n            }\n            return true;\n        }\n\n        if (\n            leftToken.type === \"String\" || rightToken.type === \"String\" ||\n            leftToken.type === \"Template\" || rightToken.type === \"Template\"\n        ) {\n            return true;\n        }\n\n        if (leftToken.type !== \"Numeric\" && rightToken.type === \"Numeric\" && rightToken.value.startsWith(\".\")) {\n            return true;\n        }\n\n        return false;\n    },\n\n    /**\n     * Get the `loc` object of a given name in a `/*globals` directive comment.\n     * @param {SourceCode} sourceCode The source code to convert index to loc.\n     * @param {Comment} comment The `/*globals` directive comment which include the name.\n     * @param {string} name The name to find.\n     * @returns {SourceLocation} The `loc` object.\n     */\n    getNameLocationInGlobalDirectiveComment(sourceCode, comment, name) {\n        const namePattern = new RegExp(`[\\\\s,]${lodash.escapeRegExp(name)}(?:$|[\\\\s,:])`, \"gu\");\n\n        // To ignore the first text \"global\".\n        namePattern.lastIndex = comment.value.indexOf(\"global\") + 6;\n\n        // Search a given variable name.\n        const match = namePattern.exec(comment.value);\n\n        // Convert the index to loc.\n        return sourceCode.getLocFromIndex(\n            comment.range[0] +\n            \"/*\".length +\n            (match ? match.index + 1 : 0)\n        );\n    },\n\n    /**\n     * Determines whether the given raw string contains an octal escape sequence.\n     *\n     * \"\\1\", \"\\2\" ... \"\\7\"\n     * \"\\00\", \"\\01\" ... \"\\09\"\n     *\n     * \"\\0\", when not followed by a digit, is not an octal escape sequence.\n     * @param {string} rawString A string in its raw representation.\n     * @returns {boolean} `true` if the string contains at least one octal escape sequence.\n     */\n    hasOctalEscapeSequence(rawString) {\n        return OCTAL_ESCAPE_PATTERN.test(rawString);\n    }\n};\n});\nvar astUtils_1 = astUtils$1.COMMENTS_IGNORE_PATTERN;\nvar astUtils_2 = astUtils$1.LINEBREAKS;\nvar astUtils_3 = astUtils$1.LINEBREAK_MATCHER;\nvar astUtils_4 = astUtils$1.SHEBANG_MATCHER;\nvar astUtils_5 = astUtils$1.STATEMENT_LIST_PARENTS;\nvar astUtils_6 = astUtils$1.isTokenOnSameLine;\nvar astUtils_7 = astUtils$1.isNullOrUndefined;\nvar astUtils_8 = astUtils$1.isCallee;\nvar astUtils_9 = astUtils$1.isES5Constructor;\nvar astUtils_10 = astUtils$1.getUpperFunction;\nvar astUtils_11 = astUtils$1.isFunction;\nvar astUtils_12 = astUtils$1.isLoop;\nvar astUtils_13 = astUtils$1.isInLoop;\nvar astUtils_14 = astUtils$1.isArrayFromMethod;\nvar astUtils_15 = astUtils$1.isParenthesised;\nvar astUtils_16 = astUtils$1.createGlobalLinebreakMatcher;\nvar astUtils_17 = astUtils$1.equalTokens;\nvar astUtils_18 = astUtils$1.isArrowToken;\nvar astUtils_19 = astUtils$1.isClosingBraceToken;\nvar astUtils_20 = astUtils$1.isClosingBracketToken;\nvar astUtils_21 = astUtils$1.isClosingParenToken;\nvar astUtils_22 = astUtils$1.isColonToken;\nvar astUtils_23 = astUtils$1.isCommaToken;\nvar astUtils_24 = astUtils$1.isCommentToken;\nvar astUtils_25 = astUtils$1.isDotToken;\nvar astUtils_26 = astUtils$1.isKeywordToken;\nvar astUtils_27 = astUtils$1.isNotClosingBraceToken;\nvar astUtils_28 = astUtils$1.isNotClosingBracketToken;\nvar astUtils_29 = astUtils$1.isNotClosingParenToken;\nvar astUtils_30 = astUtils$1.isNotColonToken;\nvar astUtils_31 = astUtils$1.isNotCommaToken;\nvar astUtils_32 = astUtils$1.isNotDotToken;\nvar astUtils_33 = astUtils$1.isNotOpeningBraceToken;\nvar astUtils_34 = astUtils$1.isNotOpeningBracketToken;\nvar astUtils_35 = astUtils$1.isNotOpeningParenToken;\nvar astUtils_36 = astUtils$1.isNotSemicolonToken;\nvar astUtils_37 = astUtils$1.isOpeningBraceToken;\nvar astUtils_38 = astUtils$1.isOpeningBracketToken;\nvar astUtils_39 = astUtils$1.isOpeningParenToken;\nvar astUtils_40 = astUtils$1.isSemicolonToken;\nvar astUtils_41 = astUtils$1.isStringLiteral;\nvar astUtils_42 = astUtils$1.isBreakableStatement;\nvar astUtils_43 = astUtils$1.getModifyingReferences;\nvar astUtils_44 = astUtils$1.isSurroundedBy;\nvar astUtils_45 = astUtils$1.isDirectiveComment;\nvar astUtils_46 = astUtils$1.getTrailingStatement;\nvar astUtils_47 = astUtils$1.getVariableByName;\nvar astUtils_48 = astUtils$1.isDefaultThisBinding;\nvar astUtils_49 = astUtils$1.getPrecedence;\nvar astUtils_50 = astUtils$1.isEmptyBlock;\nvar astUtils_51 = astUtils$1.isEmptyFunction;\nvar astUtils_52 = astUtils$1.getStaticPropertyName;\nvar astUtils_53 = astUtils$1.getDirectivePrologue;\nvar astUtils_54 = astUtils$1.isDecimalInteger;\nvar astUtils_55 = astUtils$1.isDecimalIntegerNumericToken;\nvar astUtils_56 = astUtils$1.getFunctionNameWithKind;\nvar astUtils_57 = astUtils$1.getFunctionHeadLoc;\nvar astUtils_58 = astUtils$1.getNextLocation;\nvar astUtils_59 = astUtils$1.getParenthesisedText;\nvar astUtils_60 = astUtils$1.couldBeError;\nvar astUtils_61 = astUtils$1.isNullLiteral;\nvar astUtils_62 = astUtils$1.canTokensBeAdjacent;\nvar astUtils_63 = astUtils$1.getNameLocationInGlobalDirectiveComment;\nvar astUtils_64 = astUtils$1.hasOctalEscapeSequence;\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Typedefs\n//------------------------------------------------------------------------------\n\n/**\n * Property name if it can be computed statically, otherwise the list of the tokens of the key node.\n * @typedef {string|Token[]} Key\n */\n\n/**\n * Accessor nodes with the same key.\n * @typedef {Object} AccessorData\n * @property {Key} key Accessor's key\n * @property {ASTNode[]} getters List of getter nodes.\n * @property {ASTNode[]} setters List of setter nodes.\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not the given lists represent the equal tokens in the same order.\n * Tokens are compared by their properties, not by instance.\n * @param {Token[]} left First list of tokens.\n * @param {Token[]} right Second list of tokens.\n * @returns {boolean} `true` if the lists have same tokens.\n */\nfunction areEqualTokenLists(left, right) {\n    if (left.length !== right.length) {\n        return false;\n    }\n\n    for (let i = 0; i < left.length; i++) {\n        const leftToken = left[i],\n            rightToken = right[i];\n\n        if (leftToken.type !== rightToken.type || leftToken.value !== rightToken.value) {\n            return false;\n        }\n    }\n\n    return true;\n}\n\n/**\n * Checks whether or not the given keys are equal.\n * @param {Key} left First key.\n * @param {Key} right Second key.\n * @returns {boolean} `true` if the keys are equal.\n */\nfunction areEqualKeys(left, right) {\n    if (typeof left === \"string\" && typeof right === \"string\") {\n\n        // Statically computed names.\n        return left === right;\n    }\n    if (Array.isArray(left) && Array.isArray(right)) {\n\n        // Token lists.\n        return areEqualTokenLists(left, right);\n    }\n\n    return false;\n}\n\n/**\n * Checks whether or not a given node is of an accessor kind ('get' or 'set').\n * @param {ASTNode} node A node to check.\n * @returns {boolean} `true` if the node is of an accessor kind.\n */\nfunction isAccessorKind(node) {\n    return node.kind === \"get\" || node.kind === \"set\";\n}\n\n/**\n * Checks whether or not a given node is an `Identifier` node which was named a given name.\n * @param {ASTNode} node A node to check.\n * @param {string} name An expected name of the node.\n * @returns {boolean} `true` if the node is an `Identifier` node which was named as expected.\n */\nfunction isIdentifier(node, name) {\n    return node.type === \"Identifier\" && node.name === name;\n}\n\n/**\n * Checks whether or not a given node is an argument of a specified method call.\n * @param {ASTNode} node A node to check.\n * @param {number} index An expected index of the node in arguments.\n * @param {string} object An expected name of the object of the method.\n * @param {string} property An expected name of the method.\n * @returns {boolean} `true` if the node is an argument of the specified method call.\n */\nfunction isArgumentOfMethodCall(node, index, object, property) {\n    const parent = node.parent;\n\n    return (\n        parent.type === \"CallExpression\" &&\n        parent.callee.type === \"MemberExpression\" &&\n        parent.callee.computed === false &&\n        isIdentifier(parent.callee.object, object) &&\n        isIdentifier(parent.callee.property, property) &&\n        parent.arguments[index] === node\n    );\n}\n\n/**\n * Checks whether or not a given node is a property descriptor.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} `true` if the node is a property descriptor.\n */\nfunction isPropertyDescriptor(node) {\n\n    // Object.defineProperty(obj, \"foo\", {set: ...})\n    if (isArgumentOfMethodCall(node, 2, \"Object\", \"defineProperty\") ||\n        isArgumentOfMethodCall(node, 2, \"Reflect\", \"defineProperty\")\n    ) {\n        return true;\n    }\n\n    /*\n     * Object.defineProperties(obj, {foo: {set: ...}})\n     * Object.create(proto, {foo: {set: ...}})\n     */\n    const grandparent = node.parent.parent;\n\n    return grandparent.type === \"ObjectExpression\" && (\n        isArgumentOfMethodCall(grandparent, 1, \"Object\", \"create\") ||\n        isArgumentOfMethodCall(grandparent, 1, \"Object\", \"defineProperties\")\n    );\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar accessorPairs = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce getter and setter pairs in objects and classes\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/accessor-pairs\"\n        },\n\n        schema: [{\n            type: \"object\",\n            properties: {\n                getWithoutSet: {\n                    type: \"boolean\",\n                    default: false\n                },\n                setWithoutGet: {\n                    type: \"boolean\",\n                    default: true\n                },\n                enforceForClassMembers: {\n                    type: \"boolean\",\n                    default: false\n                }\n            },\n            additionalProperties: false\n        }],\n\n        messages: {\n            missingGetterInPropertyDescriptor: \"Getter is not present in property descriptor.\",\n            missingSetterInPropertyDescriptor: \"Setter is not present in property descriptor.\",\n            missingGetterInObjectLiteral: \"Getter is not present for {{ name }}.\",\n            missingSetterInObjectLiteral: \"Setter is not present for {{ name }}.\",\n            missingGetterInClass: \"Getter is not present for class {{ name }}.\",\n            missingSetterInClass: \"Setter is not present for class {{ name }}.\"\n        }\n    },\n    create(context) {\n        const config = context.options[0] || {};\n        const checkGetWithoutSet = config.getWithoutSet === true;\n        const checkSetWithoutGet = config.setWithoutGet !== false;\n        const enforceForClassMembers = config.enforceForClassMembers === true;\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Reports the given node.\n         * @param {ASTNode} node The node to report.\n         * @param {string} messageKind \"missingGetter\" or \"missingSetter\".\n         * @returns {void}\n         * @private\n         */\n        function report(node, messageKind) {\n            if (node.type === \"Property\") {\n                context.report({\n                    node,\n                    messageId: `${messageKind}InObjectLiteral`,\n                    loc: astUtils$1.getFunctionHeadLoc(node.value, sourceCode),\n                    data: { name: astUtils$1.getFunctionNameWithKind(node.value) }\n                });\n            } else if (node.type === \"MethodDefinition\") {\n                context.report({\n                    node,\n                    messageId: `${messageKind}InClass`,\n                    loc: astUtils$1.getFunctionHeadLoc(node.value, sourceCode),\n                    data: { name: astUtils$1.getFunctionNameWithKind(node.value) }\n                });\n            } else {\n                context.report({\n                    node,\n                    messageId: `${messageKind}InPropertyDescriptor`\n                });\n            }\n        }\n\n        /**\n         * Reports each of the nodes in the given list using the same messageId.\n         * @param {ASTNode[]} nodes Nodes to report.\n         * @param {string} messageKind \"missingGetter\" or \"missingSetter\".\n         * @returns {void}\n         * @private\n         */\n        function reportList(nodes, messageKind) {\n            for (const node of nodes) {\n                report(node, messageKind);\n            }\n        }\n\n        /**\n         * Creates a new `AccessorData` object for the given getter or setter node.\n         * @param {ASTNode} node A getter or setter node.\n         * @returns {AccessorData} New `AccessorData` object that contains the given node.\n         * @private\n         */\n        function createAccessorData(node) {\n            const name = astUtils$1.getStaticPropertyName(node);\n            const key = (name !== null) ? name : sourceCode.getTokens(node.key);\n\n            return {\n                key,\n                getters: node.kind === \"get\" ? [node] : [],\n                setters: node.kind === \"set\" ? [node] : []\n            };\n        }\n\n        /**\n         * Merges the given `AccessorData` object into the given accessors list.\n         * @param {AccessorData[]} accessors The list to merge into.\n         * @param {AccessorData} accessorData The object to merge.\n         * @returns {AccessorData[]} The same instance with the merged object.\n         * @private\n         */\n        function mergeAccessorData(accessors, accessorData) {\n            const equalKeyElement = accessors.find(a => areEqualKeys(a.key, accessorData.key));\n\n            if (equalKeyElement) {\n                equalKeyElement.getters.push(...accessorData.getters);\n                equalKeyElement.setters.push(...accessorData.setters);\n            } else {\n                accessors.push(accessorData);\n            }\n\n            return accessors;\n        }\n\n        /**\n         * Checks accessor pairs in the given list of nodes.\n         * @param {ASTNode[]} nodes The list to check.\n         * @returns {void}\n         * @private\n         */\n        function checkList(nodes) {\n            const accessors = nodes\n                .filter(isAccessorKind)\n                .map(createAccessorData)\n                .reduce(mergeAccessorData, []);\n\n            for (const { getters, setters } of accessors) {\n                if (checkSetWithoutGet && setters.length && !getters.length) {\n                    reportList(setters, \"missingGetter\");\n                }\n                if (checkGetWithoutSet && getters.length && !setters.length) {\n                    reportList(getters, \"missingSetter\");\n                }\n            }\n        }\n\n        /**\n         * Checks accessor pairs in an object literal.\n         * @param {ASTNode} node `ObjectExpression` node to check.\n         * @returns {void}\n         * @private\n         */\n        function checkObjectLiteral(node) {\n            checkList(node.properties.filter(p => p.type === \"Property\"));\n        }\n\n        /**\n         * Checks accessor pairs in a property descriptor.\n         * @param {ASTNode} node Property descriptor `ObjectExpression` node to check.\n         * @returns {void}\n         * @private\n         */\n        function checkPropertyDescriptor(node) {\n            const namesToCheck = node.properties\n                .filter(p => p.type === \"Property\" && p.kind === \"init\" && !p.computed)\n                .map(({ key }) => key.name);\n\n            const hasGetter = namesToCheck.includes(\"get\");\n            const hasSetter = namesToCheck.includes(\"set\");\n\n            if (checkSetWithoutGet && hasSetter && !hasGetter) {\n                report(node, \"missingGetter\");\n            }\n            if (checkGetWithoutSet && hasGetter && !hasSetter) {\n                report(node, \"missingSetter\");\n            }\n        }\n\n        /**\n         * Checks the given object expression as an object literal and as a possible property descriptor.\n         * @param {ASTNode} node `ObjectExpression` node to check.\n         * @returns {void}\n         * @private\n         */\n        function checkObjectExpression(node) {\n            checkObjectLiteral(node);\n            if (isPropertyDescriptor(node)) {\n                checkPropertyDescriptor(node);\n            }\n        }\n\n        /**\n         * Checks the given class body.\n         * @param {ASTNode} node `ClassBody` node to check.\n         * @returns {void}\n         * @private\n         */\n        function checkClassBody(node) {\n            const methodDefinitions = node.body.filter(m => m.type === \"MethodDefinition\");\n\n            checkList(methodDefinitions.filter(m => m.static));\n            checkList(methodDefinitions.filter(m => !m.static));\n        }\n\n        const listeners = {};\n\n        if (checkSetWithoutGet || checkGetWithoutSet) {\n            listeners.ObjectExpression = checkObjectExpression;\n            if (enforceForClassMembers) {\n                listeners.ClassBody = checkClassBody;\n            }\n        }\n\n        return listeners;\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar arrayBracketNewline = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce linebreaks after opening and before closing array brackets\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/array-bracket-newline\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        enum: [\"always\", \"never\", \"consistent\"]\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            multiline: {\n                                type: \"boolean\"\n                            },\n                            minItems: {\n                                type: [\"integer\", \"null\"],\n                                minimum: 0\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ],\n\n        messages: {\n            unexpectedOpeningLinebreak: \"There should be no linebreak after '['.\",\n            unexpectedClosingLinebreak: \"There should be no linebreak before ']'.\",\n            missingOpeningLinebreak: \"A linebreak is required after '['.\",\n            missingClosingLinebreak: \"A linebreak is required before ']'.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n\n        //----------------------------------------------------------------------\n        // Helpers\n        //----------------------------------------------------------------------\n\n        /**\n         * Normalizes a given option value.\n         * @param {string|Object|undefined} option An option value to parse.\n         * @returns {{multiline: boolean, minItems: number}} Normalized option object.\n         */\n        function normalizeOptionValue(option) {\n            let consistent = false;\n            let multiline = false;\n            let minItems = 0;\n\n            if (option) {\n                if (option === \"consistent\") {\n                    consistent = true;\n                    minItems = Number.POSITIVE_INFINITY;\n                } else if (option === \"always\" || option.minItems === 0) {\n                    minItems = 0;\n                } else if (option === \"never\") {\n                    minItems = Number.POSITIVE_INFINITY;\n                } else {\n                    multiline = Boolean(option.multiline);\n                    minItems = option.minItems || Number.POSITIVE_INFINITY;\n                }\n            } else {\n                consistent = false;\n                multiline = true;\n                minItems = Number.POSITIVE_INFINITY;\n            }\n\n            return { consistent, multiline, minItems };\n        }\n\n        /**\n         * Normalizes a given option value.\n         * @param {string|Object|undefined} options An option value to parse.\n         * @returns {{ArrayExpression: {multiline: boolean, minItems: number}, ArrayPattern: {multiline: boolean, minItems: number}}} Normalized option object.\n         */\n        function normalizeOptions(options) {\n            const value = normalizeOptionValue(options);\n\n            return { ArrayExpression: value, ArrayPattern: value };\n        }\n\n        /**\n         * Reports that there shouldn't be a linebreak after the first token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportNoBeginningLinebreak(node, token) {\n            context.report({\n                node,\n                loc: token.loc,\n                messageId: \"unexpectedOpeningLinebreak\",\n                fix(fixer) {\n                    const nextToken = sourceCode.getTokenAfter(token, { includeComments: true });\n\n                    if (astUtils$1.isCommentToken(nextToken)) {\n                        return null;\n                    }\n\n                    return fixer.removeRange([token.range[1], nextToken.range[0]]);\n                }\n            });\n        }\n\n        /**\n         * Reports that there shouldn't be a linebreak before the last token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportNoEndingLinebreak(node, token) {\n            context.report({\n                node,\n                loc: token.loc,\n                messageId: \"unexpectedClosingLinebreak\",\n                fix(fixer) {\n                    const previousToken = sourceCode.getTokenBefore(token, { includeComments: true });\n\n                    if (astUtils$1.isCommentToken(previousToken)) {\n                        return null;\n                    }\n\n                    return fixer.removeRange([previousToken.range[1], token.range[0]]);\n                }\n            });\n        }\n\n        /**\n         * Reports that there should be a linebreak after the first token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportRequiredBeginningLinebreak(node, token) {\n            context.report({\n                node,\n                loc: token.loc,\n                messageId: \"missingOpeningLinebreak\",\n                fix(fixer) {\n                    return fixer.insertTextAfter(token, \"\\n\");\n                }\n            });\n        }\n\n        /**\n         * Reports that there should be a linebreak before the last token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportRequiredEndingLinebreak(node, token) {\n            context.report({\n                node,\n                loc: token.loc,\n                messageId: \"missingClosingLinebreak\",\n                fix(fixer) {\n                    return fixer.insertTextBefore(token, \"\\n\");\n                }\n            });\n        }\n\n        /**\n         * Reports a given node if it violated this rule.\n         * @param {ASTNode} node A node to check. This is an ArrayExpression node or an ArrayPattern node.\n         * @returns {void}\n         */\n        function check(node) {\n            const elements = node.elements;\n            const normalizedOptions = normalizeOptions(context.options[0]);\n            const options = normalizedOptions[node.type];\n            const openBracket = sourceCode.getFirstToken(node);\n            const closeBracket = sourceCode.getLastToken(node);\n            const firstIncComment = sourceCode.getTokenAfter(openBracket, { includeComments: true });\n            const lastIncComment = sourceCode.getTokenBefore(closeBracket, { includeComments: true });\n            const first = sourceCode.getTokenAfter(openBracket);\n            const last = sourceCode.getTokenBefore(closeBracket);\n\n            const needsLinebreaks = (\n                elements.length >= options.minItems ||\n                (\n                    options.multiline &&\n                    elements.length > 0 &&\n                    firstIncComment.loc.start.line !== lastIncComment.loc.end.line\n                ) ||\n                (\n                    elements.length === 0 &&\n                    firstIncComment.type === \"Block\" &&\n                    firstIncComment.loc.start.line !== lastIncComment.loc.end.line &&\n                    firstIncComment === lastIncComment\n                ) ||\n                (\n                    options.consistent &&\n                    openBracket.loc.end.line !== first.loc.start.line\n                )\n            );\n\n            /*\n             * Use tokens or comments to check multiline or not.\n             * But use only tokens to check whether linebreaks are needed.\n             * This allows:\n             *     var arr = [ // eslint-disable-line foo\n             *         'a'\n             *     ]\n             */\n\n            if (needsLinebreaks) {\n                if (astUtils$1.isTokenOnSameLine(openBracket, first)) {\n                    reportRequiredBeginningLinebreak(node, openBracket);\n                }\n                if (astUtils$1.isTokenOnSameLine(last, closeBracket)) {\n                    reportRequiredEndingLinebreak(node, closeBracket);\n                }\n            } else {\n                if (!astUtils$1.isTokenOnSameLine(openBracket, first)) {\n                    reportNoBeginningLinebreak(node, openBracket);\n                }\n                if (!astUtils$1.isTokenOnSameLine(last, closeBracket)) {\n                    reportNoEndingLinebreak(node, closeBracket);\n                }\n            }\n        }\n\n        //----------------------------------------------------------------------\n        // Public\n        //----------------------------------------------------------------------\n\n        return {\n            ArrayPattern: check,\n            ArrayExpression: check\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar arrayBracketSpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent spacing inside array brackets\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/array-bracket-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                enum: [\"always\", \"never\"]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    singleValue: {\n                        type: \"boolean\"\n                    },\n                    objectsInArrays: {\n                        type: \"boolean\"\n                    },\n                    arraysInArrays: {\n                        type: \"boolean\"\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            unexpectedSpaceAfter: \"There should be no space after '{{tokenValue}}'.\",\n            unexpectedSpaceBefore: \"There should be no space before '{{tokenValue}}'.\",\n            missingSpaceAfter: \"A space is required after '{{tokenValue}}'.\",\n            missingSpaceBefore: \"A space is required before '{{tokenValue}}'.\"\n        }\n    },\n    create(context) {\n        const spaced = context.options[0] === \"always\",\n            sourceCode = context.getSourceCode();\n\n        /**\n         * Determines whether an option is set, relative to the spacing option.\n         * If spaced is \"always\", then check whether option is set to false.\n         * If spaced is \"never\", then check whether option is set to true.\n         * @param {Object} option The option to exclude.\n         * @returns {boolean} Whether or not the property is excluded.\n         */\n        function isOptionSet(option) {\n            return context.options[1] ? context.options[1][option] === !spaced : false;\n        }\n\n        const options = {\n            spaced,\n            singleElementException: isOptionSet(\"singleValue\"),\n            objectsInArraysException: isOptionSet(\"objectsInArrays\"),\n            arraysInArraysException: isOptionSet(\"arraysInArrays\")\n        };\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Reports that there shouldn't be a space after the first token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportNoBeginningSpace(node, token) {\n            const nextToken = sourceCode.getTokenAfter(token);\n\n            context.report({\n                node,\n                loc: { start: token.loc.end, end: nextToken.loc.start },\n                messageId: \"unexpectedSpaceAfter\",\n                data: {\n                    tokenValue: token.value\n                },\n                fix(fixer) {\n                    return fixer.removeRange([token.range[1], nextToken.range[0]]);\n                }\n            });\n        }\n\n        /**\n         * Reports that there shouldn't be a space before the last token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportNoEndingSpace(node, token) {\n            const previousToken = sourceCode.getTokenBefore(token);\n\n            context.report({\n                node,\n                loc: { start: previousToken.loc.end, end: token.loc.start },\n                messageId: \"unexpectedSpaceBefore\",\n                data: {\n                    tokenValue: token.value\n                },\n                fix(fixer) {\n                    return fixer.removeRange([previousToken.range[1], token.range[0]]);\n                }\n            });\n        }\n\n        /**\n         * Reports that there should be a space after the first token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportRequiredBeginningSpace(node, token) {\n            context.report({\n                node,\n                loc: token.loc,\n                messageId: \"missingSpaceAfter\",\n                data: {\n                    tokenValue: token.value\n                },\n                fix(fixer) {\n                    return fixer.insertTextAfter(token, \" \");\n                }\n            });\n        }\n\n        /**\n         * Reports that there should be a space before the last token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportRequiredEndingSpace(node, token) {\n            context.report({\n                node,\n                loc: token.loc,\n                messageId: \"missingSpaceBefore\",\n                data: {\n                    tokenValue: token.value\n                },\n                fix(fixer) {\n                    return fixer.insertTextBefore(token, \" \");\n                }\n            });\n        }\n\n        /**\n         * Determines if a node is an object type\n         * @param {ASTNode} node The node to check.\n         * @returns {boolean} Whether or not the node is an object type.\n         */\n        function isObjectType(node) {\n            return node && (node.type === \"ObjectExpression\" || node.type === \"ObjectPattern\");\n        }\n\n        /**\n         * Determines if a node is an array type\n         * @param {ASTNode} node The node to check.\n         * @returns {boolean} Whether or not the node is an array type.\n         */\n        function isArrayType(node) {\n            return node && (node.type === \"ArrayExpression\" || node.type === \"ArrayPattern\");\n        }\n\n        /**\n         * Validates the spacing around array brackets\n         * @param {ASTNode} node The node we're checking for spacing\n         * @returns {void}\n         */\n        function validateArraySpacing(node) {\n            if (options.spaced && node.elements.length === 0) {\n                return;\n            }\n\n            const first = sourceCode.getFirstToken(node),\n                second = sourceCode.getFirstToken(node, 1),\n                last = node.typeAnnotation\n                    ? sourceCode.getTokenBefore(node.typeAnnotation)\n                    : sourceCode.getLastToken(node),\n                penultimate = sourceCode.getTokenBefore(last),\n                firstElement = node.elements[0],\n                lastElement = node.elements[node.elements.length - 1];\n\n            const openingBracketMustBeSpaced =\n                options.objectsInArraysException && isObjectType(firstElement) ||\n                options.arraysInArraysException && isArrayType(firstElement) ||\n                options.singleElementException && node.elements.length === 1\n                    ? !options.spaced : options.spaced;\n\n            const closingBracketMustBeSpaced =\n                options.objectsInArraysException && isObjectType(lastElement) ||\n                options.arraysInArraysException && isArrayType(lastElement) ||\n                options.singleElementException && node.elements.length === 1\n                    ? !options.spaced : options.spaced;\n\n            if (astUtils$1.isTokenOnSameLine(first, second)) {\n                if (openingBracketMustBeSpaced && !sourceCode.isSpaceBetweenTokens(first, second)) {\n                    reportRequiredBeginningSpace(node, first);\n                }\n                if (!openingBracketMustBeSpaced && sourceCode.isSpaceBetweenTokens(first, second)) {\n                    reportNoBeginningSpace(node, first);\n                }\n            }\n\n            if (first !== penultimate && astUtils$1.isTokenOnSameLine(penultimate, last)) {\n                if (closingBracketMustBeSpaced && !sourceCode.isSpaceBetweenTokens(penultimate, last)) {\n                    reportRequiredEndingSpace(node, last);\n                }\n                if (!closingBracketMustBeSpaced && sourceCode.isSpaceBetweenTokens(penultimate, last)) {\n                    reportNoEndingSpace(node, last);\n                }\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            ArrayPattern: validateArraySpacing,\n            ArrayExpression: validateArraySpacing\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u;\nconst TARGET_METHODS = /^(?:every|filter|find(?:Index)?|map|reduce(?:Right)?|some|sort)$/u;\n\n/**\n * Checks a given code path segment is reachable.\n * @param {CodePathSegment} segment A segment to check.\n * @returns {boolean} `true` if the segment is reachable.\n */\nfunction isReachable(segment) {\n    return segment.reachable;\n}\n\n/**\n * Gets a readable location.\n *\n * - FunctionExpression -> the function name or `function` keyword.\n * - ArrowFunctionExpression -> `=>` token.\n * @param {ASTNode} node A function node to get.\n * @param {SourceCode} sourceCode A source code to get tokens.\n * @returns {ASTNode|Token} The node or the token of a location.\n */\nfunction getLocation(node, sourceCode) {\n    if (node.type === \"ArrowFunctionExpression\") {\n        return sourceCode.getTokenBefore(node.body);\n    }\n    return node.id || node;\n}\n\n/**\n * Checks a given node is a MemberExpression node which has the specified name's\n * property.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} `true` if the node is a MemberExpression node which has\n *      the specified name's property\n */\nfunction isTargetMethod(node) {\n    return (\n        node.type === \"MemberExpression\" &&\n        TARGET_METHODS.test(astUtils$1.getStaticPropertyName(node) || \"\")\n    );\n}\n\n/**\n * Checks whether or not a given node is a function expression which is the\n * callback of an array method.\n * @param {ASTNode} node A node to check. This is one of\n *      FunctionExpression or ArrowFunctionExpression.\n * @returns {boolean} `true` if the node is the callback of an array method.\n */\nfunction isCallbackOfArrayMethod(node) {\n    let currentNode = node;\n\n    while (currentNode) {\n        const parent = currentNode.parent;\n\n        switch (parent.type) {\n\n            /*\n             * Looks up the destination. e.g.,\n             * foo.every(nativeFoo || function foo() { ... });\n             */\n            case \"LogicalExpression\":\n            case \"ConditionalExpression\":\n                currentNode = parent;\n                break;\n\n            /*\n             * If the upper function is IIFE, checks the destination of the return value.\n             * e.g.\n             *   foo.every((function() {\n             *     // setup...\n             *     return function callback() { ... };\n             *   })());\n             */\n            case \"ReturnStatement\": {\n                const func = astUtils$1.getUpperFunction(parent);\n\n                if (func === null || !astUtils$1.isCallee(func)) {\n                    return false;\n                }\n                currentNode = func.parent;\n                break;\n            }\n\n            /*\n             * e.g.\n             *   Array.from([], function() {});\n             *   list.every(function() {});\n             */\n            case \"CallExpression\":\n                if (astUtils$1.isArrayFromMethod(parent.callee)) {\n                    return (\n                        parent.arguments.length >= 2 &&\n                        parent.arguments[1] === currentNode\n                    );\n                }\n                if (isTargetMethod(parent.callee)) {\n                    return (\n                        parent.arguments.length >= 1 &&\n                        parent.arguments[0] === currentNode\n                    );\n                }\n                return false;\n\n            // Otherwise this node is not target.\n            default:\n                return false;\n        }\n    }\n\n    /* istanbul ignore next: unreachable */\n    return false;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar arrayCallbackReturn = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"enforce `return` statements in callbacks of array methods\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/array-callback-return\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allowImplicit: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            expectedAtEnd: \"Expected to return a value at the end of {{name}}.\",\n            expectedInside: \"Expected to return a value in {{name}}.\",\n            expectedReturnValue: \"{{name}} expected a return value.\"\n        }\n    },\n\n    create(context) {\n\n        const options = context.options[0] || { allowImplicit: false };\n\n        let funcInfo = {\n            upper: null,\n            codePath: null,\n            hasReturn: false,\n            shouldCheck: false,\n            node: null\n        };\n\n        /**\n         * Checks whether or not the last code path segment is reachable.\n         * Then reports this function if the segment is reachable.\n         *\n         * If the last code path segment is reachable, there are paths which are not\n         * returned or thrown.\n         * @param {ASTNode} node A node to check.\n         * @returns {void}\n         */\n        function checkLastSegment(node) {\n            if (funcInfo.shouldCheck &&\n                funcInfo.codePath.currentSegments.some(isReachable)\n            ) {\n                context.report({\n                    node,\n                    loc: getLocation(node, context.getSourceCode()).loc.start,\n                    messageId: funcInfo.hasReturn\n                        ? \"expectedAtEnd\"\n                        : \"expectedInside\",\n                    data: {\n                        name: astUtils$1.getFunctionNameWithKind(funcInfo.node)\n                    }\n                });\n            }\n        }\n\n        return {\n\n            // Stacks this function's information.\n            onCodePathStart(codePath, node) {\n                funcInfo = {\n                    upper: funcInfo,\n                    codePath,\n                    hasReturn: false,\n                    shouldCheck:\n                        TARGET_NODE_TYPE.test(node.type) &&\n                        node.body.type === \"BlockStatement\" &&\n                        isCallbackOfArrayMethod(node) &&\n                        !node.async &&\n                        !node.generator,\n                    node\n                };\n            },\n\n            // Pops this function's information.\n            onCodePathEnd() {\n                funcInfo = funcInfo.upper;\n            },\n\n            // Checks the return statement is valid.\n            ReturnStatement(node) {\n                if (funcInfo.shouldCheck) {\n                    funcInfo.hasReturn = true;\n\n                    // if allowImplicit: false, should also check node.argument\n                    if (!options.allowImplicit && !node.argument) {\n                        context.report({\n                            node,\n                            messageId: \"expectedReturnValue\",\n                            data: {\n                                name: lodash.upperFirst(astUtils$1.getFunctionNameWithKind(funcInfo.node))\n                            }\n                        });\n                    }\n                }\n            },\n\n            // Reports a given function if the last path is reachable.\n            \"FunctionExpression:exit\": checkLastSegment,\n            \"ArrowFunctionExpression:exit\": checkLastSegment\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar arrayElementNewline = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce line breaks after each array element\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/array-element-newline\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        enum: [\"always\", \"never\", \"consistent\"]\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            multiline: {\n                                type: \"boolean\"\n                            },\n                            minItems: {\n                                type: [\"integer\", \"null\"],\n                                minimum: 0\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ],\n\n        messages: {\n            unexpectedLineBreak: \"There should be no linebreak here.\",\n            missingLineBreak: \"There should be a linebreak after this element.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        //----------------------------------------------------------------------\n        // Helpers\n        //----------------------------------------------------------------------\n\n        /**\n         * Normalizes a given option value.\n         * @param {string|Object|undefined} providedOption An option value to parse.\n         * @returns {{multiline: boolean, minItems: number}} Normalized option object.\n         */\n        function normalizeOptionValue(providedOption) {\n            let consistent = false;\n            let multiline = false;\n            let minItems;\n\n            const option = providedOption || \"always\";\n\n            if (!option || option === \"always\" || option.minItems === 0) {\n                minItems = 0;\n            } else if (option === \"never\") {\n                minItems = Number.POSITIVE_INFINITY;\n            } else if (option === \"consistent\") {\n                consistent = true;\n                minItems = Number.POSITIVE_INFINITY;\n            } else {\n                multiline = Boolean(option.multiline);\n                minItems = option.minItems || Number.POSITIVE_INFINITY;\n            }\n\n            return { consistent, multiline, minItems };\n        }\n\n        /**\n         * Normalizes a given option value.\n         * @param {string|Object|undefined} options An option value to parse.\n         * @returns {{ArrayExpression: {multiline: boolean, minItems: number}, ArrayPattern: {multiline: boolean, minItems: number}}} Normalized option object.\n         */\n        function normalizeOptions(options) {\n            const value = normalizeOptionValue(options);\n\n            return { ArrayExpression: value, ArrayPattern: value };\n        }\n\n        /**\n         * Reports that there shouldn't be a line break after the first token\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportNoLineBreak(token) {\n            const tokenBefore = sourceCode.getTokenBefore(token, { includeComments: true });\n\n            context.report({\n                loc: {\n                    start: tokenBefore.loc.end,\n                    end: token.loc.start\n                },\n                messageId: \"unexpectedLineBreak\",\n                fix(fixer) {\n                    if (astUtils$1.isCommentToken(tokenBefore)) {\n                        return null;\n                    }\n\n                    if (!astUtils$1.isTokenOnSameLine(tokenBefore, token)) {\n                        return fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], \" \");\n                    }\n\n                    /*\n                     * This will check if the comma is on the same line as the next element\n                     * Following array:\n                     * [\n                     *     1\n                     *     , 2\n                     *     , 3\n                     * ]\n                     *\n                     * will be fixed to:\n                     * [\n                     *     1, 2, 3\n                     * ]\n                     */\n                    const twoTokensBefore = sourceCode.getTokenBefore(tokenBefore, { includeComments: true });\n\n                    if (astUtils$1.isCommentToken(twoTokensBefore)) {\n                        return null;\n                    }\n\n                    return fixer.replaceTextRange([twoTokensBefore.range[1], tokenBefore.range[0]], \"\");\n\n                }\n            });\n        }\n\n        /**\n         * Reports that there should be a line break after the first token\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportRequiredLineBreak(token) {\n            const tokenBefore = sourceCode.getTokenBefore(token, { includeComments: true });\n\n            context.report({\n                loc: {\n                    start: tokenBefore.loc.end,\n                    end: token.loc.start\n                },\n                messageId: \"missingLineBreak\",\n                fix(fixer) {\n                    return fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], \"\\n\");\n                }\n            });\n        }\n\n        /**\n         * Reports a given node if it violated this rule.\n         * @param {ASTNode} node A node to check. This is an ObjectExpression node or an ObjectPattern node.\n         * @returns {void}\n         */\n        function check(node) {\n            const elements = node.elements;\n            const normalizedOptions = normalizeOptions(context.options[0]);\n            const options = normalizedOptions[node.type];\n\n            let elementBreak = false;\n\n            /*\n             * MULTILINE: true\n             * loop through every element and check\n             * if at least one element has linebreaks inside\n             * this ensures that following is not valid (due to elements are on the same line):\n             *\n             * [\n             *      1,\n             *      2,\n             *      3\n             * ]\n             */\n            if (options.multiline) {\n                elementBreak = elements\n                    .filter(element => element !== null)\n                    .some(element => element.loc.start.line !== element.loc.end.line);\n            }\n\n            const linebreaksCount = node.elements.map((element, i) => {\n                const previousElement = elements[i - 1];\n\n                if (i === 0 || element === null || previousElement === null) {\n                    return false;\n                }\n\n                const commaToken = sourceCode.getFirstTokenBetween(previousElement, element, astUtils$1.isCommaToken);\n                const lastTokenOfPreviousElement = sourceCode.getTokenBefore(commaToken);\n                const firstTokenOfCurrentElement = sourceCode.getTokenAfter(commaToken);\n\n                return !astUtils$1.isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement);\n            }).filter(isBreak => isBreak === true).length;\n\n            const needsLinebreaks = (\n                elements.length >= options.minItems ||\n                (\n                    options.multiline &&\n                    elementBreak\n                ) ||\n                (\n                    options.consistent &&\n                    linebreaksCount > 0 &&\n                    linebreaksCount < node.elements.length\n                )\n            );\n\n            elements.forEach((element, i) => {\n                const previousElement = elements[i - 1];\n\n                if (i === 0 || element === null || previousElement === null) {\n                    return;\n                }\n\n                const commaToken = sourceCode.getFirstTokenBetween(previousElement, element, astUtils$1.isCommaToken);\n                const lastTokenOfPreviousElement = sourceCode.getTokenBefore(commaToken);\n                const firstTokenOfCurrentElement = sourceCode.getTokenAfter(commaToken);\n\n                if (needsLinebreaks) {\n                    if (astUtils$1.isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement)) {\n                        reportRequiredLineBreak(firstTokenOfCurrentElement);\n                    }\n                } else {\n                    if (!astUtils$1.isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement)) {\n                        reportNoLineBreak(firstTokenOfCurrentElement);\n                    }\n                }\n            });\n        }\n\n        //----------------------------------------------------------------------\n        // Public\n        //----------------------------------------------------------------------\n\n        return {\n            ArrayPattern: check,\n            ArrayExpression: check\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar arrowBodyStyle = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require braces around arrow function bodies\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/arrow-body-style\"\n        },\n\n        schema: {\n            anyOf: [\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"always\", \"never\"]\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 1\n                },\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"as-needed\"]\n                        },\n                        {\n                            type: \"object\",\n                            properties: {\n                                requireReturnForObjectLiteral: { type: \"boolean\" }\n                            },\n                            additionalProperties: false\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 2\n                }\n            ]\n        },\n\n        fixable: \"code\",\n\n        messages: {\n            unexpectedOtherBlock: \"Unexpected block statement surrounding arrow body.\",\n            unexpectedEmptyBlock: \"Unexpected block statement surrounding arrow body; put a value of `undefined` immediately after the `=>`.\",\n            unexpectedObjectBlock: \"Unexpected block statement surrounding arrow body; parenthesize the returned value and move it immediately after the `=>`.\",\n            unexpectedSingleBlock: \"Unexpected block statement surrounding arrow body; move the returned value immediately after the `=>`.\",\n            expectedBlock: \"Expected block statement surrounding arrow body.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options;\n        const always = options[0] === \"always\";\n        const asNeeded = !options[0] || options[0] === \"as-needed\";\n        const never = options[0] === \"never\";\n        const requireReturnForObjectLiteral = options[1] && options[1].requireReturnForObjectLiteral;\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Checks whether the given node has ASI problem or not.\n         * @param {Token} token The token to check.\n         * @returns {boolean} `true` if it changes semantics if `;` or `}` followed by the token are removed.\n         */\n        function hasASIProblem(token) {\n            return token && token.type === \"Punctuator\" && /^[([/`+-]/u.test(token.value);\n        }\n\n        /**\n         * Gets the closing parenthesis which is the pair of the given opening parenthesis.\n         * @param {Token} token The opening parenthesis token to get.\n         * @returns {Token} The found closing parenthesis token.\n         */\n        function findClosingParen(token) {\n            let node = sourceCode.getNodeByRangeIndex(token.range[1]);\n\n            while (!astUtils$1.isParenthesised(sourceCode, node)) {\n                node = node.parent;\n            }\n            return sourceCode.getTokenAfter(node);\n        }\n\n        /**\n         * Determines whether a arrow function body needs braces\n         * @param {ASTNode} node The arrow function node.\n         * @returns {void}\n         */\n        function validate(node) {\n            const arrowBody = node.body;\n\n            if (arrowBody.type === \"BlockStatement\") {\n                const blockBody = arrowBody.body;\n\n                if (blockBody.length !== 1 && !never) {\n                    return;\n                }\n\n                if (asNeeded && requireReturnForObjectLiteral && blockBody[0].type === \"ReturnStatement\" &&\n                    blockBody[0].argument && blockBody[0].argument.type === \"ObjectExpression\") {\n                    return;\n                }\n\n                if (never || asNeeded && blockBody[0].type === \"ReturnStatement\") {\n                    let messageId;\n\n                    if (blockBody.length === 0) {\n                        messageId = \"unexpectedEmptyBlock\";\n                    } else if (blockBody.length > 1) {\n                        messageId = \"unexpectedOtherBlock\";\n                    } else if (blockBody[0].argument === null) {\n                        messageId = \"unexpectedSingleBlock\";\n                    } else if (astUtils$1.isOpeningBraceToken(sourceCode.getFirstToken(blockBody[0], { skip: 1 }))) {\n                        messageId = \"unexpectedObjectBlock\";\n                    } else {\n                        messageId = \"unexpectedSingleBlock\";\n                    }\n\n                    context.report({\n                        node,\n                        loc: arrowBody.loc.start,\n                        messageId,\n                        fix(fixer) {\n                            const fixes = [];\n\n                            if (blockBody.length !== 1 ||\n                                blockBody[0].type !== \"ReturnStatement\" ||\n                                !blockBody[0].argument ||\n                                hasASIProblem(sourceCode.getTokenAfter(arrowBody))\n                            ) {\n                                return fixes;\n                            }\n\n                            const openingBrace = sourceCode.getFirstToken(arrowBody);\n                            const closingBrace = sourceCode.getLastToken(arrowBody);\n                            const firstValueToken = sourceCode.getFirstToken(blockBody[0], 1);\n                            const lastValueToken = sourceCode.getLastToken(blockBody[0]);\n                            const commentsExist =\n                                sourceCode.commentsExistBetween(openingBrace, firstValueToken) ||\n                                sourceCode.commentsExistBetween(lastValueToken, closingBrace);\n\n                            /*\n                             * Remove tokens around the return value.\n                             * If comments don't exist, remove extra spaces as well.\n                             */\n                            if (commentsExist) {\n                                fixes.push(\n                                    fixer.remove(openingBrace),\n                                    fixer.remove(closingBrace),\n                                    fixer.remove(sourceCode.getTokenAfter(openingBrace)) // return keyword\n                                );\n                            } else {\n                                fixes.push(\n                                    fixer.removeRange([openingBrace.range[0], firstValueToken.range[0]]),\n                                    fixer.removeRange([lastValueToken.range[1], closingBrace.range[1]])\n                                );\n                            }\n\n                            /*\n                             * If the first token of the reutrn value is `{` or the return value is a sequence expression,\n                             * enclose the return value by parentheses to avoid syntax error.\n                             */\n                            if (astUtils$1.isOpeningBraceToken(firstValueToken) || blockBody[0].argument.type === \"SequenceExpression\") {\n                                fixes.push(\n                                    fixer.insertTextBefore(firstValueToken, \"(\"),\n                                    fixer.insertTextAfter(lastValueToken, \")\")\n                                );\n                            }\n\n                            /*\n                             * If the last token of the return statement is semicolon, remove it.\n                             * Non-block arrow body is an expression, not a statement.\n                             */\n                            if (astUtils$1.isSemicolonToken(lastValueToken)) {\n                                fixes.push(fixer.remove(lastValueToken));\n                            }\n\n                            return fixes;\n                        }\n                    });\n                }\n            } else {\n                if (always || (asNeeded && requireReturnForObjectLiteral && arrowBody.type === \"ObjectExpression\")) {\n                    context.report({\n                        node,\n                        loc: arrowBody.loc.start,\n                        messageId: \"expectedBlock\",\n                        fix(fixer) {\n                            const fixes = [];\n                            const arrowToken = sourceCode.getTokenBefore(arrowBody, astUtils$1.isArrowToken);\n                            const firstBodyToken = sourceCode.getTokenAfter(arrowToken);\n                            const lastBodyToken = sourceCode.getLastToken(node);\n                            const isParenthesisedObjectLiteral =\n                                astUtils$1.isOpeningParenToken(firstBodyToken) &&\n                                astUtils$1.isOpeningBraceToken(sourceCode.getTokenAfter(firstBodyToken));\n\n                            // Wrap the value by a block and a return statement.\n                            fixes.push(\n                                fixer.insertTextBefore(firstBodyToken, \"{return \"),\n                                fixer.insertTextAfter(lastBodyToken, \"}\")\n                            );\n\n                            // If the value is object literal, remove parentheses which were forced by syntax.\n                            if (isParenthesisedObjectLiteral) {\n                                fixes.push(\n                                    fixer.remove(firstBodyToken),\n                                    fixer.remove(findClosingParen(firstBodyToken))\n                                );\n                            }\n\n                            return fixes;\n                        }\n                    });\n                }\n            }\n        }\n\n        return {\n            \"ArrowFunctionExpression:exit\": validate\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Get location should be reported by AST node.\n * @param {ASTNode} node AST Node.\n * @returns {Location} Location information.\n */\nfunction getLocation$1(node) {\n    return {\n        start: node.params[0].loc.start,\n        end: node.params[node.params.length - 1].loc.end\n    };\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar arrowParens = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require parentheses around arrow function arguments\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/arrow-parens\"\n        },\n\n        fixable: \"code\",\n\n        schema: [\n            {\n                enum: [\"always\", \"as-needed\"]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    requireForBlockBody: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            unexpectedParens: \"Unexpected parentheses around single function argument.\",\n            expectedParens: \"Expected parentheses around arrow function argument.\",\n\n            unexpectedParensInline: \"Unexpected parentheses around single function argument having a body with no curly braces.\",\n            expectedParensBlock: \"Expected parentheses around arrow function argument having a body with curly braces.\"\n        }\n    },\n\n    create(context) {\n        const asNeeded = context.options[0] === \"as-needed\";\n        const requireForBlockBody = asNeeded && context.options[1] && context.options[1].requireForBlockBody === true;\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Determines whether a arrow function argument end with `)`\n         * @param {ASTNode} node The arrow function node.\n         * @returns {void}\n         */\n        function parens(node) {\n            const isAsync = node.async;\n            const firstTokenOfParam = sourceCode.getFirstToken(node, isAsync ? 1 : 0);\n\n            /**\n             * Remove the parenthesis around a parameter\n             * @param {Fixer} fixer Fixer\n             * @returns {string} fixed parameter\n             */\n            function fixParamsWithParenthesis(fixer) {\n                const paramToken = sourceCode.getTokenAfter(firstTokenOfParam);\n\n                /*\n                 * ES8 allows Trailing commas in function parameter lists and calls\n                 * https://github.com/eslint/eslint/issues/8834\n                 */\n                const closingParenToken = sourceCode.getTokenAfter(paramToken, astUtils$1.isClosingParenToken);\n                const asyncToken = isAsync ? sourceCode.getTokenBefore(firstTokenOfParam) : null;\n                const shouldAddSpaceForAsync = asyncToken && (asyncToken.range[1] === firstTokenOfParam.range[0]);\n\n                return fixer.replaceTextRange([\n                    firstTokenOfParam.range[0],\n                    closingParenToken.range[1]\n                ], `${shouldAddSpaceForAsync ? \" \" : \"\"}${paramToken.value}`);\n            }\n\n            // \"as-needed\", { \"requireForBlockBody\": true }: x => x\n            if (\n                requireForBlockBody &&\n                node.params.length === 1 &&\n                node.params[0].type === \"Identifier\" &&\n                !node.params[0].typeAnnotation &&\n                node.body.type !== \"BlockStatement\" &&\n                !node.returnType\n            ) {\n                if (astUtils$1.isOpeningParenToken(firstTokenOfParam)) {\n                    context.report({\n                        node,\n                        messageId: \"unexpectedParensInline\",\n                        loc: getLocation$1(node),\n                        fix: fixParamsWithParenthesis\n                    });\n                }\n                return;\n            }\n\n            if (\n                requireForBlockBody &&\n                node.body.type === \"BlockStatement\"\n            ) {\n                if (!astUtils$1.isOpeningParenToken(firstTokenOfParam)) {\n                    context.report({\n                        node,\n                        messageId: \"expectedParensBlock\",\n                        loc: getLocation$1(node),\n                        fix(fixer) {\n                            return fixer.replaceText(firstTokenOfParam, `(${firstTokenOfParam.value})`);\n                        }\n                    });\n                }\n                return;\n            }\n\n            // \"as-needed\": x => x\n            if (asNeeded &&\n                node.params.length === 1 &&\n                node.params[0].type === \"Identifier\" &&\n                !node.params[0].typeAnnotation &&\n                !node.returnType\n            ) {\n                if (astUtils$1.isOpeningParenToken(firstTokenOfParam)) {\n                    context.report({\n                        node,\n                        messageId: \"unexpectedParens\",\n                        loc: getLocation$1(node),\n                        fix: fixParamsWithParenthesis\n                    });\n                }\n                return;\n            }\n\n            if (firstTokenOfParam.type === \"Identifier\") {\n                const after = sourceCode.getTokenAfter(firstTokenOfParam);\n\n                // (x) => x\n                if (after.value !== \")\") {\n                    context.report({\n                        node,\n                        messageId: \"expectedParens\",\n                        loc: getLocation$1(node),\n                        fix(fixer) {\n                            return fixer.replaceText(firstTokenOfParam, `(${firstTokenOfParam.value})`);\n                        }\n                    });\n                }\n            }\n        }\n\n        return {\n            ArrowFunctionExpression: parens\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar arrowSpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent spacing before and after the arrow in arrow functions\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/arrow-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    before: {\n                        type: \"boolean\",\n                        default: true\n                    },\n                    after: {\n                        type: \"boolean\",\n                        default: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            expectedBefore: \"Missing space before =>.\",\n            unexpectedBefore: \"Unexpected space before =>.\",\n\n            expectedAfter: \"Missing space after =>.\",\n            unexpectedAfter: \"Unexpected space after =>.\"\n        }\n    },\n\n    create(context) {\n\n        // merge rules with default\n        const rule = Object.assign({}, context.options[0]);\n\n        rule.before = rule.before !== false;\n        rule.after = rule.after !== false;\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Get tokens of arrow(`=>`) and before/after arrow.\n         * @param {ASTNode} node The arrow function node.\n         * @returns {Object} Tokens of arrow and before/after arrow.\n         */\n        function getTokens(node) {\n            const arrow = sourceCode.getTokenBefore(node.body, astUtils$1.isArrowToken);\n\n            return {\n                before: sourceCode.getTokenBefore(arrow),\n                arrow,\n                after: sourceCode.getTokenAfter(arrow)\n            };\n        }\n\n        /**\n         * Count spaces before/after arrow(`=>`) token.\n         * @param {Object} tokens Tokens before/after arrow.\n         * @returns {Object} count of space before/after arrow.\n         */\n        function countSpaces(tokens) {\n            const before = tokens.arrow.range[0] - tokens.before.range[1];\n            const after = tokens.after.range[0] - tokens.arrow.range[1];\n\n            return { before, after };\n        }\n\n        /**\n         * Determines whether space(s) before after arrow(`=>`) is satisfy rule.\n         * if before/after value is `true`, there should be space(s).\n         * if before/after value is `false`, there should be no space.\n         * @param {ASTNode} node The arrow function node.\n         * @returns {void}\n         */\n        function spaces(node) {\n            const tokens = getTokens(node);\n            const countSpace = countSpaces(tokens);\n\n            if (rule.before) {\n\n                // should be space(s) before arrow\n                if (countSpace.before === 0) {\n                    context.report({\n                        node: tokens.before,\n                        messageId: \"expectedBefore\",\n                        fix(fixer) {\n                            return fixer.insertTextBefore(tokens.arrow, \" \");\n                        }\n                    });\n                }\n            } else {\n\n                // should be no space before arrow\n                if (countSpace.before > 0) {\n                    context.report({\n                        node: tokens.before,\n                        messageId: \"unexpectedBefore\",\n                        fix(fixer) {\n                            return fixer.removeRange([tokens.before.range[1], tokens.arrow.range[0]]);\n                        }\n                    });\n                }\n            }\n\n            if (rule.after) {\n\n                // should be space(s) after arrow\n                if (countSpace.after === 0) {\n                    context.report({\n                        node: tokens.after,\n                        messageId: \"expectedAfter\",\n                        fix(fixer) {\n                            return fixer.insertTextAfter(tokens.arrow, \" \");\n                        }\n                    });\n                }\n            } else {\n\n                // should be no space after arrow\n                if (countSpace.after > 0) {\n                    context.report({\n                        node: tokens.after,\n                        messageId: \"unexpectedAfter\",\n                        fix(fixer) {\n                            return fixer.removeRange([tokens.arrow.range[1], tokens.after.range[0]]);\n                        }\n                    });\n                }\n            }\n        }\n\n        return {\n            ArrowFunctionExpression: spaces\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to check for \"block scoped\" variables by binding context\n * @author Matt DuVall <http://www.mattduvall.com>\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar blockScopedVar = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce the use of variables within the scope they are defined\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/block-scoped-var\"\n        },\n\n        schema: [],\n\n        messages: {\n            outOfScope: \"'{{name}}' used outside of binding context.\"\n        }\n    },\n\n    create(context) {\n        let stack = [];\n\n        /**\n         * Makes a block scope.\n         * @param {ASTNode} node A node of a scope.\n         * @returns {void}\n         */\n        function enterScope(node) {\n            stack.push(node.range);\n        }\n\n        /**\n         * Pops the last block scope.\n         * @returns {void}\n         */\n        function exitScope() {\n            stack.pop();\n        }\n\n        /**\n         * Reports a given reference.\n         * @param {eslint-scope.Reference} reference A reference to report.\n         * @returns {void}\n         */\n        function report(reference) {\n            const identifier = reference.identifier;\n\n            context.report({ node: identifier, messageId: \"outOfScope\", data: { name: identifier.name } });\n        }\n\n        /**\n         * Finds and reports references which are outside of valid scopes.\n         * @param {ASTNode} node A node to get variables.\n         * @returns {void}\n         */\n        function checkForVariables(node) {\n            if (node.kind !== \"var\") {\n                return;\n            }\n\n            // Defines a predicate to check whether or not a given reference is outside of valid scope.\n            const scopeRange = stack[stack.length - 1];\n\n            /**\n             * Check if a reference is out of scope\n             * @param {ASTNode} reference node to examine\n             * @returns {boolean} True is its outside the scope\n             * @private\n             */\n            function isOutsideOfScope(reference) {\n                const idRange = reference.identifier.range;\n\n                return idRange[0] < scopeRange[0] || idRange[1] > scopeRange[1];\n            }\n\n            // Gets declared variables, and checks its references.\n            const variables = context.getDeclaredVariables(node);\n\n            for (let i = 0; i < variables.length; ++i) {\n\n                // Reports.\n                variables[i]\n                    .references\n                    .filter(isOutsideOfScope)\n                    .forEach(report);\n            }\n        }\n\n        return {\n            Program(node) {\n                stack = [node.range];\n            },\n\n            // Manages scopes.\n            BlockStatement: enterScope,\n            \"BlockStatement:exit\": exitScope,\n            ForStatement: enterScope,\n            \"ForStatement:exit\": exitScope,\n            ForInStatement: enterScope,\n            \"ForInStatement:exit\": exitScope,\n            ForOfStatement: enterScope,\n            \"ForOfStatement:exit\": exitScope,\n            SwitchStatement: enterScope,\n            \"SwitchStatement:exit\": exitScope,\n            CatchClause: enterScope,\n            \"CatchClause:exit\": exitScope,\n\n            // Finds and reports references which are outside of valid scope.\n            VariableDeclaration: checkForVariables\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar blockSpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"disallow or enforce spaces inside of blocks after opening block and before closing block\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/block-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            { enum: [\"always\", \"never\"] }\n        ],\n\n        messages: {\n            missing: \"Requires a space {{location}} '{{token}}'.\",\n            extra: \"Unexpected space(s) {{location}} '{{token}}'.\"\n        }\n    },\n\n    create(context) {\n        const always = (context.options[0] !== \"never\"),\n            messageId = always ? \"missing\" : \"extra\",\n            sourceCode = context.getSourceCode();\n\n        /**\n         * Gets the open brace token from a given node.\n         * @param {ASTNode} node A BlockStatement/SwitchStatement node to get.\n         * @returns {Token} The token of the open brace.\n         */\n        function getOpenBrace(node) {\n            if (node.type === \"SwitchStatement\") {\n                if (node.cases.length > 0) {\n                    return sourceCode.getTokenBefore(node.cases[0]);\n                }\n                return sourceCode.getLastToken(node, 1);\n            }\n            return sourceCode.getFirstToken(node);\n        }\n\n        /**\n         * Checks whether or not:\n         *   - given tokens are on same line.\n         *   - there is/isn't a space between given tokens.\n         * @param {Token} left A token to check.\n         * @param {Token} right The token which is next to `left`.\n         * @returns {boolean}\n         *    When the option is `\"always\"`, `true` if there are one or more spaces between given tokens.\n         *    When the option is `\"never\"`, `true` if there are not any spaces between given tokens.\n         *    If given tokens are not on same line, it's always `true`.\n         */\n        function isValid(left, right) {\n            return (\n                !astUtils$1.isTokenOnSameLine(left, right) ||\n                sourceCode.isSpaceBetweenTokens(left, right) === always\n            );\n        }\n\n        /**\n         * Reports invalid spacing style inside braces.\n         * @param {ASTNode} node A BlockStatement/SwitchStatement node to get.\n         * @returns {void}\n         */\n        function checkSpacingInsideBraces(node) {\n\n            // Gets braces and the first/last token of content.\n            const openBrace = getOpenBrace(node);\n            const closeBrace = sourceCode.getLastToken(node);\n            const firstToken = sourceCode.getTokenAfter(openBrace, { includeComments: true });\n            const lastToken = sourceCode.getTokenBefore(closeBrace, { includeComments: true });\n\n            // Skip if the node is invalid or empty.\n            if (openBrace.type !== \"Punctuator\" ||\n                openBrace.value !== \"{\" ||\n                closeBrace.type !== \"Punctuator\" ||\n                closeBrace.value !== \"}\" ||\n                firstToken === closeBrace\n            ) {\n                return;\n            }\n\n            // Skip line comments for option never\n            if (!always && firstToken.type === \"Line\") {\n                return;\n            }\n\n            // Check.\n            if (!isValid(openBrace, firstToken)) {\n                context.report({\n                    node,\n                    loc: openBrace.loc.start,\n                    messageId,\n                    data: {\n                        location: \"after\",\n                        token: openBrace.value\n                    },\n                    fix(fixer) {\n                        if (always) {\n                            return fixer.insertTextBefore(firstToken, \" \");\n                        }\n\n                        return fixer.removeRange([openBrace.range[1], firstToken.range[0]]);\n                    }\n                });\n            }\n            if (!isValid(lastToken, closeBrace)) {\n                context.report({\n                    node,\n                    loc: closeBrace.loc.start,\n                    messageId,\n                    data: {\n                        location: \"before\",\n                        token: closeBrace.value\n                    },\n                    fix(fixer) {\n                        if (always) {\n                            return fixer.insertTextAfter(lastToken, \" \");\n                        }\n\n                        return fixer.removeRange([lastToken.range[1], closeBrace.range[0]]);\n                    }\n                });\n            }\n        }\n\n        return {\n            BlockStatement: checkSpacingInsideBraces,\n            SwitchStatement: checkSpacingInsideBraces\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar braceStyle = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent brace style for blocks\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/brace-style\"\n        },\n\n        schema: [\n            {\n                enum: [\"1tbs\", \"stroustrup\", \"allman\"]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    allowSingleLine: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        fixable: \"whitespace\",\n\n        messages: {\n            nextLineOpen: \"Opening curly brace does not appear on the same line as controlling statement.\",\n            sameLineOpen: \"Opening curly brace appears on the same line as controlling statement.\",\n            blockSameLine: \"Statement inside of curly braces should be on next line.\",\n            nextLineClose: \"Closing curly brace does not appear on the same line as the subsequent block.\",\n            singleLineClose: \"Closing curly brace should be on the same line as opening curly brace or on the line after the previous block.\",\n            sameLineClose: \"Closing curly brace appears on the same line as the subsequent block.\"\n        }\n    },\n\n    create(context) {\n        const style = context.options[0] || \"1tbs\",\n            params = context.options[1] || {},\n            sourceCode = context.getSourceCode();\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Fixes a place where a newline unexpectedly appears\n         * @param {Token} firstToken The token before the unexpected newline\n         * @param {Token} secondToken The token after the unexpected newline\n         * @returns {Function} A fixer function to remove the newlines between the tokens\n         */\n        function removeNewlineBetween(firstToken, secondToken) {\n            const textRange = [firstToken.range[1], secondToken.range[0]];\n            const textBetween = sourceCode.text.slice(textRange[0], textRange[1]);\n\n            // Don't do a fix if there is a comment between the tokens\n            if (textBetween.trim()) {\n                return null;\n            }\n            return fixer => fixer.replaceTextRange(textRange, \" \");\n        }\n\n        /**\n         * Validates a pair of curly brackets based on the user's config\n         * @param {Token} openingCurly The opening curly bracket\n         * @param {Token} closingCurly The closing curly bracket\n         * @returns {void}\n         */\n        function validateCurlyPair(openingCurly, closingCurly) {\n            const tokenBeforeOpeningCurly = sourceCode.getTokenBefore(openingCurly);\n            const tokenAfterOpeningCurly = sourceCode.getTokenAfter(openingCurly);\n            const tokenBeforeClosingCurly = sourceCode.getTokenBefore(closingCurly);\n            const singleLineException = params.allowSingleLine && astUtils$1.isTokenOnSameLine(openingCurly, closingCurly);\n\n            if (style !== \"allman\" && !astUtils$1.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurly)) {\n                context.report({\n                    node: openingCurly,\n                    messageId: \"nextLineOpen\",\n                    fix: removeNewlineBetween(tokenBeforeOpeningCurly, openingCurly)\n                });\n            }\n\n            if (style === \"allman\" && astUtils$1.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurly) && !singleLineException) {\n                context.report({\n                    node: openingCurly,\n                    messageId: \"sameLineOpen\",\n                    fix: fixer => fixer.insertTextBefore(openingCurly, \"\\n\")\n                });\n            }\n\n            if (astUtils$1.isTokenOnSameLine(openingCurly, tokenAfterOpeningCurly) && tokenAfterOpeningCurly !== closingCurly && !singleLineException) {\n                context.report({\n                    node: openingCurly,\n                    messageId: \"blockSameLine\",\n                    fix: fixer => fixer.insertTextAfter(openingCurly, \"\\n\")\n                });\n            }\n\n            if (tokenBeforeClosingCurly !== openingCurly && !singleLineException && astUtils$1.isTokenOnSameLine(tokenBeforeClosingCurly, closingCurly)) {\n                context.report({\n                    node: closingCurly,\n                    messageId: \"singleLineClose\",\n                    fix: fixer => fixer.insertTextBefore(closingCurly, \"\\n\")\n                });\n            }\n        }\n\n        /**\n         * Validates the location of a token that appears before a keyword (e.g. a newline before `else`)\n         * @param {Token} curlyToken The closing curly token. This is assumed to precede a keyword token (such as `else` or `finally`).\n         * @returns {void}\n         */\n        function validateCurlyBeforeKeyword(curlyToken) {\n            const keywordToken = sourceCode.getTokenAfter(curlyToken);\n\n            if (style === \"1tbs\" && !astUtils$1.isTokenOnSameLine(curlyToken, keywordToken)) {\n                context.report({\n                    node: curlyToken,\n                    messageId: \"nextLineClose\",\n                    fix: removeNewlineBetween(curlyToken, keywordToken)\n                });\n            }\n\n            if (style !== \"1tbs\" && astUtils$1.isTokenOnSameLine(curlyToken, keywordToken)) {\n                context.report({\n                    node: curlyToken,\n                    messageId: \"sameLineClose\",\n                    fix: fixer => fixer.insertTextAfter(curlyToken, \"\\n\")\n                });\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n            BlockStatement(node) {\n                if (!astUtils$1.STATEMENT_LIST_PARENTS.has(node.parent.type)) {\n                    validateCurlyPair(sourceCode.getFirstToken(node), sourceCode.getLastToken(node));\n                }\n            },\n            ClassBody(node) {\n                validateCurlyPair(sourceCode.getFirstToken(node), sourceCode.getLastToken(node));\n            },\n            SwitchStatement(node) {\n                const closingCurly = sourceCode.getLastToken(node);\n                const openingCurly = sourceCode.getTokenBefore(node.cases.length ? node.cases[0] : closingCurly);\n\n                validateCurlyPair(openingCurly, closingCurly);\n            },\n            IfStatement(node) {\n                if (node.consequent.type === \"BlockStatement\" && node.alternate) {\n\n                    // Handle the keyword after the `if` block (before `else`)\n                    validateCurlyBeforeKeyword(sourceCode.getLastToken(node.consequent));\n                }\n            },\n            TryStatement(node) {\n\n                // Handle the keyword after the `try` block (before `catch` or `finally`)\n                validateCurlyBeforeKeyword(sourceCode.getLastToken(node.block));\n\n                if (node.handler && node.finalizer) {\n\n                    // Handle the keyword after the `catch` block (before `finally`)\n                    validateCurlyBeforeKeyword(sourceCode.getLastToken(node.handler.body));\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Enforce return after a callback.\n * @author Jamund Ferguson\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar callbackReturn = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require `return` statements after callbacks\",\n            category: \"Node.js and CommonJS\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/callback-return\"\n        },\n\n        schema: [{\n            type: \"array\",\n            items: { type: \"string\" }\n        }],\n\n        messages: {\n            missingReturn: \"Expected return with your callback function.\"\n        }\n    },\n\n    create(context) {\n\n        const callbacks = context.options[0] || [\"callback\", \"cb\", \"next\"],\n            sourceCode = context.getSourceCode();\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Find the closest parent matching a list of types.\n         * @param {ASTNode} node The node whose parents we are searching\n         * @param {Array} types The node types to match\n         * @returns {ASTNode} The matched node or undefined.\n         */\n        function findClosestParentOfType(node, types) {\n            if (!node.parent) {\n                return null;\n            }\n            if (types.indexOf(node.parent.type) === -1) {\n                return findClosestParentOfType(node.parent, types);\n            }\n            return node.parent;\n        }\n\n        /**\n         * Check to see if a node contains only identifers\n         * @param {ASTNode} node The node to check\n         * @returns {boolean} Whether or not the node contains only identifers\n         */\n        function containsOnlyIdentifiers(node) {\n            if (node.type === \"Identifier\") {\n                return true;\n            }\n\n            if (node.type === \"MemberExpression\") {\n                if (node.object.type === \"Identifier\") {\n                    return true;\n                }\n                if (node.object.type === \"MemberExpression\") {\n                    return containsOnlyIdentifiers(node.object);\n                }\n            }\n\n            return false;\n        }\n\n        /**\n         * Check to see if a CallExpression is in our callback list.\n         * @param {ASTNode} node The node to check against our callback names list.\n         * @returns {boolean} Whether or not this function matches our callback name.\n         */\n        function isCallback(node) {\n            return containsOnlyIdentifiers(node.callee) && callbacks.indexOf(sourceCode.getText(node.callee)) > -1;\n        }\n\n        /**\n         * Determines whether or not the callback is part of a callback expression.\n         * @param {ASTNode} node The callback node\n         * @param {ASTNode} parentNode The expression node\n         * @returns {boolean} Whether or not this is part of a callback expression\n         */\n        function isCallbackExpression(node, parentNode) {\n\n            // ensure the parent node exists and is an expression\n            if (!parentNode || parentNode.type !== \"ExpressionStatement\") {\n                return false;\n            }\n\n            // cb()\n            if (parentNode.expression === node) {\n                return true;\n            }\n\n            // special case for cb && cb() and similar\n            if (parentNode.expression.type === \"BinaryExpression\" || parentNode.expression.type === \"LogicalExpression\") {\n                if (parentNode.expression.right === node) {\n                    return true;\n                }\n            }\n\n            return false;\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            CallExpression(node) {\n\n                // if we're not a callback we can return\n                if (!isCallback(node)) {\n                    return;\n                }\n\n                // find the closest block, return or loop\n                const closestBlock = findClosestParentOfType(node, [\"BlockStatement\", \"ReturnStatement\", \"ArrowFunctionExpression\"]) || {};\n\n                // if our parent is a return we know we're ok\n                if (closestBlock.type === \"ReturnStatement\") {\n                    return;\n                }\n\n                // arrow functions don't always have blocks and implicitly return\n                if (closestBlock.type === \"ArrowFunctionExpression\") {\n                    return;\n                }\n\n                // block statements are part of functions and most if statements\n                if (closestBlock.type === \"BlockStatement\") {\n\n                    // find the last item in the block\n                    const lastItem = closestBlock.body[closestBlock.body.length - 1];\n\n                    // if the callback is the last thing in a block that might be ok\n                    if (isCallbackExpression(node, lastItem)) {\n\n                        const parentType = closestBlock.parent.type;\n\n                        // but only if the block is part of a function\n                        if (parentType === \"FunctionExpression\" ||\n                            parentType === \"FunctionDeclaration\" ||\n                            parentType === \"ArrowFunctionExpression\"\n                        ) {\n                            return;\n                        }\n\n                    }\n\n                    // ending a block with a return is also ok\n                    if (lastItem.type === \"ReturnStatement\") {\n\n                        // but only if the callback is immediately before\n                        if (isCallbackExpression(node, closestBlock.body[closestBlock.body.length - 2])) {\n                            return;\n                        }\n                    }\n\n                }\n\n                // as long as you're the child of a function at this point you should be asked to return\n                if (findClosestParentOfType(node, [\"FunctionDeclaration\", \"FunctionExpression\", \"ArrowFunctionExpression\"])) {\n                    context.report({ node, messageId: \"missingReturn\" });\n                }\n\n            }\n\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag non-camelcased identifiers\n * @author Nicholas C. Zakas\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar camelcase = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce camelcase naming convention\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/camelcase\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    ignoreDestructuring: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    ignoreImports: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    properties: {\n                        enum: [\"always\", \"never\"]\n                    },\n                    allow: {\n                        type: \"array\",\n                        items: [\n                            {\n                                type: \"string\"\n                            }\n                        ],\n                        minItems: 0,\n                        uniqueItems: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            notCamelCase: \"Identifier '{{name}}' is not in camel case.\"\n        }\n    },\n\n    create(context) {\n\n        const options = context.options[0] || {};\n        let properties = options.properties || \"\";\n        const ignoreDestructuring = options.ignoreDestructuring;\n        const ignoreImports = options.ignoreImports;\n        const allow = options.allow || [];\n\n        if (properties !== \"always\" && properties !== \"never\") {\n            properties = \"always\";\n        }\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        // contains reported nodes to avoid reporting twice on destructuring with shorthand notation\n        const reported = [];\n        const ALLOWED_PARENT_TYPES = new Set([\"CallExpression\", \"NewExpression\"]);\n\n        /**\n         * Checks if a string contains an underscore and isn't all upper-case\n         * @param {string} name The string to check.\n         * @returns {boolean} if the string is underscored\n         * @private\n         */\n        function isUnderscored(name) {\n\n            // if there's an underscore, it might be A_CONSTANT, which is okay\n            return name.includes(\"_\") && name !== name.toUpperCase();\n        }\n\n        /**\n         * Checks if a string match the ignore list\n         * @param {string} name The string to check.\n         * @returns {boolean} if the string is ignored\n         * @private\n         */\n        function isAllowed(name) {\n            return allow.some(\n                entry => name === entry || name.match(new RegExp(entry, \"u\"))\n            );\n        }\n\n        /**\n         * Checks if a parent of a node is an ObjectPattern.\n         * @param {ASTNode} node The node to check.\n         * @returns {boolean} if the node is inside an ObjectPattern\n         * @private\n         */\n        function isInsideObjectPattern(node) {\n            let current = node;\n\n            while (current) {\n                const parent = current.parent;\n\n                if (parent && parent.type === \"Property\" && parent.computed && parent.key === current) {\n                    return false;\n                }\n\n                if (current.type === \"ObjectPattern\") {\n                    return true;\n                }\n\n                current = parent;\n            }\n\n            return false;\n        }\n\n        /**\n         * Reports an AST node as a rule violation.\n         * @param {ASTNode} node The node to report.\n         * @returns {void}\n         * @private\n         */\n        function report(node) {\n            if (!reported.includes(node)) {\n                reported.push(node);\n                context.report({ node, messageId: \"notCamelCase\", data: { name: node.name } });\n            }\n        }\n\n        return {\n\n            Identifier(node) {\n\n                /*\n                 * Leading and trailing underscores are commonly used to flag\n                 * private/protected identifiers, strip them before checking if underscored\n                 */\n                const name = node.name,\n                    nameIsUnderscored = isUnderscored(name.replace(/^_+|_+$/gu, \"\")),\n                    effectiveParent = (node.parent.type === \"MemberExpression\") ? node.parent.parent : node.parent;\n\n                // First, we ignore the node if it match the ignore list\n                if (isAllowed(name)) {\n                    return;\n                }\n\n                // MemberExpressions get special rules\n                if (node.parent.type === \"MemberExpression\") {\n\n                    // \"never\" check properties\n                    if (properties === \"never\") {\n                        return;\n                    }\n\n                    // Always report underscored object names\n                    if (node.parent.object.type === \"Identifier\" && node.parent.object.name === node.name && nameIsUnderscored) {\n                        report(node);\n\n                    // Report AssignmentExpressions only if they are the left side of the assignment\n                    } else if (effectiveParent.type === \"AssignmentExpression\" && nameIsUnderscored && (effectiveParent.right.type !== \"MemberExpression\" || effectiveParent.left.type === \"MemberExpression\" && effectiveParent.left.property.name === node.name)) {\n                        report(node);\n                    }\n\n                /*\n                 * Properties have their own rules, and\n                 * AssignmentPattern nodes can be treated like Properties:\n                 * e.g.: const { no_camelcased = false } = bar;\n                 */\n                } else if (node.parent.type === \"Property\" || node.parent.type === \"AssignmentPattern\") {\n\n                    if (node.parent.parent && node.parent.parent.type === \"ObjectPattern\") {\n                        if (node.parent.shorthand && node.parent.value.left && nameIsUnderscored) {\n                            report(node);\n                        }\n\n                        const assignmentKeyEqualsValue = node.parent.key.name === node.parent.value.name;\n\n                        if (isUnderscored(name) && node.parent.computed) {\n                            report(node);\n                        }\n\n                        // prevent checking righthand side of destructured object\n                        if (node.parent.key === node && node.parent.value !== node) {\n                            return;\n                        }\n\n                        const valueIsUnderscored = node.parent.value.name && nameIsUnderscored;\n\n                        // ignore destructuring if the option is set, unless a new identifier is created\n                        if (valueIsUnderscored && !(assignmentKeyEqualsValue && ignoreDestructuring)) {\n                            report(node);\n                        }\n                    }\n\n                    // \"never\" check properties or always ignore destructuring\n                    if (properties === \"never\" || (ignoreDestructuring && isInsideObjectPattern(node))) {\n                        return;\n                    }\n\n                    // don't check right hand side of AssignmentExpression to prevent duplicate warnings\n                    if (nameIsUnderscored && !ALLOWED_PARENT_TYPES.has(effectiveParent.type) && !(node.parent.right === node)) {\n                        report(node);\n                    }\n\n                // Check if it's an import specifier\n                } else if ([\"ImportSpecifier\", \"ImportNamespaceSpecifier\", \"ImportDefaultSpecifier\"].includes(node.parent.type)) {\n\n                    if (node.parent.type === \"ImportSpecifier\" && ignoreImports) {\n                        return;\n                    }\n\n                    // Report only if the local imported identifier is underscored\n                    if (\n                        node.parent.local &&\n                        node.parent.local.name === node.name &&\n                        nameIsUnderscored\n                    ) {\n                        report(node);\n                    }\n\n                // Report anything that is underscored that isn't a CallExpression\n                } else if (nameIsUnderscored && !ALLOWED_PARENT_TYPES.has(effectiveParent.type)) {\n                    report(node);\n                }\n            }\n\n        };\n\n    }\n};\n\n/**\n * @fileoverview Pattern for detecting any letter (even letters outside of ASCII).\n * NOTE: This file was generated using this script in JSCS based on the Unicode 7.0.0 standard: https://github.com/jscs-dev/node-jscs/blob/f5ed14427deb7e7aac84f3056a5aab2d9f3e563e/publish/helpers/generate-patterns.js\n * Do not edit this file by hand-- please use https://github.com/mathiasbynens/regenerate to regenerate the regular expression exported from this file.\n * @author Kevin Partington\n * @license MIT License (from JSCS). See below.\n */\n\nvar letters = /[A-Za-z\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B2\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16F1-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FCC\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6E5\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA78E\\uA790-\\uA7AD\\uA7B0\\uA7B1\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB5F\\uAB64\\uAB65\\uABC0-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDF00-\\uDF1F\\uDF30-\\uDF40\\uDF42-\\uDF49\\uDF50-\\uDF75\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF]|\\uD801[\\uDC00-\\uDC9D\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC60-\\uDC76\\uDC80-\\uDC9E\\uDD00-\\uDD15\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBE\\uDDBF\\uDE00\\uDE10-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE33\\uDE60-\\uDE7C\\uDE80-\\uDE9C\\uDEC0-\\uDEC7\\uDEC9-\\uDEE4\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF60-\\uDF72\\uDF80-\\uDF91]|\\uD803[\\uDC00-\\uDC48]|\\uD804[\\uDC03-\\uDC37\\uDC83-\\uDCAF\\uDCD0-\\uDCE8\\uDD03-\\uDD26\\uDD50-\\uDD72\\uDD76\\uDD83-\\uDDB2\\uDDC1-\\uDDC4\\uDDDA\\uDE00-\\uDE11\\uDE13-\\uDE2B\\uDEB0-\\uDEDE\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3D\\uDF5D-\\uDF61]|\\uD805[\\uDC80-\\uDCAF\\uDCC4\\uDCC5\\uDCC7\\uDD80-\\uDDAE\\uDE00-\\uDE2F\\uDE44\\uDE80-\\uDEAA]|\\uD806[\\uDCA0-\\uDCDF\\uDCFF\\uDEC0-\\uDEF8]|\\uD808[\\uDC00-\\uDF98]|[\\uD80C\\uD840-\\uD868\\uD86A-\\uD86C][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDED0-\\uDEED\\uDF00-\\uDF2F\\uDF40-\\uDF43\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDF00-\\uDF44\\uDF50\\uDF93-\\uDF9F]|\\uD82C[\\uDC00\\uDC01]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99]|\\uD835[\\uDC00-\\uDC54\\uDC56-\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD1E-\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD52-\\uDEA5\\uDEA8-\\uDEC0\\uDEC2-\\uDEDA\\uDEDC-\\uDEFA\\uDEFC-\\uDF14\\uDF16-\\uDF34\\uDF36-\\uDF4E\\uDF50-\\uDF6E\\uDF70-\\uDF88\\uDF8A-\\uDFA8\\uDFAA-\\uDFC2\\uDFC4-\\uDFCB]|\\uD83A[\\uDC00-\\uDCC4]|\\uD83B[\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD869[\\uDC00-\\uDED6\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF34\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D]|\\uD87E[\\uDC00-\\uDE1D]/u;\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst DEFAULT_IGNORE_PATTERN = astUtils$1.COMMENTS_IGNORE_PATTERN,\n    WHITESPACE = /\\s/gu,\n    MAYBE_URL = /^\\s*[^:/?#\\s]+:\\/\\/[^?#]/u; // TODO: Combine w/ max-len pattern?\n\n/*\n * Base schema body for defining the basic capitalization rule, ignorePattern,\n * and ignoreInlineComments values.\n * This can be used in a few different ways in the actual schema.\n */\nconst SCHEMA_BODY = {\n    type: \"object\",\n    properties: {\n        ignorePattern: {\n            type: \"string\"\n        },\n        ignoreInlineComments: {\n            type: \"boolean\"\n        },\n        ignoreConsecutiveComments: {\n            type: \"boolean\"\n        }\n    },\n    additionalProperties: false\n};\nconst DEFAULTS = {\n    ignorePattern: \"\",\n    ignoreInlineComments: false,\n    ignoreConsecutiveComments: false\n};\n\n/**\n * Get normalized options for either block or line comments from the given\n * user-provided options.\n * - If the user-provided options is just a string, returns a normalized\n *   set of options using default values for all other options.\n * - If the user-provided options is an object, then a normalized option\n *   set is returned. Options specified in overrides will take priority\n *   over options specified in the main options object, which will in\n *   turn take priority over the rule's defaults.\n * @param {Object|string} rawOptions The user-provided options.\n * @param {string} which Either \"line\" or \"block\".\n * @returns {Object} The normalized options.\n */\nfunction getNormalizedOptions(rawOptions, which) {\n    return Object.assign({}, DEFAULTS, rawOptions[which] || rawOptions);\n}\n\n/**\n * Get normalized options for block and line comments.\n * @param {Object|string} rawOptions The user-provided options.\n * @returns {Object} An object with \"Line\" and \"Block\" keys and corresponding\n * normalized options objects.\n */\nfunction getAllNormalizedOptions(rawOptions = {}) {\n    return {\n        Line: getNormalizedOptions(rawOptions, \"line\"),\n        Block: getNormalizedOptions(rawOptions, \"block\")\n    };\n}\n\n/**\n * Creates a regular expression for each ignorePattern defined in the rule\n * options.\n *\n * This is done in order to avoid invoking the RegExp constructor repeatedly.\n * @param {Object} normalizedOptions The normalized rule options.\n * @returns {void}\n */\nfunction createRegExpForIgnorePatterns(normalizedOptions) {\n    Object.keys(normalizedOptions).forEach(key => {\n        const ignorePatternStr = normalizedOptions[key].ignorePattern;\n\n        if (ignorePatternStr) {\n            const regExp = RegExp(`^\\\\s*(?:${ignorePatternStr})`, \"u\");\n\n            normalizedOptions[key].ignorePatternRegExp = regExp;\n        }\n    });\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar capitalizedComments = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce or disallow capitalization of the first letter of a comment\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/capitalized-comments\"\n        },\n\n        fixable: \"code\",\n\n        schema: [\n            { enum: [\"always\", \"never\"] },\n            {\n                oneOf: [\n                    SCHEMA_BODY,\n                    {\n                        type: \"object\",\n                        properties: {\n                            line: SCHEMA_BODY,\n                            block: SCHEMA_BODY\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ],\n\n        messages: {\n            unexpectedLowercaseComment: \"Comments should not begin with a lowercase character.\",\n            unexpectedUppercaseComment: \"Comments should not begin with an uppercase character.\"\n        }\n    },\n\n    create(context) {\n\n        const capitalize = context.options[0] || \"always\",\n            normalizedOptions = getAllNormalizedOptions(context.options[1]),\n            sourceCode = context.getSourceCode();\n\n        createRegExpForIgnorePatterns(normalizedOptions);\n\n        //----------------------------------------------------------------------\n        // Helpers\n        //----------------------------------------------------------------------\n\n        /**\n         * Checks whether a comment is an inline comment.\n         *\n         * For the purpose of this rule, a comment is inline if:\n         * 1. The comment is preceded by a token on the same line; and\n         * 2. The command is followed by a token on the same line.\n         *\n         * Note that the comment itself need not be single-line!\n         *\n         * Also, it follows from this definition that only block comments can\n         * be considered as possibly inline. This is because line comments\n         * would consume any following tokens on the same line as the comment.\n         * @param {ASTNode} comment The comment node to check.\n         * @returns {boolean} True if the comment is an inline comment, false\n         * otherwise.\n         */\n        function isInlineComment(comment) {\n            const previousToken = sourceCode.getTokenBefore(comment, { includeComments: true }),\n                nextToken = sourceCode.getTokenAfter(comment, { includeComments: true });\n\n            return Boolean(\n                previousToken &&\n                nextToken &&\n                comment.loc.start.line === previousToken.loc.end.line &&\n                comment.loc.end.line === nextToken.loc.start.line\n            );\n        }\n\n        /**\n         * Determine if a comment follows another comment.\n         * @param {ASTNode} comment The comment to check.\n         * @returns {boolean} True if the comment follows a valid comment.\n         */\n        function isConsecutiveComment(comment) {\n            const previousTokenOrComment = sourceCode.getTokenBefore(comment, { includeComments: true });\n\n            return Boolean(\n                previousTokenOrComment &&\n                [\"Block\", \"Line\"].indexOf(previousTokenOrComment.type) !== -1\n            );\n        }\n\n        /**\n         * Check a comment to determine if it is valid for this rule.\n         * @param {ASTNode} comment The comment node to process.\n         * @param {Object} options The options for checking this comment.\n         * @returns {boolean} True if the comment is valid, false otherwise.\n         */\n        function isCommentValid(comment, options) {\n\n            // 1. Check for default ignore pattern.\n            if (DEFAULT_IGNORE_PATTERN.test(comment.value)) {\n                return true;\n            }\n\n            // 2. Check for custom ignore pattern.\n            const commentWithoutAsterisks = comment.value\n                .replace(/\\*/gu, \"\");\n\n            if (options.ignorePatternRegExp && options.ignorePatternRegExp.test(commentWithoutAsterisks)) {\n                return true;\n            }\n\n            // 3. Check for inline comments.\n            if (options.ignoreInlineComments && isInlineComment(comment)) {\n                return true;\n            }\n\n            // 4. Is this a consecutive comment (and are we tolerating those)?\n            if (options.ignoreConsecutiveComments && isConsecutiveComment(comment)) {\n                return true;\n            }\n\n            // 5. Does the comment start with a possible URL?\n            if (MAYBE_URL.test(commentWithoutAsterisks)) {\n                return true;\n            }\n\n            // 6. Is the initial word character a letter?\n            const commentWordCharsOnly = commentWithoutAsterisks\n                .replace(WHITESPACE, \"\");\n\n            if (commentWordCharsOnly.length === 0) {\n                return true;\n            }\n\n            const firstWordChar = commentWordCharsOnly[0];\n\n            if (!letters.test(firstWordChar)) {\n                return true;\n            }\n\n            // 7. Check the case of the initial word character.\n            const isUppercase = firstWordChar !== firstWordChar.toLocaleLowerCase(),\n                isLowercase = firstWordChar !== firstWordChar.toLocaleUpperCase();\n\n            if (capitalize === \"always\" && isLowercase) {\n                return false;\n            }\n            if (capitalize === \"never\" && isUppercase) {\n                return false;\n            }\n\n            return true;\n        }\n\n        /**\n         * Process a comment to determine if it needs to be reported.\n         * @param {ASTNode} comment The comment node to process.\n         * @returns {void}\n         */\n        function processComment(comment) {\n            const options = normalizedOptions[comment.type],\n                commentValid = isCommentValid(comment, options);\n\n            if (!commentValid) {\n                const messageId = capitalize === \"always\"\n                    ? \"unexpectedLowercaseComment\"\n                    : \"unexpectedUppercaseComment\";\n\n                context.report({\n                    node: null, // Intentionally using loc instead\n                    loc: comment.loc,\n                    messageId,\n                    fix(fixer) {\n                        const match = comment.value.match(letters);\n\n                        return fixer.replaceTextRange(\n\n                            // Offset match.index by 2 to account for the first 2 characters that start the comment (// or /*)\n                            [comment.range[0] + match.index + 2, comment.range[0] + match.index + 3],\n                            capitalize === \"always\" ? match[0].toLocaleUpperCase() : match[0].toLocaleLowerCase()\n                        );\n                    }\n                });\n            }\n        }\n\n        //----------------------------------------------------------------------\n        // Public\n        //----------------------------------------------------------------------\n\n        return {\n            Program() {\n                const comments = sourceCode.getAllComments();\n\n                comments.filter(token => token.type !== \"Shebang\").forEach(processComment);\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar classMethodsUseThis = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce that class methods utilize `this`\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/class-methods-use-this\"\n        },\n\n        schema: [{\n            type: \"object\",\n            properties: {\n                exceptMethods: {\n                    type: \"array\",\n                    items: {\n                        type: \"string\"\n                    }\n                }\n            },\n            additionalProperties: false\n        }],\n\n        messages: {\n            missingThis: \"Expected 'this' to be used by class {{name}}.\"\n        }\n    },\n    create(context) {\n        const config = Object.assign({}, context.options[0]);\n        const exceptMethods = new Set(config.exceptMethods || []);\n\n        const stack = [];\n\n        /**\n         * Initializes the current context to false and pushes it onto the stack.\n         * These booleans represent whether 'this' has been used in the context.\n         * @returns {void}\n         * @private\n         */\n        function enterFunction() {\n            stack.push(false);\n        }\n\n        /**\n         * Check if the node is an instance method\n         * @param {ASTNode} node node to check\n         * @returns {boolean} True if its an instance method\n         * @private\n         */\n        function isInstanceMethod(node) {\n            return !node.static && node.kind !== \"constructor\" && node.type === \"MethodDefinition\";\n        }\n\n        /**\n         * Check if the node is an instance method not excluded by config\n         * @param {ASTNode} node node to check\n         * @returns {boolean} True if it is an instance method, and not excluded by config\n         * @private\n         */\n        function isIncludedInstanceMethod(node) {\n            return isInstanceMethod(node) &&\n                (node.computed || !exceptMethods.has(node.key.name));\n        }\n\n        /**\n         * Checks if we are leaving a function that is a method, and reports if 'this' has not been used.\n         * Static methods and the constructor are exempt.\n         * Then pops the context off the stack.\n         * @param {ASTNode} node A function node that was entered.\n         * @returns {void}\n         * @private\n         */\n        function exitFunction(node) {\n            const methodUsesThis = stack.pop();\n\n            if (isIncludedInstanceMethod(node.parent) && !methodUsesThis) {\n                context.report({\n                    node,\n                    messageId: \"missingThis\",\n                    data: {\n                        name: astUtils$1.getFunctionNameWithKind(node)\n                    }\n                });\n            }\n        }\n\n        /**\n         * Mark the current context as having used 'this'.\n         * @returns {void}\n         * @private\n         */\n        function markThisUsed() {\n            if (stack.length) {\n                stack[stack.length - 1] = true;\n            }\n        }\n\n        return {\n            FunctionDeclaration: enterFunction,\n            \"FunctionDeclaration:exit\": exitFunction,\n            FunctionExpression: enterFunction,\n            \"FunctionExpression:exit\": exitFunction,\n            ThisExpression: markThisUsed,\n            Super: markThisUsed\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst DEFAULT_OPTIONS = Object.freeze({\n    arrays: \"never\",\n    objects: \"never\",\n    imports: \"never\",\n    exports: \"never\",\n    functions: \"never\"\n});\n\n/**\n * Checks whether or not a trailing comma is allowed in a given node.\n * If the `lastItem` is `RestElement` or `RestProperty`, it disallows trailing commas.\n * @param {ASTNode} lastItem The node of the last element in the given node.\n * @returns {boolean} `true` if a trailing comma is allowed.\n */\nfunction isTrailingCommaAllowed(lastItem) {\n    return !(\n        lastItem.type === \"RestElement\" ||\n        lastItem.type === \"RestProperty\" ||\n        lastItem.type === \"ExperimentalRestProperty\"\n    );\n}\n\n/**\n * Normalize option value.\n * @param {string|Object|undefined} optionValue The 1st option value to normalize.\n * @param {number} ecmaVersion The normalized ECMAScript version.\n * @returns {Object} The normalized option value.\n */\nfunction normalizeOptions$2(optionValue, ecmaVersion) {\n    if (typeof optionValue === \"string\") {\n        return {\n            arrays: optionValue,\n            objects: optionValue,\n            imports: optionValue,\n            exports: optionValue,\n            functions: (!ecmaVersion || ecmaVersion < 8) ? \"ignore\" : optionValue\n        };\n    }\n    if (typeof optionValue === \"object\" && optionValue !== null) {\n        return {\n            arrays: optionValue.arrays || DEFAULT_OPTIONS.arrays,\n            objects: optionValue.objects || DEFAULT_OPTIONS.objects,\n            imports: optionValue.imports || DEFAULT_OPTIONS.imports,\n            exports: optionValue.exports || DEFAULT_OPTIONS.exports,\n            functions: optionValue.functions || DEFAULT_OPTIONS.functions\n        };\n    }\n\n    return DEFAULT_OPTIONS;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar commaDangle = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require or disallow trailing commas\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/comma-dangle\"\n        },\n\n        fixable: \"code\",\n\n        schema: {\n            definitions: {\n                value: {\n                    enum: [\n                        \"always-multiline\",\n                        \"always\",\n                        \"never\",\n                        \"only-multiline\"\n                    ]\n                },\n                valueWithIgnore: {\n                    enum: [\n                        \"always-multiline\",\n                        \"always\",\n                        \"ignore\",\n                        \"never\",\n                        \"only-multiline\"\n                    ]\n                }\n            },\n            type: \"array\",\n            items: [\n                {\n                    oneOf: [\n                        {\n                            $ref: \"#/definitions/value\"\n                        },\n                        {\n                            type: \"object\",\n                            properties: {\n                                arrays: { $ref: \"#/definitions/valueWithIgnore\" },\n                                objects: { $ref: \"#/definitions/valueWithIgnore\" },\n                                imports: { $ref: \"#/definitions/valueWithIgnore\" },\n                                exports: { $ref: \"#/definitions/valueWithIgnore\" },\n                                functions: { $ref: \"#/definitions/valueWithIgnore\" }\n                            },\n                            additionalProperties: false\n                        }\n                    ]\n                }\n            ]\n        },\n\n        messages: {\n            unexpected: \"Unexpected trailing comma.\",\n            missing: \"Missing trailing comma.\"\n        }\n    },\n\n    create(context) {\n        const options = normalizeOptions$2(context.options[0], context.parserOptions.ecmaVersion);\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Gets the last item of the given node.\n         * @param {ASTNode} node The node to get.\n         * @returns {ASTNode|null} The last node or null.\n         */\n        function getLastItem(node) {\n            switch (node.type) {\n                case \"ObjectExpression\":\n                case \"ObjectPattern\":\n                    return lodash.last(node.properties);\n                case \"ArrayExpression\":\n                case \"ArrayPattern\":\n                    return lodash.last(node.elements);\n                case \"ImportDeclaration\":\n                case \"ExportNamedDeclaration\":\n                    return lodash.last(node.specifiers);\n                case \"FunctionDeclaration\":\n                case \"FunctionExpression\":\n                case \"ArrowFunctionExpression\":\n                    return lodash.last(node.params);\n                case \"CallExpression\":\n                case \"NewExpression\":\n                    return lodash.last(node.arguments);\n                default:\n                    return null;\n            }\n        }\n\n        /**\n         * Gets the trailing comma token of the given node.\n         * If the trailing comma does not exist, this returns the token which is\n         * the insertion point of the trailing comma token.\n         * @param {ASTNode} node The node to get.\n         * @param {ASTNode} lastItem The last item of the node.\n         * @returns {Token} The trailing comma token or the insertion point.\n         */\n        function getTrailingToken(node, lastItem) {\n            switch (node.type) {\n                case \"ObjectExpression\":\n                case \"ArrayExpression\":\n                case \"CallExpression\":\n                case \"NewExpression\":\n                    return sourceCode.getLastToken(node, 1);\n                default: {\n                    const nextToken = sourceCode.getTokenAfter(lastItem);\n\n                    if (astUtils$1.isCommaToken(nextToken)) {\n                        return nextToken;\n                    }\n                    return sourceCode.getLastToken(lastItem);\n                }\n            }\n        }\n\n        /**\n         * Checks whether or not a given node is multiline.\n         * This rule handles a given node as multiline when the closing parenthesis\n         * and the last element are not on the same line.\n         * @param {ASTNode} node A node to check.\n         * @returns {boolean} `true` if the node is multiline.\n         */\n        function isMultiline(node) {\n            const lastItem = getLastItem(node);\n\n            if (!lastItem) {\n                return false;\n            }\n\n            const penultimateToken = getTrailingToken(node, lastItem);\n            const lastToken = sourceCode.getTokenAfter(penultimateToken);\n\n            return lastToken.loc.end.line !== penultimateToken.loc.end.line;\n        }\n\n        /**\n         * Reports a trailing comma if it exists.\n         * @param {ASTNode} node A node to check. Its type is one of\n         *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,\n         *   ImportDeclaration, and ExportNamedDeclaration.\n         * @returns {void}\n         */\n        function forbidTrailingComma(node) {\n            const lastItem = getLastItem(node);\n\n            if (!lastItem || (node.type === \"ImportDeclaration\" && lastItem.type !== \"ImportSpecifier\")) {\n                return;\n            }\n\n            const trailingToken = getTrailingToken(node, lastItem);\n\n            if (astUtils$1.isCommaToken(trailingToken)) {\n                context.report({\n                    node: lastItem,\n                    loc: trailingToken.loc,\n                    messageId: \"unexpected\",\n                    fix(fixer) {\n                        return fixer.remove(trailingToken);\n                    }\n                });\n            }\n        }\n\n        /**\n         * Reports the last element of a given node if it does not have a trailing\n         * comma.\n         *\n         * If a given node is `ArrayPattern` which has `RestElement`, the trailing\n         * comma is disallowed, so report if it exists.\n         * @param {ASTNode} node A node to check. Its type is one of\n         *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,\n         *   ImportDeclaration, and ExportNamedDeclaration.\n         * @returns {void}\n         */\n        function forceTrailingComma(node) {\n            const lastItem = getLastItem(node);\n\n            if (!lastItem || (node.type === \"ImportDeclaration\" && lastItem.type !== \"ImportSpecifier\")) {\n                return;\n            }\n            if (!isTrailingCommaAllowed(lastItem)) {\n                forbidTrailingComma(node);\n                return;\n            }\n\n            const trailingToken = getTrailingToken(node, lastItem);\n\n            if (trailingToken.value !== \",\") {\n                context.report({\n                    node: lastItem,\n                    loc: {\n                        start: trailingToken.loc.end,\n                        end: astUtils$1.getNextLocation(sourceCode, trailingToken.loc.end)\n                    },\n                    messageId: \"missing\",\n                    fix(fixer) {\n                        return fixer.insertTextAfter(trailingToken, \",\");\n                    }\n                });\n            }\n        }\n\n        /**\n         * If a given node is multiline, reports the last element of a given node\n         * when it does not have a trailing comma.\n         * Otherwise, reports a trailing comma if it exists.\n         * @param {ASTNode} node A node to check. Its type is one of\n         *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,\n         *   ImportDeclaration, and ExportNamedDeclaration.\n         * @returns {void}\n         */\n        function forceTrailingCommaIfMultiline(node) {\n            if (isMultiline(node)) {\n                forceTrailingComma(node);\n            } else {\n                forbidTrailingComma(node);\n            }\n        }\n\n        /**\n         * Only if a given node is not multiline, reports the last element of a given node\n         * when it does not have a trailing comma.\n         * Otherwise, reports a trailing comma if it exists.\n         * @param {ASTNode} node A node to check. Its type is one of\n         *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,\n         *   ImportDeclaration, and ExportNamedDeclaration.\n         * @returns {void}\n         */\n        function allowTrailingCommaIfMultiline(node) {\n            if (!isMultiline(node)) {\n                forbidTrailingComma(node);\n            }\n        }\n\n        const predicate = {\n            always: forceTrailingComma,\n            \"always-multiline\": forceTrailingCommaIfMultiline,\n            \"only-multiline\": allowTrailingCommaIfMultiline,\n            never: forbidTrailingComma,\n            ignore: lodash.noop\n        };\n\n        return {\n            ObjectExpression: predicate[options.objects],\n            ObjectPattern: predicate[options.objects],\n\n            ArrayExpression: predicate[options.arrays],\n            ArrayPattern: predicate[options.arrays],\n\n            ImportDeclaration: predicate[options.imports],\n\n            ExportNamedDeclaration: predicate[options.exports],\n\n            FunctionDeclaration: predicate[options.functions],\n            FunctionExpression: predicate[options.functions],\n            ArrowFunctionExpression: predicate[options.functions],\n            CallExpression: predicate[options.functions],\n            NewExpression: predicate[options.functions]\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar commaSpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent spacing before and after commas\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/comma-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    before: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    after: {\n                        type: \"boolean\",\n                        default: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            missing: \"A space is required {{loc}} ','.\",\n            unexpected: \"There should be no space {{loc}} ','.\"\n        }\n    },\n\n    create(context) {\n\n        const sourceCode = context.getSourceCode();\n        const tokensAndComments = sourceCode.tokensAndComments;\n\n        const options = {\n            before: context.options[0] ? context.options[0].before : false,\n            after: context.options[0] ? context.options[0].after : true\n        };\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        // list of comma tokens to ignore for the check of leading whitespace\n        const commaTokensToIgnore = [];\n\n        /**\n         * Reports a spacing error with an appropriate message.\n         * @param {ASTNode} node The binary expression node to report.\n         * @param {string} loc Is the error \"before\" or \"after\" the comma?\n         * @param {ASTNode} otherNode The node at the left or right of `node`\n         * @returns {void}\n         * @private\n         */\n        function report(node, loc, otherNode) {\n            context.report({\n                node,\n                fix(fixer) {\n                    if (options[loc]) {\n                        if (loc === \"before\") {\n                            return fixer.insertTextBefore(node, \" \");\n                        }\n                        return fixer.insertTextAfter(node, \" \");\n\n                    }\n                    let start, end;\n                    const newText = \"\";\n\n                    if (loc === \"before\") {\n                        start = otherNode.range[1];\n                        end = node.range[0];\n                    } else {\n                        start = node.range[1];\n                        end = otherNode.range[0];\n                    }\n\n                    return fixer.replaceTextRange([start, end], newText);\n\n                },\n                messageId: options[loc] ? \"missing\" : \"unexpected\",\n                data: {\n                    loc\n                }\n            });\n        }\n\n        /**\n         * Validates the spacing around a comma token.\n         * @param {Object} tokens The tokens to be validated.\n         * @param {Token} tokens.comma The token representing the comma.\n         * @param {Token} [tokens.left] The last token before the comma.\n         * @param {Token} [tokens.right] The first token after the comma.\n         * @param {Token|ASTNode} reportItem The item to use when reporting an error.\n         * @returns {void}\n         * @private\n         */\n        function validateCommaItemSpacing(tokens, reportItem) {\n            if (tokens.left && astUtils$1.isTokenOnSameLine(tokens.left, tokens.comma) &&\n                    (options.before !== sourceCode.isSpaceBetweenTokens(tokens.left, tokens.comma))\n            ) {\n                report(reportItem, \"before\", tokens.left);\n            }\n\n            if (tokens.right && astUtils$1.isClosingParenToken(tokens.right)) {\n                return;\n            }\n\n            if (tokens.right && !options.after && tokens.right.type === \"Line\") {\n                return;\n            }\n\n            if (tokens.right && astUtils$1.isTokenOnSameLine(tokens.comma, tokens.right) &&\n                    (options.after !== sourceCode.isSpaceBetweenTokens(tokens.comma, tokens.right))\n            ) {\n                report(reportItem, \"after\", tokens.right);\n            }\n        }\n\n        /**\n         * Adds null elements of the given ArrayExpression or ArrayPattern node to the ignore list.\n         * @param {ASTNode} node An ArrayExpression or ArrayPattern node.\n         * @returns {void}\n         */\n        function addNullElementsToIgnoreList(node) {\n            let previousToken = sourceCode.getFirstToken(node);\n\n            node.elements.forEach(element => {\n                let token;\n\n                if (element === null) {\n                    token = sourceCode.getTokenAfter(previousToken);\n\n                    if (astUtils$1.isCommaToken(token)) {\n                        commaTokensToIgnore.push(token);\n                    }\n                } else {\n                    token = sourceCode.getTokenAfter(element);\n                }\n\n                previousToken = token;\n            });\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            \"Program:exit\"() {\n                tokensAndComments.forEach((token, i) => {\n\n                    if (!astUtils$1.isCommaToken(token)) {\n                        return;\n                    }\n\n                    if (token && token.type === \"JSXText\") {\n                        return;\n                    }\n\n                    const previousToken = tokensAndComments[i - 1];\n                    const nextToken = tokensAndComments[i + 1];\n\n                    validateCommaItemSpacing({\n                        comma: token,\n                        left: astUtils$1.isCommaToken(previousToken) || commaTokensToIgnore.indexOf(token) > -1 ? null : previousToken,\n                        right: astUtils$1.isCommaToken(nextToken) ? null : nextToken\n                    }, token);\n                });\n            },\n            ArrayExpression: addNullElementsToIgnoreList,\n            ArrayPattern: addNullElementsToIgnoreList\n\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar commaStyle = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent comma style\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/comma-style\"\n        },\n\n        fixable: \"code\",\n\n        schema: [\n            {\n                enum: [\"first\", \"last\"]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    exceptions: {\n                        type: \"object\",\n                        additionalProperties: {\n                            type: \"boolean\"\n                        }\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            unexpectedLineBeforeAndAfterComma: \"Bad line breaking before and after ','.\",\n            expectedCommaFirst: \"',' should be placed first.\",\n            expectedCommaLast: \"',' should be placed last.\"\n        }\n    },\n\n    create(context) {\n        const style = context.options[0] || \"last\",\n            sourceCode = context.getSourceCode();\n        const exceptions = {\n            ArrayPattern: true,\n            ArrowFunctionExpression: true,\n            CallExpression: true,\n            FunctionDeclaration: true,\n            FunctionExpression: true,\n            ImportDeclaration: true,\n            ObjectPattern: true,\n            NewExpression: true\n        };\n\n        if (context.options.length === 2 && Object.prototype.hasOwnProperty.call(context.options[1], \"exceptions\")) {\n            const keys = Object.keys(context.options[1].exceptions);\n\n            for (let i = 0; i < keys.length; i++) {\n                exceptions[keys[i]] = context.options[1].exceptions[keys[i]];\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Modified text based on the style\n         * @param {string} styleType Style type\n         * @param {string} text Source code text\n         * @returns {string} modified text\n         * @private\n         */\n        function getReplacedText(styleType, text) {\n            switch (styleType) {\n                case \"between\":\n                    return `,${text.replace(astUtils$1.LINEBREAK_MATCHER, \"\")}`;\n\n                case \"first\":\n                    return `${text},`;\n\n                case \"last\":\n                    return `,${text}`;\n\n                default:\n                    return \"\";\n            }\n        }\n\n        /**\n         * Determines the fixer function for a given style.\n         * @param {string} styleType comma style\n         * @param {ASTNode} previousItemToken The token to check.\n         * @param {ASTNode} commaToken The token to check.\n         * @param {ASTNode} currentItemToken The token to check.\n         * @returns {Function} Fixer function\n         * @private\n         */\n        function getFixerFunction(styleType, previousItemToken, commaToken, currentItemToken) {\n            const text =\n                sourceCode.text.slice(previousItemToken.range[1], commaToken.range[0]) +\n                sourceCode.text.slice(commaToken.range[1], currentItemToken.range[0]);\n            const range = [previousItemToken.range[1], currentItemToken.range[0]];\n\n            return function(fixer) {\n                return fixer.replaceTextRange(range, getReplacedText(styleType, text));\n            };\n        }\n\n        /**\n         * Validates the spacing around single items in lists.\n         * @param {Token} previousItemToken The last token from the previous item.\n         * @param {Token} commaToken The token representing the comma.\n         * @param {Token} currentItemToken The first token of the current item.\n         * @param {Token} reportItem The item to use when reporting an error.\n         * @returns {void}\n         * @private\n         */\n        function validateCommaItemSpacing(previousItemToken, commaToken, currentItemToken, reportItem) {\n\n            // if single line\n            if (astUtils$1.isTokenOnSameLine(commaToken, currentItemToken) &&\n                    astUtils$1.isTokenOnSameLine(previousItemToken, commaToken)) ; else if (!astUtils$1.isTokenOnSameLine(commaToken, currentItemToken) &&\n                    !astUtils$1.isTokenOnSameLine(previousItemToken, commaToken)) {\n\n                const comment = sourceCode.getCommentsAfter(commaToken)[0];\n                const styleType = comment && comment.type === \"Block\" && astUtils$1.isTokenOnSameLine(commaToken, comment)\n                    ? style\n                    : \"between\";\n\n                // lone comma\n                context.report({\n                    node: reportItem,\n                    loc: {\n                        line: commaToken.loc.end.line,\n                        column: commaToken.loc.start.column\n                    },\n                    messageId: \"unexpectedLineBeforeAndAfterComma\",\n                    fix: getFixerFunction(styleType, previousItemToken, commaToken, currentItemToken)\n                });\n\n            } else if (style === \"first\" && !astUtils$1.isTokenOnSameLine(commaToken, currentItemToken)) {\n\n                context.report({\n                    node: reportItem,\n                    messageId: \"expectedCommaFirst\",\n                    fix: getFixerFunction(style, previousItemToken, commaToken, currentItemToken)\n                });\n\n            } else if (style === \"last\" && astUtils$1.isTokenOnSameLine(commaToken, currentItemToken)) {\n\n                context.report({\n                    node: reportItem,\n                    loc: {\n                        line: commaToken.loc.end.line,\n                        column: commaToken.loc.end.column\n                    },\n                    messageId: \"expectedCommaLast\",\n                    fix: getFixerFunction(style, previousItemToken, commaToken, currentItemToken)\n                });\n            }\n        }\n\n        /**\n         * Checks the comma placement with regards to a declaration/property/element\n         * @param {ASTNode} node The binary expression node to check\n         * @param {string} property The property of the node containing child nodes.\n         * @private\n         * @returns {void}\n         */\n        function validateComma(node, property) {\n            const items = node[property],\n                arrayLiteral = (node.type === \"ArrayExpression\" || node.type === \"ArrayPattern\");\n\n            if (items.length > 1 || arrayLiteral) {\n\n                // seed as opening [\n                let previousItemToken = sourceCode.getFirstToken(node);\n\n                items.forEach(item => {\n                    const commaToken = item ? sourceCode.getTokenBefore(item) : previousItemToken,\n                        currentItemToken = item ? sourceCode.getFirstToken(item) : sourceCode.getTokenAfter(commaToken),\n                        reportItem = item || currentItemToken;\n\n                    /*\n                     * This works by comparing three token locations:\n                     * - previousItemToken is the last token of the previous item\n                     * - commaToken is the location of the comma before the current item\n                     * - currentItemToken is the first token of the current item\n                     *\n                     * These values get switched around if item is undefined.\n                     * previousItemToken will refer to the last token not belonging\n                     * to the current item, which could be a comma or an opening\n                     * square bracket. currentItemToken could be a comma.\n                     *\n                     * All comparisons are done based on these tokens directly, so\n                     * they are always valid regardless of an undefined item.\n                     */\n                    if (astUtils$1.isCommaToken(commaToken)) {\n                        validateCommaItemSpacing(previousItemToken, commaToken,\n                            currentItemToken, reportItem);\n                    }\n\n                    if (item) {\n                        const tokenAfterItem = sourceCode.getTokenAfter(item, astUtils$1.isNotClosingParenToken);\n\n                        previousItemToken = tokenAfterItem\n                            ? sourceCode.getTokenBefore(tokenAfterItem)\n                            : sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1];\n                    }\n                });\n\n                /*\n                 * Special case for array literals that have empty last items, such\n                 * as [ 1, 2, ]. These arrays only have two items show up in the\n                 * AST, so we need to look at the token to verify that there's no\n                 * dangling comma.\n                 */\n                if (arrayLiteral) {\n\n                    const lastToken = sourceCode.getLastToken(node),\n                        nextToLastToken = sourceCode.getTokenBefore(lastToken);\n\n                    if (astUtils$1.isCommaToken(nextToLastToken)) {\n                        validateCommaItemSpacing(\n                            sourceCode.getTokenBefore(nextToLastToken),\n                            nextToLastToken,\n                            lastToken,\n                            lastToken\n                        );\n                    }\n                }\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        const nodes = {};\n\n        if (!exceptions.VariableDeclaration) {\n            nodes.VariableDeclaration = function(node) {\n                validateComma(node, \"declarations\");\n            };\n        }\n        if (!exceptions.ObjectExpression) {\n            nodes.ObjectExpression = function(node) {\n                validateComma(node, \"properties\");\n            };\n        }\n        if (!exceptions.ObjectPattern) {\n            nodes.ObjectPattern = function(node) {\n                validateComma(node, \"properties\");\n            };\n        }\n        if (!exceptions.ArrayExpression) {\n            nodes.ArrayExpression = function(node) {\n                validateComma(node, \"elements\");\n            };\n        }\n        if (!exceptions.ArrayPattern) {\n            nodes.ArrayPattern = function(node) {\n                validateComma(node, \"elements\");\n            };\n        }\n        if (!exceptions.FunctionDeclaration) {\n            nodes.FunctionDeclaration = function(node) {\n                validateComma(node, \"params\");\n            };\n        }\n        if (!exceptions.FunctionExpression) {\n            nodes.FunctionExpression = function(node) {\n                validateComma(node, \"params\");\n            };\n        }\n        if (!exceptions.ArrowFunctionExpression) {\n            nodes.ArrowFunctionExpression = function(node) {\n                validateComma(node, \"params\");\n            };\n        }\n        if (!exceptions.CallExpression) {\n            nodes.CallExpression = function(node) {\n                validateComma(node, \"arguments\");\n            };\n        }\n        if (!exceptions.ImportDeclaration) {\n            nodes.ImportDeclaration = function(node) {\n                validateComma(node, \"specifiers\");\n            };\n        }\n        if (!exceptions.NewExpression) {\n            nodes.NewExpression = function(node) {\n                validateComma(node, \"arguments\");\n            };\n        }\n\n        return nodes;\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar complexity = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce a maximum cyclomatic complexity allowed in a program\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/complexity\"\n        },\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        type: \"integer\",\n                        minimum: 0\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            maximum: {\n                                type: \"integer\",\n                                minimum: 0\n                            },\n                            max: {\n                                type: \"integer\",\n                                minimum: 0\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ],\n\n        messages: {\n            complex: \"{{name}} has a complexity of {{complexity}}. Maximum allowed is {{max}}.\"\n        }\n    },\n\n    create(context) {\n        const option = context.options[0];\n        let THRESHOLD = 20;\n\n        if (\n            typeof option === \"object\" &&\n            (Object.prototype.hasOwnProperty.call(option, \"maximum\") || Object.prototype.hasOwnProperty.call(option, \"max\"))\n        ) {\n            THRESHOLD = option.maximum || option.max;\n        } else if (typeof option === \"number\") {\n            THRESHOLD = option;\n        }\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        // Using a stack to store complexity (handling nested functions)\n        const fns = [];\n\n        /**\n         * When parsing a new function, store it in our function stack\n         * @returns {void}\n         * @private\n         */\n        function startFunction() {\n            fns.push(1);\n        }\n\n        /**\n         * Evaluate the node at the end of function\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function endFunction(node) {\n            const name = lodash.upperFirst(astUtils$1.getFunctionNameWithKind(node));\n            const complexity = fns.pop();\n\n            if (complexity > THRESHOLD) {\n                context.report({\n                    node,\n                    messageId: \"complex\",\n                    data: { name, complexity, max: THRESHOLD }\n                });\n            }\n        }\n\n        /**\n         * Increase the complexity of the function in context\n         * @returns {void}\n         * @private\n         */\n        function increaseComplexity() {\n            if (fns.length) {\n                fns[fns.length - 1]++;\n            }\n        }\n\n        /**\n         * Increase the switch complexity in context\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function increaseSwitchComplexity(node) {\n\n            // Avoiding `default`\n            if (node.test) {\n                increaseComplexity();\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n            FunctionDeclaration: startFunction,\n            FunctionExpression: startFunction,\n            ArrowFunctionExpression: startFunction,\n            \"FunctionDeclaration:exit\": endFunction,\n            \"FunctionExpression:exit\": endFunction,\n            \"ArrowFunctionExpression:exit\": endFunction,\n\n            CatchClause: increaseComplexity,\n            ConditionalExpression: increaseComplexity,\n            LogicalExpression: increaseComplexity,\n            ForStatement: increaseComplexity,\n            ForInStatement: increaseComplexity,\n            ForOfStatement: increaseComplexity,\n            IfStatement: increaseComplexity,\n            SwitchCase: increaseSwitchComplexity,\n            WhileStatement: increaseComplexity,\n            DoWhileStatement: increaseComplexity\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar computedPropertySpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent spacing inside computed property brackets\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/computed-property-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                enum: [\"always\", \"never\"]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    enforceForClassMembers: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            unexpectedSpaceBefore: \"There should be no space before '{{tokenValue}}'.\",\n            unexpectedSpaceAfter: \"There should be no space after '{{tokenValue}}'.\",\n\n            missingSpaceBefore: \"A space is required before '{{tokenValue}}'.\",\n            missingSpaceAfter: \"A space is required after '{{tokenValue}}'.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const propertyNameMustBeSpaced = context.options[0] === \"always\"; // default is \"never\"\n        const enforceForClassMembers = context.options[1] && context.options[1].enforceForClassMembers;\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Reports that there shouldn't be a space after the first token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @param {Token} tokenAfter The token after `token`.\n         * @returns {void}\n         */\n        function reportNoBeginningSpace(node, token, tokenAfter) {\n            context.report({\n                node,\n                loc: token.loc.start,\n                messageId: \"unexpectedSpaceAfter\",\n                data: {\n                    tokenValue: token.value\n                },\n                fix(fixer) {\n                    return fixer.removeRange([token.range[1], tokenAfter.range[0]]);\n                }\n            });\n        }\n\n        /**\n         * Reports that there shouldn't be a space before the last token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @param {Token} tokenBefore The token before `token`.\n         * @returns {void}\n         */\n        function reportNoEndingSpace(node, token, tokenBefore) {\n            context.report({\n                node,\n                loc: token.loc.start,\n                messageId: \"unexpectedSpaceBefore\",\n                data: {\n                    tokenValue: token.value\n                },\n                fix(fixer) {\n                    return fixer.removeRange([tokenBefore.range[1], token.range[0]]);\n                }\n            });\n        }\n\n        /**\n         * Reports that there should be a space after the first token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportRequiredBeginningSpace(node, token) {\n            context.report({\n                node,\n                loc: token.loc.start,\n                messageId: \"missingSpaceAfter\",\n                data: {\n                    tokenValue: token.value\n                },\n                fix(fixer) {\n                    return fixer.insertTextAfter(token, \" \");\n                }\n            });\n        }\n\n        /**\n         * Reports that there should be a space before the last token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportRequiredEndingSpace(node, token) {\n            context.report({\n                node,\n                loc: token.loc.start,\n                messageId: \"missingSpaceBefore\",\n                data: {\n                    tokenValue: token.value\n                },\n                fix(fixer) {\n                    return fixer.insertTextBefore(token, \" \");\n                }\n            });\n        }\n\n        /**\n         * Returns a function that checks the spacing of a node on the property name\n         * that was passed in.\n         * @param {string} propertyName The property on the node to check for spacing\n         * @returns {Function} A function that will check spacing on a node\n         */\n        function checkSpacing(propertyName) {\n            return function(node) {\n                if (!node.computed) {\n                    return;\n                }\n\n                const property = node[propertyName];\n\n                const before = sourceCode.getTokenBefore(property, astUtils$1.isOpeningBracketToken),\n                    first = sourceCode.getTokenAfter(before, { includeComments: true }),\n                    after = sourceCode.getTokenAfter(property, astUtils$1.isClosingBracketToken),\n                    last = sourceCode.getTokenBefore(after, { includeComments: true });\n\n                if (astUtils$1.isTokenOnSameLine(before, first)) {\n                    if (propertyNameMustBeSpaced) {\n                        if (!sourceCode.isSpaceBetweenTokens(before, first) && astUtils$1.isTokenOnSameLine(before, first)) {\n                            reportRequiredBeginningSpace(node, before);\n                        }\n                    } else {\n                        if (sourceCode.isSpaceBetweenTokens(before, first)) {\n                            reportNoBeginningSpace(node, before, first);\n                        }\n                    }\n                }\n\n                if (astUtils$1.isTokenOnSameLine(last, after)) {\n                    if (propertyNameMustBeSpaced) {\n                        if (!sourceCode.isSpaceBetweenTokens(last, after) && astUtils$1.isTokenOnSameLine(last, after)) {\n                            reportRequiredEndingSpace(node, after);\n                        }\n                    } else {\n                        if (sourceCode.isSpaceBetweenTokens(last, after)) {\n                            reportNoEndingSpace(node, after, last);\n                        }\n                    }\n                }\n            };\n        }\n\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        const listeners = {\n            Property: checkSpacing(\"key\"),\n            MemberExpression: checkSpacing(\"property\")\n        };\n\n        if (enforceForClassMembers) {\n            listeners.MethodDefinition = checkSpacing(\"key\");\n        }\n\n        return listeners;\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not a given node is an `Identifier` node which was named a given name.\n * @param {ASTNode} node A node to check.\n * @param {string} name An expected name of the node.\n * @returns {boolean} `true` if the node is an `Identifier` node which was named as expected.\n */\nfunction isIdentifier$1(node, name) {\n    return node.type === \"Identifier\" && node.name === name;\n}\n\n/**\n * Checks whether or not a given code path segment is unreachable.\n * @param {CodePathSegment} segment A CodePathSegment to check.\n * @returns {boolean} `true` if the segment is unreachable.\n */\nfunction isUnreachable(segment) {\n    return !segment.reachable;\n}\n\n/**\n * Checks whether a given node is a `constructor` method in an ES6 class\n * @param {ASTNode} node A node to check\n * @returns {boolean} `true` if the node is a `constructor` method\n */\nfunction isClassConstructor(node) {\n    return node.type === \"FunctionExpression\" &&\n        node.parent &&\n        node.parent.type === \"MethodDefinition\" &&\n        node.parent.kind === \"constructor\";\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar consistentReturn = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require `return` statements to either always or never specify values\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/consistent-return\"\n        },\n\n        schema: [{\n            type: \"object\",\n            properties: {\n                treatUndefinedAsUnspecified: {\n                    type: \"boolean\",\n                    default: false\n                }\n            },\n            additionalProperties: false\n        }],\n\n        messages: {\n            missingReturn: \"Expected to return a value at the end of {{name}}.\",\n            missingReturnValue: \"{{name}} expected a return value.\",\n            unexpectedReturnValue: \"{{name}} expected no return value.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options[0] || {};\n        const treatUndefinedAsUnspecified = options.treatUndefinedAsUnspecified === true;\n        let funcInfo = null;\n\n        /**\n         * Checks whether of not the implicit returning is consistent if the last\n         * code path segment is reachable.\n         * @param {ASTNode} node A program/function node to check.\n         * @returns {void}\n         */\n        function checkLastSegment(node) {\n            let loc, name;\n\n            /*\n             * Skip if it expected no return value or unreachable.\n             * When unreachable, all paths are returned or thrown.\n             */\n            if (!funcInfo.hasReturnValue ||\n                funcInfo.codePath.currentSegments.every(isUnreachable) ||\n                astUtils$1.isES5Constructor(node) ||\n                isClassConstructor(node)\n            ) {\n                return;\n            }\n\n            // Adjust a location and a message.\n            if (node.type === \"Program\") {\n\n                // The head of program.\n                loc = { line: 1, column: 0 };\n                name = \"program\";\n            } else if (node.type === \"ArrowFunctionExpression\") {\n\n                // `=>` token\n                loc = context.getSourceCode().getTokenBefore(node.body, astUtils$1.isArrowToken).loc.start;\n            } else if (\n                node.parent.type === \"MethodDefinition\" ||\n                (node.parent.type === \"Property\" && node.parent.method)\n            ) {\n\n                // Method name.\n                loc = node.parent.key.loc.start;\n            } else {\n\n                // Function name or `function` keyword.\n                loc = (node.id || node).loc.start;\n            }\n\n            if (!name) {\n                name = astUtils$1.getFunctionNameWithKind(node);\n            }\n\n            // Reports.\n            context.report({\n                node,\n                loc,\n                messageId: \"missingReturn\",\n                data: { name }\n            });\n        }\n\n        return {\n\n            // Initializes/Disposes state of each code path.\n            onCodePathStart(codePath, node) {\n                funcInfo = {\n                    upper: funcInfo,\n                    codePath,\n                    hasReturn: false,\n                    hasReturnValue: false,\n                    messageId: \"\",\n                    node\n                };\n            },\n            onCodePathEnd() {\n                funcInfo = funcInfo.upper;\n            },\n\n            // Reports a given return statement if it's inconsistent.\n            ReturnStatement(node) {\n                const argument = node.argument;\n                let hasReturnValue = Boolean(argument);\n\n                if (treatUndefinedAsUnspecified && hasReturnValue) {\n                    hasReturnValue = !isIdentifier$1(argument, \"undefined\") && argument.operator !== \"void\";\n                }\n\n                if (!funcInfo.hasReturn) {\n                    funcInfo.hasReturn = true;\n                    funcInfo.hasReturnValue = hasReturnValue;\n                    funcInfo.messageId = hasReturnValue ? \"missingReturnValue\" : \"unexpectedReturnValue\";\n                    funcInfo.data = {\n                        name: funcInfo.node.type === \"Program\"\n                            ? \"Program\"\n                            : lodash.upperFirst(astUtils$1.getFunctionNameWithKind(funcInfo.node))\n                    };\n                } else if (funcInfo.hasReturnValue !== hasReturnValue) {\n                    context.report({\n                        node,\n                        messageId: funcInfo.messageId,\n                        data: funcInfo.data\n                    });\n                }\n            },\n\n            // Reports a given program/function if the implicit returning is not consistent.\n            \"Program:exit\": checkLastSegment,\n            \"FunctionDeclaration:exit\": checkLastSegment,\n            \"FunctionExpression:exit\": checkLastSegment,\n            \"ArrowFunctionExpression:exit\": checkLastSegment\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to enforce consistent naming of \"this\" context variables\n * @author Raphael Pigulla\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar consistentThis = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce consistent naming when capturing the current execution context\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/consistent-this\"\n        },\n\n        schema: {\n            type: \"array\",\n            items: {\n                type: \"string\",\n                minLength: 1\n            },\n            uniqueItems: true\n        },\n\n        messages: {\n            aliasNotAssignedToThis: \"Designated alias '{{name}}' is not assigned to 'this'.\",\n            unexpectedAlias: \"Unexpected alias '{{name}}' for 'this'.\"\n        }\n    },\n\n    create(context) {\n        let aliases = [];\n\n        if (context.options.length === 0) {\n            aliases.push(\"that\");\n        } else {\n            aliases = context.options;\n        }\n\n        /**\n         * Reports that a variable declarator or assignment expression is assigning\n         * a non-'this' value to the specified alias.\n         * @param {ASTNode} node The assigning node.\n         * @param {string}  name the name of the alias that was incorrectly used.\n         * @returns {void}\n         */\n        function reportBadAssignment(node, name) {\n            context.report({ node, messageId: \"aliasNotAssignedToThis\", data: { name } });\n        }\n\n        /**\n         * Checks that an assignment to an identifier only assigns 'this' to the\n         * appropriate alias, and the alias is only assigned to 'this'.\n         * @param {ASTNode} node The assigning node.\n         * @param {Identifier} name The name of the variable assigned to.\n         * @param {Expression} value The value of the assignment.\n         * @returns {void}\n         */\n        function checkAssignment(node, name, value) {\n            const isThis = value.type === \"ThisExpression\";\n\n            if (aliases.indexOf(name) !== -1) {\n                if (!isThis || node.operator && node.operator !== \"=\") {\n                    reportBadAssignment(node, name);\n                }\n            } else if (isThis) {\n                context.report({ node, messageId: \"unexpectedAlias\", data: { name } });\n            }\n        }\n\n        /**\n         * Ensures that a variable declaration of the alias in a program or function\n         * is assigned to the correct value.\n         * @param {string} alias alias the check the assignment of.\n         * @param {Object} scope scope of the current code we are checking.\n         * @private\n         * @returns {void}\n         */\n        function checkWasAssigned(alias, scope) {\n            const variable = scope.set.get(alias);\n\n            if (!variable) {\n                return;\n            }\n\n            if (variable.defs.some(def => def.node.type === \"VariableDeclarator\" &&\n                def.node.init !== null)) {\n                return;\n            }\n\n            /*\n             * The alias has been declared and not assigned: check it was\n             * assigned later in the same scope.\n             */\n            if (!variable.references.some(reference => {\n                const write = reference.writeExpr;\n\n                return (\n                    reference.from === scope &&\n                    write && write.type === \"ThisExpression\" &&\n                    write.parent.operator === \"=\"\n                );\n            })) {\n                variable.defs.map(def => def.node).forEach(node => {\n                    reportBadAssignment(node, alias);\n                });\n            }\n        }\n\n        /**\n         * Check each alias to ensure that is was assinged to the correct value.\n         * @returns {void}\n         */\n        function ensureWasAssigned() {\n            const scope = context.getScope();\n\n            aliases.forEach(alias => {\n                checkWasAssigned(alias, scope);\n            });\n        }\n\n        return {\n            \"Program:exit\": ensureWasAssigned,\n            \"FunctionExpression:exit\": ensureWasAssigned,\n            \"FunctionDeclaration:exit\": ensureWasAssigned,\n\n            VariableDeclarator(node) {\n                const id = node.id;\n                const isDestructuring =\n                    id.type === \"ArrayPattern\" || id.type === \"ObjectPattern\";\n\n                if (node.init !== null && !isDestructuring) {\n                    checkAssignment(node, id.name, node.init);\n                }\n            },\n\n            AssignmentExpression(node) {\n                if (node.left.type === \"Identifier\") {\n                    checkAssignment(node, node.left.name, node.right);\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview A rule to verify `super()` callings in constructor.\n * @author Toru Nagashima\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether a given code path segment is reachable or not.\n * @param {CodePathSegment} segment A code path segment to check.\n * @returns {boolean} `true` if the segment is reachable.\n */\nfunction isReachable$1(segment) {\n    return segment.reachable;\n}\n\n/**\n * Checks whether or not a given node is a constructor.\n * @param {ASTNode} node A node to check. This node type is one of\n *   `Program`, `FunctionDeclaration`, `FunctionExpression`, and\n *   `ArrowFunctionExpression`.\n * @returns {boolean} `true` if the node is a constructor.\n */\nfunction isConstructorFunction(node) {\n    return (\n        node.type === \"FunctionExpression\" &&\n        node.parent.type === \"MethodDefinition\" &&\n        node.parent.kind === \"constructor\"\n    );\n}\n\n/**\n * Checks whether a given node can be a constructor or not.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} `true` if the node can be a constructor.\n */\nfunction isPossibleConstructor(node) {\n    if (!node) {\n        return false;\n    }\n\n    switch (node.type) {\n        case \"ClassExpression\":\n        case \"FunctionExpression\":\n        case \"ThisExpression\":\n        case \"MemberExpression\":\n        case \"CallExpression\":\n        case \"NewExpression\":\n        case \"YieldExpression\":\n        case \"TaggedTemplateExpression\":\n        case \"MetaProperty\":\n            return true;\n\n        case \"Identifier\":\n            return node.name !== \"undefined\";\n\n        case \"AssignmentExpression\":\n            return isPossibleConstructor(node.right);\n\n        case \"LogicalExpression\":\n            return (\n                isPossibleConstructor(node.left) ||\n                isPossibleConstructor(node.right)\n            );\n\n        case \"ConditionalExpression\":\n            return (\n                isPossibleConstructor(node.alternate) ||\n                isPossibleConstructor(node.consequent)\n            );\n\n        case \"SequenceExpression\": {\n            const lastExpression = node.expressions[node.expressions.length - 1];\n\n            return isPossibleConstructor(lastExpression);\n        }\n\n        default:\n            return false;\n    }\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar constructorSuper = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"require `super()` calls in constructors\",\n            category: \"ECMAScript 6\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/constructor-super\"\n        },\n\n        schema: [],\n\n        messages: {\n            missingSome: \"Lacked a call of 'super()' in some code paths.\",\n            missingAll: \"Expected to call 'super()'.\",\n\n            duplicate: \"Unexpected duplicate 'super()'.\",\n            badSuper: \"Unexpected 'super()' because 'super' is not a constructor.\",\n            unexpected: \"Unexpected 'super()'.\"\n        }\n    },\n\n    create(context) {\n\n        /*\n         * {{hasExtends: boolean, scope: Scope, codePath: CodePath}[]}\n         * Information for each constructor.\n         * - upper:      Information of the upper constructor.\n         * - hasExtends: A flag which shows whether own class has a valid `extends`\n         *               part.\n         * - scope:      The scope of own class.\n         * - codePath:   The code path object of the constructor.\n         */\n        let funcInfo = null;\n\n        /*\n         * {Map<string, {calledInSomePaths: boolean, calledInEveryPaths: boolean}>}\n         * Information for each code path segment.\n         * - calledInSomePaths:  A flag of be called `super()` in some code paths.\n         * - calledInEveryPaths: A flag of be called `super()` in all code paths.\n         * - validNodes:\n         */\n        let segInfoMap = Object.create(null);\n\n        /**\n         * Gets the flag which shows `super()` is called in some paths.\n         * @param {CodePathSegment} segment A code path segment to get.\n         * @returns {boolean} The flag which shows `super()` is called in some paths\n         */\n        function isCalledInSomePath(segment) {\n            return segment.reachable && segInfoMap[segment.id].calledInSomePaths;\n        }\n\n        /**\n         * Gets the flag which shows `super()` is called in all paths.\n         * @param {CodePathSegment} segment A code path segment to get.\n         * @returns {boolean} The flag which shows `super()` is called in all paths.\n         */\n        function isCalledInEveryPath(segment) {\n\n            /*\n             * If specific segment is the looped segment of the current segment,\n             * skip the segment.\n             * If not skipped, this never becomes true after a loop.\n             */\n            if (segment.nextSegments.length === 1 &&\n                segment.nextSegments[0].isLoopedPrevSegment(segment)\n            ) {\n                return true;\n            }\n            return segment.reachable && segInfoMap[segment.id].calledInEveryPaths;\n        }\n\n        return {\n\n            /**\n             * Stacks a constructor information.\n             * @param {CodePath} codePath A code path which was started.\n             * @param {ASTNode} node The current node.\n             * @returns {void}\n             */\n            onCodePathStart(codePath, node) {\n                if (isConstructorFunction(node)) {\n\n                    // Class > ClassBody > MethodDefinition > FunctionExpression\n                    const classNode = node.parent.parent.parent;\n                    const superClass = classNode.superClass;\n\n                    funcInfo = {\n                        upper: funcInfo,\n                        isConstructor: true,\n                        hasExtends: Boolean(superClass),\n                        superIsConstructor: isPossibleConstructor(superClass),\n                        codePath\n                    };\n                } else {\n                    funcInfo = {\n                        upper: funcInfo,\n                        isConstructor: false,\n                        hasExtends: false,\n                        superIsConstructor: false,\n                        codePath\n                    };\n                }\n            },\n\n            /**\n             * Pops a constructor information.\n             * And reports if `super()` lacked.\n             * @param {CodePath} codePath A code path which was ended.\n             * @param {ASTNode} node The current node.\n             * @returns {void}\n             */\n            onCodePathEnd(codePath, node) {\n                const hasExtends = funcInfo.hasExtends;\n\n                // Pop.\n                funcInfo = funcInfo.upper;\n\n                if (!hasExtends) {\n                    return;\n                }\n\n                // Reports if `super()` lacked.\n                const segments = codePath.returnedSegments;\n                const calledInEveryPaths = segments.every(isCalledInEveryPath);\n                const calledInSomePaths = segments.some(isCalledInSomePath);\n\n                if (!calledInEveryPaths) {\n                    context.report({\n                        messageId: calledInSomePaths\n                            ? \"missingSome\"\n                            : \"missingAll\",\n                        node: node.parent\n                    });\n                }\n            },\n\n            /**\n             * Initialize information of a given code path segment.\n             * @param {CodePathSegment} segment A code path segment to initialize.\n             * @returns {void}\n             */\n            onCodePathSegmentStart(segment) {\n                if (!(funcInfo && funcInfo.isConstructor && funcInfo.hasExtends)) {\n                    return;\n                }\n\n                // Initialize info.\n                const info = segInfoMap[segment.id] = {\n                    calledInSomePaths: false,\n                    calledInEveryPaths: false,\n                    validNodes: []\n                };\n\n                // When there are previous segments, aggregates these.\n                const prevSegments = segment.prevSegments;\n\n                if (prevSegments.length > 0) {\n                    info.calledInSomePaths = prevSegments.some(isCalledInSomePath);\n                    info.calledInEveryPaths = prevSegments.every(isCalledInEveryPath);\n                }\n            },\n\n            /**\n             * Update information of the code path segment when a code path was\n             * looped.\n             * @param {CodePathSegment} fromSegment The code path segment of the\n             *      end of a loop.\n             * @param {CodePathSegment} toSegment A code path segment of the head\n             *      of a loop.\n             * @returns {void}\n             */\n            onCodePathSegmentLoop(fromSegment, toSegment) {\n                if (!(funcInfo && funcInfo.isConstructor && funcInfo.hasExtends)) {\n                    return;\n                }\n\n                // Update information inside of the loop.\n                const isRealLoop = toSegment.prevSegments.length >= 2;\n\n                funcInfo.codePath.traverseSegments(\n                    { first: toSegment, last: fromSegment },\n                    segment => {\n                        const info = segInfoMap[segment.id];\n                        const prevSegments = segment.prevSegments;\n\n                        // Updates flags.\n                        info.calledInSomePaths = prevSegments.some(isCalledInSomePath);\n                        info.calledInEveryPaths = prevSegments.every(isCalledInEveryPath);\n\n                        // If flags become true anew, reports the valid nodes.\n                        if (info.calledInSomePaths || isRealLoop) {\n                            const nodes = info.validNodes;\n\n                            info.validNodes = [];\n\n                            for (let i = 0; i < nodes.length; ++i) {\n                                const node = nodes[i];\n\n                                context.report({\n                                    messageId: \"duplicate\",\n                                    node\n                                });\n                            }\n                        }\n                    }\n                );\n            },\n\n            /**\n             * Checks for a call of `super()`.\n             * @param {ASTNode} node A CallExpression node to check.\n             * @returns {void}\n             */\n            \"CallExpression:exit\"(node) {\n                if (!(funcInfo && funcInfo.isConstructor)) {\n                    return;\n                }\n\n                // Skips except `super()`.\n                if (node.callee.type !== \"Super\") {\n                    return;\n                }\n\n                // Reports if needed.\n                if (funcInfo.hasExtends) {\n                    const segments = funcInfo.codePath.currentSegments;\n                    let duplicate = false;\n                    let info = null;\n\n                    for (let i = 0; i < segments.length; ++i) {\n                        const segment = segments[i];\n\n                        if (segment.reachable) {\n                            info = segInfoMap[segment.id];\n\n                            duplicate = duplicate || info.calledInSomePaths;\n                            info.calledInSomePaths = info.calledInEveryPaths = true;\n                        }\n                    }\n\n                    if (info) {\n                        if (duplicate) {\n                            context.report({\n                                messageId: \"duplicate\",\n                                node\n                            });\n                        } else if (!funcInfo.superIsConstructor) {\n                            context.report({\n                                messageId: \"badSuper\",\n                                node\n                            });\n                        } else {\n                            info.validNodes.push(node);\n                        }\n                    }\n                } else if (funcInfo.codePath.currentSegments.some(isReachable$1)) {\n                    context.report({\n                        messageId: \"unexpected\",\n                        node\n                    });\n                }\n            },\n\n            /**\n             * Set the mark to the returned path as `super()` was called.\n             * @param {ASTNode} node A ReturnStatement node to check.\n             * @returns {void}\n             */\n            ReturnStatement(node) {\n                if (!(funcInfo && funcInfo.isConstructor && funcInfo.hasExtends)) {\n                    return;\n                }\n\n                // Skips if no argument.\n                if (!node.argument) {\n                    return;\n                }\n\n                // Returning argument is a substitute of 'super()'.\n                const segments = funcInfo.codePath.currentSegments;\n\n                for (let i = 0; i < segments.length; ++i) {\n                    const segment = segments[i];\n\n                    if (segment.reachable) {\n                        const info = segInfoMap[segment.id];\n\n                        info.calledInSomePaths = info.calledInEveryPaths = true;\n                    }\n                }\n            },\n\n            /**\n             * Resets state.\n             * @returns {void}\n             */\n            \"Program:exit\"() {\n                segInfoMap = Object.create(null);\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar curly = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce consistent brace style for all control statements\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/curly\"\n        },\n\n        schema: {\n            anyOf: [\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"all\"]\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 1\n                },\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"multi\", \"multi-line\", \"multi-or-nest\"]\n                        },\n                        {\n                            enum: [\"consistent\"]\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 2\n                }\n            ]\n        },\n\n        fixable: \"code\",\n\n        messages: {\n            missingCurlyAfter: \"Expected { after '{{name}}'.\",\n            missingCurlyAfterCondition: \"Expected { after '{{name}}' condition.\",\n            unexpectedCurlyAfter: \"Unnecessary { after '{{name}}'.\",\n            unexpectedCurlyAfterCondition: \"Unnecessary { after '{{name}}' condition.\"\n        }\n    },\n\n    create(context) {\n\n        const multiOnly = (context.options[0] === \"multi\");\n        const multiLine = (context.options[0] === \"multi-line\");\n        const multiOrNest = (context.options[0] === \"multi-or-nest\");\n        const consistent = (context.options[1] === \"consistent\");\n\n        const sourceCode = context.getSourceCode();\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Determines if a given node is a one-liner that's on the same line as it's preceding code.\n         * @param {ASTNode} node The node to check.\n         * @returns {boolean} True if the node is a one-liner that's on the same line as it's preceding code.\n         * @private\n         */\n        function isCollapsedOneLiner(node) {\n            const before = sourceCode.getTokenBefore(node);\n            const last = sourceCode.getLastToken(node);\n            const lastExcludingSemicolon = astUtils$1.isSemicolonToken(last) ? sourceCode.getTokenBefore(last) : last;\n\n            return before.loc.start.line === lastExcludingSemicolon.loc.end.line;\n        }\n\n        /**\n         * Determines if a given node is a one-liner.\n         * @param {ASTNode} node The node to check.\n         * @returns {boolean} True if the node is a one-liner.\n         * @private\n         */\n        function isOneLiner(node) {\n            if (node.type === \"EmptyStatement\") {\n                return true;\n            }\n\n            const first = sourceCode.getFirstToken(node);\n            const last = sourceCode.getLastToken(node);\n            const lastExcludingSemicolon = astUtils$1.isSemicolonToken(last) ? sourceCode.getTokenBefore(last) : last;\n\n            return first.loc.start.line === lastExcludingSemicolon.loc.end.line;\n        }\n\n        /**\n         * Determines if the given node is a lexical declaration (let, const, function, or class)\n         * @param {ASTNode} node The node to check\n         * @returns {boolean} True if the node is a lexical declaration\n         * @private\n         */\n        function isLexicalDeclaration(node) {\n            if (node.type === \"VariableDeclaration\") {\n                return node.kind === \"const\" || node.kind === \"let\";\n            }\n\n            return node.type === \"FunctionDeclaration\" || node.type === \"ClassDeclaration\";\n        }\n\n        /**\n         * Checks if the given token is an `else` token or not.\n         * @param {Token} token The token to check.\n         * @returns {boolean} `true` if the token is an `else` token.\n         */\n        function isElseKeywordToken(token) {\n            return token.value === \"else\" && token.type === \"Keyword\";\n        }\n\n        /**\n         * Gets the `else` keyword token of a given `IfStatement` node.\n         * @param {ASTNode} node A `IfStatement` node to get.\n         * @returns {Token} The `else` keyword token.\n         */\n        function getElseKeyword(node) {\n            return node.alternate && sourceCode.getFirstTokenBetween(node.consequent, node.alternate, isElseKeywordToken);\n        }\n\n        /**\n         * Checks a given IfStatement node requires braces of the consequent chunk.\n         * This returns `true` when below:\n         *\n         * 1. The given node has the `alternate` node.\n         * 2. There is a `IfStatement` which doesn't have `alternate` node in the\n         *    trailing statement chain of the `consequent` node.\n         * @param {ASTNode} node A IfStatement node to check.\n         * @returns {boolean} `true` if the node requires braces of the consequent chunk.\n         */\n        function requiresBraceOfConsequent(node) {\n            if (node.alternate && node.consequent.type === \"BlockStatement\") {\n                if (node.consequent.body.length >= 2) {\n                    return true;\n                }\n\n                for (\n                    let currentNode = node.consequent.body[0];\n                    currentNode;\n                    currentNode = astUtils$1.getTrailingStatement(currentNode)\n                ) {\n                    if (currentNode.type === \"IfStatement\" && !currentNode.alternate) {\n                        return true;\n                    }\n                }\n            }\n\n            return false;\n        }\n\n        /**\n         * Determines if a semicolon needs to be inserted after removing a set of curly brackets, in order to avoid a SyntaxError.\n         * @param {Token} closingBracket The } token\n         * @returns {boolean} `true` if a semicolon needs to be inserted after the last statement in the block.\n         */\n        function needsSemicolon(closingBracket) {\n            const tokenBefore = sourceCode.getTokenBefore(closingBracket);\n            const tokenAfter = sourceCode.getTokenAfter(closingBracket);\n            const lastBlockNode = sourceCode.getNodeByRangeIndex(tokenBefore.range[0]);\n\n            if (astUtils$1.isSemicolonToken(tokenBefore)) {\n\n                // If the last statement already has a semicolon, don't add another one.\n                return false;\n            }\n\n            if (!tokenAfter) {\n\n                // If there are no statements after this block, there is no need to add a semicolon.\n                return false;\n            }\n\n            if (lastBlockNode.type === \"BlockStatement\" && lastBlockNode.parent.type !== \"FunctionExpression\" && lastBlockNode.parent.type !== \"ArrowFunctionExpression\") {\n\n                /*\n                 * If the last node surrounded by curly brackets is a BlockStatement (other than a FunctionExpression or an ArrowFunctionExpression),\n                 * don't insert a semicolon. Otherwise, the semicolon would be parsed as a separate statement, which would cause\n                 * a SyntaxError if it was followed by `else`.\n                 */\n                return false;\n            }\n\n            if (tokenBefore.loc.end.line === tokenAfter.loc.start.line) {\n\n                // If the next token is on the same line, insert a semicolon.\n                return true;\n            }\n\n            if (/^[([/`+-]/u.test(tokenAfter.value)) {\n\n                // If the next token starts with a character that would disrupt ASI, insert a semicolon.\n                return true;\n            }\n\n            if (tokenBefore.type === \"Punctuator\" && (tokenBefore.value === \"++\" || tokenBefore.value === \"--\")) {\n\n                // If the last token is ++ or --, insert a semicolon to avoid disrupting ASI.\n                return true;\n            }\n\n            // Otherwise, do not insert a semicolon.\n            return false;\n        }\n\n        /**\n         * Prepares to check the body of a node to see if it's a block statement.\n         * @param {ASTNode} node The node to report if there's a problem.\n         * @param {ASTNode} body The body node to check for blocks.\n         * @param {string} name The name to report if there's a problem.\n         * @param {{ condition: boolean }} opts Options to pass to the report functions\n         * @returns {Object} a prepared check object, with \"actual\", \"expected\", \"check\" properties.\n         *   \"actual\" will be `true` or `false` whether the body is already a block statement.\n         *   \"expected\" will be `true` or `false` if the body should be a block statement or not, or\n         *   `null` if it doesn't matter, depending on the rule options. It can be modified to change\n         *   the final behavior of \"check\".\n         *   \"check\" will be a function reporting appropriate problems depending on the other\n         *   properties.\n         */\n        function prepareCheck(node, body, name, opts) {\n            const hasBlock = (body.type === \"BlockStatement\");\n            let expected = null;\n\n            if (node.type === \"IfStatement\" && node.consequent === body && requiresBraceOfConsequent(node)) {\n                expected = true;\n            } else if (multiOnly) {\n                if (hasBlock && body.body.length === 1 && !isLexicalDeclaration(body.body[0])) {\n                    expected = false;\n                }\n            } else if (multiLine) {\n                if (!isCollapsedOneLiner(body)) {\n                    expected = true;\n                }\n            } else if (multiOrNest) {\n                if (hasBlock && body.body.length === 1 && isOneLiner(body.body[0])) {\n                    const leadingComments = sourceCode.getCommentsBefore(body.body[0]);\n                    const isLexDef = isLexicalDeclaration(body.body[0]);\n\n                    if (isLexDef) {\n                        expected = true;\n                    } else {\n                        expected = leadingComments.length > 0;\n                    }\n                } else if (!isOneLiner(body)) {\n                    expected = true;\n                }\n            } else {\n                expected = true;\n            }\n\n            return {\n                actual: hasBlock,\n                expected,\n                check() {\n                    if (this.expected !== null && this.expected !== this.actual) {\n                        if (this.expected) {\n                            context.report({\n                                node,\n                                loc: (name !== \"else\" ? node : getElseKeyword(node)).loc.start,\n                                messageId: opts && opts.condition ? \"missingCurlyAfterCondition\" : \"missingCurlyAfter\",\n                                data: {\n                                    name\n                                },\n                                fix: fixer => fixer.replaceText(body, `{${sourceCode.getText(body)}}`)\n                            });\n                        } else {\n                            context.report({\n                                node,\n                                loc: (name !== \"else\" ? node : getElseKeyword(node)).loc.start,\n                                messageId: opts && opts.condition ? \"unexpectedCurlyAfterCondition\" : \"unexpectedCurlyAfter\",\n                                data: {\n                                    name\n                                },\n                                fix(fixer) {\n\n                                    /*\n                                     * `do while` expressions sometimes need a space to be inserted after `do`.\n                                     * e.g. `do{foo()} while (bar)` should be corrected to `do foo() while (bar)`\n                                     */\n                                    const needsPrecedingSpace = node.type === \"DoWhileStatement\" &&\n                                        sourceCode.getTokenBefore(body).range[1] === body.range[0] &&\n                                        !astUtils$1.canTokensBeAdjacent(\"do\", sourceCode.getFirstToken(body, { skip: 1 }));\n\n                                    const openingBracket = sourceCode.getFirstToken(body);\n                                    const closingBracket = sourceCode.getLastToken(body);\n                                    const lastTokenInBlock = sourceCode.getTokenBefore(closingBracket);\n\n                                    if (needsSemicolon(closingBracket)) {\n\n                                        /*\n                                         * If removing braces would cause a SyntaxError due to multiple statements on the same line (or\n                                         * change the semantics of the code due to ASI), don't perform a fix.\n                                         */\n                                        return null;\n                                    }\n\n                                    const resultingBodyText = sourceCode.getText().slice(openingBracket.range[1], lastTokenInBlock.range[0]) +\n                                        sourceCode.getText(lastTokenInBlock) +\n                                        sourceCode.getText().slice(lastTokenInBlock.range[1], closingBracket.range[0]);\n\n                                    return fixer.replaceText(body, (needsPrecedingSpace ? \" \" : \"\") + resultingBodyText);\n                                }\n                            });\n                        }\n                    }\n                }\n            };\n        }\n\n        /**\n         * Prepares to check the bodies of a \"if\", \"else if\" and \"else\" chain.\n         * @param {ASTNode} node The first IfStatement node of the chain.\n         * @returns {Object[]} prepared checks for each body of the chain. See `prepareCheck` for more\n         *   information.\n         */\n        function prepareIfChecks(node) {\n            const preparedChecks = [];\n\n            for (let currentNode = node; currentNode; currentNode = currentNode.alternate) {\n                preparedChecks.push(prepareCheck(currentNode, currentNode.consequent, \"if\", { condition: true }));\n                if (currentNode.alternate && currentNode.alternate.type !== \"IfStatement\") {\n                    preparedChecks.push(prepareCheck(currentNode, currentNode.alternate, \"else\"));\n                    break;\n                }\n            }\n\n            if (consistent) {\n\n                /*\n                 * If any node should have or already have braces, make sure they\n                 * all have braces.\n                 * If all nodes shouldn't have braces, make sure they don't.\n                 */\n                const expected = preparedChecks.some(preparedCheck => {\n                    if (preparedCheck.expected !== null) {\n                        return preparedCheck.expected;\n                    }\n                    return preparedCheck.actual;\n                });\n\n                preparedChecks.forEach(preparedCheck => {\n                    preparedCheck.expected = expected;\n                });\n            }\n\n            return preparedChecks;\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            IfStatement(node) {\n                if (node.parent.type !== \"IfStatement\") {\n                    prepareIfChecks(node).forEach(preparedCheck => {\n                        preparedCheck.check();\n                    });\n                }\n            },\n\n            WhileStatement(node) {\n                prepareCheck(node, node.body, \"while\", { condition: true }).check();\n            },\n\n            DoWhileStatement(node) {\n                prepareCheck(node, node.body, \"do\").check();\n            },\n\n            ForStatement(node) {\n                prepareCheck(node, node.body, \"for\", { condition: true }).check();\n            },\n\n            ForInStatement(node) {\n                prepareCheck(node, node.body, \"for-in\").check();\n            },\n\n            ForOfStatement(node) {\n                prepareCheck(node, node.body, \"for-of\").check();\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview require default case in switch statements\n * @author Aliaksei Shytkin\n */\n\nconst DEFAULT_COMMENT_PATTERN = /^no default$/iu;\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar defaultCase = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require `default` cases in `switch` statements\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/default-case\"\n        },\n\n        schema: [{\n            type: \"object\",\n            properties: {\n                commentPattern: {\n                    type: \"string\"\n                }\n            },\n            additionalProperties: false\n        }],\n\n        messages: {\n            missingDefaultCase: \"Expected a default case.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options[0] || {};\n        const commentPattern = options.commentPattern\n            ? new RegExp(options.commentPattern, \"u\")\n            : DEFAULT_COMMENT_PATTERN;\n\n        const sourceCode = context.getSourceCode();\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Shortcut to get last element of array\n         * @param  {*[]} collection Array\n         * @returns {*} Last element\n         */\n        function last(collection) {\n            return collection[collection.length - 1];\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n\n            SwitchStatement(node) {\n\n                if (!node.cases.length) {\n\n                    /*\n                     * skip check of empty switch because there is no easy way\n                     * to extract comments inside it now\n                     */\n                    return;\n                }\n\n                const hasDefault = node.cases.some(v => v.test === null);\n\n                if (!hasDefault) {\n\n                    let comment;\n\n                    const lastCase = last(node.cases);\n                    const comments = sourceCode.getCommentsAfter(lastCase);\n\n                    if (comments.length) {\n                        comment = last(comments);\n                    }\n\n                    if (!comment || !commentPattern.test(comment.value.trim())) {\n                        context.report({ node, messageId: \"missingDefaultCase\" });\n                    }\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview enforce default parameters to be last\n * @author Chiawen Chen\n */\n\nvar defaultParamLast = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce default parameters to be last\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/default-param-last\"\n        },\n\n        schema: [],\n\n        messages: {\n            shouldBeLast: \"Default parameters should be last.\"\n        }\n    },\n\n    create(context) {\n\n        // eslint-disable-next-line jsdoc/require-description\n        /**\n         * @param {ASTNode} node function node\n         * @returns {void}\n         */\n        function handleFunction(node) {\n            let hasSeenPlainParam = false;\n\n            for (let i = node.params.length - 1; i >= 0; i -= 1) {\n                const param = node.params[i];\n\n                if (\n                    param.type !== \"AssignmentPattern\" &&\n                    param.type !== \"RestElement\"\n                ) {\n                    hasSeenPlainParam = true;\n                    continue;\n                }\n\n                if (hasSeenPlainParam && param.type === \"AssignmentPattern\") {\n                    context.report({\n                        node: param,\n                        messageId: \"shouldBeLast\"\n                    });\n                }\n            }\n        }\n\n        return {\n            FunctionDeclaration: handleFunction,\n            FunctionExpression: handleFunction,\n            ArrowFunctionExpression: handleFunction\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar dotLocation = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent newlines before and after dots\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/dot-location\"\n        },\n\n        schema: [\n            {\n                enum: [\"object\", \"property\"]\n            }\n        ],\n\n        fixable: \"code\",\n\n        messages: {\n            expectedDotAfterObject: \"Expected dot to be on same line as object.\",\n            expectedDotBeforeProperty: \"Expected dot to be on same line as property.\"\n        }\n    },\n\n    create(context) {\n\n        const config = context.options[0];\n\n        // default to onObject if no preference is passed\n        const onObject = config === \"object\" || !config;\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Reports if the dot between object and property is on the correct loccation.\n         * @param {ASTNode} node The `MemberExpression` node.\n         * @returns {void}\n         */\n        function checkDotLocation(node) {\n            const property = node.property;\n            const dot = sourceCode.getTokenBefore(property);\n\n            // `obj` expression can be parenthesized, but those paren tokens are not a part of the `obj` node.\n            const tokenBeforeDot = sourceCode.getTokenBefore(dot);\n\n            const textBeforeDot = sourceCode.getText().slice(tokenBeforeDot.range[1], dot.range[0]);\n            const textAfterDot = sourceCode.getText().slice(dot.range[1], property.range[0]);\n\n            if (onObject) {\n                if (!astUtils$1.isTokenOnSameLine(tokenBeforeDot, dot)) {\n                    const neededTextAfterToken = astUtils$1.isDecimalIntegerNumericToken(tokenBeforeDot) ? \" \" : \"\";\n\n                    context.report({\n                        node,\n                        loc: dot.loc,\n                        messageId: \"expectedDotAfterObject\",\n                        fix: fixer => fixer.replaceTextRange([tokenBeforeDot.range[1], property.range[0]], `${neededTextAfterToken}.${textBeforeDot}${textAfterDot}`)\n                    });\n                }\n            } else if (!astUtils$1.isTokenOnSameLine(dot, property)) {\n                context.report({\n                    node,\n                    loc: dot.loc,\n                    messageId: \"expectedDotBeforeProperty\",\n                    fix: fixer => fixer.replaceTextRange([tokenBeforeDot.range[1], property.range[0]], `${textBeforeDot}${textAfterDot}.`)\n                });\n            }\n        }\n\n        /**\n         * Checks the spacing of the dot within a member expression.\n         * @param {ASTNode} node The node to check.\n         * @returns {void}\n         */\n        function checkNode(node) {\n            if (!node.computed) {\n                checkDotLocation(node);\n            }\n        }\n\n        return {\n            MemberExpression: checkNode\n        };\n    }\n};\n\n/**\n * @fileoverview A shared list of ES3 keywords.\n * @author Josh Perez\n */\n\nvar keywords$3 = [\n    \"abstract\",\n    \"boolean\",\n    \"break\",\n    \"byte\",\n    \"case\",\n    \"catch\",\n    \"char\",\n    \"class\",\n    \"const\",\n    \"continue\",\n    \"debugger\",\n    \"default\",\n    \"delete\",\n    \"do\",\n    \"double\",\n    \"else\",\n    \"enum\",\n    \"export\",\n    \"extends\",\n    \"false\",\n    \"final\",\n    \"finally\",\n    \"float\",\n    \"for\",\n    \"function\",\n    \"goto\",\n    \"if\",\n    \"implements\",\n    \"import\",\n    \"in\",\n    \"instanceof\",\n    \"int\",\n    \"interface\",\n    \"long\",\n    \"native\",\n    \"new\",\n    \"null\",\n    \"package\",\n    \"private\",\n    \"protected\",\n    \"public\",\n    \"return\",\n    \"short\",\n    \"static\",\n    \"super\",\n    \"switch\",\n    \"synchronized\",\n    \"this\",\n    \"throw\",\n    \"throws\",\n    \"transient\",\n    \"true\",\n    \"try\",\n    \"typeof\",\n    \"var\",\n    \"void\",\n    \"volatile\",\n    \"while\",\n    \"with\"\n];\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nconst validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/u;\n\n// `null` literal must be handled separately.\nconst literalTypesToCheck = new Set([\"string\", \"boolean\"]);\n\nvar dotNotation = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce dot notation whenever possible\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/dot-notation\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allowKeywords: {\n                        type: \"boolean\",\n                        default: true\n                    },\n                    allowPattern: {\n                        type: \"string\",\n                        default: \"\"\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        fixable: \"code\",\n\n        messages: {\n            useDot: \"[{{key}}] is better written in dot notation.\",\n            useBrackets: \".{{key}} is a syntax error.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options[0] || {};\n        const allowKeywords = options.allowKeywords === void 0 || options.allowKeywords;\n        const sourceCode = context.getSourceCode();\n\n        let allowPattern;\n\n        if (options.allowPattern) {\n            allowPattern = new RegExp(options.allowPattern, \"u\");\n        }\n\n        /**\n         * Check if the property is valid dot notation\n         * @param {ASTNode} node The dot notation node\n         * @param {string} value Value which is to be checked\n         * @returns {void}\n         */\n        function checkComputedProperty(node, value) {\n            if (\n                validIdentifier.test(value) &&\n                (allowKeywords || keywords$3.indexOf(String(value)) === -1) &&\n                !(allowPattern && allowPattern.test(value))\n            ) {\n                const formattedValue = node.property.type === \"Literal\" ? JSON.stringify(value) : `\\`${value}\\``;\n\n                context.report({\n                    node: node.property,\n                    messageId: \"useDot\",\n                    data: {\n                        key: formattedValue\n                    },\n                    fix(fixer) {\n                        const leftBracket = sourceCode.getTokenAfter(node.object, astUtils$1.isOpeningBracketToken);\n                        const rightBracket = sourceCode.getLastToken(node);\n\n                        if (sourceCode.getFirstTokenBetween(leftBracket, rightBracket, { includeComments: true, filter: astUtils$1.isCommentToken })) {\n\n                            // Don't perform any fixes if there are comments inside the brackets.\n                            return null;\n                        }\n\n                        const tokenAfterProperty = sourceCode.getTokenAfter(rightBracket);\n                        const needsSpaceAfterProperty = tokenAfterProperty &&\n                            rightBracket.range[1] === tokenAfterProperty.range[0] &&\n                            !astUtils$1.canTokensBeAdjacent(String(value), tokenAfterProperty);\n\n                        const textBeforeDot = astUtils$1.isDecimalInteger(node.object) ? \" \" : \"\";\n                        const textAfterProperty = needsSpaceAfterProperty ? \" \" : \"\";\n\n                        return fixer.replaceTextRange(\n                            [leftBracket.range[0], rightBracket.range[1]],\n                            `${textBeforeDot}.${value}${textAfterProperty}`\n                        );\n                    }\n                });\n            }\n        }\n\n        return {\n            MemberExpression(node) {\n                if (\n                    node.computed &&\n                    node.property.type === \"Literal\" &&\n                    (literalTypesToCheck.has(typeof node.property.value) || astUtils$1.isNullLiteral(node.property))\n                ) {\n                    checkComputedProperty(node, node.property.value);\n                }\n                if (\n                    node.computed &&\n                    node.property.type === \"TemplateLiteral\" &&\n                    node.property.expressions.length === 0\n                ) {\n                    checkComputedProperty(node, node.property.quasis[0].value.cooked);\n                }\n                if (\n                    !allowKeywords &&\n                    !node.computed &&\n                    keywords$3.indexOf(String(node.property.name)) !== -1\n                ) {\n                    context.report({\n                        node: node.property,\n                        messageId: \"useBrackets\",\n                        data: {\n                            key: node.property.name\n                        },\n                        fix(fixer) {\n                            const dot = sourceCode.getTokenBefore(node.property);\n                            const textAfterDot = sourceCode.text.slice(dot.range[1], node.property.range[0]);\n\n                            if (textAfterDot.trim()) {\n\n                                // Don't perform any fixes if there are comments between the dot and the property name.\n                                return null;\n                            }\n\n                            if (node.object.type === \"Identifier\" && node.object.name === \"let\") {\n\n                                /*\n                                 * A statement that starts with `let[` is parsed as a destructuring variable declaration, not\n                                 * a MemberExpression.\n                                 */\n                                return null;\n                            }\n\n                            return fixer.replaceTextRange(\n                                [dot.range[0], node.property.range[1]],\n                                `[${textAfterDot}\"${node.property.name}\"]`\n                            );\n                        }\n                    });\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar eolLast = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require or disallow newline at the end of files\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/eol-last\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                enum: [\"always\", \"never\", \"unix\", \"windows\"]\n            }\n        ],\n\n        messages: {\n            missing: \"Newline required at end of file but not found.\",\n            unexpected: \"Newline not allowed at end of file.\"\n        }\n    },\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            Program: function checkBadEOF(node) {\n                const sourceCode = context.getSourceCode(),\n                    src = sourceCode.getText(),\n                    location = {\n                        column: lodash.last(sourceCode.lines).length,\n                        line: sourceCode.lines.length\n                    },\n                    LF = \"\\n\",\n                    CRLF = `\\r${LF}`,\n                    endsWithNewline = lodash.endsWith(src, LF);\n\n                /*\n                 * Empty source is always valid: No content in file so we don't\n                 * need to lint for a newline on the last line of content.\n                 */\n                if (!src.length) {\n                    return;\n                }\n\n                let mode = context.options[0] || \"always\",\n                    appendCRLF = false;\n\n                if (mode === \"unix\") {\n\n                    // `\"unix\"` should behave exactly as `\"always\"`\n                    mode = \"always\";\n                }\n                if (mode === \"windows\") {\n\n                    // `\"windows\"` should behave exactly as `\"always\"`, but append CRLF in the fixer for backwards compatibility\n                    mode = \"always\";\n                    appendCRLF = true;\n                }\n                if (mode === \"always\" && !endsWithNewline) {\n\n                    // File is not newline-terminated, but should be\n                    context.report({\n                        node,\n                        loc: location,\n                        messageId: \"missing\",\n                        fix(fixer) {\n                            return fixer.insertTextAfterRange([0, src.length], appendCRLF ? CRLF : LF);\n                        }\n                    });\n                } else if (mode === \"never\" && endsWithNewline) {\n\n                    // File is newline-terminated, but shouldn't be\n                    context.report({\n                        node,\n                        loc: location,\n                        messageId: \"unexpected\",\n                        fix(fixer) {\n                            const finalEOLs = /(?:\\r?\\n)+$/u,\n                                match = finalEOLs.exec(sourceCode.text),\n                                start = match.index,\n                                end = sourceCode.text.length;\n\n                            return fixer.replaceTextRange([start, end], \"\");\n                        }\n                    });\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar eqeqeq = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require the use of `===` and `!==`\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/eqeqeq\"\n        },\n\n        schema: {\n            anyOf: [\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"always\"]\n                        },\n                        {\n                            type: \"object\",\n                            properties: {\n                                null: {\n                                    enum: [\"always\", \"never\", \"ignore\"]\n                                }\n                            },\n                            additionalProperties: false\n                        }\n                    ],\n                    additionalItems: false\n                },\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"smart\", \"allow-null\"]\n                        }\n                    ],\n                    additionalItems: false\n                }\n            ]\n        },\n\n        fixable: \"code\",\n\n        messages: {\n            unexpected: \"Expected '{{expectedOperator}}' and instead saw '{{actualOperator}}'.\"\n        }\n    },\n\n    create(context) {\n        const config = context.options[0] || \"always\";\n        const options = context.options[1] || {};\n        const sourceCode = context.getSourceCode();\n\n        const nullOption = (config === \"always\")\n            ? options.null || \"always\"\n            : \"ignore\";\n        const enforceRuleForNull = (nullOption === \"always\");\n        const enforceInverseRuleForNull = (nullOption === \"never\");\n\n        /**\n         * Checks if an expression is a typeof expression\n         * @param  {ASTNode} node The node to check\n         * @returns {boolean} if the node is a typeof expression\n         */\n        function isTypeOf(node) {\n            return node.type === \"UnaryExpression\" && node.operator === \"typeof\";\n        }\n\n        /**\n         * Checks if either operand of a binary expression is a typeof operation\n         * @param {ASTNode} node The node to check\n         * @returns {boolean} if one of the operands is typeof\n         * @private\n         */\n        function isTypeOfBinary(node) {\n            return isTypeOf(node.left) || isTypeOf(node.right);\n        }\n\n        /**\n         * Checks if operands are literals of the same type (via typeof)\n         * @param {ASTNode} node The node to check\n         * @returns {boolean} if operands are of same type\n         * @private\n         */\n        function areLiteralsAndSameType(node) {\n            return node.left.type === \"Literal\" && node.right.type === \"Literal\" &&\n                    typeof node.left.value === typeof node.right.value;\n        }\n\n        /**\n         * Checks if one of the operands is a literal null\n         * @param {ASTNode} node The node to check\n         * @returns {boolean} if operands are null\n         * @private\n         */\n        function isNullCheck(node) {\n            return astUtils$1.isNullLiteral(node.right) || astUtils$1.isNullLiteral(node.left);\n        }\n\n        /**\n         * Reports a message for this rule.\n         * @param {ASTNode} node The binary expression node that was checked\n         * @param {string} expectedOperator The operator that was expected (either '==', '!=', '===', or '!==')\n         * @returns {void}\n         * @private\n         */\n        function report(node, expectedOperator) {\n            const operatorToken = sourceCode.getFirstTokenBetween(\n                node.left,\n                node.right,\n                token => token.value === node.operator\n            );\n\n            context.report({\n                node,\n                loc: operatorToken.loc,\n                messageId: \"unexpected\",\n                data: { expectedOperator, actualOperator: node.operator },\n                fix(fixer) {\n\n                    // If the comparison is a `typeof` comparison or both sides are literals with the same type, then it's safe to fix.\n                    if (isTypeOfBinary(node) || areLiteralsAndSameType(node)) {\n                        return fixer.replaceText(operatorToken, expectedOperator);\n                    }\n                    return null;\n                }\n            });\n        }\n\n        return {\n            BinaryExpression(node) {\n                const isNull = isNullCheck(node);\n\n                if (node.operator !== \"==\" && node.operator !== \"!=\") {\n                    if (enforceInverseRuleForNull && isNull) {\n                        report(node, node.operator.slice(0, -1));\n                    }\n                    return;\n                }\n\n                if (config === \"smart\" && (isTypeOfBinary(node) ||\n                        areLiteralsAndSameType(node) || isNull)) {\n                    return;\n                }\n\n                if (!enforceRuleForNull && isNull) {\n                    return;\n                }\n\n                report(node, `${node.operator}=`);\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview enforce \"for\" loop update clause moving the counter in the right direction.(for-direction)\n * @author Aladdin-ADD<hh_2013@foxmail.com>\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar forDirection = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"enforce \\\"for\\\" loop update clause moving the counter in the right direction.\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/for-direction\"\n        },\n\n        fixable: null,\n        schema: [],\n\n        messages: {\n            incorrectDirection: \"The update clause in this loop moves the variable in the wrong direction.\"\n        }\n    },\n\n    create(context) {\n\n        /**\n         * report an error.\n         * @param {ASTNode} node the node to report.\n         * @returns {void}\n         */\n        function report(node) {\n            context.report({\n                node,\n                messageId: \"incorrectDirection\"\n            });\n        }\n\n        /**\n         * check the right side of the assignment\n         * @param {ASTNode} update UpdateExpression to check\n         * @param {int} dir expected direction that could either be turned around or invalidated\n         * @returns {int} return dir, the negated dir or zero if it's not clear for identifiers\n         */\n        function getRightDirection(update, dir) {\n            if (update.right.type === \"UnaryExpression\") {\n                if (update.right.operator === \"-\") {\n                    return -dir;\n                }\n            } else if (update.right.type === \"Identifier\") {\n                return 0;\n            }\n            return dir;\n        }\n\n        /**\n         * check UpdateExpression add/sub the counter\n         * @param {ASTNode} update UpdateExpression to check\n         * @param {string} counter variable name to check\n         * @returns {int} if add return 1, if sub return -1, if nochange, return 0\n         */\n        function getUpdateDirection(update, counter) {\n            if (update.argument.type === \"Identifier\" && update.argument.name === counter) {\n                if (update.operator === \"++\") {\n                    return 1;\n                }\n                if (update.operator === \"--\") {\n                    return -1;\n                }\n            }\n            return 0;\n        }\n\n        /**\n         * check AssignmentExpression add/sub the counter\n         * @param {ASTNode} update AssignmentExpression to check\n         * @param {string} counter variable name to check\n         * @returns {int} if add return 1, if sub return -1, if nochange, return 0\n         */\n        function getAssignmentDirection(update, counter) {\n            if (update.left.name === counter) {\n                if (update.operator === \"+=\") {\n                    return getRightDirection(update, 1);\n                }\n                if (update.operator === \"-=\") {\n                    return getRightDirection(update, -1);\n                }\n            }\n            return 0;\n        }\n        return {\n            ForStatement(node) {\n\n                if (node.test && node.test.type === \"BinaryExpression\" && node.test.left.type === \"Identifier\" && node.update) {\n                    const counter = node.test.left.name;\n                    const operator = node.test.operator;\n                    const update = node.update;\n\n                    let wrongDirection;\n\n                    if (operator === \"<\" || operator === \"<=\") {\n                        wrongDirection = -1;\n                    } else if (operator === \">\" || operator === \">=\") {\n                        wrongDirection = 1;\n                    } else {\n                        return;\n                    }\n\n                    if (update.type === \"UpdateExpression\") {\n                        if (getUpdateDirection(update, counter) === wrongDirection) {\n                            report(node);\n                        }\n                    } else if (update.type === \"AssignmentExpression\" && getAssignmentDirection(update, counter) === wrongDirection) {\n                        report(node);\n                    }\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar funcCallSpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require or disallow spacing between function identifiers and their invocations\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/func-call-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: {\n            anyOf: [\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"never\"]\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 1\n                },\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"always\"]\n                        },\n                        {\n                            type: \"object\",\n                            properties: {\n                                allowNewlines: {\n                                    type: \"boolean\"\n                                }\n                            },\n                            additionalProperties: false\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 2\n                }\n            ]\n        },\n\n        messages: {\n            unexpected: \"Unexpected newline between function name and paren.\",\n            missing: \"Missing space between function name and paren.\"\n        }\n    },\n\n    create(context) {\n\n        const never = context.options[0] !== \"always\";\n        const allowNewlines = !never && context.options[1] && context.options[1].allowNewlines;\n        const sourceCode = context.getSourceCode();\n        const text = sourceCode.getText();\n\n        /**\n         * Check if open space is present in a function name\n         * @param {ASTNode} node node to evaluate\n         * @param {Token} leftToken The last token of the callee. This may be the closing parenthesis that encloses the callee.\n         * @param {Token} rightToken Tha first token of the arguments. this is the opening parenthesis that encloses the arguments.\n         * @returns {void}\n         * @private\n         */\n        function checkSpacing(node, leftToken, rightToken) {\n            const textBetweenTokens = text.slice(leftToken.range[1], rightToken.range[0]).replace(/\\/\\*.*?\\*\\//gu, \"\");\n            const hasWhitespace = /\\s/u.test(textBetweenTokens);\n            const hasNewline = hasWhitespace && astUtils$1.LINEBREAK_MATCHER.test(textBetweenTokens);\n\n            /*\n             * never allowNewlines hasWhitespace hasNewline message\n             * F     F             F             F          Missing space between function name and paren.\n             * F     F             F             T          (Invalid `!hasWhitespace && hasNewline`)\n             * F     F             T             T          Unexpected newline between function name and paren.\n             * F     F             T             F          (OK)\n             * F     T             T             F          (OK)\n             * F     T             T             T          (OK)\n             * F     T             F             T          (Invalid `!hasWhitespace && hasNewline`)\n             * F     T             F             F          Missing space between function name and paren.\n             * T     T             F             F          (Invalid `never && allowNewlines`)\n             * T     T             F             T          (Invalid `!hasWhitespace && hasNewline`)\n             * T     T             T             T          (Invalid `never && allowNewlines`)\n             * T     T             T             F          (Invalid `never && allowNewlines`)\n             * T     F             T             F          Unexpected space between function name and paren.\n             * T     F             T             T          Unexpected space between function name and paren.\n             * T     F             F             T          (Invalid `!hasWhitespace && hasNewline`)\n             * T     F             F             F          (OK)\n             *\n             * T                   T                        Unexpected space between function name and paren.\n             * F                   F                        Missing space between function name and paren.\n             * F     F                           T          Unexpected newline between function name and paren.\n             */\n\n            if (never && hasWhitespace) {\n                context.report({\n                    node,\n                    loc: leftToken.loc.start,\n                    messageId: \"unexpected\",\n                    fix(fixer) {\n\n                        /*\n                         * Only autofix if there is no newline\n                         * https://github.com/eslint/eslint/issues/7787\n                         */\n                        if (!hasNewline) {\n                            return fixer.removeRange([leftToken.range[1], rightToken.range[0]]);\n                        }\n\n                        return null;\n                    }\n                });\n            } else if (!never && !hasWhitespace) {\n                context.report({\n                    node,\n                    loc: leftToken.loc.start,\n                    messageId: \"missing\",\n                    fix(fixer) {\n                        return fixer.insertTextBefore(rightToken, \" \");\n                    }\n                });\n            } else if (!never && !allowNewlines && hasNewline) {\n                context.report({\n                    node,\n                    loc: leftToken.loc.start,\n                    messageId: \"unexpected\",\n                    fix(fixer) {\n                        return fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], \" \");\n                    }\n                });\n            }\n        }\n\n        return {\n            \"CallExpression, NewExpression\"(node) {\n                const lastToken = sourceCode.getLastToken(node);\n                const lastCalleeToken = sourceCode.getLastToken(node.callee);\n                const parenToken = sourceCode.getFirstTokenBetween(lastCalleeToken, lastToken, astUtils$1.isOpeningParenToken);\n                const prevToken = parenToken && sourceCode.getTokenBefore(parenToken);\n\n                // Parens in NewExpression are optional\n                if (!(parenToken && parenToken.range[1] < node.range[1])) {\n                    return;\n                }\n\n                checkSpacing(node, prevToken, parenToken);\n            },\n\n            ImportExpression(node) {\n                const leftToken = sourceCode.getFirstToken(node);\n                const rightToken = sourceCode.getTokenAfter(leftToken);\n\n                checkSpacing(node, leftToken, rightToken);\n            }\n        };\n\n    }\n};\n\n//--------------------------------------------------------------------------\n// Requirements\n//--------------------------------------------------------------------------\n\n\n\n\n//--------------------------------------------------------------------------\n// Helpers\n//--------------------------------------------------------------------------\n\n/**\n * Determines if a pattern is `module.exports` or `module[\"exports\"]`\n * @param {ASTNode} pattern The left side of the AssignmentExpression\n * @returns {boolean} True if the pattern is `module.exports` or `module[\"exports\"]`\n */\nfunction isModuleExports(pattern) {\n    if (pattern.type === \"MemberExpression\" && pattern.object.type === \"Identifier\" && pattern.object.name === \"module\") {\n\n        // module.exports\n        if (pattern.property.type === \"Identifier\" && pattern.property.name === \"exports\") {\n            return true;\n        }\n\n        // module[\"exports\"]\n        if (pattern.property.type === \"Literal\" && pattern.property.value === \"exports\") {\n            return true;\n        }\n    }\n    return false;\n}\n\n/**\n * Determines if a string name is a valid identifier\n * @param {string} name The string to be checked\n * @param {int} ecmaVersion The ECMAScript version if specified in the parserOptions config\n * @returns {boolean} True if the string is a valid identifier\n */\nfunction isIdentifier$2(name, ecmaVersion) {\n    if (ecmaVersion >= 6) {\n        return utils.keyword.isIdentifierES6(name);\n    }\n    return utils.keyword.isIdentifierES5(name);\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nconst alwaysOrNever = { enum: [\"always\", \"never\"] };\nconst optionsObject = {\n    type: \"object\",\n    properties: {\n        considerPropertyDescriptor: {\n            type: \"boolean\"\n        },\n        includeCommonJSModuleExports: {\n            type: \"boolean\"\n        }\n    },\n    additionalProperties: false\n};\n\nvar funcNameMatching = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require function names to match the name of the variable or property to which they are assigned\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/func-name-matching\"\n        },\n\n        schema: {\n            anyOf: [{\n                type: \"array\",\n                additionalItems: false,\n                items: [alwaysOrNever, optionsObject]\n            }, {\n                type: \"array\",\n                additionalItems: false,\n                items: [optionsObject]\n            }]\n        },\n\n        messages: {\n            matchProperty: \"Function name `{{funcName}}` should match property name `{{name}}`.\",\n            matchVariable: \"Function name `{{funcName}}` should match variable name `{{name}}`.\",\n            notMatchProperty: \"Function name `{{funcName}}` should not match property name `{{name}}`.\",\n            notMatchVariable: \"Function name `{{funcName}}` should not match variable name `{{name}}`.\"\n        }\n    },\n\n    create(context) {\n        const options = (typeof context.options[0] === \"object\" ? context.options[0] : context.options[1]) || {};\n        const nameMatches = typeof context.options[0] === \"string\" ? context.options[0] : \"always\";\n        const considerPropertyDescriptor = options.considerPropertyDescriptor;\n        const includeModuleExports = options.includeCommonJSModuleExports;\n        const ecmaVersion = context.parserOptions && context.parserOptions.ecmaVersion ? context.parserOptions.ecmaVersion : 5;\n\n        /**\n         * Check whether node is a certain CallExpression.\n         * @param {string} objName object name\n         * @param {string} funcName function name\n         * @param {ASTNode} node The node to check\n         * @returns {boolean} `true` if node matches CallExpression\n         */\n        function isPropertyCall(objName, funcName, node) {\n            if (!node) {\n                return false;\n            }\n            return node.type === \"CallExpression\" &&\n                node.callee.type === \"MemberExpression\" &&\n                node.callee.object.name === objName &&\n                node.callee.property.name === funcName;\n        }\n\n        /**\n         * Compares identifiers based on the nameMatches option\n         * @param {string} x the first identifier\n         * @param {string} y the second identifier\n         * @returns {boolean} whether the two identifiers should warn.\n         */\n        function shouldWarn(x, y) {\n            return (nameMatches === \"always\" && x !== y) || (nameMatches === \"never\" && x === y);\n        }\n\n        /**\n         * Reports\n         * @param {ASTNode} node The node to report\n         * @param {string} name The variable or property name\n         * @param {string} funcName The function name\n         * @param {boolean} isProp True if the reported node is a property assignment\n         * @returns {void}\n         */\n        function report(node, name, funcName, isProp) {\n            let messageId;\n\n            if (nameMatches === \"always\" && isProp) {\n                messageId = \"matchProperty\";\n            } else if (nameMatches === \"always\") {\n                messageId = \"matchVariable\";\n            } else if (isProp) {\n                messageId = \"notMatchProperty\";\n            } else {\n                messageId = \"notMatchVariable\";\n            }\n            context.report({\n                node,\n                messageId,\n                data: {\n                    name,\n                    funcName\n                }\n            });\n        }\n\n        /**\n         * Determines whether a given node is a string literal\n         * @param {ASTNode} node The node to check\n         * @returns {boolean} `true` if the node is a string literal\n         */\n        function isStringLiteral(node) {\n            return node.type === \"Literal\" && typeof node.value === \"string\";\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            VariableDeclarator(node) {\n                if (!node.init || node.init.type !== \"FunctionExpression\" || node.id.type !== \"Identifier\") {\n                    return;\n                }\n                if (node.init.id && shouldWarn(node.id.name, node.init.id.name)) {\n                    report(node, node.id.name, node.init.id.name, false);\n                }\n            },\n\n            AssignmentExpression(node) {\n                if (\n                    node.right.type !== \"FunctionExpression\" ||\n                    (node.left.computed && node.left.property.type !== \"Literal\") ||\n                    (!includeModuleExports && isModuleExports(node.left)) ||\n                    (node.left.type !== \"Identifier\" && node.left.type !== \"MemberExpression\")\n                ) {\n                    return;\n                }\n\n                const isProp = node.left.type === \"MemberExpression\";\n                const name = isProp ? astUtils$1.getStaticPropertyName(node.left) : node.left.name;\n\n                if (node.right.id && isIdentifier$2(name) && shouldWarn(name, node.right.id.name)) {\n                    report(node, name, node.right.id.name, isProp);\n                }\n            },\n\n            Property(node) {\n                if (node.value.type !== \"FunctionExpression\" || !node.value.id || node.computed && !isStringLiteral(node.key)) {\n                    return;\n                }\n\n                if (node.key.type === \"Identifier\") {\n                    const functionName = node.value.id.name;\n                    let propertyName = node.key.name;\n\n                    if (considerPropertyDescriptor && propertyName === \"value\") {\n                        if (isPropertyCall(\"Object\", \"defineProperty\", node.parent.parent) || isPropertyCall(\"Reflect\", \"defineProperty\", node.parent.parent)) {\n                            const property = node.parent.parent.arguments[1];\n\n                            if (isStringLiteral(property) && shouldWarn(property.value, functionName)) {\n                                report(node, property.value, functionName, true);\n                            }\n                        } else if (isPropertyCall(\"Object\", \"defineProperties\", node.parent.parent.parent.parent)) {\n                            propertyName = node.parent.parent.key.name;\n                            if (!node.parent.parent.computed && shouldWarn(propertyName, functionName)) {\n                                report(node, propertyName, functionName, true);\n                            }\n                        } else if (isPropertyCall(\"Object\", \"create\", node.parent.parent.parent.parent)) {\n                            propertyName = node.parent.parent.key.name;\n                            if (!node.parent.parent.computed && shouldWarn(propertyName, functionName)) {\n                                report(node, propertyName, functionName, true);\n                            }\n                        } else if (shouldWarn(propertyName, functionName)) {\n                            report(node, propertyName, functionName, true);\n                        }\n                    } else if (shouldWarn(propertyName, functionName)) {\n                        report(node, propertyName, functionName, true);\n                    }\n                    return;\n                }\n\n                if (\n                    isStringLiteral(node.key) &&\n                    isIdentifier$2(node.key.value, ecmaVersion) &&\n                    shouldWarn(node.key.value, node.value.id.name)\n                ) {\n                    report(node, node.key.value, node.value.id.name, true);\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n/**\n * Checks whether or not a given variable is a function name.\n * @param {eslint-scope.Variable} variable A variable to check.\n * @returns {boolean} `true` if the variable is a function name.\n */\nfunction isFunctionName(variable) {\n    return variable && variable.defs[0].type === \"FunctionName\";\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar funcNames = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require or disallow named `function` expressions\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/func-names\"\n        },\n\n        schema: {\n            definitions: {\n                value: {\n                    enum: [\n                        \"always\",\n                        \"as-needed\",\n                        \"never\"\n                    ]\n                }\n            },\n            items: [\n                {\n                    $ref: \"#/definitions/value\"\n                },\n                {\n                    type: \"object\",\n                    properties: {\n                        generators: {\n                            $ref: \"#/definitions/value\"\n                        }\n                    },\n                    additionalProperties: false\n                }\n            ]\n        },\n\n        messages: {\n            unnamed: \"Unexpected unnamed {{name}}.\",\n            named: \"Unexpected named {{name}}.\"\n        }\n    },\n\n    create(context) {\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Returns the config option for the given node.\n         * @param {ASTNode} node A node to get the config for.\n         * @returns {string} The config option.\n         */\n        function getConfigForNode(node) {\n            if (\n                node.generator &&\n                context.options.length > 1 &&\n                context.options[1].generators\n            ) {\n                return context.options[1].generators;\n            }\n\n            return context.options[0] || \"always\";\n        }\n\n        /**\n         * Determines whether the current FunctionExpression node is a get, set, or\n         * shorthand method in an object literal or a class.\n         * @param {ASTNode} node A node to check.\n         * @returns {boolean} True if the node is a get, set, or shorthand method.\n         */\n        function isObjectOrClassMethod(node) {\n            const parent = node.parent;\n\n            return (parent.type === \"MethodDefinition\" || (\n                parent.type === \"Property\" && (\n                    parent.method ||\n                    parent.kind === \"get\" ||\n                    parent.kind === \"set\"\n                )\n            ));\n        }\n\n        /**\n         * Determines whether the current FunctionExpression node has a name that would be\n         * inferred from context in a conforming ES6 environment.\n         * @param {ASTNode} node A node to check.\n         * @returns {boolean} True if the node would have a name assigned automatically.\n         */\n        function hasInferredName(node) {\n            const parent = node.parent;\n\n            return isObjectOrClassMethod(node) ||\n                (parent.type === \"VariableDeclarator\" && parent.id.type === \"Identifier\" && parent.init === node) ||\n                (parent.type === \"Property\" && parent.value === node) ||\n                (parent.type === \"AssignmentExpression\" && parent.left.type === \"Identifier\" && parent.right === node) ||\n                (parent.type === \"ExportDefaultDeclaration\" && parent.declaration === node) ||\n                (parent.type === \"AssignmentPattern\" && parent.right === node);\n        }\n\n        /**\n         * Reports that an unnamed function should be named\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @returns {void}\n         */\n        function reportUnexpectedUnnamedFunction(node) {\n            context.report({\n                node,\n                messageId: \"unnamed\",\n                loc: astUtils$1.getFunctionHeadLoc(node, sourceCode),\n                data: { name: astUtils$1.getFunctionNameWithKind(node) }\n            });\n        }\n\n        /**\n         * Reports that a named function should be unnamed\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @returns {void}\n         */\n        function reportUnexpectedNamedFunction(node) {\n            context.report({\n                node,\n                messageId: \"named\",\n                loc: astUtils$1.getFunctionHeadLoc(node, sourceCode),\n                data: { name: astUtils$1.getFunctionNameWithKind(node) }\n            });\n        }\n\n        return {\n            \"FunctionExpression:exit\"(node) {\n\n                // Skip recursive functions.\n                const nameVar = context.getDeclaredVariables(node)[0];\n\n                if (isFunctionName(nameVar) && nameVar.references.length > 0) {\n                    return;\n                }\n\n                const hasName = Boolean(node.id && node.id.name);\n                const config = getConfigForNode(node);\n\n                if (config === \"never\") {\n                    if (hasName) {\n                        reportUnexpectedNamedFunction(node);\n                    }\n                } else if (config === \"as-needed\") {\n                    if (!hasName && !hasInferredName(node)) {\n                        reportUnexpectedUnnamedFunction(node);\n                    }\n                } else {\n                    if (!hasName && !isObjectOrClassMethod(node)) {\n                        reportUnexpectedUnnamedFunction(node);\n                    }\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to enforce a particular function style\n * @author Nicholas C. Zakas\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar funcStyle = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce the consistent use of either `function` declarations or expressions\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/func-style\"\n        },\n\n        schema: [\n            {\n                enum: [\"declaration\", \"expression\"]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    allowArrowFunctions: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            expression: \"Expected a function expression.\",\n            declaration: \"Expected a function declaration.\"\n        }\n    },\n\n    create(context) {\n\n        const style = context.options[0],\n            allowArrowFunctions = context.options[1] && context.options[1].allowArrowFunctions,\n            enforceDeclarations = (style === \"declaration\"),\n            stack = [];\n\n        const nodesToCheck = {\n            FunctionDeclaration(node) {\n                stack.push(false);\n\n                if (!enforceDeclarations && node.parent.type !== \"ExportDefaultDeclaration\") {\n                    context.report({ node, messageId: \"expression\" });\n                }\n            },\n            \"FunctionDeclaration:exit\"() {\n                stack.pop();\n            },\n\n            FunctionExpression(node) {\n                stack.push(false);\n\n                if (enforceDeclarations && node.parent.type === \"VariableDeclarator\") {\n                    context.report({ node: node.parent, messageId: \"declaration\" });\n                }\n            },\n            \"FunctionExpression:exit\"() {\n                stack.pop();\n            },\n\n            ThisExpression() {\n                if (stack.length > 0) {\n                    stack[stack.length - 1] = true;\n                }\n            }\n        };\n\n        if (!allowArrowFunctions) {\n            nodesToCheck.ArrowFunctionExpression = function() {\n                stack.push(false);\n            };\n\n            nodesToCheck[\"ArrowFunctionExpression:exit\"] = function(node) {\n                const hasThisExpr = stack.pop();\n\n                if (enforceDeclarations && !hasThisExpr && node.parent.type === \"VariableDeclarator\") {\n                    context.report({ node: node.parent, messageId: \"declaration\" });\n                }\n            };\n        }\n\n        return nodesToCheck;\n\n    }\n};\n\n/**\n * @fileoverview Rule to enforce line breaks between arguments of a function call\n * @author Alexey Gonchar <https://github.com/finico>\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar functionCallArgumentNewline = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce line breaks between arguments of a function call\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/function-call-argument-newline\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                enum: [\"always\", \"never\", \"consistent\"]\n            }\n        ],\n\n        messages: {\n            unexpectedLineBreak: \"There should be no line break here.\",\n            missingLineBreak: \"There should be a line break after this argument.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        const checkers = {\n            unexpected: {\n                messageId: \"unexpectedLineBreak\",\n                check: (prevToken, currentToken) => prevToken.loc.end.line !== currentToken.loc.start.line,\n                createFix: (token, tokenBefore) => fixer =>\n                    fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], \" \")\n            },\n            missing: {\n                messageId: \"missingLineBreak\",\n                check: (prevToken, currentToken) => prevToken.loc.end.line === currentToken.loc.start.line,\n                createFix: (token, tokenBefore) => fixer =>\n                    fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], \"\\n\")\n            }\n        };\n\n        /**\n         * Check all arguments for line breaks in the CallExpression\n         * @param {CallExpression} node node to evaluate\n         * @param {{ messageId: string, check: Function }} checker selected checker\n         * @returns {void}\n         * @private\n         */\n        function checkArguments(node, checker) {\n            for (let i = 1; i < node.arguments.length; i++) {\n                const prevArgToken = sourceCode.getLastToken(node.arguments[i - 1]);\n                const currentArgToken = sourceCode.getFirstToken(node.arguments[i]);\n\n                if (checker.check(prevArgToken, currentArgToken)) {\n                    const tokenBefore = sourceCode.getTokenBefore(\n                        currentArgToken,\n                        { includeComments: true }\n                    );\n\n                    const hasLineCommentBefore = tokenBefore.type === \"Line\";\n\n                    context.report({\n                        node,\n                        loc: {\n                            start: tokenBefore.loc.end,\n                            end: currentArgToken.loc.start\n                        },\n                        messageId: checker.messageId,\n                        fix: hasLineCommentBefore ? null : checker.createFix(currentArgToken, tokenBefore)\n                    });\n                }\n            }\n        }\n\n        /**\n         * Check if open space is present in a function name\n         * @param {CallExpression} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function check(node) {\n            if (node.arguments.length < 2) {\n                return;\n            }\n\n            const option = context.options[0] || \"always\";\n\n            if (option === \"never\") {\n                checkArguments(node, checkers.unexpected);\n            } else if (option === \"always\") {\n                checkArguments(node, checkers.missing);\n            } else if (option === \"consistent\") {\n                const firstArgToken = sourceCode.getLastToken(node.arguments[0]);\n                const secondArgToken = sourceCode.getFirstToken(node.arguments[1]);\n\n                if (firstArgToken.loc.end.line === secondArgToken.loc.start.line) {\n                    checkArguments(node, checkers.unexpected);\n                } else {\n                    checkArguments(node, checkers.missing);\n                }\n            }\n        }\n\n        return {\n            CallExpression: check,\n            NewExpression: check\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar functionParenNewline = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent line breaks inside function parentheses\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/function-paren-newline\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        enum: [\"always\", \"never\", \"consistent\", \"multiline\", \"multiline-arguments\"]\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            minItems: {\n                                type: \"integer\",\n                                minimum: 0\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ],\n\n        messages: {\n            expectedBefore: \"Expected newline before ')'.\",\n            expectedAfter: \"Expected newline after '('.\",\n            expectedBetween: \"Expected newline between arguments/params.\",\n            unexpectedBefore: \"Unexpected newline before ')'.\",\n            unexpectedAfter: \"Unexpected newline after '('.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const rawOption = context.options[0] || \"multiline\";\n        const multilineOption = rawOption === \"multiline\";\n        const multilineArgumentsOption = rawOption === \"multiline-arguments\";\n        const consistentOption = rawOption === \"consistent\";\n        let minItems;\n\n        if (typeof rawOption === \"object\") {\n            minItems = rawOption.minItems;\n        } else if (rawOption === \"always\") {\n            minItems = 0;\n        } else if (rawOption === \"never\") {\n            minItems = Infinity;\n        } else {\n            minItems = null;\n        }\n\n        //----------------------------------------------------------------------\n        // Helpers\n        //----------------------------------------------------------------------\n\n        /**\n         * Determines whether there should be newlines inside function parens\n         * @param {ASTNode[]} elements The arguments or parameters in the list\n         * @param {boolean} hasLeftNewline `true` if the left paren has a newline in the current code.\n         * @returns {boolean} `true` if there should be newlines inside the function parens\n         */\n        function shouldHaveNewlines(elements, hasLeftNewline) {\n            if (multilineArgumentsOption && elements.length === 1) {\n                return hasLeftNewline;\n            }\n            if (multilineOption || multilineArgumentsOption) {\n                return elements.some((element, index) => index !== elements.length - 1 && element.loc.end.line !== elements[index + 1].loc.start.line);\n            }\n            if (consistentOption) {\n                return hasLeftNewline;\n            }\n            return elements.length >= minItems;\n        }\n\n        /**\n         * Validates parens\n         * @param {Object} parens An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token\n         * @param {ASTNode[]} elements The arguments or parameters in the list\n         * @returns {void}\n         */\n        function validateParens(parens, elements) {\n            const leftParen = parens.leftParen;\n            const rightParen = parens.rightParen;\n            const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen);\n            const tokenBeforeRightParen = sourceCode.getTokenBefore(rightParen);\n            const hasLeftNewline = !astUtils$1.isTokenOnSameLine(leftParen, tokenAfterLeftParen);\n            const hasRightNewline = !astUtils$1.isTokenOnSameLine(tokenBeforeRightParen, rightParen);\n            const needsNewlines = shouldHaveNewlines(elements, hasLeftNewline);\n\n            if (hasLeftNewline && !needsNewlines) {\n                context.report({\n                    node: leftParen,\n                    messageId: \"unexpectedAfter\",\n                    fix(fixer) {\n                        return sourceCode.getText().slice(leftParen.range[1], tokenAfterLeftParen.range[0]).trim()\n\n                            // If there is a comment between the ( and the first element, don't do a fix.\n                            ? null\n                            : fixer.removeRange([leftParen.range[1], tokenAfterLeftParen.range[0]]);\n                    }\n                });\n            } else if (!hasLeftNewline && needsNewlines) {\n                context.report({\n                    node: leftParen,\n                    messageId: \"expectedAfter\",\n                    fix: fixer => fixer.insertTextAfter(leftParen, \"\\n\")\n                });\n            }\n\n            if (hasRightNewline && !needsNewlines) {\n                context.report({\n                    node: rightParen,\n                    messageId: \"unexpectedBefore\",\n                    fix(fixer) {\n                        return sourceCode.getText().slice(tokenBeforeRightParen.range[1], rightParen.range[0]).trim()\n\n                            // If there is a comment between the last element and the ), don't do a fix.\n                            ? null\n                            : fixer.removeRange([tokenBeforeRightParen.range[1], rightParen.range[0]]);\n                    }\n                });\n            } else if (!hasRightNewline && needsNewlines) {\n                context.report({\n                    node: rightParen,\n                    messageId: \"expectedBefore\",\n                    fix: fixer => fixer.insertTextBefore(rightParen, \"\\n\")\n                });\n            }\n        }\n\n        /**\n         * Validates a list of arguments or parameters\n         * @param {Object} parens An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token\n         * @param {ASTNode[]} elements The arguments or parameters in the list\n         * @returns {void}\n         */\n        function validateArguments(parens, elements) {\n            const leftParen = parens.leftParen;\n            const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen);\n            const hasLeftNewline = !astUtils$1.isTokenOnSameLine(leftParen, tokenAfterLeftParen);\n            const needsNewlines = shouldHaveNewlines(elements, hasLeftNewline);\n\n            for (let i = 0; i <= elements.length - 2; i++) {\n                const currentElement = elements[i];\n                const nextElement = elements[i + 1];\n                const hasNewLine = currentElement.loc.end.line !== nextElement.loc.start.line;\n\n                if (!hasNewLine && needsNewlines) {\n                    context.report({\n                        node: currentElement,\n                        messageId: \"expectedBetween\",\n                        fix: fixer => fixer.insertTextBefore(nextElement, \"\\n\")\n                    });\n                }\n            }\n        }\n\n        /**\n         * Gets the left paren and right paren tokens of a node.\n         * @param {ASTNode} node The node with parens\n         * @returns {Object} An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token.\n         * Can also return `null` if an expression has no parens (e.g. a NewExpression with no arguments, or an ArrowFunctionExpression\n         * with a single parameter)\n         */\n        function getParenTokens(node) {\n            switch (node.type) {\n                case \"NewExpression\":\n                    if (!node.arguments.length && !(\n                        astUtils$1.isOpeningParenToken(sourceCode.getLastToken(node, { skip: 1 })) &&\n                        astUtils$1.isClosingParenToken(sourceCode.getLastToken(node))\n                    )) {\n\n                        // If the NewExpression does not have parens (e.g. `new Foo`), return null.\n                        return null;\n                    }\n\n                    // falls through\n\n                case \"CallExpression\":\n                    return {\n                        leftParen: sourceCode.getTokenAfter(node.callee, astUtils$1.isOpeningParenToken),\n                        rightParen: sourceCode.getLastToken(node)\n                    };\n\n                case \"FunctionDeclaration\":\n                case \"FunctionExpression\": {\n                    const leftParen = sourceCode.getFirstToken(node, astUtils$1.isOpeningParenToken);\n                    const rightParen = node.params.length\n                        ? sourceCode.getTokenAfter(node.params[node.params.length - 1], astUtils$1.isClosingParenToken)\n                        : sourceCode.getTokenAfter(leftParen);\n\n                    return { leftParen, rightParen };\n                }\n\n                case \"ArrowFunctionExpression\": {\n                    const firstToken = sourceCode.getFirstToken(node);\n\n                    if (!astUtils$1.isOpeningParenToken(firstToken)) {\n\n                        // If the ArrowFunctionExpression has a single param without parens, return null.\n                        return null;\n                    }\n\n                    return {\n                        leftParen: firstToken,\n                        rightParen: sourceCode.getTokenBefore(node.body, astUtils$1.isClosingParenToken)\n                    };\n                }\n\n                case \"ImportExpression\": {\n                    const leftParen = sourceCode.getFirstToken(node, 1);\n                    const rightParen = sourceCode.getLastToken(node);\n\n                    return { leftParen, rightParen };\n                }\n\n                default:\n                    throw new TypeError(`unexpected node with type ${node.type}`);\n            }\n        }\n\n        //----------------------------------------------------------------------\n        // Public\n        //----------------------------------------------------------------------\n\n        return {\n            [[\n                \"ArrowFunctionExpression\",\n                \"CallExpression\",\n                \"FunctionDeclaration\",\n                \"FunctionExpression\",\n                \"ImportExpression\",\n                \"NewExpression\"\n            ]](node) {\n                const parens = getParenTokens(node);\n                let params;\n\n                if (node.type === \"ImportExpression\") {\n                    params = [node.source];\n                } else if (astUtils$1.isFunction(node)) {\n                    params = node.params;\n                } else {\n                    params = node.arguments;\n                }\n\n                if (parens) {\n                    validateParens(parens, params);\n\n                    if (multilineArgumentsOption) {\n                        validateArguments(parens, params);\n                    }\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to check the spacing around the * in generator functions.\n * @author Jamund Ferguson\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nconst OVERRIDE_SCHEMA = {\n    oneOf: [\n        {\n            enum: [\"before\", \"after\", \"both\", \"neither\"]\n        },\n        {\n            type: \"object\",\n            properties: {\n                before: { type: \"boolean\" },\n                after: { type: \"boolean\" }\n            },\n            additionalProperties: false\n        }\n    ]\n};\n\nvar generatorStarSpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent spacing around `*` operators in generator functions\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/generator-star-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        enum: [\"before\", \"after\", \"both\", \"neither\"]\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            before: { type: \"boolean\" },\n                            after: { type: \"boolean\" },\n                            named: OVERRIDE_SCHEMA,\n                            anonymous: OVERRIDE_SCHEMA,\n                            method: OVERRIDE_SCHEMA\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ],\n\n        messages: {\n            missingBefore: \"Missing space before *.\",\n            missingAfter: \"Missing space after *.\",\n            unexpectedBefore: \"Unexpected space before *.\",\n            unexpectedAfter: \"Unexpected space after *.\"\n        }\n    },\n\n    create(context) {\n\n        const optionDefinitions = {\n            before: { before: true, after: false },\n            after: { before: false, after: true },\n            both: { before: true, after: true },\n            neither: { before: false, after: false }\n        };\n\n        /**\n         * Returns resolved option definitions based on an option and defaults\n         * @param {any} option The option object or string value\n         * @param {Object} defaults The defaults to use if options are not present\n         * @returns {Object} the resolved object definition\n         */\n        function optionToDefinition(option, defaults) {\n            if (!option) {\n                return defaults;\n            }\n\n            return typeof option === \"string\"\n                ? optionDefinitions[option]\n                : Object.assign({}, defaults, option);\n        }\n\n        const modes = (function(option) {\n            const defaults = optionToDefinition(option, optionDefinitions.before);\n\n            return {\n                named: optionToDefinition(option.named, defaults),\n                anonymous: optionToDefinition(option.anonymous, defaults),\n                method: optionToDefinition(option.method, defaults)\n            };\n        }(context.options[0] || {}));\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Checks if the given token is a star token or not.\n         * @param {Token} token The token to check.\n         * @returns {boolean} `true` if the token is a star token.\n         */\n        function isStarToken(token) {\n            return token.value === \"*\" && token.type === \"Punctuator\";\n        }\n\n        /**\n         * Gets the generator star token of the given function node.\n         * @param {ASTNode} node The function node to get.\n         * @returns {Token} Found star token.\n         */\n        function getStarToken(node) {\n            return sourceCode.getFirstToken(\n                (node.parent.method || node.parent.type === \"MethodDefinition\") ? node.parent : node,\n                isStarToken\n            );\n        }\n\n        /**\n         * capitalize a given string.\n         * @param {string} str the given string.\n         * @returns {string} the capitalized string.\n         */\n        function capitalize(str) {\n            return str[0].toUpperCase() + str.slice(1);\n        }\n\n        /**\n         * Checks the spacing between two tokens before or after the star token.\n         * @param {string} kind Either \"named\", \"anonymous\", or \"method\"\n         * @param {string} side Either \"before\" or \"after\".\n         * @param {Token} leftToken `function` keyword token if side is \"before\", or\n         *     star token if side is \"after\".\n         * @param {Token} rightToken Star token if side is \"before\", or identifier\n         *     token if side is \"after\".\n         * @returns {void}\n         */\n        function checkSpacing(kind, side, leftToken, rightToken) {\n            if (!!(rightToken.range[0] - leftToken.range[1]) !== modes[kind][side]) {\n                const after = leftToken.value === \"*\";\n                const spaceRequired = modes[kind][side];\n                const node = after ? leftToken : rightToken;\n                const messageId = `${spaceRequired ? \"missing\" : \"unexpected\"}${capitalize(side)}`;\n\n                context.report({\n                    node,\n                    messageId,\n                    fix(fixer) {\n                        if (spaceRequired) {\n                            if (after) {\n                                return fixer.insertTextAfter(node, \" \");\n                            }\n                            return fixer.insertTextBefore(node, \" \");\n                        }\n                        return fixer.removeRange([leftToken.range[1], rightToken.range[0]]);\n                    }\n                });\n            }\n        }\n\n        /**\n         * Enforces the spacing around the star if node is a generator function.\n         * @param {ASTNode} node A function expression or declaration node.\n         * @returns {void}\n         */\n        function checkFunction(node) {\n            if (!node.generator) {\n                return;\n            }\n\n            const starToken = getStarToken(node);\n            const prevToken = sourceCode.getTokenBefore(starToken);\n            const nextToken = sourceCode.getTokenAfter(starToken);\n\n            let kind = \"named\";\n\n            if (node.parent.type === \"MethodDefinition\" || (node.parent.type === \"Property\" && node.parent.method)) {\n                kind = \"method\";\n            } else if (!node.id) {\n                kind = \"anonymous\";\n            }\n\n            // Only check before when preceded by `function`|`static` keyword\n            if (!(kind === \"method\" && starToken === sourceCode.getFirstToken(node.parent))) {\n                checkSpacing(kind, \"before\", prevToken, starToken);\n            }\n\n            checkSpacing(kind, \"after\", starToken, nextToken);\n        }\n\n        return {\n            FunctionDeclaration: checkFunction,\n            FunctionExpression: checkFunction\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\nconst TARGET_NODE_TYPE$1 = /^(?:Arrow)?FunctionExpression$/u;\n\n/**\n * Checks a given code path segment is reachable.\n * @param {CodePathSegment} segment A segment to check.\n * @returns {boolean} `true` if the segment is reachable.\n */\nfunction isReachable$2(segment) {\n    return segment.reachable;\n}\n\n/**\n * Gets a readable location.\n *\n * - FunctionExpression -> the function name or `function` keyword.\n * @param {ASTNode} node A function node to get.\n * @returns {ASTNode|Token} The node or the token of a location.\n */\nfunction getId(node) {\n    return node.id || node;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar getterReturn = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"enforce `return` statements in getters\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/getter-return\"\n        },\n\n        fixable: null,\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allowImplicit: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            expected: \"Expected to return a value in {{name}}.\",\n            expectedAlways: \"Expected {{name}} to always return a value.\"\n        }\n    },\n\n    create(context) {\n\n        const options = context.options[0] || { allowImplicit: false };\n\n        let funcInfo = {\n            upper: null,\n            codePath: null,\n            hasReturn: false,\n            shouldCheck: false,\n            node: null\n        };\n\n        /**\n         * Checks whether or not the last code path segment is reachable.\n         * Then reports this function if the segment is reachable.\n         *\n         * If the last code path segment is reachable, there are paths which are not\n         * returned or thrown.\n         * @param {ASTNode} node A node to check.\n         * @returns {void}\n         */\n        function checkLastSegment(node) {\n            if (funcInfo.shouldCheck &&\n                funcInfo.codePath.currentSegments.some(isReachable$2)\n            ) {\n                context.report({\n                    node,\n                    loc: getId(node).loc.start,\n                    messageId: funcInfo.hasReturn ? \"expectedAlways\" : \"expected\",\n                    data: {\n                        name: astUtils$1.getFunctionNameWithKind(funcInfo.node)\n                    }\n                });\n            }\n        }\n\n        /**\n         * Checks whether a node means a getter function.\n         * @param {ASTNode} node a node to check.\n         * @returns {boolean} if node means a getter, return true; else return false.\n         */\n        function isGetter(node) {\n            const parent = node.parent;\n\n            if (TARGET_NODE_TYPE$1.test(node.type) && node.body.type === \"BlockStatement\") {\n                if (parent.kind === \"get\") {\n                    return true;\n                }\n                if (parent.type === \"Property\" && astUtils$1.getStaticPropertyName(parent) === \"get\" && parent.parent.type === \"ObjectExpression\") {\n\n                    // Object.defineProperty()\n                    if (parent.parent.parent.type === \"CallExpression\" &&\n                        astUtils$1.getStaticPropertyName(parent.parent.parent.callee) === \"defineProperty\") {\n                        return true;\n                    }\n\n                    // Object.defineProperties()\n                    if (parent.parent.parent.type === \"Property\" &&\n                        parent.parent.parent.parent.type === \"ObjectExpression\" &&\n                        parent.parent.parent.parent.parent.type === \"CallExpression\" &&\n                        astUtils$1.getStaticPropertyName(parent.parent.parent.parent.parent.callee) === \"defineProperties\") {\n                        return true;\n                    }\n                }\n            }\n            return false;\n        }\n        return {\n\n            // Stacks this function's information.\n            onCodePathStart(codePath, node) {\n                funcInfo = {\n                    upper: funcInfo,\n                    codePath,\n                    hasReturn: false,\n                    shouldCheck: isGetter(node),\n                    node\n                };\n            },\n\n            // Pops this function's information.\n            onCodePathEnd() {\n                funcInfo = funcInfo.upper;\n            },\n\n            // Checks the return statement is valid.\n            ReturnStatement(node) {\n                if (funcInfo.shouldCheck) {\n                    funcInfo.hasReturn = true;\n\n                    // if allowImplicit: false, should also check node.argument\n                    if (!options.allowImplicit && !node.argument) {\n                        context.report({\n                            node,\n                            messageId: \"expected\",\n                            data: {\n                                name: astUtils$1.getFunctionNameWithKind(funcInfo.node)\n                            }\n                        });\n                    }\n                }\n            },\n\n            // Reports a given function if the last path is reachable.\n            \"FunctionExpression:exit\": checkLastSegment,\n            \"ArrowFunctionExpression:exit\": checkLastSegment\n        };\n    }\n};\n\n/**\n * @fileoverview Rule for disallowing require() outside of the top-level module context\n * @author Jamund Ferguson\n */\n\nconst ACCEPTABLE_PARENTS = [\n    \"AssignmentExpression\",\n    \"VariableDeclarator\",\n    \"MemberExpression\",\n    \"ExpressionStatement\",\n    \"CallExpression\",\n    \"ConditionalExpression\",\n    \"Program\",\n    \"VariableDeclaration\"\n];\n\n/**\n * Finds the eslint-scope reference in the given scope.\n * @param {Object} scope The scope to search.\n * @param {ASTNode} node The identifier node.\n * @returns {Reference|null} Returns the found reference or null if none were found.\n */\nfunction findReference(scope, node) {\n    const references = scope.references.filter(reference => reference.identifier.range[0] === node.range[0] &&\n            reference.identifier.range[1] === node.range[1]);\n\n    /* istanbul ignore else: correctly returns null */\n    if (references.length === 1) {\n        return references[0];\n    }\n    return null;\n\n}\n\n/**\n * Checks if the given identifier node is shadowed in the given scope.\n * @param {Object} scope The current scope.\n * @param {ASTNode} node The identifier node to check.\n * @returns {boolean} Whether or not the name is shadowed.\n */\nfunction isShadowed(scope, node) {\n    const reference = findReference(scope, node);\n\n    return reference && reference.resolved && reference.resolved.defs.length > 0;\n}\n\nvar globalRequire = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require `require()` calls to be placed at top-level module scope\",\n            category: \"Node.js and CommonJS\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/global-require\"\n        },\n\n        schema: [],\n        messages: {\n            unexpected: \"Unexpected require().\"\n        }\n    },\n\n    create(context) {\n        return {\n            CallExpression(node) {\n                const currentScope = context.getScope();\n\n                if (node.callee.name === \"require\" && !isShadowed(currentScope, node.callee)) {\n                    const isGoodRequire = context.getAncestors().every(parent => ACCEPTABLE_PARENTS.indexOf(parent.type) > -1);\n\n                    if (!isGoodRequire) {\n                        context.report({ node, messageId: \"unexpected\" });\n                    }\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Typedefs\n//------------------------------------------------------------------------------\n\n/**\n * Property name if it can be computed statically, otherwise the list of the tokens of the key node.\n * @typedef {string|Token[]} Key\n */\n\n/**\n * Accessor nodes with the same key.\n * @typedef {Object} AccessorData\n * @property {Key} key Accessor's key\n * @property {ASTNode[]} getters List of getter nodes.\n * @property {ASTNode[]} setters List of setter nodes.\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not the given lists represent the equal tokens in the same order.\n * Tokens are compared by their properties, not by instance.\n * @param {Token[]} left First list of tokens.\n * @param {Token[]} right Second list of tokens.\n * @returns {boolean} `true` if the lists have same tokens.\n */\nfunction areEqualTokenLists$1(left, right) {\n    if (left.length !== right.length) {\n        return false;\n    }\n\n    for (let i = 0; i < left.length; i++) {\n        const leftToken = left[i],\n            rightToken = right[i];\n\n        if (leftToken.type !== rightToken.type || leftToken.value !== rightToken.value) {\n            return false;\n        }\n    }\n\n    return true;\n}\n\n/**\n * Checks whether or not the given keys are equal.\n * @param {Key} left First key.\n * @param {Key} right Second key.\n * @returns {boolean} `true` if the keys are equal.\n */\nfunction areEqualKeys$1(left, right) {\n    if (typeof left === \"string\" && typeof right === \"string\") {\n\n        // Statically computed names.\n        return left === right;\n    }\n    if (Array.isArray(left) && Array.isArray(right)) {\n\n        // Token lists.\n        return areEqualTokenLists$1(left, right);\n    }\n\n    return false;\n}\n\n/**\n * Checks whether or not a given node is of an accessor kind ('get' or 'set').\n * @param {ASTNode} node A node to check.\n * @returns {boolean} `true` if the node is of an accessor kind.\n */\nfunction isAccessorKind$1(node) {\n    return node.kind === \"get\" || node.kind === \"set\";\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar groupedAccessorPairs = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require grouped accessor pairs in object literals and classes\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/grouped-accessor-pairs\"\n        },\n\n        schema: [\n            {\n                enum: [\"anyOrder\", \"getBeforeSet\", \"setBeforeGet\"]\n            }\n        ],\n\n        messages: {\n            notGrouped: \"Accessor pair {{ formerName }} and {{ latterName }} should be grouped.\",\n            invalidOrder: \"Expected {{ latterName }} to be before {{ formerName }}.\"\n        }\n    },\n\n    create(context) {\n        const order = context.options[0] || \"anyOrder\";\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Reports the given accessor pair.\n         * @param {string} messageId messageId to report.\n         * @param {ASTNode} formerNode getter/setter node that is defined before `latterNode`.\n         * @param {ASTNode} latterNode getter/setter node that is defined after `formerNode`.\n         * @returns {void}\n         * @private\n         */\n        function report(messageId, formerNode, latterNode) {\n            context.report({\n                node: latterNode,\n                messageId,\n                loc: astUtils$1.getFunctionHeadLoc(latterNode.value, sourceCode),\n                data: {\n                    formerName: astUtils$1.getFunctionNameWithKind(formerNode.value),\n                    latterName: astUtils$1.getFunctionNameWithKind(latterNode.value)\n                }\n            });\n        }\n\n        /**\n         * Creates a new `AccessorData` object for the given getter or setter node.\n         * @param {ASTNode} node A getter or setter node.\n         * @returns {AccessorData} New `AccessorData` object that contains the given node.\n         * @private\n         */\n        function createAccessorData(node) {\n            const name = astUtils$1.getStaticPropertyName(node);\n            const key = (name !== null) ? name : sourceCode.getTokens(node.key);\n\n            return {\n                key,\n                getters: node.kind === \"get\" ? [node] : [],\n                setters: node.kind === \"set\" ? [node] : []\n            };\n        }\n\n        /**\n         * Merges the given `AccessorData` object into the given accessors list.\n         * @param {AccessorData[]} accessors The list to merge into.\n         * @param {AccessorData} accessorData The object to merge.\n         * @returns {AccessorData[]} The same instance with the merged object.\n         * @private\n         */\n        function mergeAccessorData(accessors, accessorData) {\n            const equalKeyElement = accessors.find(a => areEqualKeys$1(a.key, accessorData.key));\n\n            if (equalKeyElement) {\n                equalKeyElement.getters.push(...accessorData.getters);\n                equalKeyElement.setters.push(...accessorData.setters);\n            } else {\n                accessors.push(accessorData);\n            }\n\n            return accessors;\n        }\n\n        /**\n         * Checks accessor pairs in the given list of nodes.\n         * @param {ASTNode[]} nodes The list to check.\n         * @param {Function} shouldCheck – Predicate that returns `true` if the node should be checked.\n         * @returns {void}\n         * @private\n         */\n        function checkList(nodes, shouldCheck) {\n            const accessors = nodes\n                .filter(shouldCheck)\n                .filter(isAccessorKind$1)\n                .map(createAccessorData)\n                .reduce(mergeAccessorData, []);\n\n            for (const { getters, setters } of accessors) {\n\n                // Don't report accessor properties that have duplicate getters or setters.\n                if (getters.length === 1 && setters.length === 1) {\n                    const [getter] = getters,\n                        [setter] = setters,\n                        getterIndex = nodes.indexOf(getter),\n                        setterIndex = nodes.indexOf(setter),\n                        formerNode = getterIndex < setterIndex ? getter : setter,\n                        latterNode = getterIndex < setterIndex ? setter : getter;\n\n                    if (Math.abs(getterIndex - setterIndex) > 1) {\n                        report(\"notGrouped\", formerNode, latterNode);\n                    } else if (\n                        (order === \"getBeforeSet\" && getterIndex > setterIndex) ||\n                        (order === \"setBeforeGet\" && getterIndex < setterIndex)\n                    ) {\n                        report(\"invalidOrder\", formerNode, latterNode);\n                    }\n                }\n            }\n        }\n\n        return {\n            ObjectExpression(node) {\n                checkList(node.properties, n => n.type === \"Property\");\n            },\n            ClassBody(node) {\n                checkList(node.body, n => n.type === \"MethodDefinition\" && !n.static);\n                checkList(node.body, n => n.type === \"MethodDefinition\" && n.static);\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag for-in loops without if statements inside\n * @author Nicholas C. Zakas\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar guardForIn = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require `for-in` loops to include an `if` statement\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/guard-for-in\"\n        },\n\n        schema: [],\n        messages: {\n            wrap: \"The body of a for-in should be wrapped in an if statement to filter unwanted properties from the prototype.\"\n        }\n    },\n\n    create(context) {\n\n        return {\n\n            ForInStatement(node) {\n                const body = node.body;\n\n                // empty statement\n                if (body.type === \"EmptyStatement\") {\n                    return;\n                }\n\n                // if statement\n                if (body.type === \"IfStatement\") {\n                    return;\n                }\n\n                // empty block\n                if (body.type === \"BlockStatement\" && body.body.length === 0) {\n                    return;\n                }\n\n                // block with just if statement\n                if (body.type === \"BlockStatement\" && body.body.length === 1 && body.body[0].type === \"IfStatement\") {\n                    return;\n                }\n\n                // block that starts with if statement\n                if (body.type === \"BlockStatement\" && body.body.length >= 1 && body.body[0].type === \"IfStatement\") {\n                    const i = body.body[0];\n\n                    // ... whose consequent is a continue\n                    if (i.consequent.type === \"ContinueStatement\") {\n                        return;\n                    }\n\n                    // ... whose consequent is a block that contains only a continue\n                    if (i.consequent.type === \"BlockStatement\" && i.consequent.body.length === 1 && i.consequent.body[0].type === \"ContinueStatement\") {\n                        return;\n                    }\n                }\n\n                context.report({ node, messageId: \"wrap\" });\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Ensure handling of errors when we know they exist.\n * @author Jamund Ferguson\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar handleCallbackErr = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require error handling in callbacks\",\n            category: \"Node.js and CommonJS\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/handle-callback-err\"\n        },\n\n        schema: [\n            {\n                type: \"string\"\n            }\n        ],\n        messages: {\n            expected: \"Expected error to be handled.\"\n        }\n    },\n\n    create(context) {\n\n        const errorArgument = context.options[0] || \"err\";\n\n        /**\n         * Checks if the given argument should be interpreted as a regexp pattern.\n         * @param {string} stringToCheck The string which should be checked.\n         * @returns {boolean} Whether or not the string should be interpreted as a pattern.\n         */\n        function isPattern(stringToCheck) {\n            const firstChar = stringToCheck[0];\n\n            return firstChar === \"^\";\n        }\n\n        /**\n         * Checks if the given name matches the configured error argument.\n         * @param {string} name The name which should be compared.\n         * @returns {boolean} Whether or not the given name matches the configured error variable name.\n         */\n        function matchesConfiguredErrorName(name) {\n            if (isPattern(errorArgument)) {\n                const regexp = new RegExp(errorArgument, \"u\");\n\n                return regexp.test(name);\n            }\n            return name === errorArgument;\n        }\n\n        /**\n         * Get the parameters of a given function scope.\n         * @param {Object} scope The function scope.\n         * @returns {Array} All parameters of the given scope.\n         */\n        function getParameters(scope) {\n            return scope.variables.filter(variable => variable.defs[0] && variable.defs[0].type === \"Parameter\");\n        }\n\n        /**\n         * Check to see if we're handling the error object properly.\n         * @param {ASTNode} node The AST node to check.\n         * @returns {void}\n         */\n        function checkForError(node) {\n            const scope = context.getScope(),\n                parameters = getParameters(scope),\n                firstParameter = parameters[0];\n\n            if (firstParameter && matchesConfiguredErrorName(firstParameter.name)) {\n                if (firstParameter.references.length === 0) {\n                    context.report({ node, messageId: \"expected\" });\n                }\n            }\n        }\n\n        return {\n            FunctionDeclaration: checkForError,\n            FunctionExpression: checkForError,\n            ArrowFunctionExpression: checkForError\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule that warns when identifier names that are\n * blacklisted in the configuration are used.\n * @author Keith Cirkel (http://keithcirkel.co.uk)\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar idBlacklist = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow specified identifiers\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/id-blacklist\"\n        },\n\n        schema: {\n            type: \"array\",\n            items: {\n                type: \"string\"\n            },\n            uniqueItems: true\n        },\n        messages: {\n            blacklisted: \"Identifier '{{name}}' is blacklisted.\"\n        }\n    },\n\n    create(context) {\n\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        const blacklist = context.options;\n\n\n        /**\n         * Checks if a string matches the provided pattern\n         * @param {string} name The string to check.\n         * @returns {boolean} if the string is a match\n         * @private\n         */\n        function isInvalid(name) {\n            return blacklist.indexOf(name) !== -1;\n        }\n\n        /**\n         * Verifies if we should report an error or not based on the effective\n         * parent node and the identifier name.\n         * @param {ASTNode} effectiveParent The effective parent node of the node to be reported\n         * @param {string} name The identifier name of the identifier node\n         * @returns {boolean} whether an error should be reported or not\n         */\n        function shouldReport(effectiveParent, name) {\n            return effectiveParent.type !== \"CallExpression\" &&\n                effectiveParent.type !== \"NewExpression\" &&\n                isInvalid(name);\n        }\n\n        /**\n         * Reports an AST node as a rule violation.\n         * @param {ASTNode} node The node to report.\n         * @returns {void}\n         * @private\n         */\n        function report(node) {\n            context.report({\n                node,\n                messageId: \"blacklisted\",\n                data: {\n                    name: node.name\n                }\n            });\n        }\n\n        return {\n\n            Identifier(node) {\n                const name = node.name,\n                    effectiveParent = (node.parent.type === \"MemberExpression\") ? node.parent.parent : node.parent;\n\n                // MemberExpressions get special rules\n                if (node.parent.type === \"MemberExpression\") {\n\n                    // Always check object names\n                    if (node.parent.object.type === \"Identifier\" &&\n                        node.parent.object.name === node.name) {\n                        if (isInvalid(name)) {\n                            report(node);\n                        }\n\n                        // Report AssignmentExpressions only if they are the left side of the assignment\n                    } else if (effectiveParent.type === \"AssignmentExpression\" &&\n                        (effectiveParent.right.type !== \"MemberExpression\" ||\n                        effectiveParent.left.type === \"MemberExpression\" &&\n                        effectiveParent.left.property.name === node.name)) {\n                        if (isInvalid(name)) {\n                            report(node);\n                        }\n                    }\n\n                // Properties have their own rules\n                } else if (node.parent.type === \"Property\") {\n\n                    if (shouldReport(effectiveParent, name)) {\n                        report(node);\n                    }\n\n                // Report anything that is a match and not a CallExpression\n                } else if (shouldReport(effectiveParent, name)) {\n                    report(node);\n                }\n            }\n\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule that warns when identifier names are shorter or longer\n * than the values provided in configuration.\n * @author Burak Yigit Kaya aka BYK\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar idLength = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce minimum and maximum identifier lengths\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/id-length\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    min: {\n                        type: \"integer\",\n                        default: 2\n                    },\n                    max: {\n                        type: \"integer\"\n                    },\n                    exceptions: {\n                        type: \"array\",\n                        uniqueItems: true,\n                        items: {\n                            type: \"string\"\n                        }\n                    },\n                    properties: {\n                        enum: [\"always\", \"never\"]\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n        messages: {\n            tooShort: \"Identifier name '{{name}}' is too short (< {{min}}).\",\n            tooLong: \"Identifier name '{{name}}' is too long (> {{max}}).\"\n        }\n    },\n\n    create(context) {\n        const options = context.options[0] || {};\n        const minLength = typeof options.min !== \"undefined\" ? options.min : 2;\n        const maxLength = typeof options.max !== \"undefined\" ? options.max : Infinity;\n        const properties = options.properties !== \"never\";\n        const exceptions = (options.exceptions ? options.exceptions : [])\n            .reduce((obj, item) => {\n                obj[item] = true;\n\n                return obj;\n            }, {});\n\n        const SUPPORTED_EXPRESSIONS = {\n            MemberExpression: properties && function(parent) {\n                return !parent.computed && (\n\n                    // regular property assignment\n                    (parent.parent.left === parent && parent.parent.type === \"AssignmentExpression\" ||\n\n                    // or the last identifier in an ObjectPattern destructuring\n                    parent.parent.type === \"Property\" && parent.parent.value === parent &&\n                    parent.parent.parent.type === \"ObjectPattern\" && parent.parent.parent.parent.left === parent.parent.parent)\n                );\n            },\n            AssignmentPattern(parent, node) {\n                return parent.left === node;\n            },\n            VariableDeclarator(parent, node) {\n                return parent.id === node;\n            },\n            Property: properties && function(parent, node) {\n                return parent.key === node;\n            },\n            ImportDefaultSpecifier: true,\n            RestElement: true,\n            FunctionExpression: true,\n            ArrowFunctionExpression: true,\n            ClassDeclaration: true,\n            FunctionDeclaration: true,\n            MethodDefinition: true,\n            CatchClause: true\n        };\n\n        return {\n            Identifier(node) {\n                const name = node.name;\n                const parent = node.parent;\n\n                const isShort = name.length < minLength;\n                const isLong = name.length > maxLength;\n\n                if (!(isShort || isLong) || exceptions[name]) {\n                    return; // Nothing to report\n                }\n\n                const isValidExpression = SUPPORTED_EXPRESSIONS[parent.type];\n\n                if (isValidExpression && (isValidExpression === true || isValidExpression(parent, node))) {\n                    context.report({\n                        node,\n                        messageId: isShort ? \"tooShort\" : \"tooLong\",\n                        data: { name, min: minLength, max: maxLength }\n                    });\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag non-matching identifiers\n * @author Matthieu Larcher\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar idMatch = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require identifiers to match a specified regular expression\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/id-match\"\n        },\n\n        schema: [\n            {\n                type: \"string\"\n            },\n            {\n                type: \"object\",\n                properties: {\n                    properties: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    onlyDeclarations: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    ignoreDestructuring: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                }\n            }\n        ],\n        messages: {\n            notMatch: \"Identifier '{{name}}' does not match the pattern '{{pattern}}'.\"\n        }\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Options\n        //--------------------------------------------------------------------------\n        const pattern = context.options[0] || \"^.+$\",\n            regexp = new RegExp(pattern, \"u\");\n\n        const options = context.options[1] || {},\n            properties = !!options.properties,\n            onlyDeclarations = !!options.onlyDeclarations,\n            ignoreDestructuring = !!options.ignoreDestructuring;\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        // contains reported nodes to avoid reporting twice on destructuring with shorthand notation\n        const reported = new Map();\n        const ALLOWED_PARENT_TYPES = new Set([\"CallExpression\", \"NewExpression\"]);\n        const DECLARATION_TYPES = new Set([\"FunctionDeclaration\", \"VariableDeclarator\"]);\n        const IMPORT_TYPES = new Set([\"ImportSpecifier\", \"ImportNamespaceSpecifier\", \"ImportDefaultSpecifier\"]);\n\n        /**\n         * Checks if a string matches the provided pattern\n         * @param {string} name The string to check.\n         * @returns {boolean} if the string is a match\n         * @private\n         */\n        function isInvalid(name) {\n            return !regexp.test(name);\n        }\n\n        /**\n         * Checks if a parent of a node is an ObjectPattern.\n         * @param {ASTNode} node The node to check.\n         * @returns {boolean} if the node is inside an ObjectPattern\n         * @private\n         */\n        function isInsideObjectPattern(node) {\n            let { parent } = node;\n\n            while (parent) {\n                if (parent.type === \"ObjectPattern\") {\n                    return true;\n                }\n\n                parent = parent.parent;\n            }\n\n            return false;\n        }\n\n        /**\n         * Verifies if we should report an error or not based on the effective\n         * parent node and the identifier name.\n         * @param {ASTNode} effectiveParent The effective parent node of the node to be reported\n         * @param {string} name The identifier name of the identifier node\n         * @returns {boolean} whether an error should be reported or not\n         */\n        function shouldReport(effectiveParent, name) {\n            return (!onlyDeclarations || DECLARATION_TYPES.has(effectiveParent.type)) &&\n                !ALLOWED_PARENT_TYPES.has(effectiveParent.type) && isInvalid(name);\n        }\n\n        /**\n         * Reports an AST node as a rule violation.\n         * @param {ASTNode} node The node to report.\n         * @returns {void}\n         * @private\n         */\n        function report(node) {\n            if (!reported.has(node)) {\n                context.report({\n                    node,\n                    messageId: \"notMatch\",\n                    data: {\n                        name: node.name,\n                        pattern\n                    }\n                });\n                reported.set(node, true);\n            }\n        }\n\n        return {\n\n            Identifier(node) {\n                const name = node.name,\n                    parent = node.parent,\n                    effectiveParent = (parent.type === \"MemberExpression\") ? parent.parent : parent;\n\n                if (parent.type === \"MemberExpression\") {\n\n                    if (!properties) {\n                        return;\n                    }\n\n                    // Always check object names\n                    if (parent.object.type === \"Identifier\" &&\n                        parent.object.name === name) {\n                        if (isInvalid(name)) {\n                            report(node);\n                        }\n\n                    // Report AssignmentExpressions left side's assigned variable id\n                    } else if (effectiveParent.type === \"AssignmentExpression\" &&\n                        effectiveParent.left.type === \"MemberExpression\" &&\n                        effectiveParent.left.property.name === node.name) {\n                        if (isInvalid(name)) {\n                            report(node);\n                        }\n\n                    // Report AssignmentExpressions only if they are the left side of the assignment\n                    } else if (effectiveParent.type === \"AssignmentExpression\" && effectiveParent.right.type !== \"MemberExpression\") {\n                        if (isInvalid(name)) {\n                            report(node);\n                        }\n                    }\n\n                /*\n                 * Properties have their own rules, and\n                 * AssignmentPattern nodes can be treated like Properties:\n                 * e.g.: const { no_camelcased = false } = bar;\n                 */\n                } else if (parent.type === \"Property\" || parent.type === \"AssignmentPattern\") {\n\n                    if (parent.parent && parent.parent.type === \"ObjectPattern\") {\n                        if (parent.shorthand && parent.value.left && isInvalid(name)) {\n\n                            report(node);\n                        }\n\n                        const assignmentKeyEqualsValue = parent.key.name === parent.value.name;\n\n                        // prevent checking righthand side of destructured object\n                        if (!assignmentKeyEqualsValue && parent.key === node) {\n                            return;\n                        }\n\n                        const valueIsInvalid = parent.value.name && isInvalid(name);\n\n                        // ignore destructuring if the option is set, unless a new identifier is created\n                        if (valueIsInvalid && !(assignmentKeyEqualsValue && ignoreDestructuring)) {\n                            report(node);\n                        }\n                    }\n\n                    // never check properties or always ignore destructuring\n                    if (!properties || (ignoreDestructuring && isInsideObjectPattern(node))) {\n                        return;\n                    }\n\n                    // don't check right hand side of AssignmentExpression to prevent duplicate warnings\n                    if (parent.right !== node && shouldReport(effectiveParent, name)) {\n                        report(node);\n                    }\n\n                // Check if it's an import specifier\n                } else if (IMPORT_TYPES.has(parent.type)) {\n\n                    // Report only if the local imported identifier is invalid\n                    if (parent.local && parent.local.name === node.name && isInvalid(name)) {\n                        report(node);\n                    }\n\n                // Report anything that is invalid that isn't a CallExpression\n                } else if (shouldReport(effectiveParent, name)) {\n                    report(node);\n                }\n            }\n\n        };\n\n    }\n};\n\nconst { isCommentToken, isNotOpeningParenToken } = astUtils$1;\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\nvar implicitArrowLinebreak = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce the location of arrow function bodies\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/implicit-arrow-linebreak\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                enum: [\"beside\", \"below\"]\n            }\n        ],\n        messages: {\n            expected: \"Expected a linebreak before this expression.\",\n            unexpected: \"Expected no linebreak before this expression.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const option = context.options[0] || \"beside\";\n\n        /**\n         * Validates the location of an arrow function body\n         * @param {ASTNode} node The arrow function body\n         * @returns {void}\n         */\n        function validateExpression(node) {\n            if (node.body.type === \"BlockStatement\") {\n                return;\n            }\n\n            const arrowToken = sourceCode.getTokenBefore(node.body, isNotOpeningParenToken);\n            const firstTokenOfBody = sourceCode.getTokenAfter(arrowToken);\n\n            if (arrowToken.loc.end.line === firstTokenOfBody.loc.start.line && option === \"below\") {\n                context.report({\n                    node: firstTokenOfBody,\n                    messageId: \"expected\",\n                    fix: fixer => fixer.insertTextBefore(firstTokenOfBody, \"\\n\")\n                });\n            } else if (arrowToken.loc.end.line !== firstTokenOfBody.loc.start.line && option === \"beside\") {\n                context.report({\n                    node: firstTokenOfBody,\n                    messageId: \"unexpected\",\n                    fix(fixer) {\n                        if (sourceCode.getFirstTokenBetween(arrowToken, firstTokenOfBody, { includeComments: true, filter: isCommentToken })) {\n                            return null;\n                        }\n\n                        return fixer.replaceTextRange([arrowToken.range[1], firstTokenOfBody.range[0]], \" \");\n                    }\n                });\n            }\n        }\n\n        //----------------------------------------------------------------------\n        // Public\n        //----------------------------------------------------------------------\n        return {\n            ArrowFunctionExpression: node => validateExpression(node)\n        };\n    }\n};\n\nvar rbtree = createRBTree;\n\nvar RED   = 0;\nvar BLACK = 1;\n\nfunction RBNode(color, key, value, left, right, count) {\n  this._color = color;\n  this.key = key;\n  this.value = value;\n  this.left = left;\n  this.right = right;\n  this._count = count;\n}\n\nfunction cloneNode(node) {\n  return new RBNode(node._color, node.key, node.value, node.left, node.right, node._count)\n}\n\nfunction repaint(color, node) {\n  return new RBNode(color, node.key, node.value, node.left, node.right, node._count)\n}\n\nfunction recount(node) {\n  node._count = 1 + (node.left ? node.left._count : 0) + (node.right ? node.right._count : 0);\n}\n\nfunction RedBlackTree(compare, root) {\n  this._compare = compare;\n  this.root = root;\n}\n\nvar proto$1 = RedBlackTree.prototype;\n\nObject.defineProperty(proto$1, \"keys\", {\n  get: function() {\n    var result = [];\n    this.forEach(function(k,v) {\n      result.push(k);\n    });\n    return result\n  }\n});\n\nObject.defineProperty(proto$1, \"values\", {\n  get: function() {\n    var result = [];\n    this.forEach(function(k,v) {\n      result.push(v);\n    });\n    return result\n  }\n});\n\n//Returns the number of nodes in the tree\nObject.defineProperty(proto$1, \"length\", {\n  get: function() {\n    if(this.root) {\n      return this.root._count\n    }\n    return 0\n  }\n});\n\n//Insert a new item into the tree\nproto$1.insert = function(key, value) {\n  var cmp = this._compare;\n  //Find point to insert new node at\n  var n = this.root;\n  var n_stack = [];\n  var d_stack = [];\n  while(n) {\n    var d = cmp(key, n.key);\n    n_stack.push(n);\n    d_stack.push(d);\n    if(d <= 0) {\n      n = n.left;\n    } else {\n      n = n.right;\n    }\n  }\n  //Rebuild path to leaf node\n  n_stack.push(new RBNode(RED, key, value, null, null, 1));\n  for(var s=n_stack.length-2; s>=0; --s) {\n    var n = n_stack[s];\n    if(d_stack[s] <= 0) {\n      n_stack[s] = new RBNode(n._color, n.key, n.value, n_stack[s+1], n.right, n._count+1);\n    } else {\n      n_stack[s] = new RBNode(n._color, n.key, n.value, n.left, n_stack[s+1], n._count+1);\n    }\n  }\n  //Rebalance tree using rotations\n  //console.log(\"start insert\", key, d_stack)\n  for(var s=n_stack.length-1; s>1; --s) {\n    var p = n_stack[s-1];\n    var n = n_stack[s];\n    if(p._color === BLACK || n._color === BLACK) {\n      break\n    }\n    var pp = n_stack[s-2];\n    if(pp.left === p) {\n      if(p.left === n) {\n        var y = pp.right;\n        if(y && y._color === RED) {\n          //console.log(\"LLr\")\n          p._color = BLACK;\n          pp.right = repaint(BLACK, y);\n          pp._color = RED;\n          s -= 1;\n        } else {\n          //console.log(\"LLb\")\n          pp._color = RED;\n          pp.left = p.right;\n          p._color = BLACK;\n          p.right = pp;\n          n_stack[s-2] = p;\n          n_stack[s-1] = n;\n          recount(pp);\n          recount(p);\n          if(s >= 3) {\n            var ppp = n_stack[s-3];\n            if(ppp.left === pp) {\n              ppp.left = p;\n            } else {\n              ppp.right = p;\n            }\n          }\n          break\n        }\n      } else {\n        var y = pp.right;\n        if(y && y._color === RED) {\n          //console.log(\"LRr\")\n          p._color = BLACK;\n          pp.right = repaint(BLACK, y);\n          pp._color = RED;\n          s -= 1;\n        } else {\n          //console.log(\"LRb\")\n          p.right = n.left;\n          pp._color = RED;\n          pp.left = n.right;\n          n._color = BLACK;\n          n.left = p;\n          n.right = pp;\n          n_stack[s-2] = n;\n          n_stack[s-1] = p;\n          recount(pp);\n          recount(p);\n          recount(n);\n          if(s >= 3) {\n            var ppp = n_stack[s-3];\n            if(ppp.left === pp) {\n              ppp.left = n;\n            } else {\n              ppp.right = n;\n            }\n          }\n          break\n        }\n      }\n    } else {\n      if(p.right === n) {\n        var y = pp.left;\n        if(y && y._color === RED) {\n          //console.log(\"RRr\", y.key)\n          p._color = BLACK;\n          pp.left = repaint(BLACK, y);\n          pp._color = RED;\n          s -= 1;\n        } else {\n          //console.log(\"RRb\")\n          pp._color = RED;\n          pp.right = p.left;\n          p._color = BLACK;\n          p.left = pp;\n          n_stack[s-2] = p;\n          n_stack[s-1] = n;\n          recount(pp);\n          recount(p);\n          if(s >= 3) {\n            var ppp = n_stack[s-3];\n            if(ppp.right === pp) {\n              ppp.right = p;\n            } else {\n              ppp.left = p;\n            }\n          }\n          break\n        }\n      } else {\n        var y = pp.left;\n        if(y && y._color === RED) {\n          //console.log(\"RLr\")\n          p._color = BLACK;\n          pp.left = repaint(BLACK, y);\n          pp._color = RED;\n          s -= 1;\n        } else {\n          //console.log(\"RLb\")\n          p.left = n.right;\n          pp._color = RED;\n          pp.right = n.left;\n          n._color = BLACK;\n          n.right = p;\n          n.left = pp;\n          n_stack[s-2] = n;\n          n_stack[s-1] = p;\n          recount(pp);\n          recount(p);\n          recount(n);\n          if(s >= 3) {\n            var ppp = n_stack[s-3];\n            if(ppp.right === pp) {\n              ppp.right = n;\n            } else {\n              ppp.left = n;\n            }\n          }\n          break\n        }\n      }\n    }\n  }\n  //Return new tree\n  n_stack[0]._color = BLACK;\n  return new RedBlackTree(cmp, n_stack[0])\n};\n\n\n//Visit all nodes inorder\nfunction doVisitFull(visit, node) {\n  if(node.left) {\n    var v = doVisitFull(visit, node.left);\n    if(v) { return v }\n  }\n  var v = visit(node.key, node.value);\n  if(v) { return v }\n  if(node.right) {\n    return doVisitFull(visit, node.right)\n  }\n}\n\n//Visit half nodes in order\nfunction doVisitHalf(lo, compare, visit, node) {\n  var l = compare(lo, node.key);\n  if(l <= 0) {\n    if(node.left) {\n      var v = doVisitHalf(lo, compare, visit, node.left);\n      if(v) { return v }\n    }\n    var v = visit(node.key, node.value);\n    if(v) { return v }\n  }\n  if(node.right) {\n    return doVisitHalf(lo, compare, visit, node.right)\n  }\n}\n\n//Visit all nodes within a range\nfunction doVisit(lo, hi, compare, visit, node) {\n  var l = compare(lo, node.key);\n  var h = compare(hi, node.key);\n  var v;\n  if(l <= 0) {\n    if(node.left) {\n      v = doVisit(lo, hi, compare, visit, node.left);\n      if(v) { return v }\n    }\n    if(h > 0) {\n      v = visit(node.key, node.value);\n      if(v) { return v }\n    }\n  }\n  if(h > 0 && node.right) {\n    return doVisit(lo, hi, compare, visit, node.right)\n  }\n}\n\n\nproto$1.forEach = function rbTreeForEach(visit, lo, hi) {\n  if(!this.root) {\n    return\n  }\n  switch(arguments.length) {\n    case 1:\n      return doVisitFull(visit, this.root)\n\n    case 2:\n      return doVisitHalf(lo, this._compare, visit, this.root)\n\n    case 3:\n      if(this._compare(lo, hi) >= 0) {\n        return\n      }\n      return doVisit(lo, hi, this._compare, visit, this.root)\n  }\n};\n\n//First item in list\nObject.defineProperty(proto$1, \"begin\", {\n  get: function() {\n    var stack = [];\n    var n = this.root;\n    while(n) {\n      stack.push(n);\n      n = n.left;\n    }\n    return new RedBlackTreeIterator(this, stack)\n  }\n});\n\n//Last item in list\nObject.defineProperty(proto$1, \"end\", {\n  get: function() {\n    var stack = [];\n    var n = this.root;\n    while(n) {\n      stack.push(n);\n      n = n.right;\n    }\n    return new RedBlackTreeIterator(this, stack)\n  }\n});\n\n//Find the ith item in the tree\nproto$1.at = function(idx) {\n  if(idx < 0) {\n    return new RedBlackTreeIterator(this, [])\n  }\n  var n = this.root;\n  var stack = [];\n  while(true) {\n    stack.push(n);\n    if(n.left) {\n      if(idx < n.left._count) {\n        n = n.left;\n        continue\n      }\n      idx -= n.left._count;\n    }\n    if(!idx) {\n      return new RedBlackTreeIterator(this, stack)\n    }\n    idx -= 1;\n    if(n.right) {\n      if(idx >= n.right._count) {\n        break\n      }\n      n = n.right;\n    } else {\n      break\n    }\n  }\n  return new RedBlackTreeIterator(this, [])\n};\n\nproto$1.ge = function(key) {\n  var cmp = this._compare;\n  var n = this.root;\n  var stack = [];\n  var last_ptr = 0;\n  while(n) {\n    var d = cmp(key, n.key);\n    stack.push(n);\n    if(d <= 0) {\n      last_ptr = stack.length;\n    }\n    if(d <= 0) {\n      n = n.left;\n    } else {\n      n = n.right;\n    }\n  }\n  stack.length = last_ptr;\n  return new RedBlackTreeIterator(this, stack)\n};\n\nproto$1.gt = function(key) {\n  var cmp = this._compare;\n  var n = this.root;\n  var stack = [];\n  var last_ptr = 0;\n  while(n) {\n    var d = cmp(key, n.key);\n    stack.push(n);\n    if(d < 0) {\n      last_ptr = stack.length;\n    }\n    if(d < 0) {\n      n = n.left;\n    } else {\n      n = n.right;\n    }\n  }\n  stack.length = last_ptr;\n  return new RedBlackTreeIterator(this, stack)\n};\n\nproto$1.lt = function(key) {\n  var cmp = this._compare;\n  var n = this.root;\n  var stack = [];\n  var last_ptr = 0;\n  while(n) {\n    var d = cmp(key, n.key);\n    stack.push(n);\n    if(d > 0) {\n      last_ptr = stack.length;\n    }\n    if(d <= 0) {\n      n = n.left;\n    } else {\n      n = n.right;\n    }\n  }\n  stack.length = last_ptr;\n  return new RedBlackTreeIterator(this, stack)\n};\n\nproto$1.le = function(key) {\n  var cmp = this._compare;\n  var n = this.root;\n  var stack = [];\n  var last_ptr = 0;\n  while(n) {\n    var d = cmp(key, n.key);\n    stack.push(n);\n    if(d >= 0) {\n      last_ptr = stack.length;\n    }\n    if(d < 0) {\n      n = n.left;\n    } else {\n      n = n.right;\n    }\n  }\n  stack.length = last_ptr;\n  return new RedBlackTreeIterator(this, stack)\n};\n\n//Finds the item with key if it exists\nproto$1.find = function(key) {\n  var cmp = this._compare;\n  var n = this.root;\n  var stack = [];\n  while(n) {\n    var d = cmp(key, n.key);\n    stack.push(n);\n    if(d === 0) {\n      return new RedBlackTreeIterator(this, stack)\n    }\n    if(d <= 0) {\n      n = n.left;\n    } else {\n      n = n.right;\n    }\n  }\n  return new RedBlackTreeIterator(this, [])\n};\n\n//Removes item with key from tree\nproto$1.remove = function(key) {\n  var iter = this.find(key);\n  if(iter) {\n    return iter.remove()\n  }\n  return this\n};\n\n//Returns the item at `key`\nproto$1.get = function(key) {\n  var cmp = this._compare;\n  var n = this.root;\n  while(n) {\n    var d = cmp(key, n.key);\n    if(d === 0) {\n      return n.value\n    }\n    if(d <= 0) {\n      n = n.left;\n    } else {\n      n = n.right;\n    }\n  }\n  return\n};\n\n//Iterator for red black tree\nfunction RedBlackTreeIterator(tree, stack) {\n  this.tree = tree;\n  this._stack = stack;\n}\n\nvar iproto = RedBlackTreeIterator.prototype;\n\n//Test if iterator is valid\nObject.defineProperty(iproto, \"valid\", {\n  get: function() {\n    return this._stack.length > 0\n  }\n});\n\n//Node of the iterator\nObject.defineProperty(iproto, \"node\", {\n  get: function() {\n    if(this._stack.length > 0) {\n      return this._stack[this._stack.length-1]\n    }\n    return null\n  },\n  enumerable: true\n});\n\n//Makes a copy of an iterator\niproto.clone = function() {\n  return new RedBlackTreeIterator(this.tree, this._stack.slice())\n};\n\n//Swaps two nodes\nfunction swapNode(n, v) {\n  n.key = v.key;\n  n.value = v.value;\n  n.left = v.left;\n  n.right = v.right;\n  n._color = v._color;\n  n._count = v._count;\n}\n\n//Fix up a double black node in a tree\nfunction fixDoubleBlack(stack) {\n  var n, p, s, z;\n  for(var i=stack.length-1; i>=0; --i) {\n    n = stack[i];\n    if(i === 0) {\n      n._color = BLACK;\n      return\n    }\n    //console.log(\"visit node:\", n.key, i, stack[i].key, stack[i-1].key)\n    p = stack[i-1];\n    if(p.left === n) {\n      //console.log(\"left child\")\n      s = p.right;\n      if(s.right && s.right._color === RED) {\n        //console.log(\"case 1: right sibling child red\")\n        s = p.right = cloneNode(s);\n        z = s.right = cloneNode(s.right);\n        p.right = s.left;\n        s.left = p;\n        s.right = z;\n        s._color = p._color;\n        n._color = BLACK;\n        p._color = BLACK;\n        z._color = BLACK;\n        recount(p);\n        recount(s);\n        if(i > 1) {\n          var pp = stack[i-2];\n          if(pp.left === p) {\n            pp.left = s;\n          } else {\n            pp.right = s;\n          }\n        }\n        stack[i-1] = s;\n        return\n      } else if(s.left && s.left._color === RED) {\n        //console.log(\"case 1: left sibling child red\")\n        s = p.right = cloneNode(s);\n        z = s.left = cloneNode(s.left);\n        p.right = z.left;\n        s.left = z.right;\n        z.left = p;\n        z.right = s;\n        z._color = p._color;\n        p._color = BLACK;\n        s._color = BLACK;\n        n._color = BLACK;\n        recount(p);\n        recount(s);\n        recount(z);\n        if(i > 1) {\n          var pp = stack[i-2];\n          if(pp.left === p) {\n            pp.left = z;\n          } else {\n            pp.right = z;\n          }\n        }\n        stack[i-1] = z;\n        return\n      }\n      if(s._color === BLACK) {\n        if(p._color === RED) {\n          //console.log(\"case 2: black sibling, red parent\", p.right.value)\n          p._color = BLACK;\n          p.right = repaint(RED, s);\n          return\n        } else {\n          //console.log(\"case 2: black sibling, black parent\", p.right.value)\n          p.right = repaint(RED, s);\n          continue  \n        }\n      } else {\n        //console.log(\"case 3: red sibling\")\n        s = cloneNode(s);\n        p.right = s.left;\n        s.left = p;\n        s._color = p._color;\n        p._color = RED;\n        recount(p);\n        recount(s);\n        if(i > 1) {\n          var pp = stack[i-2];\n          if(pp.left === p) {\n            pp.left = s;\n          } else {\n            pp.right = s;\n          }\n        }\n        stack[i-1] = s;\n        stack[i] = p;\n        if(i+1 < stack.length) {\n          stack[i+1] = n;\n        } else {\n          stack.push(n);\n        }\n        i = i+2;\n      }\n    } else {\n      //console.log(\"right child\")\n      s = p.left;\n      if(s.left && s.left._color === RED) {\n        //console.log(\"case 1: left sibling child red\", p.value, p._color)\n        s = p.left = cloneNode(s);\n        z = s.left = cloneNode(s.left);\n        p.left = s.right;\n        s.right = p;\n        s.left = z;\n        s._color = p._color;\n        n._color = BLACK;\n        p._color = BLACK;\n        z._color = BLACK;\n        recount(p);\n        recount(s);\n        if(i > 1) {\n          var pp = stack[i-2];\n          if(pp.right === p) {\n            pp.right = s;\n          } else {\n            pp.left = s;\n          }\n        }\n        stack[i-1] = s;\n        return\n      } else if(s.right && s.right._color === RED) {\n        //console.log(\"case 1: right sibling child red\")\n        s = p.left = cloneNode(s);\n        z = s.right = cloneNode(s.right);\n        p.left = z.right;\n        s.right = z.left;\n        z.right = p;\n        z.left = s;\n        z._color = p._color;\n        p._color = BLACK;\n        s._color = BLACK;\n        n._color = BLACK;\n        recount(p);\n        recount(s);\n        recount(z);\n        if(i > 1) {\n          var pp = stack[i-2];\n          if(pp.right === p) {\n            pp.right = z;\n          } else {\n            pp.left = z;\n          }\n        }\n        stack[i-1] = z;\n        return\n      }\n      if(s._color === BLACK) {\n        if(p._color === RED) {\n          //console.log(\"case 2: black sibling, red parent\")\n          p._color = BLACK;\n          p.left = repaint(RED, s);\n          return\n        } else {\n          //console.log(\"case 2: black sibling, black parent\")\n          p.left = repaint(RED, s);\n          continue  \n        }\n      } else {\n        //console.log(\"case 3: red sibling\")\n        s = cloneNode(s);\n        p.left = s.right;\n        s.right = p;\n        s._color = p._color;\n        p._color = RED;\n        recount(p);\n        recount(s);\n        if(i > 1) {\n          var pp = stack[i-2];\n          if(pp.right === p) {\n            pp.right = s;\n          } else {\n            pp.left = s;\n          }\n        }\n        stack[i-1] = s;\n        stack[i] = p;\n        if(i+1 < stack.length) {\n          stack[i+1] = n;\n        } else {\n          stack.push(n);\n        }\n        i = i+2;\n      }\n    }\n  }\n}\n\n//Removes item at iterator from tree\niproto.remove = function() {\n  var stack = this._stack;\n  if(stack.length === 0) {\n    return this.tree\n  }\n  //First copy path to node\n  var cstack = new Array(stack.length);\n  var n = stack[stack.length-1];\n  cstack[cstack.length-1] = new RBNode(n._color, n.key, n.value, n.left, n.right, n._count);\n  for(var i=stack.length-2; i>=0; --i) {\n    var n = stack[i];\n    if(n.left === stack[i+1]) {\n      cstack[i] = new RBNode(n._color, n.key, n.value, cstack[i+1], n.right, n._count);\n    } else {\n      cstack[i] = new RBNode(n._color, n.key, n.value, n.left, cstack[i+1], n._count);\n    }\n  }\n\n  //Get node\n  n = cstack[cstack.length-1];\n  //console.log(\"start remove: \", n.value)\n\n  //If not leaf, then swap with previous node\n  if(n.left && n.right) {\n    //console.log(\"moving to leaf\")\n\n    //First walk to previous leaf\n    var split = cstack.length;\n    n = n.left;\n    while(n.right) {\n      cstack.push(n);\n      n = n.right;\n    }\n    //Copy path to leaf\n    var v = cstack[split-1];\n    cstack.push(new RBNode(n._color, v.key, v.value, n.left, n.right, n._count));\n    cstack[split-1].key = n.key;\n    cstack[split-1].value = n.value;\n\n    //Fix up stack\n    for(var i=cstack.length-2; i>=split; --i) {\n      n = cstack[i];\n      cstack[i] = new RBNode(n._color, n.key, n.value, n.left, cstack[i+1], n._count);\n    }\n    cstack[split-1].left = cstack[split];\n  }\n  //console.log(\"stack=\", cstack.map(function(v) { return v.value }))\n\n  //Remove leaf node\n  n = cstack[cstack.length-1];\n  if(n._color === RED) {\n    //Easy case: removing red leaf\n    //console.log(\"RED leaf\")\n    var p = cstack[cstack.length-2];\n    if(p.left === n) {\n      p.left = null;\n    } else if(p.right === n) {\n      p.right = null;\n    }\n    cstack.pop();\n    for(var i=0; i<cstack.length; ++i) {\n      cstack[i]._count--;\n    }\n    return new RedBlackTree(this.tree._compare, cstack[0])\n  } else {\n    if(n.left || n.right) {\n      //Second easy case:  Single child black parent\n      //console.log(\"BLACK single child\")\n      if(n.left) {\n        swapNode(n, n.left);\n      } else if(n.right) {\n        swapNode(n, n.right);\n      }\n      //Child must be red, so repaint it black to balance color\n      n._color = BLACK;\n      for(var i=0; i<cstack.length-1; ++i) {\n        cstack[i]._count--;\n      }\n      return new RedBlackTree(this.tree._compare, cstack[0])\n    } else if(cstack.length === 1) {\n      //Third easy case: root\n      //console.log(\"ROOT\")\n      return new RedBlackTree(this.tree._compare, null)\n    } else {\n      //Hard case: Repaint n, and then do some nasty stuff\n      //console.log(\"BLACK leaf no children\")\n      for(var i=0; i<cstack.length; ++i) {\n        cstack[i]._count--;\n      }\n      var parent = cstack[cstack.length-2];\n      fixDoubleBlack(cstack);\n      //Fix up links\n      if(parent.left === n) {\n        parent.left = null;\n      } else {\n        parent.right = null;\n      }\n    }\n  }\n  return new RedBlackTree(this.tree._compare, cstack[0])\n};\n\n//Returns key\nObject.defineProperty(iproto, \"key\", {\n  get: function() {\n    if(this._stack.length > 0) {\n      return this._stack[this._stack.length-1].key\n    }\n    return\n  },\n  enumerable: true\n});\n\n//Returns value\nObject.defineProperty(iproto, \"value\", {\n  get: function() {\n    if(this._stack.length > 0) {\n      return this._stack[this._stack.length-1].value\n    }\n    return\n  },\n  enumerable: true\n});\n\n\n//Returns the position of this iterator in the sorted list\nObject.defineProperty(iproto, \"index\", {\n  get: function() {\n    var idx = 0;\n    var stack = this._stack;\n    if(stack.length === 0) {\n      var r = this.tree.root;\n      if(r) {\n        return r._count\n      }\n      return 0\n    } else if(stack[stack.length-1].left) {\n      idx = stack[stack.length-1].left._count;\n    }\n    for(var s=stack.length-2; s>=0; --s) {\n      if(stack[s+1] === stack[s].right) {\n        ++idx;\n        if(stack[s].left) {\n          idx += stack[s].left._count;\n        }\n      }\n    }\n    return idx\n  },\n  enumerable: true\n});\n\n//Advances iterator to next element in list\niproto.next = function() {\n  var stack = this._stack;\n  if(stack.length === 0) {\n    return\n  }\n  var n = stack[stack.length-1];\n  if(n.right) {\n    n = n.right;\n    while(n) {\n      stack.push(n);\n      n = n.left;\n    }\n  } else {\n    stack.pop();\n    while(stack.length > 0 && stack[stack.length-1].right === n) {\n      n = stack[stack.length-1];\n      stack.pop();\n    }\n  }\n};\n\n//Checks if iterator is at end of tree\nObject.defineProperty(iproto, \"hasNext\", {\n  get: function() {\n    var stack = this._stack;\n    if(stack.length === 0) {\n      return false\n    }\n    if(stack[stack.length-1].right) {\n      return true\n    }\n    for(var s=stack.length-1; s>0; --s) {\n      if(stack[s-1].left === stack[s]) {\n        return true\n      }\n    }\n    return false\n  }\n});\n\n//Update value\niproto.update = function(value) {\n  var stack = this._stack;\n  if(stack.length === 0) {\n    throw new Error(\"Can't update empty node!\")\n  }\n  var cstack = new Array(stack.length);\n  var n = stack[stack.length-1];\n  cstack[cstack.length-1] = new RBNode(n._color, n.key, value, n.left, n.right, n._count);\n  for(var i=stack.length-2; i>=0; --i) {\n    n = stack[i];\n    if(n.left === stack[i+1]) {\n      cstack[i] = new RBNode(n._color, n.key, n.value, cstack[i+1], n.right, n._count);\n    } else {\n      cstack[i] = new RBNode(n._color, n.key, n.value, n.left, cstack[i+1], n._count);\n    }\n  }\n  return new RedBlackTree(this.tree._compare, cstack[0])\n};\n\n//Moves iterator backward one element\niproto.prev = function() {\n  var stack = this._stack;\n  if(stack.length === 0) {\n    return\n  }\n  var n = stack[stack.length-1];\n  if(n.left) {\n    n = n.left;\n    while(n) {\n      stack.push(n);\n      n = n.right;\n    }\n  } else {\n    stack.pop();\n    while(stack.length > 0 && stack[stack.length-1].left === n) {\n      n = stack[stack.length-1];\n      stack.pop();\n    }\n  }\n};\n\n//Checks if iterator is at start of tree\nObject.defineProperty(iproto, \"hasPrev\", {\n  get: function() {\n    var stack = this._stack;\n    if(stack.length === 0) {\n      return false\n    }\n    if(stack[stack.length-1].left) {\n      return true\n    }\n    for(var s=stack.length-1; s>0; --s) {\n      if(stack[s-1].right === stack[s]) {\n        return true\n      }\n    }\n    return false\n  }\n});\n\n//Default comparison function\nfunction defaultCompare(a, b) {\n  if(a < b) {\n    return -1\n  }\n  if(a > b) {\n    return 1\n  }\n  return 0\n}\n\n//Build a tree\nfunction createRBTree(compare) {\n  return new RedBlackTree(compare || defaultCompare, null)\n}\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nconst KNOWN_NODES = new Set([\n    \"AssignmentExpression\",\n    \"AssignmentPattern\",\n    \"ArrayExpression\",\n    \"ArrayPattern\",\n    \"ArrowFunctionExpression\",\n    \"AwaitExpression\",\n    \"BlockStatement\",\n    \"BinaryExpression\",\n    \"BreakStatement\",\n    \"CallExpression\",\n    \"CatchClause\",\n    \"ClassBody\",\n    \"ClassDeclaration\",\n    \"ClassExpression\",\n    \"ConditionalExpression\",\n    \"ContinueStatement\",\n    \"DoWhileStatement\",\n    \"DebuggerStatement\",\n    \"EmptyStatement\",\n    \"ExperimentalRestProperty\",\n    \"ExperimentalSpreadProperty\",\n    \"ExpressionStatement\",\n    \"ForStatement\",\n    \"ForInStatement\",\n    \"ForOfStatement\",\n    \"FunctionDeclaration\",\n    \"FunctionExpression\",\n    \"Identifier\",\n    \"IfStatement\",\n    \"Literal\",\n    \"LabeledStatement\",\n    \"LogicalExpression\",\n    \"MemberExpression\",\n    \"MetaProperty\",\n    \"MethodDefinition\",\n    \"NewExpression\",\n    \"ObjectExpression\",\n    \"ObjectPattern\",\n    \"Program\",\n    \"Property\",\n    \"RestElement\",\n    \"ReturnStatement\",\n    \"SequenceExpression\",\n    \"SpreadElement\",\n    \"Super\",\n    \"SwitchCase\",\n    \"SwitchStatement\",\n    \"TaggedTemplateExpression\",\n    \"TemplateElement\",\n    \"TemplateLiteral\",\n    \"ThisExpression\",\n    \"ThrowStatement\",\n    \"TryStatement\",\n    \"UnaryExpression\",\n    \"UpdateExpression\",\n    \"VariableDeclaration\",\n    \"VariableDeclarator\",\n    \"WhileStatement\",\n    \"WithStatement\",\n    \"YieldExpression\",\n    \"JSXFragment\",\n    \"JSXOpeningFragment\",\n    \"JSXClosingFragment\",\n    \"JSXIdentifier\",\n    \"JSXNamespacedName\",\n    \"JSXMemberExpression\",\n    \"JSXEmptyExpression\",\n    \"JSXExpressionContainer\",\n    \"JSXElement\",\n    \"JSXClosingElement\",\n    \"JSXOpeningElement\",\n    \"JSXAttribute\",\n    \"JSXSpreadAttribute\",\n    \"JSXText\",\n    \"ExportDefaultDeclaration\",\n    \"ExportNamedDeclaration\",\n    \"ExportAllDeclaration\",\n    \"ExportSpecifier\",\n    \"ImportDeclaration\",\n    \"ImportSpecifier\",\n    \"ImportDefaultSpecifier\",\n    \"ImportNamespaceSpecifier\",\n    \"ImportExpression\"\n]);\n\n/*\n * General rule strategy:\n * 1. An OffsetStorage instance stores a map of desired offsets, where each token has a specified offset from another\n *    specified token or to the first column.\n * 2. As the AST is traversed, modify the desired offsets of tokens accordingly. For example, when entering a\n *    BlockStatement, offset all of the tokens in the BlockStatement by 1 indent level from the opening curly\n *    brace of the BlockStatement.\n * 3. After traversing the AST, calculate the expected indentation levels of every token according to the\n *    OffsetStorage container.\n * 4. For each line, compare the expected indentation of the first token to the actual indentation in the file,\n *    and report the token if the two values are not equal.\n */\n\n\n/**\n * A mutable balanced binary search tree that stores (key, value) pairs. The keys are numeric, and must be unique.\n * This is intended to be a generic wrapper around a balanced binary search tree library, so that the underlying implementation\n * can easily be swapped out.\n */\nclass BinarySearchTree {\n\n    /**\n     * Creates an empty tree\n     */\n    constructor() {\n        this._rbTree = rbtree();\n    }\n\n    /**\n     * Inserts an entry into the tree.\n     * @param {number} key The entry's key\n     * @param {*} value The entry's value\n     * @returns {void}\n     */\n    insert(key, value) {\n        const iterator = this._rbTree.find(key);\n\n        if (iterator.valid) {\n            this._rbTree = iterator.update(value);\n        } else {\n            this._rbTree = this._rbTree.insert(key, value);\n        }\n    }\n\n    /**\n     * Finds the entry with the largest key less than or equal to the provided key\n     * @param {number} key The provided key\n     * @returns {{key: number, value: *}|null} The found entry, or null if no such entry exists.\n     */\n    findLe(key) {\n        const iterator = this._rbTree.le(key);\n\n        return iterator && { key: iterator.key, value: iterator.value };\n    }\n\n    /**\n     * Deletes all of the keys in the interval [start, end)\n     * @param {number} start The start of the range\n     * @param {number} end The end of the range\n     * @returns {void}\n     */\n    deleteRange(start, end) {\n\n        // Exit without traversing the tree if the range has zero size.\n        if (start === end) {\n            return;\n        }\n        const iterator = this._rbTree.ge(start);\n\n        while (iterator.valid && iterator.key < end) {\n            this._rbTree = this._rbTree.remove(iterator.key);\n            iterator.next();\n        }\n    }\n}\n\n/**\n * A helper class to get token-based info related to indentation\n */\nclass TokenInfo {\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @param {SourceCode} sourceCode A SourceCode object\n     */\n    constructor(sourceCode) {\n        this.sourceCode = sourceCode;\n        this.firstTokensByLineNumber = sourceCode.tokensAndComments.reduce((map, token) => {\n            if (!map.has(token.loc.start.line)) {\n                map.set(token.loc.start.line, token);\n            }\n            if (!map.has(token.loc.end.line) && sourceCode.text.slice(token.range[1] - token.loc.end.column, token.range[1]).trim()) {\n                map.set(token.loc.end.line, token);\n            }\n            return map;\n        }, new Map());\n    }\n\n    /**\n     * Gets the first token on a given token's line\n     * @param {Token|ASTNode} token a node or token\n     * @returns {Token} The first token on the given line\n     */\n    getFirstTokenOfLine(token) {\n        return this.firstTokensByLineNumber.get(token.loc.start.line);\n    }\n\n    /**\n     * Determines whether a token is the first token in its line\n     * @param {Token} token The token\n     * @returns {boolean} `true` if the token is the first on its line\n     */\n    isFirstTokenOfLine(token) {\n        return this.getFirstTokenOfLine(token) === token;\n    }\n\n    /**\n     * Get the actual indent of a token\n     * @param {Token} token Token to examine. This should be the first token on its line.\n     * @returns {string} The indentation characters that precede the token\n     */\n    getTokenIndent(token) {\n        return this.sourceCode.text.slice(token.range[0] - token.loc.start.column, token.range[0]);\n    }\n}\n\n/**\n * A class to store information on desired offsets of tokens from each other\n */\nclass OffsetStorage {\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @param {TokenInfo} tokenInfo a TokenInfo instance\n     * @param {number} indentSize The desired size of each indentation level\n     * @param {string} indentType The indentation character\n     */\n    constructor(tokenInfo, indentSize, indentType) {\n        this._tokenInfo = tokenInfo;\n        this._indentSize = indentSize;\n        this._indentType = indentType;\n\n        this._tree = new BinarySearchTree();\n        this._tree.insert(0, { offset: 0, from: null, force: false });\n\n        this._lockedFirstTokens = new WeakMap();\n        this._desiredIndentCache = new WeakMap();\n        this._ignoredTokens = new WeakSet();\n    }\n\n    _getOffsetDescriptor(token) {\n        return this._tree.findLe(token.range[0]).value;\n    }\n\n    /**\n     * Sets the offset column of token B to match the offset column of token A.\n     * **WARNING**: This matches a *column*, even if baseToken is not the first token on its line. In\n     * most cases, `setDesiredOffset` should be used instead.\n     * @param {Token} baseToken The first token\n     * @param {Token} offsetToken The second token, whose offset should be matched to the first token\n     * @returns {void}\n     */\n    matchOffsetOf(baseToken, offsetToken) {\n\n        /*\n         * lockedFirstTokens is a map from a token whose indentation is controlled by the \"first\" option to\n         * the token that it depends on. For example, with the `ArrayExpression: first` option, the first\n         * token of each element in the array after the first will be mapped to the first token of the first\n         * element. The desired indentation of each of these tokens is computed based on the desired indentation\n         * of the \"first\" element, rather than through the normal offset mechanism.\n         */\n        this._lockedFirstTokens.set(offsetToken, baseToken);\n    }\n\n    /**\n     * Sets the desired offset of a token.\n     *\n     * This uses a line-based offset collapsing behavior to handle tokens on the same line.\n     * For example, consider the following two cases:\n     *\n     * (\n     *     [\n     *         bar\n     *     ]\n     * )\n     *\n     * ([\n     *     bar\n     * ])\n     *\n     * Based on the first case, it's clear that the `bar` token needs to have an offset of 1 indent level (4 spaces) from\n     * the `[` token, and the `[` token has to have an offset of 1 indent level from the `(` token. Since the `(` token is\n     * the first on its line (with an indent of 0 spaces), the `bar` token needs to be offset by 2 indent levels (8 spaces)\n     * from the start of its line.\n     *\n     * However, in the second case `bar` should only be indented by 4 spaces. This is because the offset of 1 indent level\n     * between the `(` and the `[` tokens gets \"collapsed\" because the two tokens are on the same line. As a result, the\n     * `(` token is mapped to the `[` token with an offset of 0, and the rule correctly decides that `bar` should be indented\n     * by 1 indent level from the start of the line.\n     *\n     * This is useful because rule listeners can usually just call `setDesiredOffset` for all the tokens in the node,\n     * without needing to check which lines those tokens are on.\n     *\n     * Note that since collapsing only occurs when two tokens are on the same line, there are a few cases where non-intuitive\n     * behavior can occur. For example, consider the following cases:\n     *\n     * foo(\n     * ).\n     *     bar(\n     *         baz\n     *     )\n     *\n     * foo(\n     * ).bar(\n     *     baz\n     * )\n     *\n     * Based on the first example, it would seem that `bar` should be offset by 1 indent level from `foo`, and `baz`\n     * should be offset by 1 indent level from `bar`. However, this is not correct, because it would result in `baz`\n     * being indented by 2 indent levels in the second case (since `foo`, `bar`, and `baz` are all on separate lines, no\n     * collapsing would occur).\n     *\n     * Instead, the correct way would be to offset `baz` by 1 level from `bar`, offset `bar` by 1 level from the `)`, and\n     * offset the `)` by 0 levels from `foo`. This ensures that the offset between `bar` and the `)` are correctly collapsed\n     * in the second case.\n     * @param {Token} token The token\n     * @param {Token} fromToken The token that `token` should be offset from\n     * @param {number} offset The desired indent level\n     * @returns {void}\n     */\n    setDesiredOffset(token, fromToken, offset) {\n        return this.setDesiredOffsets(token.range, fromToken, offset);\n    }\n\n    /**\n     * Sets the desired offset of all tokens in a range\n     * It's common for node listeners in this file to need to apply the same offset to a large, contiguous range of tokens.\n     * Moreover, the offset of any given token is usually updated multiple times (roughly once for each node that contains\n     * it). This means that the offset of each token is updated O(AST depth) times.\n     * It would not be performant to store and update the offsets for each token independently, because the rule would end\n     * up having a time complexity of O(number of tokens * AST depth), which is quite slow for large files.\n     *\n     * Instead, the offset tree is represented as a collection of contiguous offset ranges in a file. For example, the following\n     * list could represent the state of the offset tree at a given point:\n     *\n     * * Tokens starting in the interval [0, 15) are aligned with the beginning of the file\n     * * Tokens starting in the interval [15, 30) are offset by 1 indent level from the `bar` token\n     * * Tokens starting in the interval [30, 43) are offset by 1 indent level from the `foo` token\n     * * Tokens starting in the interval [43, 820) are offset by 2 indent levels from the `bar` token\n     * * Tokens starting in the interval [820, ∞) are offset by 1 indent level from the `baz` token\n     *\n     * The `setDesiredOffsets` methods inserts ranges like the ones above. The third line above would be inserted by using:\n     * `setDesiredOffsets([30, 43], fooToken, 1);`\n     * @param {[number, number]} range A [start, end] pair. All tokens with range[0] <= token.start < range[1] will have the offset applied.\n     * @param {Token} fromToken The token that this is offset from\n     * @param {number} offset The desired indent level\n     * @param {boolean} force `true` if this offset should not use the normal collapsing behavior. This should almost always be false.\n     * @returns {void}\n     */\n    setDesiredOffsets(range, fromToken, offset, force) {\n\n        /*\n         * Offset ranges are stored as a collection of nodes, where each node maps a numeric key to an offset\n         * descriptor. The tree for the example above would have the following nodes:\n         *\n         * * key: 0, value: { offset: 0, from: null }\n         * * key: 15, value: { offset: 1, from: barToken }\n         * * key: 30, value: { offset: 1, from: fooToken }\n         * * key: 43, value: { offset: 2, from: barToken }\n         * * key: 820, value: { offset: 1, from: bazToken }\n         *\n         * To find the offset descriptor for any given token, one needs to find the node with the largest key\n         * which is <= token.start. To make this operation fast, the nodes are stored in a balanced binary\n         * search tree indexed by key.\n         */\n\n        const descriptorToInsert = { offset, from: fromToken, force };\n\n        const descriptorAfterRange = this._tree.findLe(range[1]).value;\n\n        const fromTokenIsInRange = fromToken && fromToken.range[0] >= range[0] && fromToken.range[1] <= range[1];\n        const fromTokenDescriptor = fromTokenIsInRange && this._getOffsetDescriptor(fromToken);\n\n        // First, remove any existing nodes in the range from the tree.\n        this._tree.deleteRange(range[0] + 1, range[1]);\n\n        // Insert a new node into the tree for this range\n        this._tree.insert(range[0], descriptorToInsert);\n\n        /*\n         * To avoid circular offset dependencies, keep the `fromToken` token mapped to whatever it was mapped to previously,\n         * even if it's in the current range.\n         */\n        if (fromTokenIsInRange) {\n            this._tree.insert(fromToken.range[0], fromTokenDescriptor);\n            this._tree.insert(fromToken.range[1], descriptorToInsert);\n        }\n\n        /*\n         * To avoid modifying the offset of tokens after the range, insert another node to keep the offset of the following\n         * tokens the same as it was before.\n         */\n        this._tree.insert(range[1], descriptorAfterRange);\n    }\n\n    /**\n     * Gets the desired indent of a token\n     * @param {Token} token The token\n     * @returns {string} The desired indent of the token\n     */\n    getDesiredIndent(token) {\n        if (!this._desiredIndentCache.has(token)) {\n\n            if (this._ignoredTokens.has(token)) {\n\n                /*\n                 * If the token is ignored, use the actual indent of the token as the desired indent.\n                 * This ensures that no errors are reported for this token.\n                 */\n                this._desiredIndentCache.set(\n                    token,\n                    this._tokenInfo.getTokenIndent(token)\n                );\n            } else if (this._lockedFirstTokens.has(token)) {\n                const firstToken = this._lockedFirstTokens.get(token);\n\n                this._desiredIndentCache.set(\n                    token,\n\n                    // (indentation for the first element's line)\n                    this.getDesiredIndent(this._tokenInfo.getFirstTokenOfLine(firstToken)) +\n\n                        // (space between the start of the first element's line and the first element)\n                        this._indentType.repeat(firstToken.loc.start.column - this._tokenInfo.getFirstTokenOfLine(firstToken).loc.start.column)\n                );\n            } else {\n                const offsetInfo = this._getOffsetDescriptor(token);\n                const offset = (\n                    offsetInfo.from &&\n                    offsetInfo.from.loc.start.line === token.loc.start.line &&\n                    !/^\\s*?\\n/u.test(token.value) &&\n                    !offsetInfo.force\n                ) ? 0 : offsetInfo.offset * this._indentSize;\n\n                this._desiredIndentCache.set(\n                    token,\n                    (offsetInfo.from ? this.getDesiredIndent(offsetInfo.from) : \"\") + this._indentType.repeat(offset)\n                );\n            }\n        }\n        return this._desiredIndentCache.get(token);\n    }\n\n    /**\n     * Ignores a token, preventing it from being reported.\n     * @param {Token} token The token\n     * @returns {void}\n     */\n    ignoreToken(token) {\n        if (this._tokenInfo.isFirstTokenOfLine(token)) {\n            this._ignoredTokens.add(token);\n        }\n    }\n\n    /**\n     * Gets the first token that the given token's indentation is dependent on\n     * @param {Token} token The token\n     * @returns {Token} The token that the given token depends on, or `null` if the given token is at the top level\n     */\n    getFirstDependency(token) {\n        return this._getOffsetDescriptor(token).from;\n    }\n}\n\nconst ELEMENT_LIST_SCHEMA = {\n    oneOf: [\n        {\n            type: \"integer\",\n            minimum: 0\n        },\n        {\n            enum: [\"first\", \"off\"]\n        }\n    ]\n};\n\nvar indent = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent indentation\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/indent\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        enum: [\"tab\"]\n                    },\n                    {\n                        type: \"integer\",\n                        minimum: 0\n                    }\n                ]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    SwitchCase: {\n                        type: \"integer\",\n                        minimum: 0,\n                        default: 0\n                    },\n                    VariableDeclarator: {\n                        oneOf: [\n                            ELEMENT_LIST_SCHEMA,\n                            {\n                                type: \"object\",\n                                properties: {\n                                    var: ELEMENT_LIST_SCHEMA,\n                                    let: ELEMENT_LIST_SCHEMA,\n                                    const: ELEMENT_LIST_SCHEMA\n                                },\n                                additionalProperties: false\n                            }\n                        ]\n                    },\n                    outerIIFEBody: {\n                        type: \"integer\",\n                        minimum: 0\n                    },\n                    MemberExpression: {\n                        oneOf: [\n                            {\n                                type: \"integer\",\n                                minimum: 0\n                            },\n                            {\n                                enum: [\"off\"]\n                            }\n                        ]\n                    },\n                    FunctionDeclaration: {\n                        type: \"object\",\n                        properties: {\n                            parameters: ELEMENT_LIST_SCHEMA,\n                            body: {\n                                type: \"integer\",\n                                minimum: 0\n                            }\n                        },\n                        additionalProperties: false\n                    },\n                    FunctionExpression: {\n                        type: \"object\",\n                        properties: {\n                            parameters: ELEMENT_LIST_SCHEMA,\n                            body: {\n                                type: \"integer\",\n                                minimum: 0\n                            }\n                        },\n                        additionalProperties: false\n                    },\n                    CallExpression: {\n                        type: \"object\",\n                        properties: {\n                            arguments: ELEMENT_LIST_SCHEMA\n                        },\n                        additionalProperties: false\n                    },\n                    ArrayExpression: ELEMENT_LIST_SCHEMA,\n                    ObjectExpression: ELEMENT_LIST_SCHEMA,\n                    ImportDeclaration: ELEMENT_LIST_SCHEMA,\n                    flatTernaryExpressions: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    ignoredNodes: {\n                        type: \"array\",\n                        items: {\n                            type: \"string\",\n                            not: {\n                                pattern: \":exit$\"\n                            }\n                        }\n                    },\n                    ignoreComments: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n        messages: {\n            wrongIndentation: \"Expected indentation of {{expected}} but found {{actual}}.\"\n        }\n    },\n\n    create(context) {\n        const DEFAULT_VARIABLE_INDENT = 1;\n        const DEFAULT_PARAMETER_INDENT = 1;\n        const DEFAULT_FUNCTION_BODY_INDENT = 1;\n\n        let indentType = \"space\";\n        let indentSize = 4;\n        const options = {\n            SwitchCase: 0,\n            VariableDeclarator: {\n                var: DEFAULT_VARIABLE_INDENT,\n                let: DEFAULT_VARIABLE_INDENT,\n                const: DEFAULT_VARIABLE_INDENT\n            },\n            outerIIFEBody: 1,\n            FunctionDeclaration: {\n                parameters: DEFAULT_PARAMETER_INDENT,\n                body: DEFAULT_FUNCTION_BODY_INDENT\n            },\n            FunctionExpression: {\n                parameters: DEFAULT_PARAMETER_INDENT,\n                body: DEFAULT_FUNCTION_BODY_INDENT\n            },\n            CallExpression: {\n                arguments: DEFAULT_PARAMETER_INDENT\n            },\n            MemberExpression: 1,\n            ArrayExpression: 1,\n            ObjectExpression: 1,\n            ImportDeclaration: 1,\n            flatTernaryExpressions: false,\n            ignoredNodes: [],\n            ignoreComments: false\n        };\n\n        if (context.options.length) {\n            if (context.options[0] === \"tab\") {\n                indentSize = 1;\n                indentType = \"tab\";\n            } else {\n                indentSize = context.options[0];\n                indentType = \"space\";\n            }\n\n            if (context.options[1]) {\n                Object.assign(options, context.options[1]);\n\n                if (typeof options.VariableDeclarator === \"number\" || options.VariableDeclarator === \"first\") {\n                    options.VariableDeclarator = {\n                        var: options.VariableDeclarator,\n                        let: options.VariableDeclarator,\n                        const: options.VariableDeclarator\n                    };\n                }\n            }\n        }\n\n        const sourceCode = context.getSourceCode();\n        const tokenInfo = new TokenInfo(sourceCode);\n        const offsets = new OffsetStorage(tokenInfo, indentSize, indentType === \"space\" ? \" \" : \"\\t\");\n        const parameterParens = new WeakSet();\n\n        /**\n         * Creates an error message for a line, given the expected/actual indentation.\n         * @param {int} expectedAmount The expected amount of indentation characters for this line\n         * @param {int} actualSpaces The actual number of indentation spaces that were found on this line\n         * @param {int} actualTabs The actual number of indentation tabs that were found on this line\n         * @returns {string} An error message for this line\n         */\n        function createErrorMessageData(expectedAmount, actualSpaces, actualTabs) {\n            const expectedStatement = `${expectedAmount} ${indentType}${expectedAmount === 1 ? \"\" : \"s\"}`; // e.g. \"2 tabs\"\n            const foundSpacesWord = `space${actualSpaces === 1 ? \"\" : \"s\"}`; // e.g. \"space\"\n            const foundTabsWord = `tab${actualTabs === 1 ? \"\" : \"s\"}`; // e.g. \"tabs\"\n            let foundStatement;\n\n            if (actualSpaces > 0) {\n\n                /*\n                 * Abbreviate the message if the expected indentation is also spaces.\n                 * e.g. 'Expected 4 spaces but found 2' rather than 'Expected 4 spaces but found 2 spaces'\n                 */\n                foundStatement = indentType === \"space\" ? actualSpaces : `${actualSpaces} ${foundSpacesWord}`;\n            } else if (actualTabs > 0) {\n                foundStatement = indentType === \"tab\" ? actualTabs : `${actualTabs} ${foundTabsWord}`;\n            } else {\n                foundStatement = \"0\";\n            }\n            return {\n                expected: expectedStatement,\n                actual: foundStatement\n            };\n        }\n\n        /**\n         * Reports a given indent violation\n         * @param {Token} token Token violating the indent rule\n         * @param {string} neededIndent Expected indentation string\n         * @returns {void}\n         */\n        function report(token, neededIndent) {\n            const actualIndent = Array.from(tokenInfo.getTokenIndent(token));\n            const numSpaces = actualIndent.filter(char => char === \" \").length;\n            const numTabs = actualIndent.filter(char => char === \"\\t\").length;\n\n            context.report({\n                node: token,\n                messageId: \"wrongIndentation\",\n                data: createErrorMessageData(neededIndent.length, numSpaces, numTabs),\n                loc: {\n                    start: { line: token.loc.start.line, column: 0 },\n                    end: { line: token.loc.start.line, column: token.loc.start.column }\n                },\n                fix(fixer) {\n                    const range = [token.range[0] - token.loc.start.column, token.range[0]];\n                    const newText = neededIndent;\n\n                    return fixer.replaceTextRange(range, newText);\n                }\n            });\n        }\n\n        /**\n         * Checks if a token's indentation is correct\n         * @param {Token} token Token to examine\n         * @param {string} desiredIndent Desired indentation of the string\n         * @returns {boolean} `true` if the token's indentation is correct\n         */\n        function validateTokenIndent(token, desiredIndent) {\n            const indentation = tokenInfo.getTokenIndent(token);\n\n            return indentation === desiredIndent ||\n\n                // To avoid conflicts with no-mixed-spaces-and-tabs, don't report mixed spaces and tabs.\n                indentation.includes(\" \") && indentation.includes(\"\\t\");\n        }\n\n        /**\n         * Check to see if the node is a file level IIFE\n         * @param {ASTNode} node The function node to check.\n         * @returns {boolean} True if the node is the outer IIFE\n         */\n        function isOuterIIFE(node) {\n\n            /*\n             * Verify that the node is an IIFE\n             */\n            if (!node.parent || node.parent.type !== \"CallExpression\" || node.parent.callee !== node) {\n                return false;\n            }\n\n            /*\n             * Navigate legal ancestors to determine whether this IIFE is outer.\n             * A \"legal ancestor\" is an expression or statement that causes the function to get executed immediately.\n             * For example, `!(function(){})()` is an outer IIFE even though it is preceded by a ! operator.\n             */\n            let statement = node.parent && node.parent.parent;\n\n            while (\n                statement.type === \"UnaryExpression\" && [\"!\", \"~\", \"+\", \"-\"].indexOf(statement.operator) > -1 ||\n                statement.type === \"AssignmentExpression\" ||\n                statement.type === \"LogicalExpression\" ||\n                statement.type === \"SequenceExpression\" ||\n                statement.type === \"VariableDeclarator\"\n            ) {\n                statement = statement.parent;\n            }\n\n            return (statement.type === \"ExpressionStatement\" || statement.type === \"VariableDeclaration\") && statement.parent.type === \"Program\";\n        }\n\n        /**\n         * Counts the number of linebreaks that follow the last non-whitespace character in a string\n         * @param {string} string The string to check\n         * @returns {number} The number of JavaScript linebreaks that follow the last non-whitespace character,\n         * or the total number of linebreaks if the string is all whitespace.\n         */\n        function countTrailingLinebreaks(string) {\n            const trailingWhitespace = string.match(/\\s*$/u)[0];\n            const linebreakMatches = trailingWhitespace.match(astUtils$1.createGlobalLinebreakMatcher());\n\n            return linebreakMatches === null ? 0 : linebreakMatches.length;\n        }\n\n        /**\n         * Check indentation for lists of elements (arrays, objects, function params)\n         * @param {ASTNode[]} elements List of elements that should be offset\n         * @param {Token} startToken The start token of the list that element should be aligned against, e.g. '['\n         * @param {Token} endToken The end token of the list, e.g. ']'\n         * @param {number|string} offset The amount that the elements should be offset\n         * @returns {void}\n         */\n        function addElementListIndent(elements, startToken, endToken, offset) {\n\n            /**\n             * Gets the first token of a given element, including surrounding parentheses.\n             * @param {ASTNode} element A node in the `elements` list\n             * @returns {Token} The first token of this element\n             */\n            function getFirstToken(element) {\n                let token = sourceCode.getTokenBefore(element);\n\n                while (astUtils$1.isOpeningParenToken(token) && token !== startToken) {\n                    token = sourceCode.getTokenBefore(token);\n                }\n                return sourceCode.getTokenAfter(token);\n            }\n\n            // Run through all the tokens in the list, and offset them by one indent level (mainly for comments, other things will end up overridden)\n            offsets.setDesiredOffsets(\n                [startToken.range[1], endToken.range[0]],\n                startToken,\n                typeof offset === \"number\" ? offset : 1\n            );\n            offsets.setDesiredOffset(endToken, startToken, 0);\n\n            // If the preference is \"first\" but there is no first element (e.g. sparse arrays w/ empty first slot), fall back to 1 level.\n            if (offset === \"first\" && elements.length && !elements[0]) {\n                return;\n            }\n            elements.forEach((element, index) => {\n                if (!element) {\n\n                    // Skip holes in arrays\n                    return;\n                }\n                if (offset === \"off\") {\n\n                    // Ignore the first token of every element if the \"off\" option is used\n                    offsets.ignoreToken(getFirstToken(element));\n                }\n\n                // Offset the following elements correctly relative to the first element\n                if (index === 0) {\n                    return;\n                }\n                if (offset === \"first\" && tokenInfo.isFirstTokenOfLine(getFirstToken(element))) {\n                    offsets.matchOffsetOf(getFirstToken(elements[0]), getFirstToken(element));\n                } else {\n                    const previousElement = elements[index - 1];\n                    const firstTokenOfPreviousElement = previousElement && getFirstToken(previousElement);\n                    const previousElementLastToken = previousElement && sourceCode.getLastToken(previousElement);\n\n                    if (\n                        previousElement &&\n                        previousElementLastToken.loc.end.line - countTrailingLinebreaks(previousElementLastToken.value) > startToken.loc.end.line\n                    ) {\n                        offsets.setDesiredOffsets(\n                            [previousElement.range[1], element.range[1]],\n                            firstTokenOfPreviousElement,\n                            0\n                        );\n                    }\n                }\n            });\n        }\n\n        /**\n         * Check and decide whether to check for indentation for blockless nodes\n         * Scenarios are for or while statements without braces around them\n         * @param {ASTNode} node node to examine\n         * @returns {void}\n         */\n        function addBlocklessNodeIndent(node) {\n            if (node.type !== \"BlockStatement\") {\n                const lastParentToken = sourceCode.getTokenBefore(node, astUtils$1.isNotOpeningParenToken);\n\n                let firstBodyToken = sourceCode.getFirstToken(node);\n                let lastBodyToken = sourceCode.getLastToken(node);\n\n                while (\n                    astUtils$1.isOpeningParenToken(sourceCode.getTokenBefore(firstBodyToken)) &&\n                    astUtils$1.isClosingParenToken(sourceCode.getTokenAfter(lastBodyToken))\n                ) {\n                    firstBodyToken = sourceCode.getTokenBefore(firstBodyToken);\n                    lastBodyToken = sourceCode.getTokenAfter(lastBodyToken);\n                }\n\n                offsets.setDesiredOffsets([firstBodyToken.range[0], lastBodyToken.range[1]], lastParentToken, 1);\n\n                /*\n                 * For blockless nodes with semicolon-first style, don't indent the semicolon.\n                 * e.g.\n                 * if (foo) bar()\n                 * ; [1, 2, 3].map(foo)\n                 */\n                const lastToken = sourceCode.getLastToken(node);\n\n                if (node.type !== \"EmptyStatement\" && astUtils$1.isSemicolonToken(lastToken)) {\n                    offsets.setDesiredOffset(lastToken, lastParentToken, 0);\n                }\n            }\n        }\n\n        /**\n         * Checks the indentation for nodes that are like function calls (`CallExpression` and `NewExpression`)\n         * @param {ASTNode} node A CallExpression or NewExpression node\n         * @returns {void}\n         */\n        function addFunctionCallIndent(node) {\n            let openingParen;\n\n            if (node.arguments.length) {\n                openingParen = sourceCode.getFirstTokenBetween(node.callee, node.arguments[0], astUtils$1.isOpeningParenToken);\n            } else {\n                openingParen = sourceCode.getLastToken(node, 1);\n            }\n            const closingParen = sourceCode.getLastToken(node);\n\n            parameterParens.add(openingParen);\n            parameterParens.add(closingParen);\n            offsets.setDesiredOffset(openingParen, sourceCode.getTokenBefore(openingParen), 0);\n\n            addElementListIndent(node.arguments, openingParen, closingParen, options.CallExpression.arguments);\n        }\n\n        /**\n         * Checks the indentation of parenthesized values, given a list of tokens in a program\n         * @param {Token[]} tokens A list of tokens\n         * @returns {void}\n         */\n        function addParensIndent(tokens) {\n            const parenStack = [];\n            const parenPairs = [];\n\n            tokens.forEach(nextToken => {\n\n                // Accumulate a list of parenthesis pairs\n                if (astUtils$1.isOpeningParenToken(nextToken)) {\n                    parenStack.push(nextToken);\n                } else if (astUtils$1.isClosingParenToken(nextToken)) {\n                    parenPairs.unshift({ left: parenStack.pop(), right: nextToken });\n                }\n            });\n\n            parenPairs.forEach(pair => {\n                const leftParen = pair.left;\n                const rightParen = pair.right;\n\n                // We only want to handle parens around expressions, so exclude parentheses that are in function parameters and function call arguments.\n                if (!parameterParens.has(leftParen) && !parameterParens.has(rightParen)) {\n                    const parenthesizedTokens = new Set(sourceCode.getTokensBetween(leftParen, rightParen));\n\n                    parenthesizedTokens.forEach(token => {\n                        if (!parenthesizedTokens.has(offsets.getFirstDependency(token))) {\n                            offsets.setDesiredOffset(token, leftParen, 1);\n                        }\n                    });\n                }\n\n                offsets.setDesiredOffset(rightParen, leftParen, 0);\n            });\n        }\n\n        /**\n         * Ignore all tokens within an unknown node whose offset do not depend\n         * on another token's offset within the unknown node\n         * @param {ASTNode} node Unknown Node\n         * @returns {void}\n         */\n        function ignoreNode(node) {\n            const unknownNodeTokens = new Set(sourceCode.getTokens(node, { includeComments: true }));\n\n            unknownNodeTokens.forEach(token => {\n                if (!unknownNodeTokens.has(offsets.getFirstDependency(token))) {\n                    const firstTokenOfLine = tokenInfo.getFirstTokenOfLine(token);\n\n                    if (token === firstTokenOfLine) {\n                        offsets.ignoreToken(token);\n                    } else {\n                        offsets.setDesiredOffset(token, firstTokenOfLine, 0);\n                    }\n                }\n            });\n        }\n\n        /**\n         * Check whether the given token is on the first line of a statement.\n         * @param {Token} token The token to check.\n         * @param {ASTNode} leafNode The expression node that the token belongs directly.\n         * @returns {boolean} `true` if the token is on the first line of a statement.\n         */\n        function isOnFirstLineOfStatement(token, leafNode) {\n            let node = leafNode;\n\n            while (node.parent && !node.parent.type.endsWith(\"Statement\") && !node.parent.type.endsWith(\"Declaration\")) {\n                node = node.parent;\n            }\n            node = node.parent;\n\n            return !node || node.loc.start.line === token.loc.start.line;\n        }\n\n        /**\n         * Check whether there are any blank (whitespace-only) lines between\n         * two tokens on separate lines.\n         * @param {Token} firstToken The first token.\n         * @param {Token} secondToken The second token.\n         * @returns {boolean} `true` if the tokens are on separate lines and\n         *   there exists a blank line between them, `false` otherwise.\n         */\n        function hasBlankLinesBetween(firstToken, secondToken) {\n            const firstTokenLine = firstToken.loc.end.line;\n            const secondTokenLine = secondToken.loc.start.line;\n\n            if (firstTokenLine === secondTokenLine || firstTokenLine === secondTokenLine - 1) {\n                return false;\n            }\n\n            for (let line = firstTokenLine + 1; line < secondTokenLine; ++line) {\n                if (!tokenInfo.firstTokensByLineNumber.has(line)) {\n                    return true;\n                }\n            }\n\n            return false;\n        }\n\n        const ignoredNodeFirstTokens = new Set();\n\n        const baseOffsetListeners = {\n            \"ArrayExpression, ArrayPattern\"(node) {\n                const openingBracket = sourceCode.getFirstToken(node);\n                const closingBracket = sourceCode.getTokenAfter(lodash.findLast(node.elements) || openingBracket, astUtils$1.isClosingBracketToken);\n\n                addElementListIndent(node.elements, openingBracket, closingBracket, options.ArrayExpression);\n            },\n\n            \"ObjectExpression, ObjectPattern\"(node) {\n                const openingCurly = sourceCode.getFirstToken(node);\n                const closingCurly = sourceCode.getTokenAfter(\n                    node.properties.length ? node.properties[node.properties.length - 1] : openingCurly,\n                    astUtils$1.isClosingBraceToken\n                );\n\n                addElementListIndent(node.properties, openingCurly, closingCurly, options.ObjectExpression);\n            },\n\n            ArrowFunctionExpression(node) {\n                const firstToken = sourceCode.getFirstToken(node);\n\n                if (astUtils$1.isOpeningParenToken(firstToken)) {\n                    const openingParen = firstToken;\n                    const closingParen = sourceCode.getTokenBefore(node.body, astUtils$1.isClosingParenToken);\n\n                    parameterParens.add(openingParen);\n                    parameterParens.add(closingParen);\n                    addElementListIndent(node.params, openingParen, closingParen, options.FunctionExpression.parameters);\n                }\n                addBlocklessNodeIndent(node.body);\n            },\n\n            AssignmentExpression(node) {\n                const operator = sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);\n\n                offsets.setDesiredOffsets([operator.range[0], node.range[1]], sourceCode.getLastToken(node.left), 1);\n                offsets.ignoreToken(operator);\n                offsets.ignoreToken(sourceCode.getTokenAfter(operator));\n            },\n\n            \"BinaryExpression, LogicalExpression\"(node) {\n                const operator = sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);\n\n                /*\n                 * For backwards compatibility, don't check BinaryExpression indents, e.g.\n                 * var foo = bar &&\n                 *                   baz;\n                 */\n\n                const tokenAfterOperator = sourceCode.getTokenAfter(operator);\n\n                offsets.ignoreToken(operator);\n                offsets.ignoreToken(tokenAfterOperator);\n                offsets.setDesiredOffset(tokenAfterOperator, operator, 0);\n            },\n\n            \"BlockStatement, ClassBody\"(node) {\n\n                let blockIndentLevel;\n\n                if (node.parent && isOuterIIFE(node.parent)) {\n                    blockIndentLevel = options.outerIIFEBody;\n                } else if (node.parent && (node.parent.type === \"FunctionExpression\" || node.parent.type === \"ArrowFunctionExpression\")) {\n                    blockIndentLevel = options.FunctionExpression.body;\n                } else if (node.parent && node.parent.type === \"FunctionDeclaration\") {\n                    blockIndentLevel = options.FunctionDeclaration.body;\n                } else {\n                    blockIndentLevel = 1;\n                }\n\n                /*\n                 * For blocks that aren't lone statements, ensure that the opening curly brace\n                 * is aligned with the parent.\n                 */\n                if (!astUtils$1.STATEMENT_LIST_PARENTS.has(node.parent.type)) {\n                    offsets.setDesiredOffset(sourceCode.getFirstToken(node), sourceCode.getFirstToken(node.parent), 0);\n                }\n                addElementListIndent(node.body, sourceCode.getFirstToken(node), sourceCode.getLastToken(node), blockIndentLevel);\n            },\n\n            CallExpression: addFunctionCallIndent,\n\n            \"ClassDeclaration[superClass], ClassExpression[superClass]\"(node) {\n                const classToken = sourceCode.getFirstToken(node);\n                const extendsToken = sourceCode.getTokenBefore(node.superClass, astUtils$1.isNotOpeningParenToken);\n\n                offsets.setDesiredOffsets([extendsToken.range[0], node.body.range[0]], classToken, 1);\n            },\n\n            ConditionalExpression(node) {\n                const firstToken = sourceCode.getFirstToken(node);\n\n                // `flatTernaryExpressions` option is for the following style:\n                // var a =\n                //     foo > 0 ? bar :\n                //     foo < 0 ? baz :\n                //     /*else*/ qiz ;\n                if (!options.flatTernaryExpressions ||\n                    !astUtils$1.isTokenOnSameLine(node.test, node.consequent) ||\n                    isOnFirstLineOfStatement(firstToken, node)\n                ) {\n                    const questionMarkToken = sourceCode.getFirstTokenBetween(node.test, node.consequent, token => token.type === \"Punctuator\" && token.value === \"?\");\n                    const colonToken = sourceCode.getFirstTokenBetween(node.consequent, node.alternate, token => token.type === \"Punctuator\" && token.value === \":\");\n\n                    const firstConsequentToken = sourceCode.getTokenAfter(questionMarkToken);\n                    const lastConsequentToken = sourceCode.getTokenBefore(colonToken);\n                    const firstAlternateToken = sourceCode.getTokenAfter(colonToken);\n\n                    offsets.setDesiredOffset(questionMarkToken, firstToken, 1);\n                    offsets.setDesiredOffset(colonToken, firstToken, 1);\n\n                    offsets.setDesiredOffset(firstConsequentToken, firstToken, 1);\n\n                    /*\n                     * The alternate and the consequent should usually have the same indentation.\n                     * If they share part of a line, align the alternate against the first token of the consequent.\n                     * This allows the alternate to be indented correctly in cases like this:\n                     * foo ? (\n                     *   bar\n                     * ) : ( // this '(' is aligned with the '(' above, so it's considered to be aligned with `foo`\n                     *   baz // as a result, `baz` is offset by 1 rather than 2\n                     * )\n                     */\n                    if (lastConsequentToken.loc.end.line === firstAlternateToken.loc.start.line) {\n                        offsets.setDesiredOffset(firstAlternateToken, firstConsequentToken, 0);\n                    } else {\n\n                        /**\n                         * If the alternate and consequent do not share part of a line, offset the alternate from the first\n                         * token of the conditional expression. For example:\n                         * foo ? bar\n                         *   : baz\n                         *\n                         * If `baz` were aligned with `bar` rather than being offset by 1 from `foo`, `baz` would end up\n                         * having no expected indentation.\n                         */\n                        offsets.setDesiredOffset(firstAlternateToken, firstToken, 1);\n                    }\n                }\n            },\n\n            \"DoWhileStatement, WhileStatement, ForInStatement, ForOfStatement\": node => addBlocklessNodeIndent(node.body),\n\n            ExportNamedDeclaration(node) {\n                if (node.declaration === null) {\n                    const closingCurly = sourceCode.getLastToken(node, astUtils$1.isClosingBraceToken);\n\n                    // Indent the specifiers in `export {foo, bar, baz}`\n                    addElementListIndent(node.specifiers, sourceCode.getFirstToken(node, { skip: 1 }), closingCurly, 1);\n\n                    if (node.source) {\n\n                        // Indent everything after and including the `from` token in `export {foo, bar, baz} from 'qux'`\n                        offsets.setDesiredOffsets([closingCurly.range[1], node.range[1]], sourceCode.getFirstToken(node), 1);\n                    }\n                }\n            },\n\n            ForStatement(node) {\n                const forOpeningParen = sourceCode.getFirstToken(node, 1);\n\n                if (node.init) {\n                    offsets.setDesiredOffsets(node.init.range, forOpeningParen, 1);\n                }\n                if (node.test) {\n                    offsets.setDesiredOffsets(node.test.range, forOpeningParen, 1);\n                }\n                if (node.update) {\n                    offsets.setDesiredOffsets(node.update.range, forOpeningParen, 1);\n                }\n                addBlocklessNodeIndent(node.body);\n            },\n\n            \"FunctionDeclaration, FunctionExpression\"(node) {\n                const closingParen = sourceCode.getTokenBefore(node.body);\n                const openingParen = sourceCode.getTokenBefore(node.params.length ? node.params[0] : closingParen);\n\n                parameterParens.add(openingParen);\n                parameterParens.add(closingParen);\n                addElementListIndent(node.params, openingParen, closingParen, options[node.type].parameters);\n            },\n\n            IfStatement(node) {\n                addBlocklessNodeIndent(node.consequent);\n                if (node.alternate && node.alternate.type !== \"IfStatement\") {\n                    addBlocklessNodeIndent(node.alternate);\n                }\n            },\n\n            ImportDeclaration(node) {\n                if (node.specifiers.some(specifier => specifier.type === \"ImportSpecifier\")) {\n                    const openingCurly = sourceCode.getFirstToken(node, astUtils$1.isOpeningBraceToken);\n                    const closingCurly = sourceCode.getLastToken(node, astUtils$1.isClosingBraceToken);\n\n                    addElementListIndent(node.specifiers.filter(specifier => specifier.type === \"ImportSpecifier\"), openingCurly, closingCurly, options.ImportDeclaration);\n                }\n\n                const fromToken = sourceCode.getLastToken(node, token => token.type === \"Identifier\" && token.value === \"from\");\n                const sourceToken = sourceCode.getLastToken(node, token => token.type === \"String\");\n                const semiToken = sourceCode.getLastToken(node, token => token.type === \"Punctuator\" && token.value === \";\");\n\n                if (fromToken) {\n                    const end = semiToken && semiToken.range[1] === sourceToken.range[1] ? node.range[1] : sourceToken.range[1];\n\n                    offsets.setDesiredOffsets([fromToken.range[0], end], sourceCode.getFirstToken(node), 1);\n                }\n            },\n\n            ImportExpression(node) {\n                const openingParen = sourceCode.getFirstToken(node, 1);\n                const closingParen = sourceCode.getLastToken(node);\n\n                parameterParens.add(openingParen);\n                parameterParens.add(closingParen);\n                offsets.setDesiredOffset(openingParen, sourceCode.getTokenBefore(openingParen), 0);\n\n                addElementListIndent([node.source], openingParen, closingParen, options.CallExpression.arguments);\n            },\n\n            \"MemberExpression, JSXMemberExpression, MetaProperty\"(node) {\n                const object = node.type === \"MetaProperty\" ? node.meta : node.object;\n                const firstNonObjectToken = sourceCode.getFirstTokenBetween(object, node.property, astUtils$1.isNotClosingParenToken);\n                const secondNonObjectToken = sourceCode.getTokenAfter(firstNonObjectToken);\n\n                const objectParenCount = sourceCode.getTokensBetween(object, node.property, { filter: astUtils$1.isClosingParenToken }).length;\n                const firstObjectToken = objectParenCount\n                    ? sourceCode.getTokenBefore(object, { skip: objectParenCount - 1 })\n                    : sourceCode.getFirstToken(object);\n                const lastObjectToken = sourceCode.getTokenBefore(firstNonObjectToken);\n                const firstPropertyToken = node.computed ? firstNonObjectToken : secondNonObjectToken;\n\n                if (node.computed) {\n\n                    // For computed MemberExpressions, match the closing bracket with the opening bracket.\n                    offsets.setDesiredOffset(sourceCode.getLastToken(node), firstNonObjectToken, 0);\n                    offsets.setDesiredOffsets(node.property.range, firstNonObjectToken, 1);\n                }\n\n                /*\n                 * If the object ends on the same line that the property starts, match against the last token\n                 * of the object, to ensure that the MemberExpression is not indented.\n                 *\n                 * Otherwise, match against the first token of the object, e.g.\n                 * foo\n                 *   .bar\n                 *   .baz // <-- offset by 1 from `foo`\n                 */\n                const offsetBase = lastObjectToken.loc.end.line === firstPropertyToken.loc.start.line\n                    ? lastObjectToken\n                    : firstObjectToken;\n\n                if (typeof options.MemberExpression === \"number\") {\n\n                    // Match the dot (for non-computed properties) or the opening bracket (for computed properties) against the object.\n                    offsets.setDesiredOffset(firstNonObjectToken, offsetBase, options.MemberExpression);\n\n                    /*\n                     * For computed MemberExpressions, match the first token of the property against the opening bracket.\n                     * Otherwise, match the first token of the property against the object.\n                     */\n                    offsets.setDesiredOffset(secondNonObjectToken, node.computed ? firstNonObjectToken : offsetBase, options.MemberExpression);\n                } else {\n\n                    // If the MemberExpression option is off, ignore the dot and the first token of the property.\n                    offsets.ignoreToken(firstNonObjectToken);\n                    offsets.ignoreToken(secondNonObjectToken);\n\n                    // To ignore the property indentation, ensure that the property tokens depend on the ignored tokens.\n                    offsets.setDesiredOffset(firstNonObjectToken, offsetBase, 0);\n                    offsets.setDesiredOffset(secondNonObjectToken, firstNonObjectToken, 0);\n                }\n            },\n\n            NewExpression(node) {\n\n                // Only indent the arguments if the NewExpression has parens (e.g. `new Foo(bar)` or `new Foo()`, but not `new Foo`\n                if (node.arguments.length > 0 ||\n                        astUtils$1.isClosingParenToken(sourceCode.getLastToken(node)) &&\n                        astUtils$1.isOpeningParenToken(sourceCode.getLastToken(node, 1))) {\n                    addFunctionCallIndent(node);\n                }\n            },\n\n            Property(node) {\n                if (!node.shorthand && !node.method && node.kind === \"init\") {\n                    const colon = sourceCode.getFirstTokenBetween(node.key, node.value, astUtils$1.isColonToken);\n\n                    offsets.ignoreToken(sourceCode.getTokenAfter(colon));\n                }\n            },\n\n            SwitchStatement(node) {\n                const openingCurly = sourceCode.getTokenAfter(node.discriminant, astUtils$1.isOpeningBraceToken);\n                const closingCurly = sourceCode.getLastToken(node);\n\n                offsets.setDesiredOffsets([openingCurly.range[1], closingCurly.range[0]], openingCurly, options.SwitchCase);\n\n                if (node.cases.length) {\n                    sourceCode.getTokensBetween(\n                        node.cases[node.cases.length - 1],\n                        closingCurly,\n                        { includeComments: true, filter: astUtils$1.isCommentToken }\n                    ).forEach(token => offsets.ignoreToken(token));\n                }\n            },\n\n            SwitchCase(node) {\n                if (!(node.consequent.length === 1 && node.consequent[0].type === \"BlockStatement\")) {\n                    const caseKeyword = sourceCode.getFirstToken(node);\n                    const tokenAfterCurrentCase = sourceCode.getTokenAfter(node);\n\n                    offsets.setDesiredOffsets([caseKeyword.range[1], tokenAfterCurrentCase.range[0]], caseKeyword, 1);\n                }\n            },\n\n            TemplateLiteral(node) {\n                node.expressions.forEach((expression, index) => {\n                    const previousQuasi = node.quasis[index];\n                    const nextQuasi = node.quasis[index + 1];\n                    const tokenToAlignFrom = previousQuasi.loc.start.line === previousQuasi.loc.end.line\n                        ? sourceCode.getFirstToken(previousQuasi)\n                        : null;\n\n                    offsets.setDesiredOffsets([previousQuasi.range[1], nextQuasi.range[0]], tokenToAlignFrom, 1);\n                    offsets.setDesiredOffset(sourceCode.getFirstToken(nextQuasi), tokenToAlignFrom, 0);\n                });\n            },\n\n            VariableDeclaration(node) {\n                let variableIndent = Object.prototype.hasOwnProperty.call(options.VariableDeclarator, node.kind)\n                    ? options.VariableDeclarator[node.kind]\n                    : DEFAULT_VARIABLE_INDENT;\n\n                const firstToken = sourceCode.getFirstToken(node),\n                    lastToken = sourceCode.getLastToken(node);\n\n                if (options.VariableDeclarator[node.kind] === \"first\") {\n                    if (node.declarations.length > 1) {\n                        addElementListIndent(\n                            node.declarations,\n                            firstToken,\n                            lastToken,\n                            \"first\"\n                        );\n                        return;\n                    }\n\n                    variableIndent = DEFAULT_VARIABLE_INDENT;\n                }\n\n                if (node.declarations[node.declarations.length - 1].loc.start.line > node.loc.start.line) {\n\n                    /*\n                     * VariableDeclarator indentation is a bit different from other forms of indentation, in that the\n                     * indentation of an opening bracket sometimes won't match that of a closing bracket. For example,\n                     * the following indentations are correct:\n                     *\n                     * var foo = {\n                     *   ok: true\n                     * };\n                     *\n                     * var foo = {\n                     *     ok: true,\n                     *   },\n                     *   bar = 1;\n                     *\n                     * Account for when exiting the AST (after indentations have already been set for the nodes in\n                     * the declaration) by manually increasing the indentation level of the tokens in this declarator\n                     * on the same line as the start of the declaration, provided that there are declarators that\n                     * follow this one.\n                     */\n                    offsets.setDesiredOffsets(node.range, firstToken, variableIndent, true);\n                } else {\n                    offsets.setDesiredOffsets(node.range, firstToken, variableIndent);\n                }\n\n                if (astUtils$1.isSemicolonToken(lastToken)) {\n                    offsets.ignoreToken(lastToken);\n                }\n            },\n\n            VariableDeclarator(node) {\n                if (node.init) {\n                    const equalOperator = sourceCode.getTokenBefore(node.init, astUtils$1.isNotOpeningParenToken);\n                    const tokenAfterOperator = sourceCode.getTokenAfter(equalOperator);\n\n                    offsets.ignoreToken(equalOperator);\n                    offsets.ignoreToken(tokenAfterOperator);\n                    offsets.setDesiredOffsets([tokenAfterOperator.range[0], node.range[1]], equalOperator, 1);\n                    offsets.setDesiredOffset(equalOperator, sourceCode.getLastToken(node.id), 0);\n                }\n            },\n\n            \"JSXAttribute[value]\"(node) {\n                const equalsToken = sourceCode.getFirstTokenBetween(node.name, node.value, token => token.type === \"Punctuator\" && token.value === \"=\");\n\n                offsets.setDesiredOffsets([equalsToken.range[0], node.value.range[1]], sourceCode.getFirstToken(node.name), 1);\n            },\n\n            JSXElement(node) {\n                if (node.closingElement) {\n                    addElementListIndent(node.children, sourceCode.getFirstToken(node.openingElement), sourceCode.getFirstToken(node.closingElement), 1);\n                }\n            },\n\n            JSXOpeningElement(node) {\n                const firstToken = sourceCode.getFirstToken(node);\n                let closingToken;\n\n                if (node.selfClosing) {\n                    closingToken = sourceCode.getLastToken(node, { skip: 1 });\n                    offsets.setDesiredOffset(sourceCode.getLastToken(node), closingToken, 0);\n                } else {\n                    closingToken = sourceCode.getLastToken(node);\n                }\n                offsets.setDesiredOffsets(node.name.range, sourceCode.getFirstToken(node));\n                addElementListIndent(node.attributes, firstToken, closingToken, 1);\n            },\n\n            JSXClosingElement(node) {\n                const firstToken = sourceCode.getFirstToken(node);\n\n                offsets.setDesiredOffsets(node.name.range, firstToken, 1);\n            },\n\n            JSXFragment(node) {\n                const firstOpeningToken = sourceCode.getFirstToken(node.openingFragment);\n                const firstClosingToken = sourceCode.getFirstToken(node.closingFragment);\n\n                addElementListIndent(node.children, firstOpeningToken, firstClosingToken, 1);\n            },\n\n            JSXOpeningFragment(node) {\n                const firstToken = sourceCode.getFirstToken(node);\n                const closingToken = sourceCode.getLastToken(node);\n\n                offsets.setDesiredOffsets(node.range, firstToken, 1);\n                offsets.matchOffsetOf(firstToken, closingToken);\n            },\n\n            JSXClosingFragment(node) {\n                const firstToken = sourceCode.getFirstToken(node);\n                const slashToken = sourceCode.getLastToken(node, { skip: 1 });\n                const closingToken = sourceCode.getLastToken(node);\n                const tokenToMatch = astUtils$1.isTokenOnSameLine(slashToken, closingToken) ? slashToken : closingToken;\n\n                offsets.setDesiredOffsets(node.range, firstToken, 1);\n                offsets.matchOffsetOf(firstToken, tokenToMatch);\n            },\n\n            JSXExpressionContainer(node) {\n                const openingCurly = sourceCode.getFirstToken(node);\n                const closingCurly = sourceCode.getLastToken(node);\n\n                offsets.setDesiredOffsets(\n                    [openingCurly.range[1], closingCurly.range[0]],\n                    openingCurly,\n                    1\n                );\n            },\n\n            JSXSpreadAttribute(node) {\n                const openingCurly = sourceCode.getFirstToken(node);\n                const closingCurly = sourceCode.getLastToken(node);\n\n                offsets.setDesiredOffsets(\n                    [openingCurly.range[1], closingCurly.range[0]],\n                    openingCurly,\n                    1\n                );\n            },\n\n            \"*\"(node) {\n                const firstToken = sourceCode.getFirstToken(node);\n\n                // Ensure that the children of every node are indented at least as much as the first token.\n                if (firstToken && !ignoredNodeFirstTokens.has(firstToken)) {\n                    offsets.setDesiredOffsets(node.range, firstToken, 0);\n                }\n            }\n        };\n\n        const listenerCallQueue = [];\n\n        /*\n         * To ignore the indentation of a node:\n         * 1. Don't call the node's listener when entering it (if it has a listener)\n         * 2. Don't set any offsets against the first token of the node.\n         * 3. Call `ignoreNode` on the node sometime after exiting it and before validating offsets.\n         */\n        const offsetListeners = lodash.mapValues(\n            baseOffsetListeners,\n\n            /*\n             * Offset listener calls are deferred until traversal is finished, and are called as\n             * part of the final `Program:exit` listener. This is necessary because a node might\n             * be matched by multiple selectors.\n             *\n             * Example: Suppose there is an offset listener for `Identifier`, and the user has\n             * specified in configuration that `MemberExpression > Identifier` should be ignored.\n             * Due to selector specificity rules, the `Identifier` listener will get called first. However,\n             * if a given Identifier node is supposed to be ignored, then the `Identifier` offset listener\n             * should not have been called at all. Without doing extra selector matching, we don't know\n             * whether the Identifier matches the `MemberExpression > Identifier` selector until the\n             * `MemberExpression > Identifier` listener is called.\n             *\n             * To avoid this, the `Identifier` listener isn't called until traversal finishes and all\n             * ignored nodes are known.\n             */\n            listener =>\n                node =>\n                    listenerCallQueue.push({ listener, node })\n        );\n\n        // For each ignored node selector, set up a listener to collect it into the `ignoredNodes` set.\n        const ignoredNodes = new Set();\n\n        /**\n         * Ignores a node\n         * @param {ASTNode} node The node to ignore\n         * @returns {void}\n         */\n        function addToIgnoredNodes(node) {\n            ignoredNodes.add(node);\n            ignoredNodeFirstTokens.add(sourceCode.getFirstToken(node));\n        }\n\n        const ignoredNodeListeners = options.ignoredNodes.reduce(\n            (listeners, ignoredSelector) => Object.assign(listeners, { [ignoredSelector]: addToIgnoredNodes }),\n            {}\n        );\n\n        /*\n         * Join the listeners, and add a listener to verify that all tokens actually have the correct indentation\n         * at the end.\n         *\n         * Using Object.assign will cause some offset listeners to be overwritten if the same selector also appears\n         * in `ignoredNodeListeners`. This isn't a problem because all of the matching nodes will be ignored,\n         * so those listeners wouldn't be called anyway.\n         */\n        return Object.assign(\n            offsetListeners,\n            ignoredNodeListeners,\n            {\n                \"*:exit\"(node) {\n\n                    // If a node's type is nonstandard, we can't tell how its children should be offset, so ignore it.\n                    if (!KNOWN_NODES.has(node.type)) {\n                        addToIgnoredNodes(node);\n                    }\n                },\n                \"Program:exit\"() {\n\n                    // If ignoreComments option is enabled, ignore all comment tokens.\n                    if (options.ignoreComments) {\n                        sourceCode.getAllComments()\n                            .forEach(comment => offsets.ignoreToken(comment));\n                    }\n\n                    // Invoke the queued offset listeners for the nodes that aren't ignored.\n                    listenerCallQueue\n                        .filter(nodeInfo => !ignoredNodes.has(nodeInfo.node))\n                        .forEach(nodeInfo => nodeInfo.listener(nodeInfo.node));\n\n                    // Update the offsets for ignored nodes to prevent their child tokens from being reported.\n                    ignoredNodes.forEach(ignoreNode);\n\n                    addParensIndent(sourceCode.ast.tokens);\n\n                    /*\n                     * Create a Map from (tokenOrComment) => (precedingToken).\n                     * This is necessary because sourceCode.getTokenBefore does not handle a comment as an argument correctly.\n                     */\n                    const precedingTokens = sourceCode.ast.comments.reduce((commentMap, comment) => {\n                        const tokenOrCommentBefore = sourceCode.getTokenBefore(comment, { includeComments: true });\n\n                        return commentMap.set(comment, commentMap.has(tokenOrCommentBefore) ? commentMap.get(tokenOrCommentBefore) : tokenOrCommentBefore);\n                    }, new WeakMap());\n\n                    sourceCode.lines.forEach((line, lineIndex) => {\n                        const lineNumber = lineIndex + 1;\n\n                        if (!tokenInfo.firstTokensByLineNumber.has(lineNumber)) {\n\n                            // Don't check indentation on blank lines\n                            return;\n                        }\n\n                        const firstTokenOfLine = tokenInfo.firstTokensByLineNumber.get(lineNumber);\n\n                        if (firstTokenOfLine.loc.start.line !== lineNumber) {\n\n                            // Don't check the indentation of multi-line tokens (e.g. template literals or block comments) twice.\n                            return;\n                        }\n\n                        if (astUtils$1.isCommentToken(firstTokenOfLine)) {\n                            const tokenBefore = precedingTokens.get(firstTokenOfLine);\n                            const tokenAfter = tokenBefore ? sourceCode.getTokenAfter(tokenBefore) : sourceCode.ast.tokens[0];\n                            const mayAlignWithBefore = tokenBefore && !hasBlankLinesBetween(tokenBefore, firstTokenOfLine);\n                            const mayAlignWithAfter = tokenAfter && !hasBlankLinesBetween(firstTokenOfLine, tokenAfter);\n\n                            /*\n                             * If a comment precedes a line that begins with a semicolon token, align to that token, i.e.\n                             *\n                             * let foo\n                             * // comment\n                             * ;(async () => {})()\n                             */\n                            if (tokenAfter && astUtils$1.isSemicolonToken(tokenAfter) && !astUtils$1.isTokenOnSameLine(firstTokenOfLine, tokenAfter)) {\n                                offsets.setDesiredOffset(firstTokenOfLine, tokenAfter, 0);\n                            }\n\n                            // If a comment matches the expected indentation of the token immediately before or after, don't report it.\n                            if (\n                                mayAlignWithBefore && validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(tokenBefore)) ||\n                                mayAlignWithAfter && validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(tokenAfter))\n                            ) {\n                                return;\n                            }\n                        }\n\n                        // If the token matches the expected indentation, don't report it.\n                        if (validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine))) {\n                            return;\n                        }\n\n                        // Otherwise, report the token/comment.\n                        report(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine));\n                    });\n                }\n            }\n        );\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\n/* istanbul ignore next: this rule has known coverage issues, but it's deprecated and shouldn't be updated in the future anyway. */\nvar indentLegacy = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent indentation\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/indent-legacy\"\n        },\n\n        deprecated: true,\n\n        replacedBy: [\"indent\"],\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        enum: [\"tab\"]\n                    },\n                    {\n                        type: \"integer\",\n                        minimum: 0\n                    }\n                ]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    SwitchCase: {\n                        type: \"integer\",\n                        minimum: 0\n                    },\n                    VariableDeclarator: {\n                        oneOf: [\n                            {\n                                type: \"integer\",\n                                minimum: 0\n                            },\n                            {\n                                type: \"object\",\n                                properties: {\n                                    var: {\n                                        type: \"integer\",\n                                        minimum: 0\n                                    },\n                                    let: {\n                                        type: \"integer\",\n                                        minimum: 0\n                                    },\n                                    const: {\n                                        type: \"integer\",\n                                        minimum: 0\n                                    }\n                                }\n                            }\n                        ]\n                    },\n                    outerIIFEBody: {\n                        type: \"integer\",\n                        minimum: 0\n                    },\n                    MemberExpression: {\n                        type: \"integer\",\n                        minimum: 0\n                    },\n                    FunctionDeclaration: {\n                        type: \"object\",\n                        properties: {\n                            parameters: {\n                                oneOf: [\n                                    {\n                                        type: \"integer\",\n                                        minimum: 0\n                                    },\n                                    {\n                                        enum: [\"first\"]\n                                    }\n                                ]\n                            },\n                            body: {\n                                type: \"integer\",\n                                minimum: 0\n                            }\n                        }\n                    },\n                    FunctionExpression: {\n                        type: \"object\",\n                        properties: {\n                            parameters: {\n                                oneOf: [\n                                    {\n                                        type: \"integer\",\n                                        minimum: 0\n                                    },\n                                    {\n                                        enum: [\"first\"]\n                                    }\n                                ]\n                            },\n                            body: {\n                                type: \"integer\",\n                                minimum: 0\n                            }\n                        }\n                    },\n                    CallExpression: {\n                        type: \"object\",\n                        properties: {\n                            parameters: {\n                                oneOf: [\n                                    {\n                                        type: \"integer\",\n                                        minimum: 0\n                                    },\n                                    {\n                                        enum: [\"first\"]\n                                    }\n                                ]\n                            }\n                        }\n                    },\n                    ArrayExpression: {\n                        oneOf: [\n                            {\n                                type: \"integer\",\n                                minimum: 0\n                            },\n                            {\n                                enum: [\"first\"]\n                            }\n                        ]\n                    },\n                    ObjectExpression: {\n                        oneOf: [\n                            {\n                                type: \"integer\",\n                                minimum: 0\n                            },\n                            {\n                                enum: [\"first\"]\n                            }\n                        ]\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n        messages: {\n            expected: \"Expected indentation of {{expected}} but found {{actual}}.\"\n        }\n    },\n\n    create(context) {\n        const DEFAULT_VARIABLE_INDENT = 1;\n        const DEFAULT_PARAMETER_INDENT = null; // For backwards compatibility, don't check parameter indentation unless specified in the config\n        const DEFAULT_FUNCTION_BODY_INDENT = 1;\n\n        let indentType = \"space\";\n        let indentSize = 4;\n        const options = {\n            SwitchCase: 0,\n            VariableDeclarator: {\n                var: DEFAULT_VARIABLE_INDENT,\n                let: DEFAULT_VARIABLE_INDENT,\n                const: DEFAULT_VARIABLE_INDENT\n            },\n            outerIIFEBody: null,\n            FunctionDeclaration: {\n                parameters: DEFAULT_PARAMETER_INDENT,\n                body: DEFAULT_FUNCTION_BODY_INDENT\n            },\n            FunctionExpression: {\n                parameters: DEFAULT_PARAMETER_INDENT,\n                body: DEFAULT_FUNCTION_BODY_INDENT\n            },\n            CallExpression: {\n                arguments: DEFAULT_PARAMETER_INDENT\n            },\n            ArrayExpression: 1,\n            ObjectExpression: 1\n        };\n\n        const sourceCode = context.getSourceCode();\n\n        if (context.options.length) {\n            if (context.options[0] === \"tab\") {\n                indentSize = 1;\n                indentType = \"tab\";\n            } else /* istanbul ignore else : this will be caught by options validation */ if (typeof context.options[0] === \"number\") {\n                indentSize = context.options[0];\n                indentType = \"space\";\n            }\n\n            if (context.options[1]) {\n                const opts = context.options[1];\n\n                options.SwitchCase = opts.SwitchCase || 0;\n                const variableDeclaratorRules = opts.VariableDeclarator;\n\n                if (typeof variableDeclaratorRules === \"number\") {\n                    options.VariableDeclarator = {\n                        var: variableDeclaratorRules,\n                        let: variableDeclaratorRules,\n                        const: variableDeclaratorRules\n                    };\n                } else if (typeof variableDeclaratorRules === \"object\") {\n                    Object.assign(options.VariableDeclarator, variableDeclaratorRules);\n                }\n\n                if (typeof opts.outerIIFEBody === \"number\") {\n                    options.outerIIFEBody = opts.outerIIFEBody;\n                }\n\n                if (typeof opts.MemberExpression === \"number\") {\n                    options.MemberExpression = opts.MemberExpression;\n                }\n\n                if (typeof opts.FunctionDeclaration === \"object\") {\n                    Object.assign(options.FunctionDeclaration, opts.FunctionDeclaration);\n                }\n\n                if (typeof opts.FunctionExpression === \"object\") {\n                    Object.assign(options.FunctionExpression, opts.FunctionExpression);\n                }\n\n                if (typeof opts.CallExpression === \"object\") {\n                    Object.assign(options.CallExpression, opts.CallExpression);\n                }\n\n                if (typeof opts.ArrayExpression === \"number\" || typeof opts.ArrayExpression === \"string\") {\n                    options.ArrayExpression = opts.ArrayExpression;\n                }\n\n                if (typeof opts.ObjectExpression === \"number\" || typeof opts.ObjectExpression === \"string\") {\n                    options.ObjectExpression = opts.ObjectExpression;\n                }\n            }\n        }\n\n        const caseIndentStore = {};\n\n        /**\n         * Creates an error message for a line, given the expected/actual indentation.\n         * @param {int} expectedAmount The expected amount of indentation characters for this line\n         * @param {int} actualSpaces The actual number of indentation spaces that were found on this line\n         * @param {int} actualTabs The actual number of indentation tabs that were found on this line\n         * @returns {string} An error message for this line\n         */\n        function createErrorMessageData(expectedAmount, actualSpaces, actualTabs) {\n            const expectedStatement = `${expectedAmount} ${indentType}${expectedAmount === 1 ? \"\" : \"s\"}`; // e.g. \"2 tabs\"\n            const foundSpacesWord = `space${actualSpaces === 1 ? \"\" : \"s\"}`; // e.g. \"space\"\n            const foundTabsWord = `tab${actualTabs === 1 ? \"\" : \"s\"}`; // e.g. \"tabs\"\n            let foundStatement;\n\n            if (actualSpaces > 0 && actualTabs > 0) {\n                foundStatement = `${actualSpaces} ${foundSpacesWord} and ${actualTabs} ${foundTabsWord}`; // e.g. \"1 space and 2 tabs\"\n            } else if (actualSpaces > 0) {\n\n                /*\n                 * Abbreviate the message if the expected indentation is also spaces.\n                 * e.g. 'Expected 4 spaces but found 2' rather than 'Expected 4 spaces but found 2 spaces'\n                 */\n                foundStatement = indentType === \"space\" ? actualSpaces : `${actualSpaces} ${foundSpacesWord}`;\n            } else if (actualTabs > 0) {\n                foundStatement = indentType === \"tab\" ? actualTabs : `${actualTabs} ${foundTabsWord}`;\n            } else {\n                foundStatement = \"0\";\n            }\n            return {\n                expected: expectedStatement,\n                actual: foundStatement\n            };\n        }\n\n        /**\n         * Reports a given indent violation\n         * @param {ASTNode} node Node violating the indent rule\n         * @param {int} needed Expected indentation character count\n         * @param {int} gottenSpaces Indentation space count in the actual node/code\n         * @param {int} gottenTabs Indentation tab count in the actual node/code\n         * @param {Object} [loc] Error line and column location\n         * @param {boolean} isLastNodeCheck Is the error for last node check\n         * @returns {void}\n         */\n        function report(node, needed, gottenSpaces, gottenTabs, loc, isLastNodeCheck) {\n            if (gottenSpaces && gottenTabs) {\n\n                // To avoid conflicts with `no-mixed-spaces-and-tabs`, don't report lines that have both spaces and tabs.\n                return;\n            }\n\n            const desiredIndent = (indentType === \"space\" ? \" \" : \"\\t\").repeat(needed);\n\n            const textRange = isLastNodeCheck\n                ? [node.range[1] - node.loc.end.column, node.range[1] - node.loc.end.column + gottenSpaces + gottenTabs]\n                : [node.range[0] - node.loc.start.column, node.range[0] - node.loc.start.column + gottenSpaces + gottenTabs];\n\n            context.report({\n                node,\n                loc,\n                messageId: \"expected\",\n                data: createErrorMessageData(needed, gottenSpaces, gottenTabs),\n                fix: fixer => fixer.replaceTextRange(textRange, desiredIndent)\n            });\n        }\n\n        /**\n         * Get the actual indent of node\n         * @param {ASTNode|Token} node Node to examine\n         * @param {boolean} [byLastLine=false] get indent of node's last line\n         * @returns {Object} The node's indent. Contains keys `space` and `tab`, representing the indent of each character. Also\n         * contains keys `goodChar` and `badChar`, where `goodChar` is the amount of the user's desired indentation character, and\n         * `badChar` is the amount of the other indentation character.\n         */\n        function getNodeIndent(node, byLastLine) {\n            const token = byLastLine ? sourceCode.getLastToken(node) : sourceCode.getFirstToken(node);\n            const srcCharsBeforeNode = sourceCode.getText(token, token.loc.start.column).split(\"\");\n            const indentChars = srcCharsBeforeNode.slice(0, srcCharsBeforeNode.findIndex(char => char !== \" \" && char !== \"\\t\"));\n            const spaces = indentChars.filter(char => char === \" \").length;\n            const tabs = indentChars.filter(char => char === \"\\t\").length;\n\n            return {\n                space: spaces,\n                tab: tabs,\n                goodChar: indentType === \"space\" ? spaces : tabs,\n                badChar: indentType === \"space\" ? tabs : spaces\n            };\n        }\n\n        /**\n         * Checks node is the first in its own start line. By default it looks by start line.\n         * @param {ASTNode} node The node to check\n         * @param {boolean} [byEndLocation=false] Lookup based on start position or end\n         * @returns {boolean} true if its the first in the its start line\n         */\n        function isNodeFirstInLine(node, byEndLocation) {\n            const firstToken = byEndLocation === true ? sourceCode.getLastToken(node, 1) : sourceCode.getTokenBefore(node),\n                startLine = byEndLocation === true ? node.loc.end.line : node.loc.start.line,\n                endLine = firstToken ? firstToken.loc.end.line : -1;\n\n            return startLine !== endLine;\n        }\n\n        /**\n         * Check indent for node\n         * @param {ASTNode} node Node to check\n         * @param {int} neededIndent needed indent\n         * @returns {void}\n         */\n        function checkNodeIndent(node, neededIndent) {\n            const actualIndent = getNodeIndent(node, false);\n\n            if (\n                node.type !== \"ArrayExpression\" &&\n                node.type !== \"ObjectExpression\" &&\n                (actualIndent.goodChar !== neededIndent || actualIndent.badChar !== 0) &&\n                isNodeFirstInLine(node)\n            ) {\n                report(node, neededIndent, actualIndent.space, actualIndent.tab);\n            }\n\n            if (node.type === \"IfStatement\" && node.alternate) {\n                const elseToken = sourceCode.getTokenBefore(node.alternate);\n\n                checkNodeIndent(elseToken, neededIndent);\n\n                if (!isNodeFirstInLine(node.alternate)) {\n                    checkNodeIndent(node.alternate, neededIndent);\n                }\n            }\n\n            if (node.type === \"TryStatement\" && node.handler) {\n                const catchToken = sourceCode.getFirstToken(node.handler);\n\n                checkNodeIndent(catchToken, neededIndent);\n            }\n\n            if (node.type === \"TryStatement\" && node.finalizer) {\n                const finallyToken = sourceCode.getTokenBefore(node.finalizer);\n\n                checkNodeIndent(finallyToken, neededIndent);\n            }\n\n            if (node.type === \"DoWhileStatement\") {\n                const whileToken = sourceCode.getTokenAfter(node.body);\n\n                checkNodeIndent(whileToken, neededIndent);\n            }\n        }\n\n        /**\n         * Check indent for nodes list\n         * @param {ASTNode[]} nodes list of node objects\n         * @param {int} indent needed indent\n         * @returns {void}\n         */\n        function checkNodesIndent(nodes, indent) {\n            nodes.forEach(node => checkNodeIndent(node, indent));\n        }\n\n        /**\n         * Check last node line indent this detects, that block closed correctly\n         * @param {ASTNode} node Node to examine\n         * @param {int} lastLineIndent needed indent\n         * @returns {void}\n         */\n        function checkLastNodeLineIndent(node, lastLineIndent) {\n            const lastToken = sourceCode.getLastToken(node);\n            const endIndent = getNodeIndent(lastToken, true);\n\n            if ((endIndent.goodChar !== lastLineIndent || endIndent.badChar !== 0) && isNodeFirstInLine(node, true)) {\n                report(\n                    node,\n                    lastLineIndent,\n                    endIndent.space,\n                    endIndent.tab,\n                    { line: lastToken.loc.start.line, column: lastToken.loc.start.column },\n                    true\n                );\n            }\n        }\n\n        /**\n         * Check last node line indent this detects, that block closed correctly\n         * This function for more complicated return statement case, where closing parenthesis may be followed by ';'\n         * @param {ASTNode} node Node to examine\n         * @param {int} firstLineIndent first line needed indent\n         * @returns {void}\n         */\n        function checkLastReturnStatementLineIndent(node, firstLineIndent) {\n\n            /*\n             * in case if return statement ends with ');' we have traverse back to ')'\n             * otherwise we'll measure indent for ';' and replace ')'\n             */\n            const lastToken = sourceCode.getLastToken(node, astUtils$1.isClosingParenToken);\n            const textBeforeClosingParenthesis = sourceCode.getText(lastToken, lastToken.loc.start.column).slice(0, -1);\n\n            if (textBeforeClosingParenthesis.trim()) {\n\n                // There are tokens before the closing paren, don't report this case\n                return;\n            }\n\n            const endIndent = getNodeIndent(lastToken, true);\n\n            if (endIndent.goodChar !== firstLineIndent) {\n                report(\n                    node,\n                    firstLineIndent,\n                    endIndent.space,\n                    endIndent.tab,\n                    { line: lastToken.loc.start.line, column: lastToken.loc.start.column },\n                    true\n                );\n            }\n        }\n\n        /**\n         * Check first node line indent is correct\n         * @param {ASTNode} node Node to examine\n         * @param {int} firstLineIndent needed indent\n         * @returns {void}\n         */\n        function checkFirstNodeLineIndent(node, firstLineIndent) {\n            const startIndent = getNodeIndent(node, false);\n\n            if ((startIndent.goodChar !== firstLineIndent || startIndent.badChar !== 0) && isNodeFirstInLine(node)) {\n                report(\n                    node,\n                    firstLineIndent,\n                    startIndent.space,\n                    startIndent.tab,\n                    { line: node.loc.start.line, column: node.loc.start.column }\n                );\n            }\n        }\n\n        /**\n         * Returns a parent node of given node based on a specified type\n         * if not present then return null\n         * @param {ASTNode} node node to examine\n         * @param {string} type type that is being looked for\n         * @param {string} stopAtList end points for the evaluating code\n         * @returns {ASTNode|void} if found then node otherwise null\n         */\n        function getParentNodeByType(node, type, stopAtList) {\n            let parent = node.parent;\n            const stopAtSet = new Set(stopAtList || [\"Program\"]);\n\n            while (parent.type !== type && !stopAtSet.has(parent.type) && parent.type !== \"Program\") {\n                parent = parent.parent;\n            }\n\n            return parent.type === type ? parent : null;\n        }\n\n        /**\n         * Returns the VariableDeclarator based on the current node\n         * if not present then return null\n         * @param {ASTNode} node node to examine\n         * @returns {ASTNode|void} if found then node otherwise null\n         */\n        function getVariableDeclaratorNode(node) {\n            return getParentNodeByType(node, \"VariableDeclarator\");\n        }\n\n        /**\n         * Check to see if the node is part of the multi-line variable declaration.\n         * Also if its on the same line as the varNode\n         * @param {ASTNode} node node to check\n         * @param {ASTNode} varNode variable declaration node to check against\n         * @returns {boolean} True if all the above condition satisfy\n         */\n        function isNodeInVarOnTop(node, varNode) {\n            return varNode &&\n                varNode.parent.loc.start.line === node.loc.start.line &&\n                varNode.parent.declarations.length > 1;\n        }\n\n        /**\n         * Check to see if the argument before the callee node is multi-line and\n         * there should only be 1 argument before the callee node\n         * @param {ASTNode} node node to check\n         * @returns {boolean} True if arguments are multi-line\n         */\n        function isArgBeforeCalleeNodeMultiline(node) {\n            const parent = node.parent;\n\n            if (parent.arguments.length >= 2 && parent.arguments[1] === node) {\n                return parent.arguments[0].loc.end.line > parent.arguments[0].loc.start.line;\n            }\n\n            return false;\n        }\n\n        /**\n         * Check to see if the node is a file level IIFE\n         * @param {ASTNode} node The function node to check.\n         * @returns {boolean} True if the node is the outer IIFE\n         */\n        function isOuterIIFE(node) {\n            const parent = node.parent;\n            let stmt = parent.parent;\n\n            /*\n             * Verify that the node is an IIEF\n             */\n            if (\n                parent.type !== \"CallExpression\" ||\n                parent.callee !== node) {\n\n                return false;\n            }\n\n            /*\n             * Navigate legal ancestors to determine whether this IIEF is outer\n             */\n            while (\n                stmt.type === \"UnaryExpression\" && (\n                    stmt.operator === \"!\" ||\n                    stmt.operator === \"~\" ||\n                    stmt.operator === \"+\" ||\n                    stmt.operator === \"-\") ||\n                stmt.type === \"AssignmentExpression\" ||\n                stmt.type === \"LogicalExpression\" ||\n                stmt.type === \"SequenceExpression\" ||\n                stmt.type === \"VariableDeclarator\") {\n\n                stmt = stmt.parent;\n            }\n\n            return ((\n                stmt.type === \"ExpressionStatement\" ||\n                stmt.type === \"VariableDeclaration\") &&\n                stmt.parent && stmt.parent.type === \"Program\"\n            );\n        }\n\n        /**\n         * Check indent for function block content\n         * @param {ASTNode} node A BlockStatement node that is inside of a function.\n         * @returns {void}\n         */\n        function checkIndentInFunctionBlock(node) {\n\n            /*\n             * Search first caller in chain.\n             * Ex.:\n             *\n             * Models <- Identifier\n             *   .User\n             *   .find()\n             *   .exec(function() {\n             *   // function body\n             * });\n             *\n             * Looks for 'Models'\n             */\n            const calleeNode = node.parent; // FunctionExpression\n            let indent;\n\n            if (calleeNode.parent &&\n                (calleeNode.parent.type === \"Property\" ||\n                calleeNode.parent.type === \"ArrayExpression\")) {\n\n                // If function is part of array or object, comma can be put at left\n                indent = getNodeIndent(calleeNode, false).goodChar;\n            } else {\n\n                // If function is standalone, simple calculate indent\n                indent = getNodeIndent(calleeNode).goodChar;\n            }\n\n            if (calleeNode.parent.type === \"CallExpression\") {\n                const calleeParent = calleeNode.parent;\n\n                if (calleeNode.type !== \"FunctionExpression\" && calleeNode.type !== \"ArrowFunctionExpression\") {\n                    if (calleeParent && calleeParent.loc.start.line < node.loc.start.line) {\n                        indent = getNodeIndent(calleeParent).goodChar;\n                    }\n                } else {\n                    if (isArgBeforeCalleeNodeMultiline(calleeNode) &&\n                        calleeParent.callee.loc.start.line === calleeParent.callee.loc.end.line &&\n                        !isNodeFirstInLine(calleeNode)) {\n                        indent = getNodeIndent(calleeParent).goodChar;\n                    }\n                }\n            }\n\n            /*\n             * function body indent should be indent + indent size, unless this\n             * is a FunctionDeclaration, FunctionExpression, or outer IIFE and the corresponding options are enabled.\n             */\n            let functionOffset = indentSize;\n\n            if (options.outerIIFEBody !== null && isOuterIIFE(calleeNode)) {\n                functionOffset = options.outerIIFEBody * indentSize;\n            } else if (calleeNode.type === \"FunctionExpression\") {\n                functionOffset = options.FunctionExpression.body * indentSize;\n            } else if (calleeNode.type === \"FunctionDeclaration\") {\n                functionOffset = options.FunctionDeclaration.body * indentSize;\n            }\n            indent += functionOffset;\n\n            // check if the node is inside a variable\n            const parentVarNode = getVariableDeclaratorNode(node);\n\n            if (parentVarNode && isNodeInVarOnTop(node, parentVarNode)) {\n                indent += indentSize * options.VariableDeclarator[parentVarNode.parent.kind];\n            }\n\n            if (node.body.length > 0) {\n                checkNodesIndent(node.body, indent);\n            }\n\n            checkLastNodeLineIndent(node, indent - functionOffset);\n        }\n\n\n        /**\n         * Checks if the given node starts and ends on the same line\n         * @param {ASTNode} node The node to check\n         * @returns {boolean} Whether or not the block starts and ends on the same line.\n         */\n        function isSingleLineNode(node) {\n            const lastToken = sourceCode.getLastToken(node),\n                startLine = node.loc.start.line,\n                endLine = lastToken.loc.end.line;\n\n            return startLine === endLine;\n        }\n\n        /**\n         * Check to see if the first element inside an array is an object and on the same line as the node\n         * If the node is not an array then it will return false.\n         * @param {ASTNode} node node to check\n         * @returns {boolean} success/failure\n         */\n        function isFirstArrayElementOnSameLine(node) {\n            if (node.type === \"ArrayExpression\" && node.elements[0]) {\n                return node.elements[0].loc.start.line === node.loc.start.line && node.elements[0].type === \"ObjectExpression\";\n            }\n            return false;\n\n        }\n\n        /**\n         * Check indent for array block content or object block content\n         * @param {ASTNode} node node to examine\n         * @returns {void}\n         */\n        function checkIndentInArrayOrObjectBlock(node) {\n\n            // Skip inline\n            if (isSingleLineNode(node)) {\n                return;\n            }\n\n            let elements = (node.type === \"ArrayExpression\") ? node.elements : node.properties;\n\n            // filter out empty elements example would be [ , 2] so remove first element as espree considers it as null\n            elements = elements.filter(elem => elem !== null);\n\n            let nodeIndent;\n            let elementsIndent;\n            const parentVarNode = getVariableDeclaratorNode(node);\n\n            // TODO - come up with a better strategy in future\n            if (isNodeFirstInLine(node)) {\n                const parent = node.parent;\n\n                nodeIndent = getNodeIndent(parent).goodChar;\n                if (!parentVarNode || parentVarNode.loc.start.line !== node.loc.start.line) {\n                    if (parent.type !== \"VariableDeclarator\" || parentVarNode === parentVarNode.parent.declarations[0]) {\n                        if (parent.type === \"VariableDeclarator\" && parentVarNode.loc.start.line === parent.loc.start.line) {\n                            nodeIndent += (indentSize * options.VariableDeclarator[parentVarNode.parent.kind]);\n                        } else if (parent.type === \"ObjectExpression\" || parent.type === \"ArrayExpression\") {\n                            const parentElements = node.parent.type === \"ObjectExpression\" ? node.parent.properties : node.parent.elements;\n\n                            if (parentElements[0] &&\n                                    parentElements[0].loc.start.line === parent.loc.start.line &&\n                                    parentElements[0].loc.end.line !== parent.loc.start.line) ; else if (typeof options[parent.type] === \"number\") {\n                                nodeIndent += options[parent.type] * indentSize;\n                            } else {\n                                nodeIndent = parentElements[0].loc.start.column;\n                            }\n                        } else if (parent.type === \"CallExpression\" || parent.type === \"NewExpression\") {\n                            if (typeof options.CallExpression.arguments === \"number\") {\n                                nodeIndent += options.CallExpression.arguments * indentSize;\n                            } else if (options.CallExpression.arguments === \"first\") {\n                                if (parent.arguments.indexOf(node) !== -1) {\n                                    nodeIndent = parent.arguments[0].loc.start.column;\n                                }\n                            } else {\n                                nodeIndent += indentSize;\n                            }\n                        } else if (parent.type === \"LogicalExpression\" || parent.type === \"ArrowFunctionExpression\") {\n                            nodeIndent += indentSize;\n                        }\n                    }\n                } else if (!parentVarNode && !isFirstArrayElementOnSameLine(parent) && parent.type !== \"MemberExpression\" && parent.type !== \"ExpressionStatement\" && parent.type !== \"AssignmentExpression\" && parent.type !== \"Property\") {\n                    nodeIndent += indentSize;\n                }\n\n                checkFirstNodeLineIndent(node, nodeIndent);\n            } else {\n                nodeIndent = getNodeIndent(node).goodChar;\n            }\n\n            if (options[node.type] === \"first\") {\n                elementsIndent = elements.length ? elements[0].loc.start.column : 0; // If there are no elements, elementsIndent doesn't matter.\n            } else {\n                elementsIndent = nodeIndent + indentSize * options[node.type];\n            }\n\n            /*\n             * Check if the node is a multiple variable declaration; if so, then\n             * make sure indentation takes that into account.\n             */\n            if (isNodeInVarOnTop(node, parentVarNode)) {\n                elementsIndent += indentSize * options.VariableDeclarator[parentVarNode.parent.kind];\n            }\n\n            checkNodesIndent(elements, elementsIndent);\n\n            if (elements.length > 0) {\n\n                // Skip last block line check if last item in same line\n                if (elements[elements.length - 1].loc.end.line === node.loc.end.line) {\n                    return;\n                }\n            }\n\n            checkLastNodeLineIndent(node, nodeIndent +\n                (isNodeInVarOnTop(node, parentVarNode) ? options.VariableDeclarator[parentVarNode.parent.kind] * indentSize : 0));\n        }\n\n        /**\n         * Check if the node or node body is a BlockStatement or not\n         * @param {ASTNode} node node to test\n         * @returns {boolean} True if it or its body is a block statement\n         */\n        function isNodeBodyBlock(node) {\n            return node.type === \"BlockStatement\" || node.type === \"ClassBody\" || (node.body && node.body.type === \"BlockStatement\") ||\n                (node.consequent && node.consequent.type === \"BlockStatement\");\n        }\n\n        /**\n         * Check indentation for blocks\n         * @param {ASTNode} node node to check\n         * @returns {void}\n         */\n        function blockIndentationCheck(node) {\n\n            // Skip inline blocks\n            if (isSingleLineNode(node)) {\n                return;\n            }\n\n            if (node.parent && (\n                node.parent.type === \"FunctionExpression\" ||\n                node.parent.type === \"FunctionDeclaration\" ||\n                node.parent.type === \"ArrowFunctionExpression\")\n            ) {\n                checkIndentInFunctionBlock(node);\n                return;\n            }\n\n            let indent;\n            let nodesToCheck = [];\n\n            /*\n             * For this statements we should check indent from statement beginning,\n             * not from the beginning of the block.\n             */\n            const statementsWithProperties = [\n                \"IfStatement\", \"WhileStatement\", \"ForStatement\", \"ForInStatement\", \"ForOfStatement\", \"DoWhileStatement\", \"ClassDeclaration\", \"TryStatement\"\n            ];\n\n            if (node.parent && statementsWithProperties.indexOf(node.parent.type) !== -1 && isNodeBodyBlock(node)) {\n                indent = getNodeIndent(node.parent).goodChar;\n            } else if (node.parent && node.parent.type === \"CatchClause\") {\n                indent = getNodeIndent(node.parent.parent).goodChar;\n            } else {\n                indent = getNodeIndent(node).goodChar;\n            }\n\n            if (node.type === \"IfStatement\" && node.consequent.type !== \"BlockStatement\") {\n                nodesToCheck = [node.consequent];\n            } else if (Array.isArray(node.body)) {\n                nodesToCheck = node.body;\n            } else {\n                nodesToCheck = [node.body];\n            }\n\n            if (nodesToCheck.length > 0) {\n                checkNodesIndent(nodesToCheck, indent + indentSize);\n            }\n\n            if (node.type === \"BlockStatement\") {\n                checkLastNodeLineIndent(node, indent);\n            }\n        }\n\n        /**\n         * Filter out the elements which are on the same line of each other or the node.\n         * basically have only 1 elements from each line except the variable declaration line.\n         * @param {ASTNode} node Variable declaration node\n         * @returns {ASTNode[]} Filtered elements\n         */\n        function filterOutSameLineVars(node) {\n            return node.declarations.reduce((finalCollection, elem) => {\n                const lastElem = finalCollection[finalCollection.length - 1];\n\n                if ((elem.loc.start.line !== node.loc.start.line && !lastElem) ||\n                    (lastElem && lastElem.loc.start.line !== elem.loc.start.line)) {\n                    finalCollection.push(elem);\n                }\n\n                return finalCollection;\n            }, []);\n        }\n\n        /**\n         * Check indentation for variable declarations\n         * @param {ASTNode} node node to examine\n         * @returns {void}\n         */\n        function checkIndentInVariableDeclarations(node) {\n            const elements = filterOutSameLineVars(node);\n            const nodeIndent = getNodeIndent(node).goodChar;\n            const lastElement = elements[elements.length - 1];\n\n            const elementsIndent = nodeIndent + indentSize * options.VariableDeclarator[node.kind];\n\n            checkNodesIndent(elements, elementsIndent);\n\n            // Only check the last line if there is any token after the last item\n            if (sourceCode.getLastToken(node).loc.end.line <= lastElement.loc.end.line) {\n                return;\n            }\n\n            const tokenBeforeLastElement = sourceCode.getTokenBefore(lastElement);\n\n            if (tokenBeforeLastElement.value === \",\") {\n\n                // Special case for comma-first syntax where the semicolon is indented\n                checkLastNodeLineIndent(node, getNodeIndent(tokenBeforeLastElement).goodChar);\n            } else {\n                checkLastNodeLineIndent(node, elementsIndent - indentSize);\n            }\n        }\n\n        /**\n         * Check and decide whether to check for indentation for blockless nodes\n         * Scenarios are for or while statements without braces around them\n         * @param {ASTNode} node node to examine\n         * @returns {void}\n         */\n        function blockLessNodes(node) {\n            if (node.body.type !== \"BlockStatement\") {\n                blockIndentationCheck(node);\n            }\n        }\n\n        /**\n         * Returns the expected indentation for the case statement\n         * @param {ASTNode} node node to examine\n         * @param {int} [providedSwitchIndent] indent for switch statement\n         * @returns {int} indent size\n         */\n        function expectedCaseIndent(node, providedSwitchIndent) {\n            const switchNode = (node.type === \"SwitchStatement\") ? node : node.parent;\n            const switchIndent = typeof providedSwitchIndent === \"undefined\"\n                ? getNodeIndent(switchNode).goodChar\n                : providedSwitchIndent;\n            let caseIndent;\n\n            if (caseIndentStore[switchNode.loc.start.line]) {\n                return caseIndentStore[switchNode.loc.start.line];\n            }\n\n            if (switchNode.cases.length > 0 && options.SwitchCase === 0) {\n                caseIndent = switchIndent;\n            } else {\n                caseIndent = switchIndent + (indentSize * options.SwitchCase);\n            }\n\n            caseIndentStore[switchNode.loc.start.line] = caseIndent;\n            return caseIndent;\n\n        }\n\n        /**\n         * Checks wether a return statement is wrapped in ()\n         * @param {ASTNode} node node to examine\n         * @returns {boolean} the result\n         */\n        function isWrappedInParenthesis(node) {\n            const regex = /^return\\s*?\\(\\s*?\\);*?/u;\n\n            const statementWithoutArgument = sourceCode.getText(node).replace(\n                sourceCode.getText(node.argument), \"\"\n            );\n\n            return regex.test(statementWithoutArgument);\n        }\n\n        return {\n            Program(node) {\n                if (node.body.length > 0) {\n\n                    // Root nodes should have no indent\n                    checkNodesIndent(node.body, getNodeIndent(node).goodChar);\n                }\n            },\n\n            ClassBody: blockIndentationCheck,\n\n            BlockStatement: blockIndentationCheck,\n\n            WhileStatement: blockLessNodes,\n\n            ForStatement: blockLessNodes,\n\n            ForInStatement: blockLessNodes,\n\n            ForOfStatement: blockLessNodes,\n\n            DoWhileStatement: blockLessNodes,\n\n            IfStatement(node) {\n                if (node.consequent.type !== \"BlockStatement\" && node.consequent.loc.start.line > node.loc.start.line) {\n                    blockIndentationCheck(node);\n                }\n            },\n\n            VariableDeclaration(node) {\n                if (node.declarations[node.declarations.length - 1].loc.start.line > node.declarations[0].loc.start.line) {\n                    checkIndentInVariableDeclarations(node);\n                }\n            },\n\n            ObjectExpression(node) {\n                checkIndentInArrayOrObjectBlock(node);\n            },\n\n            ArrayExpression(node) {\n                checkIndentInArrayOrObjectBlock(node);\n            },\n\n            MemberExpression(node) {\n\n                if (typeof options.MemberExpression === \"undefined\") {\n                    return;\n                }\n\n                if (isSingleLineNode(node)) {\n                    return;\n                }\n\n                /*\n                 * The typical layout of variable declarations and assignments\n                 * alter the expectation of correct indentation. Skip them.\n                 * TODO: Add appropriate configuration options for variable\n                 * declarations and assignments.\n                 */\n                if (getParentNodeByType(node, \"VariableDeclarator\", [\"FunctionExpression\", \"ArrowFunctionExpression\"])) {\n                    return;\n                }\n\n                if (getParentNodeByType(node, \"AssignmentExpression\", [\"FunctionExpression\"])) {\n                    return;\n                }\n\n                const propertyIndent = getNodeIndent(node).goodChar + indentSize * options.MemberExpression;\n\n                const checkNodes = [node.property];\n\n                const dot = sourceCode.getTokenBefore(node.property);\n\n                if (dot.type === \"Punctuator\" && dot.value === \".\") {\n                    checkNodes.push(dot);\n                }\n\n                checkNodesIndent(checkNodes, propertyIndent);\n            },\n\n            SwitchStatement(node) {\n\n                // Switch is not a 'BlockStatement'\n                const switchIndent = getNodeIndent(node).goodChar;\n                const caseIndent = expectedCaseIndent(node, switchIndent);\n\n                checkNodesIndent(node.cases, caseIndent);\n\n\n                checkLastNodeLineIndent(node, switchIndent);\n            },\n\n            SwitchCase(node) {\n\n                // Skip inline cases\n                if (isSingleLineNode(node)) {\n                    return;\n                }\n                const caseIndent = expectedCaseIndent(node);\n\n                checkNodesIndent(node.consequent, caseIndent + indentSize);\n            },\n\n            FunctionDeclaration(node) {\n                if (isSingleLineNode(node)) {\n                    return;\n                }\n                if (options.FunctionDeclaration.parameters === \"first\" && node.params.length) {\n                    checkNodesIndent(node.params.slice(1), node.params[0].loc.start.column);\n                } else if (options.FunctionDeclaration.parameters !== null) {\n                    checkNodesIndent(node.params, getNodeIndent(node).goodChar + indentSize * options.FunctionDeclaration.parameters);\n                }\n            },\n\n            FunctionExpression(node) {\n                if (isSingleLineNode(node)) {\n                    return;\n                }\n                if (options.FunctionExpression.parameters === \"first\" && node.params.length) {\n                    checkNodesIndent(node.params.slice(1), node.params[0].loc.start.column);\n                } else if (options.FunctionExpression.parameters !== null) {\n                    checkNodesIndent(node.params, getNodeIndent(node).goodChar + indentSize * options.FunctionExpression.parameters);\n                }\n            },\n\n            ReturnStatement(node) {\n                if (isSingleLineNode(node)) {\n                    return;\n                }\n\n                const firstLineIndent = getNodeIndent(node).goodChar;\n\n                // in case if return statement is wrapped in parenthesis\n                if (isWrappedInParenthesis(node)) {\n                    checkLastReturnStatementLineIndent(node, firstLineIndent);\n                } else {\n                    checkNodeIndent(node, firstLineIndent);\n                }\n            },\n\n            CallExpression(node) {\n                if (isSingleLineNode(node)) {\n                    return;\n                }\n                if (options.CallExpression.arguments === \"first\" && node.arguments.length) {\n                    checkNodesIndent(node.arguments.slice(1), node.arguments[0].loc.start.column);\n                } else if (options.CallExpression.arguments !== null) {\n                    checkNodesIndent(node.arguments, getNodeIndent(node).goodChar + indentSize * options.CallExpression.arguments);\n                }\n            }\n\n        };\n\n    }\n};\n\n/**\n * @fileoverview A rule to control the style of variable initializations.\n * @author Colin Ihrig\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not a given node is a for loop.\n * @param {ASTNode} block A node to check.\n * @returns {boolean} `true` when the node is a for loop.\n */\nfunction isForLoop(block) {\n    return block.type === \"ForInStatement\" ||\n    block.type === \"ForOfStatement\" ||\n    block.type === \"ForStatement\";\n}\n\n/**\n * Checks whether or not a given declarator node has its initializer.\n * @param {ASTNode} node A declarator node to check.\n * @returns {boolean} `true` when the node has its initializer.\n */\nfunction isInitialized(node) {\n    const declaration = node.parent;\n    const block = declaration.parent;\n\n    if (isForLoop(block)) {\n        if (block.type === \"ForStatement\") {\n            return block.init === declaration;\n        }\n        return block.left === declaration;\n    }\n    return Boolean(node.init);\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar initDeclarations = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require or disallow initialization in variable declarations\",\n            category: \"Variables\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/init-declarations\"\n        },\n\n        schema: {\n            anyOf: [\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"always\"]\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 1\n                },\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"never\"]\n                        },\n                        {\n                            type: \"object\",\n                            properties: {\n                                ignoreForLoopInit: {\n                                    type: \"boolean\"\n                                }\n                            },\n                            additionalProperties: false\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 2\n                }\n            ]\n        },\n        messages: {\n            initialized: \"Variable '{{idName}}' should be initialized on declaration.\",\n            notInitialized: \"Variable '{{idName}}' should not be initialized on declaration.\"\n        }\n    },\n\n    create(context) {\n\n        const MODE_ALWAYS = \"always\",\n            MODE_NEVER = \"never\";\n\n        const mode = context.options[0] || MODE_ALWAYS;\n        const params = context.options[1] || {};\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n            \"VariableDeclaration:exit\"(node) {\n\n                const kind = node.kind,\n                    declarations = node.declarations;\n\n                for (let i = 0; i < declarations.length; ++i) {\n                    const declaration = declarations[i],\n                        id = declaration.id,\n                        initialized = isInitialized(declaration),\n                        isIgnoredForLoop = params.ignoreForLoopInit && isForLoop(node.parent);\n                    let messageId = \"\";\n\n                    if (mode === MODE_ALWAYS && !initialized) {\n                        messageId = \"initialized\";\n                    } else if (mode === MODE_NEVER && kind !== \"const\" && initialized && !isIgnoredForLoop) {\n                        messageId = \"notInitialized\";\n                    }\n\n                    if (id.type === \"Identifier\" && messageId) {\n                        context.report({\n                            node: declaration,\n                            messageId,\n                            data: {\n                                idName: id.name\n                            }\n                        });\n                    }\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Constants\n//------------------------------------------------------------------------------\n\nconst QUOTE_SETTINGS = {\n    \"prefer-double\": {\n        quote: \"\\\"\",\n        description: \"singlequote\",\n        convert(str) {\n            return str.replace(/'/gu, \"\\\"\");\n        }\n    },\n    \"prefer-single\": {\n        quote: \"'\",\n        description: \"doublequote\",\n        convert(str) {\n            return str.replace(/\"/gu, \"'\");\n        }\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar jsxQuotes = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce the consistent use of either double or single quotes in JSX attributes\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/jsx-quotes\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                enum: [\"prefer-single\", \"prefer-double\"]\n            }\n        ],\n        messages: {\n            unexpected: \"Unexpected usage of {{description}}.\"\n        }\n    },\n\n    create(context) {\n        const quoteOption = context.options[0] || \"prefer-double\",\n            setting = QUOTE_SETTINGS[quoteOption];\n\n        /**\n         * Checks if the given string literal node uses the expected quotes\n         * @param {ASTNode} node A string literal node.\n         * @returns {boolean} Whether or not the string literal used the expected quotes.\n         * @public\n         */\n        function usesExpectedQuotes(node) {\n            return node.value.indexOf(setting.quote) !== -1 || astUtils$1.isSurroundedBy(node.raw, setting.quote);\n        }\n\n        return {\n            JSXAttribute(node) {\n                const attributeValue = node.value;\n\n                if (attributeValue && astUtils$1.isStringLiteral(attributeValue) && !usesExpectedQuotes(attributeValue)) {\n                    context.report({\n                        node: attributeValue,\n                        messageId: \"unexpected\",\n                        data: {\n                            description: setting.description\n                        },\n                        fix(fixer) {\n                            return fixer.replaceText(attributeValue, setting.convert(attributeValue.raw));\n                        }\n                    });\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether a string contains a line terminator as defined in\n * http://www.ecma-international.org/ecma-262/5.1/#sec-7.3\n * @param {string} str String to test.\n * @returns {boolean} True if str contains a line terminator.\n */\nfunction containsLineTerminator(str) {\n    return astUtils$1.LINEBREAK_MATCHER.test(str);\n}\n\n/**\n * Gets the last element of an array.\n * @param {Array} arr An array.\n * @returns {any} Last element of arr.\n */\nfunction last(arr) {\n    return arr[arr.length - 1];\n}\n\n/**\n * Checks whether a node is contained on a single line.\n * @param {ASTNode} node AST Node being evaluated.\n * @returns {boolean} True if the node is a single line.\n */\nfunction isSingleLine(node) {\n    return (node.loc.end.line === node.loc.start.line);\n}\n\n/**\n * Checks whether the properties on a single line.\n * @param {ASTNode[]} properties List of Property AST nodes.\n * @returns {boolean} True if all properies is on a single line.\n */\nfunction isSingleLineProperties(properties) {\n    const [firstProp] = properties,\n        lastProp = last(properties);\n\n    return firstProp.loc.start.line === lastProp.loc.end.line;\n}\n\n/**\n * Initializes a single option property from the configuration with defaults for undefined values\n * @param {Object} toOptions Object to be initialized\n * @param {Object} fromOptions Object to be initialized from\n * @returns {Object} The object with correctly initialized options and values\n */\nfunction initOptionProperty(toOptions, fromOptions) {\n    toOptions.mode = fromOptions.mode || \"strict\";\n\n    // Set value of beforeColon\n    if (typeof fromOptions.beforeColon !== \"undefined\") {\n        toOptions.beforeColon = +fromOptions.beforeColon;\n    } else {\n        toOptions.beforeColon = 0;\n    }\n\n    // Set value of afterColon\n    if (typeof fromOptions.afterColon !== \"undefined\") {\n        toOptions.afterColon = +fromOptions.afterColon;\n    } else {\n        toOptions.afterColon = 1;\n    }\n\n    // Set align if exists\n    if (typeof fromOptions.align !== \"undefined\") {\n        if (typeof fromOptions.align === \"object\") {\n            toOptions.align = fromOptions.align;\n        } else { // \"string\"\n            toOptions.align = {\n                on: fromOptions.align,\n                mode: toOptions.mode,\n                beforeColon: toOptions.beforeColon,\n                afterColon: toOptions.afterColon\n            };\n        }\n    }\n\n    return toOptions;\n}\n\n/**\n * Initializes all the option values (singleLine, multiLine and align) from the configuration with defaults for undefined values\n * @param {Object} toOptions Object to be initialized\n * @param {Object} fromOptions Object to be initialized from\n * @returns {Object} The object with correctly initialized options and values\n */\nfunction initOptions(toOptions, fromOptions) {\n    if (typeof fromOptions.align === \"object\") {\n\n        // Initialize the alignment configuration\n        toOptions.align = initOptionProperty({}, fromOptions.align);\n        toOptions.align.on = fromOptions.align.on || \"colon\";\n        toOptions.align.mode = fromOptions.align.mode || \"strict\";\n\n        toOptions.multiLine = initOptionProperty({}, (fromOptions.multiLine || fromOptions));\n        toOptions.singleLine = initOptionProperty({}, (fromOptions.singleLine || fromOptions));\n\n    } else { // string or undefined\n        toOptions.multiLine = initOptionProperty({}, (fromOptions.multiLine || fromOptions));\n        toOptions.singleLine = initOptionProperty({}, (fromOptions.singleLine || fromOptions));\n\n        // If alignment options are defined in multiLine, pull them out into the general align configuration\n        if (toOptions.multiLine.align) {\n            toOptions.align = {\n                on: toOptions.multiLine.align.on,\n                mode: toOptions.multiLine.align.mode || toOptions.multiLine.mode,\n                beforeColon: toOptions.multiLine.align.beforeColon,\n                afterColon: toOptions.multiLine.align.afterColon\n            };\n        }\n    }\n\n    return toOptions;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar keySpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent spacing between keys and values in object literal properties\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/key-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [{\n            anyOf: [\n                {\n                    type: \"object\",\n                    properties: {\n                        align: {\n                            anyOf: [\n                                {\n                                    enum: [\"colon\", \"value\"]\n                                },\n                                {\n                                    type: \"object\",\n                                    properties: {\n                                        mode: {\n                                            enum: [\"strict\", \"minimum\"]\n                                        },\n                                        on: {\n                                            enum: [\"colon\", \"value\"]\n                                        },\n                                        beforeColon: {\n                                            type: \"boolean\"\n                                        },\n                                        afterColon: {\n                                            type: \"boolean\"\n                                        }\n                                    },\n                                    additionalProperties: false\n                                }\n                            ]\n                        },\n                        mode: {\n                            enum: [\"strict\", \"minimum\"]\n                        },\n                        beforeColon: {\n                            type: \"boolean\"\n                        },\n                        afterColon: {\n                            type: \"boolean\"\n                        }\n                    },\n                    additionalProperties: false\n                },\n                {\n                    type: \"object\",\n                    properties: {\n                        singleLine: {\n                            type: \"object\",\n                            properties: {\n                                mode: {\n                                    enum: [\"strict\", \"minimum\"]\n                                },\n                                beforeColon: {\n                                    type: \"boolean\"\n                                },\n                                afterColon: {\n                                    type: \"boolean\"\n                                }\n                            },\n                            additionalProperties: false\n                        },\n                        multiLine: {\n                            type: \"object\",\n                            properties: {\n                                align: {\n                                    anyOf: [\n                                        {\n                                            enum: [\"colon\", \"value\"]\n                                        },\n                                        {\n                                            type: \"object\",\n                                            properties: {\n                                                mode: {\n                                                    enum: [\"strict\", \"minimum\"]\n                                                },\n                                                on: {\n                                                    enum: [\"colon\", \"value\"]\n                                                },\n                                                beforeColon: {\n                                                    type: \"boolean\"\n                                                },\n                                                afterColon: {\n                                                    type: \"boolean\"\n                                                }\n                                            },\n                                            additionalProperties: false\n                                        }\n                                    ]\n                                },\n                                mode: {\n                                    enum: [\"strict\", \"minimum\"]\n                                },\n                                beforeColon: {\n                                    type: \"boolean\"\n                                },\n                                afterColon: {\n                                    type: \"boolean\"\n                                }\n                            },\n                            additionalProperties: false\n                        }\n                    },\n                    additionalProperties: false\n                },\n                {\n                    type: \"object\",\n                    properties: {\n                        singleLine: {\n                            type: \"object\",\n                            properties: {\n                                mode: {\n                                    enum: [\"strict\", \"minimum\"]\n                                },\n                                beforeColon: {\n                                    type: \"boolean\"\n                                },\n                                afterColon: {\n                                    type: \"boolean\"\n                                }\n                            },\n                            additionalProperties: false\n                        },\n                        multiLine: {\n                            type: \"object\",\n                            properties: {\n                                mode: {\n                                    enum: [\"strict\", \"minimum\"]\n                                },\n                                beforeColon: {\n                                    type: \"boolean\"\n                                },\n                                afterColon: {\n                                    type: \"boolean\"\n                                }\n                            },\n                            additionalProperties: false\n                        },\n                        align: {\n                            type: \"object\",\n                            properties: {\n                                mode: {\n                                    enum: [\"strict\", \"minimum\"]\n                                },\n                                on: {\n                                    enum: [\"colon\", \"value\"]\n                                },\n                                beforeColon: {\n                                    type: \"boolean\"\n                                },\n                                afterColon: {\n                                    type: \"boolean\"\n                                }\n                            },\n                            additionalProperties: false\n                        }\n                    },\n                    additionalProperties: false\n                }\n            ]\n        }],\n        messages: {\n            extraKey: \"Extra space after {{computed}}key '{{key}}'.\",\n            extraValue: \"Extra space before value for {{computed}}key '{{key}}'.\",\n            missingKey: \"Missing space after {{computed}}key '{{key}}'.\",\n            missingValue: \"Missing space before value for {{computed}}key '{{key}}'.\"\n        }\n    },\n\n    create(context) {\n\n        /**\n         * OPTIONS\n         * \"key-spacing\": [2, {\n         *     beforeColon: false,\n         *     afterColon: true,\n         *     align: \"colon\" // Optional, or \"value\"\n         * }\n         */\n        const options = context.options[0] || {},\n            ruleOptions = initOptions({}, options),\n            multiLineOptions = ruleOptions.multiLine,\n            singleLineOptions = ruleOptions.singleLine,\n            alignmentOptions = ruleOptions.align || null;\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Checks whether a property is a member of the property group it follows.\n         * @param {ASTNode} lastMember The last Property known to be in the group.\n         * @param {ASTNode} candidate The next Property that might be in the group.\n         * @returns {boolean} True if the candidate property is part of the group.\n         */\n        function continuesPropertyGroup(lastMember, candidate) {\n            const groupEndLine = lastMember.loc.start.line,\n                candidateStartLine = candidate.loc.start.line;\n\n            if (candidateStartLine - groupEndLine <= 1) {\n                return true;\n            }\n\n            /*\n             * Check that the first comment is adjacent to the end of the group, the\n             * last comment is adjacent to the candidate property, and that successive\n             * comments are adjacent to each other.\n             */\n            const leadingComments = sourceCode.getCommentsBefore(candidate);\n\n            if (\n                leadingComments.length &&\n                leadingComments[0].loc.start.line - groupEndLine <= 1 &&\n                candidateStartLine - last(leadingComments).loc.end.line <= 1\n            ) {\n                for (let i = 1; i < leadingComments.length; i++) {\n                    if (leadingComments[i].loc.start.line - leadingComments[i - 1].loc.end.line > 1) {\n                        return false;\n                    }\n                }\n                return true;\n            }\n\n            return false;\n        }\n\n        /**\n         * Determines if the given property is key-value property.\n         * @param {ASTNode} property Property node to check.\n         * @returns {boolean} Whether the property is a key-value property.\n         */\n        function isKeyValueProperty(property) {\n            return !(\n                (property.method ||\n                property.shorthand ||\n                property.kind !== \"init\" || property.type !== \"Property\") // Could be \"ExperimentalSpreadProperty\" or \"SpreadElement\"\n            );\n        }\n\n        /**\n         * Starting from the given a node (a property.key node here) looks forward\n         * until it finds the last token before a colon punctuator and returns it.\n         * @param {ASTNode} node The node to start looking from.\n         * @returns {ASTNode} The last token before a colon punctuator.\n         */\n        function getLastTokenBeforeColon(node) {\n            const colonToken = sourceCode.getTokenAfter(node, astUtils$1.isColonToken);\n\n            return sourceCode.getTokenBefore(colonToken);\n        }\n\n        /**\n         * Starting from the given a node (a property.key node here) looks forward\n         * until it finds the colon punctuator and returns it.\n         * @param {ASTNode} node The node to start looking from.\n         * @returns {ASTNode} The colon punctuator.\n         */\n        function getNextColon(node) {\n            return sourceCode.getTokenAfter(node, astUtils$1.isColonToken);\n        }\n\n        /**\n         * Gets an object literal property's key as the identifier name or string value.\n         * @param {ASTNode} property Property node whose key to retrieve.\n         * @returns {string} The property's key.\n         */\n        function getKey(property) {\n            const key = property.key;\n\n            if (property.computed) {\n                return sourceCode.getText().slice(key.range[0], key.range[1]);\n            }\n\n            return property.key.name || property.key.value;\n        }\n\n        /**\n         * Reports an appropriately-formatted error if spacing is incorrect on one\n         * side of the colon.\n         * @param {ASTNode} property Key-value pair in an object literal.\n         * @param {string} side Side being verified - either \"key\" or \"value\".\n         * @param {string} whitespace Actual whitespace string.\n         * @param {int} expected Expected whitespace length.\n         * @param {string} mode Value of the mode as \"strict\" or \"minimum\"\n         * @returns {void}\n         */\n        function report(property, side, whitespace, expected, mode) {\n            const diff = whitespace.length - expected,\n                nextColon = getNextColon(property.key),\n                tokenBeforeColon = sourceCode.getTokenBefore(nextColon, { includeComments: true }),\n                tokenAfterColon = sourceCode.getTokenAfter(nextColon, { includeComments: true }),\n                isKeySide = side === \"key\",\n                locStart = isKeySide ? tokenBeforeColon.loc.start : tokenAfterColon.loc.start,\n                isExtra = diff > 0,\n                diffAbs = Math.abs(diff),\n                spaces = Array(diffAbs + 1).join(\" \");\n\n            if ((\n                diff && mode === \"strict\" ||\n                diff < 0 && mode === \"minimum\" ||\n                diff > 0 && !expected && mode === \"minimum\") &&\n                !(expected && containsLineTerminator(whitespace))\n            ) {\n                let fix;\n\n                if (isExtra) {\n                    let range;\n\n                    // Remove whitespace\n                    if (isKeySide) {\n                        range = [tokenBeforeColon.range[1], tokenBeforeColon.range[1] + diffAbs];\n                    } else {\n                        range = [tokenAfterColon.range[0] - diffAbs, tokenAfterColon.range[0]];\n                    }\n                    fix = function(fixer) {\n                        return fixer.removeRange(range);\n                    };\n                } else {\n\n                    // Add whitespace\n                    if (isKeySide) {\n                        fix = function(fixer) {\n                            return fixer.insertTextAfter(tokenBeforeColon, spaces);\n                        };\n                    } else {\n                        fix = function(fixer) {\n                            return fixer.insertTextBefore(tokenAfterColon, spaces);\n                        };\n                    }\n                }\n\n                let messageId = \"\";\n\n                if (isExtra) {\n                    messageId = side === \"key\" ? \"extraKey\" : \"extraValue\";\n                } else {\n                    messageId = side === \"key\" ? \"missingKey\" : \"missingValue\";\n                }\n\n                context.report({\n                    node: property[side],\n                    loc: locStart,\n                    messageId,\n                    data: {\n                        computed: property.computed ? \"computed \" : \"\",\n                        key: getKey(property)\n                    },\n                    fix\n                });\n            }\n        }\n\n        /**\n         * Gets the number of characters in a key, including quotes around string\n         * keys and braces around computed property keys.\n         * @param {ASTNode} property Property of on object literal.\n         * @returns {int} Width of the key.\n         */\n        function getKeyWidth(property) {\n            const startToken = sourceCode.getFirstToken(property);\n            const endToken = getLastTokenBeforeColon(property.key);\n\n            return endToken.range[1] - startToken.range[0];\n        }\n\n        /**\n         * Gets the whitespace around the colon in an object literal property.\n         * @param {ASTNode} property Property node from an object literal.\n         * @returns {Object} Whitespace before and after the property's colon.\n         */\n        function getPropertyWhitespace(property) {\n            const whitespace = /(\\s*):(\\s*)/u.exec(sourceCode.getText().slice(\n                property.key.range[1], property.value.range[0]\n            ));\n\n            if (whitespace) {\n                return {\n                    beforeColon: whitespace[1],\n                    afterColon: whitespace[2]\n                };\n            }\n            return null;\n        }\n\n        /**\n         * Creates groups of properties.\n         * @param  {ASTNode} node ObjectExpression node being evaluated.\n         * @returns {Array.<ASTNode[]>} Groups of property AST node lists.\n         */\n        function createGroups(node) {\n            if (node.properties.length === 1) {\n                return [node.properties];\n            }\n\n            return node.properties.reduce((groups, property) => {\n                const currentGroup = last(groups),\n                    prev = last(currentGroup);\n\n                if (!prev || continuesPropertyGroup(prev, property)) {\n                    currentGroup.push(property);\n                } else {\n                    groups.push([property]);\n                }\n\n                return groups;\n            }, [\n                []\n            ]);\n        }\n\n        /**\n         * Verifies correct vertical alignment of a group of properties.\n         * @param {ASTNode[]} properties List of Property AST nodes.\n         * @returns {void}\n         */\n        function verifyGroupAlignment(properties) {\n            const length = properties.length,\n                widths = properties.map(getKeyWidth), // Width of keys, including quotes\n                align = alignmentOptions.on; // \"value\" or \"colon\"\n            let targetWidth = Math.max(...widths),\n                beforeColon, afterColon, mode;\n\n            if (alignmentOptions && length > 1) { // When aligning values within a group, use the alignment configuration.\n                beforeColon = alignmentOptions.beforeColon;\n                afterColon = alignmentOptions.afterColon;\n                mode = alignmentOptions.mode;\n            } else {\n                beforeColon = multiLineOptions.beforeColon;\n                afterColon = multiLineOptions.afterColon;\n                mode = alignmentOptions.mode;\n            }\n\n            // Conditionally include one space before or after colon\n            targetWidth += (align === \"colon\" ? beforeColon : afterColon);\n\n            for (let i = 0; i < length; i++) {\n                const property = properties[i];\n                const whitespace = getPropertyWhitespace(property);\n\n                if (whitespace) { // Object literal getters/setters lack a colon\n                    const width = widths[i];\n\n                    if (align === \"value\") {\n                        report(property, \"key\", whitespace.beforeColon, beforeColon, mode);\n                        report(property, \"value\", whitespace.afterColon, targetWidth - width, mode);\n                    } else { // align = \"colon\"\n                        report(property, \"key\", whitespace.beforeColon, targetWidth - width, mode);\n                        report(property, \"value\", whitespace.afterColon, afterColon, mode);\n                    }\n                }\n            }\n        }\n\n        /**\n         * Verifies spacing of property conforms to specified options.\n         * @param  {ASTNode} node Property node being evaluated.\n         * @param {Object} lineOptions Configured singleLine or multiLine options\n         * @returns {void}\n         */\n        function verifySpacing(node, lineOptions) {\n            const actual = getPropertyWhitespace(node);\n\n            if (actual) { // Object literal getters/setters lack colons\n                report(node, \"key\", actual.beforeColon, lineOptions.beforeColon, lineOptions.mode);\n                report(node, \"value\", actual.afterColon, lineOptions.afterColon, lineOptions.mode);\n            }\n        }\n\n        /**\n         * Verifies spacing of each property in a list.\n         * @param {ASTNode[]} properties List of Property AST nodes.\n         * @param {Object} lineOptions Configured singleLine or multiLine options\n         * @returns {void}\n         */\n        function verifyListSpacing(properties, lineOptions) {\n            const length = properties.length;\n\n            for (let i = 0; i < length; i++) {\n                verifySpacing(properties[i], lineOptions);\n            }\n        }\n\n        /**\n         * Verifies vertical alignment, taking into account groups of properties.\n         * @param  {ASTNode} node ObjectExpression node being evaluated.\n         * @returns {void}\n         */\n        function verifyAlignment(node) {\n            createGroups(node).forEach(group => {\n                const properties = group.filter(isKeyValueProperty);\n\n                if (properties.length > 0 && isSingleLineProperties(properties)) {\n                    verifyListSpacing(properties, multiLineOptions);\n                } else {\n                    verifyGroupAlignment(properties);\n                }\n            });\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        if (alignmentOptions) { // Verify vertical alignment\n\n            return {\n                ObjectExpression(node) {\n                    if (isSingleLine(node)) {\n                        verifyListSpacing(node.properties.filter(isKeyValueProperty), singleLineOptions);\n                    } else {\n                        verifyAlignment(node);\n                    }\n                }\n            };\n\n        }\n\n        // Obey beforeColon and afterColon in each property as configured\n        return {\n            Property(node) {\n                verifySpacing(node, isSingleLine(node.parent) ? singleLineOptions : multiLineOptions);\n            }\n        };\n\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Constants\n//------------------------------------------------------------------------------\n\nconst PREV_TOKEN = /^[)\\]}>]$/u;\nconst NEXT_TOKEN = /^(?:[([{<~!]|\\+\\+?|--?)$/u;\nconst PREV_TOKEN_M = /^[)\\]}>*]$/u;\nconst NEXT_TOKEN_M = /^[{*]$/u;\nconst TEMPLATE_OPEN_PAREN = /\\$\\{$/u;\nconst TEMPLATE_CLOSE_PAREN = /^\\}/u;\nconst CHECK_TYPE = /^(?:JSXElement|RegularExpression|String|Template)$/u;\nconst KEYS$1 = keywords$3.concat([\"as\", \"async\", \"await\", \"from\", \"get\", \"let\", \"of\", \"set\", \"yield\"]);\n\n// check duplications.\n(function() {\n    KEYS$1.sort();\n    for (let i = 1; i < KEYS$1.length; ++i) {\n        if (KEYS$1[i] === KEYS$1[i - 1]) {\n            throw new Error(`Duplication was found in the keyword list: ${KEYS$1[i]}`);\n        }\n    }\n}());\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not a given token is a \"Template\" token ends with \"${\".\n * @param {Token} token A token to check.\n * @returns {boolean} `true` if the token is a \"Template\" token ends with \"${\".\n */\nfunction isOpenParenOfTemplate(token) {\n    return token.type === \"Template\" && TEMPLATE_OPEN_PAREN.test(token.value);\n}\n\n/**\n * Checks whether or not a given token is a \"Template\" token starts with \"}\".\n * @param {Token} token A token to check.\n * @returns {boolean} `true` if the token is a \"Template\" token starts with \"}\".\n */\nfunction isCloseParenOfTemplate(token) {\n    return token.type === \"Template\" && TEMPLATE_CLOSE_PAREN.test(token.value);\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar keywordSpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent spacing before and after keywords\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/keyword-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    before: { type: \"boolean\", default: true },\n                    after: { type: \"boolean\", default: true },\n                    overrides: {\n                        type: \"object\",\n                        properties: KEYS$1.reduce((retv, key) => {\n                            retv[key] = {\n                                type: \"object\",\n                                properties: {\n                                    before: { type: \"boolean\" },\n                                    after: { type: \"boolean\" }\n                                },\n                                additionalProperties: false\n                            };\n                            return retv;\n                        }, {}),\n                        additionalProperties: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n        messages: {\n            expectedBefore: \"Expected space(s) before \\\"{{value}}\\\".\",\n            expectedAfter: \"Expected space(s) after \\\"{{value}}\\\".\",\n            unexpectedBefore: \"Unexpected space(s) before \\\"{{value}}\\\".\",\n            unexpectedAfter: \"Unexpected space(s) after \\\"{{value}}\\\".\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Reports a given token if there are not space(s) before the token.\n         * @param {Token} token A token to report.\n         * @param {RegExp} pattern A pattern of the previous token to check.\n         * @returns {void}\n         */\n        function expectSpaceBefore(token, pattern) {\n            const prevToken = sourceCode.getTokenBefore(token);\n\n            if (prevToken &&\n                (CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) &&\n                !isOpenParenOfTemplate(prevToken) &&\n                astUtils$1.isTokenOnSameLine(prevToken, token) &&\n                !sourceCode.isSpaceBetweenTokens(prevToken, token)\n            ) {\n                context.report({\n                    loc: token.loc.start,\n                    messageId: \"expectedBefore\",\n                    data: token,\n                    fix(fixer) {\n                        return fixer.insertTextBefore(token, \" \");\n                    }\n                });\n            }\n        }\n\n        /**\n         * Reports a given token if there are space(s) before the token.\n         * @param {Token} token A token to report.\n         * @param {RegExp} pattern A pattern of the previous token to check.\n         * @returns {void}\n         */\n        function unexpectSpaceBefore(token, pattern) {\n            const prevToken = sourceCode.getTokenBefore(token);\n\n            if (prevToken &&\n                (CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) &&\n                !isOpenParenOfTemplate(prevToken) &&\n                astUtils$1.isTokenOnSameLine(prevToken, token) &&\n                sourceCode.isSpaceBetweenTokens(prevToken, token)\n            ) {\n                context.report({\n                    loc: token.loc.start,\n                    messageId: \"unexpectedBefore\",\n                    data: token,\n                    fix(fixer) {\n                        return fixer.removeRange([prevToken.range[1], token.range[0]]);\n                    }\n                });\n            }\n        }\n\n        /**\n         * Reports a given token if there are not space(s) after the token.\n         * @param {Token} token A token to report.\n         * @param {RegExp} pattern A pattern of the next token to check.\n         * @returns {void}\n         */\n        function expectSpaceAfter(token, pattern) {\n            const nextToken = sourceCode.getTokenAfter(token);\n\n            if (nextToken &&\n                (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) &&\n                !isCloseParenOfTemplate(nextToken) &&\n                astUtils$1.isTokenOnSameLine(token, nextToken) &&\n                !sourceCode.isSpaceBetweenTokens(token, nextToken)\n            ) {\n                context.report({\n                    loc: token.loc.start,\n                    messageId: \"expectedAfter\",\n                    data: token,\n                    fix(fixer) {\n                        return fixer.insertTextAfter(token, \" \");\n                    }\n                });\n            }\n        }\n\n        /**\n         * Reports a given token if there are space(s) after the token.\n         * @param {Token} token A token to report.\n         * @param {RegExp} pattern A pattern of the next token to check.\n         * @returns {void}\n         */\n        function unexpectSpaceAfter(token, pattern) {\n            const nextToken = sourceCode.getTokenAfter(token);\n\n            if (nextToken &&\n                (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) &&\n                !isCloseParenOfTemplate(nextToken) &&\n                astUtils$1.isTokenOnSameLine(token, nextToken) &&\n                sourceCode.isSpaceBetweenTokens(token, nextToken)\n            ) {\n                context.report({\n                    loc: token.loc.start,\n                    messageId: \"unexpectedAfter\",\n                    data: token,\n                    fix(fixer) {\n                        return fixer.removeRange([token.range[1], nextToken.range[0]]);\n                    }\n                });\n            }\n        }\n\n        /**\n         * Parses the option object and determines check methods for each keyword.\n         * @param {Object|undefined} options The option object to parse.\n         * @returns {Object} - Normalized option object.\n         *      Keys are keywords (there are for every keyword).\n         *      Values are instances of `{\"before\": function, \"after\": function}`.\n         */\n        function parseOptions(options = {}) {\n            const before = options.before !== false;\n            const after = options.after !== false;\n            const defaultValue = {\n                before: before ? expectSpaceBefore : unexpectSpaceBefore,\n                after: after ? expectSpaceAfter : unexpectSpaceAfter\n            };\n            const overrides = (options && options.overrides) || {};\n            const retv = Object.create(null);\n\n            for (let i = 0; i < KEYS$1.length; ++i) {\n                const key = KEYS$1[i];\n                const override = overrides[key];\n\n                if (override) {\n                    const thisBefore = (\"before\" in override) ? override.before : before;\n                    const thisAfter = (\"after\" in override) ? override.after : after;\n\n                    retv[key] = {\n                        before: thisBefore ? expectSpaceBefore : unexpectSpaceBefore,\n                        after: thisAfter ? expectSpaceAfter : unexpectSpaceAfter\n                    };\n                } else {\n                    retv[key] = defaultValue;\n                }\n            }\n\n            return retv;\n        }\n\n        const checkMethodMap = parseOptions(context.options[0]);\n\n        /**\n         * Reports a given token if usage of spacing followed by the token is\n         * invalid.\n         * @param {Token} token A token to report.\n         * @param {RegExp} [pattern] Optional. A pattern of the previous\n         *      token to check.\n         * @returns {void}\n         */\n        function checkSpacingBefore(token, pattern) {\n            checkMethodMap[token.value].before(token, pattern || PREV_TOKEN);\n        }\n\n        /**\n         * Reports a given token if usage of spacing preceded by the token is\n         * invalid.\n         * @param {Token} token A token to report.\n         * @param {RegExp} [pattern] Optional. A pattern of the next\n         *      token to check.\n         * @returns {void}\n         */\n        function checkSpacingAfter(token, pattern) {\n            checkMethodMap[token.value].after(token, pattern || NEXT_TOKEN);\n        }\n\n        /**\n         * Reports a given token if usage of spacing around the token is invalid.\n         * @param {Token} token A token to report.\n         * @returns {void}\n         */\n        function checkSpacingAround(token) {\n            checkSpacingBefore(token);\n            checkSpacingAfter(token);\n        }\n\n        /**\n         * Reports the first token of a given node if the first token is a keyword\n         * and usage of spacing around the token is invalid.\n         * @param {ASTNode|null} node A node to report.\n         * @returns {void}\n         */\n        function checkSpacingAroundFirstToken(node) {\n            const firstToken = node && sourceCode.getFirstToken(node);\n\n            if (firstToken && firstToken.type === \"Keyword\") {\n                checkSpacingAround(firstToken);\n            }\n        }\n\n        /**\n         * Reports the first token of a given node if the first token is a keyword\n         * and usage of spacing followed by the token is invalid.\n         *\n         * This is used for unary operators (e.g. `typeof`), `function`, and `super`.\n         * Other rules are handling usage of spacing preceded by those keywords.\n         * @param {ASTNode|null} node A node to report.\n         * @returns {void}\n         */\n        function checkSpacingBeforeFirstToken(node) {\n            const firstToken = node && sourceCode.getFirstToken(node);\n\n            if (firstToken && firstToken.type === \"Keyword\") {\n                checkSpacingBefore(firstToken);\n            }\n        }\n\n        /**\n         * Reports the previous token of a given node if the token is a keyword and\n         * usage of spacing around the token is invalid.\n         * @param {ASTNode|null} node A node to report.\n         * @returns {void}\n         */\n        function checkSpacingAroundTokenBefore(node) {\n            if (node) {\n                const token = sourceCode.getTokenBefore(node, astUtils$1.isKeywordToken);\n\n                checkSpacingAround(token);\n            }\n        }\n\n        /**\n         * Reports `async` or `function` keywords of a given node if usage of\n         * spacing around those keywords is invalid.\n         * @param {ASTNode} node A node to report.\n         * @returns {void}\n         */\n        function checkSpacingForFunction(node) {\n            const firstToken = node && sourceCode.getFirstToken(node);\n\n            if (firstToken &&\n                ((firstToken.type === \"Keyword\" && firstToken.value === \"function\") ||\n                firstToken.value === \"async\")\n            ) {\n                checkSpacingBefore(firstToken);\n            }\n        }\n\n        /**\n         * Reports `class` and `extends` keywords of a given node if usage of\n         * spacing around those keywords is invalid.\n         * @param {ASTNode} node A node to report.\n         * @returns {void}\n         */\n        function checkSpacingForClass(node) {\n            checkSpacingAroundFirstToken(node);\n            checkSpacingAroundTokenBefore(node.superClass);\n        }\n\n        /**\n         * Reports `if` and `else` keywords of a given node if usage of spacing\n         * around those keywords is invalid.\n         * @param {ASTNode} node A node to report.\n         * @returns {void}\n         */\n        function checkSpacingForIfStatement(node) {\n            checkSpacingAroundFirstToken(node);\n            checkSpacingAroundTokenBefore(node.alternate);\n        }\n\n        /**\n         * Reports `try`, `catch`, and `finally` keywords of a given node if usage\n         * of spacing around those keywords is invalid.\n         * @param {ASTNode} node A node to report.\n         * @returns {void}\n         */\n        function checkSpacingForTryStatement(node) {\n            checkSpacingAroundFirstToken(node);\n            checkSpacingAroundFirstToken(node.handler);\n            checkSpacingAroundTokenBefore(node.finalizer);\n        }\n\n        /**\n         * Reports `do` and `while` keywords of a given node if usage of spacing\n         * around those keywords is invalid.\n         * @param {ASTNode} node A node to report.\n         * @returns {void}\n         */\n        function checkSpacingForDoWhileStatement(node) {\n            checkSpacingAroundFirstToken(node);\n            checkSpacingAroundTokenBefore(node.test);\n        }\n\n        /**\n         * Reports `for` and `in` keywords of a given node if usage of spacing\n         * around those keywords is invalid.\n         * @param {ASTNode} node A node to report.\n         * @returns {void}\n         */\n        function checkSpacingForForInStatement(node) {\n            checkSpacingAroundFirstToken(node);\n            checkSpacingAroundTokenBefore(node.right);\n        }\n\n        /**\n         * Reports `for` and `of` keywords of a given node if usage of spacing\n         * around those keywords is invalid.\n         * @param {ASTNode} node A node to report.\n         * @returns {void}\n         */\n        function checkSpacingForForOfStatement(node) {\n            if (node.await) {\n                checkSpacingBefore(sourceCode.getFirstToken(node, 0));\n                checkSpacingAfter(sourceCode.getFirstToken(node, 1));\n            } else {\n                checkSpacingAroundFirstToken(node);\n            }\n            checkSpacingAround(sourceCode.getTokenBefore(node.right, astUtils$1.isNotOpeningParenToken));\n        }\n\n        /**\n         * Reports `import`, `export`, `as`, and `from` keywords of a given node if\n         * usage of spacing around those keywords is invalid.\n         *\n         * This rule handles the `*` token in module declarations.\n         *\n         *     import*as A from \"./a\"; /*error Expected space(s) after \"import\".\n         *                               error Expected space(s) before \"as\".\n         * @param {ASTNode} node A node to report.\n         * @returns {void}\n         */\n        function checkSpacingForModuleDeclaration(node) {\n            const firstToken = sourceCode.getFirstToken(node);\n\n            checkSpacingBefore(firstToken, PREV_TOKEN_M);\n            checkSpacingAfter(firstToken, NEXT_TOKEN_M);\n\n            if (node.type === \"ExportDefaultDeclaration\") {\n                checkSpacingAround(sourceCode.getTokenAfter(firstToken));\n            }\n\n            if (node.source) {\n                const fromToken = sourceCode.getTokenBefore(node.source);\n\n                checkSpacingBefore(fromToken, PREV_TOKEN_M);\n                checkSpacingAfter(fromToken, NEXT_TOKEN_M);\n            }\n        }\n\n        /**\n         * Reports `as` keyword of a given node if usage of spacing around this\n         * keyword is invalid.\n         * @param {ASTNode} node A node to report.\n         * @returns {void}\n         */\n        function checkSpacingForImportNamespaceSpecifier(node) {\n            const asToken = sourceCode.getFirstToken(node, 1);\n\n            checkSpacingBefore(asToken, PREV_TOKEN_M);\n        }\n\n        /**\n         * Reports `static`, `get`, and `set` keywords of a given node if usage of\n         * spacing around those keywords is invalid.\n         * @param {ASTNode} node A node to report.\n         * @returns {void}\n         */\n        function checkSpacingForProperty(node) {\n            if (node.static) {\n                checkSpacingAroundFirstToken(node);\n            }\n            if (node.kind === \"get\" ||\n                node.kind === \"set\" ||\n                (\n                    (node.method || node.type === \"MethodDefinition\") &&\n                    node.value.async\n                )\n            ) {\n                const token = sourceCode.getTokenBefore(\n                    node.key,\n                    tok => {\n                        switch (tok.value) {\n                            case \"get\":\n                            case \"set\":\n                            case \"async\":\n                                return true;\n                            default:\n                                return false;\n                        }\n                    }\n                );\n\n                if (!token) {\n                    throw new Error(\"Failed to find token get, set, or async beside method name\");\n                }\n\n\n                checkSpacingAround(token);\n            }\n        }\n\n        /**\n         * Reports `await` keyword of a given node if usage of spacing before\n         * this keyword is invalid.\n         * @param {ASTNode} node A node to report.\n         * @returns {void}\n         */\n        function checkSpacingForAwaitExpression(node) {\n            checkSpacingBefore(sourceCode.getFirstToken(node));\n        }\n\n        return {\n\n            // Statements\n            DebuggerStatement: checkSpacingAroundFirstToken,\n            WithStatement: checkSpacingAroundFirstToken,\n\n            // Statements - Control flow\n            BreakStatement: checkSpacingAroundFirstToken,\n            ContinueStatement: checkSpacingAroundFirstToken,\n            ReturnStatement: checkSpacingAroundFirstToken,\n            ThrowStatement: checkSpacingAroundFirstToken,\n            TryStatement: checkSpacingForTryStatement,\n\n            // Statements - Choice\n            IfStatement: checkSpacingForIfStatement,\n            SwitchStatement: checkSpacingAroundFirstToken,\n            SwitchCase: checkSpacingAroundFirstToken,\n\n            // Statements - Loops\n            DoWhileStatement: checkSpacingForDoWhileStatement,\n            ForInStatement: checkSpacingForForInStatement,\n            ForOfStatement: checkSpacingForForOfStatement,\n            ForStatement: checkSpacingAroundFirstToken,\n            WhileStatement: checkSpacingAroundFirstToken,\n\n            // Statements - Declarations\n            ClassDeclaration: checkSpacingForClass,\n            ExportNamedDeclaration: checkSpacingForModuleDeclaration,\n            ExportDefaultDeclaration: checkSpacingForModuleDeclaration,\n            ExportAllDeclaration: checkSpacingForModuleDeclaration,\n            FunctionDeclaration: checkSpacingForFunction,\n            ImportDeclaration: checkSpacingForModuleDeclaration,\n            VariableDeclaration: checkSpacingAroundFirstToken,\n\n            // Expressions\n            ArrowFunctionExpression: checkSpacingForFunction,\n            AwaitExpression: checkSpacingForAwaitExpression,\n            ClassExpression: checkSpacingForClass,\n            FunctionExpression: checkSpacingForFunction,\n            NewExpression: checkSpacingBeforeFirstToken,\n            Super: checkSpacingBeforeFirstToken,\n            ThisExpression: checkSpacingBeforeFirstToken,\n            UnaryExpression: checkSpacingBeforeFirstToken,\n            YieldExpression: checkSpacingBeforeFirstToken,\n\n            // Others\n            ImportNamespaceSpecifier: checkSpacingForImportNamespaceSpecifier,\n            MethodDefinition: checkSpacingForProperty,\n            Property: checkSpacingForProperty\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar lineCommentPosition = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce position of line comments\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/line-comment-position\"\n        },\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        enum: [\"above\", \"beside\"]\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            position: {\n                                enum: [\"above\", \"beside\"]\n                            },\n                            ignorePattern: {\n                                type: \"string\"\n                            },\n                            applyDefaultPatterns: {\n                                type: \"boolean\"\n                            },\n                            applyDefaultIgnorePatterns: {\n                                type: \"boolean\"\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ],\n        messages: {\n            above: \"Expected comment to be above code.\",\n            beside: \"Expected comment to be beside code.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options[0];\n\n        let above,\n            ignorePattern,\n            applyDefaultIgnorePatterns = true;\n\n        if (!options || typeof options === \"string\") {\n            above = !options || options === \"above\";\n\n        } else {\n            above = !options.position || options.position === \"above\";\n            ignorePattern = options.ignorePattern;\n\n            if (Object.prototype.hasOwnProperty.call(options, \"applyDefaultIgnorePatterns\")) {\n                applyDefaultIgnorePatterns = options.applyDefaultIgnorePatterns;\n            } else {\n                applyDefaultIgnorePatterns = options.applyDefaultPatterns !== false;\n            }\n        }\n\n        const defaultIgnoreRegExp = astUtils$1.COMMENTS_IGNORE_PATTERN;\n        const fallThroughRegExp = /^\\s*falls?\\s?through/u;\n        const customIgnoreRegExp = new RegExp(ignorePattern, \"u\");\n        const sourceCode = context.getSourceCode();\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            Program() {\n                const comments = sourceCode.getAllComments();\n\n                comments.filter(token => token.type === \"Line\").forEach(node => {\n                    if (applyDefaultIgnorePatterns && (defaultIgnoreRegExp.test(node.value) || fallThroughRegExp.test(node.value))) {\n                        return;\n                    }\n\n                    if (ignorePattern && customIgnoreRegExp.test(node.value)) {\n                        return;\n                    }\n\n                    const previous = sourceCode.getTokenBefore(node, { includeComments: true });\n                    const isOnSameLine = previous && previous.loc.end.line === node.loc.start.line;\n\n                    if (above) {\n                        if (isOnSameLine) {\n                            context.report({\n                                node,\n                                messageId: \"above\"\n                            });\n                        }\n                    } else {\n                        if (!isOnSameLine) {\n                            context.report({\n                                node,\n                                messageId: \"beside\"\n                            });\n                        }\n                    }\n                });\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar linebreakStyle = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent linebreak style\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/linebreak-style\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                enum: [\"unix\", \"windows\"]\n            }\n        ],\n        messages: {\n            expectedLF: \"Expected linebreaks to be 'LF' but found 'CRLF'.\",\n            expectedCRLF: \"Expected linebreaks to be 'CRLF' but found 'LF'.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Builds a fix function that replaces text at the specified range in the source text.\n         * @param {int[]} range The range to replace\n         * @param {string} text The text to insert.\n         * @returns {Function} Fixer function\n         * @private\n         */\n        function createFix(range, text) {\n            return function(fixer) {\n                return fixer.replaceTextRange(range, text);\n            };\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            Program: function checkForlinebreakStyle(node) {\n                const linebreakStyle = context.options[0] || \"unix\",\n                    expectedLF = linebreakStyle === \"unix\",\n                    expectedLFChars = expectedLF ? \"\\n\" : \"\\r\\n\",\n                    source = sourceCode.getText(),\n                    pattern = astUtils$1.createGlobalLinebreakMatcher();\n                let match;\n\n                let i = 0;\n\n                while ((match = pattern.exec(source)) !== null) {\n                    i++;\n                    if (match[0] === expectedLFChars) {\n                        continue;\n                    }\n\n                    const index = match.index;\n                    const range = [index, index + match[0].length];\n\n                    context.report({\n                        node,\n                        loc: {\n                            line: i,\n                            column: sourceCode.lines[i - 1].length\n                        },\n                        messageId: expectedLF ? \"expectedLF\" : \"expectedCRLF\",\n                        fix: createFix(range, expectedLFChars)\n                    });\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Return an array with with any line numbers that are empty.\n * @param {Array} lines An array of each line of the file.\n * @returns {Array} An array of line numbers.\n */\nfunction getEmptyLineNums(lines) {\n    const emptyLines = lines.map((line, i) => ({\n        code: line.trim(),\n        num: i + 1\n    })).filter(line => !line.code).map(line => line.num);\n\n    return emptyLines;\n}\n\n/**\n * Return an array with with any line numbers that contain comments.\n * @param {Array} comments An array of comment tokens.\n * @returns {Array} An array of line numbers.\n */\nfunction getCommentLineNums(comments) {\n    const lines = [];\n\n    comments.forEach(token => {\n        const start = token.loc.start.line;\n        const end = token.loc.end.line;\n\n        lines.push(start, end);\n    });\n    return lines;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar linesAroundComment = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require empty lines around comments\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/lines-around-comment\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    beforeBlockComment: {\n                        type: \"boolean\",\n                        default: true\n                    },\n                    afterBlockComment: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    beforeLineComment: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    afterLineComment: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    allowBlockStart: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    allowBlockEnd: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    allowClassStart: {\n                        type: \"boolean\"\n                    },\n                    allowClassEnd: {\n                        type: \"boolean\"\n                    },\n                    allowObjectStart: {\n                        type: \"boolean\"\n                    },\n                    allowObjectEnd: {\n                        type: \"boolean\"\n                    },\n                    allowArrayStart: {\n                        type: \"boolean\"\n                    },\n                    allowArrayEnd: {\n                        type: \"boolean\"\n                    },\n                    ignorePattern: {\n                        type: \"string\"\n                    },\n                    applyDefaultIgnorePatterns: {\n                        type: \"boolean\"\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n        messages: {\n            after: \"Expected line after comment.\",\n            before: \"Expected line before comment.\"\n        }\n    },\n\n    create(context) {\n\n        const options = Object.assign({}, context.options[0]);\n        const ignorePattern = options.ignorePattern;\n        const defaultIgnoreRegExp = astUtils$1.COMMENTS_IGNORE_PATTERN;\n        const customIgnoreRegExp = new RegExp(ignorePattern, \"u\");\n        const applyDefaultIgnorePatterns = options.applyDefaultIgnorePatterns !== false;\n\n        options.beforeBlockComment = typeof options.beforeBlockComment !== \"undefined\" ? options.beforeBlockComment : true;\n\n        const sourceCode = context.getSourceCode();\n\n        const lines = sourceCode.lines,\n            numLines = lines.length + 1,\n            comments = sourceCode.getAllComments(),\n            commentLines = getCommentLineNums(comments),\n            emptyLines = getEmptyLineNums(lines),\n            commentAndEmptyLines = commentLines.concat(emptyLines);\n\n        /**\n         * Returns whether or not comments are on lines starting with or ending with code\n         * @param {token} token The comment token to check.\n         * @returns {boolean} True if the comment is not alone.\n         */\n        function codeAroundComment(token) {\n            let currentToken = token;\n\n            do {\n                currentToken = sourceCode.getTokenBefore(currentToken, { includeComments: true });\n            } while (currentToken && astUtils$1.isCommentToken(currentToken));\n\n            if (currentToken && astUtils$1.isTokenOnSameLine(currentToken, token)) {\n                return true;\n            }\n\n            currentToken = token;\n            do {\n                currentToken = sourceCode.getTokenAfter(currentToken, { includeComments: true });\n            } while (currentToken && astUtils$1.isCommentToken(currentToken));\n\n            if (currentToken && astUtils$1.isTokenOnSameLine(token, currentToken)) {\n                return true;\n            }\n\n            return false;\n        }\n\n        /**\n         * Returns whether or not comments are inside a node type or not.\n         * @param {ASTNode} parent The Comment parent node.\n         * @param {string} nodeType The parent type to check against.\n         * @returns {boolean} True if the comment is inside nodeType.\n         */\n        function isParentNodeType(parent, nodeType) {\n            return parent.type === nodeType ||\n                (parent.body && parent.body.type === nodeType) ||\n                (parent.consequent && parent.consequent.type === nodeType);\n        }\n\n        /**\n         * Returns the parent node that contains the given token.\n         * @param {token} token The token to check.\n         * @returns {ASTNode} The parent node that contains the given token.\n         */\n        function getParentNodeOfToken(token) {\n            return sourceCode.getNodeByRangeIndex(token.range[0]);\n        }\n\n        /**\n         * Returns whether or not comments are at the parent start or not.\n         * @param {token} token The Comment token.\n         * @param {string} nodeType The parent type to check against.\n         * @returns {boolean} True if the comment is at parent start.\n         */\n        function isCommentAtParentStart(token, nodeType) {\n            const parent = getParentNodeOfToken(token);\n\n            return parent && isParentNodeType(parent, nodeType) &&\n                    token.loc.start.line - parent.loc.start.line === 1;\n        }\n\n        /**\n         * Returns whether or not comments are at the parent end or not.\n         * @param {token} token The Comment token.\n         * @param {string} nodeType The parent type to check against.\n         * @returns {boolean} True if the comment is at parent end.\n         */\n        function isCommentAtParentEnd(token, nodeType) {\n            const parent = getParentNodeOfToken(token);\n\n            return parent && isParentNodeType(parent, nodeType) &&\n                    parent.loc.end.line - token.loc.end.line === 1;\n        }\n\n        /**\n         * Returns whether or not comments are at the block start or not.\n         * @param {token} token The Comment token.\n         * @returns {boolean} True if the comment is at block start.\n         */\n        function isCommentAtBlockStart(token) {\n            return isCommentAtParentStart(token, \"ClassBody\") || isCommentAtParentStart(token, \"BlockStatement\") || isCommentAtParentStart(token, \"SwitchCase\");\n        }\n\n        /**\n         * Returns whether or not comments are at the block end or not.\n         * @param {token} token The Comment token.\n         * @returns {boolean} True if the comment is at block end.\n         */\n        function isCommentAtBlockEnd(token) {\n            return isCommentAtParentEnd(token, \"ClassBody\") || isCommentAtParentEnd(token, \"BlockStatement\") || isCommentAtParentEnd(token, \"SwitchCase\") || isCommentAtParentEnd(token, \"SwitchStatement\");\n        }\n\n        /**\n         * Returns whether or not comments are at the class start or not.\n         * @param {token} token The Comment token.\n         * @returns {boolean} True if the comment is at class start.\n         */\n        function isCommentAtClassStart(token) {\n            return isCommentAtParentStart(token, \"ClassBody\");\n        }\n\n        /**\n         * Returns whether or not comments are at the class end or not.\n         * @param {token} token The Comment token.\n         * @returns {boolean} True if the comment is at class end.\n         */\n        function isCommentAtClassEnd(token) {\n            return isCommentAtParentEnd(token, \"ClassBody\");\n        }\n\n        /**\n         * Returns whether or not comments are at the object start or not.\n         * @param {token} token The Comment token.\n         * @returns {boolean} True if the comment is at object start.\n         */\n        function isCommentAtObjectStart(token) {\n            return isCommentAtParentStart(token, \"ObjectExpression\") || isCommentAtParentStart(token, \"ObjectPattern\");\n        }\n\n        /**\n         * Returns whether or not comments are at the object end or not.\n         * @param {token} token The Comment token.\n         * @returns {boolean} True if the comment is at object end.\n         */\n        function isCommentAtObjectEnd(token) {\n            return isCommentAtParentEnd(token, \"ObjectExpression\") || isCommentAtParentEnd(token, \"ObjectPattern\");\n        }\n\n        /**\n         * Returns whether or not comments are at the array start or not.\n         * @param {token} token The Comment token.\n         * @returns {boolean} True if the comment is at array start.\n         */\n        function isCommentAtArrayStart(token) {\n            return isCommentAtParentStart(token, \"ArrayExpression\") || isCommentAtParentStart(token, \"ArrayPattern\");\n        }\n\n        /**\n         * Returns whether or not comments are at the array end or not.\n         * @param {token} token The Comment token.\n         * @returns {boolean} True if the comment is at array end.\n         */\n        function isCommentAtArrayEnd(token) {\n            return isCommentAtParentEnd(token, \"ArrayExpression\") || isCommentAtParentEnd(token, \"ArrayPattern\");\n        }\n\n        /**\n         * Checks if a comment token has lines around it (ignores inline comments)\n         * @param {token} token The Comment token.\n         * @param {Object} opts Options to determine the newline.\n         * @param {boolean} opts.after Should have a newline after this line.\n         * @param {boolean} opts.before Should have a newline before this line.\n         * @returns {void}\n         */\n        function checkForEmptyLine(token, opts) {\n            if (applyDefaultIgnorePatterns && defaultIgnoreRegExp.test(token.value)) {\n                return;\n            }\n\n            if (ignorePattern && customIgnoreRegExp.test(token.value)) {\n                return;\n            }\n\n            let after = opts.after,\n                before = opts.before;\n\n            const prevLineNum = token.loc.start.line - 1,\n                nextLineNum = token.loc.end.line + 1,\n                commentIsNotAlone = codeAroundComment(token);\n\n            const blockStartAllowed = options.allowBlockStart &&\n                    isCommentAtBlockStart(token) &&\n                    !(options.allowClassStart === false &&\n                    isCommentAtClassStart(token)),\n                blockEndAllowed = options.allowBlockEnd && isCommentAtBlockEnd(token) && !(options.allowClassEnd === false && isCommentAtClassEnd(token)),\n                classStartAllowed = options.allowClassStart && isCommentAtClassStart(token),\n                classEndAllowed = options.allowClassEnd && isCommentAtClassEnd(token),\n                objectStartAllowed = options.allowObjectStart && isCommentAtObjectStart(token),\n                objectEndAllowed = options.allowObjectEnd && isCommentAtObjectEnd(token),\n                arrayStartAllowed = options.allowArrayStart && isCommentAtArrayStart(token),\n                arrayEndAllowed = options.allowArrayEnd && isCommentAtArrayEnd(token);\n\n            const exceptionStartAllowed = blockStartAllowed || classStartAllowed || objectStartAllowed || arrayStartAllowed;\n            const exceptionEndAllowed = blockEndAllowed || classEndAllowed || objectEndAllowed || arrayEndAllowed;\n\n            // ignore top of the file and bottom of the file\n            if (prevLineNum < 1) {\n                before = false;\n            }\n            if (nextLineNum >= numLines) {\n                after = false;\n            }\n\n            // we ignore all inline comments\n            if (commentIsNotAlone) {\n                return;\n            }\n\n            const previousTokenOrComment = sourceCode.getTokenBefore(token, { includeComments: true });\n            const nextTokenOrComment = sourceCode.getTokenAfter(token, { includeComments: true });\n\n            // check for newline before\n            if (!exceptionStartAllowed && before && !lodash.includes(commentAndEmptyLines, prevLineNum) &&\n                    !(astUtils$1.isCommentToken(previousTokenOrComment) && astUtils$1.isTokenOnSameLine(previousTokenOrComment, token))) {\n                const lineStart = token.range[0] - token.loc.start.column;\n                const range = [lineStart, lineStart];\n\n                context.report({\n                    node: token,\n                    messageId: \"before\",\n                    fix(fixer) {\n                        return fixer.insertTextBeforeRange(range, \"\\n\");\n                    }\n                });\n            }\n\n            // check for newline after\n            if (!exceptionEndAllowed && after && !lodash.includes(commentAndEmptyLines, nextLineNum) &&\n                    !(astUtils$1.isCommentToken(nextTokenOrComment) && astUtils$1.isTokenOnSameLine(token, nextTokenOrComment))) {\n                context.report({\n                    node: token,\n                    messageId: \"after\",\n                    fix(fixer) {\n                        return fixer.insertTextAfter(token, \"\\n\");\n                    }\n                });\n            }\n\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            Program() {\n                comments.forEach(token => {\n                    if (token.type === \"Line\") {\n                        if (options.beforeLineComment || options.afterLineComment) {\n                            checkForEmptyLine(token, {\n                                after: options.afterLineComment,\n                                before: options.beforeLineComment\n                            });\n                        }\n                    } else if (token.type === \"Block\") {\n                        if (options.beforeBlockComment || options.afterBlockComment) {\n                            checkForEmptyLine(token, {\n                                after: options.afterBlockComment,\n                                before: options.beforeBlockComment\n                            });\n                        }\n                    }\n                });\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar linesAroundDirective = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require or disallow newlines around directives\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/lines-around-directive\"\n        },\n\n        schema: [{\n            oneOf: [\n                {\n                    enum: [\"always\", \"never\"]\n                },\n                {\n                    type: \"object\",\n                    properties: {\n                        before: {\n                            enum: [\"always\", \"never\"]\n                        },\n                        after: {\n                            enum: [\"always\", \"never\"]\n                        }\n                    },\n                    additionalProperties: false,\n                    minProperties: 2\n                }\n            ]\n        }],\n\n        fixable: \"whitespace\",\n        messages: {\n            expected: \"Expected newline {{location}} \\\"{{value}}\\\" directive.\",\n            unexpected: \"Unexpected newline {{location}} \\\"{{value}}\\\" directive.\"\n        },\n        deprecated: true,\n        replacedBy: [\"padding-line-between-statements\"]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const config = context.options[0] || \"always\";\n        const expectLineBefore = typeof config === \"string\" ? config : config.before;\n        const expectLineAfter = typeof config === \"string\" ? config : config.after;\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Check if node is preceded by a blank newline.\n         * @param {ASTNode} node Node to check.\n         * @returns {boolean} Whether or not the passed in node is preceded by a blank newline.\n         */\n        function hasNewlineBefore(node) {\n            const tokenBefore = sourceCode.getTokenBefore(node, { includeComments: true });\n            const tokenLineBefore = tokenBefore ? tokenBefore.loc.end.line : 0;\n\n            return node.loc.start.line - tokenLineBefore >= 2;\n        }\n\n        /**\n         * Gets the last token of a node that is on the same line as the rest of the node.\n         * This will usually be the last token of the node, but it will be the second-to-last token if the node has a trailing\n         * semicolon on a different line.\n         * @param {ASTNode} node A directive node\n         * @returns {Token} The last token of the node on the line\n         */\n        function getLastTokenOnLine(node) {\n            const lastToken = sourceCode.getLastToken(node);\n            const secondToLastToken = sourceCode.getTokenBefore(lastToken);\n\n            return astUtils$1.isSemicolonToken(lastToken) && lastToken.loc.start.line > secondToLastToken.loc.end.line\n                ? secondToLastToken\n                : lastToken;\n        }\n\n        /**\n         * Check if node is followed by a blank newline.\n         * @param {ASTNode} node Node to check.\n         * @returns {boolean} Whether or not the passed in node is followed by a blank newline.\n         */\n        function hasNewlineAfter(node) {\n            const lastToken = getLastTokenOnLine(node);\n            const tokenAfter = sourceCode.getTokenAfter(lastToken, { includeComments: true });\n\n            return tokenAfter.loc.start.line - lastToken.loc.end.line >= 2;\n        }\n\n        /**\n         * Report errors for newlines around directives.\n         * @param {ASTNode} node Node to check.\n         * @param {string} location Whether the error was found before or after the directive.\n         * @param {boolean} expected Whether or not a newline was expected or unexpected.\n         * @returns {void}\n         */\n        function reportError(node, location, expected) {\n            context.report({\n                node,\n                messageId: expected ? \"expected\" : \"unexpected\",\n                data: {\n                    value: node.expression.value,\n                    location\n                },\n                fix(fixer) {\n                    const lastToken = getLastTokenOnLine(node);\n\n                    if (expected) {\n                        return location === \"before\" ? fixer.insertTextBefore(node, \"\\n\") : fixer.insertTextAfter(lastToken, \"\\n\");\n                    }\n                    return fixer.removeRange(location === \"before\" ? [node.range[0] - 1, node.range[0]] : [lastToken.range[1], lastToken.range[1] + 1]);\n                }\n            });\n        }\n\n        /**\n         * Check lines around directives in node\n         * @param {ASTNode} node node to check\n         * @returns {void}\n         */\n        function checkDirectives(node) {\n            const directives = astUtils$1.getDirectivePrologue(node);\n\n            if (!directives.length) {\n                return;\n            }\n\n            const firstDirective = directives[0];\n            const leadingComments = sourceCode.getCommentsBefore(firstDirective);\n\n            /*\n             * Only check before the first directive if it is preceded by a comment or if it is at the top of\n             * the file and expectLineBefore is set to \"never\". This is to not force a newline at the top of\n             * the file if there are no comments as well as for compatibility with padded-blocks.\n             */\n            if (leadingComments.length) {\n                if (expectLineBefore === \"always\" && !hasNewlineBefore(firstDirective)) {\n                    reportError(firstDirective, \"before\", true);\n                }\n\n                if (expectLineBefore === \"never\" && hasNewlineBefore(firstDirective)) {\n                    reportError(firstDirective, \"before\", false);\n                }\n            } else if (\n                node.type === \"Program\" &&\n                expectLineBefore === \"never\" &&\n                !leadingComments.length &&\n                hasNewlineBefore(firstDirective)\n            ) {\n                reportError(firstDirective, \"before\", false);\n            }\n\n            const lastDirective = directives[directives.length - 1];\n            const statements = node.type === \"Program\" ? node.body : node.body.body;\n\n            /*\n             * Do not check after the last directive if the body only\n             * contains a directive prologue and isn't followed by a comment to ensure\n             * this rule behaves well with padded-blocks.\n             */\n            if (lastDirective === statements[statements.length - 1] && !lastDirective.trailingComments) {\n                return;\n            }\n\n            if (expectLineAfter === \"always\" && !hasNewlineAfter(lastDirective)) {\n                reportError(lastDirective, \"after\", true);\n            }\n\n            if (expectLineAfter === \"never\" && hasNewlineAfter(lastDirective)) {\n                reportError(lastDirective, \"after\", false);\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            Program: checkDirectives,\n            FunctionDeclaration: checkDirectives,\n            FunctionExpression: checkDirectives,\n            ArrowFunctionExpression: checkDirectives\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar linesBetweenClassMembers = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require or disallow an empty line between class members\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/lines-between-class-members\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                enum: [\"always\", \"never\"]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    exceptAfterSingleLine: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n        messages: {\n            never: \"Unexpected blank line between class members.\",\n            always: \"Expected blank line between class members.\"\n        }\n    },\n\n    create(context) {\n\n        const options = [];\n\n        options[0] = context.options[0] || \"always\";\n        options[1] = context.options[1] || { exceptAfterSingleLine: false };\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Return the last token among the consecutive tokens that have no exceed max line difference in between, before the first token in the next member.\n         * @param {Token} prevLastToken The last token in the previous member node.\n         * @param {Token} nextFirstToken The first token in the next member node.\n         * @param {number} maxLine The maximum number of allowed line difference between consecutive tokens.\n         * @returns {Token} The last token among the consecutive tokens.\n         */\n        function findLastConsecutiveTokenAfter(prevLastToken, nextFirstToken, maxLine) {\n            const after = sourceCode.getTokenAfter(prevLastToken, { includeComments: true });\n\n            if (after !== nextFirstToken && after.loc.start.line - prevLastToken.loc.end.line <= maxLine) {\n                return findLastConsecutiveTokenAfter(after, nextFirstToken, maxLine);\n            }\n            return prevLastToken;\n        }\n\n        /**\n         * Return the first token among the consecutive tokens that have no exceed max line difference in between, after the last token in the previous member.\n         * @param {Token} nextFirstToken The first token in the next member node.\n         * @param {Token} prevLastToken The last token in the previous member node.\n         * @param {number} maxLine The maximum number of allowed line difference between consecutive tokens.\n         * @returns {Token} The first token among the consecutive tokens.\n         */\n        function findFirstConsecutiveTokenBefore(nextFirstToken, prevLastToken, maxLine) {\n            const before = sourceCode.getTokenBefore(nextFirstToken, { includeComments: true });\n\n            if (before !== prevLastToken && nextFirstToken.loc.start.line - before.loc.end.line <= maxLine) {\n                return findFirstConsecutiveTokenBefore(before, prevLastToken, maxLine);\n            }\n            return nextFirstToken;\n        }\n\n        /**\n         * Checks if there is a token or comment between two tokens.\n         * @param {Token} before The token before.\n         * @param {Token} after The token after.\n         * @returns {boolean} True if there is a token or comment between two tokens.\n         */\n        function hasTokenOrCommentBetween(before, after) {\n            return sourceCode.getTokensBetween(before, after, { includeComments: true }).length !== 0;\n        }\n\n        return {\n            ClassBody(node) {\n                const body = node.body;\n\n                for (let i = 0; i < body.length - 1; i++) {\n                    const curFirst = sourceCode.getFirstToken(body[i]);\n                    const curLast = sourceCode.getLastToken(body[i]);\n                    const nextFirst = sourceCode.getFirstToken(body[i + 1]);\n                    const isMulti = !astUtils$1.isTokenOnSameLine(curFirst, curLast);\n                    const skip = !isMulti && options[1].exceptAfterSingleLine;\n                    const beforePadding = findLastConsecutiveTokenAfter(curLast, nextFirst, 1);\n                    const afterPadding = findFirstConsecutiveTokenBefore(nextFirst, curLast, 1);\n                    const isPadded = afterPadding.loc.start.line - beforePadding.loc.end.line > 1;\n                    const hasTokenInPadding = hasTokenOrCommentBetween(beforePadding, afterPadding);\n                    const curLineLastToken = findLastConsecutiveTokenAfter(curLast, nextFirst, 0);\n\n                    if ((options[0] === \"always\" && !skip && !isPadded) ||\n                        (options[0] === \"never\" && isPadded)) {\n                        context.report({\n                            node: body[i + 1],\n                            messageId: isPadded ? \"never\" : \"always\",\n                            fix(fixer) {\n                                if (hasTokenInPadding) {\n                                    return null;\n                                }\n                                return isPadded\n                                    ? fixer.replaceTextRange([beforePadding.range[1], afterPadding.range[0]], \"\\n\")\n                                    : fixer.insertTextAfter(curLineLastToken, \"\\n\");\n                            }\n                        });\n                    }\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Enforce a maximum number of classes per file\n * @author James Garbutt <https://github.com/43081j>\n */\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar maxClassesPerFile = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce a maximum number of classes per file\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/max-classes-per-file\"\n        },\n\n        schema: [\n            {\n                type: \"integer\",\n                minimum: 1\n            }\n        ],\n\n        messages: {\n            maximumExceeded: \"File has too many classes ({{ classCount }}). Maximum allowed is {{ max }}.\"\n        }\n    },\n    create(context) {\n\n        const maxClasses = context.options[0] || 1;\n\n        let classCount = 0;\n\n        return {\n            Program() {\n                classCount = 0;\n            },\n            \"Program:exit\"(node) {\n                if (classCount > maxClasses) {\n                    context.report({\n                        node,\n                        messageId: \"maximumExceeded\",\n                        data: {\n                            classCount,\n                            max: maxClasses\n                        }\n                    });\n                }\n            },\n            \"ClassDeclaration, ClassExpression\"() {\n                classCount++;\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview A rule to set the maximum depth block can be nested in a function.\n * @author Ian Christian Myers\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar maxDepth = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce a maximum depth that blocks can be nested\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/max-depth\"\n        },\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        type: \"integer\",\n                        minimum: 0\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            maximum: {\n                                type: \"integer\",\n                                minimum: 0\n                            },\n                            max: {\n                                type: \"integer\",\n                                minimum: 0\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ],\n        messages: {\n            tooDeeply: \"Blocks are nested too deeply ({{depth}}). Maximum allowed is {{maxDepth}}.\"\n        }\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        const functionStack = [],\n            option = context.options[0];\n        let maxDepth = 4;\n\n        if (\n            typeof option === \"object\" &&\n            (Object.prototype.hasOwnProperty.call(option, \"maximum\") || Object.prototype.hasOwnProperty.call(option, \"max\"))\n        ) {\n            maxDepth = option.maximum || option.max;\n        }\n        if (typeof option === \"number\") {\n            maxDepth = option;\n        }\n\n        /**\n         * When parsing a new function, store it in our function stack\n         * @returns {void}\n         * @private\n         */\n        function startFunction() {\n            functionStack.push(0);\n        }\n\n        /**\n         * When parsing is done then pop out the reference\n         * @returns {void}\n         * @private\n         */\n        function endFunction() {\n            functionStack.pop();\n        }\n\n        /**\n         * Save the block and Evaluate the node\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function pushBlock(node) {\n            const len = ++functionStack[functionStack.length - 1];\n\n            if (len > maxDepth) {\n                context.report({ node, messageId: \"tooDeeply\", data: { depth: len, maxDepth } });\n            }\n        }\n\n        /**\n         * Pop the saved block\n         * @returns {void}\n         * @private\n         */\n        function popBlock() {\n            functionStack[functionStack.length - 1]--;\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n            Program: startFunction,\n            FunctionDeclaration: startFunction,\n            FunctionExpression: startFunction,\n            ArrowFunctionExpression: startFunction,\n\n            IfStatement(node) {\n                if (node.parent.type !== \"IfStatement\") {\n                    pushBlock(node);\n                }\n            },\n            SwitchStatement: pushBlock,\n            TryStatement: pushBlock,\n            DoWhileStatement: pushBlock,\n            WhileStatement: pushBlock,\n            WithStatement: pushBlock,\n            ForStatement: pushBlock,\n            ForInStatement: pushBlock,\n            ForOfStatement: pushBlock,\n\n            \"IfStatement:exit\": popBlock,\n            \"SwitchStatement:exit\": popBlock,\n            \"TryStatement:exit\": popBlock,\n            \"DoWhileStatement:exit\": popBlock,\n            \"WhileStatement:exit\": popBlock,\n            \"WithStatement:exit\": popBlock,\n            \"ForStatement:exit\": popBlock,\n            \"ForInStatement:exit\": popBlock,\n            \"ForOfStatement:exit\": popBlock,\n\n            \"FunctionDeclaration:exit\": endFunction,\n            \"FunctionExpression:exit\": endFunction,\n            \"ArrowFunctionExpression:exit\": endFunction,\n            \"Program:exit\": endFunction\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to check for max length on a line.\n * @author Matt DuVall <http://www.mattduvall.com>\n */\n\n//------------------------------------------------------------------------------\n// Constants\n//------------------------------------------------------------------------------\n\nconst OPTIONS_SCHEMA = {\n    type: \"object\",\n    properties: {\n        code: {\n            type: \"integer\",\n            minimum: 0\n        },\n        comments: {\n            type: \"integer\",\n            minimum: 0\n        },\n        tabWidth: {\n            type: \"integer\",\n            minimum: 0\n        },\n        ignorePattern: {\n            type: \"string\"\n        },\n        ignoreComments: {\n            type: \"boolean\"\n        },\n        ignoreStrings: {\n            type: \"boolean\"\n        },\n        ignoreUrls: {\n            type: \"boolean\"\n        },\n        ignoreTemplateLiterals: {\n            type: \"boolean\"\n        },\n        ignoreRegExpLiterals: {\n            type: \"boolean\"\n        },\n        ignoreTrailingComments: {\n            type: \"boolean\"\n        }\n    },\n    additionalProperties: false\n};\n\nconst OPTIONS_OR_INTEGER_SCHEMA = {\n    anyOf: [\n        OPTIONS_SCHEMA,\n        {\n            type: \"integer\",\n            minimum: 0\n        }\n    ]\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar maxLen = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce a maximum line length\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/max-len\"\n        },\n\n        schema: [\n            OPTIONS_OR_INTEGER_SCHEMA,\n            OPTIONS_OR_INTEGER_SCHEMA,\n            OPTIONS_SCHEMA\n        ],\n        messages: {\n            max: \"This line has a length of {{lineLength}}. Maximum allowed is {{maxLength}}.\",\n            maxComment: \"This line has a comment length of {{lineLength}}. Maximum allowed is {{maxCommentLength}}.\"\n        }\n    },\n\n    create(context) {\n\n        /*\n         * Inspired by http://tools.ietf.org/html/rfc3986#appendix-B, however:\n         * - They're matching an entire string that we know is a URI\n         * - We're matching part of a string where we think there *might* be a URL\n         * - We're only concerned about URLs, as picking out any URI would cause\n         *   too many false positives\n         * - We don't care about matching the entire URL, any small segment is fine\n         */\n        const URL_REGEXP = /[^:/?#]:\\/\\/[^?#]/u;\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Computes the length of a line that may contain tabs. The width of each\n         * tab will be the number of spaces to the next tab stop.\n         * @param {string} line The line.\n         * @param {int} tabWidth The width of each tab stop in spaces.\n         * @returns {int} The computed line length.\n         * @private\n         */\n        function computeLineLength(line, tabWidth) {\n            let extraCharacterCount = 0;\n\n            line.replace(/\\t/gu, (match, offset) => {\n                const totalOffset = offset + extraCharacterCount,\n                    previousTabStopOffset = tabWidth ? totalOffset % tabWidth : 0,\n                    spaceCount = tabWidth - previousTabStopOffset;\n\n                extraCharacterCount += spaceCount - 1; // -1 for the replaced tab\n            });\n            return Array.from(line).length + extraCharacterCount;\n        }\n\n        // The options object must be the last option specified…\n        const options = Object.assign({}, context.options[context.options.length - 1]);\n\n        // …but max code length…\n        if (typeof context.options[0] === \"number\") {\n            options.code = context.options[0];\n        }\n\n        // …and tabWidth can be optionally specified directly as integers.\n        if (typeof context.options[1] === \"number\") {\n            options.tabWidth = context.options[1];\n        }\n\n        const maxLength = typeof options.code === \"number\" ? options.code : 80,\n            tabWidth = typeof options.tabWidth === \"number\" ? options.tabWidth : 4,\n            ignoreComments = !!options.ignoreComments,\n            ignoreStrings = !!options.ignoreStrings,\n            ignoreTemplateLiterals = !!options.ignoreTemplateLiterals,\n            ignoreRegExpLiterals = !!options.ignoreRegExpLiterals,\n            ignoreTrailingComments = !!options.ignoreTrailingComments || !!options.ignoreComments,\n            ignoreUrls = !!options.ignoreUrls,\n            maxCommentLength = options.comments;\n        let ignorePattern = options.ignorePattern || null;\n\n        if (ignorePattern) {\n            ignorePattern = new RegExp(ignorePattern, \"u\");\n        }\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Tells if a given comment is trailing: it starts on the current line and\n         * extends to or past the end of the current line.\n         * @param {string} line The source line we want to check for a trailing comment on\n         * @param {number} lineNumber The one-indexed line number for line\n         * @param {ASTNode} comment The comment to inspect\n         * @returns {boolean} If the comment is trailing on the given line\n         */\n        function isTrailingComment(line, lineNumber, comment) {\n            return comment &&\n                (comment.loc.start.line === lineNumber && lineNumber <= comment.loc.end.line) &&\n                (comment.loc.end.line > lineNumber || comment.loc.end.column === line.length);\n        }\n\n        /**\n         * Tells if a comment encompasses the entire line.\n         * @param {string} line The source line with a trailing comment\n         * @param {number} lineNumber The one-indexed line number this is on\n         * @param {ASTNode} comment The comment to remove\n         * @returns {boolean} If the comment covers the entire line\n         */\n        function isFullLineComment(line, lineNumber, comment) {\n            const start = comment.loc.start,\n                end = comment.loc.end,\n                isFirstTokenOnLine = !line.slice(0, comment.loc.start.column).trim();\n\n            return comment &&\n                (start.line < lineNumber || (start.line === lineNumber && isFirstTokenOnLine)) &&\n                (end.line > lineNumber || (end.line === lineNumber && end.column === line.length));\n        }\n\n        /**\n         * Gets the line after the comment and any remaining trailing whitespace is\n         * stripped.\n         * @param {string} line The source line with a trailing comment\n         * @param {ASTNode} comment The comment to remove\n         * @returns {string} Line without comment and trailing whitepace\n         */\n        function stripTrailingComment(line, comment) {\n\n            // loc.column is zero-indexed\n            return line.slice(0, comment.loc.start.column).replace(/\\s+$/u, \"\");\n        }\n\n        /**\n         * Ensure that an array exists at [key] on `object`, and add `value` to it.\n         * @param {Object} object the object to mutate\n         * @param {string} key the object's key\n         * @param {*} value the value to add\n         * @returns {void}\n         * @private\n         */\n        function ensureArrayAndPush(object, key, value) {\n            if (!Array.isArray(object[key])) {\n                object[key] = [];\n            }\n            object[key].push(value);\n        }\n\n        /**\n         * Retrieves an array containing all strings (\" or ') in the source code.\n         * @returns {ASTNode[]} An array of string nodes.\n         */\n        function getAllStrings() {\n            return sourceCode.ast.tokens.filter(token => (token.type === \"String\" ||\n                (token.type === \"JSXText\" && sourceCode.getNodeByRangeIndex(token.range[0] - 1).type === \"JSXAttribute\")));\n        }\n\n        /**\n         * Retrieves an array containing all template literals in the source code.\n         * @returns {ASTNode[]} An array of template literal nodes.\n         */\n        function getAllTemplateLiterals() {\n            return sourceCode.ast.tokens.filter(token => token.type === \"Template\");\n        }\n\n\n        /**\n         * Retrieves an array containing all RegExp literals in the source code.\n         * @returns {ASTNode[]} An array of RegExp literal nodes.\n         */\n        function getAllRegExpLiterals() {\n            return sourceCode.ast.tokens.filter(token => token.type === \"RegularExpression\");\n        }\n\n\n        /**\n         * A reducer to group an AST node by line number, both start and end.\n         * @param {Object} acc the accumulator\n         * @param {ASTNode} node the AST node in question\n         * @returns {Object} the modified accumulator\n         * @private\n         */\n        function groupByLineNumber(acc, node) {\n            for (let i = node.loc.start.line; i <= node.loc.end.line; ++i) {\n                ensureArrayAndPush(acc, i, node);\n            }\n            return acc;\n        }\n\n        /**\n         * Check the program for max length\n         * @param {ASTNode} node Node to examine\n         * @returns {void}\n         * @private\n         */\n        function checkProgramForMaxLength(node) {\n\n            // split (honors line-ending)\n            const lines = sourceCode.lines,\n\n                // list of comments to ignore\n                comments = ignoreComments || maxCommentLength || ignoreTrailingComments ? sourceCode.getAllComments() : [];\n\n            // we iterate over comments in parallel with the lines\n            let commentsIndex = 0;\n\n            const strings = getAllStrings();\n            const stringsByLine = strings.reduce(groupByLineNumber, {});\n\n            const templateLiterals = getAllTemplateLiterals();\n            const templateLiteralsByLine = templateLiterals.reduce(groupByLineNumber, {});\n\n            const regExpLiterals = getAllRegExpLiterals();\n            const regExpLiteralsByLine = regExpLiterals.reduce(groupByLineNumber, {});\n\n            lines.forEach((line, i) => {\n\n                // i is zero-indexed, line numbers are one-indexed\n                const lineNumber = i + 1;\n\n                /*\n                 * if we're checking comment length; we need to know whether this\n                 * line is a comment\n                 */\n                let lineIsComment = false;\n                let textToMeasure;\n\n                /*\n                 * We can short-circuit the comment checks if we're already out of\n                 * comments to check.\n                 */\n                if (commentsIndex < comments.length) {\n                    let comment = null;\n\n                    // iterate over comments until we find one past the current line\n                    do {\n                        comment = comments[++commentsIndex];\n                    } while (comment && comment.loc.start.line <= lineNumber);\n\n                    // and step back by one\n                    comment = comments[--commentsIndex];\n\n                    if (isFullLineComment(line, lineNumber, comment)) {\n                        lineIsComment = true;\n                        textToMeasure = line;\n                    } else if (ignoreTrailingComments && isTrailingComment(line, lineNumber, comment)) {\n                        textToMeasure = stripTrailingComment(line, comment);\n\n                        // ignore multiple trailing comments in the same line\n                        let lastIndex = commentsIndex;\n\n                        while (isTrailingComment(textToMeasure, lineNumber, comments[--lastIndex])) {\n                            textToMeasure = stripTrailingComment(textToMeasure, comments[lastIndex]);\n                        }\n                    } else {\n                        textToMeasure = line;\n                    }\n                } else {\n                    textToMeasure = line;\n                }\n                if (ignorePattern && ignorePattern.test(textToMeasure) ||\n                    ignoreUrls && URL_REGEXP.test(textToMeasure) ||\n                    ignoreStrings && stringsByLine[lineNumber] ||\n                    ignoreTemplateLiterals && templateLiteralsByLine[lineNumber] ||\n                    ignoreRegExpLiterals && regExpLiteralsByLine[lineNumber]\n                ) {\n\n                    // ignore this line\n                    return;\n                }\n\n                const lineLength = computeLineLength(textToMeasure, tabWidth);\n                const commentLengthApplies = lineIsComment && maxCommentLength;\n\n                if (lineIsComment && ignoreComments) {\n                    return;\n                }\n\n                if (commentLengthApplies) {\n                    if (lineLength > maxCommentLength) {\n                        context.report({\n                            node,\n                            loc: { line: lineNumber, column: 0 },\n                            messageId: \"maxComment\",\n                            data: {\n                                lineLength,\n                                maxCommentLength\n                            }\n                        });\n                    }\n                } else if (lineLength > maxLength) {\n                    context.report({\n                        node,\n                        loc: { line: lineNumber, column: 0 },\n                        messageId: \"max\",\n                        data: {\n                            lineLength,\n                            maxLength\n                        }\n                    });\n                }\n            });\n        }\n\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n            Program: checkProgramForMaxLength\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar maxLines = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce a maximum number of lines per file\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/max-lines\"\n        },\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        type: \"integer\",\n                        minimum: 0\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            max: {\n                                type: \"integer\",\n                                minimum: 0\n                            },\n                            skipComments: {\n                                type: \"boolean\"\n                            },\n                            skipBlankLines: {\n                                type: \"boolean\"\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ],\n        messages: {\n            exceed: \"File has too many lines ({{actual}}). Maximum allowed is {{max}}.\"\n        }\n    },\n\n    create(context) {\n        const option = context.options[0];\n        let max = 300;\n\n        if (typeof option === \"object\" && Object.prototype.hasOwnProperty.call(option, \"max\")) {\n            max = option.max;\n        } else if (typeof option === \"number\") {\n            max = option;\n        }\n\n        const skipComments = option && option.skipComments;\n        const skipBlankLines = option && option.skipBlankLines;\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Returns whether or not a token is a comment node type\n         * @param {Token} token The token to check\n         * @returns {boolean} True if the token is a comment node\n         */\n        function isCommentNodeType(token) {\n            return token && (token.type === \"Block\" || token.type === \"Line\");\n        }\n\n        /**\n         * Returns the line numbers of a comment that don't have any code on the same line\n         * @param {Node} comment The comment node to check\n         * @returns {number[]} The line numbers\n         */\n        function getLinesWithoutCode(comment) {\n            let start = comment.loc.start.line;\n            let end = comment.loc.end.line;\n\n            let token;\n\n            token = comment;\n            do {\n                token = sourceCode.getTokenBefore(token, { includeComments: true });\n            } while (isCommentNodeType(token));\n\n            if (token && astUtils$1.isTokenOnSameLine(token, comment)) {\n                start += 1;\n            }\n\n            token = comment;\n            do {\n                token = sourceCode.getTokenAfter(token, { includeComments: true });\n            } while (isCommentNodeType(token));\n\n            if (token && astUtils$1.isTokenOnSameLine(comment, token)) {\n                end -= 1;\n            }\n\n            if (start <= end) {\n                return lodash.range(start, end + 1);\n            }\n            return [];\n        }\n\n        return {\n            \"Program:exit\"() {\n                let lines = sourceCode.lines.map((text, i) => ({ lineNumber: i + 1, text }));\n\n                if (skipBlankLines) {\n                    lines = lines.filter(l => l.text.trim() !== \"\");\n                }\n\n                if (skipComments) {\n                    const comments = sourceCode.getAllComments();\n\n                    const commentLines = lodash.flatten(comments.map(comment => getLinesWithoutCode(comment)));\n\n                    lines = lines.filter(l => !lodash.includes(commentLines, l.lineNumber));\n                }\n\n                if (lines.length > max) {\n                    context.report({\n                        loc: { line: 1, column: 0 },\n                        messageId: \"exceed\",\n                        data: {\n                            max,\n                            actual: lines.length\n                        }\n                    });\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n\n//------------------------------------------------------------------------------\n// Constants\n//------------------------------------------------------------------------------\n\nconst OPTIONS_SCHEMA$1 = {\n    type: \"object\",\n    properties: {\n        max: {\n            type: \"integer\",\n            minimum: 0\n        },\n        skipComments: {\n            type: \"boolean\"\n        },\n        skipBlankLines: {\n            type: \"boolean\"\n        },\n        IIFEs: {\n            type: \"boolean\"\n        }\n    },\n    additionalProperties: false\n};\n\nconst OPTIONS_OR_INTEGER_SCHEMA$1 = {\n    oneOf: [\n        OPTIONS_SCHEMA$1,\n        {\n            type: \"integer\",\n            minimum: 1\n        }\n    ]\n};\n\n/**\n * Given a list of comment nodes, return a map with numeric keys (source code line numbers) and comment token values.\n * @param {Array} comments An array of comment nodes.\n * @returns {Map.<string,Node>} A map with numeric keys (source code line numbers) and comment token values.\n */\nfunction getCommentLineNumbers(comments) {\n    const map = new Map();\n\n    if (!comments) {\n        return map;\n    }\n    comments.forEach(comment => {\n        for (let i = comment.loc.start.line; i <= comment.loc.end.line; i++) {\n            map.set(i, comment);\n        }\n    });\n    return map;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar maxLinesPerFunction = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce a maximum number of line of code in a function\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/max-lines-per-function\"\n        },\n\n        schema: [\n            OPTIONS_OR_INTEGER_SCHEMA$1\n        ],\n        messages: {\n            exceed: \"{{name}} has too many lines ({{lineCount}}). Maximum allowed is {{maxLines}}.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const lines = sourceCode.lines;\n\n        const option = context.options[0];\n        let maxLines = 50;\n        let skipComments = false;\n        let skipBlankLines = false;\n        let IIFEs = false;\n\n        if (typeof option === \"object\") {\n            maxLines = typeof option.max === \"number\" ? option.max : 50;\n            skipComments = !!option.skipComments;\n            skipBlankLines = !!option.skipBlankLines;\n            IIFEs = !!option.IIFEs;\n        } else if (typeof option === \"number\") {\n            maxLines = option;\n        }\n\n        const commentLineNumbers = getCommentLineNumbers(sourceCode.getAllComments());\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Tells if a comment encompasses the entire line.\n         * @param {string} line The source line with a trailing comment\n         * @param {number} lineNumber The one-indexed line number this is on\n         * @param {ASTNode} comment The comment to remove\n         * @returns {boolean} If the comment covers the entire line\n         */\n        function isFullLineComment(line, lineNumber, comment) {\n            const start = comment.loc.start,\n                end = comment.loc.end,\n                isFirstTokenOnLine = start.line === lineNumber && !line.slice(0, start.column).trim(),\n                isLastTokenOnLine = end.line === lineNumber && !line.slice(end.column).trim();\n\n            return comment &&\n                (start.line < lineNumber || isFirstTokenOnLine) &&\n                (end.line > lineNumber || isLastTokenOnLine);\n        }\n\n        /**\n         * Identifies is a node is a FunctionExpression which is part of an IIFE\n         * @param {ASTNode} node Node to test\n         * @returns {boolean} True if it's an IIFE\n         */\n        function isIIFE(node) {\n            return node.type === \"FunctionExpression\" && node.parent && node.parent.type === \"CallExpression\" && node.parent.callee === node;\n        }\n\n        /**\n         * Identifies is a node is a FunctionExpression which is embedded within a MethodDefinition or Property\n         * @param {ASTNode} node Node to test\n         * @returns {boolean} True if it's a FunctionExpression embedded within a MethodDefinition or Property\n         */\n        function isEmbedded(node) {\n            if (!node.parent) {\n                return false;\n            }\n            if (node !== node.parent.value) {\n                return false;\n            }\n            if (node.parent.type === \"MethodDefinition\") {\n                return true;\n            }\n            if (node.parent.type === \"Property\") {\n                return node.parent.method === true || node.parent.kind === \"get\" || node.parent.kind === \"set\";\n            }\n            return false;\n        }\n\n        /**\n         * Count the lines in the function\n         * @param {ASTNode} funcNode Function AST node\n         * @returns {void}\n         * @private\n         */\n        function processFunction(funcNode) {\n            const node = isEmbedded(funcNode) ? funcNode.parent : funcNode;\n\n            if (!IIFEs && isIIFE(node)) {\n                return;\n            }\n            let lineCount = 0;\n\n            for (let i = node.loc.start.line - 1; i < node.loc.end.line; ++i) {\n                const line = lines[i];\n\n                if (skipComments) {\n                    if (commentLineNumbers.has(i + 1) && isFullLineComment(line, i + 1, commentLineNumbers.get(i + 1))) {\n                        continue;\n                    }\n                }\n\n                if (skipBlankLines) {\n                    if (line.match(/^\\s*$/u)) {\n                        continue;\n                    }\n                }\n\n                lineCount++;\n            }\n\n            if (lineCount > maxLines) {\n                const name = lodash.upperFirst(astUtils$1.getFunctionNameWithKind(funcNode));\n\n                context.report({\n                    node,\n                    messageId: \"exceed\",\n                    data: { name, lineCount, maxLines }\n                });\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n            FunctionDeclaration: processFunction,\n            FunctionExpression: processFunction,\n            ArrowFunctionExpression: processFunction\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to enforce a maximum number of nested callbacks.\n * @author Ian Christian Myers\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar maxNestedCallbacks = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce a maximum depth that callbacks can be nested\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/max-nested-callbacks\"\n        },\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        type: \"integer\",\n                        minimum: 0\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            maximum: {\n                                type: \"integer\",\n                                minimum: 0\n                            },\n                            max: {\n                                type: \"integer\",\n                                minimum: 0\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ],\n        messages: {\n            exceed: \"Too many nested callbacks ({{num}}). Maximum allowed is {{max}}.\"\n        }\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Constants\n        //--------------------------------------------------------------------------\n        const option = context.options[0];\n        let THRESHOLD = 10;\n\n        if (\n            typeof option === \"object\" &&\n            (Object.prototype.hasOwnProperty.call(option, \"maximum\") || Object.prototype.hasOwnProperty.call(option, \"max\"))\n        ) {\n            THRESHOLD = option.maximum || option.max;\n        } else if (typeof option === \"number\") {\n            THRESHOLD = option;\n        }\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        const callbackStack = [];\n\n        /**\n         * Checks a given function node for too many callbacks.\n         * @param {ASTNode} node The node to check.\n         * @returns {void}\n         * @private\n         */\n        function checkFunction(node) {\n            const parent = node.parent;\n\n            if (parent.type === \"CallExpression\") {\n                callbackStack.push(node);\n            }\n\n            if (callbackStack.length > THRESHOLD) {\n                const opts = { num: callbackStack.length, max: THRESHOLD };\n\n                context.report({ node, messageId: \"exceed\", data: opts });\n            }\n        }\n\n        /**\n         * Pops the call stack.\n         * @returns {void}\n         * @private\n         */\n        function popStack() {\n            callbackStack.pop();\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n            ArrowFunctionExpression: checkFunction,\n            \"ArrowFunctionExpression:exit\": popStack,\n\n            FunctionExpression: checkFunction,\n            \"FunctionExpression:exit\": popStack\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar maxParams = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce a maximum number of parameters in function definitions\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/max-params\"\n        },\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        type: \"integer\",\n                        minimum: 0\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            maximum: {\n                                type: \"integer\",\n                                minimum: 0\n                            },\n                            max: {\n                                type: \"integer\",\n                                minimum: 0\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ],\n        messages: {\n            exceed: \"{{name}} has too many parameters ({{count}}). Maximum allowed is {{max}}.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const option = context.options[0];\n        let numParams = 3;\n\n        if (\n            typeof option === \"object\" &&\n            (Object.prototype.hasOwnProperty.call(option, \"maximum\") || Object.prototype.hasOwnProperty.call(option, \"max\"))\n        ) {\n            numParams = option.maximum || option.max;\n        }\n        if (typeof option === \"number\") {\n            numParams = option;\n        }\n\n        /**\n         * Checks a function to see if it has too many parameters.\n         * @param {ASTNode} node The node to check.\n         * @returns {void}\n         * @private\n         */\n        function checkFunction(node) {\n            if (node.params.length > numParams) {\n                context.report({\n                    loc: astUtils$1.getFunctionHeadLoc(node, sourceCode),\n                    node,\n                    messageId: \"exceed\",\n                    data: {\n                        name: lodash.upperFirst(astUtils$1.getFunctionNameWithKind(node)),\n                        count: node.params.length,\n                        max: numParams\n                    }\n                });\n            }\n        }\n\n        return {\n            FunctionDeclaration: checkFunction,\n            ArrowFunctionExpression: checkFunction,\n            FunctionExpression: checkFunction\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar maxStatements = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce a maximum number of statements allowed in function blocks\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/max-statements\"\n        },\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        type: \"integer\",\n                        minimum: 0\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            maximum: {\n                                type: \"integer\",\n                                minimum: 0\n                            },\n                            max: {\n                                type: \"integer\",\n                                minimum: 0\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    ignoreTopLevelFunctions: {\n                        type: \"boolean\"\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n        messages: {\n            exceed: \"{{name}} has too many statements ({{count}}). Maximum allowed is {{max}}.\"\n        }\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        const functionStack = [],\n            option = context.options[0],\n            ignoreTopLevelFunctions = context.options[1] && context.options[1].ignoreTopLevelFunctions || false,\n            topLevelFunctions = [];\n        let maxStatements = 10;\n\n        if (\n            typeof option === \"object\" &&\n            (Object.prototype.hasOwnProperty.call(option, \"maximum\") || Object.prototype.hasOwnProperty.call(option, \"max\"))\n        ) {\n            maxStatements = option.maximum || option.max;\n        } else if (typeof option === \"number\") {\n            maxStatements = option;\n        }\n\n        /**\n         * Reports a node if it has too many statements\n         * @param {ASTNode} node node to evaluate\n         * @param {int} count Number of statements in node\n         * @param {int} max Maximum number of statements allowed\n         * @returns {void}\n         * @private\n         */\n        function reportIfTooManyStatements(node, count, max) {\n            if (count > max) {\n                const name = lodash.upperFirst(astUtils$1.getFunctionNameWithKind(node));\n\n                context.report({\n                    node,\n                    messageId: \"exceed\",\n                    data: { name, count, max }\n                });\n            }\n        }\n\n        /**\n         * When parsing a new function, store it in our function stack\n         * @returns {void}\n         * @private\n         */\n        function startFunction() {\n            functionStack.push(0);\n        }\n\n        /**\n         * Evaluate the node at the end of function\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function endFunction(node) {\n            const count = functionStack.pop();\n\n            if (ignoreTopLevelFunctions && functionStack.length === 0) {\n                topLevelFunctions.push({ node, count });\n            } else {\n                reportIfTooManyStatements(node, count, maxStatements);\n            }\n        }\n\n        /**\n         * Increment the count of the functions\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function countStatements(node) {\n            functionStack[functionStack.length - 1] += node.body.length;\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n            FunctionDeclaration: startFunction,\n            FunctionExpression: startFunction,\n            ArrowFunctionExpression: startFunction,\n\n            BlockStatement: countStatements,\n\n            \"FunctionDeclaration:exit\": endFunction,\n            \"FunctionExpression:exit\": endFunction,\n            \"ArrowFunctionExpression:exit\": endFunction,\n\n            \"Program:exit\"() {\n                if (topLevelFunctions.length === 1) {\n                    return;\n                }\n\n                topLevelFunctions.forEach(element => {\n                    const count = element.count;\n                    const node = element.node;\n\n                    reportIfTooManyStatements(node, count, maxStatements);\n                });\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar maxStatementsPerLine = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce a maximum number of statements allowed per line\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/max-statements-per-line\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    max: {\n                        type: \"integer\",\n                        minimum: 1,\n                        default: 1\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n        messages: {\n            exceed: \"This line has {{numberOfStatementsOnThisLine}} {{statements}}. Maximum allowed is {{maxStatementsPerLine}}.\"\n        }\n    },\n\n    create(context) {\n\n        const sourceCode = context.getSourceCode(),\n            options = context.options[0] || {},\n            maxStatementsPerLine = typeof options.max !== \"undefined\" ? options.max : 1;\n\n        let lastStatementLine = 0,\n            numberOfStatementsOnThisLine = 0,\n            firstExtraStatement;\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        const SINGLE_CHILD_ALLOWED = /^(?:(?:DoWhile|For|ForIn|ForOf|If|Labeled|While)Statement|Export(?:Default|Named)Declaration)$/u;\n\n        /**\n         * Reports with the first extra statement, and clears it.\n         * @returns {void}\n         */\n        function reportFirstExtraStatementAndClear() {\n            if (firstExtraStatement) {\n                context.report({\n                    node: firstExtraStatement,\n                    messageId: \"exceed\",\n                    data: {\n                        numberOfStatementsOnThisLine,\n                        maxStatementsPerLine,\n                        statements: numberOfStatementsOnThisLine === 1 ? \"statement\" : \"statements\"\n                    }\n                });\n            }\n            firstExtraStatement = null;\n        }\n\n        /**\n         * Gets the actual last token of a given node.\n         * @param {ASTNode} node A node to get. This is a node except EmptyStatement.\n         * @returns {Token} The actual last token.\n         */\n        function getActualLastToken(node) {\n            return sourceCode.getLastToken(node, astUtils$1.isNotSemicolonToken);\n        }\n\n        /**\n         * Addresses a given node.\n         * It updates the state of this rule, then reports the node if the node violated this rule.\n         * @param {ASTNode} node A node to check.\n         * @returns {void}\n         */\n        function enterStatement(node) {\n            const line = node.loc.start.line;\n\n            /*\n             * Skip to allow non-block statements if this is direct child of control statements.\n             * `if (a) foo();` is counted as 1.\n             * But `if (a) foo(); else foo();` should be counted as 2.\n             */\n            if (SINGLE_CHILD_ALLOWED.test(node.parent.type) &&\n                node.parent.alternate !== node\n            ) {\n                return;\n            }\n\n            // Update state.\n            if (line === lastStatementLine) {\n                numberOfStatementsOnThisLine += 1;\n            } else {\n                reportFirstExtraStatementAndClear();\n                numberOfStatementsOnThisLine = 1;\n                lastStatementLine = line;\n            }\n\n            // Reports if the node violated this rule.\n            if (numberOfStatementsOnThisLine === maxStatementsPerLine + 1) {\n                firstExtraStatement = firstExtraStatement || node;\n            }\n        }\n\n        /**\n         * Updates the state of this rule with the end line of leaving node to check with the next statement.\n         * @param {ASTNode} node A node to check.\n         * @returns {void}\n         */\n        function leaveStatement(node) {\n            const line = getActualLastToken(node).loc.end.line;\n\n            // Update state.\n            if (line !== lastStatementLine) {\n                reportFirstExtraStatementAndClear();\n                numberOfStatementsOnThisLine = 1;\n                lastStatementLine = line;\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n            BreakStatement: enterStatement,\n            ClassDeclaration: enterStatement,\n            ContinueStatement: enterStatement,\n            DebuggerStatement: enterStatement,\n            DoWhileStatement: enterStatement,\n            ExpressionStatement: enterStatement,\n            ForInStatement: enterStatement,\n            ForOfStatement: enterStatement,\n            ForStatement: enterStatement,\n            FunctionDeclaration: enterStatement,\n            IfStatement: enterStatement,\n            ImportDeclaration: enterStatement,\n            LabeledStatement: enterStatement,\n            ReturnStatement: enterStatement,\n            SwitchStatement: enterStatement,\n            ThrowStatement: enterStatement,\n            TryStatement: enterStatement,\n            VariableDeclaration: enterStatement,\n            WhileStatement: enterStatement,\n            WithStatement: enterStatement,\n            ExportNamedDeclaration: enterStatement,\n            ExportDefaultDeclaration: enterStatement,\n            ExportAllDeclaration: enterStatement,\n\n            \"BreakStatement:exit\": leaveStatement,\n            \"ClassDeclaration:exit\": leaveStatement,\n            \"ContinueStatement:exit\": leaveStatement,\n            \"DebuggerStatement:exit\": leaveStatement,\n            \"DoWhileStatement:exit\": leaveStatement,\n            \"ExpressionStatement:exit\": leaveStatement,\n            \"ForInStatement:exit\": leaveStatement,\n            \"ForOfStatement:exit\": leaveStatement,\n            \"ForStatement:exit\": leaveStatement,\n            \"FunctionDeclaration:exit\": leaveStatement,\n            \"IfStatement:exit\": leaveStatement,\n            \"ImportDeclaration:exit\": leaveStatement,\n            \"LabeledStatement:exit\": leaveStatement,\n            \"ReturnStatement:exit\": leaveStatement,\n            \"SwitchStatement:exit\": leaveStatement,\n            \"ThrowStatement:exit\": leaveStatement,\n            \"TryStatement:exit\": leaveStatement,\n            \"VariableDeclaration:exit\": leaveStatement,\n            \"WhileStatement:exit\": leaveStatement,\n            \"WithStatement:exit\": leaveStatement,\n            \"ExportNamedDeclaration:exit\": leaveStatement,\n            \"ExportDefaultDeclaration:exit\": leaveStatement,\n            \"ExportAllDeclaration:exit\": leaveStatement,\n            \"Program:exit\": reportFirstExtraStatementAndClear\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar multilineCommentStyle = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce a particular style for multiline comments\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/multiline-comment-style\"\n        },\n\n        fixable: \"whitespace\",\n        schema: [{ enum: [\"starred-block\", \"separate-lines\", \"bare-block\"] }],\n        messages: {\n            expectedBlock: \"Expected a block comment instead of consecutive line comments.\",\n            expectedBareBlock: \"Expected a block comment without padding stars.\",\n            startNewline: \"Expected a linebreak after '/*'.\",\n            endNewline: \"Expected a linebreak before '*/'.\",\n            missingStar: \"Expected a '*' at the start of this line.\",\n            alignment: \"Expected this line to be aligned with the start of the comment.\",\n            expectedLines: \"Expected multiple line comments instead of a block comment.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const option = context.options[0] || \"starred-block\";\n\n        //----------------------------------------------------------------------\n        // Helpers\n        //----------------------------------------------------------------------\n\n        /**\n         * Checks if a comment line is starred.\n         * @param {string} line A string representing a comment line.\n         * @returns {boolean} Whether or not the comment line is starred.\n         */\n        function isStarredCommentLine(line) {\n            return /^\\s*\\*/u.test(line);\n        }\n\n        /**\n         * Checks if a comment group is in starred-block form.\n         * @param {Token[]} commentGroup A group of comments, containing either multiple line comments or a single block comment.\n         * @returns {boolean} Whether or not the comment group is in starred block form.\n         */\n        function isStarredBlockComment([firstComment]) {\n            if (firstComment.type !== \"Block\") {\n                return false;\n            }\n\n            const lines = firstComment.value.split(astUtils$1.LINEBREAK_MATCHER);\n\n            // The first and last lines can only contain whitespace.\n            return lines.length > 0 && lines.every((line, i) => (i === 0 || i === lines.length - 1 ? /^\\s*$/u : /^\\s*\\*/u).test(line));\n        }\n\n        /**\n         * Checks if a comment group is in JSDoc form.\n         * @param {Token[]} commentGroup A group of comments, containing either multiple line comments or a single block comment.\n         * @returns {boolean} Whether or not the comment group is in JSDoc form.\n         */\n        function isJSDocComment([firstComment]) {\n            if (firstComment.type !== \"Block\") {\n                return false;\n            }\n\n            const lines = firstComment.value.split(astUtils$1.LINEBREAK_MATCHER);\n\n            return /^\\*\\s*$/u.test(lines[0]) &&\n                lines.slice(1, -1).every(line => /^\\s* /u.test(line)) &&\n                /^\\s*$/u.test(lines[lines.length - 1]);\n        }\n\n        /**\n         * Processes a comment group that is currently in separate-line form, calculating the offset for each line.\n         * @param {Token[]} commentGroup A group of comments containing multiple line comments.\n         * @returns {string[]} An array of the processed lines.\n         */\n        function processSeparateLineComments(commentGroup) {\n            const allLinesHaveLeadingSpace = commentGroup\n                .map(({ value }) => value)\n                .filter(line => line.trim().length)\n                .every(line => line.startsWith(\" \"));\n\n            return commentGroup.map(({ value }) => (allLinesHaveLeadingSpace ? value.replace(/^ /u, \"\") : value));\n        }\n\n        /**\n         * Processes a comment group that is currently in starred-block form, calculating the offset for each line.\n         * @param {Token} comment A single block comment token in starred-block form.\n         * @returns {string[]} An array of the processed lines.\n         */\n        function processStarredBlockComment(comment) {\n            const lines = comment.value.split(astUtils$1.LINEBREAK_MATCHER)\n                .filter((line, i, linesArr) => !(i === 0 || i === linesArr.length - 1))\n                .map(line => line.replace(/^\\s*$/u, \"\"));\n            const allLinesHaveLeadingSpace = lines\n                .map(line => line.replace(/\\s*\\*/u, \"\"))\n                .filter(line => line.trim().length)\n                .every(line => line.startsWith(\" \"));\n\n            return lines.map(line => line.replace(allLinesHaveLeadingSpace ? /\\s*\\* ?/u : /\\s*\\*/u, \"\"));\n        }\n\n        /**\n         * Processes a comment group that is currently in bare-block form, calculating the offset for each line.\n         * @param {Token} comment A single block comment token in bare-block form.\n         * @returns {string[]} An array of the processed lines.\n         */\n        function processBareBlockComment(comment) {\n            const lines = comment.value.split(astUtils$1.LINEBREAK_MATCHER).map(line => line.replace(/^\\s*$/u, \"\"));\n            const leadingWhitespace = `${sourceCode.text.slice(comment.range[0] - comment.loc.start.column, comment.range[0])}   `;\n            let offset = \"\";\n\n            /*\n             * Calculate the offset of the least indented line and use that as the basis for offsetting all the lines.\n             * The first line should not be checked because it is inline with the opening block comment delimiter.\n             */\n            for (const [i, line] of lines.entries()) {\n                if (!line.trim().length || i === 0) {\n                    continue;\n                }\n\n                const [, lineOffset] = line.match(/^(\\s*\\*?\\s*)/u);\n\n                if (lineOffset.length < leadingWhitespace.length) {\n                    const newOffset = leadingWhitespace.slice(lineOffset.length - leadingWhitespace.length);\n\n                    if (newOffset.length > offset.length) {\n                        offset = newOffset;\n                    }\n                }\n            }\n\n            return lines.map(line => {\n                const match = line.match(/^(\\s*\\*?\\s*)(.*)/u);\n                const [, lineOffset, lineContents] = match;\n\n                if (lineOffset.length > leadingWhitespace.length) {\n                    return `${lineOffset.slice(leadingWhitespace.length - (offset.length + lineOffset.length))}${lineContents}`;\n                }\n\n                if (lineOffset.length < leadingWhitespace.length) {\n                    return `${lineOffset.slice(leadingWhitespace.length)}${lineContents}`;\n                }\n\n                return lineContents;\n            });\n        }\n\n        /**\n         * Gets a list of comment lines in a group, formatting leading whitespace as necessary.\n         * @param {Token[]} commentGroup A group of comments containing either multiple line comments or a single block comment.\n         * @returns {string[]} A list of comment lines.\n         */\n        function getCommentLines(commentGroup) {\n            const [firstComment] = commentGroup;\n\n            if (firstComment.type === \"Line\") {\n                return processSeparateLineComments(commentGroup);\n            }\n\n            if (isStarredBlockComment(commentGroup)) {\n                return processStarredBlockComment(firstComment);\n            }\n\n            return processBareBlockComment(firstComment);\n        }\n\n        /**\n         * Gets the initial offset (whitespace) from the beginning of a line to a given comment token.\n         * @param {Token} comment The token to check.\n         * @returns {string} The offset from the beginning of a line to the token.\n         */\n        function getInitialOffset(comment) {\n            return sourceCode.text.slice(comment.range[0] - comment.loc.start.column, comment.range[0]);\n        }\n\n        /**\n         * Converts a comment into starred-block form\n         * @param {Token} firstComment The first comment of the group being converted\n         * @param {string[]} commentLinesList A list of lines to appear in the new starred-block comment\n         * @returns {string} A representation of the comment value in starred-block form, excluding start and end markers\n         */\n        function convertToStarredBlock(firstComment, commentLinesList) {\n            const initialOffset = getInitialOffset(firstComment);\n\n            return `/*\\n${commentLinesList.map(line => `${initialOffset} * ${line}`).join(\"\\n\")}\\n${initialOffset} */`;\n        }\n\n        /**\n         * Converts a comment into separate-line form\n         * @param {Token} firstComment The first comment of the group being converted\n         * @param {string[]} commentLinesList A list of lines to appear in the new starred-block comment\n         * @returns {string} A representation of the comment value in separate-line form\n         */\n        function convertToSeparateLines(firstComment, commentLinesList) {\n            return commentLinesList.map(line => `// ${line}`).join(`\\n${getInitialOffset(firstComment)}`);\n        }\n\n        /**\n         * Converts a comment into bare-block form\n         * @param {Token} firstComment The first comment of the group being converted\n         * @param {string[]} commentLinesList A list of lines to appear in the new starred-block comment\n         * @returns {string} A representation of the comment value in bare-block form\n         */\n        function convertToBlock(firstComment, commentLinesList) {\n            return `/* ${commentLinesList.join(`\\n${getInitialOffset(firstComment)}   `)} */`;\n        }\n\n        /**\n         * Each method checks a group of comments to see if it's valid according to the given option.\n         * @param {Token[]} commentGroup A list of comments that appear together. This will either contain a single\n         * block comment or multiple line comments.\n         * @returns {void}\n         */\n        const commentGroupCheckers = {\n            \"starred-block\"(commentGroup) {\n                const [firstComment] = commentGroup;\n                const commentLines = getCommentLines(commentGroup);\n\n                if (commentLines.some(value => value.includes(\"*/\"))) {\n                    return;\n                }\n\n                if (commentGroup.length > 1) {\n                    context.report({\n                        loc: {\n                            start: firstComment.loc.start,\n                            end: commentGroup[commentGroup.length - 1].loc.end\n                        },\n                        messageId: \"expectedBlock\",\n                        fix(fixer) {\n                            const range = [firstComment.range[0], commentGroup[commentGroup.length - 1].range[1]];\n\n                            return commentLines.some(value => value.startsWith(\"/\"))\n                                ? null\n                                : fixer.replaceTextRange(range, convertToStarredBlock(firstComment, commentLines));\n                        }\n                    });\n                } else {\n                    const lines = firstComment.value.split(astUtils$1.LINEBREAK_MATCHER);\n                    const expectedLeadingWhitespace = getInitialOffset(firstComment);\n                    const expectedLinePrefix = `${expectedLeadingWhitespace} *`;\n\n                    if (!/^\\*?\\s*$/u.test(lines[0])) {\n                        const start = firstComment.value.startsWith(\"*\") ? firstComment.range[0] + 1 : firstComment.range[0];\n\n                        context.report({\n                            loc: {\n                                start: firstComment.loc.start,\n                                end: { line: firstComment.loc.start.line, column: firstComment.loc.start.column + 2 }\n                            },\n                            messageId: \"startNewline\",\n                            fix: fixer => fixer.insertTextAfterRange([start, start + 2], `\\n${expectedLinePrefix}`)\n                        });\n                    }\n\n                    if (!/^\\s*$/u.test(lines[lines.length - 1])) {\n                        context.report({\n                            loc: {\n                                start: { line: firstComment.loc.end.line, column: firstComment.loc.end.column - 2 },\n                                end: firstComment.loc.end\n                            },\n                            messageId: \"endNewline\",\n                            fix: fixer => fixer.replaceTextRange([firstComment.range[1] - 2, firstComment.range[1]], `\\n${expectedLinePrefix}/`)\n                        });\n                    }\n\n                    for (let lineNumber = firstComment.loc.start.line + 1; lineNumber <= firstComment.loc.end.line; lineNumber++) {\n                        const lineText = sourceCode.lines[lineNumber - 1];\n                        const errorType = isStarredCommentLine(lineText)\n                            ? \"alignment\"\n                            : \"missingStar\";\n\n                        if (!lineText.startsWith(expectedLinePrefix)) {\n                            context.report({\n                                loc: {\n                                    start: { line: lineNumber, column: 0 },\n                                    end: { line: lineNumber, column: lineText.length }\n                                },\n                                messageId: errorType,\n                                fix(fixer) {\n                                    const lineStartIndex = sourceCode.getIndexFromLoc({ line: lineNumber, column: 0 });\n\n                                    if (errorType === \"alignment\") {\n                                        const [, commentTextPrefix = \"\"] = lineText.match(/^(\\s*\\*)/u) || [];\n                                        const commentTextStartIndex = lineStartIndex + commentTextPrefix.length;\n\n                                        return fixer.replaceTextRange([lineStartIndex, commentTextStartIndex], expectedLinePrefix);\n                                    }\n\n                                    const [, commentTextPrefix = \"\"] = lineText.match(/^(\\s*)/u) || [];\n                                    const commentTextStartIndex = lineStartIndex + commentTextPrefix.length;\n                                    let offset;\n\n                                    for (const [idx, line] of lines.entries()) {\n                                        if (!/\\S+/u.test(line)) {\n                                            continue;\n                                        }\n\n                                        const lineTextToAlignWith = sourceCode.lines[firstComment.loc.start.line - 1 + idx];\n                                        const [, prefix = \"\", initialOffset = \"\"] = lineTextToAlignWith.match(/^(\\s*(?:\\/?\\*)?(\\s*))/u) || [];\n\n                                        offset = `${commentTextPrefix.slice(prefix.length)}${initialOffset}`;\n                                        break;\n                                    }\n\n                                    return fixer.replaceTextRange([lineStartIndex, commentTextStartIndex], `${expectedLinePrefix}${offset}`);\n                                }\n                            });\n                        }\n                    }\n                }\n            },\n            \"separate-lines\"(commentGroup) {\n                const [firstComment] = commentGroup;\n\n                if (firstComment.type !== \"Block\" || isJSDocComment(commentGroup)) {\n                    return;\n                }\n\n                const commentLines = getCommentLines(commentGroup);\n                const tokenAfter = sourceCode.getTokenAfter(firstComment, { includeComments: true });\n\n                if (tokenAfter && firstComment.loc.end.line === tokenAfter.loc.start.line) {\n                    return;\n                }\n\n                context.report({\n                    loc: {\n                        start: firstComment.loc.start,\n                        end: { line: firstComment.loc.start.line, column: firstComment.loc.start.column + 2 }\n                    },\n                    messageId: \"expectedLines\",\n                    fix(fixer) {\n                        return fixer.replaceText(firstComment, convertToSeparateLines(firstComment, commentLines));\n                    }\n                });\n            },\n            \"bare-block\"(commentGroup) {\n                if (isJSDocComment(commentGroup)) {\n                    return;\n                }\n\n                const [firstComment] = commentGroup;\n                const commentLines = getCommentLines(commentGroup);\n\n                // Disallows consecutive line comments in favor of using a block comment.\n                if (firstComment.type === \"Line\" && commentLines.length > 1 &&\n                    !commentLines.some(value => value.includes(\"*/\"))) {\n                    context.report({\n                        loc: {\n                            start: firstComment.loc.start,\n                            end: commentGroup[commentGroup.length - 1].loc.end\n                        },\n                        messageId: \"expectedBlock\",\n                        fix(fixer) {\n                            return fixer.replaceTextRange(\n                                [firstComment.range[0], commentGroup[commentGroup.length - 1].range[1]],\n                                convertToBlock(firstComment, commentLines)\n                            );\n                        }\n                    });\n                }\n\n                // Prohibits block comments from having a * at the beginning of each line.\n                if (isStarredBlockComment(commentGroup)) {\n                    context.report({\n                        loc: {\n                            start: firstComment.loc.start,\n                            end: { line: firstComment.loc.start.line, column: firstComment.loc.start.column + 2 }\n                        },\n                        messageId: \"expectedBareBlock\",\n                        fix(fixer) {\n                            return fixer.replaceText(firstComment, convertToBlock(firstComment, commentLines));\n                        }\n                    });\n                }\n            }\n        };\n\n        //----------------------------------------------------------------------\n        // Public\n        //----------------------------------------------------------------------\n\n        return {\n            Program() {\n                return sourceCode.getAllComments()\n                    .filter(comment => comment.type !== \"Shebang\")\n                    .filter(comment => !astUtils$1.COMMENTS_IGNORE_PATTERN.test(comment.value))\n                    .filter(comment => {\n                        const tokenBefore = sourceCode.getTokenBefore(comment, { includeComments: true });\n\n                        return !tokenBefore || tokenBefore.loc.end.line < comment.loc.start.line;\n                    })\n                    .reduce((commentGroups, comment, index, commentList) => {\n                        const tokenBefore = sourceCode.getTokenBefore(comment, { includeComments: true });\n\n                        if (\n                            comment.type === \"Line\" &&\n                            index && commentList[index - 1].type === \"Line\" &&\n                            tokenBefore && tokenBefore.loc.end.line === comment.loc.start.line - 1 &&\n                            tokenBefore === commentList[index - 1]\n                        ) {\n                            commentGroups[commentGroups.length - 1].push(comment);\n                        } else {\n                            commentGroups.push([comment]);\n                        }\n\n                        return commentGroups;\n                    }, [])\n                    .filter(commentGroup => !(commentGroup.length === 1 && commentGroup[0].loc.start.line === commentGroup[0].loc.end.line))\n                    .forEach(commentGroupCheckers[option]);\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar multilineTernary = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce newlines between operands of ternary expressions\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/multiline-ternary\"\n        },\n\n        schema: [\n            {\n                enum: [\"always\", \"always-multiline\", \"never\"]\n            }\n        ],\n        messages: {\n            expectedTestCons: \"Expected newline between test and consequent of ternary expression.\",\n            expectedConsAlt: \"Expected newline between consequent and alternate of ternary expression.\",\n            unexpectedTestCons: \"Unexpected newline between test and consequent of ternary expression.\",\n            unexpectedConsAlt: \"Unexpected newline between consequent and alternate of ternary expression.\"\n        }\n    },\n\n    create(context) {\n        const option = context.options[0];\n        const multiline = option !== \"never\";\n        const allowSingleLine = option === \"always-multiline\";\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Tests whether node is preceded by supplied tokens\n         * @param {ASTNode} node node to check\n         * @param {ASTNode} parentNode parent of node to report\n         * @param {boolean} expected whether newline was expected or not\n         * @returns {void}\n         * @private\n         */\n        function reportError(node, parentNode, expected) {\n            context.report({\n                node,\n                messageId: `${expected ? \"expected\" : \"unexpected\"}${node === parentNode.test ? \"TestCons\" : \"ConsAlt\"}`\n            });\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            ConditionalExpression(node) {\n                const areTestAndConsequentOnSameLine = astUtils$1.isTokenOnSameLine(node.test, node.consequent);\n                const areConsequentAndAlternateOnSameLine = astUtils$1.isTokenOnSameLine(node.consequent, node.alternate);\n\n                if (!multiline) {\n                    if (!areTestAndConsequentOnSameLine) {\n                        reportError(node.test, node, false);\n                    }\n\n                    if (!areConsequentAndAlternateOnSameLine) {\n                        reportError(node.consequent, node, false);\n                    }\n                } else {\n                    if (allowSingleLine && node.loc.start.line === node.loc.end.line) {\n                        return;\n                    }\n\n                    if (areTestAndConsequentOnSameLine) {\n                        reportError(node.test, node, true);\n                    }\n\n                    if (areConsequentAndAlternateOnSameLine) {\n                        reportError(node.consequent, node, true);\n                    }\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag use of constructors without capital letters\n * @author Nicholas C. Zakas\n */\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst CAPS_ALLOWED = [\n    \"Array\",\n    \"Boolean\",\n    \"Date\",\n    \"Error\",\n    \"Function\",\n    \"Number\",\n    \"Object\",\n    \"RegExp\",\n    \"String\",\n    \"Symbol\",\n    \"BigInt\"\n];\n\n/**\n * Ensure that if the key is provided, it must be an array.\n * @param {Object} obj Object to check with `key`.\n * @param {string} key Object key to check on `obj`.\n * @param {*} fallback If obj[key] is not present, this will be returned.\n * @returns {string[]} Returns obj[key] if it's an Array, otherwise `fallback`\n */\nfunction checkArray(obj, key, fallback) {\n\n    /* istanbul ignore if */\n    if (Object.prototype.hasOwnProperty.call(obj, key) && !Array.isArray(obj[key])) {\n        throw new TypeError(`${key}, if provided, must be an Array`);\n    }\n    return obj[key] || fallback;\n}\n\n/**\n * A reducer function to invert an array to an Object mapping the string form of the key, to `true`.\n * @param {Object} map Accumulator object for the reduce.\n * @param {string} key Object key to set to `true`.\n * @returns {Object} Returns the updated Object for further reduction.\n */\nfunction invert(map, key) {\n    map[key] = true;\n    return map;\n}\n\n/**\n * Creates an object with the cap is new exceptions as its keys and true as their values.\n * @param {Object} config Rule configuration\n * @returns {Object} Object with cap is new exceptions.\n */\nfunction calculateCapIsNewExceptions(config) {\n    let capIsNewExceptions = checkArray(config, \"capIsNewExceptions\", CAPS_ALLOWED);\n\n    if (capIsNewExceptions !== CAPS_ALLOWED) {\n        capIsNewExceptions = capIsNewExceptions.concat(CAPS_ALLOWED);\n    }\n\n    return capIsNewExceptions.reduce(invert, {});\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar newCap = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require constructor names to begin with a capital letter\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/new-cap\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    newIsCap: {\n                        type: \"boolean\",\n                        default: true\n                    },\n                    capIsNew: {\n                        type: \"boolean\",\n                        default: true\n                    },\n                    newIsCapExceptions: {\n                        type: \"array\",\n                        items: {\n                            type: \"string\"\n                        }\n                    },\n                    newIsCapExceptionPattern: {\n                        type: \"string\"\n                    },\n                    capIsNewExceptions: {\n                        type: \"array\",\n                        items: {\n                            type: \"string\"\n                        }\n                    },\n                    capIsNewExceptionPattern: {\n                        type: \"string\"\n                    },\n                    properties: {\n                        type: \"boolean\",\n                        default: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n        messages: {\n            upper: \"A function with a name starting with an uppercase letter should only be used as a constructor.\",\n            lower: \"A constructor name should not start with a lowercase letter.\"\n        }\n    },\n\n    create(context) {\n\n        const config = Object.assign({}, context.options[0]);\n\n        config.newIsCap = config.newIsCap !== false;\n        config.capIsNew = config.capIsNew !== false;\n        const skipProperties = config.properties === false;\n\n        const newIsCapExceptions = checkArray(config, \"newIsCapExceptions\", []).reduce(invert, {});\n        const newIsCapExceptionPattern = config.newIsCapExceptionPattern ? new RegExp(config.newIsCapExceptionPattern, \"u\") : null;\n\n        const capIsNewExceptions = calculateCapIsNewExceptions(config);\n        const capIsNewExceptionPattern = config.capIsNewExceptionPattern ? new RegExp(config.capIsNewExceptionPattern, \"u\") : null;\n\n        const listeners = {};\n\n        const sourceCode = context.getSourceCode();\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Get exact callee name from expression\n         * @param {ASTNode} node CallExpression or NewExpression node\n         * @returns {string} name\n         */\n        function extractNameFromExpression(node) {\n\n            let name = \"\";\n\n            if (node.callee.type === \"MemberExpression\") {\n                const property = node.callee.property;\n\n                if (property.type === \"Literal\" && (typeof property.value === \"string\")) {\n                    name = property.value;\n                } else if (property.type === \"Identifier\" && !node.callee.computed) {\n                    name = property.name;\n                }\n            } else {\n                name = node.callee.name;\n            }\n            return name;\n        }\n\n        /**\n         * Returns the capitalization state of the string -\n         * Whether the first character is uppercase, lowercase, or non-alphabetic\n         * @param {string} str String\n         * @returns {string} capitalization state: \"non-alpha\", \"lower\", or \"upper\"\n         */\n        function getCap(str) {\n            const firstChar = str.charAt(0);\n\n            const firstCharLower = firstChar.toLowerCase();\n            const firstCharUpper = firstChar.toUpperCase();\n\n            if (firstCharLower === firstCharUpper) {\n\n                // char has no uppercase variant, so it's non-alphabetic\n                return \"non-alpha\";\n            }\n            if (firstChar === firstCharLower) {\n                return \"lower\";\n            }\n            return \"upper\";\n\n        }\n\n        /**\n         * Check if capitalization is allowed for a CallExpression\n         * @param {Object} allowedMap Object mapping calleeName to a Boolean\n         * @param {ASTNode} node CallExpression node\n         * @param {string} calleeName Capitalized callee name from a CallExpression\n         * @param {Object} pattern RegExp object from options pattern\n         * @returns {boolean} Returns true if the callee may be capitalized\n         */\n        function isCapAllowed(allowedMap, node, calleeName, pattern) {\n            const sourceText = sourceCode.getText(node.callee);\n\n            if (allowedMap[calleeName] || allowedMap[sourceText]) {\n                return true;\n            }\n\n            if (pattern && pattern.test(sourceText)) {\n                return true;\n            }\n\n            if (calleeName === \"UTC\" && node.callee.type === \"MemberExpression\") {\n\n                // allow if callee is Date.UTC\n                return node.callee.object.type === \"Identifier\" &&\n                    node.callee.object.name === \"Date\";\n            }\n\n            return skipProperties && node.callee.type === \"MemberExpression\";\n        }\n\n        /**\n         * Reports the given messageId for the given node. The location will be the start of the property or the callee.\n         * @param {ASTNode} node CallExpression or NewExpression node.\n         * @param {string} messageId The messageId to report.\n         * @returns {void}\n         */\n        function report(node, messageId) {\n            let callee = node.callee;\n\n            if (callee.type === \"MemberExpression\") {\n                callee = callee.property;\n            }\n\n            context.report({ node, loc: callee.loc.start, messageId });\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        if (config.newIsCap) {\n            listeners.NewExpression = function(node) {\n\n                const constructorName = extractNameFromExpression(node);\n\n                if (constructorName) {\n                    const capitalization = getCap(constructorName);\n                    const isAllowed = capitalization !== \"lower\" || isCapAllowed(newIsCapExceptions, node, constructorName, newIsCapExceptionPattern);\n\n                    if (!isAllowed) {\n                        report(node, \"lower\");\n                    }\n                }\n            };\n        }\n\n        if (config.capIsNew) {\n            listeners.CallExpression = function(node) {\n\n                const calleeName = extractNameFromExpression(node);\n\n                if (calleeName) {\n                    const capitalization = getCap(calleeName);\n                    const isAllowed = capitalization !== \"upper\" || isCapAllowed(capIsNewExceptions, node, calleeName, capIsNewExceptionPattern);\n\n                    if (!isAllowed) {\n                        report(node, \"upper\");\n                    }\n                }\n            };\n        }\n\n        return listeners;\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar newParens = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce or disallow parentheses when invoking a constructor with no arguments\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/new-parens\"\n        },\n\n        fixable: \"code\",\n        schema: {\n            anyOf: [\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"always\", \"never\"]\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 1\n                }\n            ]\n        },\n        messages: {\n            missing: \"Missing '()' invoking a constructor.\",\n            unnecessary: \"Unnecessary '()' invoking a constructor with no arguments.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options;\n        const always = options[0] !== \"never\"; // Default is always\n\n        const sourceCode = context.getSourceCode();\n\n        return {\n            NewExpression(node) {\n                if (node.arguments.length !== 0) {\n                    return; // if there are arguments, there have to be parens\n                }\n\n                const lastToken = sourceCode.getLastToken(node);\n                const hasLastParen = lastToken && astUtils$1.isClosingParenToken(lastToken);\n\n                // `hasParens` is true only if the new expression ends with its own parens, e.g., new new foo() does not end with its own parens\n                const hasParens = hasLastParen &&\n                    astUtils$1.isOpeningParenToken(sourceCode.getTokenBefore(lastToken)) &&\n                    node.callee.range[1] < node.range[1];\n\n                if (always) {\n                    if (!hasParens) {\n                        context.report({\n                            node,\n                            messageId: \"missing\",\n                            fix: fixer => fixer.insertTextAfter(node, \"()\")\n                        });\n                    }\n                } else {\n                    if (hasParens) {\n                        context.report({\n                            node,\n                            messageId: \"unnecessary\",\n                            fix: fixer => [\n                                fixer.remove(sourceCode.getTokenBefore(lastToken)),\n                                fixer.remove(lastToken),\n                                fixer.insertTextBefore(node, \"(\"),\n                                fixer.insertTextAfter(node, \")\")\n                            ]\n                        });\n                    }\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar newlineAfterVar = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require or disallow an empty line after variable declarations\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/newline-after-var\"\n        },\n        schema: [\n            {\n                enum: [\"never\", \"always\"]\n            }\n        ],\n        fixable: \"whitespace\",\n        messages: {\n            expected: \"Expected blank line after variable declarations.\",\n            unexpected: \"Unexpected blank line after variable declarations.\"\n        },\n\n        deprecated: true,\n\n        replacedBy: [\"padding-line-between-statements\"]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        // Default `mode` to \"always\".\n        const mode = context.options[0] === \"never\" ? \"never\" : \"always\";\n\n        // Cache starting and ending line numbers of comments for faster lookup\n        const commentEndLine = sourceCode.getAllComments().reduce((result, token) => {\n            result[token.loc.start.line] = token.loc.end.line;\n            return result;\n        }, {});\n\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Gets a token from the given node to compare line to the next statement.\n         *\n         * In general, the token is the last token of the node. However, the token is the second last token if the following conditions satisfy.\n         *\n         * - The last token is semicolon.\n         * - The semicolon is on a different line from the previous token of the semicolon.\n         *\n         * This behavior would address semicolon-less style code. e.g.:\n         *\n         *     var foo = 1\n         *\n         *     ;(a || b).doSomething()\n         * @param {ASTNode} node The node to get.\n         * @returns {Token} The token to compare line to the next statement.\n         */\n        function getLastToken(node) {\n            const lastToken = sourceCode.getLastToken(node);\n\n            if (lastToken.type === \"Punctuator\" && lastToken.value === \";\") {\n                const prevToken = sourceCode.getTokenBefore(lastToken);\n\n                if (prevToken.loc.end.line !== lastToken.loc.start.line) {\n                    return prevToken;\n                }\n            }\n\n            return lastToken;\n        }\n\n        /**\n         * Determine if provided keyword is a variable declaration\n         * @private\n         * @param {string} keyword keyword to test\n         * @returns {boolean} True if `keyword` is a type of var\n         */\n        function isVar(keyword) {\n            return keyword === \"var\" || keyword === \"let\" || keyword === \"const\";\n        }\n\n        /**\n         * Determine if provided keyword is a variant of for specifiers\n         * @private\n         * @param {string} keyword keyword to test\n         * @returns {boolean} True if `keyword` is a variant of for specifier\n         */\n        function isForTypeSpecifier(keyword) {\n            return keyword === \"ForStatement\" || keyword === \"ForInStatement\" || keyword === \"ForOfStatement\";\n        }\n\n        /**\n         * Determine if provided keyword is an export specifiers\n         * @private\n         * @param {string} nodeType nodeType to test\n         * @returns {boolean} True if `nodeType` is an export specifier\n         */\n        function isExportSpecifier(nodeType) {\n            return nodeType === \"ExportNamedDeclaration\" || nodeType === \"ExportSpecifier\" ||\n                nodeType === \"ExportDefaultDeclaration\" || nodeType === \"ExportAllDeclaration\";\n        }\n\n        /**\n         * Determine if provided node is the last of their parent block.\n         * @private\n         * @param {ASTNode} node node to test\n         * @returns {boolean} True if `node` is last of their parent block.\n         */\n        function isLastNode(node) {\n            const token = sourceCode.getTokenAfter(node);\n\n            return !token || (token.type === \"Punctuator\" && token.value === \"}\");\n        }\n\n        /**\n         * Gets the last line of a group of consecutive comments\n         * @param {number} commentStartLine The starting line of the group\n         * @returns {number} The number of the last comment line of the group\n         */\n        function getLastCommentLineOfBlock(commentStartLine) {\n            const currentCommentEnd = commentEndLine[commentStartLine];\n\n            return commentEndLine[currentCommentEnd + 1] ? getLastCommentLineOfBlock(currentCommentEnd + 1) : currentCommentEnd;\n        }\n\n        /**\n         * Determine if a token starts more than one line after a comment ends\n         * @param  {token}   token            The token being checked\n         * @param {integer}  commentStartLine The line number on which the comment starts\n         * @returns {boolean}                 True if `token` does not start immediately after a comment\n         */\n        function hasBlankLineAfterComment(token, commentStartLine) {\n            return token.loc.start.line > getLastCommentLineOfBlock(commentStartLine) + 1;\n        }\n\n        /**\n         * Checks that a blank line exists after a variable declaration when mode is\n         * set to \"always\", or checks that there is no blank line when mode is set\n         * to \"never\"\n         * @private\n         * @param {ASTNode} node `VariableDeclaration` node to test\n         * @returns {void}\n         */\n        function checkForBlankLine(node) {\n\n            /*\n             * lastToken is the last token on the node's line. It will usually also be the last token of the node, but it will\n             * sometimes be second-last if there is a semicolon on a different line.\n             */\n            const lastToken = getLastToken(node),\n\n                /*\n                 * If lastToken is the last token of the node, nextToken should be the token after the node. Otherwise, nextToken\n                 * is the last token of the node.\n                 */\n                nextToken = lastToken === sourceCode.getLastToken(node) ? sourceCode.getTokenAfter(node) : sourceCode.getLastToken(node),\n                nextLineNum = lastToken.loc.end.line + 1;\n\n            // Ignore if there is no following statement\n            if (!nextToken) {\n                return;\n            }\n\n            // Ignore if parent of node is a for variant\n            if (isForTypeSpecifier(node.parent.type)) {\n                return;\n            }\n\n            // Ignore if parent of node is an export specifier\n            if (isExportSpecifier(node.parent.type)) {\n                return;\n            }\n\n            /*\n             * Some coding styles use multiple `var` statements, so do nothing if\n             * the next token is a `var` statement.\n             */\n            if (nextToken.type === \"Keyword\" && isVar(nextToken.value)) {\n                return;\n            }\n\n            // Ignore if it is last statement in a block\n            if (isLastNode(node)) {\n                return;\n            }\n\n            // Next statement is not a `var`...\n            const noNextLineToken = nextToken.loc.start.line > nextLineNum;\n            const hasNextLineComment = (typeof commentEndLine[nextLineNum] !== \"undefined\");\n\n            if (mode === \"never\" && noNextLineToken && !hasNextLineComment) {\n                context.report({\n                    node,\n                    messageId: \"unexpected\",\n                    data: { identifier: node.name },\n                    fix(fixer) {\n                        const linesBetween = sourceCode.getText().slice(lastToken.range[1], nextToken.range[0]).split(astUtils$1.LINEBREAK_MATCHER);\n\n                        return fixer.replaceTextRange([lastToken.range[1], nextToken.range[0]], `${linesBetween.slice(0, -1).join(\"\")}\\n${linesBetween[linesBetween.length - 1]}`);\n                    }\n                });\n            }\n\n            // Token on the next line, or comment without blank line\n            if (\n                mode === \"always\" && (\n                    !noNextLineToken ||\n                    hasNextLineComment && !hasBlankLineAfterComment(nextToken, nextLineNum)\n                )\n            ) {\n                context.report({\n                    node,\n                    messageId: \"expected\",\n                    data: { identifier: node.name },\n                    fix(fixer) {\n                        if ((noNextLineToken ? getLastCommentLineOfBlock(nextLineNum) : lastToken.loc.end.line) === nextToken.loc.start.line) {\n                            return fixer.insertTextBefore(nextToken, \"\\n\\n\");\n                        }\n\n                        return fixer.insertTextBeforeRange([nextToken.range[0] - nextToken.loc.start.column, nextToken.range[1]], \"\\n\");\n                    }\n                });\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            VariableDeclaration: checkForBlankLine\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to require newlines before `return` statement\n * @author Kai Cataldo\n * @deprecated\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar newlineBeforeReturn = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require an empty line before `return` statements\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/newline-before-return\"\n        },\n\n        fixable: \"whitespace\",\n        schema: [],\n        messages: {\n            expected: \"Expected newline before return statement.\"\n        },\n\n        deprecated: true,\n        replacedBy: [\"padding-line-between-statements\"]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Tests whether node is preceded by supplied tokens\n         * @param {ASTNode} node node to check\n         * @param {Array} testTokens array of tokens to test against\n         * @returns {boolean} Whether or not the node is preceded by one of the supplied tokens\n         * @private\n         */\n        function isPrecededByTokens(node, testTokens) {\n            const tokenBefore = sourceCode.getTokenBefore(node);\n\n            return testTokens.some(token => tokenBefore.value === token);\n        }\n\n        /**\n         * Checks whether node is the first node after statement or in block\n         * @param {ASTNode} node node to check\n         * @returns {boolean} Whether or not the node is the first node after statement or in block\n         * @private\n         */\n        function isFirstNode(node) {\n            const parentType = node.parent.type;\n\n            if (node.parent.body) {\n                return Array.isArray(node.parent.body)\n                    ? node.parent.body[0] === node\n                    : node.parent.body === node;\n            }\n\n            if (parentType === \"IfStatement\") {\n                return isPrecededByTokens(node, [\"else\", \")\"]);\n            }\n            if (parentType === \"DoWhileStatement\") {\n                return isPrecededByTokens(node, [\"do\"]);\n            }\n            if (parentType === \"SwitchCase\") {\n                return isPrecededByTokens(node, [\":\"]);\n            }\n            return isPrecededByTokens(node, [\")\"]);\n\n        }\n\n        /**\n         * Returns the number of lines of comments that precede the node\n         * @param {ASTNode} node node to check for overlapping comments\n         * @param {number} lineNumTokenBefore line number of previous token, to check for overlapping comments\n         * @returns {number} Number of lines of comments that precede the node\n         * @private\n         */\n        function calcCommentLines(node, lineNumTokenBefore) {\n            const comments = sourceCode.getCommentsBefore(node);\n            let numLinesComments = 0;\n\n            if (!comments.length) {\n                return numLinesComments;\n            }\n\n            comments.forEach(comment => {\n                numLinesComments++;\n\n                if (comment.type === \"Block\") {\n                    numLinesComments += comment.loc.end.line - comment.loc.start.line;\n                }\n\n                // avoid counting lines with inline comments twice\n                if (comment.loc.start.line === lineNumTokenBefore) {\n                    numLinesComments--;\n                }\n\n                if (comment.loc.end.line === node.loc.start.line) {\n                    numLinesComments--;\n                }\n            });\n\n            return numLinesComments;\n        }\n\n        /**\n         * Returns the line number of the token before the node that is passed in as an argument\n         * @param {ASTNode} node The node to use as the start of the calculation\n         * @returns {number} Line number of the token before `node`\n         * @private\n         */\n        function getLineNumberOfTokenBefore(node) {\n            const tokenBefore = sourceCode.getTokenBefore(node);\n            let lineNumTokenBefore;\n\n            /**\n             * Global return (at the beginning of a script) is a special case.\n             * If there is no token before `return`, then we expect no line\n             * break before the return. Comments are allowed to occupy lines\n             * before the global return, just no blank lines.\n             * Setting lineNumTokenBefore to zero in that case results in the\n             * desired behavior.\n             */\n            if (tokenBefore) {\n                lineNumTokenBefore = tokenBefore.loc.end.line;\n            } else {\n                lineNumTokenBefore = 0; // global return at beginning of script\n            }\n\n            return lineNumTokenBefore;\n        }\n\n        /**\n         * Checks whether node is preceded by a newline\n         * @param {ASTNode} node node to check\n         * @returns {boolean} Whether or not the node is preceded by a newline\n         * @private\n         */\n        function hasNewlineBefore(node) {\n            const lineNumNode = node.loc.start.line;\n            const lineNumTokenBefore = getLineNumberOfTokenBefore(node);\n            const commentLines = calcCommentLines(node, lineNumTokenBefore);\n\n            return (lineNumNode - lineNumTokenBefore - commentLines) > 1;\n        }\n\n        /**\n         * Checks whether it is safe to apply a fix to a given return statement.\n         *\n         * The fix is not considered safe if the given return statement has leading comments,\n         * as we cannot safely determine if the newline should be added before or after the comments.\n         * For more information, see: https://github.com/eslint/eslint/issues/5958#issuecomment-222767211\n         * @param {ASTNode} node The return statement node to check.\n         * @returns {boolean} `true` if it can fix the node.\n         * @private\n         */\n        function canFix(node) {\n            const leadingComments = sourceCode.getCommentsBefore(node);\n            const lastLeadingComment = leadingComments[leadingComments.length - 1];\n            const tokenBefore = sourceCode.getTokenBefore(node);\n\n            if (leadingComments.length === 0) {\n                return true;\n            }\n\n            /*\n             * if the last leading comment ends in the same line as the previous token and\n             * does not share a line with the `return` node, we can consider it safe to fix.\n             * Example:\n             * function a() {\n             *     var b; //comment\n             *     return;\n             * }\n             */\n            if (lastLeadingComment.loc.end.line === tokenBefore.loc.end.line &&\n                lastLeadingComment.loc.end.line !== node.loc.start.line) {\n                return true;\n            }\n\n            return false;\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            ReturnStatement(node) {\n                if (!isFirstNode(node) && !hasNewlineBefore(node)) {\n                    context.report({\n                        node,\n                        messageId: \"expected\",\n                        fix(fixer) {\n                            if (canFix(node)) {\n                                const tokenBefore = sourceCode.getTokenBefore(node);\n                                const newlines = node.loc.start.line === tokenBefore.loc.end.line ? \"\\n\\n\" : \"\\n\";\n\n                                return fixer.insertTextBefore(node, newlines);\n                            }\n                            return null;\n                        }\n                    });\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar newlinePerChainedCall = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require a newline after each call in a method chain\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/newline-per-chained-call\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [{\n            type: \"object\",\n            properties: {\n                ignoreChainWithDepth: {\n                    type: \"integer\",\n                    minimum: 1,\n                    maximum: 10,\n                    default: 2\n                }\n            },\n            additionalProperties: false\n        }],\n        messages: {\n            expected: \"Expected line break before `{{callee}}`.\"\n        }\n    },\n\n    create(context) {\n\n        const options = context.options[0] || {},\n            ignoreChainWithDepth = options.ignoreChainWithDepth || 2;\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Get the prefix of a given MemberExpression node.\n         * If the MemberExpression node is a computed value it returns a\n         * left bracket. If not it returns a period.\n         * @param  {ASTNode} node A MemberExpression node to get\n         * @returns {string} The prefix of the node.\n         */\n        function getPrefix(node) {\n            return node.computed ? \"[\" : \".\";\n        }\n\n        /**\n         * Gets the property text of a given MemberExpression node.\n         * If the text is multiline, this returns only the first line.\n         * @param {ASTNode} node A MemberExpression node to get.\n         * @returns {string} The property text of the node.\n         */\n        function getPropertyText(node) {\n            const prefix = getPrefix(node);\n            const lines = sourceCode.getText(node.property).split(astUtils$1.LINEBREAK_MATCHER);\n            const suffix = node.computed && lines.length === 1 ? \"]\" : \"\";\n\n            return prefix + lines[0] + suffix;\n        }\n\n        return {\n            \"CallExpression:exit\"(node) {\n                if (!node.callee || node.callee.type !== \"MemberExpression\") {\n                    return;\n                }\n\n                const callee = node.callee;\n                let parent = callee.object;\n                let depth = 1;\n\n                while (parent && parent.callee) {\n                    depth += 1;\n                    parent = parent.callee.object;\n                }\n\n                if (depth > ignoreChainWithDepth && astUtils$1.isTokenOnSameLine(callee.object, callee.property)) {\n                    context.report({\n                        node: callee.property,\n                        loc: callee.property.loc.start,\n                        messageId: \"expected\",\n                        data: {\n                            callee: getPropertyText(callee)\n                        },\n                        fix(fixer) {\n                            const firstTokenAfterObject = sourceCode.getTokenAfter(callee.object, astUtils$1.isNotClosingParenToken);\n\n                            return fixer.insertTextBefore(firstTokenAfterObject, \"\\n\");\n                        }\n                    });\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nconst getPropertyName = astUtils$1.getStaticPropertyName;\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks if the given name is a prohibited identifier.\n * @param {string} name The name to check\n * @returns {boolean} Whether or not the name is prohibited.\n */\nfunction isProhibitedIdentifier(name) {\n    return /^(alert|confirm|prompt)$/u.test(name);\n}\n\n/**\n * Finds the eslint-scope reference in the given scope.\n * @param {Object} scope The scope to search.\n * @param {ASTNode} node The identifier node.\n * @returns {Reference|null} Returns the found reference or null if none were found.\n */\nfunction findReference$1(scope, node) {\n    const references = scope.references.filter(reference => reference.identifier.range[0] === node.range[0] &&\n            reference.identifier.range[1] === node.range[1]);\n\n    if (references.length === 1) {\n        return references[0];\n    }\n    return null;\n}\n\n/**\n * Checks if the given identifier node is shadowed in the given scope.\n * @param {Object} scope The current scope.\n * @param {string} node The identifier node to check\n * @returns {boolean} Whether or not the name is shadowed.\n */\nfunction isShadowed$1(scope, node) {\n    const reference = findReference$1(scope, node);\n\n    return reference && reference.resolved && reference.resolved.defs.length > 0;\n}\n\n/**\n * Checks if the given identifier node is a ThisExpression in the global scope or the global window property.\n * @param {Object} scope The current scope.\n * @param {string} node The identifier node to check\n * @returns {boolean} Whether or not the node is a reference to the global object.\n */\nfunction isGlobalThisReferenceOrGlobalWindow(scope, node) {\n    if (scope.type === \"global\" && node.type === \"ThisExpression\") {\n        return true;\n    }\n    if (node.name === \"window\") {\n        return !isShadowed$1(scope, node);\n    }\n\n    return false;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noAlert = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow the use of `alert`, `confirm`, and `prompt`\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-alert\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"Unexpected {{name}}.\"\n        }\n    },\n\n    create(context) {\n        return {\n            CallExpression(node) {\n                const callee = node.callee,\n                    currentScope = context.getScope();\n\n                // without window.\n                if (callee.type === \"Identifier\") {\n                    const name = callee.name;\n\n                    if (!isShadowed$1(currentScope, callee) && isProhibitedIdentifier(callee.name)) {\n                        context.report({\n                            node,\n                            messageId: \"unexpected\",\n                            data: { name }\n                        });\n                    }\n\n                } else if (callee.type === \"MemberExpression\" && isGlobalThisReferenceOrGlobalWindow(currentScope, callee.object)) {\n                    const name = getPropertyName(callee);\n\n                    if (isProhibitedIdentifier(name)) {\n                        context.report({\n                            node,\n                            messageId: \"unexpected\",\n                            data: { name }\n                        });\n                    }\n                }\n\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Disallow construction of dense arrays using the Array constructor\n * @author Matt DuVall <http://www.mattduvall.com/>\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noArrayConstructor = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `Array` constructors\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-array-constructor\"\n        },\n\n        schema: [],\n\n        messages: {\n            preferLiteral: \"The array literal notation [] is preferable.\"\n        }\n    },\n\n    create(context) {\n\n        /**\n         * Disallow construction of dense arrays using the Array constructor\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function check(node) {\n            if (\n                node.arguments.length !== 1 &&\n                node.callee.type === \"Identifier\" &&\n                node.callee.name === \"Array\"\n            ) {\n                context.report({ node, messageId: \"preferLiteral\" });\n            }\n        }\n\n        return {\n            CallExpression: check,\n            NewExpression: check\n        };\n\n    }\n};\n\n/**\n * @fileoverview disallow using an async function as a Promise executor\n * @author Teddy Katz\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noAsyncPromiseExecutor = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow using an async function as a Promise executor\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-async-promise-executor\"\n        },\n\n        fixable: null,\n        schema: [],\n        messages: {\n            async: \"Promise executor functions should not be async.\"\n        }\n    },\n\n    create(context) {\n        return {\n            \"NewExpression[callee.name='Promise'][arguments.0.async=true]\"(node) {\n                context.report({\n                    node: context.getSourceCode().getFirstToken(node.arguments[0], token => token.value === \"async\"),\n                    messageId: \"async\"\n                });\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to disallow uses of await inside of loops.\n * @author Nat Mote (nmote)\n */\n\n/**\n * Check whether it should stop traversing ancestors at the given node.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} `true` if it should stop traversing.\n */\nfunction isBoundary(node) {\n    const t = node.type;\n\n    return (\n        t === \"FunctionDeclaration\" ||\n        t === \"FunctionExpression\" ||\n        t === \"ArrowFunctionExpression\" ||\n\n        /*\n         * Don't report the await expressions on for-await-of loop since it's\n         * asynchronous iteration intentionally.\n         */\n        (t === \"ForOfStatement\" && node.await === true)\n    );\n}\n\n/**\n * Check whether the given node is in loop.\n * @param {ASTNode} node A node to check.\n * @param {ASTNode} parent A parent node to check.\n * @returns {boolean} `true` if the node is in loop.\n */\nfunction isLooped(node, parent) {\n    switch (parent.type) {\n        case \"ForStatement\":\n            return (\n                node === parent.test ||\n                node === parent.update ||\n                node === parent.body\n            );\n\n        case \"ForOfStatement\":\n        case \"ForInStatement\":\n            return node === parent.body;\n\n        case \"WhileStatement\":\n        case \"DoWhileStatement\":\n            return node === parent.test || node === parent.body;\n\n        default:\n            return false;\n    }\n}\n\nvar noAwaitInLoop = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow `await` inside of loops\",\n            category: \"Possible Errors\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-await-in-loop\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpectedAwait: \"Unexpected `await` inside a loop.\"\n        }\n    },\n    create(context) {\n\n        /**\n         * Validate an await expression.\n         * @param {ASTNode} awaitNode An AwaitExpression or ForOfStatement node to validate.\n         * @returns {void}\n         */\n        function validate(awaitNode) {\n            if (awaitNode.type === \"ForOfStatement\" && !awaitNode.await) {\n                return;\n            }\n\n            let node = awaitNode;\n            let parent = node.parent;\n\n            while (parent && !isBoundary(parent)) {\n                if (isLooped(node, parent)) {\n                    context.report({\n                        node: awaitNode,\n                        messageId: \"unexpectedAwait\"\n                    });\n                    return;\n                }\n                node = parent;\n                parent = parent.parent;\n            }\n        }\n\n        return {\n            AwaitExpression: validate,\n            ForOfStatement: validate\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag bitwise identifiers\n * @author Nicholas C. Zakas\n */\n\n/*\n *\n * Set of bitwise operators.\n *\n */\nconst BITWISE_OPERATORS = [\n    \"^\", \"|\", \"&\", \"<<\", \">>\", \">>>\",\n    \"^=\", \"|=\", \"&=\", \"<<=\", \">>=\", \">>>=\",\n    \"~\"\n];\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noBitwise = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow bitwise operators\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-bitwise\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allow: {\n                        type: \"array\",\n                        items: {\n                            enum: BITWISE_OPERATORS\n                        },\n                        uniqueItems: true\n                    },\n                    int32Hint: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            unexpected: \"Unexpected use of '{{operator}}'.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options[0] || {};\n        const allowed = options.allow || [];\n        const int32Hint = options.int32Hint === true;\n\n        /**\n         * Reports an unexpected use of a bitwise operator.\n         * @param   {ASTNode} node Node which contains the bitwise operator.\n         * @returns {void}\n         */\n        function report(node) {\n            context.report({ node, messageId: \"unexpected\", data: { operator: node.operator } });\n        }\n\n        /**\n         * Checks if the given node has a bitwise operator.\n         * @param   {ASTNode} node The node to check.\n         * @returns {boolean} Whether or not the node has a bitwise operator.\n         */\n        function hasBitwiseOperator(node) {\n            return BITWISE_OPERATORS.indexOf(node.operator) !== -1;\n        }\n\n        /**\n         * Checks if exceptions were provided, e.g. `{ allow: ['~', '|'] }`.\n         * @param   {ASTNode} node The node to check.\n         * @returns {boolean} Whether or not the node has a bitwise operator.\n         */\n        function allowedOperator(node) {\n            return allowed.indexOf(node.operator) !== -1;\n        }\n\n        /**\n         * Checks if the given bitwise operator is used for integer typecasting, i.e. \"|0\"\n         * @param   {ASTNode} node The node to check.\n         * @returns {boolean} whether the node is used in integer typecasting.\n         */\n        function isInt32Hint(node) {\n            return int32Hint && node.operator === \"|\" && node.right &&\n              node.right.type === \"Literal\" && node.right.value === 0;\n        }\n\n        /**\n         * Report if the given node contains a bitwise operator.\n         * @param   {ASTNode} node The node to check.\n         * @returns {void}\n         */\n        function checkNodeForBitwiseOperator(node) {\n            if (hasBitwiseOperator(node) && !allowedOperator(node) && !isInt32Hint(node)) {\n                report(node);\n            }\n        }\n\n        return {\n            AssignmentExpression: checkNodeForBitwiseOperator,\n            BinaryExpression: checkNodeForBitwiseOperator,\n            UnaryExpression: checkNodeForBitwiseOperator\n        };\n\n    }\n};\n\n/**\n * @fileoverview disallow use of the Buffer() constructor\n * @author Teddy Katz\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noBufferConstructor = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow use of the `Buffer()` constructor\",\n            category: \"Node.js and CommonJS\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-buffer-constructor\"\n        },\n\n        schema: [],\n\n        messages: {\n            deprecated: \"{{expr}} is deprecated. Use Buffer.from(), Buffer.alloc(), or Buffer.allocUnsafe() instead.\"\n        }\n    },\n\n    create(context) {\n\n        //----------------------------------------------------------------------\n        // Public\n        //----------------------------------------------------------------------\n\n        return {\n            \"CallExpression[callee.name='Buffer'], NewExpression[callee.name='Buffer']\"(node) {\n                context.report({\n                    node,\n                    messageId: \"deprecated\",\n                    data: { expr: node.type === \"CallExpression\" ? \"Buffer()\" : \"new Buffer()\" }\n                });\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag use of arguments.callee and arguments.caller.\n * @author Nicholas C. Zakas\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noCaller = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow the use of `arguments.caller` or `arguments.callee`\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-caller\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"Avoid arguments.{{prop}}.\"\n        }\n    },\n\n    create(context) {\n\n        return {\n\n            MemberExpression(node) {\n                const objectName = node.object.name,\n                    propertyName = node.property.name;\n\n                if (objectName === \"arguments\" && !node.computed && propertyName && propertyName.match(/^calle[er]$/u)) {\n                    context.report({ node, messageId: \"unexpected\", data: { prop: propertyName } });\n                }\n\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag use of an lexical declarations inside a case clause\n * @author Erik Arvidsson\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noCaseDeclarations = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow lexical declarations in case clauses\",\n            category: \"Best Practices\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-case-declarations\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"Unexpected lexical declaration in case block.\"\n        }\n    },\n\n    create(context) {\n\n        /**\n         * Checks whether or not a node is a lexical declaration.\n         * @param {ASTNode} node A direct child statement of a switch case.\n         * @returns {boolean} Whether or not the node is a lexical declaration.\n         */\n        function isLexicalDeclaration(node) {\n            switch (node.type) {\n                case \"FunctionDeclaration\":\n                case \"ClassDeclaration\":\n                    return true;\n                case \"VariableDeclaration\":\n                    return node.kind !== \"var\";\n                default:\n                    return false;\n            }\n        }\n\n        return {\n            SwitchCase(node) {\n                for (let i = 0; i < node.consequent.length; i++) {\n                    const statement = node.consequent[i];\n\n                    if (isLexicalDeclaration(statement)) {\n                        context.report({\n                            node: statement,\n                            messageId: \"unexpected\"\n                        });\n                    }\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noCatchShadow = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `catch` clause parameters from shadowing variables in the outer scope\",\n            category: \"Variables\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-catch-shadow\"\n        },\n\n        replacedBy: [\"no-shadow\"],\n\n        deprecated: true,\n        schema: [],\n\n        messages: {\n            mutable: \"Value of '{{name}}' may be overwritten in IE 8 and earlier.\"\n        }\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Check if the parameters are been shadowed\n         * @param {Object} scope current scope\n         * @param {string} name parameter name\n         * @returns {boolean} True is its been shadowed\n         */\n        function paramIsShadowing(scope, name) {\n            return astUtils$1.getVariableByName(scope, name) !== null;\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n\n            \"CatchClause[param!=null]\"(node) {\n                let scope = context.getScope();\n\n                /*\n                 * When ecmaVersion >= 6, CatchClause creates its own scope\n                 * so start from one upper scope to exclude the current node\n                 */\n                if (scope.block === node) {\n                    scope = scope.upper;\n                }\n\n                if (paramIsShadowing(scope, node.param.name)) {\n                    context.report({ node, messageId: \"mutable\", data: { name: node.param.name } });\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noClassAssign = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow reassigning class members\",\n            category: \"ECMAScript 6\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-class-assign\"\n        },\n\n        schema: [],\n\n        messages: {\n            class: \"'{{name}}' is a class.\"\n        }\n    },\n\n    create(context) {\n\n        /**\n         * Finds and reports references that are non initializer and writable.\n         * @param {Variable} variable A variable to check.\n         * @returns {void}\n         */\n        function checkVariable(variable) {\n            astUtils$1.getModifyingReferences(variable.references).forEach(reference => {\n                context.report({ node: reference.identifier, messageId: \"class\", data: { name: reference.identifier.name } });\n\n            });\n        }\n\n        /**\n         * Finds and reports references that are non initializer and writable.\n         * @param {ASTNode} node A ClassDeclaration/ClassExpression node to check.\n         * @returns {void}\n         */\n        function checkForClass(node) {\n            context.getDeclaredVariables(node).forEach(checkVariable);\n        }\n\n        return {\n            ClassDeclaration: checkForClass,\n            ClassExpression: checkForClass\n        };\n\n    }\n};\n\n/**\n * @fileoverview The rule should warn against code that tries to compare against -0.\n * @author Aladdin-ADD <hh_2013@foxmail.com>\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noCompareNegZero = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow comparing against -0\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-compare-neg-zero\"\n        },\n\n        fixable: null,\n        schema: [],\n\n        messages: {\n            unexpected: \"Do not use the '{{operator}}' operator to compare against -0.\"\n        }\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Checks a given node is -0\n         * @param {ASTNode} node A node to check.\n         * @returns {boolean} `true` if the node is -0.\n         */\n        function isNegZero(node) {\n            return node.type === \"UnaryExpression\" && node.operator === \"-\" && node.argument.type === \"Literal\" && node.argument.value === 0;\n        }\n        const OPERATORS_TO_CHECK = new Set([\">\", \">=\", \"<\", \"<=\", \"==\", \"===\", \"!=\", \"!==\"]);\n\n        return {\n            BinaryExpression(node) {\n                if (OPERATORS_TO_CHECK.has(node.operator)) {\n                    if (isNegZero(node.left) || isNegZero(node.right)) {\n                        context.report({\n                            node,\n                            messageId: \"unexpected\",\n                            data: { operator: node.operator }\n                        });\n                    }\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst TEST_CONDITION_PARENT_TYPES = new Set([\"IfStatement\", \"WhileStatement\", \"DoWhileStatement\", \"ForStatement\", \"ConditionalExpression\"]);\n\nconst NODE_DESCRIPTIONS = {\n    DoWhileStatement: \"a 'do...while' statement\",\n    ForStatement: \"a 'for' statement\",\n    IfStatement: \"an 'if' statement\",\n    WhileStatement: \"a 'while' statement\"\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noCondAssign = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow assignment operators in conditional expressions\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-cond-assign\"\n        },\n\n        schema: [\n            {\n                enum: [\"except-parens\", \"always\"]\n            }\n        ],\n\n        messages: {\n            unexpected: \"Unexpected assignment within {{type}}.\",\n\n            // must match JSHint's error message\n            missing: \"Expected a conditional expression and instead saw an assignment.\"\n        }\n    },\n\n    create(context) {\n\n        const prohibitAssign = (context.options[0] || \"except-parens\");\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Check whether an AST node is the test expression for a conditional statement.\n         * @param {!Object} node The node to test.\n         * @returns {boolean} `true` if the node is the text expression for a conditional statement; otherwise, `false`.\n         */\n        function isConditionalTestExpression(node) {\n            return node.parent &&\n                TEST_CONDITION_PARENT_TYPES.has(node.parent.type) &&\n                node === node.parent.test;\n        }\n\n        /**\n         * Given an AST node, perform a bottom-up search for the first ancestor that represents a conditional statement.\n         * @param {!Object} node The node to use at the start of the search.\n         * @returns {?Object} The closest ancestor node that represents a conditional statement.\n         */\n        function findConditionalAncestor(node) {\n            let currentAncestor = node;\n\n            do {\n                if (isConditionalTestExpression(currentAncestor)) {\n                    return currentAncestor.parent;\n                }\n            } while ((currentAncestor = currentAncestor.parent) && !astUtils$1.isFunction(currentAncestor));\n\n            return null;\n        }\n\n        /**\n         * Check whether the code represented by an AST node is enclosed in two sets of parentheses.\n         * @param {!Object} node The node to test.\n         * @returns {boolean} `true` if the code is enclosed in two sets of parentheses; otherwise, `false`.\n         */\n        function isParenthesisedTwice(node) {\n            const previousToken = sourceCode.getTokenBefore(node, 1),\n                nextToken = sourceCode.getTokenAfter(node, 1);\n\n            return astUtils$1.isParenthesised(sourceCode, node) &&\n                previousToken && astUtils$1.isOpeningParenToken(previousToken) && previousToken.range[1] <= node.range[0] &&\n                astUtils$1.isClosingParenToken(nextToken) && nextToken.range[0] >= node.range[1];\n        }\n\n        /**\n         * Check a conditional statement's test expression for top-level assignments that are not enclosed in parentheses.\n         * @param {!Object} node The node for the conditional statement.\n         * @returns {void}\n         */\n        function testForAssign(node) {\n            if (node.test &&\n                (node.test.type === \"AssignmentExpression\") &&\n                (node.type === \"ForStatement\"\n                    ? !astUtils$1.isParenthesised(sourceCode, node.test)\n                    : !isParenthesisedTwice(node.test)\n                )\n            ) {\n\n                context.report({\n                    node: node.test,\n                    messageId: \"missing\"\n                });\n            }\n        }\n\n        /**\n         * Check whether an assignment expression is descended from a conditional statement's test expression.\n         * @param {!Object} node The node for the assignment expression.\n         * @returns {void}\n         */\n        function testForConditionalAncestor(node) {\n            const ancestor = findConditionalAncestor(node);\n\n            if (ancestor) {\n                context.report({\n                    node,\n                    messageId: \"unexpected\",\n                    data: {\n                        type: NODE_DESCRIPTIONS[ancestor.type] || ancestor.type\n                    }\n                });\n            }\n        }\n\n        if (prohibitAssign === \"always\") {\n            return {\n                AssignmentExpression: testForConditionalAncestor\n            };\n        }\n\n        return {\n            DoWhileStatement: testForAssign,\n            ForStatement: testForAssign,\n            IfStatement: testForAssign,\n            WhileStatement: testForAssign,\n            ConditionalExpression: testForAssign\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not a node is a conditional expression.\n * @param {ASTNode} node node to test\n * @returns {boolean} `true` if the node is a conditional expression.\n */\nfunction isConditional(node) {\n    return node && node.type === \"ConditionalExpression\";\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noConfusingArrow = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow arrow functions where they could be confused with comparisons\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-confusing-arrow\"\n        },\n\n        fixable: \"code\",\n\n        schema: [{\n            type: \"object\",\n            properties: {\n                allowParens: { type: \"boolean\", default: true }\n            },\n            additionalProperties: false\n        }],\n\n        messages: {\n            confusing: \"Arrow function used ambiguously with a conditional expression.\"\n        }\n    },\n\n    create(context) {\n        const config = context.options[0] || {};\n        const allowParens = config.allowParens || (config.allowParens === void 0);\n        const sourceCode = context.getSourceCode();\n\n\n        /**\n         * Reports if an arrow function contains an ambiguous conditional.\n         * @param {ASTNode} node A node to check and report.\n         * @returns {void}\n         */\n        function checkArrowFunc(node) {\n            const body = node.body;\n\n            if (isConditional(body) && !(allowParens && astUtils$1.isParenthesised(sourceCode, body))) {\n                context.report({\n                    node,\n                    messageId: \"confusing\",\n                    fix(fixer) {\n\n                        // if `allowParens` is not set to true dont bother wrapping in parens\n                        return allowParens && fixer.replaceText(node.body, `(${sourceCode.getText(node.body)})`);\n                    }\n                });\n            }\n        }\n\n        return {\n            ArrowFunctionExpression: checkArrowFunc\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noConsole = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow the use of `console`\",\n            category: \"Possible Errors\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-console\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allow: {\n                        type: \"array\",\n                        items: {\n                            type: \"string\"\n                        },\n                        minItems: 1,\n                        uniqueItems: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            unexpected: \"Unexpected console statement.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options[0] || {};\n        const allowed = options.allow || [];\n\n        /**\n         * Checks whether the given reference is 'console' or not.\n         * @param {eslint-scope.Reference} reference The reference to check.\n         * @returns {boolean} `true` if the reference is 'console'.\n         */\n        function isConsole(reference) {\n            const id = reference.identifier;\n\n            return id && id.name === \"console\";\n        }\n\n        /**\n         * Checks whether the property name of the given MemberExpression node\n         * is allowed by options or not.\n         * @param {ASTNode} node The MemberExpression node to check.\n         * @returns {boolean} `true` if the property name of the node is allowed.\n         */\n        function isAllowed(node) {\n            const propertyName = astUtils$1.getStaticPropertyName(node);\n\n            return propertyName && allowed.indexOf(propertyName) !== -1;\n        }\n\n        /**\n         * Checks whether the given reference is a member access which is not\n         * allowed by options or not.\n         * @param {eslint-scope.Reference} reference The reference to check.\n         * @returns {boolean} `true` if the reference is a member access which\n         *      is not allowed by options.\n         */\n        function isMemberAccessExceptAllowed(reference) {\n            const node = reference.identifier;\n            const parent = node.parent;\n\n            return (\n                parent.type === \"MemberExpression\" &&\n                parent.object === node &&\n                !isAllowed(parent)\n            );\n        }\n\n        /**\n         * Reports the given reference as a violation.\n         * @param {eslint-scope.Reference} reference The reference to report.\n         * @returns {void}\n         */\n        function report(reference) {\n            const node = reference.identifier.parent;\n\n            context.report({\n                node,\n                loc: node.loc,\n                messageId: \"unexpected\"\n            });\n        }\n\n        return {\n            \"Program:exit\"() {\n                const scope = context.getScope();\n                const consoleVar = astUtils$1.getVariableByName(scope, \"console\");\n                const shadowed = consoleVar && consoleVar.defs.length > 0;\n\n                /*\n                 * 'scope.through' includes all references to undefined\n                 * variables. If the variable 'console' is not defined, it uses\n                 * 'scope.through'.\n                 */\n                const references = consoleVar\n                    ? consoleVar.references\n                    : scope.through.filter(isConsole);\n\n                if (!shadowed) {\n                    references\n                        .filter(isMemberAccessExceptAllowed)\n                        .forEach(report);\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noConstAssign = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow reassigning `const` variables\",\n            category: \"ECMAScript 6\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-const-assign\"\n        },\n\n        schema: [],\n\n        messages: {\n            const: \"'{{name}}' is constant.\"\n        }\n    },\n\n    create(context) {\n\n        /**\n         * Finds and reports references that are non initializer and writable.\n         * @param {Variable} variable A variable to check.\n         * @returns {void}\n         */\n        function checkVariable(variable) {\n            astUtils$1.getModifyingReferences(variable.references).forEach(reference => {\n                context.report({ node: reference.identifier, messageId: \"const\", data: { name: reference.identifier.name } });\n            });\n        }\n\n        return {\n            VariableDeclaration(node) {\n                if (node.kind === \"const\") {\n                    context.getDeclaredVariables(node).forEach(checkVariable);\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag use constant conditions\n * @author Christian Schulz <http://rndm.de>\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst EQUALITY_OPERATORS = [\"===\", \"!==\", \"==\", \"!=\"];\nconst RELATIONAL_OPERATORS = [\">\", \"<\", \">=\", \"<=\", \"in\", \"instanceof\"];\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noConstantCondition = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow constant expressions in conditions\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-constant-condition\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    checkLoops: {\n                        type: \"boolean\",\n                        default: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            unexpected: \"Unexpected constant condition.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options[0] || {},\n            checkLoops = options.checkLoops !== false,\n            loopSetStack = [];\n\n        let loopsInCurrentScope = new Set();\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n\n        /**\n         * Checks if a branch node of LogicalExpression short circuits the whole condition\n         * @param {ASTNode} node The branch of main condition which needs to be checked\n         * @param {string} operator The operator of the main LogicalExpression.\n         * @returns {boolean} true when condition short circuits whole condition\n         */\n        function isLogicalIdentity(node, operator) {\n            switch (node.type) {\n                case \"Literal\":\n                    return (operator === \"||\" && node.value === true) ||\n                           (operator === \"&&\" && node.value === false);\n\n                case \"UnaryExpression\":\n                    return (operator === \"&&\" && node.operator === \"void\");\n\n                case \"LogicalExpression\":\n                    return isLogicalIdentity(node.left, node.operator) ||\n                             isLogicalIdentity(node.right, node.operator);\n\n                // no default\n            }\n            return false;\n        }\n\n        /**\n         * Checks if a node has a constant truthiness value.\n         * @param {ASTNode} node The AST node to check.\n         * @param {boolean} inBooleanPosition `false` if checking branch of a condition.\n         *  `true` in all other cases\n         * @returns {Bool} true when node's truthiness is constant\n         * @private\n         */\n        function isConstant(node, inBooleanPosition) {\n            switch (node.type) {\n                case \"Literal\":\n                case \"ArrowFunctionExpression\":\n                case \"FunctionExpression\":\n                case \"ObjectExpression\":\n                case \"ArrayExpression\":\n                    return true;\n\n                case \"UnaryExpression\":\n                    if (node.operator === \"void\") {\n                        return true;\n                    }\n\n                    return (node.operator === \"typeof\" && inBooleanPosition) ||\n                        isConstant(node.argument, true);\n\n                case \"BinaryExpression\":\n                    return isConstant(node.left, false) &&\n                            isConstant(node.right, false) &&\n                            node.operator !== \"in\";\n\n                case \"LogicalExpression\": {\n                    const isLeftConstant = isConstant(node.left, inBooleanPosition);\n                    const isRightConstant = isConstant(node.right, inBooleanPosition);\n                    const isLeftShortCircuit = (isLeftConstant && isLogicalIdentity(node.left, node.operator));\n                    const isRightShortCircuit = (isRightConstant && isLogicalIdentity(node.right, node.operator));\n\n                    return (isLeftConstant && isRightConstant) ||\n                        (\n\n                            // in the case of an \"OR\", we need to know if the right constant value is truthy\n                            node.operator === \"||\" &&\n                            isRightConstant &&\n                            node.right.value &&\n                            (\n                                !node.parent ||\n                                node.parent.type !== \"BinaryExpression\" ||\n                                !(EQUALITY_OPERATORS.includes(node.parent.operator) || RELATIONAL_OPERATORS.includes(node.parent.operator))\n                            )\n                        ) ||\n                        isLeftShortCircuit ||\n                        isRightShortCircuit;\n                }\n\n                case \"AssignmentExpression\":\n                    return (node.operator === \"=\") && isConstant(node.right, inBooleanPosition);\n\n                case \"SequenceExpression\":\n                    return isConstant(node.expressions[node.expressions.length - 1], inBooleanPosition);\n\n                // no default\n            }\n            return false;\n        }\n\n        /**\n         * Tracks when the given node contains a constant condition.\n         * @param {ASTNode} node The AST node to check.\n         * @returns {void}\n         * @private\n         */\n        function trackConstantConditionLoop(node) {\n            if (node.test && isConstant(node.test, true)) {\n                loopsInCurrentScope.add(node);\n            }\n        }\n\n        /**\n         * Reports when the set contains the given constant condition node\n         * @param {ASTNode} node The AST node to check.\n         * @returns {void}\n         * @private\n         */\n        function checkConstantConditionLoopInSet(node) {\n            if (loopsInCurrentScope.has(node)) {\n                loopsInCurrentScope.delete(node);\n                context.report({ node: node.test, messageId: \"unexpected\" });\n            }\n        }\n\n        /**\n         * Reports when the given node contains a constant condition.\n         * @param {ASTNode} node The AST node to check.\n         * @returns {void}\n         * @private\n         */\n        function reportIfConstant(node) {\n            if (node.test && isConstant(node.test, true)) {\n                context.report({ node: node.test, messageId: \"unexpected\" });\n            }\n        }\n\n        /**\n         * Stores current set of constant loops in loopSetStack temporarily\n         * and uses a new set to track constant loops\n         * @returns {void}\n         * @private\n         */\n        function enterFunction() {\n            loopSetStack.push(loopsInCurrentScope);\n            loopsInCurrentScope = new Set();\n        }\n\n        /**\n         * Reports when the set still contains stored constant conditions\n         * @returns {void}\n         * @private\n         */\n        function exitFunction() {\n            loopsInCurrentScope = loopSetStack.pop();\n        }\n\n        /**\n         * Checks node when checkLoops option is enabled\n         * @param {ASTNode} node The AST node to check.\n         * @returns {void}\n         * @private\n         */\n        function checkLoop(node) {\n            if (checkLoops) {\n                trackConstantConditionLoop(node);\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            ConditionalExpression: reportIfConstant,\n            IfStatement: reportIfConstant,\n            WhileStatement: checkLoop,\n            \"WhileStatement:exit\": checkConstantConditionLoopInSet,\n            DoWhileStatement: checkLoop,\n            \"DoWhileStatement:exit\": checkConstantConditionLoopInSet,\n            ForStatement: checkLoop,\n            \"ForStatement > .test\": node => checkLoop(node.parent),\n            \"ForStatement:exit\": checkConstantConditionLoopInSet,\n            FunctionDeclaration: enterFunction,\n            \"FunctionDeclaration:exit\": exitFunction,\n            FunctionExpression: enterFunction,\n            \"FunctionExpression:exit\": exitFunction,\n            YieldExpression: () => loopsInCurrentScope.clear()\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to disallow returning value from constructor.\n * @author Pig Fang <https://github.com/g-plane>\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noConstructorReturn = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow returning value from constructor\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-constructor-return\"\n        },\n\n        schema: {},\n\n        fixable: null,\n\n        messages: {\n            unexpected: \"Unexpected return statement in constructor.\"\n        }\n    },\n\n    create(context) {\n        const stack = [];\n\n        return {\n            onCodePathStart(_, node) {\n                stack.push(node);\n            },\n            onCodePathEnd() {\n                stack.pop();\n            },\n            ReturnStatement(node) {\n                const last = stack[stack.length - 1];\n\n                if (!last.parent) {\n                    return;\n                }\n\n                if (\n                    last.parent.type === \"MethodDefinition\" &&\n                    last.parent.kind === \"constructor\" &&\n                    (node.parent.parent === last || node.argument)\n                ) {\n                    context.report({\n                        node,\n                        messageId: \"unexpected\"\n                    });\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag use of continue statement\n * @author Borislav Zhivkov\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noContinue = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `continue` statements\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-continue\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"Unexpected use of continue statement.\"\n        }\n    },\n\n    create(context) {\n\n        return {\n            ContinueStatement(node) {\n                context.report({ node, messageId: \"unexpected\" });\n            }\n        };\n\n    }\n};\n\n/*! @author Toru Nagashima <https://github.com/mysticatea> */\n\n\nvar ast$1 = /*#__PURE__*/Object.freeze({\n\n});\n\nfunction isIdStart(cp) {\n    if (cp < 0x41)\n        return false;\n    if (cp < 0x5b)\n        return true;\n    if (cp < 0x61)\n        return false;\n    if (cp < 0x7b)\n        return true;\n    return isLargeIdStart(cp);\n}\nfunction isIdContinue(cp) {\n    if (cp < 0x30)\n        return false;\n    if (cp < 0x3a)\n        return true;\n    if (cp < 0x41)\n        return false;\n    if (cp < 0x5b)\n        return true;\n    if (cp === 0x5f)\n        return true;\n    if (cp < 0x61)\n        return false;\n    if (cp < 0x7b)\n        return true;\n    return isLargeIdStart(cp) || isLargeIdContinue(cp);\n}\nfunction isLargeIdStart(cp) {\n    if (cp < 0x30a1) {\n        if (cp < 0xec0) {\n            if (cp < 0xa35) {\n                if (cp < 0x6e5) {\n                    if (cp < 0x37a) {\n                        if (cp < 0x294) {\n                            if (cp < 0xf8) {\n                                if (cp === 0xaa)\n                                    return true;\n                                if (cp === 0xb5)\n                                    return true;\n                                if (cp === 0xba)\n                                    return true;\n                                if (cp < 0xc0)\n                                    return false;\n                                if (cp < 0xd7)\n                                    return true;\n                                if (cp < 0xd8)\n                                    return false;\n                                if (cp < 0xf7)\n                                    return true;\n                                return false;\n                            }\n                            if (cp < 0x1bb)\n                                return true;\n                            if (cp === 0x1bb)\n                                return true;\n                            if (cp < 0x1bc)\n                                return false;\n                            if (cp < 0x1c0)\n                                return true;\n                            if (cp < 0x1c0)\n                                return false;\n                            if (cp < 0x1c4)\n                                return true;\n                            if (cp < 0x1c4)\n                                return false;\n                            if (cp < 0x294)\n                                return true;\n                            return false;\n                        }\n                        if (cp < 0x2ec) {\n                            if (cp === 0x294)\n                                return true;\n                            if (cp < 0x295)\n                                return false;\n                            if (cp < 0x2b0)\n                                return true;\n                            if (cp < 0x2b0)\n                                return false;\n                            if (cp < 0x2c2)\n                                return true;\n                            if (cp < 0x2c6)\n                                return false;\n                            if (cp < 0x2d2)\n                                return true;\n                            if (cp < 0x2e0)\n                                return false;\n                            if (cp < 0x2e5)\n                                return true;\n                            return false;\n                        }\n                        if (cp === 0x2ec)\n                            return true;\n                        if (cp === 0x2ee)\n                            return true;\n                        if (cp < 0x370)\n                            return false;\n                        if (cp < 0x374)\n                            return true;\n                        if (cp === 0x374)\n                            return true;\n                        if (cp < 0x376)\n                            return false;\n                        if (cp < 0x378)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x531) {\n                        if (cp < 0x38c) {\n                            if (cp === 0x37a)\n                                return true;\n                            if (cp < 0x37b)\n                                return false;\n                            if (cp < 0x37e)\n                                return true;\n                            if (cp === 0x37f)\n                                return true;\n                            if (cp === 0x386)\n                                return true;\n                            if (cp < 0x388)\n                                return false;\n                            if (cp < 0x38b)\n                                return true;\n                            return false;\n                        }\n                        if (cp === 0x38c)\n                            return true;\n                        if (cp < 0x38e)\n                            return false;\n                        if (cp < 0x3a2)\n                            return true;\n                        if (cp < 0x3a3)\n                            return false;\n                        if (cp < 0x3f6)\n                            return true;\n                        if (cp < 0x3f7)\n                            return false;\n                        if (cp < 0x482)\n                            return true;\n                        if (cp < 0x48a)\n                            return false;\n                        if (cp < 0x530)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x620) {\n                        if (cp < 0x531)\n                            return false;\n                        if (cp < 0x557)\n                            return true;\n                        if (cp === 0x559)\n                            return true;\n                        if (cp < 0x560)\n                            return false;\n                        if (cp < 0x589)\n                            return true;\n                        if (cp < 0x5d0)\n                            return false;\n                        if (cp < 0x5eb)\n                            return true;\n                        if (cp < 0x5ef)\n                            return false;\n                        if (cp < 0x5f3)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x640)\n                        return true;\n                    if (cp === 0x640)\n                        return true;\n                    if (cp < 0x641)\n                        return false;\n                    if (cp < 0x64b)\n                        return true;\n                    if (cp < 0x66e)\n                        return false;\n                    if (cp < 0x670)\n                        return true;\n                    if (cp < 0x671)\n                        return false;\n                    if (cp < 0x6d4)\n                        return true;\n                    if (cp === 0x6d5)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x950) {\n                    if (cp < 0x7fa) {\n                        if (cp < 0x712) {\n                            if (cp < 0x6e5)\n                                return false;\n                            if (cp < 0x6e7)\n                                return true;\n                            if (cp < 0x6ee)\n                                return false;\n                            if (cp < 0x6f0)\n                                return true;\n                            if (cp < 0x6fa)\n                                return false;\n                            if (cp < 0x6fd)\n                                return true;\n                            if (cp === 0x6ff)\n                                return true;\n                            if (cp === 0x710)\n                                return true;\n                            return false;\n                        }\n                        if (cp < 0x730)\n                            return true;\n                        if (cp < 0x74d)\n                            return false;\n                        if (cp < 0x7a6)\n                            return true;\n                        if (cp === 0x7b1)\n                            return true;\n                        if (cp < 0x7ca)\n                            return false;\n                        if (cp < 0x7eb)\n                            return true;\n                        if (cp < 0x7f4)\n                            return false;\n                        if (cp < 0x7f6)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x840) {\n                        if (cp === 0x7fa)\n                            return true;\n                        if (cp < 0x800)\n                            return false;\n                        if (cp < 0x816)\n                            return true;\n                        if (cp === 0x81a)\n                            return true;\n                        if (cp === 0x824)\n                            return true;\n                        if (cp === 0x828)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x859)\n                        return true;\n                    if (cp < 0x860)\n                        return false;\n                    if (cp < 0x86b)\n                        return true;\n                    if (cp < 0x8a0)\n                        return false;\n                    if (cp < 0x8b5)\n                        return true;\n                    if (cp < 0x8b6)\n                        return false;\n                    if (cp < 0x8be)\n                        return true;\n                    if (cp < 0x904)\n                        return false;\n                    if (cp < 0x93a)\n                        return true;\n                    if (cp === 0x93d)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x9bd) {\n                    if (cp < 0x98f) {\n                        if (cp === 0x950)\n                            return true;\n                        if (cp < 0x958)\n                            return false;\n                        if (cp < 0x962)\n                            return true;\n                        if (cp === 0x971)\n                            return true;\n                        if (cp < 0x972)\n                            return false;\n                        if (cp < 0x981)\n                            return true;\n                        if (cp < 0x985)\n                            return false;\n                        if (cp < 0x98d)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x991)\n                        return true;\n                    if (cp < 0x993)\n                        return false;\n                    if (cp < 0x9a9)\n                        return true;\n                    if (cp < 0x9aa)\n                        return false;\n                    if (cp < 0x9b1)\n                        return true;\n                    if (cp === 0x9b2)\n                        return true;\n                    if (cp < 0x9b6)\n                        return false;\n                    if (cp < 0x9ba)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x9fc) {\n                    if (cp === 0x9bd)\n                        return true;\n                    if (cp === 0x9ce)\n                        return true;\n                    if (cp < 0x9dc)\n                        return false;\n                    if (cp < 0x9de)\n                        return true;\n                    if (cp < 0x9df)\n                        return false;\n                    if (cp < 0x9e2)\n                        return true;\n                    if (cp < 0x9f0)\n                        return false;\n                    if (cp < 0x9f2)\n                        return true;\n                    return false;\n                }\n                if (cp === 0x9fc)\n                    return true;\n                if (cp < 0xa05)\n                    return false;\n                if (cp < 0xa0b)\n                    return true;\n                if (cp < 0xa0f)\n                    return false;\n                if (cp < 0xa11)\n                    return true;\n                if (cp < 0xa13)\n                    return false;\n                if (cp < 0xa29)\n                    return true;\n                if (cp < 0xa2a)\n                    return false;\n                if (cp < 0xa31)\n                    return true;\n                if (cp < 0xa32)\n                    return false;\n                if (cp < 0xa34)\n                    return true;\n                return false;\n            }\n            if (cp < 0xc60) {\n                if (cp < 0xb3d) {\n                    if (cp < 0xab5) {\n                        if (cp < 0xa85) {\n                            if (cp < 0xa35)\n                                return false;\n                            if (cp < 0xa37)\n                                return true;\n                            if (cp < 0xa38)\n                                return false;\n                            if (cp < 0xa3a)\n                                return true;\n                            if (cp < 0xa59)\n                                return false;\n                            if (cp < 0xa5d)\n                                return true;\n                            if (cp === 0xa5e)\n                                return true;\n                            if (cp < 0xa72)\n                                return false;\n                            if (cp < 0xa75)\n                                return true;\n                            return false;\n                        }\n                        if (cp < 0xa8e)\n                            return true;\n                        if (cp < 0xa8f)\n                            return false;\n                        if (cp < 0xa92)\n                            return true;\n                        if (cp < 0xa93)\n                            return false;\n                        if (cp < 0xaa9)\n                            return true;\n                        if (cp < 0xaaa)\n                            return false;\n                        if (cp < 0xab1)\n                            return true;\n                        if (cp < 0xab2)\n                            return false;\n                        if (cp < 0xab4)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0xb05) {\n                        if (cp < 0xab5)\n                            return false;\n                        if (cp < 0xaba)\n                            return true;\n                        if (cp === 0xabd)\n                            return true;\n                        if (cp === 0xad0)\n                            return true;\n                        if (cp < 0xae0)\n                            return false;\n                        if (cp < 0xae2)\n                            return true;\n                        if (cp === 0xaf9)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0xb0d)\n                        return true;\n                    if (cp < 0xb0f)\n                        return false;\n                    if (cp < 0xb11)\n                        return true;\n                    if (cp < 0xb13)\n                        return false;\n                    if (cp < 0xb29)\n                        return true;\n                    if (cp < 0xb2a)\n                        return false;\n                    if (cp < 0xb31)\n                        return true;\n                    if (cp < 0xb32)\n                        return false;\n                    if (cp < 0xb34)\n                        return true;\n                    if (cp < 0xb35)\n                        return false;\n                    if (cp < 0xb3a)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xb9e) {\n                    if (cp < 0xb85) {\n                        if (cp === 0xb3d)\n                            return true;\n                        if (cp < 0xb5c)\n                            return false;\n                        if (cp < 0xb5e)\n                            return true;\n                        if (cp < 0xb5f)\n                            return false;\n                        if (cp < 0xb62)\n                            return true;\n                        if (cp === 0xb71)\n                            return true;\n                        if (cp === 0xb83)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0xb8b)\n                        return true;\n                    if (cp < 0xb8e)\n                        return false;\n                    if (cp < 0xb91)\n                        return true;\n                    if (cp < 0xb92)\n                        return false;\n                    if (cp < 0xb96)\n                        return true;\n                    if (cp < 0xb99)\n                        return false;\n                    if (cp < 0xb9b)\n                        return true;\n                    if (cp === 0xb9c)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xc05) {\n                    if (cp < 0xb9e)\n                        return false;\n                    if (cp < 0xba0)\n                        return true;\n                    if (cp < 0xba3)\n                        return false;\n                    if (cp < 0xba5)\n                        return true;\n                    if (cp < 0xba8)\n                        return false;\n                    if (cp < 0xbab)\n                        return true;\n                    if (cp < 0xbae)\n                        return false;\n                    if (cp < 0xbba)\n                        return true;\n                    if (cp === 0xbd0)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xc0d)\n                    return true;\n                if (cp < 0xc0e)\n                    return false;\n                if (cp < 0xc11)\n                    return true;\n                if (cp < 0xc12)\n                    return false;\n                if (cp < 0xc29)\n                    return true;\n                if (cp < 0xc2a)\n                    return false;\n                if (cp < 0xc3a)\n                    return true;\n                if (cp === 0xc3d)\n                    return true;\n                if (cp < 0xc58)\n                    return false;\n                if (cp < 0xc5b)\n                    return true;\n                return false;\n            }\n            if (cp < 0xdb3) {\n                if (cp < 0xcf1) {\n                    if (cp < 0xcaa) {\n                        if (cp < 0xc60)\n                            return false;\n                        if (cp < 0xc62)\n                            return true;\n                        if (cp === 0xc80)\n                            return true;\n                        if (cp < 0xc85)\n                            return false;\n                        if (cp < 0xc8d)\n                            return true;\n                        if (cp < 0xc8e)\n                            return false;\n                        if (cp < 0xc91)\n                            return true;\n                        if (cp < 0xc92)\n                            return false;\n                        if (cp < 0xca9)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0xcb4)\n                        return true;\n                    if (cp < 0xcb5)\n                        return false;\n                    if (cp < 0xcba)\n                        return true;\n                    if (cp === 0xcbd)\n                        return true;\n                    if (cp === 0xcde)\n                        return true;\n                    if (cp < 0xce0)\n                        return false;\n                    if (cp < 0xce2)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xd4e) {\n                    if (cp < 0xcf1)\n                        return false;\n                    if (cp < 0xcf3)\n                        return true;\n                    if (cp < 0xd05)\n                        return false;\n                    if (cp < 0xd0d)\n                        return true;\n                    if (cp < 0xd0e)\n                        return false;\n                    if (cp < 0xd11)\n                        return true;\n                    if (cp < 0xd12)\n                        return false;\n                    if (cp < 0xd3b)\n                        return true;\n                    if (cp === 0xd3d)\n                        return true;\n                    return false;\n                }\n                if (cp === 0xd4e)\n                    return true;\n                if (cp < 0xd54)\n                    return false;\n                if (cp < 0xd57)\n                    return true;\n                if (cp < 0xd5f)\n                    return false;\n                if (cp < 0xd62)\n                    return true;\n                if (cp < 0xd7a)\n                    return false;\n                if (cp < 0xd80)\n                    return true;\n                if (cp < 0xd85)\n                    return false;\n                if (cp < 0xd97)\n                    return true;\n                if (cp < 0xd9a)\n                    return false;\n                if (cp < 0xdb2)\n                    return true;\n                return false;\n            }\n            if (cp < 0xe8a) {\n                if (cp < 0xe40) {\n                    if (cp < 0xdb3)\n                        return false;\n                    if (cp < 0xdbc)\n                        return true;\n                    if (cp === 0xdbd)\n                        return true;\n                    if (cp < 0xdc0)\n                        return false;\n                    if (cp < 0xdc7)\n                        return true;\n                    if (cp < 0xe01)\n                        return false;\n                    if (cp < 0xe31)\n                        return true;\n                    if (cp < 0xe32)\n                        return false;\n                    if (cp < 0xe34)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xe46)\n                    return true;\n                if (cp === 0xe46)\n                    return true;\n                if (cp < 0xe81)\n                    return false;\n                if (cp < 0xe83)\n                    return true;\n                if (cp === 0xe84)\n                    return true;\n                if (cp < 0xe87)\n                    return false;\n                if (cp < 0xe89)\n                    return true;\n                return false;\n            }\n            if (cp < 0xea5) {\n                if (cp === 0xe8a)\n                    return true;\n                if (cp === 0xe8d)\n                    return true;\n                if (cp < 0xe94)\n                    return false;\n                if (cp < 0xe98)\n                    return true;\n                if (cp < 0xe99)\n                    return false;\n                if (cp < 0xea0)\n                    return true;\n                if (cp < 0xea1)\n                    return false;\n                if (cp < 0xea4)\n                    return true;\n                return false;\n            }\n            if (cp === 0xea5)\n                return true;\n            if (cp === 0xea7)\n                return true;\n            if (cp < 0xeaa)\n                return false;\n            if (cp < 0xeac)\n                return true;\n            if (cp < 0xead)\n                return false;\n            if (cp < 0xeb1)\n                return true;\n            if (cp < 0xeb2)\n                return false;\n            if (cp < 0xeb4)\n                return true;\n            if (cp === 0xebd)\n                return true;\n            return false;\n        }\n        if (cp < 0x1ce9) {\n            if (cp < 0x166f) {\n                if (cp < 0x10fd) {\n                    if (cp < 0x105a) {\n                        if (cp < 0xf49) {\n                            if (cp < 0xec0)\n                                return false;\n                            if (cp < 0xec5)\n                                return true;\n                            if (cp === 0xec6)\n                                return true;\n                            if (cp < 0xedc)\n                                return false;\n                            if (cp < 0xee0)\n                                return true;\n                            if (cp === 0xf00)\n                                return true;\n                            if (cp < 0xf40)\n                                return false;\n                            if (cp < 0xf48)\n                                return true;\n                            return false;\n                        }\n                        if (cp < 0xf6d)\n                            return true;\n                        if (cp < 0xf88)\n                            return false;\n                        if (cp < 0xf8d)\n                            return true;\n                        if (cp < 0x1000)\n                            return false;\n                        if (cp < 0x102b)\n                            return true;\n                        if (cp === 0x103f)\n                            return true;\n                        if (cp < 0x1050)\n                            return false;\n                        if (cp < 0x1056)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x108e) {\n                        if (cp < 0x105a)\n                            return false;\n                        if (cp < 0x105e)\n                            return true;\n                        if (cp === 0x1061)\n                            return true;\n                        if (cp < 0x1065)\n                            return false;\n                        if (cp < 0x1067)\n                            return true;\n                        if (cp < 0x106e)\n                            return false;\n                        if (cp < 0x1071)\n                            return true;\n                        if (cp < 0x1075)\n                            return false;\n                        if (cp < 0x1082)\n                            return true;\n                        return false;\n                    }\n                    if (cp === 0x108e)\n                        return true;\n                    if (cp < 0x10a0)\n                        return false;\n                    if (cp < 0x10c6)\n                        return true;\n                    if (cp === 0x10c7)\n                        return true;\n                    if (cp === 0x10cd)\n                        return true;\n                    if (cp < 0x10d0)\n                        return false;\n                    if (cp < 0x10fb)\n                        return true;\n                    if (cp === 0x10fc)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x12b8) {\n                    if (cp < 0x125a) {\n                        if (cp < 0x10fd)\n                            return false;\n                        if (cp < 0x1100)\n                            return true;\n                        if (cp < 0x1100)\n                            return false;\n                        if (cp < 0x1249)\n                            return true;\n                        if (cp < 0x124a)\n                            return false;\n                        if (cp < 0x124e)\n                            return true;\n                        if (cp < 0x1250)\n                            return false;\n                        if (cp < 0x1257)\n                            return true;\n                        if (cp === 0x1258)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x125e)\n                        return true;\n                    if (cp < 0x1260)\n                        return false;\n                    if (cp < 0x1289)\n                        return true;\n                    if (cp < 0x128a)\n                        return false;\n                    if (cp < 0x128e)\n                        return true;\n                    if (cp < 0x1290)\n                        return false;\n                    if (cp < 0x12b1)\n                        return true;\n                    if (cp < 0x12b2)\n                        return false;\n                    if (cp < 0x12b6)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x1312) {\n                    if (cp < 0x12b8)\n                        return false;\n                    if (cp < 0x12bf)\n                        return true;\n                    if (cp === 0x12c0)\n                        return true;\n                    if (cp < 0x12c2)\n                        return false;\n                    if (cp < 0x12c6)\n                        return true;\n                    if (cp < 0x12c8)\n                        return false;\n                    if (cp < 0x12d7)\n                        return true;\n                    if (cp < 0x12d8)\n                        return false;\n                    if (cp < 0x1311)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x1316)\n                    return true;\n                if (cp < 0x1318)\n                    return false;\n                if (cp < 0x135b)\n                    return true;\n                if (cp < 0x1380)\n                    return false;\n                if (cp < 0x1390)\n                    return true;\n                if (cp < 0x13a0)\n                    return false;\n                if (cp < 0x13f6)\n                    return true;\n                if (cp < 0x13f8)\n                    return false;\n                if (cp < 0x13fe)\n                    return true;\n                if (cp < 0x1401)\n                    return false;\n                if (cp < 0x166d)\n                    return true;\n                return false;\n            }\n            if (cp < 0x18b0) {\n                if (cp < 0x176e) {\n                    if (cp < 0x1700) {\n                        if (cp < 0x166f)\n                            return false;\n                        if (cp < 0x1680)\n                            return true;\n                        if (cp < 0x1681)\n                            return false;\n                        if (cp < 0x169b)\n                            return true;\n                        if (cp < 0x16a0)\n                            return false;\n                        if (cp < 0x16eb)\n                            return true;\n                        if (cp < 0x16ee)\n                            return false;\n                        if (cp < 0x16f1)\n                            return true;\n                        if (cp < 0x16f1)\n                            return false;\n                        if (cp < 0x16f9)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x170d)\n                        return true;\n                    if (cp < 0x170e)\n                        return false;\n                    if (cp < 0x1712)\n                        return true;\n                    if (cp < 0x1720)\n                        return false;\n                    if (cp < 0x1732)\n                        return true;\n                    if (cp < 0x1740)\n                        return false;\n                    if (cp < 0x1752)\n                        return true;\n                    if (cp < 0x1760)\n                        return false;\n                    if (cp < 0x176d)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x1843) {\n                    if (cp < 0x176e)\n                        return false;\n                    if (cp < 0x1771)\n                        return true;\n                    if (cp < 0x1780)\n                        return false;\n                    if (cp < 0x17b4)\n                        return true;\n                    if (cp === 0x17d7)\n                        return true;\n                    if (cp === 0x17dc)\n                        return true;\n                    if (cp < 0x1820)\n                        return false;\n                    if (cp < 0x1843)\n                        return true;\n                    return false;\n                }\n                if (cp === 0x1843)\n                    return true;\n                if (cp < 0x1844)\n                    return false;\n                if (cp < 0x1879)\n                    return true;\n                if (cp < 0x1880)\n                    return false;\n                if (cp < 0x1885)\n                    return true;\n                if (cp < 0x1885)\n                    return false;\n                if (cp < 0x1887)\n                    return true;\n                if (cp < 0x1887)\n                    return false;\n                if (cp < 0x18a9)\n                    return true;\n                if (cp === 0x18aa)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1b45) {\n                if (cp < 0x19b0) {\n                    if (cp < 0x18b0)\n                        return false;\n                    if (cp < 0x18f6)\n                        return true;\n                    if (cp < 0x1900)\n                        return false;\n                    if (cp < 0x191f)\n                        return true;\n                    if (cp < 0x1950)\n                        return false;\n                    if (cp < 0x196e)\n                        return true;\n                    if (cp < 0x1970)\n                        return false;\n                    if (cp < 0x1975)\n                        return true;\n                    if (cp < 0x1980)\n                        return false;\n                    if (cp < 0x19ac)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x19ca)\n                    return true;\n                if (cp < 0x1a00)\n                    return false;\n                if (cp < 0x1a17)\n                    return true;\n                if (cp < 0x1a20)\n                    return false;\n                if (cp < 0x1a55)\n                    return true;\n                if (cp === 0x1aa7)\n                    return true;\n                if (cp < 0x1b05)\n                    return false;\n                if (cp < 0x1b34)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1c4d) {\n                if (cp < 0x1b45)\n                    return false;\n                if (cp < 0x1b4c)\n                    return true;\n                if (cp < 0x1b83)\n                    return false;\n                if (cp < 0x1ba1)\n                    return true;\n                if (cp < 0x1bae)\n                    return false;\n                if (cp < 0x1bb0)\n                    return true;\n                if (cp < 0x1bba)\n                    return false;\n                if (cp < 0x1be6)\n                    return true;\n                if (cp < 0x1c00)\n                    return false;\n                if (cp < 0x1c24)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1c50)\n                return true;\n            if (cp < 0x1c5a)\n                return false;\n            if (cp < 0x1c78)\n                return true;\n            if (cp < 0x1c78)\n                return false;\n            if (cp < 0x1c7e)\n                return true;\n            if (cp < 0x1c80)\n                return false;\n            if (cp < 0x1c89)\n                return true;\n            if (cp < 0x1c90)\n                return false;\n            if (cp < 0x1cbb)\n                return true;\n            if (cp < 0x1cbd)\n                return false;\n            if (cp < 0x1cc0)\n                return true;\n            return false;\n        }\n        if (cp < 0x212f) {\n            if (cp < 0x1fc2) {\n                if (cp < 0x1f18) {\n                    if (cp < 0x1d6b) {\n                        if (cp < 0x1ce9)\n                            return false;\n                        if (cp < 0x1ced)\n                            return true;\n                        if (cp < 0x1cee)\n                            return false;\n                        if (cp < 0x1cf2)\n                            return true;\n                        if (cp < 0x1cf5)\n                            return false;\n                        if (cp < 0x1cf7)\n                            return true;\n                        if (cp < 0x1d00)\n                            return false;\n                        if (cp < 0x1d2c)\n                            return true;\n                        if (cp < 0x1d2c)\n                            return false;\n                        if (cp < 0x1d6b)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x1d78)\n                        return true;\n                    if (cp === 0x1d78)\n                        return true;\n                    if (cp < 0x1d79)\n                        return false;\n                    if (cp < 0x1d9b)\n                        return true;\n                    if (cp < 0x1d9b)\n                        return false;\n                    if (cp < 0x1dc0)\n                        return true;\n                    if (cp < 0x1e00)\n                        return false;\n                    if (cp < 0x1f16)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x1f5b) {\n                    if (cp < 0x1f18)\n                        return false;\n                    if (cp < 0x1f1e)\n                        return true;\n                    if (cp < 0x1f20)\n                        return false;\n                    if (cp < 0x1f46)\n                        return true;\n                    if (cp < 0x1f48)\n                        return false;\n                    if (cp < 0x1f4e)\n                        return true;\n                    if (cp < 0x1f50)\n                        return false;\n                    if (cp < 0x1f58)\n                        return true;\n                    if (cp === 0x1f59)\n                        return true;\n                    return false;\n                }\n                if (cp === 0x1f5b)\n                    return true;\n                if (cp === 0x1f5d)\n                    return true;\n                if (cp < 0x1f5f)\n                    return false;\n                if (cp < 0x1f7e)\n                    return true;\n                if (cp < 0x1f80)\n                    return false;\n                if (cp < 0x1fb5)\n                    return true;\n                if (cp < 0x1fb6)\n                    return false;\n                if (cp < 0x1fbd)\n                    return true;\n                if (cp === 0x1fbe)\n                    return true;\n                return false;\n            }\n            if (cp < 0x2102) {\n                if (cp < 0x1ff2) {\n                    if (cp < 0x1fc2)\n                        return false;\n                    if (cp < 0x1fc5)\n                        return true;\n                    if (cp < 0x1fc6)\n                        return false;\n                    if (cp < 0x1fcd)\n                        return true;\n                    if (cp < 0x1fd0)\n                        return false;\n                    if (cp < 0x1fd4)\n                        return true;\n                    if (cp < 0x1fd6)\n                        return false;\n                    if (cp < 0x1fdc)\n                        return true;\n                    if (cp < 0x1fe0)\n                        return false;\n                    if (cp < 0x1fed)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x1ff5)\n                    return true;\n                if (cp < 0x1ff6)\n                    return false;\n                if (cp < 0x1ffd)\n                    return true;\n                if (cp === 0x2071)\n                    return true;\n                if (cp === 0x207f)\n                    return true;\n                if (cp < 0x2090)\n                    return false;\n                if (cp < 0x209d)\n                    return true;\n                return false;\n            }\n            if (cp < 0x2119) {\n                if (cp === 0x2102)\n                    return true;\n                if (cp === 0x2107)\n                    return true;\n                if (cp < 0x210a)\n                    return false;\n                if (cp < 0x2114)\n                    return true;\n                if (cp === 0x2115)\n                    return true;\n                if (cp === 0x2118)\n                    return true;\n                return false;\n            }\n            if (cp < 0x211e)\n                return true;\n            if (cp === 0x2124)\n                return true;\n            if (cp === 0x2126)\n                return true;\n            if (cp === 0x2128)\n                return true;\n            if (cp < 0x212a)\n                return false;\n            if (cp < 0x212e)\n                return true;\n            if (cp === 0x212e)\n                return true;\n            return false;\n        }\n        if (cp < 0x2d80) {\n            if (cp < 0x2c30) {\n                if (cp < 0x214e) {\n                    if (cp < 0x212f)\n                        return false;\n                    if (cp < 0x2135)\n                        return true;\n                    if (cp < 0x2135)\n                        return false;\n                    if (cp < 0x2139)\n                        return true;\n                    if (cp === 0x2139)\n                        return true;\n                    if (cp < 0x213c)\n                        return false;\n                    if (cp < 0x2140)\n                        return true;\n                    if (cp < 0x2145)\n                        return false;\n                    if (cp < 0x214a)\n                        return true;\n                    return false;\n                }\n                if (cp === 0x214e)\n                    return true;\n                if (cp < 0x2160)\n                    return false;\n                if (cp < 0x2183)\n                    return true;\n                if (cp < 0x2183)\n                    return false;\n                if (cp < 0x2185)\n                    return true;\n                if (cp < 0x2185)\n                    return false;\n                if (cp < 0x2189)\n                    return true;\n                if (cp < 0x2c00)\n                    return false;\n                if (cp < 0x2c2f)\n                    return true;\n                return false;\n            }\n            if (cp < 0x2cf2) {\n                if (cp < 0x2c30)\n                    return false;\n                if (cp < 0x2c5f)\n                    return true;\n                if (cp < 0x2c60)\n                    return false;\n                if (cp < 0x2c7c)\n                    return true;\n                if (cp < 0x2c7c)\n                    return false;\n                if (cp < 0x2c7e)\n                    return true;\n                if (cp < 0x2c7e)\n                    return false;\n                if (cp < 0x2ce5)\n                    return true;\n                if (cp < 0x2ceb)\n                    return false;\n                if (cp < 0x2cef)\n                    return true;\n                return false;\n            }\n            if (cp < 0x2cf4)\n                return true;\n            if (cp < 0x2d00)\n                return false;\n            if (cp < 0x2d26)\n                return true;\n            if (cp === 0x2d27)\n                return true;\n            if (cp === 0x2d2d)\n                return true;\n            if (cp < 0x2d30)\n                return false;\n            if (cp < 0x2d68)\n                return true;\n            if (cp === 0x2d6f)\n                return true;\n            return false;\n        }\n        if (cp < 0x3006) {\n            if (cp < 0x2dc0) {\n                if (cp < 0x2d80)\n                    return false;\n                if (cp < 0x2d97)\n                    return true;\n                if (cp < 0x2da0)\n                    return false;\n                if (cp < 0x2da7)\n                    return true;\n                if (cp < 0x2da8)\n                    return false;\n                if (cp < 0x2daf)\n                    return true;\n                if (cp < 0x2db0)\n                    return false;\n                if (cp < 0x2db7)\n                    return true;\n                if (cp < 0x2db8)\n                    return false;\n                if (cp < 0x2dbf)\n                    return true;\n                return false;\n            }\n            if (cp < 0x2dc7)\n                return true;\n            if (cp < 0x2dc8)\n                return false;\n            if (cp < 0x2dcf)\n                return true;\n            if (cp < 0x2dd0)\n                return false;\n            if (cp < 0x2dd7)\n                return true;\n            if (cp < 0x2dd8)\n                return false;\n            if (cp < 0x2ddf)\n                return true;\n            if (cp === 0x3005)\n                return true;\n            return false;\n        }\n        if (cp < 0x303b) {\n            if (cp === 0x3006)\n                return true;\n            if (cp === 0x3007)\n                return true;\n            if (cp < 0x3021)\n                return false;\n            if (cp < 0x302a)\n                return true;\n            if (cp < 0x3031)\n                return false;\n            if (cp < 0x3036)\n                return true;\n            if (cp < 0x3038)\n                return false;\n            if (cp < 0x303b)\n                return true;\n            return false;\n        }\n        if (cp === 0x303b)\n            return true;\n        if (cp === 0x303c)\n            return true;\n        if (cp < 0x3041)\n            return false;\n        if (cp < 0x3097)\n            return true;\n        if (cp < 0x309b)\n            return false;\n        if (cp < 0x309d)\n            return true;\n        if (cp < 0x309d)\n            return false;\n        if (cp < 0x309f)\n            return true;\n        if (cp === 0x309f)\n            return true;\n        return false;\n    }\n    if (cp < 0x10b60) {\n        if (cp < 0xd7b0) {\n            if (cp < 0xa882) {\n                if (cp < 0xa67f) {\n                    if (cp < 0xa015) {\n                        if (cp < 0x31a0) {\n                            if (cp < 0x30a1)\n                                return false;\n                            if (cp < 0x30fb)\n                                return true;\n                            if (cp < 0x30fc)\n                                return false;\n                            if (cp < 0x30ff)\n                                return true;\n                            if (cp === 0x30ff)\n                                return true;\n                            if (cp < 0x3105)\n                                return false;\n                            if (cp < 0x3130)\n                                return true;\n                            if (cp < 0x3131)\n                                return false;\n                            if (cp < 0x318f)\n                                return true;\n                            return false;\n                        }\n                        if (cp < 0x31bb)\n                            return true;\n                        if (cp < 0x31f0)\n                            return false;\n                        if (cp < 0x3200)\n                            return true;\n                        if (cp < 0x3400)\n                            return false;\n                        if (cp < 0x4db6)\n                            return true;\n                        if (cp < 0x4e00)\n                            return false;\n                        if (cp < 0x9ff0)\n                            return true;\n                        if (cp < 0xa000)\n                            return false;\n                        if (cp < 0xa015)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0xa60c) {\n                        if (cp === 0xa015)\n                            return true;\n                        if (cp < 0xa016)\n                            return false;\n                        if (cp < 0xa48d)\n                            return true;\n                        if (cp < 0xa4d0)\n                            return false;\n                        if (cp < 0xa4f8)\n                            return true;\n                        if (cp < 0xa4f8)\n                            return false;\n                        if (cp < 0xa4fe)\n                            return true;\n                        if (cp < 0xa500)\n                            return false;\n                        if (cp < 0xa60c)\n                            return true;\n                        return false;\n                    }\n                    if (cp === 0xa60c)\n                        return true;\n                    if (cp < 0xa610)\n                        return false;\n                    if (cp < 0xa620)\n                        return true;\n                    if (cp < 0xa62a)\n                        return false;\n                    if (cp < 0xa62c)\n                        return true;\n                    if (cp < 0xa640)\n                        return false;\n                    if (cp < 0xa66e)\n                        return true;\n                    if (cp === 0xa66e)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xa78b) {\n                    if (cp < 0xa717) {\n                        if (cp === 0xa67f)\n                            return true;\n                        if (cp < 0xa680)\n                            return false;\n                        if (cp < 0xa69c)\n                            return true;\n                        if (cp < 0xa69c)\n                            return false;\n                        if (cp < 0xa69e)\n                            return true;\n                        if (cp < 0xa6a0)\n                            return false;\n                        if (cp < 0xa6e6)\n                            return true;\n                        if (cp < 0xa6e6)\n                            return false;\n                        if (cp < 0xa6f0)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0xa720)\n                        return true;\n                    if (cp < 0xa722)\n                        return false;\n                    if (cp < 0xa770)\n                        return true;\n                    if (cp === 0xa770)\n                        return true;\n                    if (cp < 0xa771)\n                        return false;\n                    if (cp < 0xa788)\n                        return true;\n                    if (cp === 0xa788)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xa7fa) {\n                    if (cp < 0xa78b)\n                        return false;\n                    if (cp < 0xa78f)\n                        return true;\n                    if (cp === 0xa78f)\n                        return true;\n                    if (cp < 0xa790)\n                        return false;\n                    if (cp < 0xa7ba)\n                        return true;\n                    if (cp === 0xa7f7)\n                        return true;\n                    if (cp < 0xa7f8)\n                        return false;\n                    if (cp < 0xa7fa)\n                        return true;\n                    return false;\n                }\n                if (cp === 0xa7fa)\n                    return true;\n                if (cp < 0xa7fb)\n                    return false;\n                if (cp < 0xa802)\n                    return true;\n                if (cp < 0xa803)\n                    return false;\n                if (cp < 0xa806)\n                    return true;\n                if (cp < 0xa807)\n                    return false;\n                if (cp < 0xa80b)\n                    return true;\n                if (cp < 0xa80c)\n                    return false;\n                if (cp < 0xa823)\n                    return true;\n                if (cp < 0xa840)\n                    return false;\n                if (cp < 0xa874)\n                    return true;\n                return false;\n            }\n            if (cp < 0xaab1) {\n                if (cp < 0xa9e6) {\n                    if (cp < 0xa930) {\n                        if (cp < 0xa882)\n                            return false;\n                        if (cp < 0xa8b4)\n                            return true;\n                        if (cp < 0xa8f2)\n                            return false;\n                        if (cp < 0xa8f8)\n                            return true;\n                        if (cp === 0xa8fb)\n                            return true;\n                        if (cp < 0xa8fd)\n                            return false;\n                        if (cp < 0xa8ff)\n                            return true;\n                        if (cp < 0xa90a)\n                            return false;\n                        if (cp < 0xa926)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0xa947)\n                        return true;\n                    if (cp < 0xa960)\n                        return false;\n                    if (cp < 0xa97d)\n                        return true;\n                    if (cp < 0xa984)\n                        return false;\n                    if (cp < 0xa9b3)\n                        return true;\n                    if (cp === 0xa9cf)\n                        return true;\n                    if (cp < 0xa9e0)\n                        return false;\n                    if (cp < 0xa9e5)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xaa44) {\n                    if (cp === 0xa9e6)\n                        return true;\n                    if (cp < 0xa9e7)\n                        return false;\n                    if (cp < 0xa9f0)\n                        return true;\n                    if (cp < 0xa9fa)\n                        return false;\n                    if (cp < 0xa9ff)\n                        return true;\n                    if (cp < 0xaa00)\n                        return false;\n                    if (cp < 0xaa29)\n                        return true;\n                    if (cp < 0xaa40)\n                        return false;\n                    if (cp < 0xaa43)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xaa4c)\n                    return true;\n                if (cp < 0xaa60)\n                    return false;\n                if (cp < 0xaa70)\n                    return true;\n                if (cp === 0xaa70)\n                    return true;\n                if (cp < 0xaa71)\n                    return false;\n                if (cp < 0xaa77)\n                    return true;\n                if (cp === 0xaa7a)\n                    return true;\n                if (cp < 0xaa7e)\n                    return false;\n                if (cp < 0xaab0)\n                    return true;\n                return false;\n            }\n            if (cp < 0xab01) {\n                if (cp < 0xaadb) {\n                    if (cp === 0xaab1)\n                        return true;\n                    if (cp < 0xaab5)\n                        return false;\n                    if (cp < 0xaab7)\n                        return true;\n                    if (cp < 0xaab9)\n                        return false;\n                    if (cp < 0xaabe)\n                        return true;\n                    if (cp === 0xaac0)\n                        return true;\n                    if (cp === 0xaac2)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xaadd)\n                    return true;\n                if (cp === 0xaadd)\n                    return true;\n                if (cp < 0xaae0)\n                    return false;\n                if (cp < 0xaaeb)\n                    return true;\n                if (cp === 0xaaf2)\n                    return true;\n                if (cp < 0xaaf3)\n                    return false;\n                if (cp < 0xaaf5)\n                    return true;\n                return false;\n            }\n            if (cp < 0xab30) {\n                if (cp < 0xab01)\n                    return false;\n                if (cp < 0xab07)\n                    return true;\n                if (cp < 0xab09)\n                    return false;\n                if (cp < 0xab0f)\n                    return true;\n                if (cp < 0xab11)\n                    return false;\n                if (cp < 0xab17)\n                    return true;\n                if (cp < 0xab20)\n                    return false;\n                if (cp < 0xab27)\n                    return true;\n                if (cp < 0xab28)\n                    return false;\n                if (cp < 0xab2f)\n                    return true;\n                return false;\n            }\n            if (cp < 0xab5b)\n                return true;\n            if (cp < 0xab5c)\n                return false;\n            if (cp < 0xab60)\n                return true;\n            if (cp < 0xab60)\n                return false;\n            if (cp < 0xab66)\n                return true;\n            if (cp < 0xab70)\n                return false;\n            if (cp < 0xabc0)\n                return true;\n            if (cp < 0xabc0)\n                return false;\n            if (cp < 0xabe3)\n                return true;\n            if (cp < 0xac00)\n                return false;\n            if (cp < 0xd7a4)\n                return true;\n            return false;\n        }\n        if (cp < 0x1032d) {\n            if (cp < 0xff41) {\n                if (cp < 0xfb3e) {\n                    if (cp < 0xfb13) {\n                        if (cp < 0xd7b0)\n                            return false;\n                        if (cp < 0xd7c7)\n                            return true;\n                        if (cp < 0xd7cb)\n                            return false;\n                        if (cp < 0xd7fc)\n                            return true;\n                        if (cp < 0xf900)\n                            return false;\n                        if (cp < 0xfa6e)\n                            return true;\n                        if (cp < 0xfa70)\n                            return false;\n                        if (cp < 0xfada)\n                            return true;\n                        if (cp < 0xfb00)\n                            return false;\n                        if (cp < 0xfb07)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0xfb18)\n                        return true;\n                    if (cp === 0xfb1d)\n                        return true;\n                    if (cp < 0xfb1f)\n                        return false;\n                    if (cp < 0xfb29)\n                        return true;\n                    if (cp < 0xfb2a)\n                        return false;\n                    if (cp < 0xfb37)\n                        return true;\n                    if (cp < 0xfb38)\n                        return false;\n                    if (cp < 0xfb3d)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xfd50) {\n                    if (cp === 0xfb3e)\n                        return true;\n                    if (cp < 0xfb40)\n                        return false;\n                    if (cp < 0xfb42)\n                        return true;\n                    if (cp < 0xfb43)\n                        return false;\n                    if (cp < 0xfb45)\n                        return true;\n                    if (cp < 0xfb46)\n                        return false;\n                    if (cp < 0xfbb2)\n                        return true;\n                    if (cp < 0xfbd3)\n                        return false;\n                    if (cp < 0xfd3e)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xfd90)\n                    return true;\n                if (cp < 0xfd92)\n                    return false;\n                if (cp < 0xfdc8)\n                    return true;\n                if (cp < 0xfdf0)\n                    return false;\n                if (cp < 0xfdfc)\n                    return true;\n                if (cp < 0xfe70)\n                    return false;\n                if (cp < 0xfe75)\n                    return true;\n                if (cp < 0xfe76)\n                    return false;\n                if (cp < 0xfefd)\n                    return true;\n                if (cp < 0xff21)\n                    return false;\n                if (cp < 0xff3b)\n                    return true;\n                return false;\n            }\n            if (cp < 0x10000) {\n                if (cp < 0xffa0) {\n                    if (cp < 0xff41)\n                        return false;\n                    if (cp < 0xff5b)\n                        return true;\n                    if (cp < 0xff66)\n                        return false;\n                    if (cp < 0xff70)\n                        return true;\n                    if (cp === 0xff70)\n                        return true;\n                    if (cp < 0xff71)\n                        return false;\n                    if (cp < 0xff9e)\n                        return true;\n                    if (cp < 0xff9e)\n                        return false;\n                    if (cp < 0xffa0)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xffbf)\n                    return true;\n                if (cp < 0xffc2)\n                    return false;\n                if (cp < 0xffc8)\n                    return true;\n                if (cp < 0xffca)\n                    return false;\n                if (cp < 0xffd0)\n                    return true;\n                if (cp < 0xffd2)\n                    return false;\n                if (cp < 0xffd8)\n                    return true;\n                if (cp < 0xffda)\n                    return false;\n                if (cp < 0xffdd)\n                    return true;\n                return false;\n            }\n            if (cp < 0x10050) {\n                if (cp < 0x10000)\n                    return false;\n                if (cp < 0x1000c)\n                    return true;\n                if (cp < 0x1000d)\n                    return false;\n                if (cp < 0x10027)\n                    return true;\n                if (cp < 0x10028)\n                    return false;\n                if (cp < 0x1003b)\n                    return true;\n                if (cp < 0x1003c)\n                    return false;\n                if (cp < 0x1003e)\n                    return true;\n                if (cp < 0x1003f)\n                    return false;\n                if (cp < 0x1004e)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1005e)\n                return true;\n            if (cp < 0x10080)\n                return false;\n            if (cp < 0x100fb)\n                return true;\n            if (cp < 0x10140)\n                return false;\n            if (cp < 0x10175)\n                return true;\n            if (cp < 0x10280)\n                return false;\n            if (cp < 0x1029d)\n                return true;\n            if (cp < 0x102a0)\n                return false;\n            if (cp < 0x102d1)\n                return true;\n            if (cp < 0x10300)\n                return false;\n            if (cp < 0x10320)\n                return true;\n            return false;\n        }\n        if (cp < 0x10837) {\n            if (cp < 0x10450) {\n                if (cp < 0x10380) {\n                    if (cp < 0x1032d)\n                        return false;\n                    if (cp < 0x10341)\n                        return true;\n                    if (cp === 0x10341)\n                        return true;\n                    if (cp < 0x10342)\n                        return false;\n                    if (cp < 0x1034a)\n                        return true;\n                    if (cp === 0x1034a)\n                        return true;\n                    if (cp < 0x10350)\n                        return false;\n                    if (cp < 0x10376)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x1039e)\n                    return true;\n                if (cp < 0x103a0)\n                    return false;\n                if (cp < 0x103c4)\n                    return true;\n                if (cp < 0x103c8)\n                    return false;\n                if (cp < 0x103d0)\n                    return true;\n                if (cp < 0x103d1)\n                    return false;\n                if (cp < 0x103d6)\n                    return true;\n                if (cp < 0x10400)\n                    return false;\n                if (cp < 0x10450)\n                    return true;\n                return false;\n            }\n            if (cp < 0x10600) {\n                if (cp < 0x10450)\n                    return false;\n                if (cp < 0x1049e)\n                    return true;\n                if (cp < 0x104b0)\n                    return false;\n                if (cp < 0x104d4)\n                    return true;\n                if (cp < 0x104d8)\n                    return false;\n                if (cp < 0x104fc)\n                    return true;\n                if (cp < 0x10500)\n                    return false;\n                if (cp < 0x10528)\n                    return true;\n                if (cp < 0x10530)\n                    return false;\n                if (cp < 0x10564)\n                    return true;\n                return false;\n            }\n            if (cp < 0x10737)\n                return true;\n            if (cp < 0x10740)\n                return false;\n            if (cp < 0x10756)\n                return true;\n            if (cp < 0x10760)\n                return false;\n            if (cp < 0x10768)\n                return true;\n            if (cp < 0x10800)\n                return false;\n            if (cp < 0x10806)\n                return true;\n            if (cp === 0x10808)\n                return true;\n            if (cp < 0x1080a)\n                return false;\n            if (cp < 0x10836)\n                return true;\n            return false;\n        }\n        if (cp < 0x109be) {\n            if (cp < 0x108e0) {\n                if (cp < 0x10837)\n                    return false;\n                if (cp < 0x10839)\n                    return true;\n                if (cp === 0x1083c)\n                    return true;\n                if (cp < 0x1083f)\n                    return false;\n                if (cp < 0x10856)\n                    return true;\n                if (cp < 0x10860)\n                    return false;\n                if (cp < 0x10877)\n                    return true;\n                if (cp < 0x10880)\n                    return false;\n                if (cp < 0x1089f)\n                    return true;\n                return false;\n            }\n            if (cp < 0x108f3)\n                return true;\n            if (cp < 0x108f4)\n                return false;\n            if (cp < 0x108f6)\n                return true;\n            if (cp < 0x10900)\n                return false;\n            if (cp < 0x10916)\n                return true;\n            if (cp < 0x10920)\n                return false;\n            if (cp < 0x1093a)\n                return true;\n            if (cp < 0x10980)\n                return false;\n            if (cp < 0x109b8)\n                return true;\n            return false;\n        }\n        if (cp < 0x10a60) {\n            if (cp < 0x109be)\n                return false;\n            if (cp < 0x109c0)\n                return true;\n            if (cp === 0x10a00)\n                return true;\n            if (cp < 0x10a10)\n                return false;\n            if (cp < 0x10a14)\n                return true;\n            if (cp < 0x10a15)\n                return false;\n            if (cp < 0x10a18)\n                return true;\n            if (cp < 0x10a19)\n                return false;\n            if (cp < 0x10a36)\n                return true;\n            return false;\n        }\n        if (cp < 0x10a7d)\n            return true;\n        if (cp < 0x10a80)\n            return false;\n        if (cp < 0x10a9d)\n            return true;\n        if (cp < 0x10ac0)\n            return false;\n        if (cp < 0x10ac8)\n            return true;\n        if (cp < 0x10ac9)\n            return false;\n        if (cp < 0x10ae5)\n            return true;\n        if (cp < 0x10b00)\n            return false;\n        if (cp < 0x10b36)\n            return true;\n        if (cp < 0x10b40)\n            return false;\n        if (cp < 0x10b56)\n            return true;\n        return false;\n    }\n    if (cp < 0x16e40) {\n        if (cp < 0x11580) {\n            if (cp < 0x11213) {\n                if (cp < 0x11083) {\n                    if (cp < 0x10d00) {\n                        if (cp < 0x10b60)\n                            return false;\n                        if (cp < 0x10b73)\n                            return true;\n                        if (cp < 0x10b80)\n                            return false;\n                        if (cp < 0x10b92)\n                            return true;\n                        if (cp < 0x10c00)\n                            return false;\n                        if (cp < 0x10c49)\n                            return true;\n                        if (cp < 0x10c80)\n                            return false;\n                        if (cp < 0x10cb3)\n                            return true;\n                        if (cp < 0x10cc0)\n                            return false;\n                        if (cp < 0x10cf3)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x10d24)\n                        return true;\n                    if (cp < 0x10f00)\n                        return false;\n                    if (cp < 0x10f1d)\n                        return true;\n                    if (cp === 0x10f27)\n                        return true;\n                    if (cp < 0x10f30)\n                        return false;\n                    if (cp < 0x10f46)\n                        return true;\n                    if (cp < 0x11003)\n                        return false;\n                    if (cp < 0x11038)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x11176) {\n                    if (cp < 0x11083)\n                        return false;\n                    if (cp < 0x110b0)\n                        return true;\n                    if (cp < 0x110d0)\n                        return false;\n                    if (cp < 0x110e9)\n                        return true;\n                    if (cp < 0x11103)\n                        return false;\n                    if (cp < 0x11127)\n                        return true;\n                    if (cp === 0x11144)\n                        return true;\n                    if (cp < 0x11150)\n                        return false;\n                    if (cp < 0x11173)\n                        return true;\n                    return false;\n                }\n                if (cp === 0x11176)\n                    return true;\n                if (cp < 0x11183)\n                    return false;\n                if (cp < 0x111b3)\n                    return true;\n                if (cp < 0x111c1)\n                    return false;\n                if (cp < 0x111c5)\n                    return true;\n                if (cp === 0x111da)\n                    return true;\n                if (cp === 0x111dc)\n                    return true;\n                if (cp < 0x11200)\n                    return false;\n                if (cp < 0x11212)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1132a) {\n                if (cp < 0x1129f) {\n                    if (cp < 0x11213)\n                        return false;\n                    if (cp < 0x1122c)\n                        return true;\n                    if (cp < 0x11280)\n                        return false;\n                    if (cp < 0x11287)\n                        return true;\n                    if (cp === 0x11288)\n                        return true;\n                    if (cp < 0x1128a)\n                        return false;\n                    if (cp < 0x1128e)\n                        return true;\n                    if (cp < 0x1128f)\n                        return false;\n                    if (cp < 0x1129e)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x112a9)\n                    return true;\n                if (cp < 0x112b0)\n                    return false;\n                if (cp < 0x112df)\n                    return true;\n                if (cp < 0x11305)\n                    return false;\n                if (cp < 0x1130d)\n                    return true;\n                if (cp < 0x1130f)\n                    return false;\n                if (cp < 0x11311)\n                    return true;\n                if (cp < 0x11313)\n                    return false;\n                if (cp < 0x11329)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1135d) {\n                if (cp < 0x1132a)\n                    return false;\n                if (cp < 0x11331)\n                    return true;\n                if (cp < 0x11332)\n                    return false;\n                if (cp < 0x11334)\n                    return true;\n                if (cp < 0x11335)\n                    return false;\n                if (cp < 0x1133a)\n                    return true;\n                if (cp === 0x1133d)\n                    return true;\n                if (cp === 0x11350)\n                    return true;\n                return false;\n            }\n            if (cp < 0x11362)\n                return true;\n            if (cp < 0x11400)\n                return false;\n            if (cp < 0x11435)\n                return true;\n            if (cp < 0x11447)\n                return false;\n            if (cp < 0x1144b)\n                return true;\n            if (cp < 0x11480)\n                return false;\n            if (cp < 0x114b0)\n                return true;\n            if (cp < 0x114c4)\n                return false;\n            if (cp < 0x114c6)\n                return true;\n            if (cp === 0x114c7)\n                return true;\n            return false;\n        }\n        if (cp < 0x11d00) {\n            if (cp < 0x11a0b) {\n                if (cp < 0x11700) {\n                    if (cp < 0x11580)\n                        return false;\n                    if (cp < 0x115af)\n                        return true;\n                    if (cp < 0x115d8)\n                        return false;\n                    if (cp < 0x115dc)\n                        return true;\n                    if (cp < 0x11600)\n                        return false;\n                    if (cp < 0x11630)\n                        return true;\n                    if (cp === 0x11644)\n                        return true;\n                    if (cp < 0x11680)\n                        return false;\n                    if (cp < 0x116ab)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x1171b)\n                    return true;\n                if (cp < 0x11800)\n                    return false;\n                if (cp < 0x1182c)\n                    return true;\n                if (cp < 0x118a0)\n                    return false;\n                if (cp < 0x118e0)\n                    return true;\n                if (cp === 0x118ff)\n                    return true;\n                if (cp === 0x11a00)\n                    return true;\n                return false;\n            }\n            if (cp < 0x11a9d) {\n                if (cp < 0x11a0b)\n                    return false;\n                if (cp < 0x11a33)\n                    return true;\n                if (cp === 0x11a3a)\n                    return true;\n                if (cp === 0x11a50)\n                    return true;\n                if (cp < 0x11a5c)\n                    return false;\n                if (cp < 0x11a84)\n                    return true;\n                if (cp < 0x11a86)\n                    return false;\n                if (cp < 0x11a8a)\n                    return true;\n                return false;\n            }\n            if (cp === 0x11a9d)\n                return true;\n            if (cp < 0x11ac0)\n                return false;\n            if (cp < 0x11af9)\n                return true;\n            if (cp < 0x11c00)\n                return false;\n            if (cp < 0x11c09)\n                return true;\n            if (cp < 0x11c0a)\n                return false;\n            if (cp < 0x11c2f)\n                return true;\n            if (cp === 0x11c40)\n                return true;\n            if (cp < 0x11c72)\n                return false;\n            if (cp < 0x11c90)\n                return true;\n            return false;\n        }\n        if (cp < 0x12400) {\n            if (cp < 0x11d67) {\n                if (cp < 0x11d00)\n                    return false;\n                if (cp < 0x11d07)\n                    return true;\n                if (cp < 0x11d08)\n                    return false;\n                if (cp < 0x11d0a)\n                    return true;\n                if (cp < 0x11d0b)\n                    return false;\n                if (cp < 0x11d31)\n                    return true;\n                if (cp === 0x11d46)\n                    return true;\n                if (cp < 0x11d60)\n                    return false;\n                if (cp < 0x11d66)\n                    return true;\n                return false;\n            }\n            if (cp < 0x11d69)\n                return true;\n            if (cp < 0x11d6a)\n                return false;\n            if (cp < 0x11d8a)\n                return true;\n            if (cp === 0x11d98)\n                return true;\n            if (cp < 0x11ee0)\n                return false;\n            if (cp < 0x11ef3)\n                return true;\n            if (cp < 0x12000)\n                return false;\n            if (cp < 0x1239a)\n                return true;\n            return false;\n        }\n        if (cp < 0x16a40) {\n            if (cp < 0x12400)\n                return false;\n            if (cp < 0x1246f)\n                return true;\n            if (cp < 0x12480)\n                return false;\n            if (cp < 0x12544)\n                return true;\n            if (cp < 0x13000)\n                return false;\n            if (cp < 0x1342f)\n                return true;\n            if (cp < 0x14400)\n                return false;\n            if (cp < 0x14647)\n                return true;\n            if (cp < 0x16800)\n                return false;\n            if (cp < 0x16a39)\n                return true;\n            return false;\n        }\n        if (cp < 0x16a5f)\n            return true;\n        if (cp < 0x16ad0)\n            return false;\n        if (cp < 0x16aee)\n            return true;\n        if (cp < 0x16b00)\n            return false;\n        if (cp < 0x16b30)\n            return true;\n        if (cp < 0x16b40)\n            return false;\n        if (cp < 0x16b44)\n            return true;\n        if (cp < 0x16b63)\n            return false;\n        if (cp < 0x16b78)\n            return true;\n        if (cp < 0x16b7d)\n            return false;\n        if (cp < 0x16b90)\n            return true;\n        return false;\n    }\n    if (cp < 0x1d7c4) {\n        if (cp < 0x1d4bd) {\n            if (cp < 0x1bc70) {\n                if (cp < 0x17000) {\n                    if (cp < 0x16e40)\n                        return false;\n                    if (cp < 0x16e80)\n                        return true;\n                    if (cp < 0x16f00)\n                        return false;\n                    if (cp < 0x16f45)\n                        return true;\n                    if (cp === 0x16f50)\n                        return true;\n                    if (cp < 0x16f93)\n                        return false;\n                    if (cp < 0x16fa0)\n                        return true;\n                    if (cp < 0x16fe0)\n                        return false;\n                    if (cp < 0x16fe2)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x187f2)\n                    return true;\n                if (cp < 0x18800)\n                    return false;\n                if (cp < 0x18af3)\n                    return true;\n                if (cp < 0x1b000)\n                    return false;\n                if (cp < 0x1b11f)\n                    return true;\n                if (cp < 0x1b170)\n                    return false;\n                if (cp < 0x1b2fc)\n                    return true;\n                if (cp < 0x1bc00)\n                    return false;\n                if (cp < 0x1bc6b)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1d49e) {\n                if (cp < 0x1bc70)\n                    return false;\n                if (cp < 0x1bc7d)\n                    return true;\n                if (cp < 0x1bc80)\n                    return false;\n                if (cp < 0x1bc89)\n                    return true;\n                if (cp < 0x1bc90)\n                    return false;\n                if (cp < 0x1bc9a)\n                    return true;\n                if (cp < 0x1d400)\n                    return false;\n                if (cp < 0x1d455)\n                    return true;\n                if (cp < 0x1d456)\n                    return false;\n                if (cp < 0x1d49d)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1d4a0)\n                return true;\n            if (cp === 0x1d4a2)\n                return true;\n            if (cp < 0x1d4a5)\n                return false;\n            if (cp < 0x1d4a7)\n                return true;\n            if (cp < 0x1d4a9)\n                return false;\n            if (cp < 0x1d4ad)\n                return true;\n            if (cp < 0x1d4ae)\n                return false;\n            if (cp < 0x1d4ba)\n                return true;\n            if (cp === 0x1d4bb)\n                return true;\n            return false;\n        }\n        if (cp < 0x1d552) {\n            if (cp < 0x1d51e) {\n                if (cp < 0x1d4bd)\n                    return false;\n                if (cp < 0x1d4c4)\n                    return true;\n                if (cp < 0x1d4c5)\n                    return false;\n                if (cp < 0x1d506)\n                    return true;\n                if (cp < 0x1d507)\n                    return false;\n                if (cp < 0x1d50b)\n                    return true;\n                if (cp < 0x1d50d)\n                    return false;\n                if (cp < 0x1d515)\n                    return true;\n                if (cp < 0x1d516)\n                    return false;\n                if (cp < 0x1d51d)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1d53a)\n                return true;\n            if (cp < 0x1d53b)\n                return false;\n            if (cp < 0x1d53f)\n                return true;\n            if (cp < 0x1d540)\n                return false;\n            if (cp < 0x1d545)\n                return true;\n            if (cp === 0x1d546)\n                return true;\n            if (cp < 0x1d54a)\n                return false;\n            if (cp < 0x1d551)\n                return true;\n            return false;\n        }\n        if (cp < 0x1d716) {\n            if (cp < 0x1d552)\n                return false;\n            if (cp < 0x1d6a6)\n                return true;\n            if (cp < 0x1d6a8)\n                return false;\n            if (cp < 0x1d6c1)\n                return true;\n            if (cp < 0x1d6c2)\n                return false;\n            if (cp < 0x1d6db)\n                return true;\n            if (cp < 0x1d6dc)\n                return false;\n            if (cp < 0x1d6fb)\n                return true;\n            if (cp < 0x1d6fc)\n                return false;\n            if (cp < 0x1d715)\n                return true;\n            return false;\n        }\n        if (cp < 0x1d735)\n            return true;\n        if (cp < 0x1d736)\n            return false;\n        if (cp < 0x1d74f)\n            return true;\n        if (cp < 0x1d750)\n            return false;\n        if (cp < 0x1d76f)\n            return true;\n        if (cp < 0x1d770)\n            return false;\n        if (cp < 0x1d789)\n            return true;\n        if (cp < 0x1d78a)\n            return false;\n        if (cp < 0x1d7a9)\n            return true;\n        if (cp < 0x1d7aa)\n            return false;\n        if (cp < 0x1d7c3)\n            return true;\n        return false;\n    }\n    if (cp < 0x1ee5b) {\n        if (cp < 0x1ee39) {\n            if (cp < 0x1ee21) {\n                if (cp < 0x1d7c4)\n                    return false;\n                if (cp < 0x1d7cc)\n                    return true;\n                if (cp < 0x1e800)\n                    return false;\n                if (cp < 0x1e8c5)\n                    return true;\n                if (cp < 0x1e900)\n                    return false;\n                if (cp < 0x1e944)\n                    return true;\n                if (cp < 0x1ee00)\n                    return false;\n                if (cp < 0x1ee04)\n                    return true;\n                if (cp < 0x1ee05)\n                    return false;\n                if (cp < 0x1ee20)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1ee23)\n                return true;\n            if (cp === 0x1ee24)\n                return true;\n            if (cp === 0x1ee27)\n                return true;\n            if (cp < 0x1ee29)\n                return false;\n            if (cp < 0x1ee33)\n                return true;\n            if (cp < 0x1ee34)\n                return false;\n            if (cp < 0x1ee38)\n                return true;\n            return false;\n        }\n        if (cp < 0x1ee4b) {\n            if (cp === 0x1ee39)\n                return true;\n            if (cp === 0x1ee3b)\n                return true;\n            if (cp === 0x1ee42)\n                return true;\n            if (cp === 0x1ee47)\n                return true;\n            if (cp === 0x1ee49)\n                return true;\n            return false;\n        }\n        if (cp === 0x1ee4b)\n            return true;\n        if (cp < 0x1ee4d)\n            return false;\n        if (cp < 0x1ee50)\n            return true;\n        if (cp < 0x1ee51)\n            return false;\n        if (cp < 0x1ee53)\n            return true;\n        if (cp === 0x1ee54)\n            return true;\n        if (cp === 0x1ee57)\n            return true;\n        if (cp === 0x1ee59)\n            return true;\n        return false;\n    }\n    if (cp < 0x1ee80) {\n        if (cp < 0x1ee67) {\n            if (cp === 0x1ee5b)\n                return true;\n            if (cp === 0x1ee5d)\n                return true;\n            if (cp === 0x1ee5f)\n                return true;\n            if (cp < 0x1ee61)\n                return false;\n            if (cp < 0x1ee63)\n                return true;\n            if (cp === 0x1ee64)\n                return true;\n            return false;\n        }\n        if (cp < 0x1ee6b)\n            return true;\n        if (cp < 0x1ee6c)\n            return false;\n        if (cp < 0x1ee73)\n            return true;\n        if (cp < 0x1ee74)\n            return false;\n        if (cp < 0x1ee78)\n            return true;\n        if (cp < 0x1ee79)\n            return false;\n        if (cp < 0x1ee7d)\n            return true;\n        if (cp === 0x1ee7e)\n            return true;\n        return false;\n    }\n    if (cp < 0x20000) {\n        if (cp < 0x1ee80)\n            return false;\n        if (cp < 0x1ee8a)\n            return true;\n        if (cp < 0x1ee8b)\n            return false;\n        if (cp < 0x1ee9c)\n            return true;\n        if (cp < 0x1eea1)\n            return false;\n        if (cp < 0x1eea4)\n            return true;\n        if (cp < 0x1eea5)\n            return false;\n        if (cp < 0x1eeaa)\n            return true;\n        if (cp < 0x1eeab)\n            return false;\n        if (cp < 0x1eebc)\n            return true;\n        return false;\n    }\n    if (cp < 0x2a6d7)\n        return true;\n    if (cp < 0x2a700)\n        return false;\n    if (cp < 0x2b735)\n        return true;\n    if (cp < 0x2b740)\n        return false;\n    if (cp < 0x2b81e)\n        return true;\n    if (cp < 0x2b820)\n        return false;\n    if (cp < 0x2cea2)\n        return true;\n    if (cp < 0x2ceb0)\n        return false;\n    if (cp < 0x2ebe1)\n        return true;\n    if (cp < 0x2f800)\n        return false;\n    if (cp < 0x2fa1e)\n        return true;\n    return false;\n}\nfunction isLargeIdContinue(cp) {\n    if (cp < 0x1cd0) {\n        if (cp < 0xd82) {\n            if (cp < 0xa83) {\n                if (cp < 0x93b) {\n                    if (cp < 0x6ea) {\n                        if (cp < 0x5c7) {\n                            if (cp === 0xb7)\n                                return true;\n                            if (cp < 0x300)\n                                return false;\n                            if (cp < 0x370)\n                                return true;\n                            if (cp === 0x387)\n                                return true;\n                            if (cp < 0x483)\n                                return false;\n                            if (cp < 0x488)\n                                return true;\n                            if (cp < 0x591)\n                                return false;\n                            if (cp < 0x5be)\n                                return true;\n                            if (cp === 0x5bf)\n                                return true;\n                            if (cp < 0x5c1)\n                                return false;\n                            if (cp < 0x5c3)\n                                return true;\n                            if (cp < 0x5c4)\n                                return false;\n                            if (cp < 0x5c6)\n                                return true;\n                            return false;\n                        }\n                        if (cp === 0x5c7)\n                            return true;\n                        if (cp < 0x610)\n                            return false;\n                        if (cp < 0x61b)\n                            return true;\n                        if (cp < 0x64b)\n                            return false;\n                        if (cp < 0x660)\n                            return true;\n                        if (cp < 0x660)\n                            return false;\n                        if (cp < 0x66a)\n                            return true;\n                        if (cp === 0x670)\n                            return true;\n                        if (cp < 0x6d6)\n                            return false;\n                        if (cp < 0x6dd)\n                            return true;\n                        if (cp < 0x6df)\n                            return false;\n                        if (cp < 0x6e5)\n                            return true;\n                        if (cp < 0x6e7)\n                            return false;\n                        if (cp < 0x6e9)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x816) {\n                        if (cp < 0x6ea)\n                            return false;\n                        if (cp < 0x6ee)\n                            return true;\n                        if (cp < 0x6f0)\n                            return false;\n                        if (cp < 0x6fa)\n                            return true;\n                        if (cp === 0x711)\n                            return true;\n                        if (cp < 0x730)\n                            return false;\n                        if (cp < 0x74b)\n                            return true;\n                        if (cp < 0x7a6)\n                            return false;\n                        if (cp < 0x7b1)\n                            return true;\n                        if (cp < 0x7c0)\n                            return false;\n                        if (cp < 0x7ca)\n                            return true;\n                        if (cp < 0x7eb)\n                            return false;\n                        if (cp < 0x7f4)\n                            return true;\n                        if (cp === 0x7fd)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x81a)\n                        return true;\n                    if (cp < 0x81b)\n                        return false;\n                    if (cp < 0x824)\n                        return true;\n                    if (cp < 0x825)\n                        return false;\n                    if (cp < 0x828)\n                        return true;\n                    if (cp < 0x829)\n                        return false;\n                    if (cp < 0x82e)\n                        return true;\n                    if (cp < 0x859)\n                        return false;\n                    if (cp < 0x85c)\n                        return true;\n                    if (cp < 0x8d3)\n                        return false;\n                    if (cp < 0x8e2)\n                        return true;\n                    if (cp < 0x8e3)\n                        return false;\n                    if (cp < 0x903)\n                        return true;\n                    if (cp === 0x903)\n                        return true;\n                    if (cp === 0x93a)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x9cd) {\n                    if (cp < 0x962) {\n                        if (cp === 0x93b)\n                            return true;\n                        if (cp === 0x93c)\n                            return true;\n                        if (cp < 0x93e)\n                            return false;\n                        if (cp < 0x941)\n                            return true;\n                        if (cp < 0x941)\n                            return false;\n                        if (cp < 0x949)\n                            return true;\n                        if (cp < 0x949)\n                            return false;\n                        if (cp < 0x94d)\n                            return true;\n                        if (cp === 0x94d)\n                            return true;\n                        if (cp < 0x94e)\n                            return false;\n                        if (cp < 0x950)\n                            return true;\n                        if (cp < 0x951)\n                            return false;\n                        if (cp < 0x958)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x964)\n                        return true;\n                    if (cp < 0x966)\n                        return false;\n                    if (cp < 0x970)\n                        return true;\n                    if (cp === 0x981)\n                        return true;\n                    if (cp < 0x982)\n                        return false;\n                    if (cp < 0x984)\n                        return true;\n                    if (cp === 0x9bc)\n                        return true;\n                    if (cp < 0x9be)\n                        return false;\n                    if (cp < 0x9c1)\n                        return true;\n                    if (cp < 0x9c1)\n                        return false;\n                    if (cp < 0x9c5)\n                        return true;\n                    if (cp < 0x9c7)\n                        return false;\n                    if (cp < 0x9c9)\n                        return true;\n                    if (cp < 0x9cb)\n                        return false;\n                    if (cp < 0x9cd)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xa3e) {\n                    if (cp === 0x9cd)\n                        return true;\n                    if (cp === 0x9d7)\n                        return true;\n                    if (cp < 0x9e2)\n                        return false;\n                    if (cp < 0x9e4)\n                        return true;\n                    if (cp < 0x9e6)\n                        return false;\n                    if (cp < 0x9f0)\n                        return true;\n                    if (cp === 0x9fe)\n                        return true;\n                    if (cp < 0xa01)\n                        return false;\n                    if (cp < 0xa03)\n                        return true;\n                    if (cp === 0xa03)\n                        return true;\n                    if (cp === 0xa3c)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xa41)\n                    return true;\n                if (cp < 0xa41)\n                    return false;\n                if (cp < 0xa43)\n                    return true;\n                if (cp < 0xa47)\n                    return false;\n                if (cp < 0xa49)\n                    return true;\n                if (cp < 0xa4b)\n                    return false;\n                if (cp < 0xa4e)\n                    return true;\n                if (cp === 0xa51)\n                    return true;\n                if (cp < 0xa66)\n                    return false;\n                if (cp < 0xa70)\n                    return true;\n                if (cp < 0xa70)\n                    return false;\n                if (cp < 0xa72)\n                    return true;\n                if (cp === 0xa75)\n                    return true;\n                if (cp < 0xa81)\n                    return false;\n                if (cp < 0xa83)\n                    return true;\n                return false;\n            }\n            if (cp < 0xc00) {\n                if (cp < 0xb41) {\n                    if (cp < 0xae2) {\n                        if (cp === 0xa83)\n                            return true;\n                        if (cp === 0xabc)\n                            return true;\n                        if (cp < 0xabe)\n                            return false;\n                        if (cp < 0xac1)\n                            return true;\n                        if (cp < 0xac1)\n                            return false;\n                        if (cp < 0xac6)\n                            return true;\n                        if (cp < 0xac7)\n                            return false;\n                        if (cp < 0xac9)\n                            return true;\n                        if (cp === 0xac9)\n                            return true;\n                        if (cp < 0xacb)\n                            return false;\n                        if (cp < 0xacd)\n                            return true;\n                        if (cp === 0xacd)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0xae4)\n                        return true;\n                    if (cp < 0xae6)\n                        return false;\n                    if (cp < 0xaf0)\n                        return true;\n                    if (cp < 0xafa)\n                        return false;\n                    if (cp < 0xb00)\n                        return true;\n                    if (cp === 0xb01)\n                        return true;\n                    if (cp < 0xb02)\n                        return false;\n                    if (cp < 0xb04)\n                        return true;\n                    if (cp === 0xb3c)\n                        return true;\n                    if (cp === 0xb3e)\n                        return true;\n                    if (cp === 0xb3f)\n                        return true;\n                    if (cp === 0xb40)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xb82) {\n                    if (cp < 0xb41)\n                        return false;\n                    if (cp < 0xb45)\n                        return true;\n                    if (cp < 0xb47)\n                        return false;\n                    if (cp < 0xb49)\n                        return true;\n                    if (cp < 0xb4b)\n                        return false;\n                    if (cp < 0xb4d)\n                        return true;\n                    if (cp === 0xb4d)\n                        return true;\n                    if (cp === 0xb56)\n                        return true;\n                    if (cp === 0xb57)\n                        return true;\n                    if (cp < 0xb62)\n                        return false;\n                    if (cp < 0xb64)\n                        return true;\n                    if (cp < 0xb66)\n                        return false;\n                    if (cp < 0xb70)\n                        return true;\n                    return false;\n                }\n                if (cp === 0xb82)\n                    return true;\n                if (cp < 0xbbe)\n                    return false;\n                if (cp < 0xbc0)\n                    return true;\n                if (cp === 0xbc0)\n                    return true;\n                if (cp < 0xbc1)\n                    return false;\n                if (cp < 0xbc3)\n                    return true;\n                if (cp < 0xbc6)\n                    return false;\n                if (cp < 0xbc9)\n                    return true;\n                if (cp < 0xbca)\n                    return false;\n                if (cp < 0xbcd)\n                    return true;\n                if (cp === 0xbcd)\n                    return true;\n                if (cp === 0xbd7)\n                    return true;\n                if (cp < 0xbe6)\n                    return false;\n                if (cp < 0xbf0)\n                    return true;\n                return false;\n            }\n            if (cp < 0xcc7) {\n                if (cp < 0xc62) {\n                    if (cp === 0xc00)\n                        return true;\n                    if (cp < 0xc01)\n                        return false;\n                    if (cp < 0xc04)\n                        return true;\n                    if (cp === 0xc04)\n                        return true;\n                    if (cp < 0xc3e)\n                        return false;\n                    if (cp < 0xc41)\n                        return true;\n                    if (cp < 0xc41)\n                        return false;\n                    if (cp < 0xc45)\n                        return true;\n                    if (cp < 0xc46)\n                        return false;\n                    if (cp < 0xc49)\n                        return true;\n                    if (cp < 0xc4a)\n                        return false;\n                    if (cp < 0xc4e)\n                        return true;\n                    if (cp < 0xc55)\n                        return false;\n                    if (cp < 0xc57)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xc64)\n                    return true;\n                if (cp < 0xc66)\n                    return false;\n                if (cp < 0xc70)\n                    return true;\n                if (cp === 0xc81)\n                    return true;\n                if (cp < 0xc82)\n                    return false;\n                if (cp < 0xc84)\n                    return true;\n                if (cp === 0xcbc)\n                    return true;\n                if (cp === 0xcbe)\n                    return true;\n                if (cp === 0xcbf)\n                    return true;\n                if (cp < 0xcc0)\n                    return false;\n                if (cp < 0xcc5)\n                    return true;\n                if (cp === 0xcc6)\n                    return true;\n                return false;\n            }\n            if (cp < 0xd3b) {\n                if (cp < 0xcc7)\n                    return false;\n                if (cp < 0xcc9)\n                    return true;\n                if (cp < 0xcca)\n                    return false;\n                if (cp < 0xccc)\n                    return true;\n                if (cp < 0xccc)\n                    return false;\n                if (cp < 0xcce)\n                    return true;\n                if (cp < 0xcd5)\n                    return false;\n                if (cp < 0xcd7)\n                    return true;\n                if (cp < 0xce2)\n                    return false;\n                if (cp < 0xce4)\n                    return true;\n                if (cp < 0xce6)\n                    return false;\n                if (cp < 0xcf0)\n                    return true;\n                if (cp < 0xd00)\n                    return false;\n                if (cp < 0xd02)\n                    return true;\n                if (cp < 0xd02)\n                    return false;\n                if (cp < 0xd04)\n                    return true;\n                return false;\n            }\n            if (cp < 0xd3d)\n                return true;\n            if (cp < 0xd3e)\n                return false;\n            if (cp < 0xd41)\n                return true;\n            if (cp < 0xd41)\n                return false;\n            if (cp < 0xd45)\n                return true;\n            if (cp < 0xd46)\n                return false;\n            if (cp < 0xd49)\n                return true;\n            if (cp < 0xd4a)\n                return false;\n            if (cp < 0xd4d)\n                return true;\n            if (cp === 0xd4d)\n                return true;\n            if (cp === 0xd57)\n                return true;\n            if (cp < 0xd62)\n                return false;\n            if (cp < 0xd64)\n                return true;\n            if (cp < 0xd66)\n                return false;\n            if (cp < 0xd70)\n                return true;\n            return false;\n        }\n        if (cp < 0x17e0) {\n            if (cp < 0x1038) {\n                if (cp < 0xf18) {\n                    if (cp < 0xe31) {\n                        if (cp < 0xd82)\n                            return false;\n                        if (cp < 0xd84)\n                            return true;\n                        if (cp === 0xdca)\n                            return true;\n                        if (cp < 0xdcf)\n                            return false;\n                        if (cp < 0xdd2)\n                            return true;\n                        if (cp < 0xdd2)\n                            return false;\n                        if (cp < 0xdd5)\n                            return true;\n                        if (cp === 0xdd6)\n                            return true;\n                        if (cp < 0xdd8)\n                            return false;\n                        if (cp < 0xde0)\n                            return true;\n                        if (cp < 0xde6)\n                            return false;\n                        if (cp < 0xdf0)\n                            return true;\n                        if (cp < 0xdf2)\n                            return false;\n                        if (cp < 0xdf4)\n                            return true;\n                        return false;\n                    }\n                    if (cp === 0xe31)\n                        return true;\n                    if (cp < 0xe34)\n                        return false;\n                    if (cp < 0xe3b)\n                        return true;\n                    if (cp < 0xe47)\n                        return false;\n                    if (cp < 0xe4f)\n                        return true;\n                    if (cp < 0xe50)\n                        return false;\n                    if (cp < 0xe5a)\n                        return true;\n                    if (cp === 0xeb1)\n                        return true;\n                    if (cp < 0xeb4)\n                        return false;\n                    if (cp < 0xeba)\n                        return true;\n                    if (cp < 0xebb)\n                        return false;\n                    if (cp < 0xebd)\n                        return true;\n                    if (cp < 0xec8)\n                        return false;\n                    if (cp < 0xece)\n                        return true;\n                    if (cp < 0xed0)\n                        return false;\n                    if (cp < 0xeda)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xf80) {\n                    if (cp < 0xf18)\n                        return false;\n                    if (cp < 0xf1a)\n                        return true;\n                    if (cp < 0xf20)\n                        return false;\n                    if (cp < 0xf2a)\n                        return true;\n                    if (cp === 0xf35)\n                        return true;\n                    if (cp === 0xf37)\n                        return true;\n                    if (cp === 0xf39)\n                        return true;\n                    if (cp < 0xf3e)\n                        return false;\n                    if (cp < 0xf40)\n                        return true;\n                    if (cp < 0xf71)\n                        return false;\n                    if (cp < 0xf7f)\n                        return true;\n                    if (cp === 0xf7f)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xf85)\n                    return true;\n                if (cp < 0xf86)\n                    return false;\n                if (cp < 0xf88)\n                    return true;\n                if (cp < 0xf8d)\n                    return false;\n                if (cp < 0xf98)\n                    return true;\n                if (cp < 0xf99)\n                    return false;\n                if (cp < 0xfbd)\n                    return true;\n                if (cp === 0xfc6)\n                    return true;\n                if (cp < 0x102b)\n                    return false;\n                if (cp < 0x102d)\n                    return true;\n                if (cp < 0x102d)\n                    return false;\n                if (cp < 0x1031)\n                    return true;\n                if (cp === 0x1031)\n                    return true;\n                if (cp < 0x1032)\n                    return false;\n                if (cp < 0x1038)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1090) {\n                if (cp < 0x1062) {\n                    if (cp === 0x1038)\n                        return true;\n                    if (cp < 0x1039)\n                        return false;\n                    if (cp < 0x103b)\n                        return true;\n                    if (cp < 0x103b)\n                        return false;\n                    if (cp < 0x103d)\n                        return true;\n                    if (cp < 0x103d)\n                        return false;\n                    if (cp < 0x103f)\n                        return true;\n                    if (cp < 0x1040)\n                        return false;\n                    if (cp < 0x104a)\n                        return true;\n                    if (cp < 0x1056)\n                        return false;\n                    if (cp < 0x1058)\n                        return true;\n                    if (cp < 0x1058)\n                        return false;\n                    if (cp < 0x105a)\n                        return true;\n                    if (cp < 0x105e)\n                        return false;\n                    if (cp < 0x1061)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x1065)\n                    return true;\n                if (cp < 0x1067)\n                    return false;\n                if (cp < 0x106e)\n                    return true;\n                if (cp < 0x1071)\n                    return false;\n                if (cp < 0x1075)\n                    return true;\n                if (cp === 0x1082)\n                    return true;\n                if (cp < 0x1083)\n                    return false;\n                if (cp < 0x1085)\n                    return true;\n                if (cp < 0x1085)\n                    return false;\n                if (cp < 0x1087)\n                    return true;\n                if (cp < 0x1087)\n                    return false;\n                if (cp < 0x108d)\n                    return true;\n                if (cp === 0x108d)\n                    return true;\n                if (cp === 0x108f)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1772) {\n                if (cp < 0x1090)\n                    return false;\n                if (cp < 0x109a)\n                    return true;\n                if (cp < 0x109a)\n                    return false;\n                if (cp < 0x109d)\n                    return true;\n                if (cp === 0x109d)\n                    return true;\n                if (cp < 0x135d)\n                    return false;\n                if (cp < 0x1360)\n                    return true;\n                if (cp < 0x1369)\n                    return false;\n                if (cp < 0x1372)\n                    return true;\n                if (cp < 0x1712)\n                    return false;\n                if (cp < 0x1715)\n                    return true;\n                if (cp < 0x1732)\n                    return false;\n                if (cp < 0x1735)\n                    return true;\n                if (cp < 0x1752)\n                    return false;\n                if (cp < 0x1754)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1774)\n                return true;\n            if (cp < 0x17b4)\n                return false;\n            if (cp < 0x17b6)\n                return true;\n            if (cp === 0x17b6)\n                return true;\n            if (cp < 0x17b7)\n                return false;\n            if (cp < 0x17be)\n                return true;\n            if (cp < 0x17be)\n                return false;\n            if (cp < 0x17c6)\n                return true;\n            if (cp === 0x17c6)\n                return true;\n            if (cp < 0x17c7)\n                return false;\n            if (cp < 0x17c9)\n                return true;\n            if (cp < 0x17c9)\n                return false;\n            if (cp < 0x17d4)\n                return true;\n            if (cp === 0x17dd)\n                return true;\n            return false;\n        }\n        if (cp < 0x1b04) {\n            if (cp < 0x1a1b) {\n                if (cp < 0x1930) {\n                    if (cp < 0x17e0)\n                        return false;\n                    if (cp < 0x17ea)\n                        return true;\n                    if (cp < 0x180b)\n                        return false;\n                    if (cp < 0x180e)\n                        return true;\n                    if (cp < 0x1810)\n                        return false;\n                    if (cp < 0x181a)\n                        return true;\n                    if (cp === 0x18a9)\n                        return true;\n                    if (cp < 0x1920)\n                        return false;\n                    if (cp < 0x1923)\n                        return true;\n                    if (cp < 0x1923)\n                        return false;\n                    if (cp < 0x1927)\n                        return true;\n                    if (cp < 0x1927)\n                        return false;\n                    if (cp < 0x1929)\n                        return true;\n                    if (cp < 0x1929)\n                        return false;\n                    if (cp < 0x192c)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x1932)\n                    return true;\n                if (cp === 0x1932)\n                    return true;\n                if (cp < 0x1933)\n                    return false;\n                if (cp < 0x1939)\n                    return true;\n                if (cp < 0x1939)\n                    return false;\n                if (cp < 0x193c)\n                    return true;\n                if (cp < 0x1946)\n                    return false;\n                if (cp < 0x1950)\n                    return true;\n                if (cp < 0x19d0)\n                    return false;\n                if (cp < 0x19da)\n                    return true;\n                if (cp === 0x19da)\n                    return true;\n                if (cp < 0x1a17)\n                    return false;\n                if (cp < 0x1a19)\n                    return true;\n                if (cp < 0x1a19)\n                    return false;\n                if (cp < 0x1a1b)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1a63) {\n                if (cp === 0x1a1b)\n                    return true;\n                if (cp === 0x1a55)\n                    return true;\n                if (cp === 0x1a56)\n                    return true;\n                if (cp === 0x1a57)\n                    return true;\n                if (cp < 0x1a58)\n                    return false;\n                if (cp < 0x1a5f)\n                    return true;\n                if (cp === 0x1a60)\n                    return true;\n                if (cp === 0x1a61)\n                    return true;\n                if (cp === 0x1a62)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1a65)\n                return true;\n            if (cp < 0x1a65)\n                return false;\n            if (cp < 0x1a6d)\n                return true;\n            if (cp < 0x1a6d)\n                return false;\n            if (cp < 0x1a73)\n                return true;\n            if (cp < 0x1a73)\n                return false;\n            if (cp < 0x1a7d)\n                return true;\n            if (cp === 0x1a7f)\n                return true;\n            if (cp < 0x1a80)\n                return false;\n            if (cp < 0x1a8a)\n                return true;\n            if (cp < 0x1a90)\n                return false;\n            if (cp < 0x1a9a)\n                return true;\n            if (cp < 0x1ab0)\n                return false;\n            if (cp < 0x1abe)\n                return true;\n            if (cp < 0x1b00)\n                return false;\n            if (cp < 0x1b04)\n                return true;\n            return false;\n        }\n        if (cp < 0x1baa) {\n            if (cp < 0x1b43) {\n                if (cp === 0x1b04)\n                    return true;\n                if (cp === 0x1b34)\n                    return true;\n                if (cp === 0x1b35)\n                    return true;\n                if (cp < 0x1b36)\n                    return false;\n                if (cp < 0x1b3b)\n                    return true;\n                if (cp === 0x1b3b)\n                    return true;\n                if (cp === 0x1b3c)\n                    return true;\n                if (cp < 0x1b3d)\n                    return false;\n                if (cp < 0x1b42)\n                    return true;\n                if (cp === 0x1b42)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1b45)\n                return true;\n            if (cp < 0x1b50)\n                return false;\n            if (cp < 0x1b5a)\n                return true;\n            if (cp < 0x1b6b)\n                return false;\n            if (cp < 0x1b74)\n                return true;\n            if (cp < 0x1b80)\n                return false;\n            if (cp < 0x1b82)\n                return true;\n            if (cp === 0x1b82)\n                return true;\n            if (cp === 0x1ba1)\n                return true;\n            if (cp < 0x1ba2)\n                return false;\n            if (cp < 0x1ba6)\n                return true;\n            if (cp < 0x1ba6)\n                return false;\n            if (cp < 0x1ba8)\n                return true;\n            if (cp < 0x1ba8)\n                return false;\n            if (cp < 0x1baa)\n                return true;\n            return false;\n        }\n        if (cp < 0x1bee) {\n            if (cp === 0x1baa)\n                return true;\n            if (cp < 0x1bab)\n                return false;\n            if (cp < 0x1bae)\n                return true;\n            if (cp < 0x1bb0)\n                return false;\n            if (cp < 0x1bba)\n                return true;\n            if (cp === 0x1be6)\n                return true;\n            if (cp === 0x1be7)\n                return true;\n            if (cp < 0x1be8)\n                return false;\n            if (cp < 0x1bea)\n                return true;\n            if (cp < 0x1bea)\n                return false;\n            if (cp < 0x1bed)\n                return true;\n            if (cp === 0x1bed)\n                return true;\n            return false;\n        }\n        if (cp === 0x1bee)\n            return true;\n        if (cp < 0x1bef)\n            return false;\n        if (cp < 0x1bf2)\n            return true;\n        if (cp < 0x1bf2)\n            return false;\n        if (cp < 0x1bf4)\n            return true;\n        if (cp < 0x1c24)\n            return false;\n        if (cp < 0x1c2c)\n            return true;\n        if (cp < 0x1c2c)\n            return false;\n        if (cp < 0x1c34)\n            return true;\n        if (cp < 0x1c34)\n            return false;\n        if (cp < 0x1c36)\n            return true;\n        if (cp < 0x1c36)\n            return false;\n        if (cp < 0x1c38)\n            return true;\n        if (cp < 0x1c40)\n            return false;\n        if (cp < 0x1c4a)\n            return true;\n        if (cp < 0x1c50)\n            return false;\n        if (cp < 0x1c5a)\n            return true;\n        return false;\n    }\n    if (cp < 0x1123e) {\n        if (cp < 0xaab7) {\n            if (cp < 0xa8b4) {\n                if (cp < 0x2d7f) {\n                    if (cp < 0x1cf8) {\n                        if (cp < 0x1cd0)\n                            return false;\n                        if (cp < 0x1cd3)\n                            return true;\n                        if (cp < 0x1cd4)\n                            return false;\n                        if (cp < 0x1ce1)\n                            return true;\n                        if (cp === 0x1ce1)\n                            return true;\n                        if (cp < 0x1ce2)\n                            return false;\n                        if (cp < 0x1ce9)\n                            return true;\n                        if (cp === 0x1ced)\n                            return true;\n                        if (cp < 0x1cf2)\n                            return false;\n                        if (cp < 0x1cf4)\n                            return true;\n                        if (cp === 0x1cf4)\n                            return true;\n                        if (cp === 0x1cf7)\n                            return true;\n                        return false;\n                    }\n                    if (cp < 0x1cfa)\n                        return true;\n                    if (cp < 0x1dc0)\n                        return false;\n                    if (cp < 0x1dfa)\n                        return true;\n                    if (cp < 0x1dfb)\n                        return false;\n                    if (cp < 0x1e00)\n                        return true;\n                    if (cp < 0x203f)\n                        return false;\n                    if (cp < 0x2041)\n                        return true;\n                    if (cp === 0x2054)\n                        return true;\n                    if (cp < 0x20d0)\n                        return false;\n                    if (cp < 0x20dd)\n                        return true;\n                    if (cp === 0x20e1)\n                        return true;\n                    if (cp < 0x20e5)\n                        return false;\n                    if (cp < 0x20f1)\n                        return true;\n                    if (cp < 0x2cef)\n                        return false;\n                    if (cp < 0x2cf2)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xa69e) {\n                    if (cp === 0x2d7f)\n                        return true;\n                    if (cp < 0x2de0)\n                        return false;\n                    if (cp < 0x2e00)\n                        return true;\n                    if (cp < 0x302a)\n                        return false;\n                    if (cp < 0x302e)\n                        return true;\n                    if (cp < 0x302e)\n                        return false;\n                    if (cp < 0x3030)\n                        return true;\n                    if (cp < 0x3099)\n                        return false;\n                    if (cp < 0x309b)\n                        return true;\n                    if (cp < 0xa620)\n                        return false;\n                    if (cp < 0xa62a)\n                        return true;\n                    if (cp === 0xa66f)\n                        return true;\n                    if (cp < 0xa674)\n                        return false;\n                    if (cp < 0xa67e)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xa6a0)\n                    return true;\n                if (cp < 0xa6f0)\n                    return false;\n                if (cp < 0xa6f2)\n                    return true;\n                if (cp === 0xa802)\n                    return true;\n                if (cp === 0xa806)\n                    return true;\n                if (cp === 0xa80b)\n                    return true;\n                if (cp < 0xa823)\n                    return false;\n                if (cp < 0xa825)\n                    return true;\n                if (cp < 0xa825)\n                    return false;\n                if (cp < 0xa827)\n                    return true;\n                if (cp === 0xa827)\n                    return true;\n                if (cp < 0xa880)\n                    return false;\n                if (cp < 0xa882)\n                    return true;\n                return false;\n            }\n            if (cp < 0xa9d0) {\n                if (cp < 0xa952) {\n                    if (cp < 0xa8b4)\n                        return false;\n                    if (cp < 0xa8c4)\n                        return true;\n                    if (cp < 0xa8c4)\n                        return false;\n                    if (cp < 0xa8c6)\n                        return true;\n                    if (cp < 0xa8d0)\n                        return false;\n                    if (cp < 0xa8da)\n                        return true;\n                    if (cp < 0xa8e0)\n                        return false;\n                    if (cp < 0xa8f2)\n                        return true;\n                    if (cp === 0xa8ff)\n                        return true;\n                    if (cp < 0xa900)\n                        return false;\n                    if (cp < 0xa90a)\n                        return true;\n                    if (cp < 0xa926)\n                        return false;\n                    if (cp < 0xa92e)\n                        return true;\n                    if (cp < 0xa947)\n                        return false;\n                    if (cp < 0xa952)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xa954)\n                    return true;\n                if (cp < 0xa980)\n                    return false;\n                if (cp < 0xa983)\n                    return true;\n                if (cp === 0xa983)\n                    return true;\n                if (cp === 0xa9b3)\n                    return true;\n                if (cp < 0xa9b4)\n                    return false;\n                if (cp < 0xa9b6)\n                    return true;\n                if (cp < 0xa9b6)\n                    return false;\n                if (cp < 0xa9ba)\n                    return true;\n                if (cp < 0xa9ba)\n                    return false;\n                if (cp < 0xa9bc)\n                    return true;\n                if (cp === 0xa9bc)\n                    return true;\n                if (cp < 0xa9bd)\n                    return false;\n                if (cp < 0xa9c1)\n                    return true;\n                return false;\n            }\n            if (cp < 0xaa43) {\n                if (cp < 0xa9d0)\n                    return false;\n                if (cp < 0xa9da)\n                    return true;\n                if (cp === 0xa9e5)\n                    return true;\n                if (cp < 0xa9f0)\n                    return false;\n                if (cp < 0xa9fa)\n                    return true;\n                if (cp < 0xaa29)\n                    return false;\n                if (cp < 0xaa2f)\n                    return true;\n                if (cp < 0xaa2f)\n                    return false;\n                if (cp < 0xaa31)\n                    return true;\n                if (cp < 0xaa31)\n                    return false;\n                if (cp < 0xaa33)\n                    return true;\n                if (cp < 0xaa33)\n                    return false;\n                if (cp < 0xaa35)\n                    return true;\n                if (cp < 0xaa35)\n                    return false;\n                if (cp < 0xaa37)\n                    return true;\n                return false;\n            }\n            if (cp === 0xaa43)\n                return true;\n            if (cp === 0xaa4c)\n                return true;\n            if (cp === 0xaa4d)\n                return true;\n            if (cp < 0xaa50)\n                return false;\n            if (cp < 0xaa5a)\n                return true;\n            if (cp === 0xaa7b)\n                return true;\n            if (cp === 0xaa7c)\n                return true;\n            if (cp === 0xaa7d)\n                return true;\n            if (cp === 0xaab0)\n                return true;\n            if (cp < 0xaab2)\n                return false;\n            if (cp < 0xaab5)\n                return true;\n            return false;\n        }\n        if (cp < 0x10d30) {\n            if (cp < 0xfe00) {\n                if (cp < 0xabe3) {\n                    if (cp < 0xaab7)\n                        return false;\n                    if (cp < 0xaab9)\n                        return true;\n                    if (cp < 0xaabe)\n                        return false;\n                    if (cp < 0xaac0)\n                        return true;\n                    if (cp === 0xaac1)\n                        return true;\n                    if (cp === 0xaaeb)\n                        return true;\n                    if (cp < 0xaaec)\n                        return false;\n                    if (cp < 0xaaee)\n                        return true;\n                    if (cp < 0xaaee)\n                        return false;\n                    if (cp < 0xaaf0)\n                        return true;\n                    if (cp === 0xaaf5)\n                        return true;\n                    if (cp === 0xaaf6)\n                        return true;\n                    return false;\n                }\n                if (cp < 0xabe5)\n                    return true;\n                if (cp === 0xabe5)\n                    return true;\n                if (cp < 0xabe6)\n                    return false;\n                if (cp < 0xabe8)\n                    return true;\n                if (cp === 0xabe8)\n                    return true;\n                if (cp < 0xabe9)\n                    return false;\n                if (cp < 0xabeb)\n                    return true;\n                if (cp === 0xabec)\n                    return true;\n                if (cp === 0xabed)\n                    return true;\n                if (cp < 0xabf0)\n                    return false;\n                if (cp < 0xabfa)\n                    return true;\n                if (cp === 0xfb1e)\n                    return true;\n                return false;\n            }\n            if (cp < 0x10376) {\n                if (cp < 0xfe00)\n                    return false;\n                if (cp < 0xfe10)\n                    return true;\n                if (cp < 0xfe20)\n                    return false;\n                if (cp < 0xfe30)\n                    return true;\n                if (cp < 0xfe33)\n                    return false;\n                if (cp < 0xfe35)\n                    return true;\n                if (cp < 0xfe4d)\n                    return false;\n                if (cp < 0xfe50)\n                    return true;\n                if (cp < 0xff10)\n                    return false;\n                if (cp < 0xff1a)\n                    return true;\n                if (cp === 0xff3f)\n                    return true;\n                if (cp === 0x101fd)\n                    return true;\n                if (cp === 0x102e0)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1037b)\n                return true;\n            if (cp < 0x104a0)\n                return false;\n            if (cp < 0x104aa)\n                return true;\n            if (cp < 0x10a01)\n                return false;\n            if (cp < 0x10a04)\n                return true;\n            if (cp < 0x10a05)\n                return false;\n            if (cp < 0x10a07)\n                return true;\n            if (cp < 0x10a0c)\n                return false;\n            if (cp < 0x10a10)\n                return true;\n            if (cp < 0x10a38)\n                return false;\n            if (cp < 0x10a3b)\n                return true;\n            if (cp === 0x10a3f)\n                return true;\n            if (cp < 0x10ae5)\n                return false;\n            if (cp < 0x10ae7)\n                return true;\n            if (cp < 0x10d24)\n                return false;\n            if (cp < 0x10d28)\n                return true;\n            return false;\n        }\n        if (cp < 0x1112d) {\n            if (cp < 0x11082) {\n                if (cp < 0x10d30)\n                    return false;\n                if (cp < 0x10d3a)\n                    return true;\n                if (cp < 0x10f46)\n                    return false;\n                if (cp < 0x10f51)\n                    return true;\n                if (cp === 0x11000)\n                    return true;\n                if (cp === 0x11001)\n                    return true;\n                if (cp === 0x11002)\n                    return true;\n                if (cp < 0x11038)\n                    return false;\n                if (cp < 0x11047)\n                    return true;\n                if (cp < 0x11066)\n                    return false;\n                if (cp < 0x11070)\n                    return true;\n                if (cp < 0x1107f)\n                    return false;\n                if (cp < 0x11082)\n                    return true;\n                return false;\n            }\n            if (cp === 0x11082)\n                return true;\n            if (cp < 0x110b0)\n                return false;\n            if (cp < 0x110b3)\n                return true;\n            if (cp < 0x110b3)\n                return false;\n            if (cp < 0x110b7)\n                return true;\n            if (cp < 0x110b7)\n                return false;\n            if (cp < 0x110b9)\n                return true;\n            if (cp < 0x110b9)\n                return false;\n            if (cp < 0x110bb)\n                return true;\n            if (cp < 0x110f0)\n                return false;\n            if (cp < 0x110fa)\n                return true;\n            if (cp < 0x11100)\n                return false;\n            if (cp < 0x11103)\n                return true;\n            if (cp < 0x11127)\n                return false;\n            if (cp < 0x1112c)\n                return true;\n            if (cp === 0x1112c)\n                return true;\n            return false;\n        }\n        if (cp < 0x111bf) {\n            if (cp < 0x1112d)\n                return false;\n            if (cp < 0x11135)\n                return true;\n            if (cp < 0x11136)\n                return false;\n            if (cp < 0x11140)\n                return true;\n            if (cp < 0x11145)\n                return false;\n            if (cp < 0x11147)\n                return true;\n            if (cp === 0x11173)\n                return true;\n            if (cp < 0x11180)\n                return false;\n            if (cp < 0x11182)\n                return true;\n            if (cp === 0x11182)\n                return true;\n            if (cp < 0x111b3)\n                return false;\n            if (cp < 0x111b6)\n                return true;\n            if (cp < 0x111b6)\n                return false;\n            if (cp < 0x111bf)\n                return true;\n            return false;\n        }\n        if (cp < 0x111c1)\n            return true;\n        if (cp < 0x111c9)\n            return false;\n        if (cp < 0x111cd)\n            return true;\n        if (cp < 0x111d0)\n            return false;\n        if (cp < 0x111da)\n            return true;\n        if (cp < 0x1122c)\n            return false;\n        if (cp < 0x1122f)\n            return true;\n        if (cp < 0x1122f)\n            return false;\n        if (cp < 0x11232)\n            return true;\n        if (cp < 0x11232)\n            return false;\n        if (cp < 0x11234)\n            return true;\n        if (cp === 0x11234)\n            return true;\n        if (cp === 0x11235)\n            return true;\n        if (cp < 0x11236)\n            return false;\n        if (cp < 0x11238)\n            return true;\n        return false;\n    }\n    if (cp < 0x11a33) {\n        if (cp < 0x115af) {\n            if (cp < 0x11435) {\n                if (cp < 0x1133e) {\n                    if (cp === 0x1123e)\n                        return true;\n                    if (cp === 0x112df)\n                        return true;\n                    if (cp < 0x112e0)\n                        return false;\n                    if (cp < 0x112e3)\n                        return true;\n                    if (cp < 0x112e3)\n                        return false;\n                    if (cp < 0x112eb)\n                        return true;\n                    if (cp < 0x112f0)\n                        return false;\n                    if (cp < 0x112fa)\n                        return true;\n                    if (cp < 0x11300)\n                        return false;\n                    if (cp < 0x11302)\n                        return true;\n                    if (cp < 0x11302)\n                        return false;\n                    if (cp < 0x11304)\n                        return true;\n                    if (cp < 0x1133b)\n                        return false;\n                    if (cp < 0x1133d)\n                        return true;\n                    return false;\n                }\n                if (cp < 0x11340)\n                    return true;\n                if (cp === 0x11340)\n                    return true;\n                if (cp < 0x11341)\n                    return false;\n                if (cp < 0x11345)\n                    return true;\n                if (cp < 0x11347)\n                    return false;\n                if (cp < 0x11349)\n                    return true;\n                if (cp < 0x1134b)\n                    return false;\n                if (cp < 0x1134e)\n                    return true;\n                if (cp === 0x11357)\n                    return true;\n                if (cp < 0x11362)\n                    return false;\n                if (cp < 0x11364)\n                    return true;\n                if (cp < 0x11366)\n                    return false;\n                if (cp < 0x1136d)\n                    return true;\n                if (cp < 0x11370)\n                    return false;\n                if (cp < 0x11375)\n                    return true;\n                return false;\n            }\n            if (cp < 0x114b0) {\n                if (cp < 0x11435)\n                    return false;\n                if (cp < 0x11438)\n                    return true;\n                if (cp < 0x11438)\n                    return false;\n                if (cp < 0x11440)\n                    return true;\n                if (cp < 0x11440)\n                    return false;\n                if (cp < 0x11442)\n                    return true;\n                if (cp < 0x11442)\n                    return false;\n                if (cp < 0x11445)\n                    return true;\n                if (cp === 0x11445)\n                    return true;\n                if (cp === 0x11446)\n                    return true;\n                if (cp < 0x11450)\n                    return false;\n                if (cp < 0x1145a)\n                    return true;\n                if (cp === 0x1145e)\n                    return true;\n                return false;\n            }\n            if (cp < 0x114b3)\n                return true;\n            if (cp < 0x114b3)\n                return false;\n            if (cp < 0x114b9)\n                return true;\n            if (cp === 0x114b9)\n                return true;\n            if (cp === 0x114ba)\n                return true;\n            if (cp < 0x114bb)\n                return false;\n            if (cp < 0x114bf)\n                return true;\n            if (cp < 0x114bf)\n                return false;\n            if (cp < 0x114c1)\n                return true;\n            if (cp === 0x114c1)\n                return true;\n            if (cp < 0x114c2)\n                return false;\n            if (cp < 0x114c4)\n                return true;\n            if (cp < 0x114d0)\n                return false;\n            if (cp < 0x114da)\n                return true;\n            return false;\n        }\n        if (cp < 0x116ae) {\n            if (cp < 0x11633) {\n                if (cp < 0x115af)\n                    return false;\n                if (cp < 0x115b2)\n                    return true;\n                if (cp < 0x115b2)\n                    return false;\n                if (cp < 0x115b6)\n                    return true;\n                if (cp < 0x115b8)\n                    return false;\n                if (cp < 0x115bc)\n                    return true;\n                if (cp < 0x115bc)\n                    return false;\n                if (cp < 0x115be)\n                    return true;\n                if (cp === 0x115be)\n                    return true;\n                if (cp < 0x115bf)\n                    return false;\n                if (cp < 0x115c1)\n                    return true;\n                if (cp < 0x115dc)\n                    return false;\n                if (cp < 0x115de)\n                    return true;\n                if (cp < 0x11630)\n                    return false;\n                if (cp < 0x11633)\n                    return true;\n                return false;\n            }\n            if (cp < 0x1163b)\n                return true;\n            if (cp < 0x1163b)\n                return false;\n            if (cp < 0x1163d)\n                return true;\n            if (cp === 0x1163d)\n                return true;\n            if (cp === 0x1163e)\n                return true;\n            if (cp < 0x1163f)\n                return false;\n            if (cp < 0x11641)\n                return true;\n            if (cp < 0x11650)\n                return false;\n            if (cp < 0x1165a)\n                return true;\n            if (cp === 0x116ab)\n                return true;\n            if (cp === 0x116ac)\n                return true;\n            if (cp === 0x116ad)\n                return true;\n            return false;\n        }\n        if (cp < 0x11726) {\n            if (cp < 0x116ae)\n                return false;\n            if (cp < 0x116b0)\n                return true;\n            if (cp < 0x116b0)\n                return false;\n            if (cp < 0x116b6)\n                return true;\n            if (cp === 0x116b6)\n                return true;\n            if (cp === 0x116b7)\n                return true;\n            if (cp < 0x116c0)\n                return false;\n            if (cp < 0x116ca)\n                return true;\n            if (cp < 0x1171d)\n                return false;\n            if (cp < 0x11720)\n                return true;\n            if (cp < 0x11720)\n                return false;\n            if (cp < 0x11722)\n                return true;\n            if (cp < 0x11722)\n                return false;\n            if (cp < 0x11726)\n                return true;\n            return false;\n        }\n        if (cp === 0x11726)\n            return true;\n        if (cp < 0x11727)\n            return false;\n        if (cp < 0x1172c)\n            return true;\n        if (cp < 0x11730)\n            return false;\n        if (cp < 0x1173a)\n            return true;\n        if (cp < 0x1182c)\n            return false;\n        if (cp < 0x1182f)\n            return true;\n        if (cp < 0x1182f)\n            return false;\n        if (cp < 0x11838)\n            return true;\n        if (cp === 0x11838)\n            return true;\n        if (cp < 0x11839)\n            return false;\n        if (cp < 0x1183b)\n            return true;\n        if (cp < 0x118e0)\n            return false;\n        if (cp < 0x118ea)\n            return true;\n        if (cp < 0x11a01)\n            return false;\n        if (cp < 0x11a0b)\n            return true;\n        return false;\n    }\n    if (cp < 0x11d97) {\n        if (cp < 0x11ca9) {\n            if (cp < 0x11a97) {\n                if (cp < 0x11a33)\n                    return false;\n                if (cp < 0x11a39)\n                    return true;\n                if (cp === 0x11a39)\n                    return true;\n                if (cp < 0x11a3b)\n                    return false;\n                if (cp < 0x11a3f)\n                    return true;\n                if (cp === 0x11a47)\n                    return true;\n                if (cp < 0x11a51)\n                    return false;\n                if (cp < 0x11a57)\n                    return true;\n                if (cp < 0x11a57)\n                    return false;\n                if (cp < 0x11a59)\n                    return true;\n                if (cp < 0x11a59)\n                    return false;\n                if (cp < 0x11a5c)\n                    return true;\n                if (cp < 0x11a8a)\n                    return false;\n                if (cp < 0x11a97)\n                    return true;\n                return false;\n            }\n            if (cp === 0x11a97)\n                return true;\n            if (cp < 0x11a98)\n                return false;\n            if (cp < 0x11a9a)\n                return true;\n            if (cp === 0x11c2f)\n                return true;\n            if (cp < 0x11c30)\n                return false;\n            if (cp < 0x11c37)\n                return true;\n            if (cp < 0x11c38)\n                return false;\n            if (cp < 0x11c3e)\n                return true;\n            if (cp === 0x11c3e)\n                return true;\n            if (cp === 0x11c3f)\n                return true;\n            if (cp < 0x11c50)\n                return false;\n            if (cp < 0x11c5a)\n                return true;\n            if (cp < 0x11c92)\n                return false;\n            if (cp < 0x11ca8)\n                return true;\n            return false;\n        }\n        if (cp < 0x11d3c) {\n            if (cp === 0x11ca9)\n                return true;\n            if (cp < 0x11caa)\n                return false;\n            if (cp < 0x11cb1)\n                return true;\n            if (cp === 0x11cb1)\n                return true;\n            if (cp < 0x11cb2)\n                return false;\n            if (cp < 0x11cb4)\n                return true;\n            if (cp === 0x11cb4)\n                return true;\n            if (cp < 0x11cb5)\n                return false;\n            if (cp < 0x11cb7)\n                return true;\n            if (cp < 0x11d31)\n                return false;\n            if (cp < 0x11d37)\n                return true;\n            if (cp === 0x11d3a)\n                return true;\n            return false;\n        }\n        if (cp < 0x11d3e)\n            return true;\n        if (cp < 0x11d3f)\n            return false;\n        if (cp < 0x11d46)\n            return true;\n        if (cp === 0x11d47)\n            return true;\n        if (cp < 0x11d50)\n            return false;\n        if (cp < 0x11d5a)\n            return true;\n        if (cp < 0x11d8a)\n            return false;\n        if (cp < 0x11d8f)\n            return true;\n        if (cp < 0x11d90)\n            return false;\n        if (cp < 0x11d92)\n            return true;\n        if (cp < 0x11d93)\n            return false;\n        if (cp < 0x11d95)\n            return true;\n        if (cp === 0x11d95)\n            return true;\n        if (cp === 0x11d96)\n            return true;\n        return false;\n    }\n    if (cp < 0x1d242) {\n        if (cp < 0x16f51) {\n            if (cp === 0x11d97)\n                return true;\n            if (cp < 0x11da0)\n                return false;\n            if (cp < 0x11daa)\n                return true;\n            if (cp < 0x11ef3)\n                return false;\n            if (cp < 0x11ef5)\n                return true;\n            if (cp < 0x11ef5)\n                return false;\n            if (cp < 0x11ef7)\n                return true;\n            if (cp < 0x16a60)\n                return false;\n            if (cp < 0x16a6a)\n                return true;\n            if (cp < 0x16af0)\n                return false;\n            if (cp < 0x16af5)\n                return true;\n            if (cp < 0x16b30)\n                return false;\n            if (cp < 0x16b37)\n                return true;\n            if (cp < 0x16b50)\n                return false;\n            if (cp < 0x16b5a)\n                return true;\n            return false;\n        }\n        if (cp < 0x16f7f)\n            return true;\n        if (cp < 0x16f8f)\n            return false;\n        if (cp < 0x16f93)\n            return true;\n        if (cp < 0x1bc9d)\n            return false;\n        if (cp < 0x1bc9f)\n            return true;\n        if (cp < 0x1d165)\n            return false;\n        if (cp < 0x1d167)\n            return true;\n        if (cp < 0x1d167)\n            return false;\n        if (cp < 0x1d16a)\n            return true;\n        if (cp < 0x1d16d)\n            return false;\n        if (cp < 0x1d173)\n            return true;\n        if (cp < 0x1d17b)\n            return false;\n        if (cp < 0x1d183)\n            return true;\n        if (cp < 0x1d185)\n            return false;\n        if (cp < 0x1d18c)\n            return true;\n        if (cp < 0x1d1aa)\n            return false;\n        if (cp < 0x1d1ae)\n            return true;\n        return false;\n    }\n    if (cp < 0x1e000) {\n        if (cp < 0x1d242)\n            return false;\n        if (cp < 0x1d245)\n            return true;\n        if (cp < 0x1d7ce)\n            return false;\n        if (cp < 0x1d800)\n            return true;\n        if (cp < 0x1da00)\n            return false;\n        if (cp < 0x1da37)\n            return true;\n        if (cp < 0x1da3b)\n            return false;\n        if (cp < 0x1da6d)\n            return true;\n        if (cp === 0x1da75)\n            return true;\n        if (cp === 0x1da84)\n            return true;\n        if (cp < 0x1da9b)\n            return false;\n        if (cp < 0x1daa0)\n            return true;\n        if (cp < 0x1daa1)\n            return false;\n        if (cp < 0x1dab0)\n            return true;\n        return false;\n    }\n    if (cp < 0x1e007)\n        return true;\n    if (cp < 0x1e008)\n        return false;\n    if (cp < 0x1e019)\n        return true;\n    if (cp < 0x1e01b)\n        return false;\n    if (cp < 0x1e022)\n        return true;\n    if (cp < 0x1e023)\n        return false;\n    if (cp < 0x1e025)\n        return true;\n    if (cp < 0x1e026)\n        return false;\n    if (cp < 0x1e02b)\n        return true;\n    if (cp < 0x1e8d0)\n        return false;\n    if (cp < 0x1e8d7)\n        return true;\n    if (cp < 0x1e944)\n        return false;\n    if (cp < 0x1e94b)\n        return true;\n    if (cp < 0x1e950)\n        return false;\n    if (cp < 0x1e95a)\n        return true;\n    if (cp < 0xe0100)\n        return false;\n    if (cp < 0xe01f0)\n        return true;\n    return false;\n}\n\nconst PropertyData = {\n    $LONE: new Set([\n        \"ASCII\",\n        \"ASCII_Hex_Digit\",\n        \"AHex\",\n        \"Alphabetic\",\n        \"Alpha\",\n        \"Any\",\n        \"Assigned\",\n        \"Bidi_Control\",\n        \"Bidi_C\",\n        \"Bidi_Mirrored\",\n        \"Bidi_M\",\n        \"Case_Ignorable\",\n        \"CI\",\n        \"Cased\",\n        \"Changes_When_Casefolded\",\n        \"CWCF\",\n        \"Changes_When_Casemapped\",\n        \"CWCM\",\n        \"Changes_When_Lowercased\",\n        \"CWL\",\n        \"Changes_When_NFKC_Casefolded\",\n        \"CWKCF\",\n        \"Changes_When_Titlecased\",\n        \"CWT\",\n        \"Changes_When_Uppercased\",\n        \"CWU\",\n        \"Dash\",\n        \"Default_Ignorable_Code_Point\",\n        \"DI\",\n        \"Deprecated\",\n        \"Dep\",\n        \"Diacritic\",\n        \"Dia\",\n        \"Emoji\",\n        \"Emoji_Component\",\n        \"Emoji_Modifier\",\n        \"Emoji_Modifier_Base\",\n        \"Emoji_Presentation\",\n        \"Extender\",\n        \"Ext\",\n        \"Grapheme_Base\",\n        \"Gr_Base\",\n        \"Grapheme_Extend\",\n        \"Gr_Ext\",\n        \"Hex_Digit\",\n        \"Hex\",\n        \"IDS_Binary_Operator\",\n        \"IDSB\",\n        \"IDS_Trinary_Operator\",\n        \"IDST\",\n        \"ID_Continue\",\n        \"IDC\",\n        \"ID_Start\",\n        \"IDS\",\n        \"Ideographic\",\n        \"Ideo\",\n        \"Join_Control\",\n        \"Join_C\",\n        \"Logical_Order_Exception\",\n        \"LOE\",\n        \"Lowercase\",\n        \"Lower\",\n        \"Math\",\n        \"Noncharacter_Code_Point\",\n        \"NChar\",\n        \"Pattern_Syntax\",\n        \"Pat_Syn\",\n        \"Pattern_White_Space\",\n        \"Pat_WS\",\n        \"Quotation_Mark\",\n        \"QMark\",\n        \"Radical\",\n        \"Regional_Indicator\",\n        \"RI\",\n        \"Sentence_Terminal\",\n        \"STerm\",\n        \"Soft_Dotted\",\n        \"SD\",\n        \"Terminal_Punctuation\",\n        \"Term\",\n        \"Unified_Ideograph\",\n        \"UIdeo\",\n        \"Uppercase\",\n        \"Upper\",\n        \"Variation_Selector\",\n        \"VS\",\n        \"White_Space\",\n        \"space\",\n        \"XID_Continue\",\n        \"XIDC\",\n        \"XID_Start\",\n        \"XIDS\",\n    ]),\n    General_Category: new Set([\n        \"Cased_Letter\",\n        \"LC\",\n        \"Close_Punctuation\",\n        \"Pe\",\n        \"Connector_Punctuation\",\n        \"Pc\",\n        \"Control\",\n        \"Cc\",\n        \"cntrl\",\n        \"Currency_Symbol\",\n        \"Sc\",\n        \"Dash_Punctuation\",\n        \"Pd\",\n        \"Decimal_Number\",\n        \"Nd\",\n        \"digit\",\n        \"Enclosing_Mark\",\n        \"Me\",\n        \"Final_Punctuation\",\n        \"Pf\",\n        \"Format\",\n        \"Cf\",\n        \"Initial_Punctuation\",\n        \"Pi\",\n        \"Letter\",\n        \"L\",\n        \"Letter_Number\",\n        \"Nl\",\n        \"Line_Separator\",\n        \"Zl\",\n        \"Lowercase_Letter\",\n        \"Ll\",\n        \"Mark\",\n        \"M\",\n        \"Combining_Mark\",\n        \"Math_Symbol\",\n        \"Sm\",\n        \"Modifier_Letter\",\n        \"Lm\",\n        \"Modifier_Symbol\",\n        \"Sk\",\n        \"Nonspacing_Mark\",\n        \"Mn\",\n        \"Number\",\n        \"N\",\n        \"Open_Punctuation\",\n        \"Ps\",\n        \"Other\",\n        \"C\",\n        \"Other_Letter\",\n        \"Lo\",\n        \"Other_Number\",\n        \"No\",\n        \"Other_Punctuation\",\n        \"Po\",\n        \"Other_Symbol\",\n        \"So\",\n        \"Paragraph_Separator\",\n        \"Zp\",\n        \"Private_Use\",\n        \"Co\",\n        \"Punctuation\",\n        \"P\",\n        \"punct\",\n        \"Separator\",\n        \"Z\",\n        \"Space_Separator\",\n        \"Zs\",\n        \"Spacing_Mark\",\n        \"Mc\",\n        \"Surrogate\",\n        \"Cs\",\n        \"Symbol\",\n        \"S\",\n        \"Titlecase_Letter\",\n        \"Lt\",\n        \"Unassigned\",\n        \"Cn\",\n        \"Uppercase_Letter\",\n        \"Lu\",\n    ]),\n    Script: new Set([\n        \"Adlam\",\n        \"Adlm\",\n        \"Ahom\",\n        \"Anatolian_Hieroglyphs\",\n        \"Hluw\",\n        \"Arabic\",\n        \"Arab\",\n        \"Armenian\",\n        \"Armn\",\n        \"Avestan\",\n        \"Avst\",\n        \"Balinese\",\n        \"Bali\",\n        \"Bamum\",\n        \"Bamu\",\n        \"Bassa_Vah\",\n        \"Bass\",\n        \"Batak\",\n        \"Batk\",\n        \"Bengali\",\n        \"Beng\",\n        \"Bhaiksuki\",\n        \"Bhks\",\n        \"Bopomofo\",\n        \"Bopo\",\n        \"Brahmi\",\n        \"Brah\",\n        \"Braille\",\n        \"Brai\",\n        \"Buginese\",\n        \"Bugi\",\n        \"Buhid\",\n        \"Buhd\",\n        \"Canadian_Aboriginal\",\n        \"Cans\",\n        \"Carian\",\n        \"Cari\",\n        \"Caucasian_Albanian\",\n        \"Aghb\",\n        \"Chakma\",\n        \"Cakm\",\n        \"Cham\",\n        \"Cherokee\",\n        \"Cher\",\n        \"Common\",\n        \"Zyyy\",\n        \"Coptic\",\n        \"Copt\",\n        \"Qaac\",\n        \"Cuneiform\",\n        \"Xsux\",\n        \"Cypriot\",\n        \"Cprt\",\n        \"Cyrillic\",\n        \"Cyrl\",\n        \"Deseret\",\n        \"Dsrt\",\n        \"Devanagari\",\n        \"Deva\",\n        \"Duployan\",\n        \"Dupl\",\n        \"Egyptian_Hieroglyphs\",\n        \"Egyp\",\n        \"Elbasan\",\n        \"Elba\",\n        \"Ethiopic\",\n        \"Ethi\",\n        \"Georgian\",\n        \"Geor\",\n        \"Glagolitic\",\n        \"Glag\",\n        \"Gothic\",\n        \"Goth\",\n        \"Grantha\",\n        \"Gran\",\n        \"Greek\",\n        \"Grek\",\n        \"Gujarati\",\n        \"Gujr\",\n        \"Gurmukhi\",\n        \"Guru\",\n        \"Han\",\n        \"Hani\",\n        \"Hangul\",\n        \"Hang\",\n        \"Hanunoo\",\n        \"Hano\",\n        \"Hatran\",\n        \"Hatr\",\n        \"Hebrew\",\n        \"Hebr\",\n        \"Hiragana\",\n        \"Hira\",\n        \"Imperial_Aramaic\",\n        \"Armi\",\n        \"Inherited\",\n        \"Zinh\",\n        \"Qaai\",\n        \"Inscriptional_Pahlavi\",\n        \"Phli\",\n        \"Inscriptional_Parthian\",\n        \"Prti\",\n        \"Javanese\",\n        \"Java\",\n        \"Kaithi\",\n        \"Kthi\",\n        \"Kannada\",\n        \"Knda\",\n        \"Katakana\",\n        \"Kana\",\n        \"Kayah_Li\",\n        \"Kali\",\n        \"Kharoshthi\",\n        \"Khar\",\n        \"Khmer\",\n        \"Khmr\",\n        \"Khojki\",\n        \"Khoj\",\n        \"Khudawadi\",\n        \"Sind\",\n        \"Lao\",\n        \"Laoo\",\n        \"Latin\",\n        \"Latn\",\n        \"Lepcha\",\n        \"Lepc\",\n        \"Limbu\",\n        \"Limb\",\n        \"Linear_A\",\n        \"Lina\",\n        \"Linear_B\",\n        \"Linb\",\n        \"Lisu\",\n        \"Lycian\",\n        \"Lyci\",\n        \"Lydian\",\n        \"Lydi\",\n        \"Mahajani\",\n        \"Mahj\",\n        \"Malayalam\",\n        \"Mlym\",\n        \"Mandaic\",\n        \"Mand\",\n        \"Manichaean\",\n        \"Mani\",\n        \"Marchen\",\n        \"Marc\",\n        \"Masaram_Gondi\",\n        \"Gonm\",\n        \"Meetei_Mayek\",\n        \"Mtei\",\n        \"Mende_Kikakui\",\n        \"Mend\",\n        \"Meroitic_Cursive\",\n        \"Merc\",\n        \"Meroitic_Hieroglyphs\",\n        \"Mero\",\n        \"Miao\",\n        \"Plrd\",\n        \"Modi\",\n        \"Mongolian\",\n        \"Mong\",\n        \"Mro\",\n        \"Mroo\",\n        \"Multani\",\n        \"Mult\",\n        \"Myanmar\",\n        \"Mymr\",\n        \"Nabataean\",\n        \"Nbat\",\n        \"New_Tai_Lue\",\n        \"Talu\",\n        \"Newa\",\n        \"Nko\",\n        \"Nkoo\",\n        \"Nushu\",\n        \"Nshu\",\n        \"Ogham\",\n        \"Ogam\",\n        \"Ol_Chiki\",\n        \"Olck\",\n        \"Old_Hungarian\",\n        \"Hung\",\n        \"Old_Italic\",\n        \"Ital\",\n        \"Old_North_Arabian\",\n        \"Narb\",\n        \"Old_Permic\",\n        \"Perm\",\n        \"Old_Persian\",\n        \"Xpeo\",\n        \"Old_South_Arabian\",\n        \"Sarb\",\n        \"Old_Turkic\",\n        \"Orkh\",\n        \"Oriya\",\n        \"Orya\",\n        \"Osage\",\n        \"Osge\",\n        \"Osmanya\",\n        \"Osma\",\n        \"Pahawh_Hmong\",\n        \"Hmng\",\n        \"Palmyrene\",\n        \"Palm\",\n        \"Pau_Cin_Hau\",\n        \"Pauc\",\n        \"Phags_Pa\",\n        \"Phag\",\n        \"Phoenician\",\n        \"Phnx\",\n        \"Psalter_Pahlavi\",\n        \"Phlp\",\n        \"Rejang\",\n        \"Rjng\",\n        \"Runic\",\n        \"Runr\",\n        \"Samaritan\",\n        \"Samr\",\n        \"Saurashtra\",\n        \"Saur\",\n        \"Sharada\",\n        \"Shrd\",\n        \"Shavian\",\n        \"Shaw\",\n        \"Siddham\",\n        \"Sidd\",\n        \"SignWriting\",\n        \"Sgnw\",\n        \"Sinhala\",\n        \"Sinh\",\n        \"Sora_Sompeng\",\n        \"Sora\",\n        \"Soyombo\",\n        \"Soyo\",\n        \"Sundanese\",\n        \"Sund\",\n        \"Syloti_Nagri\",\n        \"Sylo\",\n        \"Syriac\",\n        \"Syrc\",\n        \"Tagalog\",\n        \"Tglg\",\n        \"Tagbanwa\",\n        \"Tagb\",\n        \"Tai_Le\",\n        \"Tale\",\n        \"Tai_Tham\",\n        \"Lana\",\n        \"Tai_Viet\",\n        \"Tavt\",\n        \"Takri\",\n        \"Takr\",\n        \"Tamil\",\n        \"Taml\",\n        \"Tangut\",\n        \"Tang\",\n        \"Telugu\",\n        \"Telu\",\n        \"Thaana\",\n        \"Thaa\",\n        \"Thai\",\n        \"Tibetan\",\n        \"Tibt\",\n        \"Tifinagh\",\n        \"Tfng\",\n        \"Tirhuta\",\n        \"Tirh\",\n        \"Ugaritic\",\n        \"Ugar\",\n        \"Vai\",\n        \"Vaii\",\n        \"Warang_Citi\",\n        \"Wara\",\n        \"Yi\",\n        \"Yiii\",\n        \"Zanabazar_Square\",\n        \"Zanb\",\n    ]),\n};\nPropertyData.gc = PropertyData.General_Category;\nPropertyData.sc = PropertyData.Script_Extensions = PropertyData.scx =\n    PropertyData.Script;\n\nconst Backspace = 0x08;\nconst CharacterTabulation = 0x09;\nconst LineFeed = 0x0a;\nconst LineTabulation = 0x0b;\nconst FormFeed = 0x0c;\nconst CarriageReturn = 0x0d;\nconst ExclamationMark = 0x21;\nconst DollarSign = 0x24;\nconst LeftParenthesis = 0x28;\nconst RightParenthesis = 0x29;\nconst Asterisk = 0x2a;\nconst PlusSign = 0x2b;\nconst Comma = 0x2c;\nconst HyphenMinus = 0x2d;\nconst FullStop = 0x2e;\nconst Solidus = 0x2f;\nconst DigitZero = 0x30;\nconst DigitOne = 0x31;\nconst DigitSeven = 0x37;\nconst DigitNine = 0x39;\nconst Colon = 0x3a;\nconst LessThanSign = 0x3c;\nconst EqualsSign = 0x3d;\nconst GreaterThanSign = 0x3e;\nconst QuestionMark = 0x3f;\nconst LatinCapitalLetterA = 0x41;\nconst LatinCapitalLetterB = 0x42;\nconst LatinCapitalLetterD = 0x44;\nconst LatinCapitalLetterF = 0x46;\nconst LatinCapitalLetterP = 0x50;\nconst LatinCapitalLetterS = 0x53;\nconst LatinCapitalLetterW = 0x57;\nconst LatinCapitalLetterZ = 0x5a;\nconst LowLine = 0x5f;\nconst LatinSmallLetterA = 0x61;\nconst LatinSmallLetterB = 0x62;\nconst LatinSmallLetterC = 0x63;\nconst LatinSmallLetterD = 0x64;\nconst LatinSmallLetterF = 0x66;\nconst LatinSmallLetterG = 0x67;\nconst LatinSmallLetterI = 0x69;\nconst LatinSmallLetterK = 0x6b;\nconst LatinSmallLetterM = 0x6d;\nconst LatinSmallLetterN = 0x6e;\nconst LatinSmallLetterP = 0x70;\nconst LatinSmallLetterR = 0x72;\nconst LatinSmallLetterS = 0x73;\nconst LatinSmallLetterT = 0x74;\nconst LatinSmallLetterU = 0x75;\nconst LatinSmallLetterV = 0x76;\nconst LatinSmallLetterW = 0x77;\nconst LatinSmallLetterX = 0x78;\nconst LatinSmallLetterY = 0x79;\nconst LatinSmallLetterZ = 0x7a;\nconst LeftSquareBracket = 0x5b;\nconst ReverseSolidus = 0x5c;\nconst RightSquareBracket = 0x5d;\nconst CircumflexAccent = 0x5e;\nconst LeftCurlyBracket = 0x7b;\nconst VerticalLine = 0x7c;\nconst RightCurlyBracket = 0x7d;\nconst ZeroWidthNonJoiner = 0x200c;\nconst ZeroWidthJoiner = 0x200d;\nconst LineSeparator = 0x2028;\nconst ParagraphSeparator = 0x2029;\nconst MinCodePoint = 0x00;\nconst MaxCodePoint = 0x10ffff;\nfunction isLatinLetter(code) {\n    return ((code >= LatinCapitalLetterA && code <= LatinCapitalLetterZ) ||\n        (code >= LatinSmallLetterA && code <= LatinSmallLetterZ));\n}\nfunction isDecimalDigit$1(code) {\n    return code >= DigitZero && code <= DigitNine;\n}\nfunction isOctalDigit$1(code) {\n    return code >= DigitZero && code <= DigitSeven;\n}\nfunction isHexDigit$1(code) {\n    return ((code >= DigitZero && code <= DigitNine) ||\n        (code >= LatinCapitalLetterA && code <= LatinCapitalLetterF) ||\n        (code >= LatinSmallLetterA && code <= LatinSmallLetterF));\n}\nfunction isLineTerminator(code) {\n    return (code === LineFeed ||\n        code === CarriageReturn ||\n        code === LineSeparator ||\n        code === ParagraphSeparator);\n}\nfunction isValidUnicode$1(code) {\n    return code >= MinCodePoint && code <= MaxCodePoint;\n}\nfunction digitToInt(code) {\n    if (code >= LatinSmallLetterA && code <= LatinSmallLetterF) {\n        return code - LatinSmallLetterA + 10;\n    }\n    if (code >= LatinCapitalLetterA && code <= LatinCapitalLetterF) {\n        return code - LatinCapitalLetterA + 10;\n    }\n    return code - DigitZero;\n}\n\nconst legacyImpl = {\n    at(s, end, i) {\n        return i < end ? s.charCodeAt(i) : -1;\n    },\n    width(c) {\n        return 1;\n    },\n};\nconst unicodeImpl = {\n    at(s, end, i) {\n        return i < end ? s.codePointAt(i) : -1;\n    },\n    width(c) {\n        return c > 0xffff ? 2 : 1;\n    },\n};\nclass Reader {\n    constructor() {\n        this._impl = legacyImpl;\n        this._s = \"\";\n        this._i = 0;\n        this._end = 0;\n        this._cp1 = -1;\n        this._w1 = 1;\n        this._cp2 = -1;\n        this._w2 = 1;\n        this._cp3 = -1;\n        this._w3 = 1;\n        this._cp4 = -1;\n    }\n    get source() {\n        return this._s;\n    }\n    get index() {\n        return this._i;\n    }\n    get currentCodePoint() {\n        return this._cp1;\n    }\n    get nextCodePoint() {\n        return this._cp2;\n    }\n    get nextCodePoint2() {\n        return this._cp3;\n    }\n    get nextCodePoint3() {\n        return this._cp4;\n    }\n    reset(source, start, end, uFlag) {\n        this._impl = uFlag ? unicodeImpl : legacyImpl;\n        this._s = source;\n        this._end = end;\n        this.rewind(start);\n    }\n    rewind(index) {\n        const impl = this._impl;\n        this._i = index;\n        this._cp1 = impl.at(this._s, this._end, index);\n        this._w1 = impl.width(this._cp1);\n        this._cp2 = impl.at(this._s, this._end, index + this._w1);\n        this._w2 = impl.width(this._cp2);\n        this._cp3 = impl.at(this._s, this._end, index + this._w1 + this._w2);\n        this._w3 = impl.width(this._cp3);\n        this._cp4 = impl.at(this._s, this._end, index + this._w1 + this._w2 + this._w3);\n    }\n    advance() {\n        if (this._cp1 !== -1) {\n            const impl = this._impl;\n            this._i += this._w1;\n            this._cp1 = this._cp2;\n            this._w1 = this._w2;\n            this._cp2 = this._cp3;\n            this._w2 = impl.width(this._cp2);\n            this._cp3 = this._cp4;\n            this._w3 = impl.width(this._cp3);\n            this._cp4 = impl.at(this._s, this._end, this._i + this._w1 + this._w2 + this._w3);\n        }\n    }\n    eat(cp) {\n        if (this._cp1 === cp) {\n            this.advance();\n            return true;\n        }\n        return false;\n    }\n    eat2(cp1, cp2) {\n        if (this._cp1 === cp1 && this._cp2 === cp2) {\n            this.advance();\n            this.advance();\n            return true;\n        }\n        return false;\n    }\n    eat3(cp1, cp2, cp3) {\n        if (this._cp1 === cp1 && this._cp2 === cp2 && this._cp3 === cp3) {\n            this.advance();\n            this.advance();\n            this.advance();\n            return true;\n        }\n        return false;\n    }\n}\n\nclass RegExpSyntaxError extends SyntaxError {\n    constructor(source, uFlag, index, message) {\n        if (source) {\n            if (source[0] !== \"/\") {\n                source = `/${source}/${uFlag ? \"u\" : \"\"}`;\n            }\n            source = `: ${source}`;\n        }\n        super(`Invalid regular expression${source}: ${message}`);\n        this.index = index;\n    }\n}\n\nfunction isSyntaxCharacter$1(cp) {\n    return (cp === CircumflexAccent ||\n        cp === DollarSign ||\n        cp === ReverseSolidus ||\n        cp === FullStop ||\n        cp === Asterisk ||\n        cp === PlusSign ||\n        cp === QuestionMark ||\n        cp === LeftParenthesis ||\n        cp === RightParenthesis ||\n        cp === LeftSquareBracket ||\n        cp === RightSquareBracket ||\n        cp === LeftCurlyBracket ||\n        cp === RightCurlyBracket ||\n        cp === VerticalLine);\n}\nfunction isRegExpIdentifierStart$1(cp) {\n    return isIdStart(cp) || cp === DollarSign || cp === LowLine;\n}\nfunction isRegExpIdentifierPart$1(cp) {\n    return (isIdContinue(cp) ||\n        cp === DollarSign ||\n        cp === LowLine ||\n        cp === ZeroWidthNonJoiner ||\n        cp === ZeroWidthJoiner);\n}\nfunction isUnicodePropertyNameCharacter$1(cp) {\n    return isLatinLetter(cp) || cp === LowLine;\n}\nfunction isUnicodePropertyValueCharacter$1(cp) {\n    return isUnicodePropertyNameCharacter$1(cp) || isDecimalDigit$1(cp);\n}\nfunction isValidUnicodeProperty(name, value) {\n    return PropertyData.hasOwnProperty(name) && PropertyData[name].has(value);\n}\nfunction isValidUnicodePropertyName(name) {\n    return PropertyData.$LONE.has(name);\n}\nclass RegExpValidator {\n    constructor(options) {\n        this._reader = new Reader();\n        this._uFlag = false;\n        this._nFlag = false;\n        this._lastIntValue = 0;\n        this._lastMinValue = 0;\n        this._lastMaxValue = 0;\n        this._lastStrValue = \"\";\n        this._lastKeyValue = \"\";\n        this._lastValValue = \"\";\n        this._lastAssertionIsQuantifiable = false;\n        this._numCapturingParens = 0;\n        this._groupNames = new Set();\n        this._backreferenceNames = new Set();\n        this._options = options || {};\n    }\n    validateLiteral(source, start = 0, end = source.length) {\n        this._uFlag = this._nFlag = false;\n        this.reset(source, start, end);\n        this.onLiteralEnter(start);\n        if (this.eat(Solidus) && this.eatRegExpBody() && this.eat(Solidus)) {\n            const flagStart = this.index;\n            const uFlag = source.indexOf(\"u\", flagStart) !== -1;\n            this.validateFlags(source, flagStart, end);\n            this.validatePattern(source, start + 1, flagStart - 1, uFlag);\n        }\n        else if (start >= end) {\n            this.raise(\"Empty\");\n        }\n        else {\n            const c = String.fromCodePoint(this.currentCodePoint);\n            this.raise(`Unexpected character '${c}'`);\n        }\n        this.onLiteralLeave(start, end);\n    }\n    validateFlags(source, start = 0, end = source.length) {\n        const existingFlags = new Set();\n        let global = false;\n        let ignoreCase = false;\n        let multiline = false;\n        let sticky = false;\n        let unicode = false;\n        let dotAll = false;\n        for (let i = start; i < end; ++i) {\n            const flag = source.charCodeAt(i);\n            if (existingFlags.has(flag)) {\n                this.raise(`Duplicated flag '${source[i]}'`);\n            }\n            existingFlags.add(flag);\n            if (flag === LatinSmallLetterG) {\n                global = true;\n            }\n            else if (flag === LatinSmallLetterI) {\n                ignoreCase = true;\n            }\n            else if (flag === LatinSmallLetterM) {\n                multiline = true;\n            }\n            else if (flag === LatinSmallLetterU && this.ecmaVersion >= 2015) {\n                unicode = true;\n            }\n            else if (flag === LatinSmallLetterY && this.ecmaVersion >= 2015) {\n                sticky = true;\n            }\n            else if (flag === LatinSmallLetterS && this.ecmaVersion >= 2018) {\n                dotAll = true;\n            }\n            else {\n                this.raise(`Invalid flag '${source[i]}'`);\n            }\n        }\n        this.onFlags(start, end, global, ignoreCase, multiline, unicode, sticky, dotAll);\n    }\n    validatePattern(source, start = 0, end = source.length, uFlag = false) {\n        this._uFlag = uFlag && this.ecmaVersion >= 2015;\n        this._nFlag = uFlag && this.ecmaVersion >= 2018;\n        this.reset(source, start, end);\n        this.pattern();\n        if (!this._nFlag &&\n            this.ecmaVersion >= 2018 &&\n            this._groupNames.size > 0) {\n            this._nFlag = true;\n            this.rewind(start);\n            this.pattern();\n        }\n    }\n    get strict() {\n        return Boolean(this._options.strict || this._uFlag);\n    }\n    get ecmaVersion() {\n        return this._options.ecmaVersion || 2018;\n    }\n    onLiteralEnter(start) {\n        if (this._options.onLiteralEnter) {\n            this._options.onLiteralEnter(start);\n        }\n    }\n    onLiteralLeave(start, end) {\n        if (this._options.onLiteralLeave) {\n            this._options.onLiteralLeave(start, end);\n        }\n    }\n    onFlags(start, end, global, ignoreCase, multiline, unicode, sticky, dotAll) {\n        if (this._options.onFlags) {\n            this._options.onFlags(start, end, global, ignoreCase, multiline, unicode, sticky, dotAll);\n        }\n    }\n    onPatternEnter(start) {\n        if (this._options.onPatternEnter) {\n            this._options.onPatternEnter(start);\n        }\n    }\n    onPatternLeave(start, end) {\n        if (this._options.onPatternLeave) {\n            this._options.onPatternLeave(start, end);\n        }\n    }\n    onDisjunctionEnter(start) {\n        if (this._options.onDisjunctionEnter) {\n            this._options.onDisjunctionEnter(start);\n        }\n    }\n    onDisjunctionLeave(start, end) {\n        if (this._options.onDisjunctionLeave) {\n            this._options.onDisjunctionLeave(start, end);\n        }\n    }\n    onAlternativeEnter(start, index) {\n        if (this._options.onAlternativeEnter) {\n            this._options.onAlternativeEnter(start, index);\n        }\n    }\n    onAlternativeLeave(start, end, index) {\n        if (this._options.onAlternativeLeave) {\n            this._options.onAlternativeLeave(start, end, index);\n        }\n    }\n    onGroupEnter(start) {\n        if (this._options.onGroupEnter) {\n            this._options.onGroupEnter(start);\n        }\n    }\n    onGroupLeave(start, end) {\n        if (this._options.onGroupLeave) {\n            this._options.onGroupLeave(start, end);\n        }\n    }\n    onCapturingGroupEnter(start, name) {\n        if (this._options.onCapturingGroupEnter) {\n            this._options.onCapturingGroupEnter(start, name);\n        }\n    }\n    onCapturingGroupLeave(start, end, name) {\n        if (this._options.onCapturingGroupLeave) {\n            this._options.onCapturingGroupLeave(start, end, name);\n        }\n    }\n    onQuantifier(start, end, min, max, greedy) {\n        if (this._options.onQuantifier) {\n            this._options.onQuantifier(start, end, min, max, greedy);\n        }\n    }\n    onLookaroundAssertionEnter(start, kind, negate) {\n        if (this._options.onLookaroundAssertionEnter) {\n            this._options.onLookaroundAssertionEnter(start, kind, negate);\n        }\n    }\n    onLookaroundAssertionLeave(start, end, kind, negate) {\n        if (this._options.onLookaroundAssertionLeave) {\n            this._options.onLookaroundAssertionLeave(start, end, kind, negate);\n        }\n    }\n    onEdgeAssertion(start, end, kind) {\n        if (this._options.onEdgeAssertion) {\n            this._options.onEdgeAssertion(start, end, kind);\n        }\n    }\n    onWordBoundaryAssertion(start, end, kind, negate) {\n        if (this._options.onWordBoundaryAssertion) {\n            this._options.onWordBoundaryAssertion(start, end, kind, negate);\n        }\n    }\n    onAnyCharacterSet(start, end, kind) {\n        if (this._options.onAnyCharacterSet) {\n            this._options.onAnyCharacterSet(start, end, kind);\n        }\n    }\n    onEscapeCharacterSet(start, end, kind, negate) {\n        if (this._options.onEscapeCharacterSet) {\n            this._options.onEscapeCharacterSet(start, end, kind, negate);\n        }\n    }\n    onUnicodePropertyCharacterSet(start, end, kind, key, value, negate) {\n        if (this._options.onUnicodePropertyCharacterSet) {\n            this._options.onUnicodePropertyCharacterSet(start, end, kind, key, value, negate);\n        }\n    }\n    onCharacter(start, end, value) {\n        if (this._options.onCharacter) {\n            this._options.onCharacter(start, end, value);\n        }\n    }\n    onBackreference(start, end, ref) {\n        if (this._options.onBackreference) {\n            this._options.onBackreference(start, end, ref);\n        }\n    }\n    onCharacterClassEnter(start, negate) {\n        if (this._options.onCharacterClassEnter) {\n            this._options.onCharacterClassEnter(start, negate);\n        }\n    }\n    onCharacterClassLeave(start, end, negate) {\n        if (this._options.onCharacterClassLeave) {\n            this._options.onCharacterClassLeave(start, end, negate);\n        }\n    }\n    onCharacterClassRange(start, end, min, max) {\n        if (this._options.onCharacterClassRange) {\n            this._options.onCharacterClassRange(start, end, min, max);\n        }\n    }\n    get source() {\n        return this._reader.source;\n    }\n    get index() {\n        return this._reader.index;\n    }\n    get currentCodePoint() {\n        return this._reader.currentCodePoint;\n    }\n    get nextCodePoint() {\n        return this._reader.nextCodePoint;\n    }\n    get nextCodePoint2() {\n        return this._reader.nextCodePoint2;\n    }\n    get nextCodePoint3() {\n        return this._reader.nextCodePoint3;\n    }\n    reset(source, start, end) {\n        this._reader.reset(source, start, end, this._uFlag);\n    }\n    rewind(index) {\n        this._reader.rewind(index);\n    }\n    advance() {\n        this._reader.advance();\n    }\n    eat(cp) {\n        return this._reader.eat(cp);\n    }\n    eat2(cp1, cp2) {\n        return this._reader.eat2(cp1, cp2);\n    }\n    eat3(cp1, cp2, cp3) {\n        return this._reader.eat3(cp1, cp2, cp3);\n    }\n    raise(message) {\n        throw new RegExpSyntaxError(this.source, this._uFlag, this.index, message);\n    }\n    eatRegExpBody() {\n        const start = this.index;\n        let inClass = false;\n        let escaped = false;\n        for (;;) {\n            const cp = this.currentCodePoint;\n            if (cp === -1 || isLineTerminator(cp)) {\n                const kind = inClass ? \"character class\" : \"regular expression\";\n                this.raise(`Unterminated ${kind}`);\n            }\n            if (escaped) {\n                escaped = false;\n            }\n            else if (cp === ReverseSolidus) {\n                escaped = true;\n            }\n            else if (cp === LeftSquareBracket) {\n                inClass = true;\n            }\n            else if (cp === RightSquareBracket) {\n                inClass = false;\n            }\n            else if ((cp === Solidus && !inClass) ||\n                (cp === Asterisk && this.index === start)) {\n                break;\n            }\n            this.advance();\n        }\n        return this.index !== start;\n    }\n    pattern() {\n        const start = this.index;\n        this._numCapturingParens = this.countCapturingParens();\n        this._groupNames.clear();\n        this._backreferenceNames.clear();\n        this.onPatternEnter(start);\n        this.disjunction();\n        const cp = this.currentCodePoint;\n        if (this.currentCodePoint !== -1) {\n            if (cp === RightParenthesis) {\n                this.raise(\"Unmatched ')'\");\n            }\n            if (cp === ReverseSolidus) {\n                this.raise(\"\\\\ at end of pattern\");\n            }\n            if (cp === RightSquareBracket || cp === RightCurlyBracket) {\n                this.raise(\"Lone quantifier brackets\");\n            }\n            const c = String.fromCodePoint(cp);\n            this.raise(`Unexpected character '${c}'`);\n        }\n        for (const name of this._backreferenceNames) {\n            if (!this._groupNames.has(name)) {\n                this.raise(\"Invalid named capture referenced\");\n            }\n        }\n        this.onPatternLeave(start, this.index);\n    }\n    countCapturingParens() {\n        const start = this.index;\n        let inClass = false;\n        let escaped = false;\n        let count = 0;\n        let cp = 0;\n        while ((cp = this.currentCodePoint) !== -1) {\n            if (escaped) {\n                escaped = false;\n            }\n            else if (cp === ReverseSolidus) {\n                escaped = true;\n            }\n            else if (cp === LeftSquareBracket) {\n                inClass = true;\n            }\n            else if (cp === RightSquareBracket) {\n                inClass = false;\n            }\n            else if (cp === LeftParenthesis &&\n                !inClass &&\n                (this.nextCodePoint !== QuestionMark ||\n                    (this.nextCodePoint2 === LessThanSign &&\n                        this.nextCodePoint3 !== EqualsSign &&\n                        this.nextCodePoint3 !== ExclamationMark))) {\n                count += 1;\n            }\n            this.advance();\n        }\n        this.rewind(start);\n        return count;\n    }\n    disjunction() {\n        const start = this.index;\n        let i = 0;\n        this.onDisjunctionEnter(start);\n        this.alternative(i++);\n        while (this.eat(VerticalLine)) {\n            this.alternative(i++);\n        }\n        if (this.eatQuantifier(true)) {\n            this.raise(\"Nothing to repeat\");\n        }\n        if (this.eat(LeftCurlyBracket)) {\n            this.raise(\"Lone quantifier brackets\");\n        }\n        this.onDisjunctionLeave(start, this.index);\n    }\n    alternative(i) {\n        const start = this.index;\n        this.onAlternativeEnter(start, i);\n        while (this.currentCodePoint !== -1 && this.eatTerm()) {\n        }\n        this.onAlternativeLeave(start, this.index, i);\n    }\n    eatTerm() {\n        if (this.eatAssertion()) {\n            if (this._lastAssertionIsQuantifiable) {\n                this.eatQuantifier();\n            }\n            return true;\n        }\n        if (this.strict ? this.eatAtom() : this.eatExtendedAtom()) {\n            this.eatQuantifier();\n            return true;\n        }\n        return false;\n    }\n    eatAssertion() {\n        const start = this.index;\n        this._lastAssertionIsQuantifiable = false;\n        if (this.eat(CircumflexAccent)) {\n            this.onEdgeAssertion(start, this.index, \"start\");\n            return true;\n        }\n        if (this.eat(DollarSign)) {\n            this.onEdgeAssertion(start, this.index, \"end\");\n            return true;\n        }\n        if (this.eat2(ReverseSolidus, LatinCapitalLetterB)) {\n            this.onWordBoundaryAssertion(start, this.index, \"word\", true);\n            return true;\n        }\n        if (this.eat2(ReverseSolidus, LatinSmallLetterB)) {\n            this.onWordBoundaryAssertion(start, this.index, \"word\", false);\n            return true;\n        }\n        if (this.eat2(LeftParenthesis, QuestionMark)) {\n            const lookbehind = this.ecmaVersion >= 2018 && this.eat(LessThanSign);\n            let negate = false;\n            if (this.eat(EqualsSign) || (negate = this.eat(ExclamationMark))) {\n                const kind = lookbehind ? \"lookbehind\" : \"lookahead\";\n                this.onLookaroundAssertionEnter(start, kind, negate);\n                this.disjunction();\n                if (!this.eat(RightParenthesis)) {\n                    this.raise(\"Unterminated group\");\n                }\n                this._lastAssertionIsQuantifiable = !lookbehind && !this.strict;\n                this.onLookaroundAssertionLeave(start, this.index, kind, negate);\n                return true;\n            }\n            this.rewind(start);\n        }\n        return false;\n    }\n    eatQuantifier(noError = false) {\n        const start = this.index;\n        let min = 0;\n        let max = 0;\n        let greedy = false;\n        if (this.eat(Asterisk)) {\n            min = 0;\n            max = Number.POSITIVE_INFINITY;\n        }\n        else if (this.eat(PlusSign)) {\n            min = 1;\n            max = Number.POSITIVE_INFINITY;\n        }\n        else if (this.eat(QuestionMark)) {\n            min = 0;\n            max = 1;\n        }\n        else if (this.eatBracedQuantifier(noError)) {\n            min = this._lastMinValue;\n            max = this._lastMaxValue;\n        }\n        else {\n            return false;\n        }\n        greedy = !this.eat(QuestionMark);\n        if (!noError) {\n            this.onQuantifier(start, this.index, min, max, greedy);\n        }\n        return true;\n    }\n    eatBracedQuantifier(noError) {\n        const start = this.index;\n        if (this.eat(LeftCurlyBracket)) {\n            this._lastMinValue = 0;\n            this._lastMaxValue = Number.POSITIVE_INFINITY;\n            if (this.eatDecimalDigits()) {\n                this._lastMinValue = this._lastMaxValue = this._lastIntValue;\n                if (this.eat(Comma)) {\n                    this._lastMaxValue = this.eatDecimalDigits()\n                        ? this._lastIntValue\n                        : Number.POSITIVE_INFINITY;\n                }\n                if (this.eat(RightCurlyBracket)) {\n                    if (!noError && this._lastMaxValue < this._lastMinValue) {\n                        this.raise(\"numbers out of order in {} quantifier\");\n                    }\n                    return true;\n                }\n            }\n            if (!noError && this.strict) {\n                this.raise(\"Incomplete quantifier\");\n            }\n            this.rewind(start);\n        }\n        return false;\n    }\n    eatAtom() {\n        return (this.eatPatternCharacter() ||\n            this.eatDot() ||\n            this.eatReverseSolidusAtomEscape() ||\n            this.eatCharacterClass() ||\n            this.eatUncapturingGroup() ||\n            this.eatCapturingGroup());\n    }\n    eatDot() {\n        if (this.eat(FullStop)) {\n            this.onAnyCharacterSet(this.index - 1, this.index, \"any\");\n            return true;\n        }\n        return false;\n    }\n    eatReverseSolidusAtomEscape() {\n        const start = this.index;\n        if (this.eat(ReverseSolidus)) {\n            if (this.eatAtomEscape()) {\n                return true;\n            }\n            this.rewind(start);\n        }\n        return false;\n    }\n    eatUncapturingGroup() {\n        const start = this.index;\n        if (this.eat3(LeftParenthesis, QuestionMark, Colon)) {\n            this.onGroupEnter(start);\n            this.disjunction();\n            if (!this.eat(RightParenthesis)) {\n                this.raise(\"Unterminated group\");\n            }\n            this.onGroupLeave(start, this.index);\n            return true;\n        }\n        return false;\n    }\n    eatCapturingGroup() {\n        const start = this.index;\n        if (this.eat(LeftParenthesis)) {\n            this._lastStrValue = \"\";\n            if (this.ecmaVersion >= 2018) {\n                this.groupSpecifier();\n            }\n            else if (this.currentCodePoint === QuestionMark) {\n                this.raise(\"Invalid group\");\n            }\n            const name = this._lastStrValue || null;\n            this.onCapturingGroupEnter(start, name);\n            this.disjunction();\n            if (!this.eat(RightParenthesis)) {\n                this.raise(\"Unterminated group\");\n            }\n            this.onCapturingGroupLeave(start, this.index, name);\n            return true;\n        }\n        return false;\n    }\n    eatExtendedAtom() {\n        return (this.eatDot() ||\n            this.eatReverseSolidusAtomEscape() ||\n            this.eatReverseSolidusFollowedByC() ||\n            this.eatCharacterClass() ||\n            this.eatUncapturingGroup() ||\n            this.eatCapturingGroup() ||\n            this.eatInvalidBracedQuantifier() ||\n            this.eatExtendedPatternCharacter());\n    }\n    eatReverseSolidusFollowedByC() {\n        if (this.currentCodePoint === ReverseSolidus &&\n            this.nextCodePoint === LatinSmallLetterC) {\n            this._lastIntValue = this.currentCodePoint;\n            this.advance();\n            this.onCharacter(this.index - 1, this.index, ReverseSolidus);\n            return true;\n        }\n        return false;\n    }\n    eatInvalidBracedQuantifier() {\n        if (this.eatBracedQuantifier(true)) {\n            this.raise(\"Nothing to repeat\");\n        }\n        return false;\n    }\n    eatSyntaxCharacter() {\n        if (isSyntaxCharacter$1(this.currentCodePoint)) {\n            this._lastIntValue = this.currentCodePoint;\n            this.advance();\n            return true;\n        }\n        return false;\n    }\n    eatPatternCharacter() {\n        const start = this.index;\n        const cp = this.currentCodePoint;\n        if (cp !== -1 && !isSyntaxCharacter$1(cp)) {\n            this.advance();\n            this.onCharacter(start, this.index, cp);\n            return true;\n        }\n        return false;\n    }\n    eatExtendedPatternCharacter() {\n        const start = this.index;\n        const cp = this.currentCodePoint;\n        if (cp !== -1 &&\n            cp !== CircumflexAccent &&\n            cp !== DollarSign &&\n            cp !== ReverseSolidus &&\n            cp !== FullStop &&\n            cp !== Asterisk &&\n            cp !== PlusSign &&\n            cp !== QuestionMark &&\n            cp !== LeftParenthesis &&\n            cp !== RightParenthesis &&\n            cp !== LeftSquareBracket &&\n            cp !== VerticalLine) {\n            this.advance();\n            this.onCharacter(start, this.index, cp);\n            return true;\n        }\n        return false;\n    }\n    groupSpecifier() {\n        this._lastStrValue = \"\";\n        if (this.eat(QuestionMark)) {\n            if (this.eatGroupName()) {\n                if (!this._groupNames.has(this._lastStrValue)) {\n                    this._groupNames.add(this._lastStrValue);\n                    return;\n                }\n                this.raise(\"Duplicate capture group name\");\n            }\n            this.raise(\"Invalid group\");\n        }\n    }\n    eatGroupName() {\n        this._lastStrValue = \"\";\n        if (this.eat(LessThanSign)) {\n            if (this.eatRegExpIdentifierName() && this.eat(GreaterThanSign)) {\n                return true;\n            }\n            this.raise(\"Invalid capture group name\");\n        }\n        return false;\n    }\n    eatRegExpIdentifierName() {\n        this._lastStrValue = \"\";\n        if (this.eatRegExpIdentifierStart()) {\n            this._lastStrValue += String.fromCodePoint(this._lastIntValue);\n            while (this.eatRegExpIdentifierPart()) {\n                this._lastStrValue += String.fromCodePoint(this._lastIntValue);\n            }\n            return true;\n        }\n        return false;\n    }\n    eatRegExpIdentifierStart() {\n        const start = this.index;\n        let cp = this.currentCodePoint;\n        this.advance();\n        if (cp === ReverseSolidus && this.eatRegExpUnicodeEscapeSequence()) {\n            cp = this._lastIntValue;\n        }\n        if (isRegExpIdentifierStart$1(cp)) {\n            this._lastIntValue = cp;\n            return true;\n        }\n        if (this.index !== start) {\n            this.rewind(start);\n        }\n        return false;\n    }\n    eatRegExpIdentifierPart() {\n        const start = this.index;\n        let cp = this.currentCodePoint;\n        this.advance();\n        if (cp === ReverseSolidus && this.eatRegExpUnicodeEscapeSequence()) {\n            cp = this._lastIntValue;\n        }\n        if (isRegExpIdentifierPart$1(cp)) {\n            this._lastIntValue = cp;\n            return true;\n        }\n        if (this.index !== start) {\n            this.rewind(start);\n        }\n        return false;\n    }\n    eatAtomEscape() {\n        if (this.eatBackreference() ||\n            this.eatCharacterClassEscape() ||\n            this.eatCharacterEscape() ||\n            (this._nFlag && this.eatKGroupName())) {\n            return true;\n        }\n        if (this.strict || this._uFlag) {\n            this.raise(\"Invalid escape\");\n        }\n        return false;\n    }\n    eatBackreference() {\n        const start = this.index;\n        if (this.eatDecimalEscape()) {\n            const n = this._lastIntValue;\n            if (n <= this._numCapturingParens) {\n                this.onBackreference(start - 1, this.index, n);\n                return true;\n            }\n            if (this.strict) {\n                this.raise(\"Invalid escape\");\n            }\n            this.rewind(start);\n        }\n        return false;\n    }\n    eatKGroupName() {\n        const start = this.index;\n        if (this.eat(LatinSmallLetterK)) {\n            if (this.eatGroupName()) {\n                const groupName = this._lastStrValue;\n                this._backreferenceNames.add(groupName);\n                this.onBackreference(start - 1, this.index, groupName);\n                return true;\n            }\n            this.raise(\"Invalid named reference\");\n        }\n        return false;\n    }\n    eatCharacterEscape() {\n        const start = this.index;\n        if (this.eatControlEscape() ||\n            this.eatCControlLetter() ||\n            this.eatZero() ||\n            this.eatHexEscapeSequence() ||\n            this.eatRegExpUnicodeEscapeSequence() ||\n            (!this.strict && this.eatLegacyOctalEscapeSequence()) ||\n            this.eatIdentityEscape()) {\n            this.onCharacter(start - 1, this.index, this._lastIntValue);\n            return true;\n        }\n        return false;\n    }\n    eatCControlLetter() {\n        const start = this.index;\n        if (this.eat(LatinSmallLetterC)) {\n            if (this.eatControlLetter()) {\n                return true;\n            }\n            this.rewind(start);\n        }\n        return false;\n    }\n    eatZero() {\n        if (this.currentCodePoint === DigitZero &&\n            !isDecimalDigit$1(this.nextCodePoint)) {\n            this._lastIntValue = 0;\n            this.advance();\n            return true;\n        }\n        return false;\n    }\n    eatControlEscape() {\n        if (this.eat(LatinSmallLetterT)) {\n            this._lastIntValue = CharacterTabulation;\n            return true;\n        }\n        if (this.eat(LatinSmallLetterN)) {\n            this._lastIntValue = LineFeed;\n            return true;\n        }\n        if (this.eat(LatinSmallLetterV)) {\n            this._lastIntValue = LineTabulation;\n            return true;\n        }\n        if (this.eat(LatinSmallLetterF)) {\n            this._lastIntValue = FormFeed;\n            return true;\n        }\n        if (this.eat(LatinSmallLetterR)) {\n            this._lastIntValue = CarriageReturn;\n            return true;\n        }\n        return false;\n    }\n    eatControlLetter() {\n        const cp = this.currentCodePoint;\n        if (isLatinLetter(cp)) {\n            this.advance();\n            this._lastIntValue = cp % 0x20;\n            return true;\n        }\n        return false;\n    }\n    eatRegExpUnicodeEscapeSequence() {\n        const start = this.index;\n        if (this.eat(LatinSmallLetterU)) {\n            if (this.eatFixedHexDigits(4)) {\n                const lead = this._lastIntValue;\n                if (this._uFlag && lead >= 0xd800 && lead <= 0xdbff) {\n                    const leadSurrogateEnd = this.index;\n                    if (this.eat(ReverseSolidus) &&\n                        this.eat(LatinSmallLetterU) &&\n                        this.eatFixedHexDigits(4)) {\n                        const trail = this._lastIntValue;\n                        if (trail >= 0xdc00 && trail <= 0xdfff) {\n                            this._lastIntValue =\n                                (lead - 0xd800) * 0x400 +\n                                    (trail - 0xdc00) +\n                                    0x10000;\n                            return true;\n                        }\n                    }\n                    this.rewind(leadSurrogateEnd);\n                    this._lastIntValue = lead;\n                }\n                return true;\n            }\n            if (this._uFlag &&\n                this.eat(LeftCurlyBracket) &&\n                this.eatHexDigits() &&\n                this.eat(RightCurlyBracket) &&\n                isValidUnicode$1(this._lastIntValue)) {\n                return true;\n            }\n            if (this.strict || this._uFlag) {\n                this.raise(\"Invalid unicode escape\");\n            }\n            this.rewind(start);\n        }\n        return false;\n    }\n    eatIdentityEscape() {\n        if (this._uFlag) {\n            if (this.eatSyntaxCharacter()) {\n                return true;\n            }\n            if (this.eat(Solidus)) {\n                this._lastIntValue = Solidus;\n                return true;\n            }\n            return false;\n        }\n        if (this.isValidIdentityEscape(this.currentCodePoint)) {\n            this._lastIntValue = this.currentCodePoint;\n            this.advance();\n            return true;\n        }\n        return false;\n    }\n    isValidIdentityEscape(cp) {\n        if (cp === -1) {\n            return false;\n        }\n        if (this.strict) {\n            return !isIdContinue(cp);\n        }\n        return (cp !== LatinSmallLetterC &&\n            (!this._nFlag || cp !== LatinSmallLetterK));\n    }\n    eatDecimalEscape() {\n        this._lastIntValue = 0;\n        let cp = this.currentCodePoint;\n        if (cp >= DigitOne && cp <= DigitNine) {\n            do {\n                this._lastIntValue = 10 * this._lastIntValue + (cp - DigitZero);\n                this.advance();\n            } while ((cp = this.currentCodePoint) >= DigitZero &&\n                cp <= DigitNine);\n            return true;\n        }\n        return false;\n    }\n    eatCharacterClassEscape() {\n        const start = this.index;\n        if (this.eat(LatinSmallLetterD)) {\n            this._lastIntValue = -1;\n            this.onEscapeCharacterSet(start - 1, this.index, \"digit\", false);\n            return true;\n        }\n        if (this.eat(LatinCapitalLetterD)) {\n            this._lastIntValue = -1;\n            this.onEscapeCharacterSet(start - 1, this.index, \"digit\", true);\n            return true;\n        }\n        if (this.eat(LatinSmallLetterS)) {\n            this._lastIntValue = -1;\n            this.onEscapeCharacterSet(start - 1, this.index, \"space\", false);\n            return true;\n        }\n        if (this.eat(LatinCapitalLetterS)) {\n            this._lastIntValue = -1;\n            this.onEscapeCharacterSet(start - 1, this.index, \"space\", true);\n            return true;\n        }\n        if (this.eat(LatinSmallLetterW)) {\n            this._lastIntValue = -1;\n            this.onEscapeCharacterSet(start - 1, this.index, \"word\", false);\n            return true;\n        }\n        if (this.eat(LatinCapitalLetterW)) {\n            this._lastIntValue = -1;\n            this.onEscapeCharacterSet(start - 1, this.index, \"word\", true);\n            return true;\n        }\n        let negate = false;\n        if (this._uFlag &&\n            this.ecmaVersion >= 2018 &&\n            (this.eat(LatinSmallLetterP) ||\n                (negate = this.eat(LatinCapitalLetterP)))) {\n            this._lastIntValue = -1;\n            if (this.eat(LeftCurlyBracket) &&\n                this.eatUnicodePropertyValueExpression() &&\n                this.eat(RightCurlyBracket)) {\n                this.onUnicodePropertyCharacterSet(start - 1, this.index, \"property\", this._lastKeyValue, this._lastValValue || null, negate);\n                return true;\n            }\n            this.raise(\"Invalid property name\");\n        }\n        return false;\n    }\n    eatUnicodePropertyValueExpression() {\n        const start = this.index;\n        if (this.eatUnicodePropertyName() && this.eat(EqualsSign)) {\n            this._lastKeyValue = this._lastStrValue;\n            if (this.eatUnicodePropertyValue()) {\n                this._lastValValue = this._lastStrValue;\n                if (isValidUnicodeProperty(this._lastKeyValue, this._lastValValue)) {\n                    return true;\n                }\n                this.raise(\"Invalid property name\");\n            }\n        }\n        this.rewind(start);\n        if (this.eatLoneUnicodePropertyNameOrValue()) {\n            const nameOrValue = this._lastStrValue;\n            if (isValidUnicodeProperty(\"General_Category\", nameOrValue)) {\n                this._lastKeyValue = \"General_Category\";\n                this._lastValValue = nameOrValue;\n                return true;\n            }\n            if (isValidUnicodePropertyName(nameOrValue)) {\n                this._lastKeyValue = nameOrValue;\n                this._lastValValue = \"\";\n                return true;\n            }\n            this.raise(\"Invalid property name\");\n        }\n        return false;\n    }\n    eatUnicodePropertyName() {\n        this._lastStrValue = \"\";\n        while (isUnicodePropertyNameCharacter$1(this.currentCodePoint)) {\n            this._lastStrValue += String.fromCodePoint(this.currentCodePoint);\n            this.advance();\n        }\n        return this._lastStrValue !== \"\";\n    }\n    eatUnicodePropertyValue() {\n        this._lastStrValue = \"\";\n        while (isUnicodePropertyValueCharacter$1(this.currentCodePoint)) {\n            this._lastStrValue += String.fromCodePoint(this.currentCodePoint);\n            this.advance();\n        }\n        return this._lastStrValue !== \"\";\n    }\n    eatLoneUnicodePropertyNameOrValue() {\n        return this.eatUnicodePropertyValue();\n    }\n    eatCharacterClass() {\n        const start = this.index;\n        if (this.eat(LeftSquareBracket)) {\n            const negate = this.eat(CircumflexAccent);\n            this.onCharacterClassEnter(start, negate);\n            this.classRanges();\n            if (!this.eat(RightSquareBracket)) {\n                this.raise(\"Unterminated character class\");\n            }\n            this.onCharacterClassLeave(start, this.index, negate);\n            return true;\n        }\n        return false;\n    }\n    classRanges() {\n        let start = this.index;\n        while (this.eatClassAtom()) {\n            const left = this._lastIntValue;\n            const hyphenStart = this.index;\n            if (this.eat(HyphenMinus)) {\n                this.onCharacter(hyphenStart, this.index, HyphenMinus);\n                if (this.eatClassAtom()) {\n                    const right = this._lastIntValue;\n                    if (left === -1 || right === -1) {\n                        if (this.strict) {\n                            this.raise(\"Invalid character class\");\n                        }\n                    }\n                    else if (left > right) {\n                        this.raise(\"Range out of order in character class\");\n                    }\n                    else {\n                        this.onCharacterClassRange(start, this.index, left, right);\n                    }\n                }\n            }\n            start = this.index;\n        }\n    }\n    eatClassAtom() {\n        const start = this.index;\n        if (this.eat(ReverseSolidus)) {\n            if (this.eatClassEscape()) {\n                return true;\n            }\n            if (this._uFlag) {\n                this.raise(\"Invalid escape\");\n            }\n            this.rewind(start);\n        }\n        const cp = this.currentCodePoint;\n        if (cp !== -1 && cp !== RightSquareBracket) {\n            this.advance();\n            this._lastIntValue = cp;\n            this.onCharacter(start, this.index, cp);\n            return true;\n        }\n        return false;\n    }\n    eatClassEscape() {\n        const start = this.index;\n        if (this.eat(LatinSmallLetterB)) {\n            this._lastIntValue = Backspace;\n            this.onCharacter(start - 1, this.index, Backspace);\n            return true;\n        }\n        if (this._uFlag && this.eat(HyphenMinus)) {\n            this._lastIntValue = HyphenMinus;\n            this.onCharacter(start - 1, this.index, HyphenMinus);\n            return true;\n        }\n        if (!this._uFlag && this.eat(LatinSmallLetterC)) {\n            if (this.eatClassControlLetter()) {\n                this.onCharacter(start - 1, this.index, this._lastIntValue);\n                return true;\n            }\n            this.rewind(start);\n        }\n        return this.eatCharacterClassEscape() || this.eatCharacterEscape();\n    }\n    eatClassControlLetter() {\n        const cp = this.currentCodePoint;\n        if (isDecimalDigit$1(cp) || cp === LowLine) {\n            this.advance();\n            this._lastIntValue = cp % 0x20;\n            return true;\n        }\n        return false;\n    }\n    eatHexEscapeSequence() {\n        const start = this.index;\n        if (this.eat(LatinSmallLetterX)) {\n            if (this.eatFixedHexDigits(2)) {\n                return true;\n            }\n            if (this._uFlag) {\n                this.raise(\"Invalid escape\");\n            }\n            this.rewind(start);\n        }\n        return false;\n    }\n    eatDecimalDigits() {\n        const start = this.index;\n        this._lastIntValue = 0;\n        while (isDecimalDigit$1(this.currentCodePoint)) {\n            this._lastIntValue =\n                10 * this._lastIntValue + digitToInt(this.currentCodePoint);\n            this.advance();\n        }\n        return this.index !== start;\n    }\n    eatHexDigits() {\n        const start = this.index;\n        this._lastIntValue = 0;\n        while (isHexDigit$1(this.currentCodePoint)) {\n            this._lastIntValue =\n                16 * this._lastIntValue + digitToInt(this.currentCodePoint);\n            this.advance();\n        }\n        return this.index !== start;\n    }\n    eatLegacyOctalEscapeSequence() {\n        if (this.eatOctalDigit()) {\n            const n1 = this._lastIntValue;\n            if (this.eatOctalDigit()) {\n                const n2 = this._lastIntValue;\n                if (n1 <= 3 && this.eatOctalDigit()) {\n                    this._lastIntValue = n1 * 64 + n2 * 8 + this._lastIntValue;\n                }\n                else {\n                    this._lastIntValue = n1 * 8 + n2;\n                }\n            }\n            else {\n                this._lastIntValue = n1;\n            }\n            return true;\n        }\n        return false;\n    }\n    eatOctalDigit() {\n        const cp = this.currentCodePoint;\n        if (isOctalDigit$1(cp)) {\n            this.advance();\n            this._lastIntValue = cp - DigitZero;\n            return true;\n        }\n        this._lastIntValue = 0;\n        return false;\n    }\n    eatFixedHexDigits(length) {\n        const start = this.index;\n        this._lastIntValue = 0;\n        for (let i = 0; i < length; ++i) {\n            const cp = this.currentCodePoint;\n            if (!isHexDigit$1(cp)) {\n                this.rewind(start);\n                return false;\n            }\n            this._lastIntValue = 16 * this._lastIntValue + digitToInt(cp);\n            this.advance();\n        }\n        return true;\n    }\n}\n\nconst DummyPattern = {};\nconst DummyFlags = {};\nconst DummyCapturingGroup = {};\nclass RegExpParserState {\n    constructor(options) {\n        this._node = DummyPattern;\n        this._flags = DummyFlags;\n        this._backreferences = [];\n        this._capturingGroups = [];\n        this.source = \"\";\n        this.strict = Boolean(options && options.strict);\n        this.ecmaVersion = (options && options.ecmaVersion) || 2018;\n    }\n    get pattern() {\n        if (this._node.type !== \"Pattern\") {\n            throw new Error(\"UnknownError\");\n        }\n        return this._node;\n    }\n    get flags() {\n        if (this._flags.type !== \"Flags\") {\n            throw new Error(\"UnknownError\");\n        }\n        return this._flags;\n    }\n    onFlags(start, end, global, ignoreCase, multiline, unicode, sticky, dotAll) {\n        this._flags = {\n            type: \"Flags\",\n            parent: null,\n            start,\n            end,\n            raw: this.source.slice(start, end),\n            global,\n            ignoreCase,\n            multiline,\n            unicode,\n            sticky,\n            dotAll,\n        };\n    }\n    onPatternEnter(start) {\n        this._node = {\n            type: \"Pattern\",\n            parent: null,\n            start,\n            end: start,\n            raw: \"\",\n            alternatives: [],\n        };\n        this._backreferences.length = 0;\n        this._capturingGroups.length = 0;\n    }\n    onPatternLeave(start, end) {\n        this._node.end = end;\n        this._node.raw = this.source.slice(start, end);\n        for (const reference of this._backreferences) {\n            const ref = reference.ref;\n            const group = typeof ref === \"number\"\n                ? this._capturingGroups[ref - 1]\n                : this._capturingGroups.find(g => g.name === ref);\n            reference.resolved = group;\n            group.references.push(reference);\n        }\n    }\n    onAlternativeEnter(start) {\n        const parent = this._node;\n        if (parent.type !== \"Assertion\" &&\n            parent.type !== \"CapturingGroup\" &&\n            parent.type !== \"Group\" &&\n            parent.type !== \"Pattern\") {\n            throw new Error(\"UnknownError\");\n        }\n        this._node = {\n            type: \"Alternative\",\n            parent,\n            start,\n            end: start,\n            raw: \"\",\n            elements: [],\n        };\n        parent.alternatives.push(this._node);\n    }\n    onAlternativeLeave(start, end) {\n        const node = this._node;\n        if (node.type !== \"Alternative\") {\n            throw new Error(\"UnknownError\");\n        }\n        node.end = end;\n        node.raw = this.source.slice(start, end);\n        this._node = node.parent;\n    }\n    onGroupEnter(start) {\n        const parent = this._node;\n        if (parent.type !== \"Alternative\") {\n            throw new Error(\"UnknownError\");\n        }\n        this._node = {\n            type: \"Group\",\n            parent,\n            start,\n            end: start,\n            raw: \"\",\n            alternatives: [],\n        };\n        parent.elements.push(this._node);\n    }\n    onGroupLeave(start, end) {\n        const node = this._node;\n        if (node.type !== \"Group\" || node.parent.type !== \"Alternative\") {\n            throw new Error(\"UnknownError\");\n        }\n        node.end = end;\n        node.raw = this.source.slice(start, end);\n        this._node = node.parent;\n    }\n    onCapturingGroupEnter(start, name) {\n        const parent = this._node;\n        if (parent.type !== \"Alternative\") {\n            throw new Error(\"UnknownError\");\n        }\n        this._node = {\n            type: \"CapturingGroup\",\n            parent,\n            start,\n            end: start,\n            raw: \"\",\n            name,\n            alternatives: [],\n            references: [],\n        };\n        parent.elements.push(this._node);\n        this._capturingGroups.push(this._node);\n    }\n    onCapturingGroupLeave(start, end) {\n        const node = this._node;\n        if (node.type !== \"CapturingGroup\" ||\n            node.parent.type !== \"Alternative\") {\n            throw new Error(\"UnknownError\");\n        }\n        node.end = end;\n        node.raw = this.source.slice(start, end);\n        this._node = node.parent;\n    }\n    onQuantifier(start, end, min, max, greedy) {\n        const parent = this._node;\n        if (parent.type !== \"Alternative\") {\n            throw new Error(\"UnknownError\");\n        }\n        const element = parent.elements.pop();\n        if (element == null ||\n            element.type === \"Quantifier\" ||\n            (element.type === \"Assertion\" && element.kind !== \"lookahead\")) {\n            throw new Error(\"UnknownError\");\n        }\n        const node = {\n            type: \"Quantifier\",\n            parent,\n            start: element.start,\n            end,\n            raw: this.source.slice(element.start, end),\n            min,\n            max,\n            greedy,\n            element,\n        };\n        parent.elements.push(node);\n        element.parent = node;\n    }\n    onLookaroundAssertionEnter(start, kind, negate) {\n        const parent = this._node;\n        if (parent.type !== \"Alternative\") {\n            throw new Error(\"UnknownError\");\n        }\n        this._node = {\n            type: \"Assertion\",\n            parent,\n            start,\n            end: start,\n            raw: \"\",\n            kind,\n            negate,\n            alternatives: [],\n        };\n        parent.elements.push(this._node);\n    }\n    onLookaroundAssertionLeave(start, end) {\n        const node = this._node;\n        if (node.type !== \"Assertion\" || node.parent.type !== \"Alternative\") {\n            throw new Error(\"UnknownError\");\n        }\n        node.end = end;\n        node.raw = this.source.slice(start, end);\n        this._node = node.parent;\n    }\n    onEdgeAssertion(start, end, kind) {\n        const parent = this._node;\n        if (parent.type !== \"Alternative\") {\n            throw new Error(\"UnknownError\");\n        }\n        parent.elements.push({\n            type: \"Assertion\",\n            parent,\n            start,\n            end,\n            raw: this.source.slice(start, end),\n            kind,\n        });\n    }\n    onWordBoundaryAssertion(start, end, kind, negate) {\n        const parent = this._node;\n        if (parent.type !== \"Alternative\") {\n            throw new Error(\"UnknownError\");\n        }\n        parent.elements.push({\n            type: \"Assertion\",\n            parent,\n            start,\n            end,\n            raw: this.source.slice(start, end),\n            kind,\n            negate,\n        });\n    }\n    onAnyCharacterSet(start, end, kind) {\n        const parent = this._node;\n        if (parent.type !== \"Alternative\") {\n            throw new Error(\"UnknownError\");\n        }\n        parent.elements.push({\n            type: \"CharacterSet\",\n            parent,\n            start,\n            end,\n            raw: this.source.slice(start, end),\n            kind,\n        });\n    }\n    onEscapeCharacterSet(start, end, kind, negate) {\n        const parent = this._node;\n        if (parent.type !== \"Alternative\" && parent.type !== \"CharacterClass\") {\n            throw new Error(\"UnknownError\");\n        }\n        parent.elements.push({\n            type: \"CharacterSet\",\n            parent,\n            start,\n            end,\n            raw: this.source.slice(start, end),\n            kind,\n            negate,\n        });\n    }\n    onUnicodePropertyCharacterSet(start, end, kind, key, value, negate) {\n        const parent = this._node;\n        if (parent.type !== \"Alternative\" && parent.type !== \"CharacterClass\") {\n            throw new Error(\"UnknownError\");\n        }\n        parent.elements.push({\n            type: \"CharacterSet\",\n            parent,\n            start,\n            end,\n            raw: this.source.slice(start, end),\n            kind,\n            key,\n            value,\n            negate,\n        });\n    }\n    onCharacter(start, end, value) {\n        const parent = this._node;\n        if (parent.type !== \"Alternative\" && parent.type !== \"CharacterClass\") {\n            throw new Error(\"UnknownError\");\n        }\n        parent.elements.push({\n            type: \"Character\",\n            parent,\n            start,\n            end,\n            raw: this.source.slice(start, end),\n            value,\n        });\n    }\n    onBackreference(start, end, ref) {\n        const parent = this._node;\n        if (parent.type !== \"Alternative\") {\n            throw new Error(\"UnknownError\");\n        }\n        const node = {\n            type: \"Backreference\",\n            parent,\n            start,\n            end,\n            raw: this.source.slice(start, end),\n            ref,\n            resolved: DummyCapturingGroup,\n        };\n        parent.elements.push(node);\n        this._backreferences.push(node);\n    }\n    onCharacterClassEnter(start, negate) {\n        const parent = this._node;\n        if (parent.type !== \"Alternative\") {\n            throw new Error(\"UnknownError\");\n        }\n        this._node = {\n            type: \"CharacterClass\",\n            parent,\n            start,\n            end: start,\n            raw: \"\",\n            negate,\n            elements: [],\n        };\n        parent.elements.push(this._node);\n    }\n    onCharacterClassLeave(start, end) {\n        const node = this._node;\n        if (node.type !== \"CharacterClass\" ||\n            node.parent.type !== \"Alternative\") {\n            throw new Error(\"UnknownError\");\n        }\n        node.end = end;\n        node.raw = this.source.slice(start, end);\n        this._node = node.parent;\n    }\n    onCharacterClassRange(start, end) {\n        const parent = this._node;\n        if (parent.type !== \"CharacterClass\") {\n            throw new Error(\"UnknownError\");\n        }\n        const elements = parent.elements;\n        const max = elements.pop();\n        const hyphen = elements.pop();\n        const min = elements.pop();\n        if (!min ||\n            !max ||\n            !hyphen ||\n            min.type !== \"Character\" ||\n            max.type !== \"Character\" ||\n            hyphen.type !== \"Character\" ||\n            hyphen.value !== HyphenMinus) {\n            throw new Error(\"UnknownError\");\n        }\n        const node = {\n            type: \"CharacterClassRange\",\n            parent,\n            start,\n            end,\n            raw: this.source.slice(start, end),\n            min,\n            max,\n        };\n        min.parent = node;\n        max.parent = node;\n        elements.push(node);\n    }\n}\nclass RegExpParser {\n    constructor(options) {\n        this._state = new RegExpParserState(options);\n        this._validator = new RegExpValidator(this._state);\n    }\n    parseLiteral(source, start = 0, end = source.length) {\n        this._state.source = source;\n        this._validator.validateLiteral(source, start, end);\n        const pattern = this._state.pattern;\n        const flags = this._state.flags;\n        const literal = {\n            type: \"RegExpLiteral\",\n            parent: null,\n            start,\n            end,\n            raw: source,\n            pattern,\n            flags,\n        };\n        pattern.parent = literal;\n        flags.parent = literal;\n        return literal;\n    }\n    parseFlags(source, start = 0, end = source.length) {\n        this._state.source = source;\n        this._validator.validateFlags(source, start, end);\n        return this._state.flags;\n    }\n    parsePattern(source, start = 0, end = source.length, uFlag = false) {\n        this._state.source = source;\n        this._validator.validatePattern(source, start, end, uFlag);\n        return this._state.pattern;\n    }\n}\n\nclass RegExpVisitor {\n    constructor(handlers) {\n        this._handlers = handlers;\n    }\n    visit(node) {\n        switch (node.type) {\n            case \"Alternative\":\n                this.visitAlternative(node);\n                break;\n            case \"Assertion\":\n                this.visitAssertion(node);\n                break;\n            case \"Backreference\":\n                this.visitBackreference(node);\n                break;\n            case \"CapturingGroup\":\n                this.visitCapturingGroup(node);\n                break;\n            case \"Character\":\n                this.visitCharacter(node);\n                break;\n            case \"CharacterClass\":\n                this.visitCharacterClass(node);\n                break;\n            case \"CharacterClassRange\":\n                this.visitCharacterClassRange(node);\n                break;\n            case \"CharacterSet\":\n                this.visitCharacterSet(node);\n                break;\n            case \"Flags\":\n                this.visitFlags(node);\n                break;\n            case \"Group\":\n                this.visitGroup(node);\n                break;\n            case \"Pattern\":\n                this.visitPattern(node);\n                break;\n            case \"Quantifier\":\n                this.visitQuantifier(node);\n                break;\n            case \"RegExpLiteral\":\n                this.visitRegExpLiteral(node);\n                break;\n            default:\n                throw new Error(`Unknown type: ${node.type}`);\n        }\n    }\n    visitAlternative(node) {\n        if (this._handlers.onAlternativeEnter) {\n            this._handlers.onAlternativeEnter(node);\n        }\n        node.elements.forEach(this.visit, this);\n        if (this._handlers.onAlternativeLeave) {\n            this._handlers.onAlternativeLeave(node);\n        }\n    }\n    visitAssertion(node) {\n        if (this._handlers.onAssertionEnter) {\n            this._handlers.onAssertionEnter(node);\n        }\n        if (node.kind === \"lookahead\" || node.kind === \"lookbehind\") {\n            node.alternatives.forEach(this.visit, this);\n        }\n        if (this._handlers.onAssertionLeave) {\n            this._handlers.onAssertionLeave(node);\n        }\n    }\n    visitBackreference(node) {\n        if (this._handlers.onBackreferenceEnter) {\n            this._handlers.onBackreferenceEnter(node);\n        }\n        if (this._handlers.onBackreferenceLeave) {\n            this._handlers.onBackreferenceLeave(node);\n        }\n    }\n    visitCapturingGroup(node) {\n        if (this._handlers.onCapturingGroupEnter) {\n            this._handlers.onCapturingGroupEnter(node);\n        }\n        node.alternatives.forEach(this.visit, this);\n        if (this._handlers.onCapturingGroupLeave) {\n            this._handlers.onCapturingGroupLeave(node);\n        }\n    }\n    visitCharacter(node) {\n        if (this._handlers.onCharacterEnter) {\n            this._handlers.onCharacterEnter(node);\n        }\n        if (this._handlers.onCharacterLeave) {\n            this._handlers.onCharacterLeave(node);\n        }\n    }\n    visitCharacterClass(node) {\n        if (this._handlers.onCharacterClassEnter) {\n            this._handlers.onCharacterClassEnter(node);\n        }\n        node.elements.forEach(this.visit, this);\n        if (this._handlers.onCharacterClassLeave) {\n            this._handlers.onCharacterClassLeave(node);\n        }\n    }\n    visitCharacterClassRange(node) {\n        if (this._handlers.onCharacterClassRangeEnter) {\n            this._handlers.onCharacterClassRangeEnter(node);\n        }\n        this.visitCharacter(node.min);\n        this.visitCharacter(node.max);\n        if (this._handlers.onCharacterClassRangeLeave) {\n            this._handlers.onCharacterClassRangeLeave(node);\n        }\n    }\n    visitCharacterSet(node) {\n        if (this._handlers.onCharacterSetEnter) {\n            this._handlers.onCharacterSetEnter(node);\n        }\n        if (this._handlers.onCharacterSetLeave) {\n            this._handlers.onCharacterSetLeave(node);\n        }\n    }\n    visitFlags(node) {\n        if (this._handlers.onFlagsEnter) {\n            this._handlers.onFlagsEnter(node);\n        }\n        if (this._handlers.onFlagsLeave) {\n            this._handlers.onFlagsLeave(node);\n        }\n    }\n    visitGroup(node) {\n        if (this._handlers.onGroupEnter) {\n            this._handlers.onGroupEnter(node);\n        }\n        node.alternatives.forEach(this.visit, this);\n        if (this._handlers.onGroupLeave) {\n            this._handlers.onGroupLeave(node);\n        }\n    }\n    visitPattern(node) {\n        if (this._handlers.onPatternEnter) {\n            this._handlers.onPatternEnter(node);\n        }\n        node.alternatives.forEach(this.visit, this);\n        if (this._handlers.onPatternLeave) {\n            this._handlers.onPatternLeave(node);\n        }\n    }\n    visitQuantifier(node) {\n        if (this._handlers.onQuantifierEnter) {\n            this._handlers.onQuantifierEnter(node);\n        }\n        this.visit(node.element);\n        if (this._handlers.onQuantifierLeave) {\n            this._handlers.onQuantifierLeave(node);\n        }\n    }\n    visitRegExpLiteral(node) {\n        if (this._handlers.onRegExpLiteralEnter) {\n            this._handlers.onRegExpLiteralEnter(node);\n        }\n        this.visitPattern(node.pattern);\n        this.visitFlags(node.flags);\n        if (this._handlers.onRegExpLiteralLeave) {\n            this._handlers.onRegExpLiteralLeave(node);\n        }\n    }\n}\n\nfunction parseRegExpLiteral(source, options) {\n    return new RegExpParser(options).parseLiteral(String(source));\n}\nfunction validateRegExpLiteral(source, options) {\n    return new RegExpValidator(options).validateLiteral(source);\n}\nfunction visitRegExpAST(node, handlers) {\n    new RegExpVisitor(handlers).visit(node);\n}\n\nvar regexpp = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  AST: ast$1,\n  RegExpParser: RegExpParser,\n  RegExpValidator: RegExpValidator,\n  parseRegExpLiteral: parseRegExpLiteral,\n  validateRegExpLiteral: validateRegExpLiteral,\n  visitRegExpAST: visitRegExpAST\n});\n\nvar regexpp$1 = getCjsExportFromNamespace(regexpp);\n\nconst RegExpValidator$1 = regexpp$1.RegExpValidator;\nconst collector = new (class {\n    constructor() {\n        this.ecmaVersion = 2018;\n        this._source = \"\";\n        this._controlChars = [];\n        this._validator = new RegExpValidator$1(this);\n    }\n\n    onPatternEnter() {\n        this._controlChars = [];\n    }\n\n    onCharacter(start, end, cp) {\n        if (cp >= 0x00 &&\n            cp <= 0x1F &&\n            (\n                this._source.codePointAt(start) === cp ||\n                this._source.slice(start, end).startsWith(\"\\\\x\") ||\n                this._source.slice(start, end).startsWith(\"\\\\u\")\n            )\n        ) {\n            this._controlChars.push(`\\\\x${`0${cp.toString(16)}`.slice(-2)}`);\n        }\n    }\n\n    collectControlChars(regexpStr) {\n        try {\n            this._source = regexpStr;\n            this._validator.validatePattern(regexpStr); // Call onCharacter hook\n        } catch (err) {\n\n            // Ignore syntax errors in RegExp.\n        }\n        return this._controlChars;\n    }\n})();\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noControlRegex = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow control characters in regular expressions\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-control-regex\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"Unexpected control character(s) in regular expression: {{controlChars}}.\"\n        }\n    },\n\n    create(context) {\n\n        /**\n         * Get the regex expression\n         * @param {ASTNode} node node to evaluate\n         * @returns {RegExp|null} Regex if found else null\n         * @private\n         */\n        function getRegExpPattern(node) {\n            if (node.regex) {\n                return node.regex.pattern;\n            }\n            if (typeof node.value === \"string\" &&\n                (node.parent.type === \"NewExpression\" || node.parent.type === \"CallExpression\") &&\n                node.parent.callee.type === \"Identifier\" &&\n                node.parent.callee.name === \"RegExp\" &&\n                node.parent.arguments[0] === node\n            ) {\n                return node.value;\n            }\n\n            return null;\n        }\n\n        return {\n            Literal(node) {\n                const pattern = getRegExpPattern(node);\n\n                if (pattern) {\n                    const controlCharacters = collector.collectControlChars(pattern);\n\n                    if (controlCharacters.length > 0) {\n                        context.report({\n                            node,\n                            messageId: \"unexpected\",\n                            data: {\n                                controlChars: controlCharacters.join(\", \")\n                            }\n                        });\n                    }\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag use of a debugger statement\n * @author Nicholas C. Zakas\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noDebugger = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow the use of `debugger`\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-debugger\"\n        },\n\n        fixable: null,\n        schema: [],\n\n        messages: {\n            unexpected: \"Unexpected 'debugger' statement.\"\n        }\n    },\n\n    create(context) {\n\n        return {\n            DebuggerStatement(node) {\n                context.report({\n                    node,\n                    messageId: \"unexpected\"\n                });\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag when deleting variables\n * @author Ilya Volodin\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noDeleteVar = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow deleting variables\",\n            category: \"Variables\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-delete-var\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"Variables should not be deleted.\"\n        }\n    },\n\n    create(context) {\n\n        return {\n\n            UnaryExpression(node) {\n                if (node.operator === \"delete\" && node.argument.type === \"Identifier\") {\n                    context.report({ node, messageId: \"unexpected\" });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to check for ambiguous div operator in regexes\n * @author Matt DuVall <http://www.mattduvall.com>\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noDivRegex = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow division operators explicitly at the beginning of regular expressions\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-div-regex\"\n        },\n\n        fixable: \"code\",\n\n        schema: [],\n\n        messages: {\n            unexpected: \"A regular expression literal can be confused with '/='.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        return {\n\n            Literal(node) {\n                const token = sourceCode.getFirstToken(node);\n\n                if (token.type === \"RegularExpression\" && token.value[1] === \"=\") {\n                    context.report({\n                        node,\n                        messageId: \"unexpected\",\n                        fix(fixer) {\n                            return fixer.replaceTextRange([token.range[0] + 1, token.range[0] + 2], \"[=]\");\n                        }\n                    });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag duplicate arguments\n * @author Jamund Ferguson\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noDupeArgs = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow duplicate arguments in `function` definitions\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-dupe-args\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"Duplicate param '{{name}}'.\"\n        }\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Checks whether or not a given definition is a parameter's.\n         * @param {eslint-scope.DefEntry} def A definition to check.\n         * @returns {boolean} `true` if the definition is a parameter's.\n         */\n        function isParameter(def) {\n            return def.type === \"Parameter\";\n        }\n\n        /**\n         * Determines if a given node has duplicate parameters.\n         * @param {ASTNode} node The node to check.\n         * @returns {void}\n         * @private\n         */\n        function checkParams(node) {\n            const variables = context.getDeclaredVariables(node);\n\n            for (let i = 0; i < variables.length; ++i) {\n                const variable = variables[i];\n\n                // Checks and reports duplications.\n                const defs = variable.defs.filter(isParameter);\n\n                if (defs.length >= 2) {\n                    context.report({\n                        node,\n                        messageId: \"unexpected\",\n                        data: { name: variable.name }\n                    });\n                }\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n            FunctionDeclaration: checkParams,\n            FunctionExpression: checkParams\n        };\n\n    }\n};\n\n/**\n * @fileoverview A rule to disallow duplicate name in class members.\n * @author Toru Nagashima\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noDupeClassMembers = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow duplicate class members\",\n            category: \"ECMAScript 6\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-dupe-class-members\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"Duplicate name '{{name}}'.\"\n        }\n    },\n\n    create(context) {\n        let stack = [];\n\n        /**\n         * Gets state of a given member name.\n         * @param {string} name A name of a member.\n         * @param {boolean} isStatic A flag which specifies that is a static member.\n         * @returns {Object} A state of a given member name.\n         *   - retv.init {boolean} A flag which shows the name is declared as normal member.\n         *   - retv.get {boolean} A flag which shows the name is declared as getter.\n         *   - retv.set {boolean} A flag which shows the name is declared as setter.\n         */\n        function getState(name, isStatic) {\n            const stateMap = stack[stack.length - 1];\n            const key = `$${name}`; // to avoid \"__proto__\".\n\n            if (!stateMap[key]) {\n                stateMap[key] = {\n                    nonStatic: { init: false, get: false, set: false },\n                    static: { init: false, get: false, set: false }\n                };\n            }\n\n            return stateMap[key][isStatic ? \"static\" : \"nonStatic\"];\n        }\n\n        /**\n         * Gets the name text of a given node.\n         * @param {ASTNode} node A node to get the name.\n         * @returns {string} The name text of the node.\n         */\n        function getName(node) {\n            switch (node.type) {\n                case \"Identifier\": return node.name;\n                case \"Literal\": return String(node.value);\n\n                /* istanbul ignore next: syntax error */\n                default: return \"\";\n            }\n        }\n\n        return {\n\n            // Initializes the stack of state of member declarations.\n            Program() {\n                stack = [];\n            },\n\n            // Initializes state of member declarations for the class.\n            ClassBody() {\n                stack.push(Object.create(null));\n            },\n\n            // Disposes the state for the class.\n            \"ClassBody:exit\"() {\n                stack.pop();\n            },\n\n            // Reports the node if its name has been declared already.\n            MethodDefinition(node) {\n                if (node.computed) {\n                    return;\n                }\n\n                const name = getName(node.key);\n                const state = getState(name, node.static);\n                let isDuplicate = false;\n\n                if (node.kind === \"get\") {\n                    isDuplicate = (state.init || state.get);\n                    state.get = true;\n                } else if (node.kind === \"set\") {\n                    isDuplicate = (state.init || state.set);\n                    state.set = true;\n                } else {\n                    isDuplicate = (state.init || state.get || state.set);\n                    state.init = true;\n                }\n\n                if (isDuplicate) {\n                    context.report({ node, messageId: \"unexpected\", data: { name } });\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Determines whether the first given array is a subset of the second given array.\n * @param {Function} comparator A function to compare two elements, should return `true` if they are equal.\n * @param {Array} arrA The array to compare from.\n * @param {Array} arrB The array to compare against.\n * @returns {boolean} `true` if the array `arrA` is a subset of the array `arrB`.\n */\nfunction isSubsetByComparator(comparator, arrA, arrB) {\n    return arrA.every(a => arrB.some(b => comparator(a, b)));\n}\n\n/**\n * Splits the given node by the given logical operator.\n * @param {string} operator Logical operator `||` or `&&`.\n * @param {ASTNode} node The node to split.\n * @returns {ASTNode[]} Array of conditions that makes the node when joined by the operator.\n */\nfunction splitByLogicalOperator(operator, node) {\n    if (node.type === \"LogicalExpression\" && node.operator === operator) {\n        return [...splitByLogicalOperator(operator, node.left), ...splitByLogicalOperator(operator, node.right)];\n    }\n    return [node];\n}\n\nconst splitByOr = splitByLogicalOperator.bind(null, \"||\");\nconst splitByAnd = splitByLogicalOperator.bind(null, \"&&\");\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noDupeElseIf = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow duplicate conditions in if-else-if chains\",\n            category: \"Possible Errors\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-dupe-else-if\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"This branch can never execute. Its condition is a duplicate or covered by previous conditions in the if-else-if chain.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Determines whether the two given nodes are considered to be equal. In particular, given that the nodes\n         * represent expressions in a boolean context, `||` and `&&` can be considered as commutative operators.\n         * @param {ASTNode} a First node.\n         * @param {ASTNode} b Second node.\n         * @returns {boolean} `true` if the nodes are considered to be equal.\n         */\n        function equal(a, b) {\n            if (a.type !== b.type) {\n                return false;\n            }\n\n            if (\n                a.type === \"LogicalExpression\" &&\n                (a.operator === \"||\" || a.operator === \"&&\") &&\n                a.operator === b.operator\n            ) {\n                return equal(a.left, b.left) && equal(a.right, b.right) ||\n                    equal(a.left, b.right) && equal(a.right, b.left);\n            }\n\n            return astUtils$1.equalTokens(a, b, sourceCode);\n        }\n\n        const isSubset = isSubsetByComparator.bind(null, equal);\n\n        return {\n            IfStatement(node) {\n                const test = node.test,\n                    conditionsToCheck = test.type === \"LogicalExpression\" && test.operator === \"&&\"\n                        ? [test, ...splitByAnd(test)]\n                        : [test];\n                let current = node,\n                    listToCheck = conditionsToCheck.map(c => splitByOr(c).map(splitByAnd));\n\n                while (current.parent && current.parent.type === \"IfStatement\" && current.parent.alternate === current) {\n                    current = current.parent;\n\n                    const currentOrOperands = splitByOr(current.test).map(splitByAnd);\n\n                    listToCheck = listToCheck.map(orOperands => orOperands.filter(\n                        orOperand => !currentOrOperands.some(currentOrOperand => isSubset(currentOrOperand, orOperand))\n                    ));\n\n                    if (listToCheck.some(orOperands => orOperands.length === 0)) {\n                        context.report({ node: test, messageId: \"unexpected\" });\n                        break;\n                    }\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst GET_KIND = /^(?:init|get)$/u;\nconst SET_KIND = /^(?:init|set)$/u;\n\n/**\n * The class which stores properties' information of an object.\n */\nclass ObjectInfo {\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @param {ObjectInfo|null} upper The information of the outer object.\n     * @param {ASTNode} node The ObjectExpression node of this information.\n     */\n    constructor(upper, node) {\n        this.upper = upper;\n        this.node = node;\n        this.properties = new Map();\n    }\n\n    /**\n     * Gets the information of the given Property node.\n     * @param {ASTNode} node The Property node to get.\n     * @returns {{get: boolean, set: boolean}} The information of the property.\n     */\n    getPropertyInfo(node) {\n        const name = astUtils$1.getStaticPropertyName(node);\n\n        if (!this.properties.has(name)) {\n            this.properties.set(name, { get: false, set: false });\n        }\n        return this.properties.get(name);\n    }\n\n    /**\n     * Checks whether the given property has been defined already or not.\n     * @param {ASTNode} node The Property node to check.\n     * @returns {boolean} `true` if the property has been defined.\n     */\n    isPropertyDefined(node) {\n        const entry = this.getPropertyInfo(node);\n\n        return (\n            (GET_KIND.test(node.kind) && entry.get) ||\n            (SET_KIND.test(node.kind) && entry.set)\n        );\n    }\n\n    /**\n     * Defines the given property.\n     * @param {ASTNode} node The Property node to define.\n     * @returns {void}\n     */\n    defineProperty(node) {\n        const entry = this.getPropertyInfo(node);\n\n        if (GET_KIND.test(node.kind)) {\n            entry.get = true;\n        }\n        if (SET_KIND.test(node.kind)) {\n            entry.set = true;\n        }\n    }\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noDupeKeys = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow duplicate keys in object literals\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-dupe-keys\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"Duplicate key '{{name}}'.\"\n        }\n    },\n\n    create(context) {\n        let info = null;\n\n        return {\n            ObjectExpression(node) {\n                info = new ObjectInfo(info, node);\n            },\n            \"ObjectExpression:exit\"() {\n                info = info.upper;\n            },\n\n            Property(node) {\n                const name = astUtils$1.getStaticPropertyName(node);\n\n                // Skip destructuring.\n                if (node.parent.type !== \"ObjectExpression\") {\n                    return;\n                }\n\n                // Skip if the name is not static.\n                if (name === null) {\n                    return;\n                }\n\n                // Reports if the name is defined already.\n                if (info.isPropertyDefined(node)) {\n                    context.report({\n                        node: info.node,\n                        loc: node.key.loc,\n                        messageId: \"unexpected\",\n                        data: { name }\n                    });\n                }\n\n                // Update info.\n                info.defineProperty(node);\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to disallow a duplicate case label.\n * @author Dieter Oberkofler\n * @author Burak Yigit Kaya\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noDuplicateCase = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow duplicate case labels\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-duplicate-case\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"Duplicate case label.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        return {\n            SwitchStatement(node) {\n                const previousKeys = new Set();\n\n                for (const switchCase of node.cases) {\n                    if (switchCase.test) {\n                        const key = sourceCode.getText(switchCase.test);\n\n                        if (previousKeys.has(key)) {\n                            context.report({ node: switchCase, messageId: \"unexpected\" });\n                        } else {\n                            previousKeys.add(key);\n                        }\n                    }\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Restrict usage of duplicate imports.\n * @author Simen Bekkhus\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\n/**\n * Returns the name of the module imported or re-exported.\n * @param {ASTNode} node A node to get.\n * @returns {string} the name of the module, or empty string if no name.\n */\nfunction getValue(node) {\n    if (node && node.source && node.source.value) {\n        return node.source.value.trim();\n    }\n\n    return \"\";\n}\n\n/**\n * Checks if the name of the import or export exists in the given array, and reports if so.\n * @param {RuleContext} context The ESLint rule context object.\n * @param {ASTNode} node A node to get.\n * @param {string} value The name of the imported or exported module.\n * @param {string[]} array The array containing other imports or exports in the file.\n * @param {string} messageId A messageId to be reported after the name of the module\n *\n * @returns {void} No return value\n */\nfunction checkAndReport(context, node, value, array, messageId) {\n    if (array.indexOf(value) !== -1) {\n        context.report({\n            node,\n            messageId,\n            data: {\n                module: value\n            }\n        });\n    }\n}\n\n/**\n * @callback nodeCallback\n * @param {ASTNode} node A node to handle.\n */\n\n/**\n * Returns a function handling the imports of a given file\n * @param {RuleContext} context The ESLint rule context object.\n * @param {boolean} includeExports Whether or not to check for exports in addition to imports.\n * @param {string[]} importsInFile The array containing other imports in the file.\n * @param {string[]} exportsInFile The array containing other exports in the file.\n *\n * @returns {nodeCallback} A function passed to ESLint to handle the statement.\n */\nfunction handleImports(context, includeExports, importsInFile, exportsInFile) {\n    return function(node) {\n        const value = getValue(node);\n\n        if (value) {\n            checkAndReport(context, node, value, importsInFile, \"import\");\n\n            if (includeExports) {\n                checkAndReport(context, node, value, exportsInFile, \"importAs\");\n            }\n\n            importsInFile.push(value);\n        }\n    };\n}\n\n/**\n * Returns a function handling the exports of a given file\n * @param {RuleContext} context The ESLint rule context object.\n * @param {string[]} importsInFile The array containing other imports in the file.\n * @param {string[]} exportsInFile The array containing other exports in the file.\n *\n * @returns {nodeCallback} A function passed to ESLint to handle the statement.\n */\nfunction handleExports(context, importsInFile, exportsInFile) {\n    return function(node) {\n        const value = getValue(node);\n\n        if (value) {\n            checkAndReport(context, node, value, exportsInFile, \"export\");\n            checkAndReport(context, node, value, importsInFile, \"exportAs\");\n\n            exportsInFile.push(value);\n        }\n    };\n}\n\nvar noDuplicateImports = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow duplicate module imports\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-duplicate-imports\"\n        },\n\n        schema: [{\n            type: \"object\",\n            properties: {\n                includeExports: {\n                    type: \"boolean\",\n                    default: false\n                }\n            },\n            additionalProperties: false\n        }],\n        messages: {\n            import: \"'{{module}}' import is duplicated.\",\n            importAs: \"'{{module}}' import is duplicated as export.\",\n            export: \"'{{module}}' export is duplicated.\",\n            exportAs: \"'{{module}}' export is duplicated as import.\"\n        }\n    },\n\n    create(context) {\n        const includeExports = (context.options[0] || {}).includeExports,\n            importsInFile = [],\n            exportsInFile = [];\n\n        const handlers = {\n            ImportDeclaration: handleImports(context, includeExports, importsInFile, exportsInFile)\n        };\n\n        if (includeExports) {\n            handlers.ExportNamedDeclaration = handleExports(context, importsInFile, exportsInFile);\n            handlers.ExportAllDeclaration = handleExports(context, importsInFile, exportsInFile);\n        }\n\n        return handlers;\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * A helper class to combine fix options into a fix command. Currently, it\n * exposes some \"retain\" methods that extend the range of the text being\n * replaced so that other fixes won't touch that region in the same pass.\n */\nclass FixTracker {\n\n    /**\n     * Create a new FixTracker.\n     * @param {ruleFixer} fixer A ruleFixer instance.\n     * @param {SourceCode} sourceCode A SourceCode object for the current code.\n     */\n    constructor(fixer, sourceCode) {\n        this.fixer = fixer;\n        this.sourceCode = sourceCode;\n        this.retainedRange = null;\n    }\n\n    /**\n     * Mark the given range as \"retained\", meaning that other fixes may not\n     * may not modify this region in the same pass.\n     * @param {int[]} range The range to retain.\n     * @returns {FixTracker} The same RuleFixer, for chained calls.\n     */\n    retainRange(range) {\n        this.retainedRange = range;\n        return this;\n    }\n\n    /**\n     * Given a node, find the function containing it (or the entire program) and\n     * mark it as retained, meaning that other fixes may not modify it in this\n     * pass. This is useful for avoiding conflicts in fixes that modify control\n     * flow.\n     * @param {ASTNode} node The node to use as a starting point.\n     * @returns {FixTracker} The same RuleFixer, for chained calls.\n     */\n    retainEnclosingFunction(node) {\n        const functionNode = astUtils$1.getUpperFunction(node);\n\n        return this.retainRange(functionNode ? functionNode.range : this.sourceCode.ast.range);\n    }\n\n    /**\n     * Given a node or token, find the token before and afterward, and mark that\n     * range as retained, meaning that other fixes may not modify it in this\n     * pass. This is useful for avoiding conflicts in fixes that make a small\n     * change to the code where the AST should not be changed.\n     * @param {ASTNode|Token} nodeOrToken The node or token to use as a starting\n     *      point. The token to the left and right are use in the range.\n     * @returns {FixTracker} The same RuleFixer, for chained calls.\n     */\n    retainSurroundingTokens(nodeOrToken) {\n        const tokenBefore = this.sourceCode.getTokenBefore(nodeOrToken) || nodeOrToken;\n        const tokenAfter = this.sourceCode.getTokenAfter(nodeOrToken) || nodeOrToken;\n\n        return this.retainRange([tokenBefore.range[0], tokenAfter.range[1]]);\n    }\n\n    /**\n     * Create a fix command that replaces the given range with the given text,\n     * accounting for any retained ranges.\n     * @param {int[]} range The range to remove in the fix.\n     * @param {string} text The text to insert in place of the range.\n     * @returns {Object} The fix command.\n     */\n    replaceTextRange(range, text) {\n        let actualRange;\n\n        if (this.retainedRange) {\n            actualRange = [\n                Math.min(this.retainedRange[0], range[0]),\n                Math.max(this.retainedRange[1], range[1])\n            ];\n        } else {\n            actualRange = range;\n        }\n\n        return this.fixer.replaceTextRange(\n            actualRange,\n            this.sourceCode.text.slice(actualRange[0], range[0]) +\n                text +\n                this.sourceCode.text.slice(range[1], actualRange[1])\n        );\n    }\n\n    /**\n     * Create a fix command that removes the given node or token, accounting for\n     * any retained ranges.\n     * @param {ASTNode|Token} nodeOrToken The node or token to remove.\n     * @returns {Object} The fix command.\n     */\n    remove(nodeOrToken) {\n        return this.replaceTextRange(nodeOrToken.range, \"\");\n    }\n}\n\nvar fixTracker = FixTracker;\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noElseReturn = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `else` blocks after `return` statements in `if` statements\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-else-return\"\n        },\n\n        schema: [{\n            type: \"object\",\n            properties: {\n                allowElseIf: {\n                    type: \"boolean\",\n                    default: true\n                }\n            },\n            additionalProperties: false\n        }],\n\n        fixable: \"code\",\n\n        messages: {\n            unexpected: \"Unnecessary 'else' after 'return'.\"\n        }\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Checks whether the given names can be safely used to declare block-scoped variables\n         * in the given scope. Name collisions can produce redeclaration syntax errors,\n         * or silently change references and modify behavior of the original code.\n         *\n         * This is not a generic function. In particular, it is assumed that the scope is a function scope or\n         * a function's inner scope, and that the names can be valid identifiers in the given scope.\n         * @param {string[]} names Array of variable names.\n         * @param {eslint-scope.Scope} scope Function scope or a function's inner scope.\n         * @returns {boolean} True if all names can be safely declared, false otherwise.\n         */\n        function isSafeToDeclare(names, scope) {\n\n            if (names.length === 0) {\n                return true;\n            }\n\n            const functionScope = scope.variableScope;\n\n            /*\n             * If this is a function scope, scope.variables will contain parameters, implicit variables such as \"arguments\",\n             * all function-scoped variables ('var'), and block-scoped variables defined in the scope.\n             * If this is an inner scope, scope.variables will contain block-scoped variables defined in the scope.\n             *\n             * Redeclaring any of these would cause a syntax error, except for the implicit variables.\n             */\n            const declaredVariables = scope.variables.filter(({ defs }) => defs.length > 0);\n\n            if (declaredVariables.some(({ name }) => names.includes(name))) {\n                return false;\n            }\n\n            // Redeclaring a catch variable would also cause a syntax error.\n            if (scope !== functionScope && scope.upper.type === \"catch\") {\n                if (scope.upper.variables.some(({ name }) => names.includes(name))) {\n                    return false;\n                }\n            }\n\n            /*\n             * Redeclaring an implicit variable, such as \"arguments\", would not cause a syntax error.\n             * However, if the variable was used, declaring a new one with the same name would change references\n             * and modify behavior.\n             */\n            const usedImplicitVariables = scope.variables.filter(({ defs, references }) =>\n                defs.length === 0 && references.length > 0);\n\n            if (usedImplicitVariables.some(({ name }) => names.includes(name))) {\n                return false;\n            }\n\n            /*\n             * Declaring a variable with a name that was already used to reference a variable from an upper scope\n             * would change references and modify behavior.\n             */\n            if (scope.through.some(t => names.includes(t.identifier.name))) {\n                return false;\n            }\n\n            /*\n             * If the scope is an inner scope (not the function scope), an uninitialized `var` variable declared inside\n             * the scope node (directly or in one of its descendants) is neither declared nor 'through' in the scope.\n             *\n             * For example, this would be a syntax error \"Identifier 'a' has already been declared\":\n             * function foo() { if (bar) { let a; if (baz) { var a; } } }\n             */\n            if (scope !== functionScope) {\n                const scopeNodeRange = scope.block.range;\n                const variablesToCheck = functionScope.variables.filter(({ name }) => names.includes(name));\n\n                if (variablesToCheck.some(v => v.defs.some(({ node: { range } }) =>\n                    scopeNodeRange[0] <= range[0] && range[1] <= scopeNodeRange[1]))) {\n                    return false;\n                }\n            }\n\n            return true;\n        }\n\n\n        /**\n         * Checks whether the removal of `else` and its braces is safe from variable name collisions.\n         * @param {Node} node The 'else' node.\n         * @param {eslint-scope.Scope} scope The scope in which the node and the whole 'if' statement is.\n         * @returns {boolean} True if it is safe, false otherwise.\n         */\n        function isSafeFromNameCollisions(node, scope) {\n\n            if (node.type === \"FunctionDeclaration\") {\n\n                // Conditional function declaration. Scope and hoisting are unpredictable, different engines work differently.\n                return false;\n            }\n\n            if (node.type !== \"BlockStatement\") {\n                return true;\n            }\n\n            const elseBlockScope = scope.childScopes.find(({ block }) => block === node);\n\n            if (!elseBlockScope) {\n\n                // ecmaVersion < 6, `else` block statement cannot have its own scope, no possible collisions.\n                return true;\n            }\n\n            /*\n             * elseBlockScope is supposed to merge into its upper scope. elseBlockScope.variables array contains\n             * only block-scoped variables (such as let and const variables or class and function declarations)\n             * defined directly in the elseBlockScope. These are exactly the only names that could cause collisions.\n             */\n            const namesToCheck = elseBlockScope.variables.map(({ name }) => name);\n\n            return isSafeToDeclare(namesToCheck, scope);\n        }\n\n        /**\n         * Display the context report if rule is violated\n         * @param {Node} node The 'else' node\n         * @returns {void}\n         */\n        function displayReport(node) {\n            const currentScope = context.getScope();\n\n            context.report({\n                node,\n                messageId: \"unexpected\",\n                fix: fixer => {\n\n                    if (!isSafeFromNameCollisions(node, currentScope)) {\n                        return null;\n                    }\n\n                    const sourceCode = context.getSourceCode();\n                    const startToken = sourceCode.getFirstToken(node);\n                    const elseToken = sourceCode.getTokenBefore(startToken);\n                    const source = sourceCode.getText(node);\n                    const lastIfToken = sourceCode.getTokenBefore(elseToken);\n                    let fixedSource, firstTokenOfElseBlock;\n\n                    if (startToken.type === \"Punctuator\" && startToken.value === \"{\") {\n                        firstTokenOfElseBlock = sourceCode.getTokenAfter(startToken);\n                    } else {\n                        firstTokenOfElseBlock = startToken;\n                    }\n\n                    /*\n                     * If the if block does not have curly braces and does not end in a semicolon\n                     * and the else block starts with (, [, /, +, ` or -, then it is not\n                     * safe to remove the else keyword, because ASI will not add a semicolon\n                     * after the if block\n                     */\n                    const ifBlockMaybeUnsafe = node.parent.consequent.type !== \"BlockStatement\" && lastIfToken.value !== \";\";\n                    const elseBlockUnsafe = /^[([/+`-]/u.test(firstTokenOfElseBlock.value);\n\n                    if (ifBlockMaybeUnsafe && elseBlockUnsafe) {\n                        return null;\n                    }\n\n                    const endToken = sourceCode.getLastToken(node);\n                    const lastTokenOfElseBlock = sourceCode.getTokenBefore(endToken);\n\n                    if (lastTokenOfElseBlock.value !== \";\") {\n                        const nextToken = sourceCode.getTokenAfter(endToken);\n\n                        const nextTokenUnsafe = nextToken && /^[([/+`-]/u.test(nextToken.value);\n                        const nextTokenOnSameLine = nextToken && nextToken.loc.start.line === lastTokenOfElseBlock.loc.start.line;\n\n                        /*\n                         * If the else block contents does not end in a semicolon,\n                         * and the else block starts with (, [, /, +, ` or -, then it is not\n                         * safe to remove the else block, because ASI will not add a semicolon\n                         * after the remaining else block contents\n                         */\n                        if (nextTokenUnsafe || (nextTokenOnSameLine && nextToken.value !== \"}\")) {\n                            return null;\n                        }\n                    }\n\n                    if (startToken.type === \"Punctuator\" && startToken.value === \"{\") {\n                        fixedSource = source.slice(1, -1);\n                    } else {\n                        fixedSource = source;\n                    }\n\n                    /*\n                     * Extend the replacement range to include the entire\n                     * function to avoid conflicting with no-useless-return.\n                     * https://github.com/eslint/eslint/issues/8026\n                     *\n                     * Also, to avoid name collisions between two else blocks.\n                     */\n                    return new fixTracker(fixer, sourceCode)\n                        .retainEnclosingFunction(node)\n                        .replaceTextRange([elseToken.range[0], node.range[1]], fixedSource);\n                }\n            });\n        }\n\n        /**\n         * Check to see if the node is a ReturnStatement\n         * @param {Node} node The node being evaluated\n         * @returns {boolean} True if node is a return\n         */\n        function checkForReturn(node) {\n            return node.type === \"ReturnStatement\";\n        }\n\n        /**\n         * Naive return checking, does not iterate through the whole\n         * BlockStatement because we make the assumption that the ReturnStatement\n         * will be the last node in the body of the BlockStatement.\n         * @param {Node} node The consequent/alternate node\n         * @returns {boolean} True if it has a return\n         */\n        function naiveHasReturn(node) {\n            if (node.type === \"BlockStatement\") {\n                const body = node.body,\n                    lastChildNode = body[body.length - 1];\n\n                return lastChildNode && checkForReturn(lastChildNode);\n            }\n            return checkForReturn(node);\n        }\n\n        /**\n         * Check to see if the node is valid for evaluation,\n         * meaning it has an else.\n         * @param {Node} node The node being evaluated\n         * @returns {boolean} True if the node is valid\n         */\n        function hasElse(node) {\n            return node.alternate && node.consequent;\n        }\n\n        /**\n         * If the consequent is an IfStatement, check to see if it has an else\n         * and both its consequent and alternate path return, meaning this is\n         * a nested case of rule violation.  If-Else not considered currently.\n         * @param {Node} node The consequent node\n         * @returns {boolean} True if this is a nested rule violation\n         */\n        function checkForIf(node) {\n            return node.type === \"IfStatement\" && hasElse(node) &&\n                naiveHasReturn(node.alternate) && naiveHasReturn(node.consequent);\n        }\n\n        /**\n         * Check the consequent/body node to make sure it is not\n         * a ReturnStatement or an IfStatement that returns on both\n         * code paths.\n         * @param {Node} node The consequent or body node\n         * @returns {boolean} `true` if it is a Return/If node that always returns.\n         */\n        function checkForReturnOrIf(node) {\n            return checkForReturn(node) || checkForIf(node);\n        }\n\n\n        /**\n         * Check whether a node returns in every codepath.\n         * @param {Node} node The node to be checked\n         * @returns {boolean} `true` if it returns on every codepath.\n         */\n        function alwaysReturns(node) {\n            if (node.type === \"BlockStatement\") {\n\n                // If we have a BlockStatement, check each consequent body node.\n                return node.body.some(checkForReturnOrIf);\n            }\n\n            /*\n             * If not a block statement, make sure the consequent isn't a\n             * ReturnStatement or an IfStatement with returns on both paths.\n             */\n            return checkForReturnOrIf(node);\n        }\n\n\n        /**\n         * Check the if statement, but don't catch else-if blocks.\n         * @returns {void}\n         * @param {Node} node The node for the if statement to check\n         * @private\n         */\n        function checkIfWithoutElse(node) {\n            const parent = node.parent;\n\n            /*\n             * Fixing this would require splitting one statement into two, so no error should\n             * be reported if this node is in a position where only one statement is allowed.\n             */\n            if (!astUtils$1.STATEMENT_LIST_PARENTS.has(parent.type)) {\n                return;\n            }\n\n            const consequents = [];\n            let alternate;\n\n            for (let currentNode = node; currentNode.type === \"IfStatement\"; currentNode = currentNode.alternate) {\n                if (!currentNode.alternate) {\n                    return;\n                }\n                consequents.push(currentNode.consequent);\n                alternate = currentNode.alternate;\n            }\n\n            if (consequents.every(alwaysReturns)) {\n                displayReport(alternate);\n            }\n        }\n\n        /**\n         * Check the if statement\n         * @returns {void}\n         * @param {Node} node The node for the if statement to check\n         * @private\n         */\n        function checkIfWithElse(node) {\n            const parent = node.parent;\n\n\n            /*\n             * Fixing this would require splitting one statement into two, so no error should\n             * be reported if this node is in a position where only one statement is allowed.\n             */\n            if (!astUtils$1.STATEMENT_LIST_PARENTS.has(parent.type)) {\n                return;\n            }\n\n            const alternate = node.alternate;\n\n            if (alternate && alwaysReturns(node.consequent)) {\n                displayReport(alternate);\n            }\n        }\n\n        const allowElseIf = !(context.options[0] && context.options[0].allowElseIf === false);\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n\n            \"IfStatement:exit\": allowElseIf ? checkIfWithoutElse : checkIfWithElse\n\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noEmpty = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow empty block statements\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-empty\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allowEmptyCatch: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            unexpected: \"Empty {{type}} statement.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options[0] || {},\n            allowEmptyCatch = options.allowEmptyCatch || false;\n\n        const sourceCode = context.getSourceCode();\n\n        return {\n            BlockStatement(node) {\n\n                // if the body is not empty, we can just return immediately\n                if (node.body.length !== 0) {\n                    return;\n                }\n\n                // a function is generally allowed to be empty\n                if (astUtils$1.isFunction(node.parent)) {\n                    return;\n                }\n\n                if (allowEmptyCatch && node.parent.type === \"CatchClause\") {\n                    return;\n                }\n\n                // any other block is only allowed to be empty, if it contains a comment\n                if (sourceCode.getCommentsInside(node).length > 0) {\n                    return;\n                }\n\n                context.report({ node, messageId: \"unexpected\", data: { type: \"block\" } });\n            },\n\n            SwitchStatement(node) {\n\n                if (typeof node.cases === \"undefined\" || node.cases.length === 0) {\n                    context.report({ node, messageId: \"unexpected\", data: { type: \"switch\" } });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag the use of empty character classes in regular expressions\n * @author Ian Christian Myers\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/*\n * plain-English description of the following regexp:\n * 0. `^` fix the match at the beginning of the string\n * 1. `\\/`: the `/` that begins the regexp\n * 2. `([^\\\\[]|\\\\.|\\[([^\\\\\\]]|\\\\.)+\\])*`: regexp contents; 0 or more of the following\n * 2.0. `[^\\\\[]`: any character that's not a `\\` or a `[` (anything but escape sequences and character classes)\n * 2.1. `\\\\.`: an escape sequence\n * 2.2. `\\[([^\\\\\\]]|\\\\.)+\\]`: a character class that isn't empty\n * 3. `\\/` the `/` that ends the regexp\n * 4. `[gimuy]*`: optional regexp flags\n * 5. `$`: fix the match at the end of the string\n */\nconst regex = /^\\/([^\\\\[]|\\\\.|\\[([^\\\\\\]]|\\\\.)+\\])*\\/[gimuys]*$/u;\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noEmptyCharacterClass = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow empty character classes in regular expressions\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-empty-character-class\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"Empty class.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        return {\n\n            Literal(node) {\n                const token = sourceCode.getFirstToken(node);\n\n                if (token.type === \"RegularExpression\" && !regex.test(token.value)) {\n                    context.report({ node, messageId: \"unexpected\" });\n                }\n            }\n\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst ALLOW_OPTIONS = Object.freeze([\n    \"functions\",\n    \"arrowFunctions\",\n    \"generatorFunctions\",\n    \"methods\",\n    \"generatorMethods\",\n    \"getters\",\n    \"setters\",\n    \"constructors\"\n]);\n\n/**\n * Gets the kind of a given function node.\n * @param {ASTNode} node A function node to get. This is one of\n *      an ArrowFunctionExpression, a FunctionDeclaration, or a\n *      FunctionExpression.\n * @returns {string} The kind of the function. This is one of \"functions\",\n *      \"arrowFunctions\", \"generatorFunctions\", \"asyncFunctions\", \"methods\",\n *      \"generatorMethods\", \"asyncMethods\", \"getters\", \"setters\", and\n *      \"constructors\".\n */\nfunction getKind(node) {\n    const parent = node.parent;\n    let kind = \"\";\n\n    if (node.type === \"ArrowFunctionExpression\") {\n        return \"arrowFunctions\";\n    }\n\n    // Detects main kind.\n    if (parent.type === \"Property\") {\n        if (parent.kind === \"get\") {\n            return \"getters\";\n        }\n        if (parent.kind === \"set\") {\n            return \"setters\";\n        }\n        kind = parent.method ? \"methods\" : \"functions\";\n\n    } else if (parent.type === \"MethodDefinition\") {\n        if (parent.kind === \"get\") {\n            return \"getters\";\n        }\n        if (parent.kind === \"set\") {\n            return \"setters\";\n        }\n        if (parent.kind === \"constructor\") {\n            return \"constructors\";\n        }\n        kind = \"methods\";\n\n    } else {\n        kind = \"functions\";\n    }\n\n    // Detects prefix.\n    let prefix = \"\";\n\n    if (node.generator) {\n        prefix = \"generator\";\n    } else if (node.async) {\n        prefix = \"async\";\n    } else {\n        return kind;\n    }\n    return prefix + kind[0].toUpperCase() + kind.slice(1);\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noEmptyFunction = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow empty functions\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-empty-function\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allow: {\n                        type: \"array\",\n                        items: { enum: ALLOW_OPTIONS },\n                        uniqueItems: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            unexpected: \"Unexpected empty {{name}}.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options[0] || {};\n        const allowed = options.allow || [];\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Reports a given function node if the node matches the following patterns.\n         *\n         * - Not allowed by options.\n         * - The body is empty.\n         * - The body doesn't have any comments.\n         * @param {ASTNode} node A function node to report. This is one of\n         *      an ArrowFunctionExpression, a FunctionDeclaration, or a\n         *      FunctionExpression.\n         * @returns {void}\n         */\n        function reportIfEmpty(node) {\n            const kind = getKind(node);\n            const name = astUtils$1.getFunctionNameWithKind(node);\n            const innerComments = sourceCode.getTokens(node.body, {\n                includeComments: true,\n                filter: astUtils$1.isCommentToken\n            });\n\n            if (allowed.indexOf(kind) === -1 &&\n                node.body.type === \"BlockStatement\" &&\n                node.body.body.length === 0 &&\n                innerComments.length === 0\n            ) {\n                context.report({\n                    node,\n                    loc: node.body.loc.start,\n                    messageId: \"unexpected\",\n                    data: { name }\n                });\n            }\n        }\n\n        return {\n            ArrowFunctionExpression: reportIfEmpty,\n            FunctionDeclaration: reportIfEmpty,\n            FunctionExpression: reportIfEmpty\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to disallow an empty pattern\n * @author Alberto Rodríguez\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noEmptyPattern = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow empty destructuring patterns\",\n            category: \"Best Practices\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-empty-pattern\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"Unexpected empty {{type}} pattern.\"\n        }\n    },\n\n    create(context) {\n        return {\n            ObjectPattern(node) {\n                if (node.properties.length === 0) {\n                    context.report({ node, messageId: \"unexpected\", data: { type: \"object\" } });\n                }\n            },\n            ArrayPattern(node) {\n                if (node.elements.length === 0) {\n                    context.report({ node, messageId: \"unexpected\", data: { type: \"array\" } });\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag comparisons to null without a type-checking\n * operator.\n * @author Ian Christian Myers\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noEqNull = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `null` comparisons without type-checking operators\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-eq-null\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"Use '===' to compare with null.\"\n        }\n    },\n\n    create(context) {\n\n        return {\n\n            BinaryExpression(node) {\n                const badOperator = node.operator === \"==\" || node.operator === \"!=\";\n\n                if (node.right.type === \"Literal\" && node.right.raw === \"null\" && badOperator ||\n                        node.left.type === \"Literal\" && node.left.raw === \"null\" && badOperator) {\n                    context.report({ node, messageId: \"unexpected\" });\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst candidatesOfGlobalObject = Object.freeze([\n    \"global\",\n    \"window\"\n]);\n\n/**\n * Checks a given node is a Identifier node of the specified name.\n * @param {ASTNode} node A node to check.\n * @param {string} name A name to check.\n * @returns {boolean} `true` if the node is a Identifier node of the name.\n */\nfunction isIdentifier$3(node, name) {\n    return node.type === \"Identifier\" && node.name === name;\n}\n\n/**\n * Checks a given node is a Literal node of the specified string value.\n * @param {ASTNode} node A node to check.\n * @param {string} name A name to check.\n * @returns {boolean} `true` if the node is a Literal node of the name.\n */\nfunction isConstant(node, name) {\n    switch (node.type) {\n        case \"Literal\":\n            return node.value === name;\n\n        case \"TemplateLiteral\":\n            return (\n                node.expressions.length === 0 &&\n                node.quasis[0].value.cooked === name\n            );\n\n        default:\n            return false;\n    }\n}\n\n/**\n * Checks a given node is a MemberExpression node which has the specified name's\n * property.\n * @param {ASTNode} node A node to check.\n * @param {string} name A name to check.\n * @returns {boolean} `true` if the node is a MemberExpression node which has\n *      the specified name's property\n */\nfunction isMember(node, name) {\n    return (\n        node.type === \"MemberExpression\" &&\n        (node.computed ? isConstant : isIdentifier$3)(node.property, name)\n    );\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noEval = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow the use of `eval()`\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-eval\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allowIndirect: { type: \"boolean\", default: false }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            unexpected: \"eval can be harmful.\"\n        }\n    },\n\n    create(context) {\n        const allowIndirect = Boolean(\n            context.options[0] &&\n            context.options[0].allowIndirect\n        );\n        const sourceCode = context.getSourceCode();\n        let funcInfo = null;\n\n        /**\n         * Pushs a variable scope (Program or Function) information to the stack.\n         *\n         * This is used in order to check whether or not `this` binding is a\n         * reference to the global object.\n         * @param {ASTNode} node A node of the scope. This is one of Program,\n         *      FunctionDeclaration, FunctionExpression, and ArrowFunctionExpression.\n         * @returns {void}\n         */\n        function enterVarScope(node) {\n            const strict = context.getScope().isStrict;\n\n            funcInfo = {\n                upper: funcInfo,\n                node,\n                strict,\n                defaultThis: false,\n                initialized: strict\n            };\n        }\n\n        /**\n         * Pops a variable scope from the stack.\n         * @returns {void}\n         */\n        function exitVarScope() {\n            funcInfo = funcInfo.upper;\n        }\n\n        /**\n         * Reports a given node.\n         *\n         * `node` is `Identifier` or `MemberExpression`.\n         * The parent of `node` might be `CallExpression`.\n         *\n         * The location of the report is always `eval` `Identifier` (or possibly\n         * `Literal`). The type of the report is `CallExpression` if the parent is\n         * `CallExpression`. Otherwise, it's the given node type.\n         * @param {ASTNode} node A node to report.\n         * @returns {void}\n         */\n        function report(node) {\n            const parent = node.parent;\n            const locationNode = node.type === \"MemberExpression\"\n                ? node.property\n                : node;\n\n            const reportNode = parent.type === \"CallExpression\" && parent.callee === node\n                ? parent\n                : node;\n\n            context.report({\n                node: reportNode,\n                loc: locationNode.loc.start,\n                messageId: \"unexpected\"\n            });\n        }\n\n        /**\n         * Reports accesses of `eval` via the global object.\n         * @param {eslint-scope.Scope} globalScope The global scope.\n         * @returns {void}\n         */\n        function reportAccessingEvalViaGlobalObject(globalScope) {\n            for (let i = 0; i < candidatesOfGlobalObject.length; ++i) {\n                const name = candidatesOfGlobalObject[i];\n                const variable = astUtils$1.getVariableByName(globalScope, name);\n\n                if (!variable) {\n                    continue;\n                }\n\n                const references = variable.references;\n\n                for (let j = 0; j < references.length; ++j) {\n                    const identifier = references[j].identifier;\n                    let node = identifier.parent;\n\n                    // To detect code like `window.window.eval`.\n                    while (isMember(node, name)) {\n                        node = node.parent;\n                    }\n\n                    // Reports.\n                    if (isMember(node, \"eval\")) {\n                        report(node);\n                    }\n                }\n            }\n        }\n\n        /**\n         * Reports all accesses of `eval` (excludes direct calls to eval).\n         * @param {eslint-scope.Scope} globalScope The global scope.\n         * @returns {void}\n         */\n        function reportAccessingEval(globalScope) {\n            const variable = astUtils$1.getVariableByName(globalScope, \"eval\");\n\n            if (!variable) {\n                return;\n            }\n\n            const references = variable.references;\n\n            for (let i = 0; i < references.length; ++i) {\n                const reference = references[i];\n                const id = reference.identifier;\n\n                if (id.name === \"eval\" && !astUtils$1.isCallee(id)) {\n\n                    // Is accessing to eval (excludes direct calls to eval)\n                    report(id);\n                }\n            }\n        }\n\n        if (allowIndirect) {\n\n            // Checks only direct calls to eval. It's simple!\n            return {\n                \"CallExpression:exit\"(node) {\n                    const callee = node.callee;\n\n                    if (isIdentifier$3(callee, \"eval\")) {\n                        report(callee);\n                    }\n                }\n            };\n        }\n\n        return {\n            \"CallExpression:exit\"(node) {\n                const callee = node.callee;\n\n                if (isIdentifier$3(callee, \"eval\")) {\n                    report(callee);\n                }\n            },\n\n            Program(node) {\n                const scope = context.getScope(),\n                    features = context.parserOptions.ecmaFeatures || {},\n                    strict =\n                        scope.isStrict ||\n                        node.sourceType === \"module\" ||\n                        (features.globalReturn && scope.childScopes[0].isStrict);\n\n                funcInfo = {\n                    upper: null,\n                    node,\n                    strict,\n                    defaultThis: true,\n                    initialized: true\n                };\n            },\n\n            \"Program:exit\"() {\n                const globalScope = context.getScope();\n\n                exitVarScope();\n                reportAccessingEval(globalScope);\n                reportAccessingEvalViaGlobalObject(globalScope);\n            },\n\n            FunctionDeclaration: enterVarScope,\n            \"FunctionDeclaration:exit\": exitVarScope,\n            FunctionExpression: enterVarScope,\n            \"FunctionExpression:exit\": exitVarScope,\n            ArrowFunctionExpression: enterVarScope,\n            \"ArrowFunctionExpression:exit\": exitVarScope,\n\n            ThisExpression(node) {\n                if (!isMember(node.parent, \"eval\")) {\n                    return;\n                }\n\n                /*\n                 * `this.eval` is found.\n                 * Checks whether or not the value of `this` is the global object.\n                 */\n                if (!funcInfo.initialized) {\n                    funcInfo.initialized = true;\n                    funcInfo.defaultThis = astUtils$1.isDefaultThisBinding(\n                        funcInfo.node,\n                        sourceCode\n                    );\n                }\n\n                if (!funcInfo.strict && funcInfo.defaultThis) {\n\n                    // `this.eval` is possible built-in `eval`.\n                    report(node.parent);\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noExAssign = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow reassigning exceptions in `catch` clauses\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-ex-assign\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpected: \"Do not assign to the exception parameter.\"\n        }\n    },\n\n    create(context) {\n\n        /**\n         * Finds and reports references that are non initializer and writable.\n         * @param {Variable} variable A variable to check.\n         * @returns {void}\n         */\n        function checkVariable(variable) {\n            astUtils$1.getModifyingReferences(variable.references).forEach(reference => {\n                context.report({ node: reference.identifier, messageId: \"unexpected\" });\n            });\n        }\n\n        return {\n            CatchClause(node) {\n                context.getDeclaredVariables(node).forEach(checkVariable);\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst propertyDefinitionMethods = new Set([\"defineProperty\", \"defineProperties\"]);\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noExtendNative = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow extending native types\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-extend-native\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    exceptions: {\n                        type: \"array\",\n                        items: {\n                            type: \"string\"\n                        },\n                        uniqueItems: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            unexpected: \"{{builtin}} prototype is read only, properties should not be added.\"\n        }\n    },\n\n    create(context) {\n\n        const config = context.options[0] || {};\n        const exceptions = new Set(config.exceptions || []);\n        const modifiedBuiltins = new Set(\n            Object.keys(globals$2.builtin)\n                .filter(builtin => builtin[0].toUpperCase() === builtin[0])\n                .filter(builtin => !exceptions.has(builtin))\n        );\n\n        /**\n         * Reports a lint error for the given node.\n         * @param {ASTNode} node The node to report.\n         * @param {string} builtin The name of the native builtin being extended.\n         * @returns {void}\n         */\n        function reportNode(node, builtin) {\n            context.report({\n                node,\n                messageId: \"unexpected\",\n                data: {\n                    builtin\n                }\n            });\n        }\n\n        /**\n         * Check to see if the `prototype` property of the given object\n         * identifier node is being accessed.\n         * @param {ASTNode} identifierNode The Identifier representing the object\n         * to check.\n         * @returns {boolean} True if the identifier is the object of a\n         * MemberExpression and its `prototype` property is being accessed,\n         * false otherwise.\n         */\n        function isPrototypePropertyAccessed(identifierNode) {\n            return Boolean(\n                identifierNode &&\n                identifierNode.parent &&\n                identifierNode.parent.type === \"MemberExpression\" &&\n                identifierNode.parent.object === identifierNode &&\n                astUtils$1.getStaticPropertyName(identifierNode.parent) === \"prototype\"\n            );\n        }\n\n        /**\n         * Checks that an identifier is an object of a prototype whose member\n         * is being assigned in an AssignmentExpression.\n         * Example: Object.prototype.foo = \"bar\"\n         * @param {ASTNode} identifierNode The identifier to check.\n         * @returns {boolean} True if the identifier's prototype is modified.\n         */\n        function isInPrototypePropertyAssignment(identifierNode) {\n            return Boolean(\n                isPrototypePropertyAccessed(identifierNode) &&\n                identifierNode.parent.parent.type === \"MemberExpression\" &&\n                identifierNode.parent.parent.parent.type === \"AssignmentExpression\" &&\n                identifierNode.parent.parent.parent.left === identifierNode.parent.parent\n            );\n        }\n\n        /**\n         * Checks that an identifier is an object of a prototype whose member\n         * is being extended via the Object.defineProperty() or\n         * Object.defineProperties() methods.\n         * Example: Object.defineProperty(Array.prototype, \"foo\", ...)\n         * Example: Object.defineProperties(Array.prototype, ...)\n         * @param {ASTNode} identifierNode The identifier to check.\n         * @returns {boolean} True if the identifier's prototype is modified.\n         */\n        function isInDefinePropertyCall(identifierNode) {\n            return Boolean(\n                isPrototypePropertyAccessed(identifierNode) &&\n                identifierNode.parent.parent.type === \"CallExpression\" &&\n                identifierNode.parent.parent.arguments[0] === identifierNode.parent &&\n                identifierNode.parent.parent.callee.type === \"MemberExpression\" &&\n                identifierNode.parent.parent.callee.object.type === \"Identifier\" &&\n                identifierNode.parent.parent.callee.object.name === \"Object\" &&\n                identifierNode.parent.parent.callee.property.type === \"Identifier\" &&\n                propertyDefinitionMethods.has(identifierNode.parent.parent.callee.property.name)\n            );\n        }\n\n        /**\n         * Check to see if object prototype access is part of a prototype\n         * extension. There are three ways a prototype can be extended:\n         * 1. Assignment to prototype property (Object.prototype.foo = 1)\n         * 2. Object.defineProperty()/Object.defineProperties() on a prototype\n         * If prototype extension is detected, report the AssignmentExpression\n         * or CallExpression node.\n         * @param {ASTNode} identifierNode The Identifier representing the object\n         * which prototype is being accessed and possibly extended.\n         * @returns {void}\n         */\n        function checkAndReportPrototypeExtension(identifierNode) {\n            if (isInPrototypePropertyAssignment(identifierNode)) {\n\n                // Identifier --> MemberExpression --> MemberExpression --> AssignmentExpression\n                reportNode(identifierNode.parent.parent.parent, identifierNode.name);\n            } else if (isInDefinePropertyCall(identifierNode)) {\n\n                // Identifier --> MemberExpression --> CallExpression\n                reportNode(identifierNode.parent.parent, identifierNode.name);\n            }\n        }\n\n        return {\n\n            \"Program:exit\"() {\n                const globalScope = context.getScope();\n\n                modifiedBuiltins.forEach(builtin => {\n                    const builtinVar = globalScope.set.get(builtin);\n\n                    if (builtinVar && builtinVar.references) {\n                        builtinVar.references\n                            .map(ref => ref.identifier)\n                            .forEach(checkAndReportPrototypeExtension);\n                    }\n                });\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst SIDE_EFFECT_FREE_NODE_TYPES = new Set([\"Literal\", \"Identifier\", \"ThisExpression\", \"FunctionExpression\"]);\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noExtraBind = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow unnecessary calls to `.bind()`\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-extra-bind\"\n        },\n\n        schema: [],\n        fixable: \"code\",\n\n        messages: {\n            unexpected: \"The function binding is unnecessary.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        let scopeInfo = null;\n\n        /**\n         * Checks if a node is free of side effects.\n         *\n         * This check is stricter than it needs to be, in order to keep the implementation simple.\n         * @param {ASTNode} node A node to check.\n         * @returns {boolean} True if the node is known to be side-effect free, false otherwise.\n         */\n        function isSideEffectFree(node) {\n            return SIDE_EFFECT_FREE_NODE_TYPES.has(node.type);\n        }\n\n        /**\n         * Reports a given function node.\n         * @param {ASTNode} node A node to report. This is a FunctionExpression or\n         *      an ArrowFunctionExpression.\n         * @returns {void}\n         */\n        function report(node) {\n            context.report({\n                node: node.parent.parent,\n                messageId: \"unexpected\",\n                loc: node.parent.property.loc.start,\n                fix(fixer) {\n                    if (node.parent.parent.arguments.length && !isSideEffectFree(node.parent.parent.arguments[0])) {\n                        return null;\n                    }\n\n                    const firstTokenToRemove = sourceCode\n                        .getFirstTokenBetween(node.parent.object, node.parent.property, astUtils$1.isNotClosingParenToken);\n                    const lastTokenToRemove = sourceCode.getLastToken(node.parent.parent);\n\n                    if (sourceCode.commentsExistBetween(firstTokenToRemove, lastTokenToRemove)) {\n                        return null;\n                    }\n\n                    return fixer.removeRange([firstTokenToRemove.range[0], node.parent.parent.range[1]]);\n                }\n            });\n        }\n\n        /**\n         * Checks whether or not a given function node is the callee of `.bind()`\n         * method.\n         *\n         * e.g. `(function() {}.bind(foo))`\n         * @param {ASTNode} node A node to report. This is a FunctionExpression or\n         *      an ArrowFunctionExpression.\n         * @returns {boolean} `true` if the node is the callee of `.bind()` method.\n         */\n        function isCalleeOfBindMethod(node) {\n            const parent = node.parent;\n            const grandparent = parent.parent;\n\n            return (\n                grandparent &&\n                grandparent.type === \"CallExpression\" &&\n                grandparent.callee === parent &&\n                grandparent.arguments.length === 1 &&\n                grandparent.arguments[0].type !== \"SpreadElement\" &&\n                parent.type === \"MemberExpression\" &&\n                parent.object === node &&\n                astUtils$1.getStaticPropertyName(parent) === \"bind\"\n            );\n        }\n\n        /**\n         * Adds a scope information object to the stack.\n         * @param {ASTNode} node A node to add. This node is a FunctionExpression\n         *      or a FunctionDeclaration node.\n         * @returns {void}\n         */\n        function enterFunction(node) {\n            scopeInfo = {\n                isBound: isCalleeOfBindMethod(node),\n                thisFound: false,\n                upper: scopeInfo\n            };\n        }\n\n        /**\n         * Removes the scope information object from the top of the stack.\n         * At the same time, this reports the function node if the function has\n         * `.bind()` and the `this` keywords found.\n         * @param {ASTNode} node A node to remove. This node is a\n         *      FunctionExpression or a FunctionDeclaration node.\n         * @returns {void}\n         */\n        function exitFunction(node) {\n            if (scopeInfo.isBound && !scopeInfo.thisFound) {\n                report(node);\n            }\n\n            scopeInfo = scopeInfo.upper;\n        }\n\n        /**\n         * Reports a given arrow function if the function is callee of `.bind()`\n         * method.\n         * @param {ASTNode} node A node to report. This node is an\n         *      ArrowFunctionExpression.\n         * @returns {void}\n         */\n        function exitArrowFunction(node) {\n            if (isCalleeOfBindMethod(node)) {\n                report(node);\n            }\n        }\n\n        /**\n         * Set the mark as the `this` keyword was found in this scope.\n         * @returns {void}\n         */\n        function markAsThisFound() {\n            if (scopeInfo) {\n                scopeInfo.thisFound = true;\n            }\n        }\n\n        return {\n            \"ArrowFunctionExpression:exit\": exitArrowFunction,\n            FunctionDeclaration: enterFunction,\n            \"FunctionDeclaration:exit\": exitFunction,\n            FunctionExpression: enterFunction,\n            \"FunctionExpression:exit\": exitFunction,\n            ThisExpression: markAsThisFound\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noExtraBooleanCast = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow unnecessary boolean casts\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-extra-boolean-cast\"\n        },\n\n        schema: [],\n        fixable: \"code\",\n\n        messages: {\n            unexpectedCall: \"Redundant Boolean call.\",\n            unexpectedNegation: \"Redundant double negation.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        // Node types which have a test which will coerce values to booleans.\n        const BOOLEAN_NODE_TYPES = [\n            \"IfStatement\",\n            \"DoWhileStatement\",\n            \"WhileStatement\",\n            \"ConditionalExpression\",\n            \"ForStatement\"\n        ];\n\n        /**\n         * Check if a node is in a context where its value would be coerced to a boolean at runtime.\n         * @param {ASTNode} node The node\n         * @param {ASTNode} parent Its parent\n         * @returns {boolean} If it is in a boolean context\n         */\n        function isInBooleanContext(node, parent) {\n            return (\n                (BOOLEAN_NODE_TYPES.indexOf(parent.type) !== -1 &&\n                    node === parent.test) ||\n\n                // !<bool>\n                (parent.type === \"UnaryExpression\" &&\n                    parent.operator === \"!\")\n            );\n        }\n\n        /**\n         * Check if a node has comments inside.\n         * @param {ASTNode} node The node to check.\n         * @returns {boolean} `true` if it has comments inside.\n         */\n        function hasCommentsInside(node) {\n            return Boolean(sourceCode.getCommentsInside(node).length);\n        }\n\n        return {\n            UnaryExpression(node) {\n                const ancestors = context.getAncestors(),\n                    parent = ancestors.pop(),\n                    grandparent = ancestors.pop();\n\n                // Exit early if it's guaranteed not to match\n                if (node.operator !== \"!\" ||\n                        parent.type !== \"UnaryExpression\" ||\n                        parent.operator !== \"!\") {\n                    return;\n                }\n\n                if (isInBooleanContext(parent, grandparent) ||\n\n                    // Boolean(<bool>) and new Boolean(<bool>)\n                    ((grandparent.type === \"CallExpression\" || grandparent.type === \"NewExpression\") &&\n                        grandparent.callee.type === \"Identifier\" &&\n                        grandparent.callee.name === \"Boolean\")\n                ) {\n                    context.report({\n                        node: parent,\n                        messageId: \"unexpectedNegation\",\n                        fix: fixer => {\n                            if (hasCommentsInside(parent)) {\n                                return null;\n                            }\n\n                            let prefix = \"\";\n                            const tokenBefore = sourceCode.getTokenBefore(parent);\n                            const firstReplacementToken = sourceCode.getFirstToken(node.argument);\n\n                            if (tokenBefore && tokenBefore.range[1] === parent.range[0] &&\n                                    !astUtils$1.canTokensBeAdjacent(tokenBefore, firstReplacementToken)) {\n                                prefix = \" \";\n                            }\n\n                            return fixer.replaceText(parent, prefix + sourceCode.getText(node.argument));\n                        }\n                    });\n                }\n            },\n            CallExpression(node) {\n                const parent = node.parent;\n\n                if (node.callee.type !== \"Identifier\" || node.callee.name !== \"Boolean\") {\n                    return;\n                }\n\n                if (isInBooleanContext(node, parent)) {\n                    context.report({\n                        node,\n                        messageId: \"unexpectedCall\",\n                        fix: fixer => {\n                            if (!node.arguments.length) {\n                                if (parent.type === \"UnaryExpression\" && parent.operator === \"!\") {\n\n                                    // !Boolean() -> true\n\n                                    if (hasCommentsInside(parent)) {\n                                        return null;\n                                    }\n\n                                    const replacement = \"true\";\n                                    let prefix = \"\";\n                                    const tokenBefore = sourceCode.getTokenBefore(parent);\n\n                                    if (tokenBefore && tokenBefore.range[1] === parent.range[0] &&\n                                            !astUtils$1.canTokensBeAdjacent(tokenBefore, replacement)) {\n                                        prefix = \" \";\n                                    }\n\n                                    return fixer.replaceText(parent, prefix + replacement);\n                                }\n\n                                // Boolean() -> false\n                                if (hasCommentsInside(node)) {\n                                    return null;\n                                }\n                                return fixer.replaceText(node, \"false\");\n                            }\n\n                            if (node.arguments.length > 1 || node.arguments[0].type === \"SpreadElement\" ||\n                                    hasCommentsInside(node)) {\n                                return null;\n                            }\n\n                            const argument = node.arguments[0];\n\n                            if (astUtils$1.getPrecedence(argument) < astUtils$1.getPrecedence(node.parent)) {\n                                return fixer.replaceText(node, `(${sourceCode.getText(argument)})`);\n                            }\n                            return fixer.replaceText(node, sourceCode.getText(argument));\n                        }\n                    });\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noExtraLabel = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow unnecessary labels\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-extra-label\"\n        },\n\n        schema: [],\n        fixable: \"code\",\n\n        messages: {\n            unexpected: \"This label '{{name}}' is unnecessary.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        let scopeInfo = null;\n\n        /**\n         * Creates a new scope with a breakable statement.\n         * @param {ASTNode} node A node to create. This is a BreakableStatement.\n         * @returns {void}\n         */\n        function enterBreakableStatement(node) {\n            scopeInfo = {\n                label: node.parent.type === \"LabeledStatement\" ? node.parent.label : null,\n                breakable: true,\n                upper: scopeInfo\n            };\n        }\n\n        /**\n         * Removes the top scope of the stack.\n         * @returns {void}\n         */\n        function exitBreakableStatement() {\n            scopeInfo = scopeInfo.upper;\n        }\n\n        /**\n         * Creates a new scope with a labeled statement.\n         *\n         * This ignores it if the body is a breakable statement.\n         * In this case it's handled in the `enterBreakableStatement` function.\n         * @param {ASTNode} node A node to create. This is a LabeledStatement.\n         * @returns {void}\n         */\n        function enterLabeledStatement(node) {\n            if (!astUtils$1.isBreakableStatement(node.body)) {\n                scopeInfo = {\n                    label: node.label,\n                    breakable: false,\n                    upper: scopeInfo\n                };\n            }\n        }\n\n        /**\n         * Removes the top scope of the stack.\n         *\n         * This ignores it if the body is a breakable statement.\n         * In this case it's handled in the `exitBreakableStatement` function.\n         * @param {ASTNode} node A node. This is a LabeledStatement.\n         * @returns {void}\n         */\n        function exitLabeledStatement(node) {\n            if (!astUtils$1.isBreakableStatement(node.body)) {\n                scopeInfo = scopeInfo.upper;\n            }\n        }\n\n        /**\n         * Reports a given control node if it's unnecessary.\n         * @param {ASTNode} node A node. This is a BreakStatement or a\n         *      ContinueStatement.\n         * @returns {void}\n         */\n        function reportIfUnnecessary(node) {\n            if (!node.label) {\n                return;\n            }\n\n            const labelNode = node.label;\n\n            for (let info = scopeInfo; info !== null; info = info.upper) {\n                if (info.breakable || info.label && info.label.name === labelNode.name) {\n                    if (info.breakable && info.label && info.label.name === labelNode.name) {\n                        context.report({\n                            node: labelNode,\n                            messageId: \"unexpected\",\n                            data: labelNode,\n                            fix(fixer) {\n                                const breakOrContinueToken = sourceCode.getFirstToken(node);\n\n                                if (sourceCode.commentsExistBetween(breakOrContinueToken, labelNode)) {\n                                    return null;\n                                }\n\n                                return fixer.removeRange([breakOrContinueToken.range[1], labelNode.range[1]]);\n                            }\n                        });\n                    }\n                    return;\n                }\n            }\n        }\n\n        return {\n            WhileStatement: enterBreakableStatement,\n            \"WhileStatement:exit\": exitBreakableStatement,\n            DoWhileStatement: enterBreakableStatement,\n            \"DoWhileStatement:exit\": exitBreakableStatement,\n            ForStatement: enterBreakableStatement,\n            \"ForStatement:exit\": exitBreakableStatement,\n            ForInStatement: enterBreakableStatement,\n            \"ForInStatement:exit\": exitBreakableStatement,\n            ForOfStatement: enterBreakableStatement,\n            \"ForOfStatement:exit\": exitBreakableStatement,\n            SwitchStatement: enterBreakableStatement,\n            \"SwitchStatement:exit\": exitBreakableStatement,\n            LabeledStatement: enterLabeledStatement,\n            \"LabeledStatement:exit\": exitLabeledStatement,\n            BreakStatement: reportIfUnnecessary,\n            ContinueStatement: reportIfUnnecessary\n        };\n    }\n};\n\n/*! @author Toru Nagashima <https://github.com/mysticatea> */\n\n/**\n * Get the innermost scope which contains a given location.\n * @param {Scope} initialScope The initial scope to search.\n * @param {Node} node The location to search.\n * @returns {Scope} The innermost scope.\n */\nfunction getInnermostScope(initialScope, node) {\n    const location = node.range[0];\n\n    let scope = initialScope;\n    let found = false;\n    do {\n        found = false;\n        for (const childScope of scope.childScopes) {\n            const range = childScope.block.range;\n\n            if (range[0] <= location && location < range[1]) {\n                scope = childScope;\n                found = true;\n                break\n            }\n        }\n    } while (found)\n\n    return scope\n}\n\n/**\n * Find the variable of a given name.\n * @param {Scope} initialScope The scope to start finding.\n * @param {string|Node} nameOrNode The variable name to find. If this is a Node object then it should be an Identifier node.\n * @returns {Variable|null} The found variable or null.\n */\nfunction findVariable(initialScope, nameOrNode) {\n    let name = \"\";\n    let scope = initialScope;\n\n    if (typeof nameOrNode === \"string\") {\n        name = nameOrNode;\n    } else {\n        name = nameOrNode.name;\n        scope = getInnermostScope(scope, nameOrNode);\n    }\n\n    while (scope != null) {\n        const variable = scope.set.get(name);\n        if (variable != null) {\n            return variable\n        }\n        scope = scope.upper;\n    }\n\n    return null\n}\n\n/**\n * Negate the result of `this` calling.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the result of `this(token)` is `false`.\n */\nfunction negate0(token) {\n    return !this(token) //eslint-disable-line no-invalid-this\n}\n\n/**\n * Creates the negate function of the given function.\n * @param {function(Token):boolean} f - The function to negate.\n * @returns {function(Token):boolean} Negated function.\n */\nfunction negate(f) {\n    return negate0.bind(f)\n}\n\n/**\n * Checks if the given token is an arrow token or not.\n * @param {Token} token - The token to check.\n * @returns {boolean} `true` if the token is an arrow token.\n */\nfunction isArrowToken(token) {\n    return token.value === \"=>\" && token.type === \"Punctuator\"\n}\n\n/**\n * Checks if the given token is a comma token or not.\n * @param {Token} token - The token to check.\n * @returns {boolean} `true` if the token is a comma token.\n */\nfunction isCommaToken(token) {\n    return token.value === \",\" && token.type === \"Punctuator\"\n}\n\n/**\n * Checks if the given token is a semicolon token or not.\n * @param {Token} token - The token to check.\n * @returns {boolean} `true` if the token is a semicolon token.\n */\nfunction isSemicolonToken(token) {\n    return token.value === \";\" && token.type === \"Punctuator\"\n}\n\n/**\n * Checks if the given token is a colon token or not.\n * @param {Token} token - The token to check.\n * @returns {boolean} `true` if the token is a colon token.\n */\nfunction isColonToken(token) {\n    return token.value === \":\" && token.type === \"Punctuator\"\n}\n\n/**\n * Checks if the given token is an opening parenthesis token or not.\n * @param {Token} token - The token to check.\n * @returns {boolean} `true` if the token is an opening parenthesis token.\n */\nfunction isOpeningParenToken(token) {\n    return token.value === \"(\" && token.type === \"Punctuator\"\n}\n\n/**\n * Checks if the given token is a closing parenthesis token or not.\n * @param {Token} token - The token to check.\n * @returns {boolean} `true` if the token is a closing parenthesis token.\n */\nfunction isClosingParenToken(token) {\n    return token.value === \")\" && token.type === \"Punctuator\"\n}\n\n/**\n * Checks if the given token is an opening square bracket token or not.\n * @param {Token} token - The token to check.\n * @returns {boolean} `true` if the token is an opening square bracket token.\n */\nfunction isOpeningBracketToken(token) {\n    return token.value === \"[\" && token.type === \"Punctuator\"\n}\n\n/**\n * Checks if the given token is a closing square bracket token or not.\n * @param {Token} token - The token to check.\n * @returns {boolean} `true` if the token is a closing square bracket token.\n */\nfunction isClosingBracketToken(token) {\n    return token.value === \"]\" && token.type === \"Punctuator\"\n}\n\n/**\n * Checks if the given token is an opening brace token or not.\n * @param {Token} token - The token to check.\n * @returns {boolean} `true` if the token is an opening brace token.\n */\nfunction isOpeningBraceToken(token) {\n    return token.value === \"{\" && token.type === \"Punctuator\"\n}\n\n/**\n * Checks if the given token is a closing brace token or not.\n * @param {Token} token - The token to check.\n * @returns {boolean} `true` if the token is a closing brace token.\n */\nfunction isClosingBraceToken(token) {\n    return token.value === \"}\" && token.type === \"Punctuator\"\n}\n\n/**\n * Checks if the given token is a comment token or not.\n * @param {Token} token - The token to check.\n * @returns {boolean} `true` if the token is a comment token.\n */\nfunction isCommentToken$1(token) {\n    return (\n        token.type === \"Line\" ||\n        token.type === \"Block\" ||\n        token.type === \"Shebang\"\n    )\n}\n\nconst isNotArrowToken = negate(isArrowToken);\nconst isNotCommaToken = negate(isCommaToken);\nconst isNotSemicolonToken = negate(isSemicolonToken);\nconst isNotColonToken = negate(isColonToken);\nconst isNotOpeningParenToken$1 = negate(isOpeningParenToken);\nconst isNotClosingParenToken = negate(isClosingParenToken);\nconst isNotOpeningBracketToken = negate(isOpeningBracketToken);\nconst isNotClosingBracketToken = negate(isClosingBracketToken);\nconst isNotOpeningBraceToken = negate(isOpeningBraceToken);\nconst isNotClosingBraceToken = negate(isClosingBraceToken);\nconst isNotCommentToken = negate(isCommentToken$1);\n\n/**\n * Get the `(` token of the given function node.\n * @param {Node} node - The function node to get.\n * @param {SourceCode} sourceCode - The source code object to get tokens.\n * @returns {Token} `(` token.\n */\nfunction getOpeningParenOfParams(node, sourceCode) {\n    return node.id\n        ? sourceCode.getTokenAfter(node.id, isOpeningParenToken)\n        : sourceCode.getFirstToken(node, isOpeningParenToken)\n}\n\n/**\n * Get the location of the given function node for reporting.\n * @param {Node} node - The function node to get.\n * @param {SourceCode} sourceCode - The source code object to get tokens.\n * @returns {string} The location of the function node for reporting.\n */\nfunction getFunctionHeadLocation(node, sourceCode) {\n    const parent = node.parent;\n    let start = null;\n    let end = null;\n\n    if (node.type === \"ArrowFunctionExpression\") {\n        const arrowToken = sourceCode.getTokenBefore(node.body, isArrowToken);\n\n        start = arrowToken.loc.start;\n        end = arrowToken.loc.end;\n    } else if (\n        parent.type === \"Property\" ||\n        parent.type === \"MethodDefinition\"\n    ) {\n        start = parent.loc.start;\n        end = getOpeningParenOfParams(node, sourceCode).loc.start;\n    } else {\n        start = node.loc.start;\n        end = getOpeningParenOfParams(node, sourceCode).loc.start;\n    }\n\n    return {\n        start: Object.assign({}, start),\n        end: Object.assign({}, end),\n    }\n}\n\n/* globals BigInt, globalThis, global, self, window */\n\nconst globalObject =\n    typeof globalThis !== \"undefined\"\n        ? globalThis\n        : typeof self !== \"undefined\"\n        ? self\n        : typeof window !== \"undefined\"\n        ? window\n        : typeof global !== \"undefined\"\n        ? global\n        : {};\n\nconst builtinNames = Object.freeze(\n    new Set([\n        \"Array\",\n        \"ArrayBuffer\",\n        \"BigInt\",\n        \"BigInt64Array\",\n        \"BigUint64Array\",\n        \"Boolean\",\n        \"DataView\",\n        \"Date\",\n        \"decodeURI\",\n        \"decodeURIComponent\",\n        \"encodeURI\",\n        \"encodeURIComponent\",\n        \"escape\",\n        \"Float32Array\",\n        \"Float64Array\",\n        \"Function\",\n        \"Infinity\",\n        \"Int16Array\",\n        \"Int32Array\",\n        \"Int8Array\",\n        \"isFinite\",\n        \"isNaN\",\n        \"isPrototypeOf\",\n        \"JSON\",\n        \"Map\",\n        \"Math\",\n        \"NaN\",\n        \"Number\",\n        \"Object\",\n        \"parseFloat\",\n        \"parseInt\",\n        \"Promise\",\n        \"Proxy\",\n        \"Reflect\",\n        \"RegExp\",\n        \"Set\",\n        \"String\",\n        \"Symbol\",\n        \"Uint16Array\",\n        \"Uint32Array\",\n        \"Uint8Array\",\n        \"Uint8ClampedArray\",\n        \"undefined\",\n        \"unescape\",\n        \"WeakMap\",\n        \"WeakSet\",\n    ])\n);\nconst callAllowed = new Set(\n    [\n        Array.isArray,\n        typeof BigInt === \"function\" ? BigInt : undefined,\n        Boolean,\n        Date,\n        Date.parse,\n        decodeURI,\n        decodeURIComponent,\n        encodeURI,\n        encodeURIComponent,\n        escape,\n        isFinite,\n        isNaN,\n        isPrototypeOf,\n        ...Object.getOwnPropertyNames(Math)\n            .map(k => Math[k])\n            .filter(f => typeof f === \"function\"),\n        Number,\n        Number.isFinite,\n        Number.isNaN,\n        Number.parseFloat,\n        Number.parseInt,\n        Object,\n        Object.entries,\n        Object.is,\n        Object.isExtensible,\n        Object.isFrozen,\n        Object.isSealed,\n        Object.keys,\n        Object.values,\n        parseFloat,\n        parseInt,\n        RegExp,\n        String,\n        String.fromCharCode,\n        String.fromCodePoint,\n        String.raw,\n        Symbol,\n        Symbol.for,\n        Symbol.keyFor,\n        unescape,\n    ].filter(f => typeof f === \"function\")\n);\nconst callPassThrough = new Set([\n    Object.freeze,\n    Object.preventExtensions,\n    Object.seal,\n]);\n\n/**\n * Get the property descriptor.\n * @param {object} object The object to get.\n * @param {string|number|symbol} name The property name to get.\n */\nfunction getPropertyDescriptor(object, name) {\n    let x = object;\n    while ((typeof x === \"object\" || typeof x === \"function\") && x !== null) {\n        const d = Object.getOwnPropertyDescriptor(x, name);\n        if (d) {\n            return d\n        }\n        x = Object.getPrototypeOf(x);\n    }\n    return null\n}\n\n/**\n * Check if a property is getter or not.\n * @param {object} object The object to check.\n * @param {string|number|symbol} name The property name to check.\n */\nfunction isGetter(object, name) {\n    const d = getPropertyDescriptor(object, name);\n    return d != null && d.get != null\n}\n\n/**\n * Get the element values of a given node list.\n * @param {Node[]} nodeList The node list to get values.\n * @param {Scope|undefined} initialScope The initial scope to find variables.\n * @returns {any[]|null} The value list if all nodes are constant. Otherwise, null.\n */\nfunction getElementValues(nodeList, initialScope) {\n    const valueList = [];\n\n    for (let i = 0; i < nodeList.length; ++i) {\n        const elementNode = nodeList[i];\n\n        if (elementNode == null) {\n            valueList.length = i + 1;\n        } else if (elementNode.type === \"SpreadElement\") {\n            const argument = getStaticValueR(elementNode.argument, initialScope);\n            if (argument == null) {\n                return null\n            }\n            valueList.push(...argument.value);\n        } else {\n            const element = getStaticValueR(elementNode, initialScope);\n            if (element == null) {\n                return null\n            }\n            valueList.push(element.value);\n        }\n    }\n\n    return valueList\n}\n\nconst operations = Object.freeze({\n    ArrayExpression(node, initialScope) {\n        const elements = getElementValues(node.elements, initialScope);\n        return elements != null ? { value: elements } : null\n    },\n\n    AssignmentExpression(node, initialScope) {\n        if (node.operator === \"=\") {\n            return getStaticValueR(node.right, initialScope)\n        }\n        return null\n    },\n\n    //eslint-disable-next-line complexity\n    BinaryExpression(node, initialScope) {\n        if (node.operator === \"in\" || node.operator === \"instanceof\") {\n            // Not supported.\n            return null\n        }\n\n        const left = getStaticValueR(node.left, initialScope);\n        const right = getStaticValueR(node.right, initialScope);\n        if (left != null && right != null) {\n            switch (node.operator) {\n                case \"==\":\n                    return { value: left.value == right.value } //eslint-disable-line eqeqeq\n                case \"!=\":\n                    return { value: left.value != right.value } //eslint-disable-line eqeqeq\n                case \"===\":\n                    return { value: left.value === right.value }\n                case \"!==\":\n                    return { value: left.value !== right.value }\n                case \"<\":\n                    return { value: left.value < right.value }\n                case \"<=\":\n                    return { value: left.value <= right.value }\n                case \">\":\n                    return { value: left.value > right.value }\n                case \">=\":\n                    return { value: left.value >= right.value }\n                case \"<<\":\n                    return { value: left.value << right.value }\n                case \">>\":\n                    return { value: left.value >> right.value }\n                case \">>>\":\n                    return { value: left.value >>> right.value }\n                case \"+\":\n                    return { value: left.value + right.value }\n                case \"-\":\n                    return { value: left.value - right.value }\n                case \"*\":\n                    return { value: left.value * right.value }\n                case \"/\":\n                    return { value: left.value / right.value }\n                case \"%\":\n                    return { value: left.value % right.value }\n                case \"**\":\n                    return { value: Math.pow(left.value, right.value) }\n                case \"|\":\n                    return { value: left.value | right.value }\n                case \"^\":\n                    return { value: left.value ^ right.value }\n                case \"&\":\n                    return { value: left.value & right.value }\n\n                // no default\n            }\n        }\n\n        return null\n    },\n\n    CallExpression(node, initialScope) {\n        const calleeNode = node.callee;\n        const args = getElementValues(node.arguments, initialScope);\n\n        if (args != null) {\n            if (calleeNode.type === \"MemberExpression\") {\n                const object = getStaticValueR(calleeNode.object, initialScope);\n                const property = calleeNode.computed\n                    ? getStaticValueR(calleeNode.property, initialScope)\n                    : { value: calleeNode.property.name };\n\n                if (object != null && property != null) {\n                    const receiver = object.value;\n                    const methodName = property.value;\n                    if (callAllowed.has(receiver[methodName])) {\n                        return { value: receiver[methodName](...args) }\n                    }\n                    if (callPassThrough.has(receiver[methodName])) {\n                        return { value: args[0] }\n                    }\n                }\n            } else {\n                const callee = getStaticValueR(calleeNode, initialScope);\n                if (callee != null) {\n                    const func = callee.value;\n                    if (callAllowed.has(func)) {\n                        return { value: func(...args) }\n                    }\n                    if (callPassThrough.has(func)) {\n                        return { value: args[0] }\n                    }\n                }\n            }\n        }\n\n        return null\n    },\n\n    ConditionalExpression(node, initialScope) {\n        const test = getStaticValueR(node.test, initialScope);\n        if (test != null) {\n            return test.value\n                ? getStaticValueR(node.consequent, initialScope)\n                : getStaticValueR(node.alternate, initialScope)\n        }\n        return null\n    },\n\n    ExpressionStatement(node, initialScope) {\n        return getStaticValueR(node.expression, initialScope)\n    },\n\n    Identifier(node, initialScope) {\n        if (initialScope != null) {\n            const variable = findVariable(initialScope, node);\n\n            // Built-in globals.\n            if (\n                variable != null &&\n                variable.defs.length === 0 &&\n                builtinNames.has(variable.name) &&\n                variable.name in globalObject\n            ) {\n                return { value: globalObject[variable.name] }\n            }\n\n            // Constants.\n            if (variable != null && variable.defs.length === 1) {\n                const def = variable.defs[0];\n                if (\n                    def.parent &&\n                    def.parent.kind === \"const\" &&\n                    // TODO(mysticatea): don't support destructuring here.\n                    def.node.id.type === \"Identifier\"\n                ) {\n                    return getStaticValueR(def.node.init, initialScope)\n                }\n            }\n        }\n        return null\n    },\n\n    Literal(node) {\n        //istanbul ignore if : this is implementation-specific behavior.\n        if ((node.regex != null || node.bigint != null) && node.value == null) {\n            // It was a RegExp/BigInt literal, but Node.js didn't support it.\n            return null\n        }\n        return { value: node.value }\n    },\n\n    LogicalExpression(node, initialScope) {\n        const left = getStaticValueR(node.left, initialScope);\n        if (left != null) {\n            if (\n                (node.operator === \"||\" && Boolean(left.value) === true) ||\n                (node.operator === \"&&\" && Boolean(left.value) === false)\n            ) {\n                return left\n            }\n\n            const right = getStaticValueR(node.right, initialScope);\n            if (right != null) {\n                return right\n            }\n        }\n\n        return null\n    },\n\n    MemberExpression(node, initialScope) {\n        const object = getStaticValueR(node.object, initialScope);\n        const property = node.computed\n            ? getStaticValueR(node.property, initialScope)\n            : { value: node.property.name };\n\n        if (\n            object != null &&\n            property != null &&\n            !isGetter(object.value, property.value)\n        ) {\n            return { value: object.value[property.value] }\n        }\n        return null\n    },\n\n    NewExpression(node, initialScope) {\n        const callee = getStaticValueR(node.callee, initialScope);\n        const args = getElementValues(node.arguments, initialScope);\n\n        if (callee != null && args != null) {\n            const Func = callee.value;\n            if (callAllowed.has(Func)) {\n                return { value: new Func(...args) }\n            }\n        }\n\n        return null\n    },\n\n    ObjectExpression(node, initialScope) {\n        const object = {};\n\n        for (const propertyNode of node.properties) {\n            if (propertyNode.type === \"Property\") {\n                if (propertyNode.kind !== \"init\") {\n                    return null\n                }\n                const key = propertyNode.computed\n                    ? getStaticValueR(propertyNode.key, initialScope)\n                    : { value: propertyNode.key.name };\n                const value = getStaticValueR(propertyNode.value, initialScope);\n                if (key == null || value == null) {\n                    return null\n                }\n                object[key.value] = value.value;\n            } else if (\n                propertyNode.type === \"SpreadElement\" ||\n                propertyNode.type === \"ExperimentalSpreadProperty\"\n            ) {\n                const argument = getStaticValueR(\n                    propertyNode.argument,\n                    initialScope\n                );\n                if (argument == null) {\n                    return null\n                }\n                Object.assign(object, argument.value);\n            } else {\n                return null\n            }\n        }\n\n        return { value: object }\n    },\n\n    SequenceExpression(node, initialScope) {\n        const last = node.expressions[node.expressions.length - 1];\n        return getStaticValueR(last, initialScope)\n    },\n\n    TaggedTemplateExpression(node, initialScope) {\n        const tag = getStaticValueR(node.tag, initialScope);\n        const expressions = getElementValues(\n            node.quasi.expressions,\n            initialScope\n        );\n\n        if (tag != null && expressions != null) {\n            const func = tag.value;\n            const strings = node.quasi.quasis.map(q => q.value.cooked);\n            strings.raw = node.quasi.quasis.map(q => q.value.raw);\n\n            if (func === String.raw) {\n                return { value: func(strings, ...expressions) }\n            }\n        }\n\n        return null\n    },\n\n    TemplateLiteral(node, initialScope) {\n        const expressions = getElementValues(node.expressions, initialScope);\n        if (expressions != null) {\n            let value = node.quasis[0].value.cooked;\n            for (let i = 0; i < expressions.length; ++i) {\n                value += expressions[i];\n                value += node.quasis[i + 1].value.cooked;\n            }\n            return { value }\n        }\n        return null\n    },\n\n    UnaryExpression(node, initialScope) {\n        if (node.operator === \"delete\") {\n            // Not supported.\n            return null\n        }\n        if (node.operator === \"void\") {\n            return { value: undefined }\n        }\n\n        const arg = getStaticValueR(node.argument, initialScope);\n        if (arg != null) {\n            switch (node.operator) {\n                case \"-\":\n                    return { value: -arg.value }\n                case \"+\":\n                    return { value: +arg.value } //eslint-disable-line no-implicit-coercion\n                case \"!\":\n                    return { value: !arg.value }\n                case \"~\":\n                    return { value: ~arg.value }\n                case \"typeof\":\n                    return { value: typeof arg.value }\n\n                // no default\n            }\n        }\n\n        return null\n    },\n});\n\n/**\n * Get the value of a given node if it's a static value.\n * @param {Node} node The node to get.\n * @param {Scope|undefined} initialScope The scope to start finding variable.\n * @returns {{value:any}|null} The static value of the node, or `null`.\n */\nfunction getStaticValueR(node, initialScope) {\n    if (node != null && Object.hasOwnProperty.call(operations, node.type)) {\n        return operations[node.type](node, initialScope)\n    }\n    return null\n}\n\n/**\n * Get the value of a given node if it's a static value.\n * @param {Node} node The node to get.\n * @param {Scope} [initialScope] The scope to start finding variable. Optional. If this scope was given, this tries to resolve identifier references which are in the given node as much as possible.\n * @returns {{value:any}|null} The static value of the node, or `null`.\n */\nfunction getStaticValue(node, initialScope = null) {\n    try {\n        return getStaticValueR(node, initialScope)\n    } catch (_error) {\n        return null\n    }\n}\n\n/**\n * Get the value of a given node if it's a literal or a template literal.\n * @param {Node} node The node to get.\n * @param {Scope} [initialScope] The scope to start finding variable. Optional. If the node is an Identifier node and this scope was given, this checks the variable of the identifier, and returns the value of it if the variable is a constant.\n * @returns {string|null} The value of the node, or `null`.\n */\nfunction getStringIfConstant(node, initialScope = null) {\n    // Handle the literals that the platform doesn't support natively.\n    if (node && node.type === \"Literal\" && node.value === null) {\n        if (node.regex) {\n            return `/${node.regex.pattern}/${node.regex.flags}`\n        }\n        if (node.bigint) {\n            return node.bigint\n        }\n    }\n\n    const evaluated = getStaticValue(node, initialScope);\n    return evaluated && String(evaluated.value)\n}\n\n/**\n * Get the property name from a MemberExpression node or a Property node.\n * @param {Node} node The node to get.\n * @param {Scope} [initialScope] The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it.\n * @returns {string|null} The property name of the node.\n */\nfunction getPropertyName$1(node, initialScope) {\n    switch (node.type) {\n        case \"MemberExpression\":\n            if (node.computed) {\n                return getStringIfConstant(node.property, initialScope)\n            }\n            return node.property.name\n\n        case \"Property\":\n        case \"MethodDefinition\":\n            if (node.computed) {\n                return getStringIfConstant(node.key, initialScope)\n            }\n            if (node.key.type === \"Literal\") {\n                return String(node.key.value)\n            }\n            return node.key.name\n\n        // no default\n    }\n\n    return null\n}\n\n/**\n * Get the name and kind of the given function node.\n * @param {ASTNode} node - The function node to get.\n * @returns {string} The name and kind of the function node.\n */\nfunction getFunctionNameWithKind(node) {\n    const parent = node.parent;\n    const tokens = [];\n\n    if (parent.type === \"MethodDefinition\" && parent.static) {\n        tokens.push(\"static\");\n    }\n    if (node.async) {\n        tokens.push(\"async\");\n    }\n    if (node.generator) {\n        tokens.push(\"generator\");\n    }\n\n    if (node.type === \"ArrowFunctionExpression\") {\n        tokens.push(\"arrow\", \"function\");\n    } else if (\n        parent.type === \"Property\" ||\n        parent.type === \"MethodDefinition\"\n    ) {\n        if (parent.kind === \"constructor\") {\n            return \"constructor\"\n        }\n        if (parent.kind === \"get\") {\n            tokens.push(\"getter\");\n        } else if (parent.kind === \"set\") {\n            tokens.push(\"setter\");\n        } else {\n            tokens.push(\"method\");\n        }\n    } else {\n        tokens.push(\"function\");\n    }\n\n    if (node.id) {\n        tokens.push(`'${node.id.name}'`);\n    } else {\n        const name = getPropertyName$1(parent);\n\n        if (name) {\n            tokens.push(`'${name}'`);\n        }\n    }\n\n    return tokens.join(\" \")\n}\n\nconst typeConversionBinaryOps = Object.freeze(\n    new Set([\n        \"==\",\n        \"!=\",\n        \"<\",\n        \"<=\",\n        \">\",\n        \">=\",\n        \"<<\",\n        \">>\",\n        \">>>\",\n        \"+\",\n        \"-\",\n        \"*\",\n        \"/\",\n        \"%\",\n        \"|\",\n        \"^\",\n        \"&\",\n        \"in\",\n    ])\n);\nconst typeConversionUnaryOps = Object.freeze(new Set([\"-\", \"+\", \"!\", \"~\"]));\nconst visitor = Object.freeze(\n    Object.assign(Object.create(null), {\n        $visit(node, options, visitorKeys) {\n            const { type } = node;\n\n            if (typeof this[type] === \"function\") {\n                return this[type](node, options, visitorKeys)\n            }\n\n            return this.$visitChildren(node, options, visitorKeys)\n        },\n\n        $visitChildren(node, options, visitorKeys) {\n            const { type } = node;\n\n            for (const key of visitorKeys[type] || lib$1.getKeys(node)) {\n                const value = node[key];\n\n                if (Array.isArray(value)) {\n                    for (const element of value) {\n                        if (\n                            element &&\n                            this.$visit(element, options, visitorKeys)\n                        ) {\n                            return true\n                        }\n                    }\n                } else if (value && this.$visit(value, options, visitorKeys)) {\n                    return true\n                }\n            }\n\n            return false\n        },\n\n        ArrowFunctionExpression() {\n            return false\n        },\n        AssignmentExpression() {\n            return true\n        },\n        AwaitExpression() {\n            return true\n        },\n        BinaryExpression(node, options, visitorKeys) {\n            if (\n                options.considerImplicitTypeConversion &&\n                typeConversionBinaryOps.has(node.operator) &&\n                (node.left.type !== \"Literal\" || node.right.type !== \"Literal\")\n            ) {\n                return true\n            }\n            return this.$visitChildren(node, options, visitorKeys)\n        },\n        CallExpression() {\n            return true\n        },\n        FunctionExpression() {\n            return false\n        },\n        ImportExpression() {\n            return true\n        },\n        MemberExpression(node, options, visitorKeys) {\n            if (options.considerGetters) {\n                return true\n            }\n            if (\n                options.considerImplicitTypeConversion &&\n                node.computed &&\n                node.property.type !== \"Literal\"\n            ) {\n                return true\n            }\n            return this.$visitChildren(node, options, visitorKeys)\n        },\n        MethodDefinition(node, options, visitorKeys) {\n            if (\n                options.considerImplicitTypeConversion &&\n                node.computed &&\n                node.key.type !== \"Literal\"\n            ) {\n                return true\n            }\n            return this.$visitChildren(node, options, visitorKeys)\n        },\n        NewExpression() {\n            return true\n        },\n        Property(node, options, visitorKeys) {\n            if (\n                options.considerImplicitTypeConversion &&\n                node.computed &&\n                node.key.type !== \"Literal\"\n            ) {\n                return true\n            }\n            return this.$visitChildren(node, options, visitorKeys)\n        },\n        UnaryExpression(node, options, visitorKeys) {\n            if (node.operator === \"delete\") {\n                return true\n            }\n            if (\n                options.considerImplicitTypeConversion &&\n                typeConversionUnaryOps.has(node.operator) &&\n                node.argument.type !== \"Literal\"\n            ) {\n                return true\n            }\n            return this.$visitChildren(node, options, visitorKeys)\n        },\n        UpdateExpression() {\n            return true\n        },\n        YieldExpression() {\n            return true\n        },\n    })\n);\n\n/**\n * Check whether a given node has any side effect or not.\n * @param {Node} node The node to get.\n * @param {SourceCode} sourceCode The source code object.\n * @param {object} [options] The option object.\n * @param {boolean} [options.considerGetters=false] If `true` then it considers member accesses as the node which has side effects.\n * @param {boolean} [options.considerImplicitTypeConversion=false] If `true` then it considers implicit type conversion as the node which has side effects.\n * @param {object} [options.visitorKeys=evk.KEYS] The keys to traverse nodes. Use `context.getSourceCode().visitorKeys`.\n * @returns {boolean} `true` if the node has a certain side effect.\n */\nfunction hasSideEffect(\n    node,\n    sourceCode,\n    { considerGetters = false, considerImplicitTypeConversion = false } = {}\n) {\n    return visitor.$visit(\n        node,\n        { considerGetters, considerImplicitTypeConversion },\n        sourceCode.visitorKeys || lib$1.KEYS\n    )\n}\n\n/**\n * Get the left parenthesis of the parent node syntax if it exists.\n * E.g., `if (a) {}` then the `(`.\n * @param {Node} node The AST node to check.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {Token|null} The left parenthesis of the parent node syntax\n */\nfunction getParentSyntaxParen(node, sourceCode) {\n    const parent = node.parent;\n\n    switch (parent.type) {\n        case \"CallExpression\":\n        case \"NewExpression\":\n            if (parent.arguments.length === 1 && parent.arguments[0] === node) {\n                return sourceCode.getTokenAfter(\n                    parent.callee,\n                    isOpeningParenToken\n                )\n            }\n            return null\n\n        case \"DoWhileStatement\":\n            if (parent.test === node) {\n                return sourceCode.getTokenAfter(\n                    parent.body,\n                    isOpeningParenToken\n                )\n            }\n            return null\n\n        case \"IfStatement\":\n        case \"WhileStatement\":\n            if (parent.test === node) {\n                return sourceCode.getFirstToken(parent, 1)\n            }\n            return null\n\n        case \"ImportExpression\":\n            if (parent.source === node) {\n                return sourceCode.getFirstToken(parent, 1)\n            }\n            return null\n\n        case \"SwitchStatement\":\n            if (parent.discriminant === node) {\n                return sourceCode.getFirstToken(parent, 1)\n            }\n            return null\n\n        case \"WithStatement\":\n            if (parent.object === node) {\n                return sourceCode.getFirstToken(parent, 1)\n            }\n            return null\n\n        default:\n            return null\n    }\n}\n\n/**\n * Check whether a given node is parenthesized or not.\n * @param {number} times The number of parantheses.\n * @param {Node} node The AST node to check.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {boolean} `true` if the node is parenthesized the given times.\n */\n/**\n * Check whether a given node is parenthesized or not.\n * @param {Node} node The AST node to check.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {boolean} `true` if the node is parenthesized.\n */\nfunction isParenthesized(\n    timesOrNode,\n    nodeOrSourceCode,\n    optionalSourceCode\n) {\n    let times, node, sourceCode, maybeLeftParen, maybeRightParen;\n    if (typeof timesOrNode === \"number\") {\n        times = timesOrNode | 0;\n        node = nodeOrSourceCode;\n        sourceCode = optionalSourceCode;\n        if (!(times >= 1)) {\n            throw new TypeError(\"'times' should be a positive integer.\")\n        }\n    } else {\n        times = 1;\n        node = timesOrNode;\n        sourceCode = nodeOrSourceCode;\n    }\n\n    if (node == null) {\n        return false\n    }\n\n    maybeLeftParen = maybeRightParen = node;\n    do {\n        maybeLeftParen = sourceCode.getTokenBefore(maybeLeftParen);\n        maybeRightParen = sourceCode.getTokenAfter(maybeRightParen);\n    } while (\n        maybeLeftParen != null &&\n        maybeRightParen != null &&\n        isOpeningParenToken(maybeLeftParen) &&\n        isClosingParenToken(maybeRightParen) &&\n        // Avoid false positive such as `if (a) {}`\n        maybeLeftParen !== getParentSyntaxParen(node, sourceCode) &&\n        --times > 0\n    )\n\n    return times === 0\n}\n\n/**\n * @author Toru Nagashima <https://github.com/mysticatea>\n * See LICENSE file in root directory for full license.\n */\n\nconst placeholder = /\\$(?:[$&`']|[1-9][0-9]?)/gu;\n\n/** @type {WeakMap<PatternMatcher, {pattern:RegExp,escaped:boolean}>} */\nconst internal = new WeakMap();\n\n/**\n * Check whether a given character is escaped or not.\n * @param {string} str The string to check.\n * @param {number} index The location of the character to check.\n * @returns {boolean} `true` if the character is escaped.\n */\nfunction isEscaped(str, index) {\n    let escaped = false;\n    for (let i = index - 1; i >= 0 && str.charCodeAt(i) === 0x5c; --i) {\n        escaped = !escaped;\n    }\n    return escaped\n}\n\n/**\n * Replace a given string by a given matcher.\n * @param {PatternMatcher} matcher The pattern matcher.\n * @param {string} str The string to be replaced.\n * @param {string} replacement The new substring to replace each matched part.\n * @returns {string} The replaced string.\n */\nfunction replaceS(matcher, str, replacement) {\n    const chunks = [];\n    let index = 0;\n\n    /** @type {RegExpExecArray} */\n    let match = null;\n\n    /**\n     * @param {string} key The placeholder.\n     * @returns {string} The replaced string.\n     */\n    function replacer(key) {\n        switch (key) {\n            case \"$$\":\n                return \"$\"\n            case \"$&\":\n                return match[0]\n            case \"$`\":\n                return str.slice(0, match.index)\n            case \"$'\":\n                return str.slice(match.index + match[0].length)\n            default: {\n                const i = key.slice(1);\n                if (i in match) {\n                    return match[i]\n                }\n                return key\n            }\n        }\n    }\n\n    for (match of matcher.execAll(str)) {\n        chunks.push(str.slice(index, match.index));\n        chunks.push(replacement.replace(placeholder, replacer));\n        index = match.index + match[0].length;\n    }\n    chunks.push(str.slice(index));\n\n    return chunks.join(\"\")\n}\n\n/**\n * Replace a given string by a given matcher.\n * @param {PatternMatcher} matcher The pattern matcher.\n * @param {string} str The string to be replaced.\n * @param {(...strs[])=>string} replace The function to replace each matched part.\n * @returns {string} The replaced string.\n */\nfunction replaceF(matcher, str, replace) {\n    const chunks = [];\n    let index = 0;\n\n    for (const match of matcher.execAll(str)) {\n        chunks.push(str.slice(index, match.index));\n        chunks.push(String(replace(...match, match.index, match.input)));\n        index = match.index + match[0].length;\n    }\n    chunks.push(str.slice(index));\n\n    return chunks.join(\"\")\n}\n\n/**\n * The class to find patterns as considering escape sequences.\n */\nclass PatternMatcher {\n    /**\n     * Initialize this matcher.\n     * @param {RegExp} pattern The pattern to match.\n     * @param {{escaped:boolean}} options The options.\n     */\n    constructor(pattern, { escaped = false } = {}) {\n        if (!(pattern instanceof RegExp)) {\n            throw new TypeError(\"'pattern' should be a RegExp instance.\")\n        }\n        if (!pattern.flags.includes(\"g\")) {\n            throw new Error(\"'pattern' should contains 'g' flag.\")\n        }\n\n        internal.set(this, {\n            pattern: new RegExp(pattern.source, pattern.flags),\n            escaped: Boolean(escaped),\n        });\n    }\n\n    /**\n     * Find the pattern in a given string.\n     * @param {string} str The string to find.\n     * @returns {IterableIterator<RegExpExecArray>} The iterator which iterate the matched information.\n     */\n    *execAll(str) {\n        const { pattern, escaped } = internal.get(this);\n        let match = null;\n        let lastIndex = 0;\n\n        pattern.lastIndex = 0;\n        while ((match = pattern.exec(str)) != null) {\n            if (escaped || !isEscaped(str, match.index)) {\n                lastIndex = pattern.lastIndex;\n                yield match;\n                pattern.lastIndex = lastIndex;\n            }\n        }\n    }\n\n    /**\n     * Check whether the pattern is found in a given string.\n     * @param {string} str The string to check.\n     * @returns {boolean} `true` if the pattern was found in the string.\n     */\n    test(str) {\n        const it = this.execAll(str);\n        const ret = it.next();\n        return !ret.done\n    }\n\n    /**\n     * Replace a given string.\n     * @param {string} str The string to be replaced.\n     * @param {(string|((...strs:string[])=>string))} replacer The string or function to replace. This is the same as the 2nd argument of `String.prototype.replace`.\n     * @returns {string} The replaced string.\n     */\n    [Symbol.replace](str, replacer) {\n        return typeof replacer === \"function\"\n            ? replaceF(this, String(str), replacer)\n            : replaceS(this, String(str), String(replacer))\n    }\n}\n\nconst IMPORT_TYPE = /^(?:Import|Export(?:All|Default|Named))Declaration$/u;\nconst has$1 = Function.call.bind(Object.hasOwnProperty);\n\nconst READ$1 = Symbol(\"read\");\nconst CALL = Symbol(\"call\");\nconst CONSTRUCT = Symbol(\"construct\");\nconst ESM = Symbol(\"esm\");\n\nconst requireCall = { require: { [CALL]: true } };\n\n/**\n * Check whether a given variable is modified or not.\n * @param {Variable} variable The variable to check.\n * @returns {boolean} `true` if the variable is modified.\n */\nfunction isModifiedGlobal(variable) {\n    return (\n        variable == null ||\n        variable.defs.length !== 0 ||\n        variable.references.some(r => r.isWrite())\n    )\n}\n\n/**\n * Check if the value of a given node is passed through to the parent syntax as-is.\n * For example, `a` and `b` in (`a || b` and `c ? a : b`) are passed through.\n * @param {Node} node A node to check.\n * @returns {boolean} `true` if the node is passed through.\n */\nfunction isPassThrough(node) {\n    const parent = node.parent;\n\n    switch (parent && parent.type) {\n        case \"ConditionalExpression\":\n            return parent.consequent === node || parent.alternate === node\n        case \"LogicalExpression\":\n            return true\n        case \"SequenceExpression\":\n            return parent.expressions[parent.expressions.length - 1] === node\n\n        default:\n            return false\n    }\n}\n\n/**\n * The reference tracker.\n */\nclass ReferenceTracker {\n    /**\n     * Initialize this tracker.\n     * @param {Scope} globalScope The global scope.\n     * @param {object} [options] The options.\n     * @param {\"legacy\"|\"strict\"} [options.mode=\"strict\"] The mode to determine the ImportDeclaration's behavior for CJS modules.\n     * @param {string[]} [options.globalObjectNames=[\"global\",\"self\",\"window\"]] The variable names for Global Object.\n     */\n    constructor(\n        globalScope,\n        {\n            mode = \"strict\",\n            globalObjectNames = [\"global\", \"self\", \"window\"],\n        } = {}\n    ) {\n        this.variableStack = [];\n        this.globalScope = globalScope;\n        this.mode = mode;\n        this.globalObjectNames = globalObjectNames.slice(0);\n    }\n\n    /**\n     * Iterate the references of global variables.\n     * @param {object} traceMap The trace map.\n     * @returns {IterableIterator<{node:Node,path:string[],type:symbol,info:any}>} The iterator to iterate references.\n     */\n    *iterateGlobalReferences(traceMap) {\n        for (const key of Object.keys(traceMap)) {\n            const nextTraceMap = traceMap[key];\n            const path = [key];\n            const variable = this.globalScope.set.get(key);\n\n            if (isModifiedGlobal(variable)) {\n                continue\n            }\n\n            yield* this._iterateVariableReferences(\n                variable,\n                path,\n                nextTraceMap,\n                true\n            );\n        }\n\n        for (const key of this.globalObjectNames) {\n            const path = [];\n            const variable = this.globalScope.set.get(key);\n\n            if (isModifiedGlobal(variable)) {\n                continue\n            }\n\n            yield* this._iterateVariableReferences(\n                variable,\n                path,\n                traceMap,\n                false\n            );\n        }\n    }\n\n    /**\n     * Iterate the references of CommonJS modules.\n     * @param {object} traceMap The trace map.\n     * @returns {IterableIterator<{node:Node,path:string[],type:symbol,info:any}>} The iterator to iterate references.\n     */\n    *iterateCjsReferences(traceMap) {\n        for (const { node } of this.iterateGlobalReferences(requireCall)) {\n            const key = getStringIfConstant(node.arguments[0]);\n            if (key == null || !has$1(traceMap, key)) {\n                continue\n            }\n\n            const nextTraceMap = traceMap[key];\n            const path = [key];\n\n            if (nextTraceMap[READ$1]) {\n                yield {\n                    node,\n                    path,\n                    type: READ$1,\n                    info: nextTraceMap[READ$1],\n                };\n            }\n            yield* this._iteratePropertyReferences(node, path, nextTraceMap);\n        }\n    }\n\n    /**\n     * Iterate the references of ES modules.\n     * @param {object} traceMap The trace map.\n     * @returns {IterableIterator<{node:Node,path:string[],type:symbol,info:any}>} The iterator to iterate references.\n     */\n    *iterateEsmReferences(traceMap) {\n        const programNode = this.globalScope.block;\n\n        for (const node of programNode.body) {\n            if (!IMPORT_TYPE.test(node.type) || node.source == null) {\n                continue\n            }\n            const moduleId = node.source.value;\n\n            if (!has$1(traceMap, moduleId)) {\n                continue\n            }\n            const nextTraceMap = traceMap[moduleId];\n            const path = [moduleId];\n\n            if (nextTraceMap[READ$1]) {\n                yield { node, path, type: READ$1, info: nextTraceMap[READ$1] };\n            }\n\n            if (node.type === \"ExportAllDeclaration\") {\n                for (const key of Object.keys(nextTraceMap)) {\n                    const exportTraceMap = nextTraceMap[key];\n                    if (exportTraceMap[READ$1]) {\n                        yield {\n                            node,\n                            path: path.concat(key),\n                            type: READ$1,\n                            info: exportTraceMap[READ$1],\n                        };\n                    }\n                }\n            } else {\n                for (const specifier of node.specifiers) {\n                    const esm = has$1(nextTraceMap, ESM);\n                    const it = this._iterateImportReferences(\n                        specifier,\n                        path,\n                        esm\n                            ? nextTraceMap\n                            : this.mode === \"legacy\"\n                            ? Object.assign(\n                                  { default: nextTraceMap },\n                                  nextTraceMap\n                              )\n                            : { default: nextTraceMap }\n                    );\n\n                    if (esm) {\n                        yield* it;\n                    } else {\n                        for (const report of it) {\n                            report.path = report.path.filter(exceptDefault);\n                            if (\n                                report.path.length >= 2 ||\n                                report.type !== READ$1\n                            ) {\n                                yield report;\n                            }\n                        }\n                    }\n                }\n            }\n        }\n    }\n\n    /**\n     * Iterate the references for a given variable.\n     * @param {Variable} variable The variable to iterate that references.\n     * @param {string[]} path The current path.\n     * @param {object} traceMap The trace map.\n     * @param {boolean} shouldReport = The flag to report those references.\n     * @returns {IterableIterator<{node:Node,path:string[],type:symbol,info:any}>} The iterator to iterate references.\n     */\n    *_iterateVariableReferences(variable, path, traceMap, shouldReport) {\n        if (this.variableStack.includes(variable)) {\n            return\n        }\n        this.variableStack.push(variable);\n        try {\n            for (const reference of variable.references) {\n                if (!reference.isRead()) {\n                    continue\n                }\n                const node = reference.identifier;\n\n                if (shouldReport && traceMap[READ$1]) {\n                    yield { node, path, type: READ$1, info: traceMap[READ$1] };\n                }\n                yield* this._iteratePropertyReferences(node, path, traceMap);\n            }\n        } finally {\n            this.variableStack.pop();\n        }\n    }\n\n    /**\n     * Iterate the references for a given AST node.\n     * @param rootNode The AST node to iterate references.\n     * @param {string[]} path The current path.\n     * @param {object} traceMap The trace map.\n     * @returns {IterableIterator<{node:Node,path:string[],type:symbol,info:any}>} The iterator to iterate references.\n     */\n    //eslint-disable-next-line complexity\n    *_iteratePropertyReferences(rootNode, path, traceMap) {\n        let node = rootNode;\n        while (isPassThrough(node)) {\n            node = node.parent;\n        }\n\n        const parent = node.parent;\n        if (parent.type === \"MemberExpression\") {\n            if (parent.object === node) {\n                const key = getPropertyName$1(parent);\n                if (key == null || !has$1(traceMap, key)) {\n                    return\n                }\n\n                path = path.concat(key); //eslint-disable-line no-param-reassign\n                const nextTraceMap = traceMap[key];\n                if (nextTraceMap[READ$1]) {\n                    yield {\n                        node: parent,\n                        path,\n                        type: READ$1,\n                        info: nextTraceMap[READ$1],\n                    };\n                }\n                yield* this._iteratePropertyReferences(\n                    parent,\n                    path,\n                    nextTraceMap\n                );\n            }\n            return\n        }\n        if (parent.type === \"CallExpression\") {\n            if (parent.callee === node && traceMap[CALL]) {\n                yield { node: parent, path, type: CALL, info: traceMap[CALL] };\n            }\n            return\n        }\n        if (parent.type === \"NewExpression\") {\n            if (parent.callee === node && traceMap[CONSTRUCT]) {\n                yield {\n                    node: parent,\n                    path,\n                    type: CONSTRUCT,\n                    info: traceMap[CONSTRUCT],\n                };\n            }\n            return\n        }\n        if (parent.type === \"AssignmentExpression\") {\n            if (parent.right === node) {\n                yield* this._iterateLhsReferences(parent.left, path, traceMap);\n                yield* this._iteratePropertyReferences(parent, path, traceMap);\n            }\n            return\n        }\n        if (parent.type === \"AssignmentPattern\") {\n            if (parent.right === node) {\n                yield* this._iterateLhsReferences(parent.left, path, traceMap);\n            }\n            return\n        }\n        if (parent.type === \"VariableDeclarator\") {\n            if (parent.init === node) {\n                yield* this._iterateLhsReferences(parent.id, path, traceMap);\n            }\n        }\n    }\n\n    /**\n     * Iterate the references for a given Pattern node.\n     * @param {Node} patternNode The Pattern node to iterate references.\n     * @param {string[]} path The current path.\n     * @param {object} traceMap The trace map.\n     * @returns {IterableIterator<{node:Node,path:string[],type:symbol,info:any}>} The iterator to iterate references.\n     */\n    *_iterateLhsReferences(patternNode, path, traceMap) {\n        if (patternNode.type === \"Identifier\") {\n            const variable = findVariable(this.globalScope, patternNode);\n            if (variable != null) {\n                yield* this._iterateVariableReferences(\n                    variable,\n                    path,\n                    traceMap,\n                    false\n                );\n            }\n            return\n        }\n        if (patternNode.type === \"ObjectPattern\") {\n            for (const property of patternNode.properties) {\n                const key = getPropertyName$1(property);\n\n                if (key == null || !has$1(traceMap, key)) {\n                    continue\n                }\n\n                const nextPath = path.concat(key);\n                const nextTraceMap = traceMap[key];\n                if (nextTraceMap[READ$1]) {\n                    yield {\n                        node: property,\n                        path: nextPath,\n                        type: READ$1,\n                        info: nextTraceMap[READ$1],\n                    };\n                }\n                yield* this._iterateLhsReferences(\n                    property.value,\n                    nextPath,\n                    nextTraceMap\n                );\n            }\n            return\n        }\n        if (patternNode.type === \"AssignmentPattern\") {\n            yield* this._iterateLhsReferences(patternNode.left, path, traceMap);\n        }\n    }\n\n    /**\n     * Iterate the references for a given ModuleSpecifier node.\n     * @param {Node} specifierNode The ModuleSpecifier node to iterate references.\n     * @param {string[]} path The current path.\n     * @param {object} traceMap The trace map.\n     * @returns {IterableIterator<{node:Node,path:string[],type:symbol,info:any}>} The iterator to iterate references.\n     */\n    *_iterateImportReferences(specifierNode, path, traceMap) {\n        const type = specifierNode.type;\n\n        if (type === \"ImportSpecifier\" || type === \"ImportDefaultSpecifier\") {\n            const key =\n                type === \"ImportDefaultSpecifier\"\n                    ? \"default\"\n                    : specifierNode.imported.name;\n            if (!has$1(traceMap, key)) {\n                return\n            }\n\n            path = path.concat(key); //eslint-disable-line no-param-reassign\n            const nextTraceMap = traceMap[key];\n            if (nextTraceMap[READ$1]) {\n                yield {\n                    node: specifierNode,\n                    path,\n                    type: READ$1,\n                    info: nextTraceMap[READ$1],\n                };\n            }\n            yield* this._iterateVariableReferences(\n                findVariable(this.globalScope, specifierNode.local),\n                path,\n                nextTraceMap,\n                false\n            );\n\n            return\n        }\n\n        if (type === \"ImportNamespaceSpecifier\") {\n            yield* this._iterateVariableReferences(\n                findVariable(this.globalScope, specifierNode.local),\n                path,\n                traceMap,\n                false\n            );\n            return\n        }\n\n        if (type === \"ExportSpecifier\") {\n            const key = specifierNode.local.name;\n            if (!has$1(traceMap, key)) {\n                return\n            }\n\n            path = path.concat(key); //eslint-disable-line no-param-reassign\n            const nextTraceMap = traceMap[key];\n            if (nextTraceMap[READ$1]) {\n                yield {\n                    node: specifierNode,\n                    path,\n                    type: READ$1,\n                    info: nextTraceMap[READ$1],\n                };\n            }\n        }\n    }\n}\n\nReferenceTracker.READ = READ$1;\nReferenceTracker.CALL = CALL;\nReferenceTracker.CONSTRUCT = CONSTRUCT;\nReferenceTracker.ESM = ESM;\n\n/**\n * This is a predicate function for Array#filter.\n * @param {string} name A name part.\n * @param {number} index The index of the name.\n * @returns {boolean} `false` if it's default.\n */\nfunction exceptDefault(name, index) {\n    return !(index === 1 && name === \"default\")\n}\n\nvar index = {\n    CALL,\n    CONSTRUCT,\n    ESM,\n    findVariable,\n    getFunctionHeadLocation,\n    getFunctionNameWithKind,\n    getInnermostScope,\n    getPropertyName: getPropertyName$1,\n    getStaticValue,\n    getStringIfConstant,\n    hasSideEffect,\n    isArrowToken,\n    isClosingBraceToken,\n    isClosingBracketToken,\n    isClosingParenToken,\n    isColonToken,\n    isCommaToken,\n    isCommentToken: isCommentToken$1,\n    isNotArrowToken,\n    isNotClosingBraceToken,\n    isNotClosingBracketToken,\n    isNotClosingParenToken,\n    isNotColonToken,\n    isNotCommaToken,\n    isNotCommentToken,\n    isNotOpeningBraceToken,\n    isNotOpeningBracketToken,\n    isNotOpeningParenToken: isNotOpeningParenToken$1,\n    isNotSemicolonToken,\n    isOpeningBraceToken,\n    isOpeningBracketToken,\n    isOpeningParenToken,\n    isParenthesized,\n    isSemicolonToken,\n    PatternMatcher,\n    READ: READ$1,\n    ReferenceTracker,\n};\n\nvar eslintUtils = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  'default': index,\n  CALL: CALL,\n  CONSTRUCT: CONSTRUCT,\n  ESM: ESM,\n  PatternMatcher: PatternMatcher,\n  READ: READ$1,\n  ReferenceTracker: ReferenceTracker,\n  findVariable: findVariable,\n  getFunctionHeadLocation: getFunctionHeadLocation,\n  getFunctionNameWithKind: getFunctionNameWithKind,\n  getInnermostScope: getInnermostScope,\n  getPropertyName: getPropertyName$1,\n  getStaticValue: getStaticValue,\n  getStringIfConstant: getStringIfConstant,\n  hasSideEffect: hasSideEffect,\n  isArrowToken: isArrowToken,\n  isClosingBraceToken: isClosingBraceToken,\n  isClosingBracketToken: isClosingBracketToken,\n  isClosingParenToken: isClosingParenToken,\n  isColonToken: isColonToken,\n  isCommaToken: isCommaToken,\n  isCommentToken: isCommentToken$1,\n  isNotArrowToken: isNotArrowToken,\n  isNotClosingBraceToken: isNotClosingBraceToken,\n  isNotClosingBracketToken: isNotClosingBracketToken,\n  isNotClosingParenToken: isNotClosingParenToken,\n  isNotColonToken: isNotColonToken,\n  isNotCommaToken: isNotCommaToken,\n  isNotCommentToken: isNotCommentToken,\n  isNotOpeningBraceToken: isNotOpeningBraceToken,\n  isNotOpeningBracketToken: isNotOpeningBracketToken,\n  isNotOpeningParenToken: isNotOpeningParenToken$1,\n  isNotSemicolonToken: isNotSemicolonToken,\n  isOpeningBraceToken: isOpeningBraceToken,\n  isOpeningBracketToken: isOpeningBracketToken,\n  isOpeningParenToken: isOpeningParenToken,\n  isParenthesized: isParenthesized,\n  isSemicolonToken: isSemicolonToken\n});\n\nvar require$$0$2 = getCjsExportFromNamespace(eslintUtils);\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nconst { isParenthesized: isParenthesizedRaw } = require$$0$2;\n\n\nvar noExtraParens = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"disallow unnecessary parentheses\",\n            category: \"Possible Errors\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-extra-parens\"\n        },\n\n        fixable: \"code\",\n\n        schema: {\n            anyOf: [\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"functions\"]\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 1\n                },\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"all\"]\n                        },\n                        {\n                            type: \"object\",\n                            properties: {\n                                conditionalAssign: { type: \"boolean\" },\n                                nestedBinaryExpressions: { type: \"boolean\" },\n                                returnAssign: { type: \"boolean\" },\n                                ignoreJSX: { enum: [\"none\", \"all\", \"single-line\", \"multi-line\"] },\n                                enforceForArrowConditionals: { type: \"boolean\" },\n                                enforceForSequenceExpressions: { type: \"boolean\" },\n                                enforceForNewInMemberExpressions: { type: \"boolean\" }\n                            },\n                            additionalProperties: false\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 2\n                }\n            ]\n        },\n\n        messages: {\n            unexpected: \"Unnecessary parentheses around expression.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        const tokensToIgnore = new WeakSet();\n        const precedence = astUtils$1.getPrecedence;\n        const ALL_NODES = context.options[0] !== \"functions\";\n        const EXCEPT_COND_ASSIGN = ALL_NODES && context.options[1] && context.options[1].conditionalAssign === false;\n        const NESTED_BINARY = ALL_NODES && context.options[1] && context.options[1].nestedBinaryExpressions === false;\n        const EXCEPT_RETURN_ASSIGN = ALL_NODES && context.options[1] && context.options[1].returnAssign === false;\n        const IGNORE_JSX = ALL_NODES && context.options[1] && context.options[1].ignoreJSX;\n        const IGNORE_ARROW_CONDITIONALS = ALL_NODES && context.options[1] &&\n            context.options[1].enforceForArrowConditionals === false;\n        const IGNORE_SEQUENCE_EXPRESSIONS = ALL_NODES && context.options[1] &&\n            context.options[1].enforceForSequenceExpressions === false;\n        const IGNORE_NEW_IN_MEMBER_EXPR = ALL_NODES && context.options[1] &&\n            context.options[1].enforceForNewInMemberExpressions === false;\n\n        const PRECEDENCE_OF_ASSIGNMENT_EXPR = precedence({ type: \"AssignmentExpression\" });\n        const PRECEDENCE_OF_UPDATE_EXPR = precedence({ type: \"UpdateExpression\" });\n\n        let reportsBuffer;\n\n        /**\n         * Determines if this rule should be enforced for a node given the current configuration.\n         * @param {ASTNode} node The node to be checked.\n         * @returns {boolean} True if the rule should be enforced for this node.\n         * @private\n         */\n        function ruleApplies(node) {\n            if (node.type === \"JSXElement\" || node.type === \"JSXFragment\") {\n                const isSingleLine = node.loc.start.line === node.loc.end.line;\n\n                switch (IGNORE_JSX) {\n\n                    // Exclude this JSX element from linting\n                    case \"all\":\n                        return false;\n\n                    // Exclude this JSX element if it is multi-line element\n                    case \"multi-line\":\n                        return isSingleLine;\n\n                    // Exclude this JSX element if it is single-line element\n                    case \"single-line\":\n                        return !isSingleLine;\n\n                    // no default\n                }\n            }\n\n            if (node.type === \"SequenceExpression\" && IGNORE_SEQUENCE_EXPRESSIONS) {\n                return false;\n            }\n\n            return ALL_NODES || node.type === \"FunctionExpression\" || node.type === \"ArrowFunctionExpression\";\n        }\n\n        /**\n         * Determines if a node is surrounded by parentheses.\n         * @param {ASTNode} node The node to be checked.\n         * @returns {boolean} True if the node is parenthesised.\n         * @private\n         */\n        function isParenthesised(node) {\n            return isParenthesizedRaw(1, node, sourceCode);\n        }\n\n        /**\n         * Determines if a node is surrounded by parentheses twice.\n         * @param {ASTNode} node The node to be checked.\n         * @returns {boolean} True if the node is doubly parenthesised.\n         * @private\n         */\n        function isParenthesisedTwice(node) {\n            return isParenthesizedRaw(2, node, sourceCode);\n        }\n\n        /**\n         * Determines if a node is surrounded by (potentially) invalid parentheses.\n         * @param {ASTNode} node The node to be checked.\n         * @returns {boolean} True if the node is incorrectly parenthesised.\n         * @private\n         */\n        function hasExcessParens(node) {\n            return ruleApplies(node) && isParenthesised(node);\n        }\n\n        /**\n         * Determines if a node that is expected to be parenthesised is surrounded by\n         * (potentially) invalid extra parentheses.\n         * @param {ASTNode} node The node to be checked.\n         * @returns {boolean} True if the node is has an unexpected extra pair of parentheses.\n         * @private\n         */\n        function hasDoubleExcessParens(node) {\n            return ruleApplies(node) && isParenthesisedTwice(node);\n        }\n\n        /**\n         * Determines if a node test expression is allowed to have a parenthesised assignment\n         * @param {ASTNode} node The node to be checked.\n         * @returns {boolean} True if the assignment can be parenthesised.\n         * @private\n         */\n        function isCondAssignException(node) {\n            return EXCEPT_COND_ASSIGN && node.test.type === \"AssignmentExpression\";\n        }\n\n        /**\n         * Determines if a node is in a return statement\n         * @param {ASTNode} node The node to be checked.\n         * @returns {boolean} True if the node is in a return statement.\n         * @private\n         */\n        function isInReturnStatement(node) {\n            for (let currentNode = node; currentNode; currentNode = currentNode.parent) {\n                if (\n                    currentNode.type === \"ReturnStatement\" ||\n                    (currentNode.type === \"ArrowFunctionExpression\" && currentNode.body.type !== \"BlockStatement\")\n                ) {\n                    return true;\n                }\n            }\n\n            return false;\n        }\n\n        /**\n         * Determines if a constructor function is newed-up with parens\n         * @param {ASTNode} newExpression The NewExpression node to be checked.\n         * @returns {boolean} True if the constructor is called with parens.\n         * @private\n         */\n        function isNewExpressionWithParens(newExpression) {\n            const lastToken = sourceCode.getLastToken(newExpression);\n            const penultimateToken = sourceCode.getTokenBefore(lastToken);\n\n            return newExpression.arguments.length > 0 ||\n                (\n\n                    // The expression should end with its own parens, e.g., new new foo() is not a new expression with parens\n                    astUtils$1.isOpeningParenToken(penultimateToken) &&\n                    astUtils$1.isClosingParenToken(lastToken) &&\n                    newExpression.callee.range[1] < newExpression.range[1]\n                );\n        }\n\n        /**\n         * Determines if a node is or contains an assignment expression\n         * @param {ASTNode} node The node to be checked.\n         * @returns {boolean} True if the node is or contains an assignment expression.\n         * @private\n         */\n        function containsAssignment(node) {\n            if (node.type === \"AssignmentExpression\") {\n                return true;\n            }\n            if (node.type === \"ConditionalExpression\" &&\n                    (node.consequent.type === \"AssignmentExpression\" || node.alternate.type === \"AssignmentExpression\")) {\n                return true;\n            }\n            if ((node.left && node.left.type === \"AssignmentExpression\") ||\n                    (node.right && node.right.type === \"AssignmentExpression\")) {\n                return true;\n            }\n\n            return false;\n        }\n\n        /**\n         * Determines if a node is contained by or is itself a return statement and is allowed to have a parenthesised assignment\n         * @param {ASTNode} node The node to be checked.\n         * @returns {boolean} True if the assignment can be parenthesised.\n         * @private\n         */\n        function isReturnAssignException(node) {\n            if (!EXCEPT_RETURN_ASSIGN || !isInReturnStatement(node)) {\n                return false;\n            }\n\n            if (node.type === \"ReturnStatement\") {\n                return node.argument && containsAssignment(node.argument);\n            }\n            if (node.type === \"ArrowFunctionExpression\" && node.body.type !== \"BlockStatement\") {\n                return containsAssignment(node.body);\n            }\n            return containsAssignment(node);\n\n        }\n\n        /**\n         * Determines if a node following a [no LineTerminator here] restriction is\n         * surrounded by (potentially) invalid extra parentheses.\n         * @param {Token} token The token preceding the [no LineTerminator here] restriction.\n         * @param {ASTNode} node The node to be checked.\n         * @returns {boolean} True if the node is incorrectly parenthesised.\n         * @private\n         */\n        function hasExcessParensNoLineTerminator(token, node) {\n            if (token.loc.end.line === node.loc.start.line) {\n                return hasExcessParens(node);\n            }\n\n            return hasDoubleExcessParens(node);\n        }\n\n        /**\n         * Determines whether a node should be preceded by an additional space when removing parens\n         * @param {ASTNode} node node to evaluate; must be surrounded by parentheses\n         * @returns {boolean} `true` if a space should be inserted before the node\n         * @private\n         */\n        function requiresLeadingSpace(node) {\n            const leftParenToken = sourceCode.getTokenBefore(node);\n            const tokenBeforeLeftParen = sourceCode.getTokenBefore(node, 1);\n            const firstToken = sourceCode.getFirstToken(node);\n\n            return tokenBeforeLeftParen &&\n                tokenBeforeLeftParen.range[1] === leftParenToken.range[0] &&\n                leftParenToken.range[1] === firstToken.range[0] &&\n                !astUtils$1.canTokensBeAdjacent(tokenBeforeLeftParen, firstToken);\n        }\n\n        /**\n         * Determines whether a node should be followed by an additional space when removing parens\n         * @param {ASTNode} node node to evaluate; must be surrounded by parentheses\n         * @returns {boolean} `true` if a space should be inserted after the node\n         * @private\n         */\n        function requiresTrailingSpace(node) {\n            const nextTwoTokens = sourceCode.getTokensAfter(node, { count: 2 });\n            const rightParenToken = nextTwoTokens[0];\n            const tokenAfterRightParen = nextTwoTokens[1];\n            const tokenBeforeRightParen = sourceCode.getLastToken(node);\n\n            return rightParenToken && tokenAfterRightParen &&\n                !sourceCode.isSpaceBetweenTokens(rightParenToken, tokenAfterRightParen) &&\n                !astUtils$1.canTokensBeAdjacent(tokenBeforeRightParen, tokenAfterRightParen);\n        }\n\n        /**\n         * Determines if a given expression node is an IIFE\n         * @param {ASTNode} node The node to check\n         * @returns {boolean} `true` if the given node is an IIFE\n         */\n        function isIIFE(node) {\n            return node.type === \"CallExpression\" && node.callee.type === \"FunctionExpression\";\n        }\n\n        /**\n         * Report the node\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function report(node) {\n            const leftParenToken = sourceCode.getTokenBefore(node);\n            const rightParenToken = sourceCode.getTokenAfter(node);\n\n            if (!isParenthesisedTwice(node)) {\n                if (tokensToIgnore.has(sourceCode.getFirstToken(node))) {\n                    return;\n                }\n\n                if (isIIFE(node) && !isParenthesised(node.callee)) {\n                    return;\n                }\n            }\n\n            /**\n             * Finishes reporting\n             * @returns {void}\n             * @private\n             */\n            function finishReport() {\n                context.report({\n                    node,\n                    loc: leftParenToken.loc,\n                    messageId: \"unexpected\",\n                    fix(fixer) {\n                        const parenthesizedSource = sourceCode.text.slice(leftParenToken.range[1], rightParenToken.range[0]);\n\n                        return fixer.replaceTextRange([\n                            leftParenToken.range[0],\n                            rightParenToken.range[1]\n                        ], (requiresLeadingSpace(node) ? \" \" : \"\") + parenthesizedSource + (requiresTrailingSpace(node) ? \" \" : \"\"));\n                    }\n                });\n            }\n\n            if (reportsBuffer) {\n                reportsBuffer.reports.push({ node, finishReport });\n                return;\n            }\n\n            finishReport();\n        }\n\n        /**\n         * Evaluate Unary update\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function checkUnaryUpdate(node) {\n            if (node.type === \"UnaryExpression\" && node.argument.type === \"BinaryExpression\" && node.argument.operator === \"**\") {\n                return;\n            }\n\n            if (hasExcessParens(node.argument) && precedence(node.argument) >= precedence(node)) {\n                report(node.argument);\n            }\n        }\n\n        /**\n         * Check if a member expression contains a call expression\n         * @param {ASTNode} node MemberExpression node to evaluate\n         * @returns {boolean} true if found, false if not\n         */\n        function doesMemberExpressionContainCallExpression(node) {\n            let currentNode = node.object;\n            let currentNodeType = node.object.type;\n\n            while (currentNodeType === \"MemberExpression\") {\n                currentNode = currentNode.object;\n                currentNodeType = currentNode.type;\n            }\n\n            return currentNodeType === \"CallExpression\";\n        }\n\n        /**\n         * Evaluate a new call\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function checkCallNew(node) {\n            const callee = node.callee;\n\n            if (hasExcessParens(callee) && precedence(callee) >= precedence(node)) {\n                const hasNewParensException = callee.type === \"NewExpression\" && !isNewExpressionWithParens(callee);\n\n                if (\n                    hasDoubleExcessParens(callee) ||\n                    !isIIFE(node) && !hasNewParensException && !(\n\n                        /*\n                         * Allow extra parens around a new expression if\n                         * there are intervening parentheses.\n                         */\n                        (callee.type === \"MemberExpression\" && doesMemberExpressionContainCallExpression(callee))\n                    )\n                ) {\n                    report(node.callee);\n                }\n            }\n            node.arguments\n                .filter(arg => hasExcessParens(arg) && precedence(arg) >= PRECEDENCE_OF_ASSIGNMENT_EXPR)\n                .forEach(report);\n        }\n\n        /**\n         * Evaluate binary logicals\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function checkBinaryLogical(node) {\n            const prec = precedence(node);\n            const leftPrecedence = precedence(node.left);\n            const rightPrecedence = precedence(node.right);\n            const isExponentiation = node.operator === \"**\";\n            const shouldSkipLeft = (NESTED_BINARY && (node.left.type === \"BinaryExpression\" || node.left.type === \"LogicalExpression\")) ||\n              node.left.type === \"UnaryExpression\" && isExponentiation;\n            const shouldSkipRight = NESTED_BINARY && (node.right.type === \"BinaryExpression\" || node.right.type === \"LogicalExpression\");\n\n            if (!shouldSkipLeft && hasExcessParens(node.left) && (leftPrecedence > prec || (leftPrecedence === prec && !isExponentiation))) {\n                report(node.left);\n            }\n            if (!shouldSkipRight && hasExcessParens(node.right) && (rightPrecedence > prec || (rightPrecedence === prec && isExponentiation))) {\n                report(node.right);\n            }\n        }\n\n        /**\n         * Check the parentheses around the super class of the given class definition.\n         * @param {ASTNode} node The node of class declarations to check.\n         * @returns {void}\n         */\n        function checkClass(node) {\n            if (!node.superClass) {\n                return;\n            }\n\n            /*\n             * If `node.superClass` is a LeftHandSideExpression, parentheses are extra.\n             * Otherwise, parentheses are needed.\n             */\n            const hasExtraParens = precedence(node.superClass) > PRECEDENCE_OF_UPDATE_EXPR\n                ? hasExcessParens(node.superClass)\n                : hasDoubleExcessParens(node.superClass);\n\n            if (hasExtraParens) {\n                report(node.superClass);\n            }\n        }\n\n        /**\n         * Check the parentheses around the argument of the given spread operator.\n         * @param {ASTNode} node The node of spread elements/properties to check.\n         * @returns {void}\n         */\n        function checkSpreadOperator(node) {\n            const hasExtraParens = precedence(node.argument) >= PRECEDENCE_OF_ASSIGNMENT_EXPR\n                ? hasExcessParens(node.argument)\n                : hasDoubleExcessParens(node.argument);\n\n            if (hasExtraParens) {\n                report(node.argument);\n            }\n        }\n\n        /**\n         * Checks the parentheses for an ExpressionStatement or ExportDefaultDeclaration\n         * @param {ASTNode} node The ExpressionStatement.expression or ExportDefaultDeclaration.declaration node\n         * @returns {void}\n         */\n        function checkExpressionOrExportStatement(node) {\n            const firstToken = isParenthesised(node) ? sourceCode.getTokenBefore(node) : sourceCode.getFirstToken(node);\n            const secondToken = sourceCode.getTokenAfter(firstToken, astUtils$1.isNotOpeningParenToken);\n            const thirdToken = secondToken ? sourceCode.getTokenAfter(secondToken) : null;\n            const tokenAfterClosingParens = secondToken ? sourceCode.getTokenAfter(secondToken, astUtils$1.isNotClosingParenToken) : null;\n\n            if (\n                astUtils$1.isOpeningParenToken(firstToken) &&\n                (\n                    astUtils$1.isOpeningBraceToken(secondToken) ||\n                    secondToken.type === \"Keyword\" && (\n                        secondToken.value === \"function\" ||\n                        secondToken.value === \"class\" ||\n                        secondToken.value === \"let\" &&\n                            tokenAfterClosingParens &&\n                            (\n                                astUtils$1.isOpeningBracketToken(tokenAfterClosingParens) ||\n                                tokenAfterClosingParens.type === \"Identifier\"\n                            )\n                    ) ||\n                    secondToken && secondToken.type === \"Identifier\" && secondToken.value === \"async\" && thirdToken && thirdToken.type === \"Keyword\" && thirdToken.value === \"function\"\n                )\n            ) {\n                tokensToIgnore.add(secondToken);\n            }\n\n            if (hasExcessParens(node)) {\n                report(node);\n            }\n        }\n\n        /**\n         * Finds the path from the given node to the specified ancestor.\n         * @param {ASTNode} node First node in the path.\n         * @param {ASTNode} ancestor Last node in the path.\n         * @returns {ASTNode[]} Path, including both nodes.\n         * @throws {Error} If the given node does not have the specified ancestor.\n         */\n        function pathToAncestor(node, ancestor) {\n            const path = [node];\n            let currentNode = node;\n\n            while (currentNode !== ancestor) {\n\n                currentNode = currentNode.parent;\n\n                /* istanbul ignore if */\n                if (currentNode === null) {\n                    throw new Error(\"Nodes are not in the ancestor-descendant relationship.\");\n                }\n\n                path.push(currentNode);\n            }\n\n            return path;\n        }\n\n        /**\n         * Finds the path from the given node to the specified descendant.\n         * @param {ASTNode} node First node in the path.\n         * @param {ASTNode} descendant Last node in the path.\n         * @returns {ASTNode[]} Path, including both nodes.\n         * @throws {Error} If the given node does not have the specified descendant.\n         */\n        function pathToDescendant(node, descendant) {\n            return pathToAncestor(descendant, node).reverse();\n        }\n\n        /**\n         * Checks whether the syntax of the given ancestor of an 'in' expression inside a for-loop initializer\n         * is preventing the 'in' keyword from being interpreted as a part of an ill-formed for-in loop.\n         * @param {ASTNode} node Ancestor of an 'in' expression.\n         * @param {ASTNode} child Child of the node, ancestor of the same 'in' expression or the 'in' expression itself.\n         * @returns {boolean} True if the keyword 'in' would be interpreted as the 'in' operator, without any parenthesis.\n         */\n        function isSafelyEnclosingInExpression(node, child) {\n            switch (node.type) {\n                case \"ArrayExpression\":\n                case \"ArrayPattern\":\n                case \"BlockStatement\":\n                case \"ObjectExpression\":\n                case \"ObjectPattern\":\n                case \"TemplateLiteral\":\n                    return true;\n                case \"ArrowFunctionExpression\":\n                case \"FunctionExpression\":\n                    return node.params.includes(child);\n                case \"CallExpression\":\n                case \"NewExpression\":\n                    return node.arguments.includes(child);\n                case \"MemberExpression\":\n                    return node.computed && node.property === child;\n                case \"ConditionalExpression\":\n                    return node.consequent === child;\n                default:\n                    return false;\n            }\n        }\n\n        /**\n         * Starts a new reports buffering. Warnings will be stored in a buffer instead of being reported immediately.\n         * An additional logic that requires multiple nodes (e.g. a whole subtree) may dismiss some of the stored warnings.\n         * @returns {void}\n         */\n        function startNewReportsBuffering() {\n            reportsBuffer = {\n                upper: reportsBuffer,\n                inExpressionNodes: [],\n                reports: []\n            };\n        }\n\n        /**\n         * Ends the current reports buffering.\n         * @returns {void}\n         */\n        function endCurrentReportsBuffering() {\n            const { upper, inExpressionNodes, reports } = reportsBuffer;\n\n            if (upper) {\n                upper.inExpressionNodes.push(...inExpressionNodes);\n                upper.reports.push(...reports);\n            } else {\n\n                // flush remaining reports\n                reports.forEach(({ finishReport }) => finishReport());\n            }\n\n            reportsBuffer = upper;\n        }\n\n        /**\n         * Checks whether the given node is in the current reports buffer.\n         * @param {ASTNode} node Node to check.\n         * @returns {boolean} True if the node is in the current buffer, false otherwise.\n         */\n        function isInCurrentReportsBuffer(node) {\n            return reportsBuffer.reports.some(r => r.node === node);\n        }\n\n        /**\n         * Removes the given node from the current reports buffer.\n         * @param {ASTNode} node Node to remove.\n         * @returns {void}\n         */\n        function removeFromCurrentReportsBuffer(node) {\n            reportsBuffer.reports = reportsBuffer.reports.filter(r => r.node !== node);\n        }\n\n        return {\n            ArrayExpression(node) {\n                node.elements\n                    .filter(e => e && hasExcessParens(e) && precedence(e) >= PRECEDENCE_OF_ASSIGNMENT_EXPR)\n                    .forEach(report);\n            },\n\n            ArrowFunctionExpression(node) {\n                if (isReturnAssignException(node)) {\n                    return;\n                }\n\n                if (node.body.type === \"ConditionalExpression\" &&\n                    IGNORE_ARROW_CONDITIONALS &&\n                    !isParenthesisedTwice(node.body)\n                ) {\n                    return;\n                }\n\n                if (node.body.type !== \"BlockStatement\") {\n                    const firstBodyToken = sourceCode.getFirstToken(node.body, astUtils$1.isNotOpeningParenToken);\n                    const tokenBeforeFirst = sourceCode.getTokenBefore(firstBodyToken);\n\n                    if (astUtils$1.isOpeningParenToken(tokenBeforeFirst) && astUtils$1.isOpeningBraceToken(firstBodyToken)) {\n                        tokensToIgnore.add(firstBodyToken);\n                    }\n                    if (hasExcessParens(node.body) && precedence(node.body) >= PRECEDENCE_OF_ASSIGNMENT_EXPR) {\n                        report(node.body);\n                    }\n                }\n            },\n\n            AssignmentExpression(node) {\n                if (isReturnAssignException(node)) {\n                    return;\n                }\n\n                if (hasExcessParens(node.right) && precedence(node.right) >= precedence(node)) {\n                    report(node.right);\n                }\n            },\n\n            BinaryExpression(node) {\n                if (reportsBuffer && node.operator === \"in\") {\n                    reportsBuffer.inExpressionNodes.push(node);\n                }\n\n                checkBinaryLogical(node);\n            },\n\n            CallExpression: checkCallNew,\n\n            ClassBody(node) {\n                node.body\n                    .filter(member => member.type === \"MethodDefinition\" && member.computed &&\n                        member.key && hasExcessParens(member.key) && precedence(member.key) >= PRECEDENCE_OF_ASSIGNMENT_EXPR)\n                    .forEach(member => report(member.key));\n            },\n\n            ConditionalExpression(node) {\n                if (isReturnAssignException(node)) {\n                    return;\n                }\n\n                if (hasExcessParens(node.test) && precedence(node.test) >= precedence({ type: \"LogicalExpression\", operator: \"||\" })) {\n                    report(node.test);\n                }\n\n                if (hasExcessParens(node.consequent) && precedence(node.consequent) >= PRECEDENCE_OF_ASSIGNMENT_EXPR) {\n                    report(node.consequent);\n                }\n\n                if (hasExcessParens(node.alternate) && precedence(node.alternate) >= PRECEDENCE_OF_ASSIGNMENT_EXPR) {\n                    report(node.alternate);\n                }\n            },\n\n            DoWhileStatement(node) {\n                if (hasExcessParens(node.test) && !isCondAssignException(node)) {\n                    report(node.test);\n                }\n            },\n\n            ExportDefaultDeclaration: node => checkExpressionOrExportStatement(node.declaration),\n            ExpressionStatement: node => checkExpressionOrExportStatement(node.expression),\n\n            \"ForInStatement, ForOfStatement\"(node) {\n                if (node.left.type !== \"VariableDeclarator\") {\n                    const firstLeftToken = sourceCode.getFirstToken(node.left, astUtils$1.isNotOpeningParenToken);\n\n                    if (\n                        firstLeftToken.value === \"let\" && (\n\n                            /*\n                             * If `let` is the only thing on the left side of the loop, it's the loop variable: `for ((let) of foo);`\n                             * Removing it will cause a syntax error, because it will be parsed as the start of a VariableDeclarator.\n                             */\n                            (firstLeftToken.range[1] === node.left.range[1] || /*\n                             * If `let` is followed by a `[` token, it's a property access on the `let` value: `for ((let[foo]) of bar);`\n                             * Removing it will cause the property access to be parsed as a destructuring declaration of `foo` instead.\n                             */\n                            astUtils$1.isOpeningBracketToken(\n                                sourceCode.getTokenAfter(firstLeftToken, astUtils$1.isNotClosingParenToken)\n                            ))\n                        )\n                    ) {\n                        tokensToIgnore.add(firstLeftToken);\n                    }\n                }\n                if (!(node.type === \"ForOfStatement\" && node.right.type === \"SequenceExpression\") && hasExcessParens(node.right)) {\n                    report(node.right);\n                }\n                if (hasExcessParens(node.left)) {\n                    report(node.left);\n                }\n            },\n\n            ForStatement(node) {\n                if (node.test && hasExcessParens(node.test) && !isCondAssignException(node)) {\n                    report(node.test);\n                }\n\n                if (node.update && hasExcessParens(node.update)) {\n                    report(node.update);\n                }\n\n                if (node.init) {\n                    startNewReportsBuffering();\n\n                    if (hasExcessParens(node.init)) {\n                        report(node.init);\n                    }\n                }\n            },\n\n            \"ForStatement > *.init:exit\"(node) {\n\n                /*\n                 * Removing parentheses around `in` expressions might change semantics and cause errors.\n                 *\n                 * For example, this valid for loop:\n                 *      for (let a = (b in c); ;);\n                 * after removing parentheses would be treated as an invalid for-in loop:\n                 *      for (let a = b in c; ;);\n                 */\n\n                if (reportsBuffer.reports.length) {\n                    reportsBuffer.inExpressionNodes.forEach(inExpressionNode => {\n                        const path = pathToDescendant(node, inExpressionNode);\n                        let nodeToExclude;\n\n                        for (let i = 0; i < path.length; i++) {\n                            const pathNode = path[i];\n\n                            if (i < path.length - 1) {\n                                const nextPathNode = path[i + 1];\n\n                                if (isSafelyEnclosingInExpression(pathNode, nextPathNode)) {\n\n                                    // The 'in' expression in safely enclosed by the syntax of its ancestor nodes (e.g. by '{}' or '[]').\n                                    return;\n                                }\n                            }\n\n                            if (isParenthesised(pathNode)) {\n                                if (isInCurrentReportsBuffer(pathNode)) {\n\n                                    // This node was supposed to be reported, but parentheses might be necessary.\n\n                                    if (isParenthesisedTwice(pathNode)) {\n\n                                        /*\n                                         * This node is parenthesised twice, it certainly has at least one pair of `extra` parentheses.\n                                         * If the --fix option is on, the current fixing iteration will remove only one pair of parentheses.\n                                         * The remaining pair is safely enclosing the 'in' expression.\n                                         */\n                                        return;\n                                    }\n\n                                    // Exclude the outermost node only.\n                                    if (!nodeToExclude) {\n                                        nodeToExclude = pathNode;\n                                    }\n\n                                    // Don't break the loop here, there might be some safe nodes or parentheses that will stay inside.\n\n                                } else {\n\n                                    // This node will stay parenthesised, the 'in' expression in safely enclosed by '()'.\n                                    return;\n                                }\n                            }\n                        }\n\n                        // Exclude the node from the list (i.e. treat parentheses as necessary)\n                        removeFromCurrentReportsBuffer(nodeToExclude);\n                    });\n                }\n\n                endCurrentReportsBuffering();\n            },\n\n            IfStatement(node) {\n                if (hasExcessParens(node.test) && !isCondAssignException(node)) {\n                    report(node.test);\n                }\n            },\n\n            ImportExpression(node) {\n                const { source } = node;\n\n                if (source.type === \"SequenceExpression\") {\n                    if (hasDoubleExcessParens(source)) {\n                        report(source);\n                    }\n                } else if (hasExcessParens(source)) {\n                    report(source);\n                }\n            },\n\n            LogicalExpression: checkBinaryLogical,\n\n            MemberExpression(node) {\n                const nodeObjHasExcessParens = hasExcessParens(node.object);\n\n                if (\n                    nodeObjHasExcessParens &&\n                    precedence(node.object) >= precedence(node) &&\n                    (\n                        node.computed ||\n                        !(\n                            astUtils$1.isDecimalInteger(node.object) ||\n\n                            // RegExp literal is allowed to have parens (#1589)\n                            (node.object.type === \"Literal\" && node.object.regex)\n                        )\n                    )\n                ) {\n                    report(node.object);\n                }\n\n                if (nodeObjHasExcessParens &&\n                  node.object.type === \"CallExpression\" &&\n                  node.parent.type !== \"NewExpression\") {\n                    report(node.object);\n                }\n\n                if (nodeObjHasExcessParens &&\n                  !IGNORE_NEW_IN_MEMBER_EXPR &&\n                  node.object.type === \"NewExpression\" &&\n                  isNewExpressionWithParens(node.object)) {\n                    report(node.object);\n                }\n\n                if (node.computed && hasExcessParens(node.property)) {\n                    report(node.property);\n                }\n            },\n\n            NewExpression: checkCallNew,\n\n            ObjectExpression(node) {\n                node.properties\n                    .filter(property => {\n                        const value = property.value;\n\n                        return value && hasExcessParens(value) && precedence(value) >= PRECEDENCE_OF_ASSIGNMENT_EXPR;\n                    }).forEach(property => report(property.value));\n            },\n\n            Property(node) {\n                if (node.computed) {\n                    const { key } = node;\n\n                    if (key && hasExcessParens(key) && precedence(key) >= PRECEDENCE_OF_ASSIGNMENT_EXPR) {\n                        report(key);\n                    }\n                }\n            },\n\n            ReturnStatement(node) {\n                const returnToken = sourceCode.getFirstToken(node);\n\n                if (isReturnAssignException(node)) {\n                    return;\n                }\n\n                if (node.argument &&\n                        hasExcessParensNoLineTerminator(returnToken, node.argument) &&\n\n                        // RegExp literal is allowed to have parens (#1589)\n                        !(node.argument.type === \"Literal\" && node.argument.regex)) {\n                    report(node.argument);\n                }\n            },\n\n            SequenceExpression(node) {\n                node.expressions\n                    .filter(e => hasExcessParens(e) && precedence(e) >= precedence(node))\n                    .forEach(report);\n            },\n\n            SwitchCase(node) {\n                if (node.test && hasExcessParens(node.test)) {\n                    report(node.test);\n                }\n            },\n\n            SwitchStatement(node) {\n                if (hasExcessParens(node.discriminant)) {\n                    report(node.discriminant);\n                }\n            },\n\n            ThrowStatement(node) {\n                const throwToken = sourceCode.getFirstToken(node);\n\n                if (hasExcessParensNoLineTerminator(throwToken, node.argument)) {\n                    report(node.argument);\n                }\n            },\n\n            UnaryExpression: checkUnaryUpdate,\n            UpdateExpression: checkUnaryUpdate,\n            AwaitExpression: checkUnaryUpdate,\n\n            VariableDeclarator(node) {\n                if (node.init && hasExcessParens(node.init) &&\n                        precedence(node.init) >= PRECEDENCE_OF_ASSIGNMENT_EXPR &&\n\n                        // RegExp literal is allowed to have parens (#1589)\n                        !(node.init.type === \"Literal\" && node.init.regex)) {\n                    report(node.init);\n                }\n            },\n\n            WhileStatement(node) {\n                if (hasExcessParens(node.test) && !isCondAssignException(node)) {\n                    report(node.test);\n                }\n            },\n\n            WithStatement(node) {\n                if (hasExcessParens(node.object)) {\n                    report(node.object);\n                }\n            },\n\n            YieldExpression(node) {\n                if (node.argument) {\n                    const yieldToken = sourceCode.getFirstToken(node);\n\n                    if ((precedence(node.argument) >= precedence(node) &&\n                            hasExcessParensNoLineTerminator(yieldToken, node.argument)) ||\n                            hasDoubleExcessParens(node.argument)) {\n                        report(node.argument);\n                    }\n                }\n            },\n\n            ClassDeclaration: checkClass,\n            ClassExpression: checkClass,\n\n            SpreadElement: checkSpreadOperator,\n            SpreadProperty: checkSpreadOperator,\n            ExperimentalSpreadProperty: checkSpreadOperator,\n\n            TemplateLiteral(node) {\n                node.expressions\n                    .filter(e => e && hasExcessParens(e))\n                    .forEach(report);\n            },\n\n            AssignmentPattern(node) {\n                const { right } = node;\n\n                if (right && hasExcessParens(right) && precedence(right) >= PRECEDENCE_OF_ASSIGNMENT_EXPR) {\n                    report(right);\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noExtraSemi = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow unnecessary semicolons\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-extra-semi\"\n        },\n\n        fixable: \"code\",\n        schema: [],\n\n        messages: {\n            unexpected: \"Unnecessary semicolon.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Reports an unnecessary semicolon error.\n         * @param {Node|Token} nodeOrToken A node or a token to be reported.\n         * @returns {void}\n         */\n        function report(nodeOrToken) {\n            context.report({\n                node: nodeOrToken,\n                messageId: \"unexpected\",\n                fix(fixer) {\n\n                    /*\n                     * Expand the replacement range to include the surrounding\n                     * tokens to avoid conflicting with semi.\n                     * https://github.com/eslint/eslint/issues/7928\n                     */\n                    return new fixTracker(fixer, context.getSourceCode())\n                        .retainSurroundingTokens(nodeOrToken)\n                        .remove(nodeOrToken);\n                }\n            });\n        }\n\n        /**\n         * Checks for a part of a class body.\n         * This checks tokens from a specified token to a next MethodDefinition or the end of class body.\n         * @param {Token} firstToken The first token to check.\n         * @returns {void}\n         */\n        function checkForPartOfClassBody(firstToken) {\n            for (let token = firstToken;\n                token.type === \"Punctuator\" && !astUtils$1.isClosingBraceToken(token);\n                token = sourceCode.getTokenAfter(token)\n            ) {\n                if (astUtils$1.isSemicolonToken(token)) {\n                    report(token);\n                }\n            }\n        }\n\n        return {\n\n            /**\n             * Reports this empty statement, except if the parent node is a loop.\n             * @param {Node} node A EmptyStatement node to be reported.\n             * @returns {void}\n             */\n            EmptyStatement(node) {\n                const parent = node.parent,\n                    allowedParentTypes = [\n                        \"ForStatement\",\n                        \"ForInStatement\",\n                        \"ForOfStatement\",\n                        \"WhileStatement\",\n                        \"DoWhileStatement\",\n                        \"IfStatement\",\n                        \"LabeledStatement\",\n                        \"WithStatement\"\n                    ];\n\n                if (allowedParentTypes.indexOf(parent.type) === -1) {\n                    report(node);\n                }\n            },\n\n            /**\n             * Checks tokens from the head of this class body to the first MethodDefinition or the end of this class body.\n             * @param {Node} node A ClassBody node to check.\n             * @returns {void}\n             */\n            ClassBody(node) {\n                checkForPartOfClassBody(sourceCode.getFirstToken(node, 1)); // 0 is `{`.\n            },\n\n            /**\n             * Checks tokens from this MethodDefinition to the next MethodDefinition or the end of this class body.\n             * @param {Node} node A MethodDefinition node of the start point.\n             * @returns {void}\n             */\n            MethodDefinition(node) {\n                checkForPartOfClassBody(sourceCode.getTokenAfter(node));\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst DEFAULT_FALLTHROUGH_COMMENT = /falls?\\s?through/iu;\n\n/**\n * Checks whether or not a given node has a fallthrough comment.\n * @param {ASTNode} node A SwitchCase node to get comments.\n * @param {RuleContext} context A rule context which stores comments.\n * @param {RegExp} fallthroughCommentPattern A pattern to match comment to.\n * @returns {boolean} `true` if the node has a valid fallthrough comment.\n */\nfunction hasFallthroughComment(node, context, fallthroughCommentPattern) {\n    const sourceCode = context.getSourceCode();\n    const comment = lodash.last(sourceCode.getCommentsBefore(node));\n\n    return Boolean(comment && fallthroughCommentPattern.test(comment.value));\n}\n\n/**\n * Checks whether or not a given code path segment is reachable.\n * @param {CodePathSegment} segment A CodePathSegment to check.\n * @returns {boolean} `true` if the segment is reachable.\n */\nfunction isReachable$3(segment) {\n    return segment.reachable;\n}\n\n/**\n * Checks whether a node and a token are separated by blank lines\n * @param {ASTNode} node The node to check\n * @param {Token} token The token to compare against\n * @returns {boolean} `true` if there are blank lines between node and token\n */\nfunction hasBlankLinesBetween(node, token) {\n    return token.loc.start.line > node.loc.end.line + 1;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noFallthrough = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow fallthrough of `case` statements\",\n            category: \"Best Practices\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-fallthrough\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    commentPattern: {\n                        type: \"string\",\n                        default: \"\"\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n        messages: {\n            case: \"Expected a 'break' statement before 'case'.\",\n            default: \"Expected a 'break' statement before 'default'.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options[0] || {};\n        let currentCodePath = null;\n        const sourceCode = context.getSourceCode();\n\n        /*\n         * We need to use leading comments of the next SwitchCase node because\n         * trailing comments is wrong if semicolons are omitted.\n         */\n        let fallthroughCase = null;\n        let fallthroughCommentPattern = null;\n\n        if (options.commentPattern) {\n            fallthroughCommentPattern = new RegExp(options.commentPattern, \"u\");\n        } else {\n            fallthroughCommentPattern = DEFAULT_FALLTHROUGH_COMMENT;\n        }\n\n        return {\n            onCodePathStart(codePath) {\n                currentCodePath = codePath;\n            },\n            onCodePathEnd() {\n                currentCodePath = currentCodePath.upper;\n            },\n\n            SwitchCase(node) {\n\n                /*\n                 * Checks whether or not there is a fallthrough comment.\n                 * And reports the previous fallthrough node if that does not exist.\n                 */\n                if (fallthroughCase && !hasFallthroughComment(node, context, fallthroughCommentPattern)) {\n                    context.report({\n                        messageId: node.test ? \"case\" : \"default\",\n                        node\n                    });\n                }\n                fallthroughCase = null;\n            },\n\n            \"SwitchCase:exit\"(node) {\n                const nextToken = sourceCode.getTokenAfter(node);\n\n                /*\n                 * `reachable` meant fall through because statements preceded by\n                 * `break`, `return`, or `throw` are unreachable.\n                 * And allows empty cases and the last case.\n                 */\n                if (currentCodePath.currentSegments.some(isReachable$3) &&\n                    (node.consequent.length > 0 || hasBlankLinesBetween(node, nextToken)) &&\n                    lodash.last(node.parent.cases) !== node) {\n                    fallthroughCase = node;\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noFloatingDecimal = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow leading or trailing decimal points in numeric literals\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-floating-decimal\"\n        },\n\n        schema: [],\n        fixable: \"code\",\n        messages: {\n            leading: \"A leading decimal point can be confused with a dot.\",\n            trailing: \"A trailing decimal point can be confused with a dot.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        return {\n            Literal(node) {\n\n                if (typeof node.value === \"number\") {\n                    if (node.raw.startsWith(\".\")) {\n                        context.report({\n                            node,\n                            messageId: \"leading\",\n                            fix(fixer) {\n                                const tokenBefore = sourceCode.getTokenBefore(node);\n                                const needsSpaceBefore = tokenBefore &&\n                                    tokenBefore.range[1] === node.range[0] &&\n                                    !astUtils$1.canTokensBeAdjacent(tokenBefore, `0${node.raw}`);\n\n                                return fixer.insertTextBefore(node, needsSpaceBefore ? \" 0\" : \"0\");\n                            }\n                        });\n                    }\n                    if (node.raw.indexOf(\".\") === node.raw.length - 1) {\n                        context.report({\n                            node,\n                            messageId: \"trailing\",\n                            fix: fixer => fixer.insertTextAfter(node, \"0\")\n                        });\n                    }\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noFuncAssign = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow reassigning `function` declarations\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-func-assign\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        /**\n         * Reports a reference if is non initializer and writable.\n         * @param {References} references Collection of reference to check.\n         * @returns {void}\n         */\n        function checkReference(references) {\n            astUtils$1.getModifyingReferences(references).forEach(reference => {\n                context.report({ node: reference.identifier, message: \"'{{name}}' is a function.\", data: { name: reference.identifier.name } });\n            });\n        }\n\n        /**\n         * Finds and reports references that are non initializer and writable.\n         * @param {Variable} variable A variable to check.\n         * @returns {void}\n         */\n        function checkVariable(variable) {\n            if (variable.defs[0].type === \"FunctionName\") {\n                checkReference(variable.references);\n            }\n        }\n\n        /**\n         * Checks parameters of a given function node.\n         * @param {ASTNode} node A function node to check.\n         * @returns {void}\n         */\n        function checkForFunction(node) {\n            context.getDeclaredVariables(node).forEach(checkVariable);\n        }\n\n        return {\n            FunctionDeclaration: checkForFunction,\n            FunctionExpression: checkForFunction\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to disallow assignments to native objects or read-only global variables\n * @author Ilya Volodin\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noGlobalAssign = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow assignments to native objects or read-only global variables\",\n            category: \"Best Practices\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-global-assign\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    exceptions: {\n                        type: \"array\",\n                        items: { type: \"string\" },\n                        uniqueItems: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const config = context.options[0];\n        const exceptions = (config && config.exceptions) || [];\n\n        /**\n         * Reports write references.\n         * @param {Reference} reference A reference to check.\n         * @param {int} index The index of the reference in the references.\n         * @param {Reference[]} references The array that the reference belongs to.\n         * @returns {void}\n         */\n        function checkReference(reference, index, references) {\n            const identifier = reference.identifier;\n\n            if (reference.init === false &&\n                reference.isWrite() &&\n\n                /*\n                 * Destructuring assignments can have multiple default value,\n                 * so possibly there are multiple writeable references for the same identifier.\n                 */\n                (index === 0 || references[index - 1].identifier !== identifier)\n            ) {\n                context.report({\n                    node: identifier,\n                    message: \"Read-only global '{{name}}' should not be modified.\",\n                    data: identifier\n                });\n            }\n        }\n\n        /**\n         * Reports write references if a given variable is read-only builtin.\n         * @param {Variable} variable A variable to check.\n         * @returns {void}\n         */\n        function checkVariable(variable) {\n            if (variable.writeable === false && exceptions.indexOf(variable.name) === -1) {\n                variable.references.forEach(checkReference);\n            }\n        }\n\n        return {\n            Program() {\n                const globalScope = context.getScope();\n\n                globalScope.variables.forEach(checkVariable);\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst INDEX_OF_PATTERN = /^(?:i|lastI)ndexOf$/u;\nconst ALLOWABLE_OPERATORS = [\"~\", \"!!\", \"+\", \"*\"];\n\n/**\n * Parses and normalizes an option object.\n * @param {Object} options An option object to parse.\n * @returns {Object} The parsed and normalized option object.\n */\nfunction parseOptions(options) {\n    return {\n        boolean: \"boolean\" in options ? options.boolean : true,\n        number: \"number\" in options ? options.number : true,\n        string: \"string\" in options ? options.string : true,\n        allow: options.allow || []\n    };\n}\n\n/**\n * Checks whether or not a node is a double logical nigating.\n * @param {ASTNode} node An UnaryExpression node to check.\n * @returns {boolean} Whether or not the node is a double logical nigating.\n */\nfunction isDoubleLogicalNegating(node) {\n    return (\n        node.operator === \"!\" &&\n        node.argument.type === \"UnaryExpression\" &&\n        node.argument.operator === \"!\"\n    );\n}\n\n/**\n * Checks whether or not a node is a binary negating of `.indexOf()` method calling.\n * @param {ASTNode} node An UnaryExpression node to check.\n * @returns {boolean} Whether or not the node is a binary negating of `.indexOf()` method calling.\n */\nfunction isBinaryNegatingOfIndexOf(node) {\n    return (\n        node.operator === \"~\" &&\n        node.argument.type === \"CallExpression\" &&\n        node.argument.callee.type === \"MemberExpression\" &&\n        node.argument.callee.property.type === \"Identifier\" &&\n        INDEX_OF_PATTERN.test(node.argument.callee.property.name)\n    );\n}\n\n/**\n * Checks whether or not a node is a multiplying by one.\n * @param {BinaryExpression} node A BinaryExpression node to check.\n * @returns {boolean} Whether or not the node is a multiplying by one.\n */\nfunction isMultiplyByOne(node) {\n    return node.operator === \"*\" && (\n        node.left.type === \"Literal\" && node.left.value === 1 ||\n        node.right.type === \"Literal\" && node.right.value === 1\n    );\n}\n\n/**\n * Checks whether the result of a node is numeric or not\n * @param {ASTNode} node The node to test\n * @returns {boolean} true if the node is a number literal or a `Number()`, `parseInt` or `parseFloat` call\n */\nfunction isNumeric(node) {\n    return (\n        node.type === \"Literal\" && typeof node.value === \"number\" ||\n        node.type === \"CallExpression\" && (\n            node.callee.name === \"Number\" ||\n            node.callee.name === \"parseInt\" ||\n            node.callee.name === \"parseFloat\"\n        )\n    );\n}\n\n/**\n * Returns the first non-numeric operand in a BinaryExpression. Designed to be\n * used from bottom to up since it walks up the BinaryExpression trees using\n * node.parent to find the result.\n * @param {BinaryExpression} node The BinaryExpression node to be walked up on\n * @returns {ASTNode|null} The first non-numeric item in the BinaryExpression tree or null\n */\nfunction getNonNumericOperand(node) {\n    const left = node.left,\n        right = node.right;\n\n    if (right.type !== \"BinaryExpression\" && !isNumeric(right)) {\n        return right;\n    }\n\n    if (left.type !== \"BinaryExpression\" && !isNumeric(left)) {\n        return left;\n    }\n\n    return null;\n}\n\n/**\n * Checks whether a node is an empty string literal or not.\n * @param {ASTNode} node The node to check.\n * @returns {boolean} Whether or not the passed in node is an\n * empty string literal or not.\n */\nfunction isEmptyString(node) {\n    return astUtils$1.isStringLiteral(node) && (node.value === \"\" || (node.type === \"TemplateLiteral\" && node.quasis.length === 1 && node.quasis[0].value.cooked === \"\"));\n}\n\n/**\n * Checks whether or not a node is a concatenating with an empty string.\n * @param {ASTNode} node A BinaryExpression node to check.\n * @returns {boolean} Whether or not the node is a concatenating with an empty string.\n */\nfunction isConcatWithEmptyString(node) {\n    return node.operator === \"+\" && (\n        (isEmptyString(node.left) && !astUtils$1.isStringLiteral(node.right)) ||\n        (isEmptyString(node.right) && !astUtils$1.isStringLiteral(node.left))\n    );\n}\n\n/**\n * Checks whether or not a node is appended with an empty string.\n * @param {ASTNode} node An AssignmentExpression node to check.\n * @returns {boolean} Whether or not the node is appended with an empty string.\n */\nfunction isAppendEmptyString(node) {\n    return node.operator === \"+=\" && isEmptyString(node.right);\n}\n\n/**\n * Returns the operand that is not an empty string from a flagged BinaryExpression.\n * @param {ASTNode} node The flagged BinaryExpression node to check.\n * @returns {ASTNode} The operand that is not an empty string from a flagged BinaryExpression.\n */\nfunction getNonEmptyOperand(node) {\n    return isEmptyString(node.left) ? node.right : node.left;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noImplicitCoercion = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow shorthand type conversions\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-implicit-coercion\"\n        },\n\n        fixable: \"code\",\n\n        schema: [{\n            type: \"object\",\n            properties: {\n                boolean: {\n                    type: \"boolean\",\n                    default: true\n                },\n                number: {\n                    type: \"boolean\",\n                    default: true\n                },\n                string: {\n                    type: \"boolean\",\n                    default: true\n                },\n                allow: {\n                    type: \"array\",\n                    items: {\n                        enum: ALLOWABLE_OPERATORS\n                    },\n                    uniqueItems: true\n                }\n            },\n            additionalProperties: false\n        }]\n    },\n\n    create(context) {\n        const options = parseOptions(context.options[0] || {});\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Reports an error and autofixes the node\n         * @param {ASTNode} node An ast node to report the error on.\n         * @param {string} recommendation The recommended code for the issue\n         * @param {bool} shouldFix Whether this report should fix the node\n         * @returns {void}\n         */\n        function report(node, recommendation, shouldFix) {\n            context.report({\n                node,\n                message: \"use `{{recommendation}}` instead.\",\n                data: {\n                    recommendation\n                },\n                fix(fixer) {\n                    if (!shouldFix) {\n                        return null;\n                    }\n\n                    const tokenBefore = sourceCode.getTokenBefore(node);\n\n                    if (\n                        tokenBefore &&\n                        tokenBefore.range[1] === node.range[0] &&\n                        !astUtils$1.canTokensBeAdjacent(tokenBefore, recommendation)\n                    ) {\n                        return fixer.replaceText(node, ` ${recommendation}`);\n                    }\n                    return fixer.replaceText(node, recommendation);\n                }\n            });\n        }\n\n        return {\n            UnaryExpression(node) {\n                let operatorAllowed;\n\n                // !!foo\n                operatorAllowed = options.allow.indexOf(\"!!\") >= 0;\n                if (!operatorAllowed && options.boolean && isDoubleLogicalNegating(node)) {\n                    const recommendation = `Boolean(${sourceCode.getText(node.argument.argument)})`;\n\n                    report(node, recommendation, true);\n                }\n\n                // ~foo.indexOf(bar)\n                operatorAllowed = options.allow.indexOf(\"~\") >= 0;\n                if (!operatorAllowed && options.boolean && isBinaryNegatingOfIndexOf(node)) {\n                    const recommendation = `${sourceCode.getText(node.argument)} !== -1`;\n\n                    report(node, recommendation, false);\n                }\n\n                // +foo\n                operatorAllowed = options.allow.indexOf(\"+\") >= 0;\n                if (!operatorAllowed && options.number && node.operator === \"+\" && !isNumeric(node.argument)) {\n                    const recommendation = `Number(${sourceCode.getText(node.argument)})`;\n\n                    report(node, recommendation, true);\n                }\n            },\n\n            // Use `:exit` to prevent double reporting\n            \"BinaryExpression:exit\"(node) {\n                let operatorAllowed;\n\n                // 1 * foo\n                operatorAllowed = options.allow.indexOf(\"*\") >= 0;\n                const nonNumericOperand = !operatorAllowed && options.number && isMultiplyByOne(node) && getNonNumericOperand(node);\n\n                if (nonNumericOperand) {\n                    const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;\n\n                    report(node, recommendation, true);\n                }\n\n                // \"\" + foo\n                operatorAllowed = options.allow.indexOf(\"+\") >= 0;\n                if (!operatorAllowed && options.string && isConcatWithEmptyString(node)) {\n                    const recommendation = `String(${sourceCode.getText(getNonEmptyOperand(node))})`;\n\n                    report(node, recommendation, true);\n                }\n            },\n\n            AssignmentExpression(node) {\n\n                // foo += \"\"\n                const operatorAllowed = options.allow.indexOf(\"+\") >= 0;\n\n                if (!operatorAllowed && options.string && isAppendEmptyString(node)) {\n                    const code = sourceCode.getText(getNonEmptyOperand(node));\n                    const recommendation = `${code} = String(${code})`;\n\n                    report(node, recommendation, true);\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to check for implicit global variables, functions and classes.\n * @author Joshua Peek\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noImplicitGlobals = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow declarations in the global scope\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-implicit-globals\"\n        },\n\n        schema: [{\n            type: \"object\",\n            properties: {\n                lexicalBindings: {\n                    type: \"boolean\",\n                    default: false\n                }\n            },\n            additionalProperties: false\n        }],\n\n        messages: {\n            globalNonLexicalBinding: \"Unexpected {{kind}} declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable.\",\n            globalLexicalBinding: \"Unexpected {{kind}} declaration in the global scope, wrap in a block or in an IIFE.\",\n            globalVariableLeak: \"Global variable leak, declare the variable if it is intended to be local.\",\n            assignmentToReadonlyGlobal: \"Unexpected assignment to read-only global variable.\",\n            redeclarationOfReadonlyGlobal: \"Unexpected redeclaration of read-only global variable.\"\n        }\n    },\n\n    create(context) {\n\n        const checkLexicalBindings = context.options[0] && context.options[0].lexicalBindings === true;\n\n        /**\n         * Reports the node.\n         * @param {ASTNode} node Node to report.\n         * @param {string} messageId Id of the message to report.\n         * @param {string|undefined} kind Declaration kind, can be 'var', 'const', 'let', function or class.\n         * @returns {void}\n         */\n        function report(node, messageId, kind) {\n            context.report({\n                node,\n                messageId,\n                data: {\n                    kind\n                }\n            });\n        }\n\n        return {\n            Program() {\n                const scope = context.getScope();\n\n                scope.variables.forEach(variable => {\n\n                    // Only ESLint global variables have the `writable` key.\n                    const isReadonlyEslintGlobalVariable = variable.writeable === false;\n                    const isWritableEslintGlobalVariable = variable.writeable === true;\n\n                    if (isWritableEslintGlobalVariable) {\n\n                        // Everything is allowed with writable ESLint global variables.\n                        return;\n                    }\n\n                    variable.defs.forEach(def => {\n                        const defNode = def.node;\n\n                        if (def.type === \"FunctionName\" || (def.type === \"Variable\" && def.parent.kind === \"var\")) {\n                            if (isReadonlyEslintGlobalVariable) {\n                                report(defNode, \"redeclarationOfReadonlyGlobal\");\n                            } else {\n                                report(\n                                    defNode,\n                                    \"globalNonLexicalBinding\",\n                                    def.type === \"FunctionName\" ? \"function\" : `'${def.parent.kind}'`\n                                );\n                            }\n                        }\n\n                        if (checkLexicalBindings) {\n                            if (def.type === \"ClassName\" ||\n                                    (def.type === \"Variable\" && (def.parent.kind === \"let\" || def.parent.kind === \"const\"))) {\n                                if (isReadonlyEslintGlobalVariable) {\n                                    report(defNode, \"redeclarationOfReadonlyGlobal\");\n                                } else {\n                                    report(\n                                        defNode,\n                                        \"globalLexicalBinding\",\n                                        def.type === \"ClassName\" ? \"class\" : `'${def.parent.kind}'`\n                                    );\n                                }\n                            }\n                        }\n                    });\n                });\n\n                // Undeclared assigned variables.\n                scope.implicit.variables.forEach(variable => {\n                    const scopeVariable = scope.set.get(variable.name);\n                    let messageId;\n\n                    if (scopeVariable) {\n\n                        // ESLint global variable\n                        if (scopeVariable.writeable) {\n                            return;\n                        }\n                        messageId = \"assignmentToReadonlyGlobal\";\n\n                    } else {\n\n                        // Reference to an unknown variable, possible global leak.\n                        messageId = \"globalVariableLeak\";\n                    }\n\n                    // def.node is an AssignmentExpression, ForInStatement or ForOfStatement.\n                    variable.defs.forEach(def => {\n                        report(def.node, messageId);\n                    });\n                });\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag use of implied eval via setTimeout and setInterval\n * @author James Allardice\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noImpliedEval = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow the use of `eval()`-like methods\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-implied-eval\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        const CALLEE_RE = /^(setTimeout|setInterval|execScript)$/u;\n\n        /*\n         * Figures out if we should inspect a given binary expression. Is a stack\n         * of stacks, where the first element in each substack is a CallExpression.\n         */\n        const impliedEvalAncestorsStack = [];\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Get the last element of an array, without modifying arr, like pop(), but non-destructive.\n         * @param {Array} arr What to inspect\n         * @returns {*} The last element of arr\n         * @private\n         */\n        function last(arr) {\n            return arr ? arr[arr.length - 1] : null;\n        }\n\n        /**\n         * Checks if the given MemberExpression node is a potentially implied eval identifier on window.\n         * @param {ASTNode} node The MemberExpression node to check.\n         * @returns {boolean} Whether or not the given node is potentially an implied eval.\n         * @private\n         */\n        function isImpliedEvalMemberExpression(node) {\n            const object = node.object,\n                property = node.property,\n                hasImpliedEvalName = CALLEE_RE.test(property.name) || CALLEE_RE.test(property.value);\n\n            return object.name === \"window\" && hasImpliedEvalName;\n        }\n\n        /**\n         * Determines if a node represents a call to a potentially implied eval.\n         *\n         * This checks the callee name and that there's an argument, but not the type of the argument.\n         * @param {ASTNode} node The CallExpression to check.\n         * @returns {boolean} True if the node matches, false if not.\n         * @private\n         */\n        function isImpliedEvalCallExpression(node) {\n            const isMemberExpression = (node.callee.type === \"MemberExpression\"),\n                isIdentifier = (node.callee.type === \"Identifier\"),\n                isImpliedEvalCallee =\n                    (isIdentifier && CALLEE_RE.test(node.callee.name)) ||\n                    (isMemberExpression && isImpliedEvalMemberExpression(node.callee));\n\n            return isImpliedEvalCallee && node.arguments.length;\n        }\n\n        /**\n         * Checks that the parent is a direct descendent of an potential implied eval CallExpression, and if the parent is a CallExpression, that we're the first argument.\n         * @param {ASTNode} node The node to inspect the parent of.\n         * @returns {boolean} Was the parent a direct descendent, and is the child therefore potentially part of a dangerous argument?\n         * @private\n         */\n        function hasImpliedEvalParent(node) {\n\n            // make sure our parent is marked\n            return node.parent === last(last(impliedEvalAncestorsStack)) &&\n\n                // if our parent is a CallExpression, make sure we're the first argument\n                (node.parent.type !== \"CallExpression\" || node === node.parent.arguments[0]);\n        }\n\n        /**\n         * Checks if our parent is marked as part of an implied eval argument. If\n         * so, collapses the top of impliedEvalAncestorsStack and reports on the\n         * original CallExpression.\n         * @param {ASTNode} node The CallExpression to check.\n         * @returns {boolean} True if the node matches, false if not.\n         * @private\n         */\n        function checkString(node) {\n            if (hasImpliedEvalParent(node)) {\n\n                // remove the entire substack, to avoid duplicate reports\n                const substack = impliedEvalAncestorsStack.pop();\n\n                context.report({ node: substack[0], message: \"Implied eval. Consider passing a function instead of a string.\" });\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            CallExpression(node) {\n                if (isImpliedEvalCallExpression(node)) {\n\n                    // call expressions create a new substack\n                    impliedEvalAncestorsStack.push([node]);\n                }\n            },\n\n            \"CallExpression:exit\"(node) {\n                if (node === last(last(impliedEvalAncestorsStack))) {\n\n                    /*\n                     * Destroys the entire sub-stack, rather than just using\n                     * last(impliedEvalAncestorsStack).pop(), as a CallExpression is\n                     * always the bottom of a impliedEvalAncestorsStack substack.\n                     */\n                    impliedEvalAncestorsStack.pop();\n                }\n            },\n\n            BinaryExpression(node) {\n                if (node.operator === \"+\" && hasImpliedEvalParent(node)) {\n                    last(impliedEvalAncestorsStack).push(node);\n                }\n            },\n\n            \"BinaryExpression:exit\"(node) {\n                if (node === last(last(impliedEvalAncestorsStack))) {\n                    last(impliedEvalAncestorsStack).pop();\n                }\n            },\n\n            Literal(node) {\n                if (typeof node.value === \"string\") {\n                    checkString(node);\n                }\n            },\n\n            TemplateLiteral(node) {\n                checkString(node);\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst { findVariable: findVariable$1, getPropertyName: getPropertyName$2 } = require$$0$2;\n\nconst MutationMethods = {\n    Object: new Set([\n        \"assign\", \"defineProperties\", \"defineProperty\", \"freeze\",\n        \"setPrototypeOf\"\n    ]),\n    Reflect: new Set([\n        \"defineProperty\", \"deleteProperty\", \"set\", \"setPrototypeOf\"\n    ])\n};\n\n/**\n * Check if a given node is LHS of an assignment node.\n * @param {ASTNode} node The node to check.\n * @returns {boolean} `true` if the node is LHS.\n */\nfunction isAssignmentLeft(node) {\n    const { parent } = node;\n\n    return (\n        (\n            parent.type === \"AssignmentExpression\" &&\n            parent.left === node\n        ) ||\n\n        // Destructuring assignments\n        parent.type === \"ArrayPattern\" ||\n        (\n            parent.type === \"Property\" &&\n            parent.value === node &&\n            parent.parent.type === \"ObjectPattern\"\n        ) ||\n        parent.type === \"RestElement\" ||\n        (\n            parent.type === \"AssignmentPattern\" &&\n            parent.left === node\n        )\n    );\n}\n\n/**\n * Check if a given node is the operand of mutation unary operator.\n * @param {ASTNode} node The node to check.\n * @returns {boolean} `true` if the node is the operand of mutation unary operator.\n */\nfunction isOperandOfMutationUnaryOperator(node) {\n    const { parent } = node;\n\n    return (\n        (\n            parent.type === \"UpdateExpression\" &&\n            parent.argument === node\n        ) ||\n        (\n            parent.type === \"UnaryExpression\" &&\n            parent.operator === \"delete\" &&\n            parent.argument === node\n        )\n    );\n}\n\n/**\n * Check if a given node is the iteration variable of `for-in`/`for-of` syntax.\n * @param {ASTNode} node The node to check.\n * @returns {boolean} `true` if the node is the iteration variable.\n */\nfunction isIterationVariable(node) {\n    const { parent } = node;\n\n    return (\n        (\n            parent.type === \"ForInStatement\" &&\n            parent.left === node\n        ) ||\n        (\n            parent.type === \"ForOfStatement\" &&\n            parent.left === node\n        )\n    );\n}\n\n/**\n * Check if a given node is the iteration variable of `for-in`/`for-of` syntax.\n * @param {ASTNode} node The node to check.\n * @param {Scope} scope A `escope.Scope` object to find variable (whichever).\n * @returns {boolean} `true` if the node is the iteration variable.\n */\nfunction isArgumentOfWellKnownMutationFunction(node, scope) {\n    const { parent } = node;\n\n    if (\n        parent.type === \"CallExpression\" &&\n        parent.arguments[0] === node &&\n        parent.callee.type === \"MemberExpression\" &&\n        parent.callee.object.type === \"Identifier\"\n    ) {\n        const { callee } = parent;\n        const { object } = callee;\n\n        if (Object.keys(MutationMethods).includes(object.name)) {\n            const variable = findVariable$1(scope, object);\n\n            return (\n                variable !== null &&\n                variable.scope.type === \"global\" &&\n                MutationMethods[object.name].has(getPropertyName$2(callee, scope))\n            );\n        }\n    }\n\n    return false;\n}\n\n/**\n * Check if the identifier node is placed at to update members.\n * @param {ASTNode} id The Identifier node to check.\n * @param {Scope} scope A `escope.Scope` object to find variable (whichever).\n * @returns {boolean} `true` if the member of `id` was updated.\n */\nfunction isMemberWrite(id, scope) {\n    const { parent } = id;\n\n    return (\n        (\n            parent.type === \"MemberExpression\" &&\n            parent.object === id &&\n            (\n                isAssignmentLeft(parent) ||\n                isOperandOfMutationUnaryOperator(parent) ||\n                isIterationVariable(parent)\n            )\n        ) ||\n        isArgumentOfWellKnownMutationFunction(id, scope)\n    );\n}\n\n/**\n * Get the mutation node.\n * @param {ASTNode} id The Identifier node to get.\n * @returns {ASTNode} The mutation node.\n */\nfunction getWriteNode(id) {\n    let node = id.parent;\n\n    while (\n        node &&\n        node.type !== \"AssignmentExpression\" &&\n        node.type !== \"UpdateExpression\" &&\n        node.type !== \"UnaryExpression\" &&\n        node.type !== \"CallExpression\" &&\n        node.type !== \"ForInStatement\" &&\n        node.type !== \"ForOfStatement\"\n    ) {\n        node = node.parent;\n    }\n\n    return node || id;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noImportAssign = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow assigning to imported bindings\",\n            category: \"Possible Errors\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-import-assign\"\n        },\n\n        schema: [],\n\n        messages: {\n            readonly: \"'{{name}}' is read-only.\",\n            readonlyMember: \"The members of '{{name}}' are read-only.\"\n        }\n    },\n\n    create(context) {\n        return {\n            ImportDeclaration(node) {\n                const scope = context.getScope();\n\n                for (const variable of context.getDeclaredVariables(node)) {\n                    const shouldCheckMembers = variable.defs.some(\n                        d => d.node.type === \"ImportNamespaceSpecifier\"\n                    );\n                    let prevIdNode = null;\n\n                    for (const reference of variable.references) {\n                        const idNode = reference.identifier;\n\n                        /*\n                         * AssignmentPattern (e.g. `[a = 0] = b`) makes two write\n                         * references for the same identifier. This should skip\n                         * the one of the two in order to prevent redundant reports.\n                         */\n                        if (idNode === prevIdNode) {\n                            continue;\n                        }\n                        prevIdNode = idNode;\n\n                        if (reference.isWrite()) {\n                            context.report({\n                                node: getWriteNode(idNode),\n                                messageId: \"readonly\",\n                                data: { name: idNode.name }\n                            });\n                        } else if (shouldCheckMembers && isMemberWrite(idNode, scope)) {\n                            context.report({\n                                node: getWriteNode(idNode),\n                                messageId: \"readonlyMember\",\n                                data: { name: idNode.name }\n                            });\n                        }\n                    }\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noInlineComments = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow inline comments after code\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-inline-comments\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Will check that comments are not on lines starting with or ending with code\n         * @param {ASTNode} node The comment node to check\n         * @private\n         * @returns {void}\n         */\n        function testCodeAroundComment(node) {\n\n            const startLine = String(sourceCode.lines[node.loc.start.line - 1]),\n                endLine = String(sourceCode.lines[node.loc.end.line - 1]),\n                preamble = startLine.slice(0, node.loc.start.column).trim(),\n                postamble = endLine.slice(node.loc.end.column).trim(),\n                isPreambleEmpty = !preamble,\n                isPostambleEmpty = !postamble;\n\n            // Nothing on both sides\n            if (isPreambleEmpty && isPostambleEmpty) {\n                return;\n            }\n\n            // JSX Exception\n            if (\n                (isPreambleEmpty || preamble === \"{\") &&\n                (isPostambleEmpty || postamble === \"}\")\n            ) {\n                const enclosingNode = sourceCode.getNodeByRangeIndex(node.range[0]);\n\n                if (enclosingNode && enclosingNode.type === \"JSXEmptyExpression\") {\n                    return;\n                }\n            }\n\n            // Don't report ESLint directive comments\n            if (astUtils$1.isDirectiveComment(node)) {\n                return;\n            }\n\n            context.report({ node, message: \"Unexpected comment inline with code.\" });\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            Program() {\n                const comments = sourceCode.getAllComments();\n\n                comments.filter(token => token.type !== \"Shebang\").forEach(testCodeAroundComment);\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to enforce declarations in program or function body root.\n * @author Brandon Mills\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noInnerDeclarations = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow variable or `function` declarations in nested blocks\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-inner-declarations\"\n        },\n\n        schema: [\n            {\n                enum: [\"functions\", \"both\"]\n            }\n        ]\n    },\n\n    create(context) {\n\n        /**\n         * Find the nearest Program or Function ancestor node.\n         * @returns {Object} Ancestor's type and distance from node.\n         */\n        function nearestBody() {\n            const ancestors = context.getAncestors();\n            let ancestor = ancestors.pop(),\n                generation = 1;\n\n            while (ancestor && [\"Program\", \"FunctionDeclaration\",\n                \"FunctionExpression\", \"ArrowFunctionExpression\"\n            ].indexOf(ancestor.type) < 0) {\n                generation += 1;\n                ancestor = ancestors.pop();\n            }\n\n            return {\n\n                // Type of containing ancestor\n                type: ancestor.type,\n\n                // Separation between ancestor and node\n                distance: generation\n            };\n        }\n\n        /**\n         * Ensure that a given node is at a program or function body's root.\n         * @param {ASTNode} node Declaration node to check.\n         * @returns {void}\n         */\n        function check(node) {\n            const body = nearestBody(),\n                valid = ((body.type === \"Program\" && body.distance === 1) ||\n                    body.distance === 2);\n\n            if (!valid) {\n                context.report({\n                    node,\n                    message: \"Move {{type}} declaration to {{body}} root.\",\n                    data: {\n                        type: (node.type === \"FunctionDeclaration\" ? \"function\" : \"variable\"),\n                        body: (body.type === \"Program\" ? \"program\" : \"function body\")\n                    }\n                });\n            }\n        }\n\n        return {\n\n            FunctionDeclaration: check,\n            VariableDeclaration(node) {\n                if (context.options[0] === \"both\" && node.kind === \"var\") {\n                    check(node);\n                }\n            }\n\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nconst RegExpValidator$2 = regexpp$1.RegExpValidator;\nconst validator = new RegExpValidator$2({ ecmaVersion: 2018 });\nconst validFlags = /[gimuys]/gu;\nconst undefined1 = void 0;\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noInvalidRegexp = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow invalid regular expression strings in `RegExp` constructors\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-invalid-regexp\"\n        },\n\n        schema: [{\n            type: \"object\",\n            properties: {\n                allowConstructorFlags: {\n                    type: \"array\",\n                    items: {\n                        type: \"string\"\n                    }\n                }\n            },\n            additionalProperties: false\n        }]\n    },\n\n    create(context) {\n\n        const options = context.options[0];\n        let allowedFlags = null;\n\n        if (options && options.allowConstructorFlags) {\n            const temp = options.allowConstructorFlags.join(\"\").replace(validFlags, \"\");\n\n            if (temp) {\n                allowedFlags = new RegExp(`[${temp}]`, \"giu\");\n            }\n        }\n\n        /**\n         * Check if node is a string\n         * @param {ASTNode} node node to evaluate\n         * @returns {boolean} True if its a string\n         * @private\n         */\n        function isString(node) {\n            return node && node.type === \"Literal\" && typeof node.value === \"string\";\n        }\n\n        /**\n         * Check syntax error in a given pattern.\n         * @param {string} pattern The RegExp pattern to validate.\n         * @param {boolean} uFlag The Unicode flag.\n         * @returns {string|null} The syntax error.\n         */\n        function validateRegExpPattern(pattern, uFlag) {\n            try {\n                validator.validatePattern(pattern, undefined1, undefined1, uFlag);\n                return null;\n            } catch (err) {\n                return err.message;\n            }\n        }\n\n        /**\n         * Check syntax error in a given flags.\n         * @param {string} flags The RegExp flags to validate.\n         * @returns {string|null} The syntax error.\n         */\n        function validateRegExpFlags(flags) {\n            try {\n                validator.validateFlags(flags);\n                return null;\n            } catch (err) {\n                return `Invalid flags supplied to RegExp constructor '${flags}'`;\n            }\n        }\n\n        return {\n            \"CallExpression, NewExpression\"(node) {\n                if (node.callee.type !== \"Identifier\" || node.callee.name !== \"RegExp\" || !isString(node.arguments[0])) {\n                    return;\n                }\n                const pattern = node.arguments[0].value;\n                let flags = isString(node.arguments[1]) ? node.arguments[1].value : \"\";\n\n                if (allowedFlags) {\n                    flags = flags.replace(allowedFlags, \"\");\n                }\n\n                // If flags are unknown, check both are errored or not.\n                const message = validateRegExpFlags(flags) || (\n                    flags\n                        ? validateRegExpPattern(pattern, flags.indexOf(\"u\") !== -1)\n                        : validateRegExpPattern(pattern, true) && validateRegExpPattern(pattern, false)\n                );\n\n                if (message) {\n                    context.report({\n                        node,\n                        message: \"{{message}}.\",\n                        data: { message }\n                    });\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noInvalidThis = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `this` keywords outside of classes or class-like objects\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-invalid-this\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    capIsConstructor: {\n                        type: \"boolean\",\n                        default: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const options = context.options[0] || {};\n        const capIsConstructor = options.capIsConstructor !== false;\n        const stack = [],\n            sourceCode = context.getSourceCode();\n\n        /**\n         * Gets the current checking context.\n         *\n         * The return value has a flag that whether or not `this` keyword is valid.\n         * The flag is initialized when got at the first time.\n         * @returns {{valid: boolean}}\n         *   an object which has a flag that whether or not `this` keyword is valid.\n         */\n        stack.getCurrent = function() {\n            const current = this[this.length - 1];\n\n            if (!current.init) {\n                current.init = true;\n                current.valid = !astUtils$1.isDefaultThisBinding(\n                    current.node,\n                    sourceCode,\n                    { capIsConstructor }\n                );\n            }\n            return current;\n        };\n\n        /**\n         * Pushs new checking context into the stack.\n         *\n         * The checking context is not initialized yet.\n         * Because most functions don't have `this` keyword.\n         * When `this` keyword was found, the checking context is initialized.\n         * @param {ASTNode} node A function node that was entered.\n         * @returns {void}\n         */\n        function enterFunction(node) {\n\n            // `this` can be invalid only under strict mode.\n            stack.push({\n                init: !context.getScope().isStrict,\n                node,\n                valid: true\n            });\n        }\n\n        /**\n         * Pops the current checking context from the stack.\n         * @returns {void}\n         */\n        function exitFunction() {\n            stack.pop();\n        }\n\n        return {\n\n            /*\n             * `this` is invalid only under strict mode.\n             * Modules is always strict mode.\n             */\n            Program(node) {\n                const scope = context.getScope(),\n                    features = context.parserOptions.ecmaFeatures || {};\n\n                stack.push({\n                    init: true,\n                    node,\n                    valid: !(\n                        scope.isStrict ||\n                        node.sourceType === \"module\" ||\n                        (features.globalReturn && scope.childScopes[0].isStrict)\n                    )\n                });\n            },\n\n            \"Program:exit\"() {\n                stack.pop();\n            },\n\n            FunctionDeclaration: enterFunction,\n            \"FunctionDeclaration:exit\": exitFunction,\n            FunctionExpression: enterFunction,\n            \"FunctionExpression:exit\": exitFunction,\n\n            // Reports if `this` of the current context is invalid.\n            ThisExpression(node) {\n                const current = stack.getCurrent();\n\n                if (current && !current.valid) {\n                    context.report({ node, message: \"Unexpected 'this'.\" });\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Constants\n//------------------------------------------------------------------------------\n\nconst ALL_IRREGULARS = /[\\f\\v\\u0085\\ufeff\\u00a0\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u200b\\u202f\\u205f\\u3000\\u2028\\u2029]/u;\nconst IRREGULAR_WHITESPACE = /[\\f\\v\\u0085\\ufeff\\u00a0\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u200b\\u202f\\u205f\\u3000]+/mgu;\nconst IRREGULAR_LINE_TERMINATORS = /[\\u2028\\u2029]/mgu;\nconst LINE_BREAK = astUtils$1.createGlobalLinebreakMatcher();\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noIrregularWhitespace = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow irregular whitespace\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-irregular-whitespace\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    skipComments: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    skipStrings: {\n                        type: \"boolean\",\n                        default: true\n                    },\n                    skipTemplates: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    skipRegExps: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n\n        // Module store of errors that we have found\n        let errors = [];\n\n        // Lookup the `skipComments` option, which defaults to `false`.\n        const options = context.options[0] || {};\n        const skipComments = !!options.skipComments;\n        const skipStrings = options.skipStrings !== false;\n        const skipRegExps = !!options.skipRegExps;\n        const skipTemplates = !!options.skipTemplates;\n\n        const sourceCode = context.getSourceCode();\n        const commentNodes = sourceCode.getAllComments();\n\n        /**\n         * Removes errors that occur inside a string node\n         * @param {ASTNode} node to check for matching errors.\n         * @returns {void}\n         * @private\n         */\n        function removeWhitespaceError(node) {\n            const locStart = node.loc.start;\n            const locEnd = node.loc.end;\n\n            errors = errors.filter(({ loc: errorLoc }) => {\n                if (errorLoc.line >= locStart.line && errorLoc.line <= locEnd.line) {\n                    if (errorLoc.column >= locStart.column && (errorLoc.column <= locEnd.column || errorLoc.line < locEnd.line)) {\n                        return false;\n                    }\n                }\n                return true;\n            });\n        }\n\n        /**\n         * Checks identifier or literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors\n         * @param {ASTNode} node to check for matching errors.\n         * @returns {void}\n         * @private\n         */\n        function removeInvalidNodeErrorsInIdentifierOrLiteral(node) {\n            const shouldCheckStrings = skipStrings && (typeof node.value === \"string\");\n            const shouldCheckRegExps = skipRegExps && Boolean(node.regex);\n\n            if (shouldCheckStrings || shouldCheckRegExps) {\n\n                // If we have irregular characters remove them from the errors list\n                if (ALL_IRREGULARS.test(node.raw)) {\n                    removeWhitespaceError(node);\n                }\n            }\n        }\n\n        /**\n         * Checks template string literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors\n         * @param {ASTNode} node to check for matching errors.\n         * @returns {void}\n         * @private\n         */\n        function removeInvalidNodeErrorsInTemplateLiteral(node) {\n            if (typeof node.value.raw === \"string\") {\n                if (ALL_IRREGULARS.test(node.value.raw)) {\n                    removeWhitespaceError(node);\n                }\n            }\n        }\n\n        /**\n         * Checks comment nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors\n         * @param {ASTNode} node to check for matching errors.\n         * @returns {void}\n         * @private\n         */\n        function removeInvalidNodeErrorsInComment(node) {\n            if (ALL_IRREGULARS.test(node.value)) {\n                removeWhitespaceError(node);\n            }\n        }\n\n        /**\n         * Checks the program source for irregular whitespace\n         * @param {ASTNode} node The program node\n         * @returns {void}\n         * @private\n         */\n        function checkForIrregularWhitespace(node) {\n            const sourceLines = sourceCode.lines;\n\n            sourceLines.forEach((sourceLine, lineIndex) => {\n                const lineNumber = lineIndex + 1;\n                let match;\n\n                while ((match = IRREGULAR_WHITESPACE.exec(sourceLine)) !== null) {\n                    const location = {\n                        line: lineNumber,\n                        column: match.index\n                    };\n\n                    errors.push({ node, message: \"Irregular whitespace not allowed.\", loc: location });\n                }\n            });\n        }\n\n        /**\n         * Checks the program source for irregular line terminators\n         * @param {ASTNode} node The program node\n         * @returns {void}\n         * @private\n         */\n        function checkForIrregularLineTerminators(node) {\n            const source = sourceCode.getText(),\n                sourceLines = sourceCode.lines,\n                linebreaks = source.match(LINE_BREAK);\n            let lastLineIndex = -1,\n                match;\n\n            while ((match = IRREGULAR_LINE_TERMINATORS.exec(source)) !== null) {\n                const lineIndex = linebreaks.indexOf(match[0], lastLineIndex + 1) || 0;\n                const location = {\n                    line: lineIndex + 1,\n                    column: sourceLines[lineIndex].length\n                };\n\n                errors.push({ node, message: \"Irregular whitespace not allowed.\", loc: location });\n                lastLineIndex = lineIndex;\n            }\n        }\n\n        /**\n         * A no-op function to act as placeholder for comment accumulation when the `skipComments` option is `false`.\n         * @returns {void}\n         * @private\n         */\n        function noop() {}\n\n        const nodes = {};\n\n        if (ALL_IRREGULARS.test(sourceCode.getText())) {\n            nodes.Program = function(node) {\n\n                /*\n                 * As we can easily fire warnings for all white space issues with\n                 * all the source its simpler to fire them here.\n                 * This means we can check all the application code without having\n                 * to worry about issues caused in the parser tokens.\n                 * When writing this code also evaluating per node was missing out\n                 * connecting tokens in some cases.\n                 * We can later filter the errors when they are found to be not an\n                 * issue in nodes we don't care about.\n                 */\n                checkForIrregularWhitespace(node);\n                checkForIrregularLineTerminators(node);\n            };\n\n            nodes.Identifier = removeInvalidNodeErrorsInIdentifierOrLiteral;\n            nodes.Literal = removeInvalidNodeErrorsInIdentifierOrLiteral;\n            nodes.TemplateElement = skipTemplates ? removeInvalidNodeErrorsInTemplateLiteral : noop;\n            nodes[\"Program:exit\"] = function() {\n                if (skipComments) {\n\n                    // First strip errors occurring in comment nodes.\n                    commentNodes.forEach(removeInvalidNodeErrorsInComment);\n                }\n\n                // If we have any errors remaining report on them\n                errors.forEach(error => context.report(error));\n            };\n        } else {\n            nodes.Program = noop;\n        }\n\n        return nodes;\n    }\n};\n\n/**\n * @fileoverview Rule to flag usage of __iterator__ property\n * @author Ian Christian Myers\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noIterator = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow the use of the `__iterator__` property\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-iterator\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        return {\n\n            MemberExpression(node) {\n\n                if (node.property &&\n                        (node.property.type === \"Identifier\" && node.property.name === \"__iterator__\" && !node.computed) ||\n                        (node.property.type === \"Literal\" && node.property.value === \"__iterator__\")) {\n                    context.report({ node, message: \"Reserved name '__iterator__'.\" });\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noLabelVar = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow labels that share a name with a variable\",\n            category: \"Variables\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-label-var\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Check if the identifier is present inside current scope\n         * @param {Object} scope current scope\n         * @param {string} name To evaluate\n         * @returns {boolean} True if its present\n         * @private\n         */\n        function findIdentifier(scope, name) {\n            return astUtils$1.getVariableByName(scope, name) !== null;\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n\n            LabeledStatement(node) {\n\n                // Fetch the innermost scope.\n                const scope = context.getScope();\n\n                /*\n                 * Recursively find the identifier walking up the scope, starting\n                 * with the innermost scope.\n                 */\n                if (findIdentifier(scope, node.label.name)) {\n                    context.report({ node, message: \"Found identifier with same name as label.\" });\n                }\n            }\n\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noLabels = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow labeled statements\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-labels\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allowLoop: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    allowSwitch: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const options = context.options[0];\n        const allowLoop = options && options.allowLoop;\n        const allowSwitch = options && options.allowSwitch;\n        let scopeInfo = null;\n\n        /**\n         * Gets the kind of a given node.\n         * @param {ASTNode} node A node to get.\n         * @returns {string} The kind of the node.\n         */\n        function getBodyKind(node) {\n            if (astUtils$1.isLoop(node)) {\n                return \"loop\";\n            }\n            if (node.type === \"SwitchStatement\") {\n                return \"switch\";\n            }\n            return \"other\";\n        }\n\n        /**\n         * Checks whether the label of a given kind is allowed or not.\n         * @param {string} kind A kind to check.\n         * @returns {boolean} `true` if the kind is allowed.\n         */\n        function isAllowed(kind) {\n            switch (kind) {\n                case \"loop\": return allowLoop;\n                case \"switch\": return allowSwitch;\n                default: return false;\n            }\n        }\n\n        /**\n         * Checks whether a given name is a label of a loop or not.\n         * @param {string} label A name of a label to check.\n         * @returns {boolean} `true` if the name is a label of a loop.\n         */\n        function getKind(label) {\n            let info = scopeInfo;\n\n            while (info) {\n                if (info.label === label) {\n                    return info.kind;\n                }\n                info = info.upper;\n            }\n\n            /* istanbul ignore next: syntax error */\n            return \"other\";\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            LabeledStatement(node) {\n                scopeInfo = {\n                    label: node.label.name,\n                    kind: getBodyKind(node.body),\n                    upper: scopeInfo\n                };\n            },\n\n            \"LabeledStatement:exit\"(node) {\n                if (!isAllowed(scopeInfo.kind)) {\n                    context.report({\n                        node,\n                        message: \"Unexpected labeled statement.\"\n                    });\n                }\n\n                scopeInfo = scopeInfo.upper;\n            },\n\n            BreakStatement(node) {\n                if (node.label && !isAllowed(getKind(node.label.name))) {\n                    context.report({\n                        node,\n                        message: \"Unexpected label in break statement.\"\n                    });\n                }\n            },\n\n            ContinueStatement(node) {\n                if (node.label && !isAllowed(getKind(node.label.name))) {\n                    context.report({\n                        node,\n                        message: \"Unexpected label in continue statement.\"\n                    });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag blocks with no reason to exist\n * @author Brandon Mills\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noLoneBlocks = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow unnecessary nested blocks\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-lone-blocks\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        // A stack of lone blocks to be checked for block-level bindings\n        const loneBlocks = [];\n        let ruleDef;\n\n        /**\n         * Reports a node as invalid.\n         * @param {ASTNode} node The node to be reported.\n         * @returns {void}\n         */\n        function report(node) {\n            const message = node.parent.type === \"BlockStatement\" ? \"Nested block is redundant.\" : \"Block is redundant.\";\n\n            context.report({ node, message });\n        }\n\n        /**\n         * Checks for any ocurrence of a BlockStatement in a place where lists of statements can appear\n         * @param {ASTNode} node The node to check\n         * @returns {boolean} True if the node is a lone block.\n         */\n        function isLoneBlock(node) {\n            return node.parent.type === \"BlockStatement\" ||\n                node.parent.type === \"Program\" ||\n\n                // Don't report blocks in switch cases if the block is the only statement of the case.\n                node.parent.type === \"SwitchCase\" && !(node.parent.consequent[0] === node && node.parent.consequent.length === 1);\n        }\n\n        /**\n         * Checks the enclosing block of the current node for block-level bindings,\n         * and \"marks it\" as valid if any.\n         * @returns {void}\n         */\n        function markLoneBlock() {\n            if (loneBlocks.length === 0) {\n                return;\n            }\n\n            const block = context.getAncestors().pop();\n\n            if (loneBlocks[loneBlocks.length - 1] === block) {\n                loneBlocks.pop();\n            }\n        }\n\n        // Default rule definition: report all lone blocks\n        ruleDef = {\n            BlockStatement(node) {\n                if (isLoneBlock(node)) {\n                    report(node);\n                }\n            }\n        };\n\n        // ES6: report blocks without block-level bindings, or that's only child of another block\n        if (context.parserOptions.ecmaVersion >= 6) {\n            ruleDef = {\n                BlockStatement(node) {\n                    if (isLoneBlock(node)) {\n                        loneBlocks.push(node);\n                    }\n                },\n                \"BlockStatement:exit\"(node) {\n                    if (loneBlocks.length > 0 && loneBlocks[loneBlocks.length - 1] === node) {\n                        loneBlocks.pop();\n                        report(node);\n                    } else if (\n                        node.parent.type === \"BlockStatement\" &&\n                        node.parent.body.length === 1\n                    ) {\n                        report(node);\n                    }\n                }\n            };\n\n            ruleDef.VariableDeclaration = function(node) {\n                if (node.kind === \"let\" || node.kind === \"const\") {\n                    markLoneBlock();\n                }\n            };\n\n            ruleDef.FunctionDeclaration = function() {\n                if (context.getScope().isStrict) {\n                    markLoneBlock();\n                }\n            };\n\n            ruleDef.ClassDeclaration = markLoneBlock;\n        }\n\n        return ruleDef;\n    }\n};\n\n/**\n * @fileoverview Rule to disallow if as the only statmenet in an else block\n * @author Brandon Mills\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noLonelyIf = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `if` statements as the only statement in `else` blocks\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-lonely-if\"\n        },\n\n        schema: [],\n        fixable: \"code\"\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        return {\n            IfStatement(node) {\n                const ancestors = context.getAncestors(),\n                    parent = ancestors.pop(),\n                    grandparent = ancestors.pop();\n\n                if (parent && parent.type === \"BlockStatement\" &&\n                        parent.body.length === 1 && grandparent &&\n                        grandparent.type === \"IfStatement\" &&\n                        parent === grandparent.alternate) {\n                    context.report({\n                        node,\n                        message: \"Unexpected if as the only statement in an else block.\",\n                        fix(fixer) {\n                            const openingElseCurly = sourceCode.getFirstToken(parent);\n                            const closingElseCurly = sourceCode.getLastToken(parent);\n                            const elseKeyword = sourceCode.getTokenBefore(openingElseCurly);\n                            const tokenAfterElseBlock = sourceCode.getTokenAfter(closingElseCurly);\n                            const lastIfToken = sourceCode.getLastToken(node.consequent);\n                            const sourceText = sourceCode.getText();\n\n                            if (sourceText.slice(openingElseCurly.range[1],\n                                node.range[0]).trim() || sourceText.slice(node.range[1], closingElseCurly.range[0]).trim()) {\n\n                                // Don't fix if there are any non-whitespace characters interfering (e.g. comments)\n                                return null;\n                            }\n\n                            if (\n                                node.consequent.type !== \"BlockStatement\" && lastIfToken.value !== \";\" && tokenAfterElseBlock &&\n                                (\n                                    node.consequent.loc.end.line === tokenAfterElseBlock.loc.start.line ||\n                                    /^[([/+`-]/u.test(tokenAfterElseBlock.value) ||\n                                    lastIfToken.value === \"++\" ||\n                                    lastIfToken.value === \"--\"\n                                )\n                            ) {\n\n                                /*\n                                 * If the `if` statement has no block, and is not followed by a semicolon, make sure that fixing\n                                 * the issue would not change semantics due to ASI. If this would happen, don't do a fix.\n                                 */\n                                return null;\n                            }\n\n                            return fixer.replaceTextRange(\n                                [openingElseCurly.range[0], closingElseCurly.range[1]],\n                                (elseKeyword.range[1] === openingElseCurly.range[0] ? \" \" : \"\") + sourceCode.getText(node)\n                            );\n                        }\n                    });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag creation of function inside a loop\n * @author Ilya Volodin\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Gets the containing loop node of a specified node.\n *\n * We don't need to check nested functions, so this ignores those.\n * `Scope.through` contains references of nested functions.\n * @param {ASTNode} node An AST node to get.\n * @returns {ASTNode|null} The containing loop node of the specified node, or\n *      `null`.\n */\nfunction getContainingLoopNode(node) {\n    for (let currentNode = node; currentNode.parent; currentNode = currentNode.parent) {\n        const parent = currentNode.parent;\n\n        switch (parent.type) {\n            case \"WhileStatement\":\n            case \"DoWhileStatement\":\n                return parent;\n\n            case \"ForStatement\":\n\n                // `init` is outside of the loop.\n                if (parent.init !== currentNode) {\n                    return parent;\n                }\n                break;\n\n            case \"ForInStatement\":\n            case \"ForOfStatement\":\n\n                // `right` is outside of the loop.\n                if (parent.right !== currentNode) {\n                    return parent;\n                }\n                break;\n\n            case \"ArrowFunctionExpression\":\n            case \"FunctionExpression\":\n            case \"FunctionDeclaration\":\n\n                // We don't need to check nested functions.\n                return null;\n        }\n    }\n\n    return null;\n}\n\n/**\n * Gets the containing loop node of a given node.\n * If the loop was nested, this returns the most outer loop.\n * @param {ASTNode} node A node to get. This is a loop node.\n * @param {ASTNode|null} excludedNode A node that the result node should not\n *      include.\n * @returns {ASTNode} The most outer loop node.\n */\nfunction getTopLoopNode(node, excludedNode) {\n    const border = excludedNode ? excludedNode.range[1] : 0;\n    let retv = node;\n    let containingLoopNode = node;\n\n    while (containingLoopNode && containingLoopNode.range[0] >= border) {\n        retv = containingLoopNode;\n        containingLoopNode = getContainingLoopNode(containingLoopNode);\n    }\n\n    return retv;\n}\n\n/**\n * Checks whether a given reference which refers to an upper scope's variable is\n * safe or not.\n * @param {ASTNode} loopNode A containing loop node.\n * @param {eslint-scope.Reference} reference A reference to check.\n * @returns {boolean} `true` if the reference is safe or not.\n */\nfunction isSafe(loopNode, reference) {\n    const variable = reference.resolved;\n    const definition = variable && variable.defs[0];\n    const declaration = definition && definition.parent;\n    const kind = (declaration && declaration.type === \"VariableDeclaration\")\n        ? declaration.kind\n        : \"\";\n\n    // Variables which are declared by `const` is safe.\n    if (kind === \"const\") {\n        return true;\n    }\n\n    /*\n     * Variables which are declared by `let` in the loop is safe.\n     * It's a different instance from the next loop step's.\n     */\n    if (kind === \"let\" &&\n        declaration.range[0] > loopNode.range[0] &&\n        declaration.range[1] < loopNode.range[1]\n    ) {\n        return true;\n    }\n\n    /*\n     * WriteReferences which exist after this border are unsafe because those\n     * can modify the variable.\n     */\n    const border = getTopLoopNode(\n        loopNode,\n        (kind === \"let\") ? declaration : null\n    ).range[0];\n\n    /**\n     * Checks whether a given reference is safe or not.\n     * The reference is every reference of the upper scope's variable we are\n     * looking now.\n     *\n     * It's safeafe if the reference matches one of the following condition.\n     * - is readonly.\n     * - doesn't exist inside a local function and after the border.\n     * @param {eslint-scope.Reference} upperRef A reference to check.\n     * @returns {boolean} `true` if the reference is safe.\n     */\n    function isSafeReference(upperRef) {\n        const id = upperRef.identifier;\n\n        return (\n            !upperRef.isWrite() ||\n            variable.scope.variableScope === upperRef.from.variableScope &&\n            id.range[0] < border\n        );\n    }\n\n    return Boolean(variable) && variable.references.every(isSafeReference);\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noLoopFunc = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow function declarations that contain unsafe references inside loop statements\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-loop-func\"\n        },\n\n        schema: [],\n\n        messages: {\n            unsafeRefs: \"Function declared in a loop contains unsafe references to variable(s) {{ varNames }}.\"\n        }\n    },\n\n    create(context) {\n\n        /**\n         * Reports functions which match the following condition:\n         *\n         * - has a loop node in ancestors.\n         * - has any references which refers to an unsafe variable.\n         * @param {ASTNode} node The AST node to check.\n         * @returns {boolean} Whether or not the node is within a loop.\n         */\n        function checkForLoops(node) {\n            const loopNode = getContainingLoopNode(node);\n\n            if (!loopNode) {\n                return;\n            }\n\n            const references = context.getScope().through;\n            const unsafeRefs = references.filter(r => !isSafe(loopNode, r)).map(r => r.identifier.name);\n\n            if (unsafeRefs.length > 0) {\n                context.report({\n                    node,\n                    messageId: \"unsafeRefs\",\n                    data: { varNames: `'${unsafeRefs.join(\"', '\")}'` }\n                });\n            }\n        }\n\n        return {\n            ArrowFunctionExpression: checkForLoops,\n            FunctionExpression: checkForLoops,\n            FunctionDeclaration: checkForLoops\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag statements that use magic numbers (adapted from https://github.com/danielstjules/buddy.js)\n * @author Vincent Lemeunier\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noMagicNumbers = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow magic numbers\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-magic-numbers\"\n        },\n\n        schema: [{\n            type: \"object\",\n            properties: {\n                detectObjects: {\n                    type: \"boolean\",\n                    default: false\n                },\n                enforceConst: {\n                    type: \"boolean\",\n                    default: false\n                },\n                ignore: {\n                    type: \"array\",\n                    items: {\n                        type: \"number\"\n                    },\n                    uniqueItems: true\n                },\n                ignoreArrayIndexes: {\n                    type: \"boolean\",\n                    default: false\n                }\n            },\n            additionalProperties: false\n        }],\n\n        messages: {\n            useConst: \"Number constants declarations must use 'const'.\",\n            noMagic: \"No magic number: {{raw}}.\"\n        }\n    },\n\n    create(context) {\n        const config = context.options[0] || {},\n            detectObjects = !!config.detectObjects,\n            enforceConst = !!config.enforceConst,\n            ignore = config.ignore || [],\n            ignoreArrayIndexes = !!config.ignoreArrayIndexes;\n\n        /**\n         * Returns whether the node is number literal\n         * @param {Node} node the node literal being evaluated\n         * @returns {boolean} true if the node is a number literal\n         */\n        function isNumber(node) {\n            return typeof node.value === \"number\";\n        }\n\n        /**\n         * Returns whether the number should be ignored\n         * @param {number} num the number\n         * @returns {boolean} true if the number should be ignored\n         */\n        function shouldIgnoreNumber(num) {\n            return ignore.indexOf(num) !== -1;\n        }\n\n        /**\n         * Returns whether the number should be ignored when used as a radix within parseInt() or Number.parseInt()\n         * @param {ASTNode} parent the non-\"UnaryExpression\" parent\n         * @param {ASTNode} node the node literal being evaluated\n         * @returns {boolean} true if the number should be ignored\n         */\n        function shouldIgnoreParseInt(parent, node) {\n            return parent.type === \"CallExpression\" && node === parent.arguments[1] &&\n                (parent.callee.name === \"parseInt\" ||\n                parent.callee.type === \"MemberExpression\" &&\n                parent.callee.object.name === \"Number\" &&\n                parent.callee.property.name === \"parseInt\");\n        }\n\n        /**\n         * Returns whether the number should be ignored when used to define a JSX prop\n         * @param {ASTNode} parent the non-\"UnaryExpression\" parent\n         * @returns {boolean} true if the number should be ignored\n         */\n        function shouldIgnoreJSXNumbers(parent) {\n            return parent.type.indexOf(\"JSX\") === 0;\n        }\n\n        /**\n         * Returns whether the number should be ignored when used as an array index with enabled 'ignoreArrayIndexes' option.\n         * @param {ASTNode} parent the non-\"UnaryExpression\" parent.\n         * @returns {boolean} true if the number should be ignored\n         */\n        function shouldIgnoreArrayIndexes(parent) {\n            return parent.type === \"MemberExpression\" && ignoreArrayIndexes;\n        }\n\n        return {\n            Literal(node) {\n                const okTypes = detectObjects ? [] : [\"ObjectExpression\", \"Property\", \"AssignmentExpression\"];\n\n                if (!isNumber(node)) {\n                    return;\n                }\n\n                let fullNumberNode;\n                let parent;\n                let value;\n                let raw;\n\n                // For negative magic numbers: update the value and parent node\n                if (node.parent.type === \"UnaryExpression\" && node.parent.operator === \"-\") {\n                    fullNumberNode = node.parent;\n                    parent = fullNumberNode.parent;\n                    value = -node.value;\n                    raw = `-${node.raw}`;\n                } else {\n                    fullNumberNode = node;\n                    parent = node.parent;\n                    value = node.value;\n                    raw = node.raw;\n                }\n\n                if (shouldIgnoreNumber(value) ||\n                    shouldIgnoreParseInt(parent, fullNumberNode) ||\n                    shouldIgnoreArrayIndexes(parent) ||\n                    shouldIgnoreJSXNumbers(parent)) {\n                    return;\n                }\n\n                if (parent.type === \"VariableDeclarator\") {\n                    if (enforceConst && parent.parent.kind !== \"const\") {\n                        context.report({\n                            node: fullNumberNode,\n                            messageId: \"useConst\"\n                        });\n                    }\n                } else if (\n                    okTypes.indexOf(parent.type) === -1 ||\n                    (parent.type === \"AssignmentExpression\" && parent.left.type === \"Identifier\")\n                ) {\n                    context.report({\n                        node: fullNumberNode,\n                        messageId: \"noMagic\",\n                        data: {\n                            raw\n                        }\n                    });\n                }\n            }\n        };\n    }\n};\n\n// THIS FILE WAS GENERATED BY 'tools/update-unicode-utils.js'\n\nconst combiningChars = new Set([768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,1155,1156,1157,1158,1159,1160,1161,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1471,1473,1474,1476,1477,1479,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1648,1750,1751,1752,1753,1754,1755,1756,1759,1760,1761,1762,1763,1764,1767,1768,1770,1771,1772,1773,1809,1840,1841,1842,1843,1844,1845,1846,1847,1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858,1859,1860,1861,1862,1863,1864,1865,1866,1958,1959,1960,1961,1962,1963,1964,1965,1966,1967,1968,2027,2028,2029,2030,2031,2032,2033,2034,2035,2070,2071,2072,2073,2075,2076,2077,2078,2079,2080,2081,2082,2083,2085,2086,2087,2089,2090,2091,2092,2093,2137,2138,2139,2260,2261,2262,2263,2264,2265,2266,2267,2268,2269,2270,2271,2272,2273,2275,2276,2277,2278,2279,2280,2281,2282,2283,2284,2285,2286,2287,2288,2289,2290,2291,2292,2293,2294,2295,2296,2297,2298,2299,2300,2301,2302,2303,2304,2305,2306,2307,2362,2363,2364,2366,2367,2368,2369,2370,2371,2372,2373,2374,2375,2376,2377,2378,2379,2380,2381,2382,2383,2385,2386,2387,2388,2389,2390,2391,2402,2403,2433,2434,2435,2492,2494,2495,2496,2497,2498,2499,2500,2503,2504,2507,2508,2509,2519,2530,2531,2561,2562,2563,2620,2622,2623,2624,2625,2626,2631,2632,2635,2636,2637,2641,2672,2673,2677,2689,2690,2691,2748,2750,2751,2752,2753,2754,2755,2756,2757,2759,2760,2761,2763,2764,2765,2786,2787,2810,2811,2812,2813,2814,2815,2817,2818,2819,2876,2878,2879,2880,2881,2882,2883,2884,2887,2888,2891,2892,2893,2902,2903,2914,2915,2946,3006,3007,3008,3009,3010,3014,3015,3016,3018,3019,3020,3021,3031,3072,3073,3074,3075,3134,3135,3136,3137,3138,3139,3140,3142,3143,3144,3146,3147,3148,3149,3157,3158,3170,3171,3201,3202,3203,3260,3262,3263,3264,3265,3266,3267,3268,3270,3271,3272,3274,3275,3276,3277,3285,3286,3298,3299,3328,3329,3330,3331,3387,3388,3390,3391,3392,3393,3394,3395,3396,3398,3399,3400,3402,3403,3404,3405,3415,3426,3427,3458,3459,3530,3535,3536,3537,3538,3539,3540,3542,3544,3545,3546,3547,3548,3549,3550,3551,3570,3571,3633,3636,3637,3638,3639,3640,3641,3642,3655,3656,3657,3658,3659,3660,3661,3662,3761,3764,3765,3766,3767,3768,3769,3771,3772,3784,3785,3786,3787,3788,3789,3864,3865,3893,3895,3897,3902,3903,3953,3954,3955,3956,3957,3958,3959,3960,3961,3962,3963,3964,3965,3966,3967,3968,3969,3970,3971,3972,3974,3975,3981,3982,3983,3984,3985,3986,3987,3988,3989,3990,3991,3993,3994,3995,3996,3997,3998,3999,4000,4001,4002,4003,4004,4005,4006,4007,4008,4009,4010,4011,4012,4013,4014,4015,4016,4017,4018,4019,4020,4021,4022,4023,4024,4025,4026,4027,4028,4038,4139,4140,4141,4142,4143,4144,4145,4146,4147,4148,4149,4150,4151,4152,4153,4154,4155,4156,4157,4158,4182,4183,4184,4185,4190,4191,4192,4194,4195,4196,4199,4200,4201,4202,4203,4204,4205,4209,4210,4211,4212,4226,4227,4228,4229,4230,4231,4232,4233,4234,4235,4236,4237,4239,4250,4251,4252,4253,4957,4958,4959,5906,5907,5908,5938,5939,5940,5970,5971,6002,6003,6068,6069,6070,6071,6072,6073,6074,6075,6076,6077,6078,6079,6080,6081,6082,6083,6084,6085,6086,6087,6088,6089,6090,6091,6092,6093,6094,6095,6096,6097,6098,6099,6109,6155,6156,6157,6277,6278,6313,6432,6433,6434,6435,6436,6437,6438,6439,6440,6441,6442,6443,6448,6449,6450,6451,6452,6453,6454,6455,6456,6457,6458,6459,6679,6680,6681,6682,6683,6741,6742,6743,6744,6745,6746,6747,6748,6749,6750,6752,6753,6754,6755,6756,6757,6758,6759,6760,6761,6762,6763,6764,6765,6766,6767,6768,6769,6770,6771,6772,6773,6774,6775,6776,6777,6778,6779,6780,6783,6832,6833,6834,6835,6836,6837,6838,6839,6840,6841,6842,6843,6844,6845,6846,6912,6913,6914,6915,6916,6964,6965,6966,6967,6968,6969,6970,6971,6972,6973,6974,6975,6976,6977,6978,6979,6980,7019,7020,7021,7022,7023,7024,7025,7026,7027,7040,7041,7042,7073,7074,7075,7076,7077,7078,7079,7080,7081,7082,7083,7084,7085,7142,7143,7144,7145,7146,7147,7148,7149,7150,7151,7152,7153,7154,7155,7204,7205,7206,7207,7208,7209,7210,7211,7212,7213,7214,7215,7216,7217,7218,7219,7220,7221,7222,7223,7376,7377,7378,7380,7381,7382,7383,7384,7385,7386,7387,7388,7389,7390,7391,7392,7393,7394,7395,7396,7397,7398,7399,7400,7405,7410,7411,7412,7415,7416,7417,7616,7617,7618,7619,7620,7621,7622,7623,7624,7625,7626,7627,7628,7629,7630,7631,7632,7633,7634,7635,7636,7637,7638,7639,7640,7641,7642,7643,7644,7645,7646,7647,7648,7649,7650,7651,7652,7653,7654,7655,7656,7657,7658,7659,7660,7661,7662,7663,7664,7665,7666,7667,7668,7669,7670,7671,7672,7673,7675,7676,7677,7678,7679,8400,8401,8402,8403,8404,8405,8406,8407,8408,8409,8410,8411,8412,8413,8414,8415,8416,8417,8418,8419,8420,8421,8422,8423,8424,8425,8426,8427,8428,8429,8430,8431,8432,11503,11504,11505,11647,11744,11745,11746,11747,11748,11749,11750,11751,11752,11753,11754,11755,11756,11757,11758,11759,11760,11761,11762,11763,11764,11765,11766,11767,11768,11769,11770,11771,11772,11773,11774,11775,12330,12331,12332,12333,12334,12335,12441,12442,42607,42608,42609,42610,42612,42613,42614,42615,42616,42617,42618,42619,42620,42621,42654,42655,42736,42737,43010,43014,43019,43043,43044,43045,43046,43047,43136,43137,43188,43189,43190,43191,43192,43193,43194,43195,43196,43197,43198,43199,43200,43201,43202,43203,43204,43205,43232,43233,43234,43235,43236,43237,43238,43239,43240,43241,43242,43243,43244,43245,43246,43247,43248,43249,43302,43303,43304,43305,43306,43307,43308,43309,43335,43336,43337,43338,43339,43340,43341,43342,43343,43344,43345,43346,43347,43392,43393,43394,43395,43443,43444,43445,43446,43447,43448,43449,43450,43451,43452,43453,43454,43455,43456,43493,43561,43562,43563,43564,43565,43566,43567,43568,43569,43570,43571,43572,43573,43574,43587,43596,43597,43643,43644,43645,43696,43698,43699,43700,43703,43704,43710,43711,43713,43755,43756,43757,43758,43759,43765,43766,44003,44004,44005,44006,44007,44008,44009,44010,44012,44013,64286,65024,65025,65026,65027,65028,65029,65030,65031,65032,65033,65034,65035,65036,65037,65038,65039,65056,65057,65058,65059,65060,65061,65062,65063,65064,65065,65066,65067,65068,65069,65070,65071,66045,66272,66422,66423,66424,66425,66426,68097,68098,68099,68101,68102,68108,68109,68110,68111,68152,68153,68154,68159,68325,68326,69632,69633,69634,69688,69689,69690,69691,69692,69693,69694,69695,69696,69697,69698,69699,69700,69701,69702,69759,69760,69761,69762,69808,69809,69810,69811,69812,69813,69814,69815,69816,69817,69818,69888,69889,69890,69927,69928,69929,69930,69931,69932,69933,69934,69935,69936,69937,69938,69939,69940,70003,70016,70017,70018,70067,70068,70069,70070,70071,70072,70073,70074,70075,70076,70077,70078,70079,70080,70090,70091,70092,70188,70189,70190,70191,70192,70193,70194,70195,70196,70197,70198,70199,70206,70367,70368,70369,70370,70371,70372,70373,70374,70375,70376,70377,70378,70400,70401,70402,70403,70460,70462,70463,70464,70465,70466,70467,70468,70471,70472,70475,70476,70477,70487,70498,70499,70502,70503,70504,70505,70506,70507,70508,70512,70513,70514,70515,70516,70709,70710,70711,70712,70713,70714,70715,70716,70717,70718,70719,70720,70721,70722,70723,70724,70725,70726,70832,70833,70834,70835,70836,70837,70838,70839,70840,70841,70842,70843,70844,70845,70846,70847,70848,70849,70850,70851,71087,71088,71089,71090,71091,71092,71093,71096,71097,71098,71099,71100,71101,71102,71103,71104,71132,71133,71216,71217,71218,71219,71220,71221,71222,71223,71224,71225,71226,71227,71228,71229,71230,71231,71232,71339,71340,71341,71342,71343,71344,71345,71346,71347,71348,71349,71350,71351,71453,71454,71455,71456,71457,71458,71459,71460,71461,71462,71463,71464,71465,71466,71467,72193,72194,72195,72196,72197,72198,72199,72200,72201,72202,72243,72244,72245,72246,72247,72248,72249,72251,72252,72253,72254,72263,72273,72274,72275,72276,72277,72278,72279,72280,72281,72282,72283,72330,72331,72332,72333,72334,72335,72336,72337,72338,72339,72340,72341,72342,72343,72344,72345,72751,72752,72753,72754,72755,72756,72757,72758,72760,72761,72762,72763,72764,72765,72766,72767,72850,72851,72852,72853,72854,72855,72856,72857,72858,72859,72860,72861,72862,72863,72864,72865,72866,72867,72868,72869,72870,72871,72873,72874,72875,72876,72877,72878,72879,72880,72881,72882,72883,72884,72885,72886,73009,73010,73011,73012,73013,73014,73018,73020,73021,73023,73024,73025,73026,73027,73028,73029,73031,92912,92913,92914,92915,92916,92976,92977,92978,92979,92980,92981,92982,94033,94034,94035,94036,94037,94038,94039,94040,94041,94042,94043,94044,94045,94046,94047,94048,94049,94050,94051,94052,94053,94054,94055,94056,94057,94058,94059,94060,94061,94062,94063,94064,94065,94066,94067,94068,94069,94070,94071,94072,94073,94074,94075,94076,94077,94078,94095,94096,94097,94098,113821,113822,119141,119142,119143,119144,119145,119149,119150,119151,119152,119153,119154,119163,119164,119165,119166,119167,119168,119169,119170,119173,119174,119175,119176,119177,119178,119179,119210,119211,119212,119213,119362,119363,119364,121344,121345,121346,121347,121348,121349,121350,121351,121352,121353,121354,121355,121356,121357,121358,121359,121360,121361,121362,121363,121364,121365,121366,121367,121368,121369,121370,121371,121372,121373,121374,121375,121376,121377,121378,121379,121380,121381,121382,121383,121384,121385,121386,121387,121388,121389,121390,121391,121392,121393,121394,121395,121396,121397,121398,121403,121404,121405,121406,121407,121408,121409,121410,121411,121412,121413,121414,121415,121416,121417,121418,121419,121420,121421,121422,121423,121424,121425,121426,121427,121428,121429,121430,121431,121432,121433,121434,121435,121436,121437,121438,121439,121440,121441,121442,121443,121444,121445,121446,121447,121448,121449,121450,121451,121452,121461,121476,121499,121500,121501,121502,121503,121505,121506,121507,121508,121509,121510,121511,121512,121513,121514,121515,121516,121517,121518,121519,122880,122881,122882,122883,122884,122885,122886,122888,122889,122890,122891,122892,122893,122894,122895,122896,122897,122898,122899,122900,122901,122902,122903,122904,122907,122908,122909,122910,122911,122912,122913,122915,122916,122918,122919,122920,122921,122922,125136,125137,125138,125139,125140,125141,125142,125252,125253,125254,125255,125256,125257,125258,917760,917761,917762,917763,917764,917765,917766,917767,917768,917769,917770,917771,917772,917773,917774,917775,917776,917777,917778,917779,917780,917781,917782,917783,917784,917785,917786,917787,917788,917789,917790,917791,917792,917793,917794,917795,917796,917797,917798,917799,917800,917801,917802,917803,917804,917805,917806,917807,917808,917809,917810,917811,917812,917813,917814,917815,917816,917817,917818,917819,917820,917821,917822,917823,917824,917825,917826,917827,917828,917829,917830,917831,917832,917833,917834,917835,917836,917837,917838,917839,917840,917841,917842,917843,917844,917845,917846,917847,917848,917849,917850,917851,917852,917853,917854,917855,917856,917857,917858,917859,917860,917861,917862,917863,917864,917865,917866,917867,917868,917869,917870,917871,917872,917873,917874,917875,917876,917877,917878,917879,917880,917881,917882,917883,917884,917885,917886,917887,917888,917889,917890,917891,917892,917893,917894,917895,917896,917897,917898,917899,917900,917901,917902,917903,917904,917905,917906,917907,917908,917909,917910,917911,917912,917913,917914,917915,917916,917917,917918,917919,917920,917921,917922,917923,917924,917925,917926,917927,917928,917929,917930,917931,917932,917933,917934,917935,917936,917937,917938,917939,917940,917941,917942,917943,917944,917945,917946,917947,917948,917949,917950,917951,917952,917953,917954,917955,917956,917957,917958,917959,917960,917961,917962,917963,917964,917965,917966,917967,917968,917969,917970,917971,917972,917973,917974,917975,917976,917977,917978,917979,917980,917981,917982,917983,917984,917985,917986,917987,917988,917989,917990,917991,917992,917993,917994,917995,917996,917997,917998,917999]);\n\n/**\n * Check whether a given character is a combining mark or not.\n * @param {number} c The character code to check.\n * @returns {boolean} `true` if the character belongs to the category, one of `Mc`, `Me`, and `Mn`.\n */\nvar isCombiningCharacter = function isCombiningCharacter(c) {\n    return combiningChars.has(c);\n};\n\n/**\n * @author Toru Nagashima <https://github.com/mysticatea>\n */\n\n/**\n * Check whether a given character is an emoji modifier.\n * @param {number} code The character code to check.\n * @returns {boolean} `true` if the character is an emoji modifier.\n */\nvar isEmojiModifier = function isEmojiModifier(code) {\n    return code >= 0x1F3FB && code <= 0x1F3FF;\n};\n\n/**\n * @author Toru Nagashima <https://github.com/mysticatea>\n */\n\n/**\n * Check whether a given character is a regional indicator symbol.\n * @param {number} code The character code to check.\n * @returns {boolean} `true` if the character is a regional indicator symbol.\n */\nvar isRegionalIndicatorSymbol = function isRegionalIndicatorSymbol(code) {\n    return code >= 0x1F1E6 && code <= 0x1F1FF;\n};\n\n/**\n * @author Toru Nagashima <https://github.com/mysticatea>\n */\n\n/**\n * Check whether given two characters are a surrogate pair.\n * @param {number} lead The code of the lead character.\n * @param {number} tail The code of the tail character.\n * @returns {boolean} `true` if the character pair is a surrogate pair.\n */\nvar isSurrogatePair = function isSurrogatePair(lead, tail) {\n    return lead >= 0xD800 && lead < 0xDC00 && tail >= 0xDC00 && tail < 0xE000;\n};\n\nvar unicode = {\n    isCombiningCharacter: isCombiningCharacter,\n    isEmojiModifier: isEmojiModifier,\n    isRegionalIndicatorSymbol: isRegionalIndicatorSymbol,\n    isSurrogatePair: isSurrogatePair\n};\n\nconst { CALL: CALL$1, CONSTRUCT: CONSTRUCT$1, ReferenceTracker: ReferenceTracker$1, getStringIfConstant: getStringIfConstant$1 } = require$$0$2;\nconst { RegExpParser: RegExpParser$1, visitRegExpAST: visitRegExpAST$1 } = regexpp$1;\nconst { isCombiningCharacter: isCombiningCharacter$1, isEmojiModifier: isEmojiModifier$1, isRegionalIndicatorSymbol: isRegionalIndicatorSymbol$1, isSurrogatePair: isSurrogatePair$1 } = unicode;\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Iterate character sequences of a given nodes.\n *\n * CharacterClassRange syntax can steal a part of character sequence,\n * so this function reverts CharacterClassRange syntax and restore the sequence.\n * @param {regexpp.AST.CharacterClassElement[]} nodes The node list to iterate character sequences.\n * @returns {IterableIterator<number[]>} The list of character sequences.\n */\nfunction *iterateCharacterSequence(nodes) {\n    let seq = [];\n\n    for (const node of nodes) {\n        switch (node.type) {\n            case \"Character\":\n                seq.push(node.value);\n                break;\n\n            case \"CharacterClassRange\":\n                seq.push(node.min.value);\n                yield seq;\n                seq = [node.max.value];\n                break;\n\n            case \"CharacterSet\":\n                if (seq.length > 0) {\n                    yield seq;\n                    seq = [];\n                }\n                break;\n\n            // no default\n        }\n    }\n\n    if (seq.length > 0) {\n        yield seq;\n    }\n}\n\nconst hasCharacterSequence = {\n    surrogatePairWithoutUFlag(chars) {\n        return chars.some((c, i) => i !== 0 && isSurrogatePair$1(chars[i - 1], c));\n    },\n\n    combiningClass(chars) {\n        return chars.some((c, i) => (\n            i !== 0 &&\n            isCombiningCharacter$1(c) &&\n            !isCombiningCharacter$1(chars[i - 1])\n        ));\n    },\n\n    emojiModifier(chars) {\n        return chars.some((c, i) => (\n            i !== 0 &&\n            isEmojiModifier$1(c) &&\n            !isEmojiModifier$1(chars[i - 1])\n        ));\n    },\n\n    regionalIndicatorSymbol(chars) {\n        return chars.some((c, i) => (\n            i !== 0 &&\n            isRegionalIndicatorSymbol$1(c) &&\n            isRegionalIndicatorSymbol$1(chars[i - 1])\n        ));\n    },\n\n    zwj(chars) {\n        const lastIndex = chars.length - 1;\n\n        return chars.some((c, i) => (\n            i !== 0 &&\n            i !== lastIndex &&\n            c === 0x200d &&\n            chars[i - 1] !== 0x200d &&\n            chars[i + 1] !== 0x200d\n        ));\n    }\n};\n\nconst kinds = Object.keys(hasCharacterSequence);\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noMisleadingCharacterClass = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow characters which are made with multiple code points in character class syntax\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-misleading-character-class\"\n        },\n\n        schema: [],\n\n        messages: {\n            surrogatePairWithoutUFlag: \"Unexpected surrogate pair in character class. Use 'u' flag.\",\n            combiningClass: \"Unexpected combined character in character class.\",\n            emojiModifier: \"Unexpected modified Emoji in character class.\",\n            regionalIndicatorSymbol: \"Unexpected national flag in character class.\",\n            zwj: \"Unexpected joined character sequence in character class.\"\n        }\n    },\n    create(context) {\n        const parser = new RegExpParser$1();\n\n        /**\n         * Verify a given regular expression.\n         * @param {Node} node The node to report.\n         * @param {string} pattern The regular expression pattern to verify.\n         * @param {string} flags The flags of the regular expression.\n         * @returns {void}\n         */\n        function verify(node, pattern, flags) {\n            const has = {\n                surrogatePairWithoutUFlag: false,\n                combiningClass: false,\n                variationSelector: false,\n                emojiModifier: false,\n                regionalIndicatorSymbol: false,\n                zwj: false\n            };\n            let patternNode;\n\n            try {\n                patternNode = parser.parsePattern(\n                    pattern,\n                    0,\n                    pattern.length,\n                    flags.includes(\"u\")\n                );\n            } catch (e) {\n\n                // Ignore regular expressions with syntax errors\n                return;\n            }\n\n            visitRegExpAST$1(patternNode, {\n                onCharacterClassEnter(ccNode) {\n                    for (const chars of iterateCharacterSequence(ccNode.elements)) {\n                        for (const kind of kinds) {\n                            has[kind] = has[kind] || hasCharacterSequence[kind](chars);\n                        }\n                    }\n                }\n            });\n\n            for (const kind of kinds) {\n                if (has[kind]) {\n                    context.report({ node, messageId: kind });\n                }\n            }\n        }\n\n        return {\n            \"Literal[regex]\"(node) {\n                verify(node, node.regex.pattern, node.regex.flags);\n            },\n            \"Program\"() {\n                const scope = context.getScope();\n                const tracker = new ReferenceTracker$1(scope);\n\n                /*\n                 * Iterate calls of RegExp.\n                 * E.g., `new RegExp()`, `RegExp()`, `new window.RegExp()`,\n                 *       `const {RegExp: a} = window; new a()`, etc...\n                 */\n                for (const { node } of tracker.iterateGlobalReferences({\n                    RegExp: { [CALL$1]: true, [CONSTRUCT$1]: true }\n                })) {\n                    const [patternNode, flagsNode] = node.arguments;\n                    const pattern = getStringIfConstant$1(patternNode, scope);\n                    const flags = getStringIfConstant$1(flagsNode, scope);\n\n                    if (typeof pattern === \"string\") {\n                        verify(node, pattern, flags || \"\");\n                    }\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst ARITHMETIC_OPERATORS = [\"+\", \"-\", \"*\", \"/\", \"%\", \"**\"];\nconst BITWISE_OPERATORS$1 = [\"&\", \"|\", \"^\", \"~\", \"<<\", \">>\", \">>>\"];\nconst COMPARISON_OPERATORS = [\"==\", \"!=\", \"===\", \"!==\", \">\", \">=\", \"<\", \"<=\"];\nconst LOGICAL_OPERATORS = [\"&&\", \"||\"];\nconst RELATIONAL_OPERATORS$1 = [\"in\", \"instanceof\"];\nconst TERNARY_OPERATOR = [\"?:\"];\nconst ALL_OPERATORS = [].concat(\n    ARITHMETIC_OPERATORS,\n    BITWISE_OPERATORS$1,\n    COMPARISON_OPERATORS,\n    LOGICAL_OPERATORS,\n    RELATIONAL_OPERATORS$1,\n    TERNARY_OPERATOR\n);\nconst DEFAULT_GROUPS = [\n    ARITHMETIC_OPERATORS,\n    BITWISE_OPERATORS$1,\n    COMPARISON_OPERATORS,\n    LOGICAL_OPERATORS,\n    RELATIONAL_OPERATORS$1\n];\nconst TARGET_NODE_TYPE$2 = /^(?:Binary|Logical|Conditional)Expression$/u;\n\n/**\n * Normalizes options.\n * @param {Object|undefined} options A options object to normalize.\n * @returns {Object} Normalized option object.\n */\nfunction normalizeOptions$3(options = {}) {\n    const hasGroups = options.groups && options.groups.length > 0;\n    const groups = hasGroups ? options.groups : DEFAULT_GROUPS;\n    const allowSamePrecedence = options.allowSamePrecedence !== false;\n\n    return {\n        groups,\n        allowSamePrecedence\n    };\n}\n\n/**\n * Checks whether any group which includes both given operator exists or not.\n * @param {Array.<string[]>} groups A list of groups to check.\n * @param {string} left An operator.\n * @param {string} right Another operator.\n * @returns {boolean} `true` if such group existed.\n */\nfunction includesBothInAGroup(groups, left, right) {\n    return groups.some(group => group.indexOf(left) !== -1 && group.indexOf(right) !== -1);\n}\n\n/**\n * Checks whether the given node is a conditional expression and returns the test node else the left node.\n * @param {ASTNode} node A node which can be a BinaryExpression or a LogicalExpression node.\n * This parent node can be BinaryExpression, LogicalExpression\n *      , or a ConditionalExpression node\n * @returns {ASTNode} node the appropriate node(left or test).\n */\nfunction getChildNode(node) {\n    return node.type === \"ConditionalExpression\" ? node.test : node.left;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noMixedOperators = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow mixed binary operators\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-mixed-operators\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    groups: {\n                        type: \"array\",\n                        items: {\n                            type: \"array\",\n                            items: { enum: ALL_OPERATORS },\n                            minItems: 2,\n                            uniqueItems: true\n                        },\n                        uniqueItems: true\n                    },\n                    allowSamePrecedence: {\n                        type: \"boolean\",\n                        default: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const options = normalizeOptions$3(context.options[0]);\n\n        /**\n         * Checks whether a given node should be ignored by options or not.\n         * @param {ASTNode} node A node to check. This is a BinaryExpression\n         *      node or a LogicalExpression node. This parent node is one of\n         *      them, too.\n         * @returns {boolean} `true` if the node should be ignored.\n         */\n        function shouldIgnore(node) {\n            const a = node;\n            const b = node.parent;\n\n            return (\n                !includesBothInAGroup(options.groups, a.operator, b.type === \"ConditionalExpression\" ? \"?:\" : b.operator) ||\n                (\n                    options.allowSamePrecedence &&\n                    astUtils$1.getPrecedence(a) === astUtils$1.getPrecedence(b)\n                )\n            );\n        }\n\n        /**\n         * Checks whether the operator of a given node is mixed with parent\n         * node's operator or not.\n         * @param {ASTNode} node A node to check. This is a BinaryExpression\n         *      node or a LogicalExpression node. This parent node is one of\n         *      them, too.\n         * @returns {boolean} `true` if the node was mixed.\n         */\n        function isMixedWithParent(node) {\n\n            return (\n                node.operator !== node.parent.operator &&\n                !astUtils$1.isParenthesised(sourceCode, node)\n            );\n        }\n\n        /**\n         * Checks whether the operator of a given node is mixed with a\n         * conditional expression.\n         * @param {ASTNode} node A node to check. This is a conditional\n         *      expression node\n         * @returns {boolean} `true` if the node was mixed.\n         */\n        function isMixedWithConditionalParent(node) {\n            return !astUtils$1.isParenthesised(sourceCode, node) && !astUtils$1.isParenthesised(sourceCode, node.test);\n        }\n\n        /**\n         * Gets the operator token of a given node.\n         * @param {ASTNode} node A node to check. This is a BinaryExpression\n         *      node or a LogicalExpression node.\n         * @returns {Token} The operator token of the node.\n         */\n        function getOperatorToken(node) {\n            return sourceCode.getTokenAfter(getChildNode(node), astUtils$1.isNotClosingParenToken);\n        }\n\n        /**\n         * Reports both the operator of a given node and the operator of the\n         * parent node.\n         * @param {ASTNode} node A node to check. This is a BinaryExpression\n         *      node or a LogicalExpression node. This parent node is one of\n         *      them, too.\n         * @returns {void}\n         */\n        function reportBothOperators(node) {\n            const parent = node.parent;\n            const left = (getChildNode(parent) === node) ? node : parent;\n            const right = (getChildNode(parent) !== node) ? node : parent;\n            const message =\n                \"Unexpected mix of '{{leftOperator}}' and '{{rightOperator}}'.\";\n            const data = {\n                leftOperator: left.operator || \"?:\",\n                rightOperator: right.operator || \"?:\"\n            };\n\n            context.report({\n                node: left,\n                loc: getOperatorToken(left).loc,\n                message,\n                data\n            });\n            context.report({\n                node: right,\n                loc: getOperatorToken(right).loc,\n                message,\n                data\n            });\n        }\n\n        /**\n         * Checks between the operator of this node and the operator of the\n         * parent node.\n         * @param {ASTNode} node A node to check.\n         * @returns {void}\n         */\n        function check(node) {\n            if (TARGET_NODE_TYPE$2.test(node.parent.type)) {\n                if (node.parent.type === \"ConditionalExpression\" && !shouldIgnore(node) && isMixedWithConditionalParent(node.parent)) {\n                    reportBothOperators(node);\n                } else {\n                    if (TARGET_NODE_TYPE$2.test(node.parent.type) &&\n                        isMixedWithParent(node) &&\n                        !shouldIgnore(node)\n                    ) {\n                        reportBothOperators(node);\n                    }\n                }\n            }\n\n        }\n\n        return {\n            BinaryExpression: check,\n            LogicalExpression: check\n\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to enforce grouped require statements for Node.JS\n * @author Raphael Pigulla\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noMixedRequires = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `require` calls to be mixed with regular variable declarations\",\n            category: \"Node.js and CommonJS\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-mixed-requires\"\n        },\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        type: \"boolean\"\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            grouping: {\n                                type: \"boolean\"\n                            },\n                            allowCall: {\n                                type: \"boolean\"\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ]\n    },\n\n    create(context) {\n\n        const options = context.options[0];\n        let grouping = false,\n            allowCall = false;\n\n        if (typeof options === \"object\") {\n            grouping = options.grouping;\n            allowCall = options.allowCall;\n        } else {\n            grouping = !!options;\n        }\n\n        /**\n         * Returns the list of built-in modules.\n         * @returns {string[]} An array of built-in Node.js modules.\n         */\n        function getBuiltinModules() {\n\n            /*\n             * This list is generated using:\n             * `require(\"repl\")._builtinLibs.concat('repl').sort()`\n             * This particular list is as per nodejs v0.12.2 and iojs v0.7.1\n             */\n            return [\n                \"assert\", \"buffer\", \"child_process\", \"cluster\", \"crypto\",\n                \"dgram\", \"dns\", \"domain\", \"events\", \"fs\", \"http\", \"https\",\n                \"net\", \"os\", \"path\", \"punycode\", \"querystring\", \"readline\",\n                \"repl\", \"smalloc\", \"stream\", \"string_decoder\", \"tls\", \"tty\",\n                \"url\", \"util\", \"v8\", \"vm\", \"zlib\"\n            ];\n        }\n\n        const BUILTIN_MODULES = getBuiltinModules();\n\n        const DECL_REQUIRE = \"require\",\n            DECL_UNINITIALIZED = \"uninitialized\",\n            DECL_OTHER = \"other\";\n\n        const REQ_CORE = \"core\",\n            REQ_FILE = \"file\",\n            REQ_MODULE = \"module\",\n            REQ_COMPUTED = \"computed\";\n\n        /**\n         * Determines the type of a declaration statement.\n         * @param {ASTNode} initExpression The init node of the VariableDeclarator.\n         * @returns {string} The type of declaration represented by the expression.\n         */\n        function getDeclarationType(initExpression) {\n            if (!initExpression) {\n\n                // \"var x;\"\n                return DECL_UNINITIALIZED;\n            }\n\n            if (initExpression.type === \"CallExpression\" &&\n                initExpression.callee.type === \"Identifier\" &&\n                initExpression.callee.name === \"require\"\n            ) {\n\n                // \"var x = require('util');\"\n                return DECL_REQUIRE;\n            }\n            if (allowCall &&\n                initExpression.type === \"CallExpression\" &&\n                initExpression.callee.type === \"CallExpression\"\n            ) {\n\n                // \"var x = require('diagnose')('sub-module');\"\n                return getDeclarationType(initExpression.callee);\n            }\n            if (initExpression.type === \"MemberExpression\") {\n\n                // \"var x = require('glob').Glob;\"\n                return getDeclarationType(initExpression.object);\n            }\n\n            // \"var x = 42;\"\n            return DECL_OTHER;\n        }\n\n        /**\n         * Determines the type of module that is loaded via require.\n         * @param {ASTNode} initExpression The init node of the VariableDeclarator.\n         * @returns {string} The module type.\n         */\n        function inferModuleType(initExpression) {\n            if (initExpression.type === \"MemberExpression\") {\n\n                // \"var x = require('glob').Glob;\"\n                return inferModuleType(initExpression.object);\n            }\n            if (initExpression.arguments.length === 0) {\n\n                // \"var x = require();\"\n                return REQ_COMPUTED;\n            }\n\n            const arg = initExpression.arguments[0];\n\n            if (arg.type !== \"Literal\" || typeof arg.value !== \"string\") {\n\n                // \"var x = require(42);\"\n                return REQ_COMPUTED;\n            }\n\n            if (BUILTIN_MODULES.indexOf(arg.value) !== -1) {\n\n                // \"var fs = require('fs');\"\n                return REQ_CORE;\n            }\n            if (/^\\.{0,2}\\//u.test(arg.value)) {\n\n                // \"var utils = require('./utils');\"\n                return REQ_FILE;\n            }\n\n            // \"var async = require('async');\"\n            return REQ_MODULE;\n\n        }\n\n        /**\n         * Check if the list of variable declarations is mixed, i.e. whether it\n         * contains both require and other declarations.\n         * @param {ASTNode} declarations The list of VariableDeclarators.\n         * @returns {boolean} True if the declarations are mixed, false if not.\n         */\n        function isMixed(declarations) {\n            const contains = {};\n\n            declarations.forEach(declaration => {\n                const type = getDeclarationType(declaration.init);\n\n                contains[type] = true;\n            });\n\n            return !!(\n                contains[DECL_REQUIRE] &&\n                (contains[DECL_UNINITIALIZED] || contains[DECL_OTHER])\n            );\n        }\n\n        /**\n         * Check if all require declarations in the given list are of the same\n         * type.\n         * @param {ASTNode} declarations The list of VariableDeclarators.\n         * @returns {boolean} True if the declarations are grouped, false if not.\n         */\n        function isGrouped(declarations) {\n            const found = {};\n\n            declarations.forEach(declaration => {\n                if (getDeclarationType(declaration.init) === DECL_REQUIRE) {\n                    found[inferModuleType(declaration.init)] = true;\n                }\n            });\n\n            return Object.keys(found).length <= 1;\n        }\n\n\n        return {\n\n            VariableDeclaration(node) {\n\n                if (isMixed(node.declarations)) {\n                    context.report({ node, message: \"Do not mix 'require' and other declarations.\" });\n                } else if (grouping && !isGrouped(node.declarations)) {\n                    context.report({ node, message: \"Do not mix core, module, file and computed requires.\" });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Disallow mixed spaces and tabs for indentation\n * @author Jary Niebur\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noMixedSpacesAndTabs = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"disallow mixed spaces and tabs for indentation\",\n            category: \"Stylistic Issues\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-mixed-spaces-and-tabs\"\n        },\n\n        schema: [\n            {\n                enum: [\"smart-tabs\", true, false]\n            }\n        ]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        let smartTabs;\n        const ignoredLocs = [];\n\n        switch (context.options[0]) {\n            case true: // Support old syntax, maybe add deprecation warning here\n            case \"smart-tabs\":\n                smartTabs = true;\n                break;\n            default:\n                smartTabs = false;\n        }\n\n        /**\n         * Determines if a given line and column are before a location.\n         * @param {Location} loc The location object from an AST node.\n         * @param {int} line The line to check.\n         * @param {int} column The column to check.\n         * @returns {boolean} True if the line and column are before the location, false if not.\n         * @private\n         */\n        function beforeLoc(loc, line, column) {\n            if (line < loc.start.line) {\n                return true;\n            }\n            return line === loc.start.line && column < loc.start.column;\n        }\n\n        /**\n         * Determines if a given line and column are after a location.\n         * @param {Location} loc The location object from an AST node.\n         * @param {int} line The line to check.\n         * @param {int} column The column to check.\n         * @returns {boolean} True if the line and column are after the location, false if not.\n         * @private\n         */\n        function afterLoc(loc, line, column) {\n            if (line > loc.end.line) {\n                return true;\n            }\n            return line === loc.end.line && column > loc.end.column;\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n\n            TemplateElement(node) {\n                ignoredLocs.push(node.loc);\n            },\n\n            \"Program:exit\"(node) {\n\n                /*\n                 * At least one space followed by a tab\n                 * or the reverse before non-tab/-space\n                 * characters begin.\n                 */\n                let regex = /^(?=[\\t ]*(\\t | \\t))/u;\n                const lines = sourceCode.lines,\n                    comments = sourceCode.getAllComments();\n\n                comments.forEach(comment => {\n                    ignoredLocs.push(comment.loc);\n                });\n\n                ignoredLocs.sort((first, second) => {\n                    if (beforeLoc(first, second.start.line, second.start.column)) {\n                        return 1;\n                    }\n\n                    if (beforeLoc(second, first.start.line, second.start.column)) {\n                        return -1;\n                    }\n\n                    return 0;\n                });\n\n                if (smartTabs) {\n\n                    /*\n                     * At least one space followed by a tab\n                     * before non-tab/-space characters begin.\n                     */\n                    regex = /^(?=[\\t ]* \\t)/u;\n                }\n\n                lines.forEach((line, i) => {\n                    const match = regex.exec(line);\n\n                    if (match) {\n                        const lineNumber = i + 1,\n                            column = match.index + 1;\n\n                        for (let j = 0; j < ignoredLocs.length; j++) {\n                            if (beforeLoc(ignoredLocs[j], lineNumber, column)) {\n                                continue;\n                            }\n                            if (afterLoc(ignoredLocs[j], lineNumber, column)) {\n                                continue;\n                            }\n\n                            return;\n                        }\n\n                        context.report({ node, loc: { line: lineNumber, column }, message: \"Mixed spaces and tabs.\" });\n                    }\n                });\n            }\n\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to check use of chained assignment expressions\n * @author Stewart Rand\n */\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noMultiAssign = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow use of chained assignment expressions\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-multi-assign\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            AssignmentExpression(node) {\n                if ([\"AssignmentExpression\", \"VariableDeclarator\"].indexOf(node.parent.type) !== -1) {\n                    context.report({\n                        node,\n                        message: \"Unexpected chained assignment.\"\n                    });\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noMultiSpaces = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"disallow multiple spaces\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-multi-spaces\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    exceptions: {\n                        type: \"object\",\n                        patternProperties: {\n                            \"^([A-Z][a-z]*)+$\": {\n                                type: \"boolean\"\n                            }\n                        },\n                        additionalProperties: false\n                    },\n                    ignoreEOLComments: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const options = context.options[0] || {};\n        const ignoreEOLComments = options.ignoreEOLComments;\n        const exceptions = Object.assign({ Property: true }, options.exceptions);\n        const hasExceptions = Object.keys(exceptions).filter(key => exceptions[key]).length > 0;\n\n        /**\n         * Formats value of given comment token for error message by truncating its length.\n         * @param {Token} token comment token\n         * @returns {string} formatted value\n         * @private\n         */\n        function formatReportedCommentValue(token) {\n            const valueLines = token.value.split(\"\\n\");\n            const value = valueLines[0];\n            const formattedValue = `${value.slice(0, 12)}...`;\n\n            return valueLines.length === 1 && value.length <= 12 ? value : formattedValue;\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            Program() {\n                sourceCode.tokensAndComments.forEach((leftToken, leftIndex, tokensAndComments) => {\n                    if (leftIndex === tokensAndComments.length - 1) {\n                        return;\n                    }\n                    const rightToken = tokensAndComments[leftIndex + 1];\n\n                    // Ignore tokens that don't have 2 spaces between them or are on different lines\n                    if (\n                        !sourceCode.text.slice(leftToken.range[1], rightToken.range[0]).includes(\"  \") ||\n                        leftToken.loc.end.line < rightToken.loc.start.line\n                    ) {\n                        return;\n                    }\n\n                    // Ignore comments that are the last token on their line if `ignoreEOLComments` is active.\n                    if (\n                        ignoreEOLComments &&\n                        astUtils$1.isCommentToken(rightToken) &&\n                        (\n                            leftIndex === tokensAndComments.length - 2 ||\n                            rightToken.loc.end.line < tokensAndComments[leftIndex + 2].loc.start.line\n                        )\n                    ) {\n                        return;\n                    }\n\n                    // Ignore tokens that are in a node in the \"exceptions\" object\n                    if (hasExceptions) {\n                        const parentNode = sourceCode.getNodeByRangeIndex(rightToken.range[0] - 1);\n\n                        if (parentNode && exceptions[parentNode.type]) {\n                            return;\n                        }\n                    }\n\n                    let displayValue;\n\n                    if (rightToken.type === \"Block\") {\n                        displayValue = `/*${formatReportedCommentValue(rightToken)}*/`;\n                    } else if (rightToken.type === \"Line\") {\n                        displayValue = `//${formatReportedCommentValue(rightToken)}`;\n                    } else {\n                        displayValue = rightToken.value;\n                    }\n\n                    context.report({\n                        node: rightToken,\n                        loc: { start: leftToken.loc.end, end: rightToken.loc.start },\n                        message: \"Multiple spaces found before '{{displayValue}}'.\",\n                        data: { displayValue },\n                        fix: fixer => fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], \" \")\n                    });\n                });\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noMultiStr = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow multiline strings\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-multi-str\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        /**\n         * Determines if a given node is part of JSX syntax.\n         * @param {ASTNode} node The node to check.\n         * @returns {boolean} True if the node is a JSX node, false if not.\n         * @private\n         */\n        function isJSXElement(node) {\n            return node.type.indexOf(\"JSX\") === 0;\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n\n            Literal(node) {\n                if (astUtils$1.LINEBREAK_MATCHER.test(node.raw) && !isJSXElement(node.parent)) {\n                    context.report({ node, message: \"Multiline support is limited to browsers supporting ES5 only.\" });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Disallows multiple blank lines.\n * implementation adapted from the no-trailing-spaces rule.\n * @author Greg Cochard\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noMultipleEmptyLines = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"disallow multiple empty lines\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-multiple-empty-lines\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    max: {\n                        type: \"integer\",\n                        minimum: 0\n                    },\n                    maxEOF: {\n                        type: \"integer\",\n                        minimum: 0\n                    },\n                    maxBOF: {\n                        type: \"integer\",\n                        minimum: 0\n                    }\n                },\n                required: [\"max\"],\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n\n        // Use options.max or 2 as default\n        let max = 2,\n            maxEOF = max,\n            maxBOF = max;\n\n        if (context.options.length) {\n            max = context.options[0].max;\n            maxEOF = typeof context.options[0].maxEOF !== \"undefined\" ? context.options[0].maxEOF : max;\n            maxBOF = typeof context.options[0].maxBOF !== \"undefined\" ? context.options[0].maxBOF : max;\n        }\n\n        const sourceCode = context.getSourceCode();\n\n        // Swallow the final newline, as some editors add it automatically and we don't want it to cause an issue\n        const allLines = sourceCode.lines[sourceCode.lines.length - 1] === \"\" ? sourceCode.lines.slice(0, -1) : sourceCode.lines;\n        const templateLiteralLines = new Set();\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            TemplateLiteral(node) {\n                node.quasis.forEach(literalPart => {\n\n                    // Empty lines have a semantic meaning if they're inside template literals. Don't count these as empty lines.\n                    for (let ignoredLine = literalPart.loc.start.line; ignoredLine < literalPart.loc.end.line; ignoredLine++) {\n                        templateLiteralLines.add(ignoredLine);\n                    }\n                });\n            },\n            \"Program:exit\"(node) {\n                return allLines\n\n                    // Given a list of lines, first get a list of line numbers that are non-empty.\n                    .reduce((nonEmptyLineNumbers, line, index) => {\n                        if (line.trim() || templateLiteralLines.has(index + 1)) {\n                            nonEmptyLineNumbers.push(index + 1);\n                        }\n                        return nonEmptyLineNumbers;\n                    }, [])\n\n                    // Add a value at the end to allow trailing empty lines to be checked.\n                    .concat(allLines.length + 1)\n\n                    // Given two line numbers of non-empty lines, report the lines between if the difference is too large.\n                    .reduce((lastLineNumber, lineNumber) => {\n                        let message, maxAllowed;\n\n                        if (lastLineNumber === 0) {\n                            message = \"Too many blank lines at the beginning of file. Max of {{max}} allowed.\";\n                            maxAllowed = maxBOF;\n                        } else if (lineNumber === allLines.length + 1) {\n                            message = \"Too many blank lines at the end of file. Max of {{max}} allowed.\";\n                            maxAllowed = maxEOF;\n                        } else {\n                            message = \"More than {{max}} blank {{pluralizedLines}} not allowed.\";\n                            maxAllowed = max;\n                        }\n\n                        if (lineNumber - lastLineNumber - 1 > maxAllowed) {\n                            context.report({\n                                node,\n                                loc: { start: { line: lastLineNumber + maxAllowed + 1, column: 0 }, end: { line: lineNumber, column: 0 } },\n                                message,\n                                data: { max: maxAllowed, pluralizedLines: maxAllowed === 1 ? \"line\" : \"lines\" },\n                                fix(fixer) {\n                                    const rangeStart = sourceCode.getIndexFromLoc({ line: lastLineNumber + 1, column: 0 });\n\n                                    /*\n                                     * The end of the removal range is usually the start index of the next line.\n                                     * However, at the end of the file there is no next line, so the end of the\n                                     * range is just the length of the text.\n                                     */\n                                    const lineNumberAfterRemovedLines = lineNumber - maxAllowed;\n                                    const rangeEnd = lineNumberAfterRemovedLines <= allLines.length\n                                        ? sourceCode.getIndexFromLoc({ line: lineNumberAfterRemovedLines, column: 0 })\n                                        : sourceCode.text.length;\n\n                                    return fixer.removeRange([rangeStart, rangeEnd]);\n                                }\n                            });\n                        }\n\n                        return lineNumber;\n                    }, 0);\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to disallow assignments to native objects or read-only global variables\n * @author Ilya Volodin\n * @deprecated in ESLint v3.3.0\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noNativeReassign = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow assignments to native objects or read-only global variables\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-native-reassign\"\n        },\n\n        deprecated: true,\n\n        replacedBy: [\"no-global-assign\"],\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    exceptions: {\n                        type: \"array\",\n                        items: { type: \"string\" },\n                        uniqueItems: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const config = context.options[0];\n        const exceptions = (config && config.exceptions) || [];\n\n        /**\n         * Reports write references.\n         * @param {Reference} reference A reference to check.\n         * @param {int} index The index of the reference in the references.\n         * @param {Reference[]} references The array that the reference belongs to.\n         * @returns {void}\n         */\n        function checkReference(reference, index, references) {\n            const identifier = reference.identifier;\n\n            if (reference.init === false &&\n                reference.isWrite() &&\n\n                /*\n                 * Destructuring assignments can have multiple default value,\n                 * so possibly there are multiple writeable references for the same identifier.\n                 */\n                (index === 0 || references[index - 1].identifier !== identifier)\n            ) {\n                context.report({\n                    node: identifier,\n                    message: \"Read-only global '{{name}}' should not be modified.\",\n                    data: identifier\n                });\n            }\n        }\n\n        /**\n         * Reports write references if a given variable is read-only builtin.\n         * @param {Variable} variable A variable to check.\n         * @returns {void}\n         */\n        function checkVariable(variable) {\n            if (variable.writeable === false && exceptions.indexOf(variable.name) === -1) {\n                variable.references.forEach(checkReference);\n            }\n        }\n\n        return {\n            Program() {\n                const globalScope = context.getScope();\n\n                globalScope.variables.forEach(checkVariable);\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to disallow a negated condition\n * @author Alberto Rodríguez\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noNegatedCondition = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow negated conditions\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-negated-condition\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        /**\n         * Determines if a given node is an if-else without a condition on the else\n         * @param {ASTNode} node The node to check.\n         * @returns {boolean} True if the node has an else without an if.\n         * @private\n         */\n        function hasElseWithoutCondition(node) {\n            return node.alternate && node.alternate.type !== \"IfStatement\";\n        }\n\n        /**\n         * Determines if a given node is a negated unary expression\n         * @param {Object} test The test object to check.\n         * @returns {boolean} True if the node is a negated unary expression.\n         * @private\n         */\n        function isNegatedUnaryExpression(test) {\n            return test.type === \"UnaryExpression\" && test.operator === \"!\";\n        }\n\n        /**\n         * Determines if a given node is a negated binary expression\n         * @param {Test} test The test to check.\n         * @returns {boolean} True if the node is a negated binary expression.\n         * @private\n         */\n        function isNegatedBinaryExpression(test) {\n            return test.type === \"BinaryExpression\" &&\n                (test.operator === \"!=\" || test.operator === \"!==\");\n        }\n\n        /**\n         * Determines if a given node has a negated if expression\n         * @param {ASTNode} node The node to check.\n         * @returns {boolean} True if the node has a negated if expression.\n         * @private\n         */\n        function isNegatedIf(node) {\n            return isNegatedUnaryExpression(node.test) || isNegatedBinaryExpression(node.test);\n        }\n\n        return {\n            IfStatement(node) {\n                if (!hasElseWithoutCondition(node)) {\n                    return;\n                }\n\n                if (isNegatedIf(node)) {\n                    context.report({ node, message: \"Unexpected negated condition.\" });\n                }\n            },\n            ConditionalExpression(node) {\n                if (isNegatedIf(node)) {\n                    context.report({ node, message: \"Unexpected negated condition.\" });\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview A rule to disallow negated left operands of the `in` operator\n * @author Michael Ficarra\n * @deprecated in ESLint v3.3.0\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noNegatedInLhs = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow negating the left operand in `in` expressions\",\n            category: \"Possible Errors\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-negated-in-lhs\"\n        },\n\n        replacedBy: [\"no-unsafe-negation\"],\n\n        deprecated: true,\n        schema: []\n    },\n\n    create(context) {\n\n        return {\n\n            BinaryExpression(node) {\n                if (node.operator === \"in\" && node.left.type === \"UnaryExpression\" && node.left.operator === \"!\") {\n                    context.report({ node, message: \"The 'in' expression's left operand is negated.\" });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag nested ternary expressions\n * @author Ian Christian Myers\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noNestedTernary = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow nested ternary expressions\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-nested-ternary\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        return {\n            ConditionalExpression(node) {\n                if (node.alternate.type === \"ConditionalExpression\" ||\n                        node.consequent.type === \"ConditionalExpression\") {\n                    context.report({ node, message: \"Do not nest ternary expressions.\" });\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag statements with function invocation preceded by\n * \"new\" and not part of assignment\n * @author Ilya Volodin\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noNew = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `new` operators outside of assignments or comparisons\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-new\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        return {\n            \"ExpressionStatement > NewExpression\"(node) {\n                context.report({ node: node.parent, message: \"Do not use 'new' for side effects.\" });\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag when using new Function\n * @author Ilya Volodin\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noNewFunc = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `new` operators with the `Function` object\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-new-func\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Reports a node.\n         * @param {ASTNode} node The node to report\n         * @returns {void}\n         * @private\n         */\n        function report(node) {\n            context.report({ node, message: \"The Function constructor is eval.\" });\n        }\n\n        return {\n            \"NewExpression[callee.name = 'Function']\": report,\n            \"CallExpression[callee.name = 'Function']\": report\n        };\n\n    }\n};\n\n/**\n * @fileoverview A rule to disallow calls to the Object constructor\n * @author Matt DuVall <http://www.mattduvall.com/>\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noNewObject = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `Object` constructors\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-new-object\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        return {\n\n            NewExpression(node) {\n                if (node.callee.name === \"Object\") {\n                    context.report({ node, message: \"The object literal notation {} is preferrable.\" });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to disallow use of new operator with the `require` function\n * @author Wil Moore III\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noNewRequire = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `new` operators with calls to `require`\",\n            category: \"Node.js and CommonJS\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-new-require\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        return {\n\n            NewExpression(node) {\n                if (node.callee.type === \"Identifier\" && node.callee.name === \"require\") {\n                    context.report({ node, message: \"Unexpected use of new with require.\" });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to disallow use of the new operator with the `Symbol` object\n * @author Alberto Rodríguez\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noNewSymbol = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow `new` operators with the `Symbol` object\",\n            category: \"ECMAScript 6\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-new-symbol\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        return {\n            \"Program:exit\"() {\n                const globalScope = context.getScope();\n                const variable = globalScope.set.get(\"Symbol\");\n\n                if (variable && variable.defs.length === 0) {\n                    variable.references.forEach(ref => {\n                        const node = ref.identifier;\n\n                        if (node.parent && node.parent.type === \"NewExpression\") {\n                            context.report({ node, message: \"`Symbol` cannot be called as a constructor.\" });\n                        }\n                    });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag when using constructor for wrapper objects\n * @author Ilya Volodin\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noNewWrappers = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `new` operators with the `String`, `Number`, and `Boolean` objects\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-new-wrappers\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        return {\n\n            NewExpression(node) {\n                const wrapperObjects = [\"String\", \"Number\", \"Boolean\", \"Math\", \"JSON\"];\n\n                if (wrapperObjects.indexOf(node.callee.name) > -1) {\n                    context.report({ node, message: \"Do not use {{fn}} as a constructor.\", data: { fn: node.callee.name } });\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nconst { CALL: CALL$2, ReferenceTracker: ReferenceTracker$2 } = require$$0$2;\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst nonCallableGlobals = [\"Atomics\", \"JSON\", \"Math\", \"Reflect\"];\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noObjCalls = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow calling global object properties as functions\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-obj-calls\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpectedCall: \"'{{name}}' is not a function.\"\n        }\n    },\n\n    create(context) {\n\n        return {\n            Program() {\n                const scope = context.getScope();\n                const tracker = new ReferenceTracker$2(scope);\n                const traceMap = {};\n\n                for (const global of nonCallableGlobals) {\n                    traceMap[global] = {\n                        [CALL$2]: true\n                    };\n                }\n\n                for (const { node } of tracker.iterateGlobalReferences(traceMap)) {\n                    context.report({ node, messageId: \"unexpectedCall\", data: { name: node.callee.name } });\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag when initializing octal literal\n * @author Ilya Volodin\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noOctal = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow octal literals\",\n            category: \"Best Practices\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-octal\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        return {\n\n            Literal(node) {\n                if (typeof node.value === \"number\" && /^0[0-9]/u.test(node.raw)) {\n                    context.report({ node, message: \"Octal literals should not be used.\" });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag octal escape sequences in string literals.\n * @author Ian Christian Myers\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noOctalEscape = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow octal escape sequences in string literals\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-octal-escape\"\n        },\n\n        schema: [],\n\n        messages: {\n            octalEscapeSequence: \"Don't use octal: '\\\\{{sequence}}'. Use '\\\\u....' instead.\"\n        }\n    },\n\n    create(context) {\n\n        return {\n\n            Literal(node) {\n                if (typeof node.value !== \"string\") {\n                    return;\n                }\n\n                // \\0 represents a valid NULL character if it isn't followed by a digit.\n                const match = node.raw.match(\n                    /^(?:[^\\\\]|\\\\.)*?\\\\([0-3][0-7]{1,2}|[4-7][0-7]|0(?=[89])|[1-7])/su\n                );\n\n                if (match) {\n                    context.report({\n                        node,\n                        messageId: \"octalEscapeSequence\",\n                        data: { sequence: match[1] }\n                    });\n                }\n            }\n\n        };\n\n    }\n};\n\n/**\n * @fileoverview Disallow reassignment of function parameters.\n * @author Nat Burns\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nconst stopNodePattern = /(?:Statement|Declaration|Function(?:Expression)?|Program)$/u;\n\nvar noParamReassign = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow reassigning `function` parameters\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-param-reassign\"\n        },\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        type: \"object\",\n                        properties: {\n                            props: {\n                                enum: [false]\n                            }\n                        },\n                        additionalProperties: false\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            props: {\n                                enum: [true]\n                            },\n                            ignorePropertyModificationsFor: {\n                                type: \"array\",\n                                items: {\n                                    type: \"string\"\n                                },\n                                uniqueItems: true\n                            },\n                            ignorePropertyModificationsForRegex: {\n                                type: \"array\",\n                                items: {\n                                    type: \"string\"\n                                },\n                                uniqueItems: true\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ]\n    },\n\n    create(context) {\n        const props = context.options[0] && context.options[0].props;\n        const ignoredPropertyAssignmentsFor = context.options[0] && context.options[0].ignorePropertyModificationsFor || [];\n        const ignoredPropertyAssignmentsForRegex = context.options[0] && context.options[0].ignorePropertyModificationsForRegex || [];\n\n        /**\n         * Checks whether or not the reference modifies properties of its variable.\n         * @param {Reference} reference A reference to check.\n         * @returns {boolean} Whether or not the reference modifies properties of its variable.\n         */\n        function isModifyingProp(reference) {\n            let node = reference.identifier;\n            let parent = node.parent;\n\n            while (parent && (!stopNodePattern.test(parent.type) ||\n                    parent.type === \"ForInStatement\" || parent.type === \"ForOfStatement\")) {\n                switch (parent.type) {\n\n                    // e.g. foo.a = 0;\n                    case \"AssignmentExpression\":\n                        return parent.left === node;\n\n                    // e.g. ++foo.a;\n                    case \"UpdateExpression\":\n                        return true;\n\n                    // e.g. delete foo.a;\n                    case \"UnaryExpression\":\n                        if (parent.operator === \"delete\") {\n                            return true;\n                        }\n                        break;\n\n                    // e.g. for (foo.a in b) {}\n                    case \"ForInStatement\":\n                    case \"ForOfStatement\":\n                        if (parent.left === node) {\n                            return true;\n                        }\n\n                        // this is a stop node for parent.right and parent.body\n                        return false;\n\n                    // EXCLUDES: e.g. cache.get(foo.a).b = 0;\n                    case \"CallExpression\":\n                        if (parent.callee !== node) {\n                            return false;\n                        }\n                        break;\n\n                    // EXCLUDES: e.g. cache[foo.a] = 0;\n                    case \"MemberExpression\":\n                        if (parent.property === node) {\n                            return false;\n                        }\n                        break;\n\n                    // EXCLUDES: e.g. ({ [foo]: a }) = bar;\n                    case \"Property\":\n                        if (parent.key === node) {\n                            return false;\n                        }\n\n                        break;\n\n                    // EXCLUDES: e.g. (foo ? a : b).c = bar;\n                    case \"ConditionalExpression\":\n                        if (parent.test === node) {\n                            return false;\n                        }\n\n                        break;\n\n                    // no default\n                }\n\n                node = parent;\n                parent = node.parent;\n            }\n\n            return false;\n        }\n\n        /**\n         * Tests that an identifier name matches any of the ignored property assignments.\n         * First we test strings in ignoredPropertyAssignmentsFor.\n         * Then we instantiate and test RegExp objects from ignoredPropertyAssignmentsForRegex strings.\n         * @param {string} identifierName A string that describes the name of an identifier to\n         * ignore property assignments for.\n         * @returns {boolean} Whether the string matches an ignored property assignment regular expression or not.\n         */\n        function isIgnoredPropertyAssignment(identifierName) {\n            return ignoredPropertyAssignmentsFor.includes(identifierName) ||\n                ignoredPropertyAssignmentsForRegex.some(ignored => new RegExp(ignored, \"u\").test(identifierName));\n        }\n\n        /**\n         * Reports a reference if is non initializer and writable.\n         * @param {Reference} reference A reference to check.\n         * @param {int} index The index of the reference in the references.\n         * @param {Reference[]} references The array that the reference belongs to.\n         * @returns {void}\n         */\n        function checkReference(reference, index, references) {\n            const identifier = reference.identifier;\n\n            if (identifier &&\n                !reference.init &&\n\n                /*\n                 * Destructuring assignments can have multiple default value,\n                 * so possibly there are multiple writeable references for the same identifier.\n                 */\n                (index === 0 || references[index - 1].identifier !== identifier)\n            ) {\n                if (reference.isWrite()) {\n                    context.report({ node: identifier, message: \"Assignment to function parameter '{{name}}'.\", data: { name: identifier.name } });\n                } else if (props && isModifyingProp(reference) && !isIgnoredPropertyAssignment(identifier.name)) {\n                    context.report({ node: identifier, message: \"Assignment to property of function parameter '{{name}}'.\", data: { name: identifier.name } });\n                }\n            }\n        }\n\n        /**\n         * Finds and reports references that are non initializer and writable.\n         * @param {Variable} variable A variable to check.\n         * @returns {void}\n         */\n        function checkVariable(variable) {\n            if (variable.defs[0].type === \"Parameter\") {\n                variable.references.forEach(checkReference);\n            }\n        }\n\n        /**\n         * Checks parameters of a given function node.\n         * @param {ASTNode} node A function node to check.\n         * @returns {void}\n         */\n        function checkForFunction(node) {\n            context.getDeclaredVariables(node).forEach(checkVariable);\n        }\n\n        return {\n\n            // `:exit` is needed for the `node.parent` property of identifier nodes.\n            \"FunctionDeclaration:exit\": checkForFunction,\n            \"FunctionExpression:exit\": checkForFunction,\n            \"ArrowFunctionExpression:exit\": checkForFunction\n        };\n\n    }\n};\n\n/**\n * @fileoverview Disallow string concatenation when using __dirname and __filename\n * @author Nicholas C. Zakas\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noPathConcat = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow string concatenation with `__dirname` and `__filename`\",\n            category: \"Node.js and CommonJS\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-path-concat\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        const MATCHER = /^__(?:dir|file)name$/u;\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n\n            BinaryExpression(node) {\n\n                const left = node.left,\n                    right = node.right;\n\n                if (node.operator === \"+\" &&\n                        ((left.type === \"Identifier\" && MATCHER.test(left.name)) ||\n                        (right.type === \"Identifier\" && MATCHER.test(right.name)))\n                ) {\n\n                    context.report({ node, message: \"Use path.join() or path.resolve() instead of + to create paths.\" });\n                }\n            }\n\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag use of unary increment and decrement operators.\n * @author Ian Christian Myers\n * @author Brody McKee (github.com/mrmckeb)\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noPlusplus = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow the unary operators `++` and `--`\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-plusplus\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allowForLoopAfterthoughts: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n\n        const config = context.options[0];\n        let allowInForAfterthought = false;\n\n        if (typeof config === \"object\") {\n            allowInForAfterthought = config.allowForLoopAfterthoughts === true;\n        }\n\n        return {\n\n            UpdateExpression(node) {\n                if (allowInForAfterthought && node.parent.type === \"ForStatement\") {\n                    return;\n                }\n                context.report({\n                    node,\n                    message: \"Unary operator '{{operator}}' used.\",\n                    data: {\n                        operator: node.operator\n                    }\n                });\n            }\n\n        };\n\n    }\n};\n\n/**\n * @fileoverview Disallow the use of process.env()\n * @author Vignesh Anand\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noProcessEnv = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow the use of `process.env`\",\n            category: \"Node.js and CommonJS\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-process-env\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        return {\n\n            MemberExpression(node) {\n                const objectName = node.object.name,\n                    propertyName = node.property.name;\n\n                if (objectName === \"process\" && !node.computed && propertyName && propertyName === \"env\") {\n                    context.report({ node, message: \"Unexpected use of process.env.\" });\n                }\n\n            }\n\n        };\n\n    }\n};\n\n/**\n * @fileoverview Disallow the use of process.exit()\n * @author Nicholas C. Zakas\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noProcessExit = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow the use of `process.exit()`\",\n            category: \"Node.js and CommonJS\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-process-exit\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            \"CallExpression > MemberExpression.callee[object.name = 'process'][property.name = 'exit']\"(node) {\n                context.report({ node: node.parent, message: \"Don't use process.exit(); throw an error instead.\" });\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag usage of __proto__ property\n * @author Ilya Volodin\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noProto = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow the use of the `__proto__` property\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-proto\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        return {\n\n            MemberExpression(node) {\n\n                if (node.property &&\n                        (node.property.type === \"Identifier\" && node.property.name === \"__proto__\" && !node.computed) ||\n                        (node.property.type === \"Literal\" && node.property.value === \"__proto__\")) {\n                    context.report({ node, message: \"The '__proto__' property is deprecated.\" });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to disallow use of Object.prototype builtins on objects\n * @author Andrew Levine\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noPrototypeBuiltins = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow calling some `Object.prototype` methods directly on objects\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-prototype-builtins\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        const DISALLOWED_PROPS = [\n            \"hasOwnProperty\",\n            \"isPrototypeOf\",\n            \"propertyIsEnumerable\"\n        ];\n\n        /**\n         * Reports if a disallowed property is used in a CallExpression\n         * @param {ASTNode} node The CallExpression node.\n         * @returns {void}\n         */\n        function disallowBuiltIns(node) {\n            if (node.callee.type !== \"MemberExpression\" || node.callee.computed) {\n                return;\n            }\n            const propName = node.callee.property.name;\n\n            if (DISALLOWED_PROPS.indexOf(propName) > -1) {\n                context.report({\n                    message: \"Do not access Object.prototype method '{{prop}}' from target object.\",\n                    loc: node.callee.property.loc.start,\n                    data: { prop: propName },\n                    node\n                });\n            }\n        }\n\n        return {\n            CallExpression: disallowBuiltIns\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noRedeclare = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow variable redeclaration\",\n            category: \"Best Practices\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-redeclare\"\n        },\n\n        messages: {\n            redeclared: \"'{{id}}' is already defined.\",\n            redeclaredAsBuiltin: \"'{{id}}' is already defined as a built-in global variable.\",\n            redeclaredBySyntax: \"'{{id}}' is already defined by a variable declaration.\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    builtinGlobals: { type: \"boolean\", default: true }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const options = {\n            builtinGlobals: Boolean(\n                context.options.length === 0 ||\n                context.options[0].builtinGlobals\n            )\n        };\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Iterate declarations of a given variable.\n         * @param {escope.variable} variable The variable object to iterate declarations.\n         * @returns {IterableIterator<{type:string,node:ASTNode,loc:SourceLocation}>} The declarations.\n         */\n        function *iterateDeclarations(variable) {\n            if (options.builtinGlobals && (\n                variable.eslintImplicitGlobalSetting === \"readonly\" ||\n                variable.eslintImplicitGlobalSetting === \"writable\"\n            )) {\n                yield { type: \"builtin\" };\n            }\n\n            for (const id of variable.identifiers) {\n                yield { type: \"syntax\", node: id, loc: id.loc };\n            }\n\n            if (variable.eslintExplicitGlobalComments) {\n                for (const comment of variable.eslintExplicitGlobalComments) {\n                    yield {\n                        type: \"comment\",\n                        node: comment,\n                        loc: astUtils$1.getNameLocationInGlobalDirectiveComment(\n                            sourceCode,\n                            comment,\n                            variable.name\n                        )\n                    };\n                }\n            }\n        }\n\n        /**\n         * Find variables in a given scope and flag redeclared ones.\n         * @param {Scope} scope An eslint-scope scope object.\n         * @returns {void}\n         * @private\n         */\n        function findVariablesInScope(scope) {\n            for (const variable of scope.variables) {\n                const [\n                    declaration,\n                    ...extraDeclarations\n                ] = iterateDeclarations(variable);\n\n                if (extraDeclarations.length === 0) {\n                    continue;\n                }\n\n                /*\n                 * If the type of a declaration is different from the type of\n                 * the first declaration, it shows the location of the first\n                 * declaration.\n                 */\n                const detailMessageId = declaration.type === \"builtin\"\n                    ? \"redeclaredAsBuiltin\"\n                    : \"redeclaredBySyntax\";\n                const data = { id: variable.name };\n\n                // Report extra declarations.\n                for (const { type, node, loc } of extraDeclarations) {\n                    const messageId = type === declaration.type\n                        ? \"redeclared\"\n                        : detailMessageId;\n\n                    context.report({ node, loc, messageId, data });\n                }\n            }\n        }\n\n        /**\n         * Find variables in the current scope.\n         * @param {ASTNode} node The node of the current scope.\n         * @returns {void}\n         * @private\n         */\n        function checkForBlock(node) {\n            const scope = context.getScope();\n\n            /*\n             * In ES5, some node type such as `BlockStatement` doesn't have that scope.\n             * `scope.block` is a different node in such a case.\n             */\n            if (scope.block === node) {\n                findVariablesInScope(scope);\n            }\n        }\n\n        return {\n            Program() {\n                const scope = context.getScope();\n\n                findVariablesInScope(scope);\n\n                // Node.js or ES modules has a special scope.\n                if (\n                    scope.type === \"global\" &&\n                    scope.childScopes[0] &&\n\n                    // The special scope's block is the Program node.\n                    scope.block === scope.childScopes[0].block\n                ) {\n                    findVariablesInScope(scope.childScopes[0]);\n                }\n            },\n\n            FunctionDeclaration: checkForBlock,\n            FunctionExpression: checkForBlock,\n            ArrowFunctionExpression: checkForBlock,\n\n            BlockStatement: checkForBlock,\n            ForStatement: checkForBlock,\n            ForInStatement: checkForBlock,\n            ForOfStatement: checkForBlock,\n            SwitchStatement: checkForBlock\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst regExpParser = new regexpp$1.RegExpParser();\nconst DOUBLE_SPACE = / {2}/u;\n\n/**\n * Check if node is a string\n * @param {ASTNode} node node to evaluate\n * @returns {boolean} True if its a string\n * @private\n */\nfunction isString(node) {\n    return node && node.type === \"Literal\" && typeof node.value === \"string\";\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noRegexSpaces = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow multiple spaces in regular expressions\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-regex-spaces\"\n        },\n\n        schema: [],\n        fixable: \"code\"\n    },\n\n    create(context) {\n\n        /**\n         * Validate regular expression\n         * @param {ASTNode} nodeToReport Node to report.\n         * @param {string} pattern Regular expression pattern to validate.\n         * @param {string} rawPattern Raw representation of the pattern in the source code.\n         * @param {number} rawPatternStartRange Start range of the pattern in the source code.\n         * @param {string} flags Regular expression flags.\n         * @returns {void}\n         * @private\n         */\n        function checkRegex(nodeToReport, pattern, rawPattern, rawPatternStartRange, flags) {\n\n            // Skip if there are no consecutive spaces in the source code, to avoid reporting e.g., RegExp(' \\ ').\n            if (!DOUBLE_SPACE.test(rawPattern)) {\n                return;\n            }\n\n            const characterClassNodes = [];\n            let regExpAST;\n\n            try {\n                regExpAST = regExpParser.parsePattern(pattern, 0, pattern.length, flags.includes(\"u\"));\n            } catch (e) {\n\n                // Ignore regular expressions with syntax errors\n                return;\n            }\n\n            regexpp$1.visitRegExpAST(regExpAST, {\n                onCharacterClassEnter(ccNode) {\n                    characterClassNodes.push(ccNode);\n                }\n            });\n\n            const spacesPattern = /( {2,})(?: [+*{?]|[^+*{?]|$)/gu;\n            let match;\n\n            while ((match = spacesPattern.exec(pattern))) {\n                const { 1: { length }, index } = match;\n\n                // Report only consecutive spaces that are not in character classes.\n                if (\n                    characterClassNodes.every(({ start, end }) => index < start || end <= index)\n                ) {\n                    context.report({\n                        node: nodeToReport,\n                        message: \"Spaces are hard to count. Use {{{length}}}.\",\n                        data: { length },\n                        fix(fixer) {\n                            if (pattern !== rawPattern) {\n                                return null;\n                            }\n                            return fixer.replaceTextRange(\n                                [rawPatternStartRange + index, rawPatternStartRange + index + length],\n                                ` {${length}}`\n                            );\n                        }\n                    });\n\n                    // Report only the first occurence of consecutive spaces\n                    return;\n                }\n            }\n        }\n\n        /**\n         * Validate regular expression literals\n         * @param {ASTNode} node node to validate\n         * @returns {void}\n         * @private\n         */\n        function checkLiteral(node) {\n            if (node.regex) {\n                const pattern = node.regex.pattern;\n                const rawPattern = node.raw.slice(1, node.raw.lastIndexOf(\"/\"));\n                const rawPatternStartRange = node.range[0] + 1;\n                const flags = node.regex.flags;\n\n                checkRegex(\n                    node,\n                    pattern,\n                    rawPattern,\n                    rawPatternStartRange,\n                    flags\n                );\n            }\n        }\n\n        /**\n         * Validate strings passed to the RegExp constructor\n         * @param {ASTNode} node node to validate\n         * @returns {void}\n         * @private\n         */\n        function checkFunction(node) {\n            const scope = context.getScope();\n            const regExpVar = astUtils$1.getVariableByName(scope, \"RegExp\");\n            const shadowed = regExpVar && regExpVar.defs.length > 0;\n            const patternNode = node.arguments[0];\n            const flagsNode = node.arguments[1];\n\n            if (node.callee.type === \"Identifier\" && node.callee.name === \"RegExp\" && isString(patternNode) && !shadowed) {\n                const pattern = patternNode.value;\n                const rawPattern = patternNode.raw.slice(1, -1);\n                const rawPatternStartRange = patternNode.range[0] + 1;\n                const flags = isString(flagsNode) ? flagsNode.value : \"\";\n\n                checkRegex(\n                    node,\n                    pattern,\n                    rawPattern,\n                    rawPatternStartRange,\n                    flags\n                );\n            }\n        }\n\n        return {\n            Literal: checkLiteral,\n            CallExpression: checkFunction,\n            NewExpression: checkFunction\n        };\n    }\n};\n\n/**\n * @fileoverview Restrict usage of specified globals.\n * @author Benoît Zugmeyer\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst DEFAULT_MESSAGE_TEMPLATE = \"Unexpected use of '{{name}}'.\",\n    CUSTOM_MESSAGE_TEMPLATE = \"Unexpected use of '{{name}}'. {{customMessage}}\";\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noRestrictedGlobals = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow specified global variables\",\n            category: \"Variables\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-restricted-globals\"\n        },\n\n        schema: {\n            type: \"array\",\n            items: {\n                oneOf: [\n                    {\n                        type: \"string\"\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            name: { type: \"string\" },\n                            message: { type: \"string\" }\n                        },\n                        required: [\"name\"],\n                        additionalProperties: false\n                    }\n                ]\n            },\n            uniqueItems: true,\n            minItems: 0\n        }\n    },\n\n    create(context) {\n\n        // If no globals are restricted, we don't need to do anything\n        if (context.options.length === 0) {\n            return {};\n        }\n\n        const restrictedGlobalMessages = context.options.reduce((memo, option) => {\n            if (typeof option === \"string\") {\n                memo[option] = null;\n            } else {\n                memo[option.name] = option.message;\n            }\n\n            return memo;\n        }, {});\n\n        /**\n         * Report a variable to be used as a restricted global.\n         * @param {Reference} reference the variable reference\n         * @returns {void}\n         * @private\n         */\n        function reportReference(reference) {\n            const name = reference.identifier.name,\n                customMessage = restrictedGlobalMessages[name],\n                message = customMessage\n                    ? CUSTOM_MESSAGE_TEMPLATE\n                    : DEFAULT_MESSAGE_TEMPLATE;\n\n            context.report({\n                node: reference.identifier,\n                message,\n                data: {\n                    name,\n                    customMessage\n                }\n            });\n        }\n\n        /**\n         * Check if the given name is a restricted global name.\n         * @param {string} name name of a variable\n         * @returns {boolean} whether the variable is a restricted global or not\n         * @private\n         */\n        function isRestricted(name) {\n            return Object.prototype.hasOwnProperty.call(restrictedGlobalMessages, name);\n        }\n\n        return {\n            Program() {\n                const scope = context.getScope();\n\n                // Report variables declared elsewhere (ex: variables defined as \"global\" by eslint)\n                scope.variables.forEach(variable => {\n                    if (!variable.defs.length && isRestricted(variable.name)) {\n                        variable.references.forEach(reportReference);\n                    }\n                });\n\n                // Report variables not declared at all\n                scope.through.forEach(reference => {\n                    if (isRestricted(reference.identifier.name)) {\n                        reportReference(reference);\n                    }\n                });\n\n            }\n        };\n    }\n};\n\n// A simple implementation of make-array\nfunction make_array (subject) {\n  return Array.isArray(subject)\n    ? subject\n    : [subject]\n}\n\nconst REGEX_BLANK_LINE = /^\\s+$/;\nconst REGEX_LEADING_EXCAPED_EXCLAMATION = /^\\\\!/;\nconst REGEX_LEADING_EXCAPED_HASH = /^\\\\#/;\nconst SLASH = '/';\nconst KEY_IGNORE = typeof Symbol !== 'undefined'\n  ? Symbol.for('node-ignore')\n  /* istanbul ignore next */\n  : 'node-ignore';\n\nconst define = (object, key, value) =>\n  Object.defineProperty(object, key, {value});\n\nconst REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;\n\n// Sanitize the range of a regular expression\n// The cases are complicated, see test cases for details\nconst sanitizeRange = range => range.replace(\n  REGEX_REGEXP_RANGE,\n  (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0)\n    ? match\n    // Invalid range (out of order) which is ok for gitignore rules but\n    //   fatal for JavaScript regular expression, so eliminate it.\n    : ''\n);\n\n// > If the pattern ends with a slash,\n// > it is removed for the purpose of the following description,\n// > but it would only find a match with a directory.\n// > In other words, foo/ will match a directory foo and paths underneath it,\n// > but will not match a regular file or a symbolic link foo\n// >  (this is consistent with the way how pathspec works in general in Git).\n// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'\n// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call\n//      you could use option `mark: true` with `glob`\n\n// '`foo/`' should not continue with the '`..`'\nconst DEFAULT_REPLACER_PREFIX = [\n\n  // > Trailing spaces are ignored unless they are quoted with backslash (\"\\\")\n  [\n    // (a\\ ) -> (a )\n    // (a  ) -> (a)\n    // (a \\ ) -> (a  )\n    /\\\\?\\s+$/,\n    match => match.indexOf('\\\\') === 0\n      ? ' '\n      : ''\n  ],\n\n  // replace (\\ ) with ' '\n  [\n    /\\\\\\s/g,\n    () => ' '\n  ],\n\n  // Escape metacharacters\n  // which is written down by users but means special for regular expressions.\n\n  // > There are 12 characters with special meanings:\n  // > - the backslash \\,\n  // > - the caret ^,\n  // > - the dollar sign $,\n  // > - the period or dot .,\n  // > - the vertical bar or pipe symbol |,\n  // > - the question mark ?,\n  // > - the asterisk or star *,\n  // > - the plus sign +,\n  // > - the opening parenthesis (,\n  // > - the closing parenthesis ),\n  // > - and the opening square bracket [,\n  // > - the opening curly brace {,\n  // > These special characters are often called \"metacharacters\".\n  [\n    /[\\\\^$.|*+(){]/g,\n    match => `\\\\${match}`\n  ],\n\n  [\n    // > [abc] matches any character inside the brackets\n    // >    (in this case a, b, or c);\n    /\\[([^\\]/]*)($|\\])/g,\n    (match, p1, p2) => p2 === ']'\n      ? `[${sanitizeRange(p1)}]`\n      : `\\\\${match}`\n  ],\n\n  [\n    // > a question mark (?) matches a single character\n    /(?!\\\\)\\?/g,\n    () => '[^/]'\n  ],\n\n  // leading slash\n  [\n\n    // > A leading slash matches the beginning of the pathname.\n    // > For example, \"/*.c\" matches \"cat-file.c\" but not \"mozilla-sha1/sha1.c\".\n    // A leading slash matches the beginning of the pathname\n    /^\\//,\n    () => '^'\n  ],\n\n  // replace special metacharacter slash after the leading slash\n  [\n    /\\//g,\n    () => '\\\\/'\n  ],\n\n  [\n    // > A leading \"**\" followed by a slash means match in all directories.\n    // > For example, \"**/foo\" matches file or directory \"foo\" anywhere,\n    // > the same as pattern \"foo\".\n    // > \"**/foo/bar\" matches file or directory \"bar\" anywhere that is directly\n    // >   under directory \"foo\".\n    // Notice that the '*'s have been replaced as '\\\\*'\n    /^\\^*\\\\\\*\\\\\\*\\\\\\//,\n\n    // '**/foo' <-> 'foo'\n    () => '^(?:.*\\\\/)?'\n  ]\n];\n\nconst DEFAULT_REPLACER_SUFFIX = [\n  // starting\n  [\n    // there will be no leading '/'\n    //   (which has been replaced by section \"leading slash\")\n    // If starts with '**', adding a '^' to the regular expression also works\n    /^(?=[^^])/,\n    function startingReplacer () {\n      return !/\\/(?!$)/.test(this)\n        // > If the pattern does not contain a slash /,\n        // >   Git treats it as a shell glob pattern\n        // Actually, if there is only a trailing slash,\n        //   git also treats it as a shell glob pattern\n        ? '(?:^|\\\\/)'\n\n        // > Otherwise, Git treats the pattern as a shell glob suitable for\n        // >   consumption by fnmatch(3)\n        : '^'\n    }\n  ],\n\n  // two globstars\n  [\n    // Use lookahead assertions so that we could match more than one `'/**'`\n    /\\\\\\/\\\\\\*\\\\\\*(?=\\\\\\/|$)/g,\n\n    // Zero, one or several directories\n    // should not use '*', or it will be replaced by the next replacer\n\n    // Check if it is not the last `'/**'`\n    (match, index, str) => index + 6 < str.length\n\n      // case: /**/\n      // > A slash followed by two consecutive asterisks then a slash matches\n      // >   zero or more directories.\n      // > For example, \"a/**/b\" matches \"a/b\", \"a/x/b\", \"a/x/y/b\" and so on.\n      // '/**/'\n      ? '(?:\\\\/[^\\\\/]+)*'\n\n      // case: /**\n      // > A trailing `\"/**\"` matches everything inside.\n\n      // #21: everything inside but it should not include the current folder\n      : '\\\\/.+'\n  ],\n\n  // intermediate wildcards\n  [\n    // Never replace escaped '*'\n    // ignore rule '\\*' will match the path '*'\n\n    // 'abc.*/' -> go\n    // 'abc.*'  -> skip this rule\n    /(^|[^\\\\]+)\\\\\\*(?=.+)/g,\n\n    // '*.js' matches '.js'\n    // '*.js' doesn't match 'abc'\n    (match, p1) => `${p1}[^\\\\/]*`\n  ],\n\n  // trailing wildcard\n  [\n    /(\\^|\\\\\\/)?\\\\\\*$/,\n    (match, p1) => {\n      const prefix = p1\n        // '\\^':\n        // '/*' does not match ''\n        // '/*' does not match everything\n\n        // '\\\\\\/':\n        // 'abc/*' does not match 'abc/'\n        ? `${p1}[^/]+`\n\n        // 'a*' matches 'a'\n        // 'a*' matches 'aa'\n        : '[^/]*';\n\n      return `${prefix}(?=$|\\\\/$)`\n    }\n  ],\n\n  [\n    // unescape\n    /\\\\\\\\\\\\/g,\n    () => '\\\\'\n  ]\n];\n\nconst POSITIVE_REPLACERS = [\n  ...DEFAULT_REPLACER_PREFIX,\n\n  // 'f'\n  // matches\n  // - /f(end)\n  // - /f/\n  // - (start)f(end)\n  // - (start)f/\n  // doesn't match\n  // - oof\n  // - foo\n  // pseudo:\n  // -> (^|/)f(/|$)\n\n  // ending\n  [\n    // 'js' will not match 'js.'\n    // 'ab' will not match 'abc'\n    /(?:[^*/])$/,\n\n    // 'js*' will not match 'a.js'\n    // 'js/' will not match 'a.js'\n    // 'js' will match 'a.js' and 'a.js/'\n    match => `${match}(?=$|\\\\/)`\n  ],\n\n  ...DEFAULT_REPLACER_SUFFIX\n];\n\nconst NEGATIVE_REPLACERS = [\n  ...DEFAULT_REPLACER_PREFIX,\n\n  // #24, #38\n  // The MISSING rule of [gitignore docs](https://git-scm.com/docs/gitignore)\n  // A negative pattern without a trailing wildcard should not\n  // re-include the things inside that directory.\n\n  // eg:\n  // ['node_modules/*', '!node_modules']\n  // should ignore `node_modules/a.js`\n  [\n    /(?:[^*])$/,\n    match => `${match}(?=$|\\\\/$)`\n  ],\n\n  ...DEFAULT_REPLACER_SUFFIX\n];\n\n// A simple cache, because an ignore rule only has only one certain meaning\nconst cache = Object.create(null);\n\n// @param {pattern}\nconst make_regex = (pattern, negative, ignorecase) => {\n  const r = cache[pattern];\n  if (r) {\n    return r\n  }\n\n  const replacers = negative\n    ? NEGATIVE_REPLACERS\n    : POSITIVE_REPLACERS;\n\n  const source = replacers.reduce(\n    (prev, current) => prev.replace(current[0], current[1].bind(pattern)),\n    pattern\n  );\n\n  return cache[pattern] = ignorecase\n    ? new RegExp(source, 'i')\n    : new RegExp(source)\n};\n\n// > A blank line matches no files, so it can serve as a separator for readability.\nconst checkPattern = pattern => pattern\n  && typeof pattern === 'string'\n  && !REGEX_BLANK_LINE.test(pattern)\n\n  // > A line starting with # serves as a comment.\n  && pattern.indexOf('#') !== 0;\n\nconst createRule = (pattern, ignorecase) => {\n  const origin = pattern;\n  let negative = false;\n\n  // > An optional prefix \"!\" which negates the pattern;\n  if (pattern.indexOf('!') === 0) {\n    negative = true;\n    pattern = pattern.substr(1);\n  }\n\n  pattern = pattern\n  // > Put a backslash (\"\\\") in front of the first \"!\" for patterns that\n  // >   begin with a literal \"!\", for example, `\"\\!important!.txt\"`.\n  .replace(REGEX_LEADING_EXCAPED_EXCLAMATION, '!')\n  // > Put a backslash (\"\\\") in front of the first hash for patterns that\n  // >   begin with a hash.\n  .replace(REGEX_LEADING_EXCAPED_HASH, '#');\n\n  const regex = make_regex(pattern, negative, ignorecase);\n\n  return {\n    origin,\n    pattern,\n    negative,\n    regex\n  }\n};\n\nclass IgnoreBase {\n  constructor ({\n    ignorecase = true\n  } = {}) {\n    this._rules = [];\n    this._ignorecase = ignorecase;\n    define(this, KEY_IGNORE, true);\n    this._initCache();\n  }\n\n  _initCache () {\n    this._cache = Object.create(null);\n  }\n\n  // @param {Array.<string>|string|Ignore} pattern\n  add (pattern) {\n    this._added = false;\n\n    if (typeof pattern === 'string') {\n      pattern = pattern.split(/\\r?\\n/g);\n    }\n\n    make_array(pattern).forEach(this._addPattern, this);\n\n    // Some rules have just added to the ignore,\n    // making the behavior changed.\n    if (this._added) {\n      this._initCache();\n    }\n\n    return this\n  }\n\n  // legacy\n  addPattern (pattern) {\n    return this.add(pattern)\n  }\n\n  _addPattern (pattern) {\n    // #32\n    if (pattern && pattern[KEY_IGNORE]) {\n      this._rules = this._rules.concat(pattern._rules);\n      this._added = true;\n      return\n    }\n\n    if (checkPattern(pattern)) {\n      const rule = createRule(pattern, this._ignorecase);\n      this._added = true;\n      this._rules.push(rule);\n    }\n  }\n\n  filter (paths) {\n    return make_array(paths).filter(path => this._filter(path))\n  }\n\n  createFilter () {\n    return path => this._filter(path)\n  }\n\n  ignores (path) {\n    return !this._filter(path)\n  }\n\n  // @returns `Boolean` true if the `path` is NOT ignored\n  _filter (path, slices) {\n    if (!path) {\n      return false\n    }\n\n    if (path in this._cache) {\n      return this._cache[path]\n    }\n\n    if (!slices) {\n      // path/to/a.js\n      // ['path', 'to', 'a.js']\n      slices = path.split(SLASH);\n    }\n\n    slices.pop();\n\n    return this._cache[path] = slices.length\n      // > It is not possible to re-include a file if a parent directory of\n      // >   that file is excluded.\n      // If the path contains a parent directory, check the parent first\n      ? this._filter(slices.join(SLASH) + SLASH, slices)\n        && this._test(path)\n\n      // Or only test the path\n      : this._test(path)\n  }\n\n  // @returns {Boolean} true if a file is NOT ignored\n  _test (path) {\n    // Explicitly define variable type by setting matched to `0`\n    let matched = 0;\n\n    this._rules.forEach(rule => {\n      // if matched = true, then we only test negative rules\n      // if matched = false, then we test non-negative rules\n      if (!(matched ^ rule.negative)) {\n        matched = rule.negative ^ rule.regex.test(path);\n      }\n    });\n\n    return !matched\n  }\n}\n\n// Windows\n// --------------------------------------------------------------\n/* istanbul ignore if  */\nif (\n  // Detect `process` so that it can run in browsers.\n  typeof process !== 'undefined'\n  && (\n    process.env && process.env.IGNORE_TEST_WIN32\n    || process.platform === 'win32'\n  )\n) {\n  const filter = IgnoreBase.prototype._filter;\n\n  /* eslint no-control-regex: \"off\" */\n  const make_posix = str => /^\\\\\\\\\\?\\\\/.test(str)\n  || /[^\\x00-\\x80]+/.test(str)\n    ? str\n    : str.replace(/\\\\/g, '/');\n\n  IgnoreBase.prototype._filter = function filterWin32 (path, slices) {\n    path = make_posix(path);\n    return filter.call(this, path, slices)\n  };\n}\n\nvar ignore = options => new IgnoreBase(options);\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\n\n\nconst arrayOfStrings = {\n    type: \"array\",\n    items: { type: \"string\" },\n    uniqueItems: true\n};\n\nconst arrayOfStringsOrObjects = {\n    type: \"array\",\n    items: {\n        anyOf: [\n            { type: \"string\" },\n            {\n                type: \"object\",\n                properties: {\n                    name: { type: \"string\" },\n                    message: {\n                        type: \"string\",\n                        minLength: 1\n                    },\n                    importNames: {\n                        type: \"array\",\n                        items: {\n                            type: \"string\"\n                        }\n                    }\n                },\n                additionalProperties: false,\n                required: [\"name\"]\n            }\n        ]\n    },\n    uniqueItems: true\n};\n\nvar noRestrictedImports = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow specified modules when loaded by `import`\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-restricted-imports\"\n        },\n\n        messages: {\n            path: \"'{{importSource}}' import is restricted from being used.\",\n            // eslint-disable-next-line eslint-plugin/report-message-format\n            pathWithCustomMessage: \"'{{importSource}}' import is restricted from being used. {{customMessage}}\",\n\n            patterns: \"'{{importSource}}' import is restricted from being used by a pattern.\",\n\n            everything: \"* import is invalid because '{{importNames}}' from '{{importSource}}' is restricted.\",\n            // eslint-disable-next-line eslint-plugin/report-message-format\n            everythingWithCustomMessage: \"* import is invalid because '{{importNames}}' from '{{importSource}}' is restricted. {{customMessage}}\"\n        },\n\n        schema: {\n            anyOf: [\n                arrayOfStringsOrObjects,\n                {\n                    type: \"array\",\n                    items: [{\n                        type: \"object\",\n                        properties: {\n                            paths: arrayOfStringsOrObjects,\n                            patterns: arrayOfStrings\n                        },\n                        additionalProperties: false\n                    }],\n                    additionalItems: false\n                }\n            ]\n        }\n    },\n\n    create(context) {\n        const options = Array.isArray(context.options) ? context.options : [];\n        const isPathAndPatternsObject =\n            typeof options[0] === \"object\" &&\n            (Object.prototype.hasOwnProperty.call(options[0], \"paths\") || Object.prototype.hasOwnProperty.call(options[0], \"patterns\"));\n\n        const restrictedPaths = (isPathAndPatternsObject ? options[0].paths : context.options) || [];\n        const restrictedPatterns = (isPathAndPatternsObject ? options[0].patterns : []) || [];\n\n        const restrictedPathMessages = restrictedPaths.reduce((memo, importSource) => {\n            if (typeof importSource === \"string\") {\n                memo[importSource] = { message: null };\n            } else {\n                memo[importSource.name] = {\n                    message: importSource.message,\n                    importNames: importSource.importNames\n                };\n            }\n            return memo;\n        }, {});\n\n        // if no imports are restricted we don\"t need to check\n        if (Object.keys(restrictedPaths).length === 0 && restrictedPatterns.length === 0) {\n            return {};\n        }\n\n        const restrictedPatternsMatcher = ignore().add(restrictedPatterns);\n\n        /**\n         * Checks to see if \"*\" is being used to import everything.\n         * @param {Set.<string>} importNames Set of import names that are being imported\n         * @returns {boolean} whether everything is imported or not\n         */\n        function isEverythingImported(importNames) {\n            return importNames.has(\"*\");\n        }\n\n        /**\n         * Report a restricted path.\n         * @param {node} node representing the restricted path reference\n         * @returns {void}\n         * @private\n         */\n        function reportPath(node) {\n            const importSource = node.source.value.trim();\n            const customMessage = restrictedPathMessages[importSource] && restrictedPathMessages[importSource].message;\n\n            context.report({\n                node,\n                messageId: customMessage ? \"pathWithCustomMessage\" : \"path\",\n                data: {\n                    importSource,\n                    customMessage\n                }\n            });\n        }\n\n        /**\n         * Report a restricted path specifically for patterns.\n         * @param {node} node representing the restricted path reference\n         * @returns {void}\n         * @private\n         */\n        function reportPathForPatterns(node) {\n            const importSource = node.source.value.trim();\n\n            context.report({\n                node,\n                messageId: \"patterns\",\n                data: {\n                    importSource\n                }\n            });\n        }\n\n        /**\n         * Report a restricted path specifically when using the '*' import.\n         * @param {string} importSource path of the import\n         * @param {node} node representing the restricted path reference\n         * @returns {void}\n         * @private\n         */\n        function reportPathForEverythingImported(importSource, node) {\n            const importNames = restrictedPathMessages[importSource].importNames;\n            const customMessage = restrictedPathMessages[importSource] && restrictedPathMessages[importSource].message;\n\n            context.report({\n                node,\n                messageId: customMessage ? \"everythingWithCustomMessage\" : \"everything\",\n                data: {\n                    importSource,\n                    importNames,\n                    customMessage\n                }\n            });\n        }\n\n        /**\n         * Check if the given importSource is restricted because '*' is being imported.\n         * @param {string} importSource path of the import\n         * @param {Set.<string>} importNames Set of import names that are being imported\n         * @returns {boolean} whether the path is restricted\n         * @private\n         */\n        function isRestrictedForEverythingImported(importSource, importNames) {\n            return Object.prototype.hasOwnProperty.call(restrictedPathMessages, importSource) &&\n                restrictedPathMessages[importSource].importNames &&\n                isEverythingImported(importNames);\n        }\n\n        /**\n         * Check if the given importNames are restricted given a list of restrictedImportNames.\n         * @param {Set.<string>} importNames Set of import names that are being imported\n         * @param {string[]} restrictedImportNames array of import names that are restricted for this import\n         * @returns {boolean} whether the objectName is restricted\n         * @private\n         */\n        function isRestrictedObject(importNames, restrictedImportNames) {\n            return restrictedImportNames.some(restrictedObjectName => (\n                importNames.has(restrictedObjectName)\n            ));\n        }\n\n        /**\n         * Check if the given importSource is a restricted path.\n         * @param {string} importSource path of the import\n         * @param {Set.<string>} importNames Set of import names that are being imported\n         * @returns {boolean} whether the variable is a restricted path or not\n         * @private\n         */\n        function isRestrictedPath(importSource, importNames) {\n            let isRestricted = false;\n\n            if (Object.prototype.hasOwnProperty.call(restrictedPathMessages, importSource)) {\n                if (restrictedPathMessages[importSource].importNames) {\n                    isRestricted = isRestrictedObject(importNames, restrictedPathMessages[importSource].importNames);\n                } else {\n                    isRestricted = true;\n                }\n            }\n\n            return isRestricted;\n        }\n\n        /**\n         * Check if the given importSource is restricted by a pattern.\n         * @param {string} importSource path of the import\n         * @returns {boolean} whether the variable is a restricted pattern or not\n         * @private\n         */\n        function isRestrictedPattern(importSource) {\n            return restrictedPatterns.length > 0 && restrictedPatternsMatcher.ignores(importSource);\n        }\n\n        /**\n         * Checks a node to see if any problems should be reported.\n         * @param {ASTNode} node The node to check.\n         * @returns {void}\n         * @private\n         */\n        function checkNode(node) {\n            const importSource = node.source.value.trim();\n            const importNames = node.specifiers ? node.specifiers.reduce((set, specifier) => {\n                if (specifier.type === \"ImportDefaultSpecifier\") {\n                    set.add(\"default\");\n                } else if (specifier.type === \"ImportNamespaceSpecifier\") {\n                    set.add(\"*\");\n                } else if (specifier.imported) {\n                    set.add(specifier.imported.name);\n                } else if (specifier.local) {\n                    set.add(specifier.local.name);\n                }\n                return set;\n            }, new Set()) : new Set();\n\n            if (isRestrictedForEverythingImported(importSource, importNames)) {\n                reportPathForEverythingImported(importSource, node);\n            }\n\n            if (isRestrictedPath(importSource, importNames)) {\n                reportPath(node);\n            }\n            if (isRestrictedPattern(importSource)) {\n                reportPathForPatterns(node);\n            }\n        }\n\n        return {\n            ImportDeclaration: checkNode,\n            ExportNamedDeclaration(node) {\n                if (node.source) {\n                    checkNode(node);\n                }\n            },\n            ExportAllDeclaration: checkNode\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst DEFAULT_MESSAGE_TEMPLATE$1 = \"'{{moduleName}}' module is restricted from being used.\";\nconst CUSTOM_MESSAGE_TEMPLATE$1 = \"'{{moduleName}}' module is restricted from being used. {{customMessage}}\";\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\n\n\nconst arrayOfStrings$1 = {\n    type: \"array\",\n    items: { type: \"string\" },\n    uniqueItems: true\n};\n\nconst arrayOfStringsOrObjects$1 = {\n    type: \"array\",\n    items: {\n        anyOf: [\n            { type: \"string\" },\n            {\n                type: \"object\",\n                properties: {\n                    name: { type: \"string\" },\n                    message: {\n                        type: \"string\",\n                        minLength: 1\n                    }\n                },\n                additionalProperties: false,\n                required: [\"name\"]\n            }\n        ]\n    },\n    uniqueItems: true\n};\n\nvar noRestrictedModules = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow specified modules when loaded by `require`\",\n            category: \"Node.js and CommonJS\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-restricted-modules\"\n        },\n\n        schema: {\n            anyOf: [\n                arrayOfStringsOrObjects$1,\n                {\n                    type: \"array\",\n                    items: {\n                        type: \"object\",\n                        properties: {\n                            paths: arrayOfStringsOrObjects$1,\n                            patterns: arrayOfStrings$1\n                        },\n                        additionalProperties: false\n                    },\n                    additionalItems: false\n                }\n            ]\n        }\n    },\n\n    create(context) {\n        const options = Array.isArray(context.options) ? context.options : [];\n        const isPathAndPatternsObject =\n            typeof options[0] === \"object\" &&\n            (Object.prototype.hasOwnProperty.call(options[0], \"paths\") || Object.prototype.hasOwnProperty.call(options[0], \"patterns\"));\n\n        const restrictedPaths = (isPathAndPatternsObject ? options[0].paths : context.options) || [];\n        const restrictedPatterns = (isPathAndPatternsObject ? options[0].patterns : []) || [];\n\n        const restrictedPathMessages = restrictedPaths.reduce((memo, importName) => {\n            if (typeof importName === \"string\") {\n                memo[importName] = null;\n            } else {\n                memo[importName.name] = importName.message;\n            }\n            return memo;\n        }, {});\n\n        // if no imports are restricted we don\"t need to check\n        if (Object.keys(restrictedPaths).length === 0 && restrictedPatterns.length === 0) {\n            return {};\n        }\n\n        const ig = ignore().add(restrictedPatterns);\n\n\n        /**\n         * Function to check if a node is a string literal.\n         * @param {ASTNode} node The node to check.\n         * @returns {boolean} If the node is a string literal.\n         */\n        function isString(node) {\n            return node && node.type === \"Literal\" && typeof node.value === \"string\";\n        }\n\n        /**\n         * Function to check if a node is a require call.\n         * @param {ASTNode} node The node to check.\n         * @returns {boolean} If the node is a require call.\n         */\n        function isRequireCall(node) {\n            return node.callee.type === \"Identifier\" && node.callee.name === \"require\";\n        }\n\n        /**\n         * Report a restricted path.\n         * @param {node} node representing the restricted path reference\n         * @returns {void}\n         * @private\n         */\n        function reportPath(node) {\n            const moduleName = node.arguments[0].value.trim();\n            const customMessage = restrictedPathMessages[moduleName];\n            const message = customMessage\n                ? CUSTOM_MESSAGE_TEMPLATE$1\n                : DEFAULT_MESSAGE_TEMPLATE$1;\n\n            context.report({\n                node,\n                message,\n                data: {\n                    moduleName,\n                    customMessage\n                }\n            });\n        }\n\n        /**\n         * Check if the given name is a restricted path name\n         * @param {string} name name of a variable\n         * @returns {boolean} whether the variable is a restricted path or not\n         * @private\n         */\n        function isRestrictedPath(name) {\n            return Object.prototype.hasOwnProperty.call(restrictedPathMessages, name);\n        }\n\n        return {\n            CallExpression(node) {\n                if (isRequireCall(node)) {\n\n                    // node has arguments and first argument is string\n                    if (node.arguments.length && isString(node.arguments[0])) {\n                        const moduleName = node.arguments[0].value.trim();\n\n                        // check if argument value is in restricted modules array\n                        if (isRestrictedPath(moduleName)) {\n                            reportPath(node);\n                        }\n\n                        if (restrictedPatterns.length > 0 && ig.ignores(moduleName)) {\n                            context.report({\n                                node,\n                                message: \"'{{moduleName}}' module is restricted from being used by a pattern.\",\n                                data: { moduleName }\n                            });\n                        }\n                    }\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noRestrictedProperties = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow certain properties on certain objects\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-restricted-properties\"\n        },\n\n        schema: {\n            type: \"array\",\n            items: {\n                anyOf: [ // `object` and `property` are both optional, but at least one of them must be provided.\n                    {\n                        type: \"object\",\n                        properties: {\n                            object: {\n                                type: \"string\"\n                            },\n                            property: {\n                                type: \"string\"\n                            },\n                            message: {\n                                type: \"string\"\n                            }\n                        },\n                        additionalProperties: false,\n                        required: [\"object\"]\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            object: {\n                                type: \"string\"\n                            },\n                            property: {\n                                type: \"string\"\n                            },\n                            message: {\n                                type: \"string\"\n                            }\n                        },\n                        additionalProperties: false,\n                        required: [\"property\"]\n                    }\n                ]\n            },\n            uniqueItems: true\n        }\n    },\n\n    create(context) {\n        const restrictedCalls = context.options;\n\n        if (restrictedCalls.length === 0) {\n            return {};\n        }\n\n        const restrictedProperties = new Map();\n        const globallyRestrictedObjects = new Map();\n        const globallyRestrictedProperties = new Map();\n\n        restrictedCalls.forEach(option => {\n            const objectName = option.object;\n            const propertyName = option.property;\n\n            if (typeof objectName === \"undefined\") {\n                globallyRestrictedProperties.set(propertyName, { message: option.message });\n            } else if (typeof propertyName === \"undefined\") {\n                globallyRestrictedObjects.set(objectName, { message: option.message });\n            } else {\n                if (!restrictedProperties.has(objectName)) {\n                    restrictedProperties.set(objectName, new Map());\n                }\n\n                restrictedProperties.get(objectName).set(propertyName, {\n                    message: option.message\n                });\n            }\n        });\n\n        /**\n         * Checks to see whether a property access is restricted, and reports it if so.\n         * @param {ASTNode} node The node to report\n         * @param {string} objectName The name of the object\n         * @param {string} propertyName The name of the property\n         * @returns {undefined}\n         */\n        function checkPropertyAccess(node, objectName, propertyName) {\n            if (propertyName === null) {\n                return;\n            }\n            const matchedObject = restrictedProperties.get(objectName);\n            const matchedObjectProperty = matchedObject ? matchedObject.get(propertyName) : globallyRestrictedObjects.get(objectName);\n            const globalMatchedProperty = globallyRestrictedProperties.get(propertyName);\n\n            if (matchedObjectProperty) {\n                const message = matchedObjectProperty.message ? ` ${matchedObjectProperty.message}` : \"\";\n\n                context.report({\n                    node,\n                    // eslint-disable-next-line eslint-plugin/report-message-format\n                    message: \"'{{objectName}}.{{propertyName}}' is restricted from being used.{{message}}\",\n                    data: {\n                        objectName,\n                        propertyName,\n                        message\n                    }\n                });\n            } else if (globalMatchedProperty) {\n                const message = globalMatchedProperty.message ? ` ${globalMatchedProperty.message}` : \"\";\n\n                context.report({\n                    node,\n                    // eslint-disable-next-line eslint-plugin/report-message-format\n                    message: \"'{{propertyName}}' is restricted from being used.{{message}}\",\n                    data: {\n                        propertyName,\n                        message\n                    }\n                });\n            }\n        }\n\n        /**\n         * Checks property accesses in a destructuring assignment expression, e.g. `var foo; ({foo} = bar);`\n         * @param {ASTNode} node An AssignmentExpression or AssignmentPattern node\n         * @returns {undefined}\n         */\n        function checkDestructuringAssignment(node) {\n            if (node.right.type === \"Identifier\") {\n                const objectName = node.right.name;\n\n                if (node.left.type === \"ObjectPattern\") {\n                    node.left.properties.forEach(property => {\n                        checkPropertyAccess(node.left, objectName, astUtils$1.getStaticPropertyName(property));\n                    });\n                }\n            }\n        }\n\n        return {\n            MemberExpression(node) {\n                checkPropertyAccess(node, node.object && node.object.name, astUtils$1.getStaticPropertyName(node));\n            },\n            VariableDeclarator(node) {\n                if (node.init && node.init.type === \"Identifier\") {\n                    const objectName = node.init.name;\n\n                    if (node.id.type === \"ObjectPattern\") {\n                        node.id.properties.forEach(property => {\n                            checkPropertyAccess(node.id, objectName, astUtils$1.getStaticPropertyName(property));\n                        });\n                    }\n                }\n            },\n            AssignmentExpression: checkDestructuringAssignment,\n            AssignmentPattern: checkDestructuringAssignment\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag use of certain node types\n * @author Burak Yigit Kaya\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noRestrictedSyntax = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow specified syntax\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-restricted-syntax\"\n        },\n\n        schema: {\n            type: \"array\",\n            items: {\n                oneOf: [\n                    {\n                        type: \"string\"\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            selector: { type: \"string\" },\n                            message: { type: \"string\" }\n                        },\n                        required: [\"selector\"],\n                        additionalProperties: false\n                    }\n                ]\n            },\n            uniqueItems: true,\n            minItems: 0\n        }\n    },\n\n    create(context) {\n        return context.options.reduce((result, selectorOrObject) => {\n            const isStringFormat = (typeof selectorOrObject === \"string\");\n            const hasCustomMessage = !isStringFormat && Boolean(selectorOrObject.message);\n\n            const selector = isStringFormat ? selectorOrObject : selectorOrObject.selector;\n            const message = hasCustomMessage ? selectorOrObject.message : \"Using '{{selector}}' is not allowed.\";\n\n            return Object.assign(result, {\n                [selector](node) {\n                    context.report({\n                        node,\n                        message,\n                        data: hasCustomMessage ? {} : { selector }\n                    });\n                }\n            });\n        }, {});\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst SENTINEL_TYPE = /^(?:[a-zA-Z]+?Statement|ArrowFunctionExpression|FunctionExpression|ClassExpression)$/u;\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noReturnAssign = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow assignment operators in `return` statements\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-return-assign\"\n        },\n\n        schema: [\n            {\n                enum: [\"except-parens\", \"always\"]\n            }\n        ]\n    },\n\n    create(context) {\n        const always = (context.options[0] || \"except-parens\") !== \"except-parens\";\n        const sourceCode = context.getSourceCode();\n\n        return {\n            AssignmentExpression(node) {\n                if (!always && astUtils$1.isParenthesised(sourceCode, node)) {\n                    return;\n                }\n\n                let currentChild = node;\n                let parent = currentChild.parent;\n\n                // Find ReturnStatement or ArrowFunctionExpression in ancestors.\n                while (parent && !SENTINEL_TYPE.test(parent.type)) {\n                    currentChild = parent;\n                    parent = parent.parent;\n                }\n\n                // Reports.\n                if (parent && parent.type === \"ReturnStatement\") {\n                    context.report({\n                        node: parent,\n                        message: \"Return statement should not contain assignment.\"\n                    });\n                } else if (parent && parent.type === \"ArrowFunctionExpression\" && parent.body === currentChild) {\n                    context.report({\n                        node: parent,\n                        message: \"Arrow function should not return assignment.\"\n                    });\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nconst message = \"Redundant use of `await` on a return value.\";\n\nvar noReturnAwait = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow unnecessary `return await`\",\n            category: \"Best Practices\",\n\n            recommended: false,\n\n            url: \"https://eslint.org/docs/rules/no-return-await\"\n        },\n\n        fixable: null,\n\n        schema: [\n        ]\n    },\n\n    create(context) {\n\n        /**\n         * Reports a found unnecessary `await` expression.\n         * @param {ASTNode} node The node representing the `await` expression to report\n         * @returns {void}\n         */\n        function reportUnnecessaryAwait(node) {\n            context.report({\n                node: context.getSourceCode().getFirstToken(node),\n                loc: node.loc,\n                message\n            });\n        }\n\n        /**\n         * Determines whether a thrown error from this node will be caught/handled within this function rather than immediately halting\n         * this function. For example, a statement in a `try` block will always have an error handler. A statement in\n         * a `catch` block will only have an error handler if there is also a `finally` block.\n         * @param {ASTNode} node A node representing a location where an could be thrown\n         * @returns {boolean} `true` if a thrown error will be caught/handled in this function\n         */\n        function hasErrorHandler(node) {\n            let ancestor = node;\n\n            while (!astUtils$1.isFunction(ancestor) && ancestor.type !== \"Program\") {\n                if (ancestor.parent.type === \"TryStatement\" && (ancestor === ancestor.parent.block || ancestor === ancestor.parent.handler && ancestor.parent.finalizer)) {\n                    return true;\n                }\n                ancestor = ancestor.parent;\n            }\n            return false;\n        }\n\n        /**\n         * Checks if a node is placed in tail call position. Once `return` arguments (or arrow function expressions) can be a complex expression,\n         * an `await` expression could or could not be unnecessary by the definition of this rule. So we're looking for `await` expressions that are in tail position.\n         * @param {ASTNode} node A node representing the `await` expression to check\n         * @returns {boolean} The checking result\n         */\n        function isInTailCallPosition(node) {\n            if (node.parent.type === \"ArrowFunctionExpression\") {\n                return true;\n            }\n            if (node.parent.type === \"ReturnStatement\") {\n                return !hasErrorHandler(node.parent);\n            }\n            if (node.parent.type === \"ConditionalExpression\" && (node === node.parent.consequent || node === node.parent.alternate)) {\n                return isInTailCallPosition(node.parent);\n            }\n            if (node.parent.type === \"LogicalExpression\" && node === node.parent.right) {\n                return isInTailCallPosition(node.parent);\n            }\n            if (node.parent.type === \"SequenceExpression\" && node === node.parent.expressions[node.parent.expressions.length - 1]) {\n                return isInTailCallPosition(node.parent);\n            }\n            return false;\n        }\n\n        return {\n            AwaitExpression(node) {\n                if (isInTailCallPosition(node) && !hasErrorHandler(node)) {\n                    reportUnnecessaryAwait(node);\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag when using javascript: urls\n * @author Ilya Volodin\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noScriptUrl = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `javascript:` urls\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-script-url\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        return {\n\n            Literal(node) {\n                if (node.value && typeof node.value === \"string\") {\n                    const value = node.value.toLowerCase();\n\n                    if (value.indexOf(\"javascript:\") === 0) {\n                        context.report({ node, message: \"Script URL is a form of eval.\" });\n                    }\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst SPACES = /\\s+/gu;\n\n/**\n * Checks whether the property of 2 given member expression nodes are the same\n * property or not.\n * @param {ASTNode} left A member expression node to check.\n * @param {ASTNode} right Another member expression node to check.\n * @returns {boolean} `true` if the member expressions have the same property.\n */\nfunction isSameProperty(left, right) {\n    if (left.property.type === \"Identifier\" &&\n        left.property.type === right.property.type &&\n        left.property.name === right.property.name &&\n        left.computed === right.computed\n    ) {\n        return true;\n    }\n\n    const lname = astUtils$1.getStaticPropertyName(left);\n    const rname = astUtils$1.getStaticPropertyName(right);\n\n    return lname !== null && lname === rname;\n}\n\n/**\n * Checks whether 2 given member expression nodes are the reference to the same\n * property or not.\n * @param {ASTNode} left A member expression node to check.\n * @param {ASTNode} right Another member expression node to check.\n * @returns {boolean} `true` if the member expressions are the reference to the\n *  same property or not.\n */\nfunction isSameMember(left, right) {\n    if (!isSameProperty(left, right)) {\n        return false;\n    }\n\n    const lobj = left.object;\n    const robj = right.object;\n\n    if (lobj.type !== robj.type) {\n        return false;\n    }\n    if (lobj.type === \"MemberExpression\") {\n        return isSameMember(lobj, robj);\n    }\n    if (lobj.type === \"ThisExpression\") {\n        return true;\n    }\n    return lobj.type === \"Identifier\" && lobj.name === robj.name;\n}\n\n/**\n * Traverses 2 Pattern nodes in parallel, then reports self-assignments.\n * @param {ASTNode|null} left A left node to traverse. This is a Pattern or\n *      a Property.\n * @param {ASTNode|null} right A right node to traverse. This is a Pattern or\n *      a Property.\n * @param {boolean} props The flag to check member expressions as well.\n * @param {Function} report A callback function to report.\n * @returns {void}\n */\nfunction eachSelfAssignment(left, right, props, report) {\n    if (!left || !right) ; else if (\n        left.type === \"Identifier\" &&\n        right.type === \"Identifier\" &&\n        left.name === right.name\n    ) {\n        report(right);\n    } else if (\n        left.type === \"ArrayPattern\" &&\n        right.type === \"ArrayExpression\"\n    ) {\n        const end = Math.min(left.elements.length, right.elements.length);\n\n        for (let i = 0; i < end; ++i) {\n            const leftElement = left.elements[i];\n            const rightElement = right.elements[i];\n\n            // Avoid cases such as [...a] = [...a, 1]\n            if (\n                leftElement &&\n                leftElement.type === \"RestElement\" &&\n                i < right.elements.length - 1\n            ) {\n                break;\n            }\n\n            eachSelfAssignment(leftElement, rightElement, props, report);\n\n            // After a spread element, those indices are unknown.\n            if (rightElement && rightElement.type === \"SpreadElement\") {\n                break;\n            }\n        }\n    } else if (\n        left.type === \"RestElement\" &&\n        right.type === \"SpreadElement\"\n    ) {\n        eachSelfAssignment(left.argument, right.argument, props, report);\n    } else if (\n        left.type === \"ObjectPattern\" &&\n        right.type === \"ObjectExpression\" &&\n        right.properties.length >= 1\n    ) {\n\n        /*\n         * Gets the index of the last spread property.\n         * It's possible to overwrite properties followed by it.\n         */\n        let startJ = 0;\n\n        for (let i = right.properties.length - 1; i >= 0; --i) {\n            const propType = right.properties[i].type;\n\n            if (propType === \"SpreadElement\" || propType === \"ExperimentalSpreadProperty\") {\n                startJ = i + 1;\n                break;\n            }\n        }\n\n        for (let i = 0; i < left.properties.length; ++i) {\n            for (let j = startJ; j < right.properties.length; ++j) {\n                eachSelfAssignment(\n                    left.properties[i],\n                    right.properties[j],\n                    props,\n                    report\n                );\n            }\n        }\n    } else if (\n        left.type === \"Property\" &&\n        right.type === \"Property\" &&\n        right.kind === \"init\" &&\n        !right.method\n    ) {\n        const leftName = astUtils$1.getStaticPropertyName(left);\n\n        if (leftName !== null && leftName === astUtils$1.getStaticPropertyName(right)) {\n            eachSelfAssignment(left.value, right.value, props, report);\n        }\n    } else if (\n        props &&\n        left.type === \"MemberExpression\" &&\n        right.type === \"MemberExpression\" &&\n        isSameMember(left, right)\n    ) {\n        report(right);\n    }\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noSelfAssign = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow assignments where both sides are exactly the same\",\n            category: \"Best Practices\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-self-assign\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    props: {\n                        type: \"boolean\",\n                        default: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const [{ props = true } = {}] = context.options;\n\n        /**\n         * Reports a given node as self assignments.\n         * @param {ASTNode} node A node to report. This is an Identifier node.\n         * @returns {void}\n         */\n        function report(node) {\n            context.report({\n                node,\n                message: \"'{{name}}' is assigned to itself.\",\n                data: {\n                    name: sourceCode.getText(node).replace(SPACES, \"\")\n                }\n            });\n        }\n\n        return {\n            AssignmentExpression(node) {\n                if (node.operator === \"=\") {\n                    eachSelfAssignment(node.left, node.right, props, report);\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag comparison where left part is the same as the right\n * part.\n * @author Ilya Volodin\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noSelfCompare = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow comparisons where both sides are exactly the same\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-self-compare\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Determines whether two nodes are composed of the same tokens.\n         * @param {ASTNode} nodeA The first node\n         * @param {ASTNode} nodeB The second node\n         * @returns {boolean} true if the nodes have identical token representations\n         */\n        function hasSameTokens(nodeA, nodeB) {\n            const tokensA = sourceCode.getTokens(nodeA);\n            const tokensB = sourceCode.getTokens(nodeB);\n\n            return tokensA.length === tokensB.length &&\n                tokensA.every((token, index) => token.type === tokensB[index].type && token.value === tokensB[index].value);\n        }\n\n        return {\n\n            BinaryExpression(node) {\n                const operators = new Set([\"===\", \"==\", \"!==\", \"!=\", \">\", \"<\", \">=\", \"<=\"]);\n\n                if (operators.has(node.operator) && hasSameTokens(node.left, node.right)) {\n                    context.report({ node, message: \"Comparing to itself is potentially pointless.\" });\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noSequences = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow comma operators\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-sequences\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Parts of the grammar that are required to have parens.\n         */\n        const parenthesized = {\n            DoWhileStatement: \"test\",\n            IfStatement: \"test\",\n            SwitchStatement: \"discriminant\",\n            WhileStatement: \"test\",\n            WithStatement: \"object\",\n            ArrowFunctionExpression: \"body\"\n\n            /*\n             * Omitting CallExpression - commas are parsed as argument separators\n             * Omitting NewExpression - commas are parsed as argument separators\n             * Omitting ForInStatement - parts aren't individually parenthesised\n             * Omitting ForStatement - parts aren't individually parenthesised\n             */\n        };\n\n        /**\n         * Determines whether a node is required by the grammar to be wrapped in\n         * parens, e.g. the test of an if statement.\n         * @param {ASTNode} node The AST node\n         * @returns {boolean} True if parens around node belong to parent node.\n         */\n        function requiresExtraParens(node) {\n            return node.parent && parenthesized[node.parent.type] &&\n                    node === node.parent[parenthesized[node.parent.type]];\n        }\n\n        /**\n         * Check if a node is wrapped in parens.\n         * @param {ASTNode} node The AST node\n         * @returns {boolean} True if the node has a paren on each side.\n         */\n        function isParenthesised(node) {\n            return astUtils$1.isParenthesised(sourceCode, node);\n        }\n\n        /**\n         * Check if a node is wrapped in two levels of parens.\n         * @param {ASTNode} node The AST node\n         * @returns {boolean} True if two parens surround the node on each side.\n         */\n        function isParenthesisedTwice(node) {\n            const previousToken = sourceCode.getTokenBefore(node, 1),\n                nextToken = sourceCode.getTokenAfter(node, 1);\n\n            return isParenthesised(node) && previousToken && nextToken &&\n                astUtils$1.isOpeningParenToken(previousToken) && previousToken.range[1] <= node.range[0] &&\n                astUtils$1.isClosingParenToken(nextToken) && nextToken.range[0] >= node.range[1];\n        }\n\n        return {\n            SequenceExpression(node) {\n\n                // Always allow sequences in for statement update\n                if (node.parent.type === \"ForStatement\" &&\n                        (node === node.parent.init || node === node.parent.update)) {\n                    return;\n                }\n\n                // Wrapping a sequence in extra parens indicates intent\n                if (requiresExtraParens(node)) {\n                    if (isParenthesisedTwice(node)) {\n                        return;\n                    }\n                } else {\n                    if (isParenthesised(node)) {\n                        return;\n                    }\n                }\n\n                const firstCommaToken = sourceCode.getTokenAfter(node.expressions[0], astUtils$1.isCommaToken);\n\n                context.report({ node, loc: firstCommaToken.loc, message: \"Unexpected use of comma operator.\" });\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\nconst { findVariable: findVariable$2 } = require$$0$2;\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Determines whether the given identifier node is a reference to a global variable.\n * @param {ASTNode} node `Identifier` node to check.\n * @param {Scope} scope Scope to which the node belongs.\n * @returns {boolean} True if the identifier is a reference to a global variable.\n */\nfunction isGlobalReference(node, scope) {\n    const variable = findVariable$2(scope, node);\n\n    return variable !== null && variable.scope.type === \"global\" && variable.defs.length === 0;\n}\n\n/**\n * Determines whether the given node is an argument of the specified global method call, at the given `index` position.\n * E.g., for given `index === 1`, this function checks for `objectName.methodName(foo, node)`, where objectName is a global variable.\n * @param {ASTNode} node The node to check.\n * @param {Scope} scope Scope to which the node belongs.\n * @param {string} objectName Name of the global object.\n * @param {string} methodName Name of the method.\n * @param {number} index The given position.\n * @returns {boolean} `true` if the node is argument at the given position.\n */\nfunction isArgumentOfGlobalMethodCall(node, scope, objectName, methodName, index) {\n    const parent = node.parent;\n\n    return parent.type === \"CallExpression\" &&\n        parent.arguments[index] === node &&\n        parent.callee.type === \"MemberExpression\" &&\n        astUtils$1.getStaticPropertyName(parent.callee) === methodName &&\n        parent.callee.object.type === \"Identifier\" &&\n        parent.callee.object.name === objectName &&\n        isGlobalReference(parent.callee.object, scope);\n}\n\n/**\n * Determines whether the given node is used as a property descriptor.\n * @param {ASTNode} node The node to check.\n * @param {Scope} scope Scope to which the node belongs.\n * @returns {boolean} `true` if the node is a property descriptor.\n */\nfunction isPropertyDescriptor$1(node, scope) {\n    if (\n        isArgumentOfGlobalMethodCall(node, scope, \"Object\", \"defineProperty\", 2) ||\n        isArgumentOfGlobalMethodCall(node, scope, \"Reflect\", \"defineProperty\", 2)\n    ) {\n        return true;\n    }\n\n    const parent = node.parent;\n\n    if (\n        parent.type === \"Property\" &&\n        parent.value === node\n    ) {\n        const grandparent = parent.parent;\n\n        if (\n            grandparent.type === \"ObjectExpression\" &&\n            (\n                isArgumentOfGlobalMethodCall(grandparent, scope, \"Object\", \"create\", 1) ||\n                isArgumentOfGlobalMethodCall(grandparent, scope, \"Object\", \"defineProperties\", 1)\n            )\n        ) {\n            return true;\n        }\n    }\n\n    return false;\n}\n\n/**\n * Determines whether the given function node is used as a setter function.\n * @param {ASTNode} node The node to check.\n * @param {Scope} scope Scope to which the node belongs.\n * @returns {boolean} `true` if the node is a setter.\n */\nfunction isSetter(node, scope) {\n    const parent = node.parent;\n\n    if (\n        parent.kind === \"set\" &&\n        parent.value === node\n    ) {\n\n        // Setter in an object literal or in a class\n        return true;\n    }\n\n    if (\n        parent.type === \"Property\" &&\n        parent.value === node &&\n        astUtils$1.getStaticPropertyName(parent) === \"set\" &&\n        parent.parent.type === \"ObjectExpression\" &&\n        isPropertyDescriptor$1(parent.parent, scope)\n    ) {\n\n        // Setter in a property descriptor\n        return true;\n    }\n\n    return false;\n}\n\n/**\n * Finds function's outer scope.\n * @param {Scope} scope Function's own scope.\n * @returns {Scope} Function's outer scope.\n */\nfunction getOuterScope(scope) {\n    const upper = scope.upper;\n\n    if (upper.type === \"function-expression-name\") {\n        return upper.upper;\n    }\n\n    return upper;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noSetterReturn = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow returning values from setters\",\n            category: \"Possible Errors\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-setter-return\"\n        },\n\n        schema: [],\n\n        messages: {\n            returnsValue: \"Setter cannot return a value.\"\n        }\n    },\n\n    create(context) {\n        let funcInfo = null;\n\n        /**\n         * Creates and pushes to the stack a function info object for the given function node.\n         * @param {ASTNode} node The function node.\n         * @returns {void}\n         */\n        function enterFunction(node) {\n            const outerScope = getOuterScope(context.getScope());\n\n            funcInfo = {\n                upper: funcInfo,\n                isSetter: isSetter(node, outerScope)\n            };\n        }\n\n        /**\n         * Pops the current function info object from the stack.\n         * @returns {void}\n         */\n        function exitFunction() {\n            funcInfo = funcInfo.upper;\n        }\n\n        /**\n         * Reports the given node.\n         * @param {ASTNode} node Node to report.\n         * @returns {void}\n         */\n        function report(node) {\n            context.report({ node, messageId: \"returnsValue\" });\n        }\n\n        return {\n\n            /*\n             * Function declarations cannot be setters, but we still have to track them in the `funcInfo` stack to avoid\n             * false positives, because a ReturnStatement node can belong to a function declaration inside a setter.\n             *\n             * Note: A previously declared function can be referenced and actually used as a setter in a property descriptor,\n             * but that's out of scope for this rule.\n             */\n            FunctionDeclaration: enterFunction,\n            FunctionExpression: enterFunction,\n            ArrowFunctionExpression(node) {\n                enterFunction(node);\n\n                if (funcInfo.isSetter && node.expression) {\n\n                    // { set: foo => bar } property descriptor. Report implicit return 'bar' as the equivalent for a return statement.\n                    report(node.body);\n                }\n            },\n\n            \"FunctionDeclaration:exit\": exitFunction,\n            \"FunctionExpression:exit\": exitFunction,\n            \"ArrowFunctionExpression:exit\": exitFunction,\n\n            ReturnStatement(node) {\n\n                // Global returns (e.g., at the top level of a Node module) don't have `funcInfo`.\n                if (funcInfo && funcInfo.isSetter && node.argument) {\n                    report(node);\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noShadow = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow variable declarations from shadowing variables declared in the outer scope\",\n            category: \"Variables\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-shadow\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    builtinGlobals: { type: \"boolean\", default: false },\n                    hoist: { enum: [\"all\", \"functions\", \"never\"], default: \"functions\" },\n                    allow: {\n                        type: \"array\",\n                        items: {\n                            type: \"string\"\n                        }\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n\n        const options = {\n            builtinGlobals: context.options[0] && context.options[0].builtinGlobals,\n            hoist: (context.options[0] && context.options[0].hoist) || \"functions\",\n            allow: (context.options[0] && context.options[0].allow) || []\n        };\n\n        /**\n         * Check if variable name is allowed.\n         * @param  {ASTNode} variable The variable to check.\n         * @returns {boolean} Whether or not the variable name is allowed.\n         */\n        function isAllowed(variable) {\n            return options.allow.indexOf(variable.name) !== -1;\n        }\n\n        /**\n         * Checks if a variable of the class name in the class scope of ClassDeclaration.\n         *\n         * ClassDeclaration creates two variables of its name into its outer scope and its class scope.\n         * So we should ignore the variable in the class scope.\n         * @param {Object} variable The variable to check.\n         * @returns {boolean} Whether or not the variable of the class name in the class scope of ClassDeclaration.\n         */\n        function isDuplicatedClassNameVariable(variable) {\n            const block = variable.scope.block;\n\n            return block.type === \"ClassDeclaration\" && block.id === variable.identifiers[0];\n        }\n\n        /**\n         * Checks if a variable is inside the initializer of scopeVar.\n         *\n         * To avoid reporting at declarations such as `var a = function a() {};`.\n         * But it should report `var a = function(a) {};` or `var a = function() { function a() {} };`.\n         * @param {Object} variable The variable to check.\n         * @param {Object} scopeVar The scope variable to look for.\n         * @returns {boolean} Whether or not the variable is inside initializer of scopeVar.\n         */\n        function isOnInitializer(variable, scopeVar) {\n            const outerScope = scopeVar.scope;\n            const outerDef = scopeVar.defs[0];\n            const outer = outerDef && outerDef.parent && outerDef.parent.range;\n            const innerScope = variable.scope;\n            const innerDef = variable.defs[0];\n            const inner = innerDef && innerDef.name.range;\n\n            return (\n                outer &&\n                inner &&\n                outer[0] < inner[0] &&\n                inner[1] < outer[1] &&\n                ((innerDef.type === \"FunctionName\" && innerDef.node.type === \"FunctionExpression\") || innerDef.node.type === \"ClassExpression\") &&\n                outerScope === innerScope.upper\n            );\n        }\n\n        /**\n         * Get a range of a variable's identifier node.\n         * @param {Object} variable The variable to get.\n         * @returns {Array|undefined} The range of the variable's identifier node.\n         */\n        function getNameRange(variable) {\n            const def = variable.defs[0];\n\n            return def && def.name.range;\n        }\n\n        /**\n         * Checks if a variable is in TDZ of scopeVar.\n         * @param {Object} variable The variable to check.\n         * @param {Object} scopeVar The variable of TDZ.\n         * @returns {boolean} Whether or not the variable is in TDZ of scopeVar.\n         */\n        function isInTdz(variable, scopeVar) {\n            const outerDef = scopeVar.defs[0];\n            const inner = getNameRange(variable);\n            const outer = getNameRange(scopeVar);\n\n            return (\n                inner &&\n                outer &&\n                inner[1] < outer[0] &&\n\n                // Excepts FunctionDeclaration if is {\"hoist\":\"function\"}.\n                (options.hoist !== \"functions\" || !outerDef || outerDef.node.type !== \"FunctionDeclaration\")\n            );\n        }\n\n        /**\n         * Checks the current context for shadowed variables.\n         * @param {Scope} scope Fixme\n         * @returns {void}\n         */\n        function checkForShadows(scope) {\n            const variables = scope.variables;\n\n            for (let i = 0; i < variables.length; ++i) {\n                const variable = variables[i];\n\n                // Skips \"arguments\" or variables of a class name in the class scope of ClassDeclaration.\n                if (variable.identifiers.length === 0 ||\n                    isDuplicatedClassNameVariable(variable) ||\n                    isAllowed(variable)\n                ) {\n                    continue;\n                }\n\n                // Gets shadowed variable.\n                const shadowed = astUtils$1.getVariableByName(scope.upper, variable.name);\n\n                if (shadowed &&\n                    (shadowed.identifiers.length > 0 || (options.builtinGlobals && \"writeable\" in shadowed)) &&\n                    !isOnInitializer(variable, shadowed) &&\n                    !(options.hoist !== \"all\" && isInTdz(variable, shadowed))\n                ) {\n                    context.report({\n                        node: variable.identifiers[0],\n                        message: \"'{{name}}' is already declared in the upper scope.\",\n                        data: variable\n                    });\n                }\n            }\n        }\n\n        return {\n            \"Program:exit\"() {\n                const globalScope = context.getScope();\n                const stack = globalScope.childScopes.slice();\n\n                while (stack.length) {\n                    const scope = stack.pop();\n\n                    stack.push(...scope.childScopes);\n                    checkForShadows(scope);\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Disallow shadowing of NaN, undefined, and Infinity (ES5 section 15.1.1)\n * @author Michael Ficarra\n */\n\n/**\n * Determines if a variable safely shadows undefined.\n * This is the case when a variable named `undefined` is never assigned to a value (i.e. it always shares the same value\n * as the global).\n * @param {eslintScope.Variable} variable The variable to check\n * @returns {boolean} true if this variable safely shadows `undefined`\n */\nfunction safelyShadowsUndefined(variable) {\n    return variable.name === \"undefined\" &&\n        variable.references.every(ref => !ref.isWrite()) &&\n        variable.defs.every(def => def.node.type === \"VariableDeclarator\" && def.node.init === null);\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noShadowRestrictedNames = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow identifiers from shadowing restricted names\",\n            category: \"Variables\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-shadow-restricted-names\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n\n        const RESTRICTED = new Set([\"undefined\", \"NaN\", \"Infinity\", \"arguments\", \"eval\"]);\n\n        return {\n            \"VariableDeclaration, :function, CatchClause\"(node) {\n                for (const variable of context.getDeclaredVariables(node)) {\n                    if (variable.defs.length > 0 && RESTRICTED.has(variable.name) && !safelyShadowsUndefined(variable)) {\n                        context.report({\n                            node: variable.defs[0].name,\n                            message: \"Shadowing of global property '{{idName}}'.\",\n                            data: {\n                                idName: variable.name\n                            }\n                        });\n                    }\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to check that spaced function application\n * @author Matt DuVall <http://www.mattduvall.com>\n * @deprecated in ESLint v3.3.0\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noSpacedFunc = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"disallow spacing between function identifiers and their applications (deprecated)\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-spaced-func\"\n        },\n\n        deprecated: true,\n\n        replacedBy: [\"func-call-spacing\"],\n\n        fixable: \"whitespace\",\n        schema: []\n    },\n\n    create(context) {\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Check if open space is present in a function name\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function detectOpenSpaces(node) {\n            const lastCalleeToken = sourceCode.getLastToken(node.callee);\n            let prevToken = lastCalleeToken,\n                parenToken = sourceCode.getTokenAfter(lastCalleeToken);\n\n            // advances to an open parenthesis.\n            while (\n                parenToken &&\n                parenToken.range[1] < node.range[1] &&\n                parenToken.value !== \"(\"\n            ) {\n                prevToken = parenToken;\n                parenToken = sourceCode.getTokenAfter(parenToken);\n            }\n\n            // look for a space between the callee and the open paren\n            if (parenToken &&\n                parenToken.range[1] < node.range[1] &&\n                sourceCode.isSpaceBetweenTokens(prevToken, parenToken)\n            ) {\n                context.report({\n                    node,\n                    loc: lastCalleeToken.loc.start,\n                    message: \"Unexpected space between function name and paren.\",\n                    fix(fixer) {\n                        return fixer.removeRange([prevToken.range[1], parenToken.range[0]]);\n                    }\n                });\n            }\n        }\n\n        return {\n            CallExpression: detectOpenSpaces,\n            NewExpression: detectOpenSpaces\n        };\n\n    }\n};\n\n/**\n * @fileoverview Disallow sparse arrays\n * @author Nicholas C. Zakas\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noSparseArrays = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow sparse arrays\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-sparse-arrays\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n\n            ArrayExpression(node) {\n\n                const emptySpot = node.elements.indexOf(null) > -1;\n\n                if (emptySpot) {\n                    context.report({ node, message: \"Unexpected comma in middle of array.\" });\n                }\n            }\n\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to check for properties whose identifier ends with the string Sync\n * @author Matt DuVall<http://mattduvall.com/>\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noSync = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow synchronous methods\",\n            category: \"Node.js and CommonJS\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-sync\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allowAtRootLevel: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const selector = context.options[0] && context.options[0].allowAtRootLevel\n            ? \":function MemberExpression[property.name=/.*Sync$/]\"\n            : \"MemberExpression[property.name=/.*Sync$/]\";\n\n        return {\n            [selector](node) {\n                context.report({\n                    node,\n                    message: \"Unexpected sync method: '{{propertyName}}'.\",\n                    data: {\n                        propertyName: node.property.name\n                    }\n                });\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to check for tabs inside a file\n * @author Gyandeep Singh\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst tabRegex = /\\t+/gu;\nconst anyNonWhitespaceRegex = /\\S/u;\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nvar noTabs = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"disallow all tabs\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-tabs\"\n        },\n        schema: [{\n            type: \"object\",\n            properties: {\n                allowIndentationTabs: {\n                    type: \"boolean\",\n                    default: false\n                }\n            },\n            additionalProperties: false\n        }]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const allowIndentationTabs = context.options && context.options[0] && context.options[0].allowIndentationTabs;\n\n        return {\n            Program(node) {\n                sourceCode.getLines().forEach((line, index) => {\n                    let match;\n\n                    while ((match = tabRegex.exec(line)) !== null) {\n                        if (allowIndentationTabs && !anyNonWhitespaceRegex.test(line.slice(0, match.index))) {\n                            continue;\n                        }\n\n                        context.report({\n                            node,\n                            loc: {\n                                start: {\n                                    line: index + 1,\n                                    column: match.index\n                                },\n                                end: {\n                                    line: index + 1,\n                                    column: match.index + match[0].length\n                                }\n                            },\n                            message: \"Unexpected tab character.\"\n                        });\n                    }\n                });\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Warn when using template string syntax in regular strings\n * @author Jeroen Engels\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noTemplateCurlyInString = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow template literal placeholder syntax in regular strings\",\n            category: \"Possible Errors\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-template-curly-in-string\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        const regex = /\\$\\{[^}]+\\}/u;\n\n        return {\n            Literal(node) {\n                if (typeof node.value === \"string\" && regex.test(node.value)) {\n                    context.report({\n                        node,\n                        message: \"Unexpected template string expression.\"\n                    });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag use of ternary operators.\n * @author Ian Christian Myers\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noTernary = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow ternary operators\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-ternary\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        return {\n\n            ConditionalExpression(node) {\n                context.report({ node, message: \"Ternary operator used.\" });\n            }\n\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not a given node is a constructor.\n * @param {ASTNode} node A node to check. This node type is one of\n *   `Program`, `FunctionDeclaration`, `FunctionExpression`, and\n *   `ArrowFunctionExpression`.\n * @returns {boolean} `true` if the node is a constructor.\n */\nfunction isConstructorFunction$1(node) {\n    return (\n        node.type === \"FunctionExpression\" &&\n        node.parent.type === \"MethodDefinition\" &&\n        node.parent.kind === \"constructor\"\n    );\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noThisBeforeSuper = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow `this`/`super` before calling `super()` in constructors\",\n            category: \"ECMAScript 6\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-this-before-super\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        /*\n         * Information for each constructor.\n         * - upper:      Information of the upper constructor.\n         * - hasExtends: A flag which shows whether the owner class has a valid\n         *   `extends` part.\n         * - scope:      The scope of the owner class.\n         * - codePath:   The code path of this constructor.\n         */\n        let funcInfo = null;\n\n        /*\n         * Information for each code path segment.\n         * Each key is the id of a code path segment.\n         * Each value is an object:\n         * - superCalled:  The flag which shows `super()` called in all code paths.\n         * - invalidNodes: The array of invalid ThisExpression and Super nodes.\n         */\n        let segInfoMap = Object.create(null);\n\n        /**\n         * Gets whether or not `super()` is called in a given code path segment.\n         * @param {CodePathSegment} segment A code path segment to get.\n         * @returns {boolean} `true` if `super()` is called.\n         */\n        function isCalled(segment) {\n            return !segment.reachable || segInfoMap[segment.id].superCalled;\n        }\n\n        /**\n         * Checks whether or not this is in a constructor.\n         * @returns {boolean} `true` if this is in a constructor.\n         */\n        function isInConstructorOfDerivedClass() {\n            return Boolean(funcInfo && funcInfo.isConstructor && funcInfo.hasExtends);\n        }\n\n        /**\n         * Checks whether or not this is before `super()` is called.\n         * @returns {boolean} `true` if this is before `super()` is called.\n         */\n        function isBeforeCallOfSuper() {\n            return (\n                isInConstructorOfDerivedClass() &&\n                !funcInfo.codePath.currentSegments.every(isCalled)\n            );\n        }\n\n        /**\n         * Sets a given node as invalid.\n         * @param {ASTNode} node A node to set as invalid. This is one of\n         *      a ThisExpression and a Super.\n         * @returns {void}\n         */\n        function setInvalid(node) {\n            const segments = funcInfo.codePath.currentSegments;\n\n            for (let i = 0; i < segments.length; ++i) {\n                const segment = segments[i];\n\n                if (segment.reachable) {\n                    segInfoMap[segment.id].invalidNodes.push(node);\n                }\n            }\n        }\n\n        /**\n         * Sets the current segment as `super` was called.\n         * @returns {void}\n         */\n        function setSuperCalled() {\n            const segments = funcInfo.codePath.currentSegments;\n\n            for (let i = 0; i < segments.length; ++i) {\n                const segment = segments[i];\n\n                if (segment.reachable) {\n                    segInfoMap[segment.id].superCalled = true;\n                }\n            }\n        }\n\n        return {\n\n            /**\n             * Adds information of a constructor into the stack.\n             * @param {CodePath} codePath A code path which was started.\n             * @param {ASTNode} node The current node.\n             * @returns {void}\n             */\n            onCodePathStart(codePath, node) {\n                if (isConstructorFunction$1(node)) {\n\n                    // Class > ClassBody > MethodDefinition > FunctionExpression\n                    const classNode = node.parent.parent.parent;\n\n                    funcInfo = {\n                        upper: funcInfo,\n                        isConstructor: true,\n                        hasExtends: Boolean(\n                            classNode.superClass &&\n                            !astUtils$1.isNullOrUndefined(classNode.superClass)\n                        ),\n                        codePath\n                    };\n                } else {\n                    funcInfo = {\n                        upper: funcInfo,\n                        isConstructor: false,\n                        hasExtends: false,\n                        codePath\n                    };\n                }\n            },\n\n            /**\n             * Removes the top of stack item.\n             *\n             * And this treverses all segments of this code path then reports every\n             * invalid node.\n             * @param {CodePath} codePath A code path which was ended.\n             * @returns {void}\n             */\n            onCodePathEnd(codePath) {\n                const isDerivedClass = funcInfo.hasExtends;\n\n                funcInfo = funcInfo.upper;\n                if (!isDerivedClass) {\n                    return;\n                }\n\n                codePath.traverseSegments((segment, controller) => {\n                    const info = segInfoMap[segment.id];\n\n                    for (let i = 0; i < info.invalidNodes.length; ++i) {\n                        const invalidNode = info.invalidNodes[i];\n\n                        context.report({\n                            message: \"'{{kind}}' is not allowed before 'super()'.\",\n                            node: invalidNode,\n                            data: {\n                                kind: invalidNode.type === \"Super\" ? \"super\" : \"this\"\n                            }\n                        });\n                    }\n\n                    if (info.superCalled) {\n                        controller.skip();\n                    }\n                });\n            },\n\n            /**\n             * Initialize information of a given code path segment.\n             * @param {CodePathSegment} segment A code path segment to initialize.\n             * @returns {void}\n             */\n            onCodePathSegmentStart(segment) {\n                if (!isInConstructorOfDerivedClass()) {\n                    return;\n                }\n\n                // Initialize info.\n                segInfoMap[segment.id] = {\n                    superCalled: (\n                        segment.prevSegments.length > 0 &&\n                        segment.prevSegments.every(isCalled)\n                    ),\n                    invalidNodes: []\n                };\n            },\n\n            /**\n             * Update information of the code path segment when a code path was\n             * looped.\n             * @param {CodePathSegment} fromSegment The code path segment of the\n             *      end of a loop.\n             * @param {CodePathSegment} toSegment A code path segment of the head\n             *      of a loop.\n             * @returns {void}\n             */\n            onCodePathSegmentLoop(fromSegment, toSegment) {\n                if (!isInConstructorOfDerivedClass()) {\n                    return;\n                }\n\n                // Update information inside of the loop.\n                funcInfo.codePath.traverseSegments(\n                    { first: toSegment, last: fromSegment },\n                    (segment, controller) => {\n                        const info = segInfoMap[segment.id];\n\n                        if (info.superCalled) {\n                            info.invalidNodes = [];\n                            controller.skip();\n                        } else if (\n                            segment.prevSegments.length > 0 &&\n                            segment.prevSegments.every(isCalled)\n                        ) {\n                            info.superCalled = true;\n                            info.invalidNodes = [];\n                        }\n                    }\n                );\n            },\n\n            /**\n             * Reports if this is before `super()`.\n             * @param {ASTNode} node A target node.\n             * @returns {void}\n             */\n            ThisExpression(node) {\n                if (isBeforeCallOfSuper()) {\n                    setInvalid(node);\n                }\n            },\n\n            /**\n             * Reports if this is before `super()`.\n             * @param {ASTNode} node A target node.\n             * @returns {void}\n             */\n            Super(node) {\n                if (!astUtils$1.isCallee(node) && isBeforeCallOfSuper()) {\n                    setInvalid(node);\n                }\n            },\n\n            /**\n             * Marks `super()` called.\n             * @param {ASTNode} node A target node.\n             * @returns {void}\n             */\n            \"CallExpression:exit\"(node) {\n                if (node.callee.type === \"Super\" && isBeforeCallOfSuper()) {\n                    setSuperCalled();\n                }\n            },\n\n            /**\n             * Resets state.\n             * @returns {void}\n             */\n            \"Program:exit\"() {\n                segInfoMap = Object.create(null);\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noThrowLiteral = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow throwing literals as exceptions\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-throw-literal\"\n        },\n\n        schema: [],\n\n        messages: {\n            object: \"Expected an error object to be thrown.\",\n            undef: \"Do not throw undefined.\"\n        }\n    },\n\n    create(context) {\n\n        return {\n\n            ThrowStatement(node) {\n                if (!astUtils$1.couldBeError(node.argument)) {\n                    context.report({ node, messageId: \"object\" });\n                } else if (node.argument.type === \"Identifier\") {\n                    if (node.argument.name === \"undefined\") {\n                        context.report({ node, messageId: \"undef\" });\n                    }\n                }\n\n            }\n\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noTrailingSpaces = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"disallow trailing whitespace at the end of lines\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-trailing-spaces\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    skipBlankLines: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    ignoreComments: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        const BLANK_CLASS = \"[ \\t\\u00a0\\u2000-\\u200b\\u3000]\",\n            SKIP_BLANK = `^${BLANK_CLASS}*$`,\n            NONBLANK = `${BLANK_CLASS}+$`;\n\n        const options = context.options[0] || {},\n            skipBlankLines = options.skipBlankLines || false,\n            ignoreComments = options.ignoreComments || false;\n\n        /**\n         * Report the error message\n         * @param {ASTNode} node node to report\n         * @param {int[]} location range information\n         * @param {int[]} fixRange Range based on the whole program\n         * @returns {void}\n         */\n        function report(node, location, fixRange) {\n\n            /*\n             * Passing node is a bit dirty, because message data will contain big\n             * text in `source`. But... who cares :) ?\n             * One more kludge will not make worse the bloody wizardry of this\n             * plugin.\n             */\n            context.report({\n                node,\n                loc: location,\n                message: \"Trailing spaces not allowed.\",\n                fix(fixer) {\n                    return fixer.removeRange(fixRange);\n                }\n            });\n        }\n\n        /**\n         * Given a list of comment nodes, return the line numbers for those comments.\n         * @param {Array} comments An array of comment nodes.\n         * @returns {number[]} An array of line numbers containing comments.\n         */\n        function getCommentLineNumbers(comments) {\n            const lines = new Set();\n\n            comments.forEach(comment => {\n                const endLine = comment.type === \"Block\"\n                    ? comment.loc.end.line - 1\n                    : comment.loc.end.line;\n\n                for (let i = comment.loc.start.line; i <= endLine; i++) {\n                    lines.add(i);\n                }\n            });\n\n            return lines;\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n\n            Program: function checkTrailingSpaces(node) {\n\n                /*\n                 * Let's hack. Since Espree does not return whitespace nodes,\n                 * fetch the source code and do matching via regexps.\n                 */\n\n                const re = new RegExp(NONBLANK, \"u\"),\n                    skipMatch = new RegExp(SKIP_BLANK, \"u\"),\n                    lines = sourceCode.lines,\n                    linebreaks = sourceCode.getText().match(astUtils$1.createGlobalLinebreakMatcher()),\n                    comments = sourceCode.getAllComments(),\n                    commentLineNumbers = getCommentLineNumbers(comments);\n\n                let totalLength = 0,\n                    fixRange = [];\n\n                for (let i = 0, ii = lines.length; i < ii; i++) {\n                    const lineNumber = i + 1;\n\n                    /*\n                     * Always add linebreak length to line length to accommodate for line break (\\n or \\r\\n)\n                     * Because during the fix time they also reserve one spot in the array.\n                     * Usually linebreak length is 2 for \\r\\n (CRLF) and 1 for \\n (LF)\n                     */\n                    const linebreakLength = linebreaks && linebreaks[i] ? linebreaks[i].length : 1;\n                    const lineLength = lines[i].length + linebreakLength;\n\n                    const matches = re.exec(lines[i]);\n\n                    if (matches) {\n                        const location = {\n                            start: {\n                                line: lineNumber,\n                                column: matches.index\n                            },\n                            end: {\n                                line: lineNumber,\n                                column: lineLength - linebreakLength\n                            }\n                        };\n\n                        const rangeStart = totalLength + location.start.column;\n                        const rangeEnd = totalLength + location.end.column;\n                        const containingNode = sourceCode.getNodeByRangeIndex(rangeStart);\n\n                        if (containingNode && containingNode.type === \"TemplateElement\" &&\n                          rangeStart > containingNode.parent.range[0] &&\n                          rangeEnd < containingNode.parent.range[1]) {\n                            totalLength += lineLength;\n                            continue;\n                        }\n\n                        /*\n                         * If the line has only whitespace, and skipBlankLines\n                         * is true, don't report it\n                         */\n                        if (skipBlankLines && skipMatch.test(lines[i])) {\n                            totalLength += lineLength;\n                            continue;\n                        }\n\n                        fixRange = [rangeStart, rangeEnd];\n\n                        if (!ignoreComments || !commentLineNumbers.has(lineNumber)) {\n                            report(node, location, fixRange);\n                        }\n                    }\n\n                    totalLength += lineLength;\n                }\n            }\n\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag references to undeclared variables.\n * @author Mark Macdonald\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks if the given node is the argument of a typeof operator.\n * @param {ASTNode} node The AST node being checked.\n * @returns {boolean} Whether or not the node is the argument of a typeof operator.\n */\nfunction hasTypeOfOperator(node) {\n    const parent = node.parent;\n\n    return parent.type === \"UnaryExpression\" && parent.operator === \"typeof\";\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUndef = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow the use of undeclared variables unless mentioned in `/*global */` comments\",\n            category: \"Variables\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-undef\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    typeof: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n        messages: {\n            undef: \"'{{name}}' is not defined.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options[0];\n        const considerTypeOf = options && options.typeof === true || false;\n\n        return {\n            \"Program:exit\"(/* node */) {\n                const globalScope = context.getScope();\n\n                globalScope.through.forEach(ref => {\n                    const identifier = ref.identifier;\n\n                    if (!considerTypeOf && hasTypeOfOperator(identifier)) {\n                        return;\n                    }\n\n                    context.report({\n                        node: identifier,\n                        messageId: \"undef\",\n                        data: identifier\n                    });\n                });\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUndefInit = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow initializing variables to `undefined`\",\n            category: \"Variables\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-undef-init\"\n        },\n\n        schema: [],\n        fixable: \"code\"\n    },\n\n    create(context) {\n\n        const sourceCode = context.getSourceCode();\n\n        return {\n\n            VariableDeclarator(node) {\n                const name = sourceCode.getText(node.id),\n                    init = node.init && node.init.name,\n                    scope = context.getScope(),\n                    undefinedVar = astUtils$1.getVariableByName(scope, \"undefined\"),\n                    shadowed = undefinedVar && undefinedVar.defs.length > 0,\n                    lastToken = sourceCode.getLastToken(node);\n\n                if (init === \"undefined\" && node.parent.kind !== \"const\" && !shadowed) {\n                    context.report({\n                        node,\n                        message: \"It's not necessary to initialize '{{name}}' to undefined.\",\n                        data: { name },\n                        fix(fixer) {\n                            if (node.parent.kind === \"var\") {\n                                return null;\n                            }\n\n                            if (node.id.type === \"ArrayPattern\" || node.id.type === \"ObjectPattern\") {\n\n                                // Don't fix destructuring assignment to `undefined`.\n                                return null;\n                            }\n\n                            if (sourceCode.commentsExistBetween(node.id, lastToken)) {\n                                return null;\n                            }\n\n                            return fixer.removeRange([node.id.range[1], node.range[1]]);\n                        }\n                    });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag references to the undefined variable.\n * @author Michael Ficarra\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUndefined = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow the use of `undefined` as an identifier\",\n            category: \"Variables\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-undefined\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        /**\n         * Report an invalid \"undefined\" identifier node.\n         * @param {ASTNode} node The node to report.\n         * @returns {void}\n         */\n        function report(node) {\n            context.report({\n                node,\n                message: \"Unexpected use of undefined.\"\n            });\n        }\n\n        /**\n         * Checks the given scope for references to `undefined` and reports\n         * all references found.\n         * @param {eslint-scope.Scope} scope The scope to check.\n         * @returns {void}\n         */\n        function checkScope(scope) {\n            const undefinedVar = scope.set.get(\"undefined\");\n\n            if (!undefinedVar) {\n                return;\n            }\n\n            const references = undefinedVar.references;\n\n            const defs = undefinedVar.defs;\n\n            // Report non-initializing references (those are covered in defs below)\n            references\n                .filter(ref => !ref.init)\n                .forEach(ref => report(ref.identifier));\n\n            defs.forEach(def => report(def.name));\n        }\n\n        return {\n            \"Program:exit\"() {\n                const globalScope = context.getScope();\n\n                const stack = [globalScope];\n\n                while (stack.length) {\n                    const scope = stack.pop();\n\n                    stack.push(...scope.childScopes);\n                    checkScope(scope);\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag trailing underscores in variable declarations.\n * @author Matt DuVall <http://www.mattduvall.com>\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUnderscoreDangle = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow dangling underscores in identifiers\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-underscore-dangle\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allow: {\n                        type: \"array\",\n                        items: {\n                            type: \"string\"\n                        }\n                    },\n                    allowAfterThis: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    allowAfterSuper: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    allowAfterThisConstructor: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    enforceInMethodNames: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n\n        const options = context.options[0] || {};\n        const ALLOWED_VARIABLES = options.allow ? options.allow : [];\n        const allowAfterThis = typeof options.allowAfterThis !== \"undefined\" ? options.allowAfterThis : false;\n        const allowAfterSuper = typeof options.allowAfterSuper !== \"undefined\" ? options.allowAfterSuper : false;\n        const allowAfterThisConstructor = typeof options.allowAfterThisConstructor !== \"undefined\" ? options.allowAfterThisConstructor : false;\n        const enforceInMethodNames = typeof options.enforceInMethodNames !== \"undefined\" ? options.enforceInMethodNames : false;\n\n        //-------------------------------------------------------------------------\n        // Helpers\n        //-------------------------------------------------------------------------\n\n        /**\n         * Check if identifier is present inside the allowed option\n         * @param {string} identifier name of the node\n         * @returns {boolean} true if its is present\n         * @private\n         */\n        function isAllowed(identifier) {\n            return ALLOWED_VARIABLES.some(ident => ident === identifier);\n        }\n\n        /**\n         * Check if identifier has a underscore at the end\n         * @param {string} identifier name of the node\n         * @returns {boolean} true if its is present\n         * @private\n         */\n        function hasTrailingUnderscore(identifier) {\n            const len = identifier.length;\n\n            return identifier !== \"_\" && (identifier[0] === \"_\" || identifier[len - 1] === \"_\");\n        }\n\n        /**\n         * Check if identifier is a special case member expression\n         * @param {string} identifier name of the node\n         * @returns {boolean} true if its is a special case\n         * @private\n         */\n        function isSpecialCaseIdentifierForMemberExpression(identifier) {\n            return identifier === \"__proto__\";\n        }\n\n        /**\n         * Check if identifier is a special case variable expression\n         * @param {string} identifier name of the node\n         * @returns {boolean} true if its is a special case\n         * @private\n         */\n        function isSpecialCaseIdentifierInVariableExpression(identifier) {\n\n            // Checks for the underscore library usage here\n            return identifier === \"_\";\n        }\n\n        /**\n         * Check if a node is a member reference of this.constructor\n         * @param {ASTNode} node node to evaluate\n         * @returns {boolean} true if it is a reference on this.constructor\n         * @private\n         */\n        function isThisConstructorReference(node) {\n            return node.object.type === \"MemberExpression\" &&\n                node.object.property.name === \"constructor\" &&\n                node.object.object.type === \"ThisExpression\";\n        }\n\n        /**\n         * Check if function has a underscore at the end\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function checkForTrailingUnderscoreInFunctionDeclaration(node) {\n            if (node.id) {\n                const identifier = node.id.name;\n\n                if (typeof identifier !== \"undefined\" && hasTrailingUnderscore(identifier) && !isAllowed(identifier)) {\n                    context.report({\n                        node,\n                        message: \"Unexpected dangling '_' in '{{identifier}}'.\",\n                        data: {\n                            identifier\n                        }\n                    });\n                }\n            }\n        }\n\n        /**\n         * Check if variable expression has a underscore at the end\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function checkForTrailingUnderscoreInVariableExpression(node) {\n            const identifier = node.id.name;\n\n            if (typeof identifier !== \"undefined\" && hasTrailingUnderscore(identifier) &&\n                !isSpecialCaseIdentifierInVariableExpression(identifier) && !isAllowed(identifier)) {\n                context.report({\n                    node,\n                    message: \"Unexpected dangling '_' in '{{identifier}}'.\",\n                    data: {\n                        identifier\n                    }\n                });\n            }\n        }\n\n        /**\n         * Check if member expression has a underscore at the end\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function checkForTrailingUnderscoreInMemberExpression(node) {\n            const identifier = node.property.name,\n                isMemberOfThis = node.object.type === \"ThisExpression\",\n                isMemberOfSuper = node.object.type === \"Super\",\n                isMemberOfThisConstructor = isThisConstructorReference(node);\n\n            if (typeof identifier !== \"undefined\" && hasTrailingUnderscore(identifier) &&\n                !(isMemberOfThis && allowAfterThis) &&\n                !(isMemberOfSuper && allowAfterSuper) &&\n                !(isMemberOfThisConstructor && allowAfterThisConstructor) &&\n                !isSpecialCaseIdentifierForMemberExpression(identifier) && !isAllowed(identifier)) {\n                context.report({\n                    node,\n                    message: \"Unexpected dangling '_' in '{{identifier}}'.\",\n                    data: {\n                        identifier\n                    }\n                });\n            }\n        }\n\n        /**\n         * Check if method declaration or method property has a underscore at the end\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function checkForTrailingUnderscoreInMethod(node) {\n            const identifier = node.key.name;\n            const isMethod = node.type === \"MethodDefinition\" || node.type === \"Property\" && node.method;\n\n            if (typeof identifier !== \"undefined\" && enforceInMethodNames && isMethod && hasTrailingUnderscore(identifier)) {\n                context.report({\n                    node,\n                    message: \"Unexpected dangling '_' in '{{identifier}}'.\",\n                    data: {\n                        identifier\n                    }\n                });\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n            FunctionDeclaration: checkForTrailingUnderscoreInFunctionDeclaration,\n            VariableDeclarator: checkForTrailingUnderscoreInVariableExpression,\n            MemberExpression: checkForTrailingUnderscoreInMemberExpression,\n            MethodDefinition: checkForTrailingUnderscoreInMethod,\n            Property: checkForTrailingUnderscoreInMethod\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUnexpectedMultiline = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow confusing multiline expressions\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-unexpected-multiline\"\n        },\n\n        schema: [],\n        messages: {\n            function: \"Unexpected newline between function and ( of function call.\",\n            property: \"Unexpected newline between object and [ of property access.\",\n            taggedTemplate: \"Unexpected newline between template tag and template literal.\",\n            division: \"Unexpected newline between numerator and division operator.\"\n        }\n    },\n\n    create(context) {\n\n        const REGEX_FLAG_MATCHER = /^[gimsuy]+$/u;\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Check to see if there is a newline between the node and the following open bracket\n         * line's expression\n         * @param {ASTNode} node The node to check.\n         * @param {string} messageId The error messageId to use.\n         * @returns {void}\n         * @private\n         */\n        function checkForBreakAfter(node, messageId) {\n            const openParen = sourceCode.getTokenAfter(node, astUtils$1.isNotClosingParenToken);\n            const nodeExpressionEnd = sourceCode.getTokenBefore(openParen);\n\n            if (openParen.loc.start.line !== nodeExpressionEnd.loc.end.line) {\n                context.report({ node, loc: openParen.loc.start, messageId, data: { char: openParen.value } });\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n\n            MemberExpression(node) {\n                if (!node.computed) {\n                    return;\n                }\n                checkForBreakAfter(node.object, \"property\");\n            },\n\n            TaggedTemplateExpression(node) {\n                if (node.tag.loc.end.line === node.quasi.loc.start.line) {\n                    return;\n                }\n\n                // handle generics type parameters on template tags\n                const tokenBefore = sourceCode.getTokenBefore(node.quasi);\n\n                if (tokenBefore.loc.end.line === node.quasi.loc.start.line) {\n                    return;\n                }\n\n                context.report({ node, loc: node.loc.start, messageId: \"taggedTemplate\" });\n            },\n\n            CallExpression(node) {\n                if (node.arguments.length === 0) {\n                    return;\n                }\n                checkForBreakAfter(node.callee, \"function\");\n            },\n\n            \"BinaryExpression[operator='/'] > BinaryExpression[operator='/'].left\"(node) {\n                const secondSlash = sourceCode.getTokenAfter(node, token => token.value === \"/\");\n                const tokenAfterOperator = sourceCode.getTokenAfter(secondSlash);\n\n                if (\n                    tokenAfterOperator.type === \"Identifier\" &&\n                    REGEX_FLAG_MATCHER.test(tokenAfterOperator.value) &&\n                    secondSlash.range[1] === tokenAfterOperator.range[0]\n                ) {\n                    checkForBreakAfter(node.left, \"division\");\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\nconst debug$1 = src(\"eslint:traverser\");\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Do nothing.\n * @returns {void}\n */\nfunction noop() {\n\n    // do nothing.\n}\n\n/**\n * Check whether the given value is an ASTNode or not.\n * @param {any} x The value to check.\n * @returns {boolean} `true` if the value is an ASTNode.\n */\nfunction isNode(x) {\n    return x !== null && typeof x === \"object\" && typeof x.type === \"string\";\n}\n\n/**\n * Get the visitor keys of a given node.\n * @param {Object} visitorKeys The map of visitor keys.\n * @param {ASTNode} node The node to get their visitor keys.\n * @returns {string[]} The visitor keys of the node.\n */\nfunction getVisitorKeys(visitorKeys, node) {\n    let keys = visitorKeys[node.type];\n\n    if (!keys) {\n        keys = lib$1.getKeys(node);\n        debug$1(\"Unknown node type \\\"%s\\\": Estimated visitor keys %j\", node.type, keys);\n    }\n\n    return keys;\n}\n\n/**\n * The traverser class to traverse AST trees.\n */\nclass Traverser {\n    constructor() {\n        this._current = null;\n        this._parents = [];\n        this._skipped = false;\n        this._broken = false;\n        this._visitorKeys = null;\n        this._enter = null;\n        this._leave = null;\n    }\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @returns {ASTNode} The current node.\n     */\n    current() {\n        return this._current;\n    }\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @returns {ASTNode[]} The ancestor nodes.\n     */\n    parents() {\n        return this._parents.slice(0);\n    }\n\n    /**\n     * Break the current traversal.\n     * @returns {void}\n     */\n    break() {\n        this._broken = true;\n    }\n\n    /**\n     * Skip child nodes for the current traversal.\n     * @returns {void}\n     */\n    skip() {\n        this._skipped = true;\n    }\n\n    /**\n     * Traverse the given AST tree.\n     * @param {ASTNode} node The root node to traverse.\n     * @param {Object} options The option object.\n     * @param {Object} [options.visitorKeys=DEFAULT_VISITOR_KEYS] The keys of each node types to traverse child nodes. Default is `./default-visitor-keys.json`.\n     * @param {Function} [options.enter=noop] The callback function which is called on entering each node.\n     * @param {Function} [options.leave=noop] The callback function which is called on leaving each node.\n     * @returns {void}\n     */\n    traverse(node, options) {\n        this._current = null;\n        this._parents = [];\n        this._skipped = false;\n        this._broken = false;\n        this._visitorKeys = options.visitorKeys || lib$1.KEYS;\n        this._enter = options.enter || noop;\n        this._leave = options.leave || noop;\n        this._traverse(node, null);\n    }\n\n    /**\n     * Traverse the given AST tree recursively.\n     * @param {ASTNode} node The current node.\n     * @param {ASTNode|null} parent The parent node.\n     * @returns {void}\n     * @private\n     */\n    _traverse(node, parent) {\n        if (!isNode(node)) {\n            return;\n        }\n\n        this._current = node;\n        this._skipped = false;\n        this._enter(node, parent);\n\n        if (!this._skipped && !this._broken) {\n            const keys = getVisitorKeys(this._visitorKeys, node);\n\n            if (keys.length >= 1) {\n                this._parents.push(node);\n                for (let i = 0; i < keys.length && !this._broken; ++i) {\n                    const child = node[keys[i]];\n\n                    if (Array.isArray(child)) {\n                        for (let j = 0; j < child.length && !this._broken; ++j) {\n                            this._traverse(child[j], node);\n                        }\n                    } else {\n                        this._traverse(child, node);\n                    }\n                }\n                this._parents.pop();\n            }\n        }\n\n        if (!this._broken) {\n            this._leave(node, parent);\n        }\n\n        this._current = parent;\n    }\n\n    /**\n     * Calculates the keys to use for traversal.\n     * @param {ASTNode} node The node to read keys from.\n     * @returns {string[]} An array of keys to visit on the node.\n     * @private\n     */\n    static getKeys(node) {\n        return lib$1.getKeys(node);\n    }\n\n    /**\n     * Traverse the given AST tree.\n     * @param {ASTNode} node The root node to traverse.\n     * @param {Object} options The option object.\n     * @param {Object} [options.visitorKeys=DEFAULT_VISITOR_KEYS] The keys of each node types to traverse child nodes. Default is `./default-visitor-keys.json`.\n     * @param {Function} [options.enter=noop] The callback function which is called on entering each node.\n     * @param {Function} [options.leave=noop] The callback function which is called on leaving each node.\n     * @returns {void}\n     */\n    static traverse(node, options) {\n        new Traverser().traverse(node, options);\n    }\n\n    /**\n     * The default visitor keys.\n     * @type {Object}\n     */\n    static get DEFAULT_VISITOR_KEYS() {\n        return lib$1.KEYS;\n    }\n}\n\nvar traverser = Traverser;\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst SENTINEL_PATTERN = /(?:(?:Call|Class|Function|Member|New|Yield)Expression|Statement|Declaration)$/u;\nconst LOOP_PATTERN = /^(?:DoWhile|For|While)Statement$/u; // for-in/of statements don't have `test` property.\nconst GROUP_PATTERN = /^(?:BinaryExpression|ConditionalExpression)$/u;\nconst SKIP_PATTERN = /^(?:ArrowFunction|Class|Function)Expression$/u;\nconst DYNAMIC_PATTERN = /^(?:Call|Member|New|TaggedTemplate|Yield)Expression$/u;\n\n/**\n * @typedef {Object} LoopConditionInfo\n * @property {eslint-scope.Reference} reference - The reference.\n * @property {ASTNode} group - BinaryExpression or ConditionalExpression nodes\n *      that the reference is belonging to.\n * @property {Function} isInLoop - The predicate which checks a given reference\n *      is in this loop.\n * @property {boolean} modified - The flag that the reference is modified in\n *      this loop.\n */\n\n/**\n * Checks whether or not a given reference is a write reference.\n * @param {eslint-scope.Reference} reference A reference to check.\n * @returns {boolean} `true` if the reference is a write reference.\n */\nfunction isWriteReference(reference) {\n    if (reference.init) {\n        const def = reference.resolved && reference.resolved.defs[0];\n\n        if (!def || def.type !== \"Variable\" || def.parent.kind !== \"var\") {\n            return false;\n        }\n    }\n    return reference.isWrite();\n}\n\n/**\n * Checks whether or not a given loop condition info does not have the modified\n * flag.\n * @param {LoopConditionInfo} condition A loop condition info to check.\n * @returns {boolean} `true` if the loop condition info is \"unmodified\".\n */\nfunction isUnmodified(condition) {\n    return !condition.modified;\n}\n\n/**\n * Checks whether or not a given loop condition info does not have the modified\n * flag and does not have the group this condition belongs to.\n * @param {LoopConditionInfo} condition A loop condition info to check.\n * @returns {boolean} `true` if the loop condition info is \"unmodified\".\n */\nfunction isUnmodifiedAndNotBelongToGroup(condition) {\n    return !(condition.modified || condition.group);\n}\n\n/**\n * Checks whether or not a given reference is inside of a given node.\n * @param {ASTNode} node A node to check.\n * @param {eslint-scope.Reference} reference A reference to check.\n * @returns {boolean} `true` if the reference is inside of the node.\n */\nfunction isInRange(node, reference) {\n    const or = node.range;\n    const ir = reference.identifier.range;\n\n    return or[0] <= ir[0] && ir[1] <= or[1];\n}\n\n/**\n * Checks whether or not a given reference is inside of a loop node's condition.\n * @param {ASTNode} node A node to check.\n * @param {eslint-scope.Reference} reference A reference to check.\n * @returns {boolean} `true` if the reference is inside of the loop node's\n *      condition.\n */\nconst isInLoop = {\n    WhileStatement: isInRange,\n    DoWhileStatement: isInRange,\n    ForStatement(node, reference) {\n        return (\n            isInRange(node, reference) &&\n            !(node.init && isInRange(node.init, reference))\n        );\n    }\n};\n\n/**\n * Gets the function which encloses a given reference.\n * This supports only FunctionDeclaration.\n * @param {eslint-scope.Reference} reference A reference to get.\n * @returns {ASTNode|null} The function node or null.\n */\nfunction getEncloseFunctionDeclaration(reference) {\n    let node = reference.identifier;\n\n    while (node) {\n        if (node.type === \"FunctionDeclaration\") {\n            return node.id ? node : null;\n        }\n\n        node = node.parent;\n    }\n\n    return null;\n}\n\n/**\n * Updates the \"modified\" flags of given loop conditions with given modifiers.\n * @param {LoopConditionInfo[]} conditions The loop conditions to be updated.\n * @param {eslint-scope.Reference[]} modifiers The references to update.\n * @returns {void}\n */\nfunction updateModifiedFlag(conditions, modifiers) {\n\n    for (let i = 0; i < conditions.length; ++i) {\n        const condition = conditions[i];\n\n        for (let j = 0; !condition.modified && j < modifiers.length; ++j) {\n            const modifier = modifiers[j];\n            let funcNode, funcVar;\n\n            /*\n             * Besides checking for the condition being in the loop, we want to\n             * check the function that this modifier is belonging to is called\n             * in the loop.\n             * FIXME: This should probably be extracted to a function.\n             */\n            const inLoop = condition.isInLoop(modifier) || Boolean(\n                (funcNode = getEncloseFunctionDeclaration(modifier)) &&\n                (funcVar = astUtils$1.getVariableByName(modifier.from.upper, funcNode.id.name)) &&\n                funcVar.references.some(condition.isInLoop)\n            );\n\n            condition.modified = inLoop;\n        }\n    }\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUnmodifiedLoopCondition = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow unmodified loop conditions\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-unmodified-loop-condition\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        let groupMap = null;\n\n        /**\n         * Reports a given condition info.\n         * @param {LoopConditionInfo} condition A loop condition info to report.\n         * @returns {void}\n         */\n        function report(condition) {\n            const node = condition.reference.identifier;\n\n            context.report({\n                node,\n                message: \"'{{name}}' is not modified in this loop.\",\n                data: node\n            });\n        }\n\n        /**\n         * Registers given conditions to the group the condition belongs to.\n         * @param {LoopConditionInfo[]} conditions A loop condition info to\n         *      register.\n         * @returns {void}\n         */\n        function registerConditionsToGroup(conditions) {\n            for (let i = 0; i < conditions.length; ++i) {\n                const condition = conditions[i];\n\n                if (condition.group) {\n                    let group = groupMap.get(condition.group);\n\n                    if (!group) {\n                        group = [];\n                        groupMap.set(condition.group, group);\n                    }\n                    group.push(condition);\n                }\n            }\n        }\n\n        /**\n         * Reports references which are inside of unmodified groups.\n         * @param {LoopConditionInfo[]} conditions A loop condition info to report.\n         * @returns {void}\n         */\n        function checkConditionsInGroup(conditions) {\n            if (conditions.every(isUnmodified)) {\n                conditions.forEach(report);\n            }\n        }\n\n        /**\n         * Checks whether or not a given group node has any dynamic elements.\n         * @param {ASTNode} root A node to check.\n         *      This node is one of BinaryExpression or ConditionalExpression.\n         * @returns {boolean} `true` if the node is dynamic.\n         */\n        function hasDynamicExpressions(root) {\n            let retv = false;\n\n            traverser.traverse(root, {\n                visitorKeys: sourceCode.visitorKeys,\n                enter(node) {\n                    if (DYNAMIC_PATTERN.test(node.type)) {\n                        retv = true;\n                        this.break();\n                    } else if (SKIP_PATTERN.test(node.type)) {\n                        this.skip();\n                    }\n                }\n            });\n\n            return retv;\n        }\n\n        /**\n         * Creates the loop condition information from a given reference.\n         * @param {eslint-scope.Reference} reference A reference to create.\n         * @returns {LoopConditionInfo|null} Created loop condition info, or null.\n         */\n        function toLoopCondition(reference) {\n            if (reference.init) {\n                return null;\n            }\n\n            let group = null;\n            let child = reference.identifier;\n            let node = child.parent;\n\n            while (node) {\n                if (SENTINEL_PATTERN.test(node.type)) {\n                    if (LOOP_PATTERN.test(node.type) && node.test === child) {\n\n                        // This reference is inside of a loop condition.\n                        return {\n                            reference,\n                            group,\n                            isInLoop: isInLoop[node.type].bind(null, node),\n                            modified: false\n                        };\n                    }\n\n                    // This reference is outside of a loop condition.\n                    break;\n                }\n\n                /*\n                 * If it's inside of a group, OK if either operand is modified.\n                 * So stores the group this reference belongs to.\n                 */\n                if (GROUP_PATTERN.test(node.type)) {\n\n                    // If this expression is dynamic, no need to check.\n                    if (hasDynamicExpressions(node)) {\n                        break;\n                    } else {\n                        group = node;\n                    }\n                }\n\n                child = node;\n                node = node.parent;\n            }\n\n            return null;\n        }\n\n        /**\n         * Finds unmodified references which are inside of a loop condition.\n         * Then reports the references which are outside of groups.\n         * @param {eslint-scope.Variable} variable A variable to report.\n         * @returns {void}\n         */\n        function checkReferences(variable) {\n\n            // Gets references that exist in loop conditions.\n            const conditions = variable\n                .references\n                .map(toLoopCondition)\n                .filter(Boolean);\n\n            if (conditions.length === 0) {\n                return;\n            }\n\n            // Registers the conditions to belonging groups.\n            registerConditionsToGroup(conditions);\n\n            // Check the conditions are modified.\n            const modifiers = variable.references.filter(isWriteReference);\n\n            if (modifiers.length > 0) {\n                updateModifiedFlag(conditions, modifiers);\n            }\n\n            /*\n             * Reports the conditions which are not belonging to groups.\n             * Others will be reported after all variables are done.\n             */\n            conditions\n                .filter(isUnmodifiedAndNotBelongToGroup)\n                .forEach(report);\n        }\n\n        return {\n            \"Program:exit\"() {\n                const queue = [context.getScope()];\n\n                groupMap = new Map();\n\n                let scope;\n\n                while ((scope = queue.pop())) {\n                    queue.push(...scope.childScopes);\n                    scope.variables.forEach(checkReferences);\n                }\n\n                groupMap.forEach(checkConditionsInGroup);\n                groupMap = null;\n            }\n        };\n    }\n};\n\n// Operators that always result in a boolean value\nconst BOOLEAN_OPERATORS = new Set([\"==\", \"===\", \"!=\", \"!==\", \">\", \">=\", \"<\", \"<=\", \"in\", \"instanceof\"]);\nconst OPERATOR_INVERSES = {\n    \"==\": \"!=\",\n    \"!=\": \"==\",\n    \"===\": \"!==\",\n    \"!==\": \"===\"\n\n    // Operators like < and >= are not true inverses, since both will return false with NaN.\n};\nconst OR_PRECEDENCE = astUtils$1.getPrecedence({ type: \"LogicalExpression\", operator: \"||\" });\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUnneededTernary = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow ternary operators when simpler alternatives exist\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-unneeded-ternary\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    defaultAssignment: {\n                        type: \"boolean\",\n                        default: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        fixable: \"code\"\n    },\n\n    create(context) {\n        const options = context.options[0] || {};\n        const defaultAssignment = options.defaultAssignment !== false;\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Test if the node is a boolean literal\n         * @param {ASTNode} node The node to report.\n         * @returns {boolean} True if the its a boolean literal\n         * @private\n         */\n        function isBooleanLiteral(node) {\n            return node.type === \"Literal\" && typeof node.value === \"boolean\";\n        }\n\n        /**\n         * Creates an expression that represents the boolean inverse of the expression represented by the original node\n         * @param {ASTNode} node A node representing an expression\n         * @returns {string} A string representing an inverted expression\n         */\n        function invertExpression(node) {\n            if (node.type === \"BinaryExpression\" && Object.prototype.hasOwnProperty.call(OPERATOR_INVERSES, node.operator)) {\n                const operatorToken = sourceCode.getFirstTokenBetween(\n                    node.left,\n                    node.right,\n                    token => token.value === node.operator\n                );\n                const text = sourceCode.getText();\n\n                return text.slice(node.range[0],\n                    operatorToken.range[0]) + OPERATOR_INVERSES[node.operator] + text.slice(operatorToken.range[1], node.range[1]);\n            }\n\n            if (astUtils$1.getPrecedence(node) < astUtils$1.getPrecedence({ type: \"UnaryExpression\" })) {\n                return `!(${astUtils$1.getParenthesisedText(sourceCode, node)})`;\n            }\n            return `!${astUtils$1.getParenthesisedText(sourceCode, node)}`;\n        }\n\n        /**\n         * Tests if a given node always evaluates to a boolean value\n         * @param {ASTNode} node An expression node\n         * @returns {boolean} True if it is determined that the node will always evaluate to a boolean value\n         */\n        function isBooleanExpression(node) {\n            return node.type === \"BinaryExpression\" && BOOLEAN_OPERATORS.has(node.operator) ||\n                node.type === \"UnaryExpression\" && node.operator === \"!\";\n        }\n\n        /**\n         * Test if the node matches the pattern id ? id : expression\n         * @param {ASTNode} node The ConditionalExpression to check.\n         * @returns {boolean} True if the pattern is matched, and false otherwise\n         * @private\n         */\n        function matchesDefaultAssignment(node) {\n            return node.test.type === \"Identifier\" &&\n                   node.consequent.type === \"Identifier\" &&\n                   node.test.name === node.consequent.name;\n        }\n\n        return {\n\n            ConditionalExpression(node) {\n                if (isBooleanLiteral(node.alternate) && isBooleanLiteral(node.consequent)) {\n                    context.report({\n                        node,\n                        loc: node.consequent.loc.start,\n                        message: \"Unnecessary use of boolean literals in conditional expression.\",\n                        fix(fixer) {\n                            if (node.consequent.value === node.alternate.value) {\n\n                                // Replace `foo ? true : true` with just `true`, but don't replace `foo() ? true : true`\n                                return node.test.type === \"Identifier\" ? fixer.replaceText(node, node.consequent.value.toString()) : null;\n                            }\n                            if (node.alternate.value) {\n\n                                // Replace `foo() ? false : true` with `!(foo())`\n                                return fixer.replaceText(node, invertExpression(node.test));\n                            }\n\n                            // Replace `foo ? true : false` with `foo` if `foo` is guaranteed to be a boolean, or `!!foo` otherwise.\n\n                            return fixer.replaceText(node, isBooleanExpression(node.test) ? astUtils$1.getParenthesisedText(sourceCode, node.test) : `!${invertExpression(node.test)}`);\n                        }\n                    });\n                } else if (!defaultAssignment && matchesDefaultAssignment(node)) {\n                    context.report({\n                        node,\n                        loc: node.consequent.loc.start,\n                        message: \"Unnecessary use of conditional expression for default assignment.\",\n                        fix: fixer => {\n                            const shouldParenthesizeAlternate = (\n                                astUtils$1.getPrecedence(node.alternate) < OR_PRECEDENCE &&\n                                !astUtils$1.isParenthesised(sourceCode, node.alternate)\n                            );\n                            const alternateText = shouldParenthesizeAlternate\n                                ? `(${sourceCode.getText(node.alternate)})`\n                                : astUtils$1.getParenthesisedText(sourceCode, node.alternate);\n                            const testText = astUtils$1.getParenthesisedText(sourceCode, node.test);\n\n                            return fixer.replaceText(node, `${testText} || ${alternateText}`);\n                        }\n                    });\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Checks for unreachable code due to return, throws, break, and continue.\n * @author Joel Feenstra\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not a given variable declarator has the initializer.\n * @param {ASTNode} node A VariableDeclarator node to check.\n * @returns {boolean} `true` if the node has the initializer.\n */\nfunction isInitialized$1(node) {\n    return Boolean(node.init);\n}\n\n/**\n * Checks whether or not a given code path segment is unreachable.\n * @param {CodePathSegment} segment A CodePathSegment to check.\n * @returns {boolean} `true` if the segment is unreachable.\n */\nfunction isUnreachable$1(segment) {\n    return !segment.reachable;\n}\n\n/**\n * The class to distinguish consecutive unreachable statements.\n */\nclass ConsecutiveRange {\n    constructor(sourceCode) {\n        this.sourceCode = sourceCode;\n        this.startNode = null;\n        this.endNode = null;\n    }\n\n    /**\n     * The location object of this range.\n     * @type {Object}\n     */\n    get location() {\n        return {\n            start: this.startNode.loc.start,\n            end: this.endNode.loc.end\n        };\n    }\n\n    /**\n     * `true` if this range is empty.\n     * @type {boolean}\n     */\n    get isEmpty() {\n        return !(this.startNode && this.endNode);\n    }\n\n    /**\n     * Checks whether the given node is inside of this range.\n     * @param {ASTNode|Token} node The node to check.\n     * @returns {boolean} `true` if the node is inside of this range.\n     */\n    contains(node) {\n        return (\n            node.range[0] >= this.startNode.range[0] &&\n            node.range[1] <= this.endNode.range[1]\n        );\n    }\n\n    /**\n     * Checks whether the given node is consecutive to this range.\n     * @param {ASTNode} node The node to check.\n     * @returns {boolean} `true` if the node is consecutive to this range.\n     */\n    isConsecutive(node) {\n        return this.contains(this.sourceCode.getTokenBefore(node));\n    }\n\n    /**\n     * Merges the given node to this range.\n     * @param {ASTNode} node The node to merge.\n     * @returns {void}\n     */\n    merge(node) {\n        this.endNode = node;\n    }\n\n    /**\n     * Resets this range by the given node or null.\n     * @param {ASTNode|null} node The node to reset, or null.\n     * @returns {void}\n     */\n    reset(node) {\n        this.startNode = this.endNode = node;\n    }\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUnreachable = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow unreachable code after `return`, `throw`, `continue`, and `break` statements\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-unreachable\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        let currentCodePath = null;\n\n        const range = new ConsecutiveRange(context.getSourceCode());\n\n        /**\n         * Reports a given node if it's unreachable.\n         * @param {ASTNode} node A statement node to report.\n         * @returns {void}\n         */\n        function reportIfUnreachable(node) {\n            let nextNode = null;\n\n            if (node && currentCodePath.currentSegments.every(isUnreachable$1)) {\n\n                // Store this statement to distinguish consecutive statements.\n                if (range.isEmpty) {\n                    range.reset(node);\n                    return;\n                }\n\n                // Skip if this statement is inside of the current range.\n                if (range.contains(node)) {\n                    return;\n                }\n\n                // Merge if this statement is consecutive to the current range.\n                if (range.isConsecutive(node)) {\n                    range.merge(node);\n                    return;\n                }\n\n                nextNode = node;\n            }\n\n            /*\n             * Report the current range since this statement is reachable or is\n             * not consecutive to the current range.\n             */\n            if (!range.isEmpty) {\n                context.report({\n                    message: \"Unreachable code.\",\n                    loc: range.location,\n                    node: range.startNode\n                });\n            }\n\n            // Update the current range.\n            range.reset(nextNode);\n        }\n\n        return {\n\n            // Manages the current code path.\n            onCodePathStart(codePath) {\n                currentCodePath = codePath;\n            },\n\n            onCodePathEnd() {\n                currentCodePath = currentCodePath.upper;\n            },\n\n            // Registers for all statement nodes (excludes FunctionDeclaration).\n            BlockStatement: reportIfUnreachable,\n            BreakStatement: reportIfUnreachable,\n            ClassDeclaration: reportIfUnreachable,\n            ContinueStatement: reportIfUnreachable,\n            DebuggerStatement: reportIfUnreachable,\n            DoWhileStatement: reportIfUnreachable,\n            ExpressionStatement: reportIfUnreachable,\n            ForInStatement: reportIfUnreachable,\n            ForOfStatement: reportIfUnreachable,\n            ForStatement: reportIfUnreachable,\n            IfStatement: reportIfUnreachable,\n            ImportDeclaration: reportIfUnreachable,\n            LabeledStatement: reportIfUnreachable,\n            ReturnStatement: reportIfUnreachable,\n            SwitchStatement: reportIfUnreachable,\n            ThrowStatement: reportIfUnreachable,\n            TryStatement: reportIfUnreachable,\n\n            VariableDeclaration(node) {\n                if (node.kind !== \"var\" || node.declarations.some(isInitialized$1)) {\n                    reportIfUnreachable(node);\n                }\n            },\n\n            WhileStatement: reportIfUnreachable,\n            WithStatement: reportIfUnreachable,\n            ExportNamedDeclaration: reportIfUnreachable,\n            ExportDefaultDeclaration: reportIfUnreachable,\n            ExportAllDeclaration: reportIfUnreachable,\n\n            \"Program:exit\"() {\n                reportIfUnreachable();\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag unsafe statements in finally block\n * @author Onur Temizkan\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst SENTINEL_NODE_TYPE_RETURN_THROW = /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression)$/u;\nconst SENTINEL_NODE_TYPE_BREAK = /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|DoWhileStatement|WhileStatement|ForOfStatement|ForInStatement|ForStatement|SwitchStatement)$/u;\nconst SENTINEL_NODE_TYPE_CONTINUE = /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|DoWhileStatement|WhileStatement|ForOfStatement|ForInStatement|ForStatement)$/u;\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUnsafeFinally = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow control flow statements in `finally` blocks\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-unsafe-finally\"\n        },\n\n        schema: []\n    },\n    create(context) {\n\n        /**\n         * Checks if the node is the finalizer of a TryStatement\n         * @param {ASTNode} node node to check.\n         * @returns {boolean} - true if the node is the finalizer of a TryStatement\n         */\n        function isFinallyBlock(node) {\n            return node.parent.type === \"TryStatement\" && node.parent.finalizer === node;\n        }\n\n        /**\n         * Climbs up the tree if the node is not a sentinel node\n         * @param {ASTNode} node node to check.\n         * @param {string} label label of the break or continue statement\n         * @returns {boolean} - return whether the node is a finally block or a sentinel node\n         */\n        function isInFinallyBlock(node, label) {\n            let labelInside = false;\n            let sentinelNodeType;\n\n            if (node.type === \"BreakStatement\" && !node.label) {\n                sentinelNodeType = SENTINEL_NODE_TYPE_BREAK;\n            } else if (node.type === \"ContinueStatement\") {\n                sentinelNodeType = SENTINEL_NODE_TYPE_CONTINUE;\n            } else {\n                sentinelNodeType = SENTINEL_NODE_TYPE_RETURN_THROW;\n            }\n\n            for (\n                let currentNode = node;\n                currentNode && !sentinelNodeType.test(currentNode.type);\n                currentNode = currentNode.parent\n            ) {\n                if (currentNode.parent.label && label && (currentNode.parent.label.name === label.name)) {\n                    labelInside = true;\n                }\n                if (isFinallyBlock(currentNode)) {\n                    if (label && labelInside) {\n                        return false;\n                    }\n                    return true;\n                }\n            }\n            return false;\n        }\n\n        /**\n         * Checks whether the possibly-unsafe statement is inside a finally block.\n         * @param {ASTNode} node node to check.\n         * @returns {void}\n         */\n        function check(node) {\n            if (isInFinallyBlock(node, node.label)) {\n                context.report({\n                    message: \"Unsafe usage of {{nodeType}}.\",\n                    data: {\n                        nodeType: node.type\n                    },\n                    node,\n                    line: node.loc.line,\n                    column: node.loc.column\n                });\n            }\n        }\n\n        return {\n            ReturnStatement: check,\n            ThrowStatement: check,\n            BreakStatement: check,\n            ContinueStatement: check\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether the given operator is `in` or `instanceof`\n * @param {string} op The operator type to check.\n * @returns {boolean} `true` if the operator is `in` or `instanceof`\n */\nfunction isInOrInstanceOfOperator(op) {\n    return op === \"in\" || op === \"instanceof\";\n}\n\n/**\n * Checks whether the given operator is an ordering relational operator or not.\n * @param {string} op The operator type to check.\n * @returns {boolean} `true` if the operator is an ordering relational operator.\n */\nfunction isOrderingRelationalOperator(op) {\n    return op === \"<\" || op === \">\" || op === \">=\" || op === \"<=\";\n}\n\n/**\n * Checks whether the given node is a logical negation expression or not.\n * @param {ASTNode} node The node to check.\n * @returns {boolean} `true` if the node is a logical negation expression.\n */\nfunction isNegation(node) {\n    return node.type === \"UnaryExpression\" && node.operator === \"!\";\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUnsafeNegation = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow negating the left operand of relational operators\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-unsafe-negation\",\n            suggestion: true\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    enforceForOrderingRelations: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        fixable: null,\n\n        messages: {\n            unexpected: \"Unexpected negating the left operand of '{{operator}}' operator.\",\n            suggestNegatedExpression: \"Negate '{{operator}}' expression instead of its left operand. This changes the current behavior.\",\n            suggestParenthesisedNegation: \"Wrap negation in '()' to make the intention explicit. This preserves the current behavior.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const options = context.options[0] || {};\n        const enforceForOrderingRelations = options.enforceForOrderingRelations === true;\n\n        return {\n            BinaryExpression(node) {\n                const operator = node.operator;\n                const orderingRelationRuleApplies = enforceForOrderingRelations && isOrderingRelationalOperator(operator);\n\n                if (\n                    (isInOrInstanceOfOperator(operator) || orderingRelationRuleApplies) &&\n                    isNegation(node.left) &&\n                    !astUtils$1.isParenthesised(sourceCode, node.left)\n                ) {\n                    context.report({\n                        node,\n                        loc: node.left.loc,\n                        messageId: \"unexpected\",\n                        data: { operator },\n                        suggest: [\n                            {\n                                messageId: \"suggestNegatedExpression\",\n                                data: { operator },\n                                fix(fixer) {\n                                    const negationToken = sourceCode.getFirstToken(node.left);\n                                    const fixRange = [negationToken.range[1], node.range[1]];\n                                    const text = sourceCode.text.slice(fixRange[0], fixRange[1]);\n\n                                    return fixer.replaceTextRange(fixRange, `(${text})`);\n                                }\n                            },\n                            {\n                                messageId: \"suggestParenthesisedNegation\",\n                                fix(fixer) {\n                                    return fixer.replaceText(node.left, `(${sourceCode.getText(node.left)})`);\n                                }\n                            }\n                        ]\n                    });\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Flag expressions in statement position that do not side effect\n * @author Michael Ficarra\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUnusedExpressions = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow unused expressions\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-unused-expressions\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allowShortCircuit: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    allowTernary: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    allowTaggedTemplates: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const config = context.options[0] || {},\n            allowShortCircuit = config.allowShortCircuit || false,\n            allowTernary = config.allowTernary || false,\n            allowTaggedTemplates = config.allowTaggedTemplates || false;\n\n        // eslint-disable-next-line jsdoc/require-description\n        /**\n         * @param {ASTNode} node any node\n         * @returns {boolean} whether the given node structurally represents a directive\n         */\n        function looksLikeDirective(node) {\n            return node.type === \"ExpressionStatement\" &&\n                node.expression.type === \"Literal\" && typeof node.expression.value === \"string\";\n        }\n\n        // eslint-disable-next-line jsdoc/require-description\n        /**\n         * @param {Function} predicate ([a] -> Boolean) the function used to make the determination\n         * @param {a[]} list the input list\n         * @returns {a[]} the leading sequence of members in the given list that pass the given predicate\n         */\n        function takeWhile(predicate, list) {\n            for (let i = 0; i < list.length; ++i) {\n                if (!predicate(list[i])) {\n                    return list.slice(0, i);\n                }\n            }\n            return list.slice();\n        }\n\n        // eslint-disable-next-line jsdoc/require-description\n        /**\n         * @param {ASTNode} node a Program or BlockStatement node\n         * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body\n         */\n        function directives(node) {\n            return takeWhile(looksLikeDirective, node.body);\n        }\n\n        // eslint-disable-next-line jsdoc/require-description\n        /**\n         * @param {ASTNode} node any node\n         * @param {ASTNode[]} ancestors the given node's ancestors\n         * @returns {boolean} whether the given node is considered a directive in its current position\n         */\n        function isDirective(node, ancestors) {\n            const parent = ancestors[ancestors.length - 1],\n                grandparent = ancestors[ancestors.length - 2];\n\n            return (parent.type === \"Program\" || parent.type === \"BlockStatement\" &&\n                    (/Function/u.test(grandparent.type))) &&\n                    directives(parent).indexOf(node) >= 0;\n        }\n\n        /**\n         * Determines whether or not a given node is a valid expression. Recurses on short circuit eval and ternary nodes if enabled by flags.\n         * @param {ASTNode} node any node\n         * @returns {boolean} whether the given node is a valid expression\n         */\n        function isValidExpression(node) {\n            if (allowTernary) {\n\n                // Recursive check for ternary and logical expressions\n                if (node.type === \"ConditionalExpression\") {\n                    return isValidExpression(node.consequent) && isValidExpression(node.alternate);\n                }\n            }\n\n            if (allowShortCircuit) {\n                if (node.type === \"LogicalExpression\") {\n                    return isValidExpression(node.right);\n                }\n            }\n\n            if (allowTaggedTemplates && node.type === \"TaggedTemplateExpression\") {\n                return true;\n            }\n\n            return /^(?:Assignment|Call|New|Update|Yield|Await)Expression$/u.test(node.type) ||\n                (node.type === \"UnaryExpression\" && [\"delete\", \"void\"].indexOf(node.operator) >= 0);\n        }\n\n        return {\n            ExpressionStatement(node) {\n                if (!isValidExpression(node.expression) && !isDirective(node, context.getAncestors())) {\n                    context.report({ node, message: \"Expected an assignment or function call and instead saw an expression.\" });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to disallow unused labels.\n * @author Toru Nagashima\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUnusedLabels = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow unused labels\",\n            category: \"Best Practices\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-unused-labels\"\n        },\n\n        schema: [],\n\n        fixable: \"code\",\n\n        messages: {\n            unused: \"'{{name}}:' is defined but never used.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        let scopeInfo = null;\n\n        /**\n         * Adds a scope info to the stack.\n         * @param {ASTNode} node A node to add. This is a LabeledStatement.\n         * @returns {void}\n         */\n        function enterLabeledScope(node) {\n            scopeInfo = {\n                label: node.label.name,\n                used: false,\n                upper: scopeInfo\n            };\n        }\n\n        /**\n         * Removes the top of the stack.\n         * At the same time, this reports the label if it's never used.\n         * @param {ASTNode} node A node to report. This is a LabeledStatement.\n         * @returns {void}\n         */\n        function exitLabeledScope(node) {\n            if (!scopeInfo.used) {\n                context.report({\n                    node: node.label,\n                    messageId: \"unused\",\n                    data: node.label,\n                    fix(fixer) {\n\n                        /*\n                         * Only perform a fix if there are no comments between the label and the body. This will be the case\n                         * when there is exactly one token/comment (the \":\") between the label and the body.\n                         */\n                        if (sourceCode.getTokenAfter(node.label, { includeComments: true }) ===\n                                sourceCode.getTokenBefore(node.body, { includeComments: true })) {\n                            return fixer.removeRange([node.range[0], node.body.range[0]]);\n                        }\n\n                        return null;\n                    }\n                });\n            }\n\n            scopeInfo = scopeInfo.upper;\n        }\n\n        /**\n         * Marks the label of a given node as used.\n         * @param {ASTNode} node A node to mark. This is a BreakStatement or\n         *      ContinueStatement.\n         * @returns {void}\n         */\n        function markAsUsed(node) {\n            if (!node.label) {\n                return;\n            }\n\n            const label = node.label.name;\n            let info = scopeInfo;\n\n            while (info) {\n                if (info.label === label) {\n                    info.used = true;\n                    break;\n                }\n                info = info.upper;\n            }\n        }\n\n        return {\n            LabeledStatement: enterLabeledScope,\n            \"LabeledStatement:exit\": exitLabeledScope,\n            BreakStatement: markAsUsed,\n            ContinueStatement: markAsUsed\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUnusedVars = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow unused variables\",\n            category: \"Variables\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-unused-vars\"\n        },\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        enum: [\"all\", \"local\"]\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            vars: {\n                                enum: [\"all\", \"local\"]\n                            },\n                            varsIgnorePattern: {\n                                type: \"string\"\n                            },\n                            args: {\n                                enum: [\"all\", \"after-used\", \"none\"]\n                            },\n                            ignoreRestSiblings: {\n                                type: \"boolean\"\n                            },\n                            argsIgnorePattern: {\n                                type: \"string\"\n                            },\n                            caughtErrors: {\n                                enum: [\"all\", \"none\"]\n                            },\n                            caughtErrorsIgnorePattern: {\n                                type: \"string\"\n                            }\n                        }\n                    }\n                ]\n            }\n        ]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        const REST_PROPERTY_TYPE = /^(?:RestElement|(?:Experimental)?RestProperty)$/u;\n\n        const config = {\n            vars: \"all\",\n            args: \"after-used\",\n            ignoreRestSiblings: false,\n            caughtErrors: \"none\"\n        };\n\n        const firstOption = context.options[0];\n\n        if (firstOption) {\n            if (typeof firstOption === \"string\") {\n                config.vars = firstOption;\n            } else {\n                config.vars = firstOption.vars || config.vars;\n                config.args = firstOption.args || config.args;\n                config.ignoreRestSiblings = firstOption.ignoreRestSiblings || config.ignoreRestSiblings;\n                config.caughtErrors = firstOption.caughtErrors || config.caughtErrors;\n\n                if (firstOption.varsIgnorePattern) {\n                    config.varsIgnorePattern = new RegExp(firstOption.varsIgnorePattern, \"u\");\n                }\n\n                if (firstOption.argsIgnorePattern) {\n                    config.argsIgnorePattern = new RegExp(firstOption.argsIgnorePattern, \"u\");\n                }\n\n                if (firstOption.caughtErrorsIgnorePattern) {\n                    config.caughtErrorsIgnorePattern = new RegExp(firstOption.caughtErrorsIgnorePattern, \"u\");\n                }\n            }\n        }\n\n        /**\n         * Generate the warning message about the variable being\n         * defined and unused, including the ignore pattern if configured.\n         * @param {Variable} unusedVar eslint-scope variable object.\n         * @returns {string} The warning message to be used with this unused variable.\n         */\n        function getDefinedMessage(unusedVar) {\n            const defType = unusedVar.defs && unusedVar.defs[0] && unusedVar.defs[0].type;\n            let type;\n            let pattern;\n\n            if (defType === \"CatchClause\" && config.caughtErrorsIgnorePattern) {\n                type = \"args\";\n                pattern = config.caughtErrorsIgnorePattern.toString();\n            } else if (defType === \"Parameter\" && config.argsIgnorePattern) {\n                type = \"args\";\n                pattern = config.argsIgnorePattern.toString();\n            } else if (defType !== \"Parameter\" && config.varsIgnorePattern) {\n                type = \"vars\";\n                pattern = config.varsIgnorePattern.toString();\n            }\n\n            const additional = type ? ` Allowed unused ${type} must match ${pattern}.` : \"\";\n\n            return `'{{name}}' is defined but never used.${additional}`;\n        }\n\n        /**\n         * Generate the warning message about the variable being\n         * assigned and unused, including the ignore pattern if configured.\n         * @returns {string} The warning message to be used with this unused variable.\n         */\n        function getAssignedMessage() {\n            const additional = config.varsIgnorePattern ? ` Allowed unused vars must match ${config.varsIgnorePattern.toString()}.` : \"\";\n\n            return `'{{name}}' is assigned a value but never used.${additional}`;\n        }\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        const STATEMENT_TYPE = /(?:Statement|Declaration)$/u;\n\n        /**\n         * Determines if a given variable is being exported from a module.\n         * @param {Variable} variable eslint-scope variable object.\n         * @returns {boolean} True if the variable is exported, false if not.\n         * @private\n         */\n        function isExported(variable) {\n\n            const definition = variable.defs[0];\n\n            if (definition) {\n\n                let node = definition.node;\n\n                if (node.type === \"VariableDeclarator\") {\n                    node = node.parent;\n                } else if (definition.type === \"Parameter\") {\n                    return false;\n                }\n\n                return node.parent.type.indexOf(\"Export\") === 0;\n            }\n            return false;\n\n        }\n\n        /**\n         * Determines if a variable has a sibling rest property\n         * @param {Variable} variable eslint-scope variable object.\n         * @returns {boolean} True if the variable is exported, false if not.\n         * @private\n         */\n        function hasRestSpreadSibling(variable) {\n            if (config.ignoreRestSiblings) {\n                return variable.defs.some(def => {\n                    const propertyNode = def.name.parent;\n                    const patternNode = propertyNode.parent;\n\n                    return (\n                        propertyNode.type === \"Property\" &&\n                        patternNode.type === \"ObjectPattern\" &&\n                        REST_PROPERTY_TYPE.test(patternNode.properties[patternNode.properties.length - 1].type)\n                    );\n                });\n            }\n\n            return false;\n        }\n\n        /**\n         * Determines if a reference is a read operation.\n         * @param {Reference} ref An eslint-scope Reference\n         * @returns {boolean} whether the given reference represents a read operation\n         * @private\n         */\n        function isReadRef(ref) {\n            return ref.isRead();\n        }\n\n        /**\n         * Determine if an identifier is referencing an enclosing function name.\n         * @param {Reference} ref The reference to check.\n         * @param {ASTNode[]} nodes The candidate function nodes.\n         * @returns {boolean} True if it's a self-reference, false if not.\n         * @private\n         */\n        function isSelfReference(ref, nodes) {\n            let scope = ref.from;\n\n            while (scope) {\n                if (nodes.indexOf(scope.block) >= 0) {\n                    return true;\n                }\n\n                scope = scope.upper;\n            }\n\n            return false;\n        }\n\n        /**\n         * Gets a list of function definitions for a specified variable.\n         * @param {Variable} variable eslint-scope variable object.\n         * @returns {ASTNode[]} Function nodes.\n         * @private\n         */\n        function getFunctionDefinitions(variable) {\n            const functionDefinitions = [];\n\n            variable.defs.forEach(def => {\n                const { type, node } = def;\n\n                // FunctionDeclarations\n                if (type === \"FunctionName\") {\n                    functionDefinitions.push(node);\n                }\n\n                // FunctionExpressions\n                if (type === \"Variable\" && node.init &&\n                    (node.init.type === \"FunctionExpression\" || node.init.type === \"ArrowFunctionExpression\")) {\n                    functionDefinitions.push(node.init);\n                }\n            });\n            return functionDefinitions;\n        }\n\n        /**\n         * Checks the position of given nodes.\n         * @param {ASTNode} inner A node which is expected as inside.\n         * @param {ASTNode} outer A node which is expected as outside.\n         * @returns {boolean} `true` if the `inner` node exists in the `outer` node.\n         * @private\n         */\n        function isInside(inner, outer) {\n            return (\n                inner.range[0] >= outer.range[0] &&\n                inner.range[1] <= outer.range[1]\n            );\n        }\n\n        /**\n         * If a given reference is left-hand side of an assignment, this gets\n         * the right-hand side node of the assignment.\n         *\n         * In the following cases, this returns null.\n         *\n         * - The reference is not the LHS of an assignment expression.\n         * - The reference is inside of a loop.\n         * - The reference is inside of a function scope which is different from\n         *   the declaration.\n         * @param {eslint-scope.Reference} ref A reference to check.\n         * @param {ASTNode} prevRhsNode The previous RHS node.\n         * @returns {ASTNode|null} The RHS node or null.\n         * @private\n         */\n        function getRhsNode(ref, prevRhsNode) {\n            const id = ref.identifier;\n            const parent = id.parent;\n            const granpa = parent.parent;\n            const refScope = ref.from.variableScope;\n            const varScope = ref.resolved.scope.variableScope;\n            const canBeUsedLater = refScope !== varScope || astUtils$1.isInLoop(id);\n\n            /*\n             * Inherits the previous node if this reference is in the node.\n             * This is for `a = a + a`-like code.\n             */\n            if (prevRhsNode && isInside(id, prevRhsNode)) {\n                return prevRhsNode;\n            }\n\n            if (parent.type === \"AssignmentExpression\" &&\n                granpa.type === \"ExpressionStatement\" &&\n                id === parent.left &&\n                !canBeUsedLater\n            ) {\n                return parent.right;\n            }\n            return null;\n        }\n\n        /**\n         * Checks whether a given function node is stored to somewhere or not.\n         * If the function node is stored, the function can be used later.\n         * @param {ASTNode} funcNode A function node to check.\n         * @param {ASTNode} rhsNode The RHS node of the previous assignment.\n         * @returns {boolean} `true` if under the following conditions:\n         *      - the funcNode is assigned to a variable.\n         *      - the funcNode is bound as an argument of a function call.\n         *      - the function is bound to a property and the object satisfies above conditions.\n         * @private\n         */\n        function isStorableFunction(funcNode, rhsNode) {\n            let node = funcNode;\n            let parent = funcNode.parent;\n\n            while (parent && isInside(parent, rhsNode)) {\n                switch (parent.type) {\n                    case \"SequenceExpression\":\n                        if (parent.expressions[parent.expressions.length - 1] !== node) {\n                            return false;\n                        }\n                        break;\n\n                    case \"CallExpression\":\n                    case \"NewExpression\":\n                        return parent.callee !== node;\n\n                    case \"AssignmentExpression\":\n                    case \"TaggedTemplateExpression\":\n                    case \"YieldExpression\":\n                        return true;\n\n                    default:\n                        if (STATEMENT_TYPE.test(parent.type)) {\n\n                            /*\n                             * If it encountered statements, this is a complex pattern.\n                             * Since analyzeing complex patterns is hard, this returns `true` to avoid false positive.\n                             */\n                            return true;\n                        }\n                }\n\n                node = parent;\n                parent = parent.parent;\n            }\n\n            return false;\n        }\n\n        /**\n         * Checks whether a given Identifier node exists inside of a function node which can be used later.\n         *\n         * \"can be used later\" means:\n         * - the function is assigned to a variable.\n         * - the function is bound to a property and the object can be used later.\n         * - the function is bound as an argument of a function call.\n         *\n         * If a reference exists in a function which can be used later, the reference is read when the function is called.\n         * @param {ASTNode} id An Identifier node to check.\n         * @param {ASTNode} rhsNode The RHS node of the previous assignment.\n         * @returns {boolean} `true` if the `id` node exists inside of a function node which can be used later.\n         * @private\n         */\n        function isInsideOfStorableFunction(id, rhsNode) {\n            const funcNode = astUtils$1.getUpperFunction(id);\n\n            return (\n                funcNode &&\n                isInside(funcNode, rhsNode) &&\n                isStorableFunction(funcNode, rhsNode)\n            );\n        }\n\n        /**\n         * Checks whether a given reference is a read to update itself or not.\n         * @param {eslint-scope.Reference} ref A reference to check.\n         * @param {ASTNode} rhsNode The RHS node of the previous assignment.\n         * @returns {boolean} The reference is a read to update itself.\n         * @private\n         */\n        function isReadForItself(ref, rhsNode) {\n            const id = ref.identifier;\n            const parent = id.parent;\n            const granpa = parent.parent;\n\n            return ref.isRead() && (\n\n                // self update. e.g. `a += 1`, `a++`\n                (// in RHS of an assignment for itself. e.g. `a = a + 1`\n                    ((\n                        parent.type === \"AssignmentExpression\" &&\n                    granpa.type === \"ExpressionStatement\" &&\n                    parent.left === id\n                    ) ||\n                (\n                    parent.type === \"UpdateExpression\" &&\n                    granpa.type === \"ExpressionStatement\"\n                ) || rhsNode &&\n                isInside(id, rhsNode) &&\n                !isInsideOfStorableFunction(id, rhsNode)))\n            );\n        }\n\n        /**\n         * Determine if an identifier is used either in for-in loops.\n         * @param {Reference} ref The reference to check.\n         * @returns {boolean} whether reference is used in the for-in loops\n         * @private\n         */\n        function isForInRef(ref) {\n            let target = ref.identifier.parent;\n\n\n            // \"for (var ...) { return; }\"\n            if (target.type === \"VariableDeclarator\") {\n                target = target.parent.parent;\n            }\n\n            if (target.type !== \"ForInStatement\") {\n                return false;\n            }\n\n            // \"for (...) { return; }\"\n            if (target.body.type === \"BlockStatement\") {\n                target = target.body.body[0];\n\n            // \"for (...) return;\"\n            } else {\n                target = target.body;\n            }\n\n            // For empty loop body\n            if (!target) {\n                return false;\n            }\n\n            return target.type === \"ReturnStatement\";\n        }\n\n        /**\n         * Determines if the variable is used.\n         * @param {Variable} variable The variable to check.\n         * @returns {boolean} True if the variable is used\n         * @private\n         */\n        function isUsedVariable(variable) {\n            const functionNodes = getFunctionDefinitions(variable),\n                isFunctionDefinition = functionNodes.length > 0;\n            let rhsNode = null;\n\n            return variable.references.some(ref => {\n                if (isForInRef(ref)) {\n                    return true;\n                }\n\n                const forItself = isReadForItself(ref, rhsNode);\n\n                rhsNode = getRhsNode(ref, rhsNode);\n\n                return (\n                    isReadRef(ref) &&\n                    !forItself &&\n                    !(isFunctionDefinition && isSelfReference(ref, functionNodes))\n                );\n            });\n        }\n\n        /**\n         * Checks whether the given variable is after the last used parameter.\n         * @param {eslint-scope.Variable} variable The variable to check.\n         * @returns {boolean} `true` if the variable is defined after the last\n         * used parameter.\n         */\n        function isAfterLastUsedArg(variable) {\n            const def = variable.defs[0];\n            const params = context.getDeclaredVariables(def.node);\n            const posteriorParams = params.slice(params.indexOf(variable) + 1);\n\n            // If any used parameters occur after this parameter, do not report.\n            return !posteriorParams.some(v => v.references.length > 0 || v.eslintUsed);\n        }\n\n        /**\n         * Gets an array of variables without read references.\n         * @param {Scope} scope an eslint-scope Scope object.\n         * @param {Variable[]} unusedVars an array that saving result.\n         * @returns {Variable[]} unused variables of the scope and descendant scopes.\n         * @private\n         */\n        function collectUnusedVariables(scope, unusedVars) {\n            const variables = scope.variables;\n            const childScopes = scope.childScopes;\n            let i, l;\n\n            if (scope.type !== \"global\" || config.vars === \"all\") {\n                for (i = 0, l = variables.length; i < l; ++i) {\n                    const variable = variables[i];\n\n                    // skip a variable of class itself name in the class scope\n                    if (scope.type === \"class\" && scope.block.id === variable.identifiers[0]) {\n                        continue;\n                    }\n\n                    // skip function expression names and variables marked with markVariableAsUsed()\n                    if (scope.functionExpressionScope || variable.eslintUsed) {\n                        continue;\n                    }\n\n                    // skip implicit \"arguments\" variable\n                    if (scope.type === \"function\" && variable.name === \"arguments\" && variable.identifiers.length === 0) {\n                        continue;\n                    }\n\n                    // explicit global variables don't have definitions.\n                    const def = variable.defs[0];\n\n                    if (def) {\n                        const type = def.type;\n\n                        // skip catch variables\n                        if (type === \"CatchClause\") {\n                            if (config.caughtErrors === \"none\") {\n                                continue;\n                            }\n\n                            // skip ignored parameters\n                            if (config.caughtErrorsIgnorePattern && config.caughtErrorsIgnorePattern.test(def.name.name)) {\n                                continue;\n                            }\n                        }\n\n                        if (type === \"Parameter\") {\n\n                            // skip any setter argument\n                            if ((def.node.parent.type === \"Property\" || def.node.parent.type === \"MethodDefinition\") && def.node.parent.kind === \"set\") {\n                                continue;\n                            }\n\n                            // if \"args\" option is \"none\", skip any parameter\n                            if (config.args === \"none\") {\n                                continue;\n                            }\n\n                            // skip ignored parameters\n                            if (config.argsIgnorePattern && config.argsIgnorePattern.test(def.name.name)) {\n                                continue;\n                            }\n\n                            // if \"args\" option is \"after-used\", skip used variables\n                            if (config.args === \"after-used\" && astUtils$1.isFunction(def.name.parent) && !isAfterLastUsedArg(variable)) {\n                                continue;\n                            }\n                        } else {\n\n                            // skip ignored variables\n                            if (config.varsIgnorePattern && config.varsIgnorePattern.test(def.name.name)) {\n                                continue;\n                            }\n                        }\n                    }\n\n                    if (!isUsedVariable(variable) && !isExported(variable) && !hasRestSpreadSibling(variable)) {\n                        unusedVars.push(variable);\n                    }\n                }\n            }\n\n            for (i = 0, l = childScopes.length; i < l; ++i) {\n                collectUnusedVariables(childScopes[i], unusedVars);\n            }\n\n            return unusedVars;\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            \"Program:exit\"(programNode) {\n                const unusedVars = collectUnusedVariables(context.getScope(), []);\n\n                for (let i = 0, l = unusedVars.length; i < l; ++i) {\n                    const unusedVar = unusedVars[i];\n\n                    // Report the first declaration.\n                    if (unusedVar.defs.length > 0) {\n                        context.report({\n                            node: unusedVar.identifiers[0],\n                            message: unusedVar.references.some(ref => ref.isWrite())\n                                ? getAssignedMessage()\n                                : getDefinedMessage(unusedVar),\n                            data: unusedVar\n                        });\n\n                    // If there are no regular declaration, report the first `/*globals*/` comment directive.\n                    } else if (unusedVar.eslintExplicitGlobalComments) {\n                        const directiveComment = unusedVar.eslintExplicitGlobalComments[0];\n\n                        context.report({\n                            node: programNode,\n                            loc: astUtils$1.getNameLocationInGlobalDirectiveComment(sourceCode, directiveComment, unusedVar.name),\n                            message: getDefinedMessage(unusedVar),\n                            data: unusedVar\n                        });\n                    }\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag use of variables before they are defined\n * @author Ilya Volodin\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst SENTINEL_TYPE$1 = /^(?:(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|CatchClause|ImportDeclaration|ExportNamedDeclaration)$/u;\nconst FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/u;\n\n/**\n * Parses a given value as options.\n * @param {any} options A value to parse.\n * @returns {Object} The parsed options.\n */\nfunction parseOptions$1(options) {\n    let functions = true;\n    let classes = true;\n    let variables = true;\n\n    if (typeof options === \"string\") {\n        functions = (options !== \"nofunc\");\n    } else if (typeof options === \"object\" && options !== null) {\n        functions = options.functions !== false;\n        classes = options.classes !== false;\n        variables = options.variables !== false;\n    }\n\n    return { functions, classes, variables };\n}\n\n/**\n * Checks whether or not a given variable is a function declaration.\n * @param {eslint-scope.Variable} variable A variable to check.\n * @returns {boolean} `true` if the variable is a function declaration.\n */\nfunction isFunction$1(variable) {\n    return variable.defs[0].type === \"FunctionName\";\n}\n\n/**\n * Checks whether or not a given variable is a class declaration in an upper function scope.\n * @param {eslint-scope.Variable} variable A variable to check.\n * @param {eslint-scope.Reference} reference A reference to check.\n * @returns {boolean} `true` if the variable is a class declaration.\n */\nfunction isOuterClass(variable, reference) {\n    return (\n        variable.defs[0].type === \"ClassName\" &&\n        variable.scope.variableScope !== reference.from.variableScope\n    );\n}\n\n/**\n * Checks whether or not a given variable is a variable declaration in an upper function scope.\n * @param {eslint-scope.Variable} variable A variable to check.\n * @param {eslint-scope.Reference} reference A reference to check.\n * @returns {boolean} `true` if the variable is a variable declaration.\n */\nfunction isOuterVariable(variable, reference) {\n    return (\n        variable.defs[0].type === \"Variable\" &&\n        variable.scope.variableScope !== reference.from.variableScope\n    );\n}\n\n/**\n * Checks whether or not a given location is inside of the range of a given node.\n * @param {ASTNode} node An node to check.\n * @param {number} location A location to check.\n * @returns {boolean} `true` if the location is inside of the range of the node.\n */\nfunction isInRange$1(node, location) {\n    return node && node.range[0] <= location && location <= node.range[1];\n}\n\n/**\n * Checks whether or not a given reference is inside of the initializers of a given variable.\n *\n * This returns `true` in the following cases:\n *\n *     var a = a\n *     var [a = a] = list\n *     var {a = a} = obj\n *     for (var a in a) {}\n *     for (var a of a) {}\n * @param {Variable} variable A variable to check.\n * @param {Reference} reference A reference to check.\n * @returns {boolean} `true` if the reference is inside of the initializers.\n */\nfunction isInInitializer(variable, reference) {\n    if (variable.scope !== reference.from) {\n        return false;\n    }\n\n    let node = variable.identifiers[0].parent;\n    const location = reference.identifier.range[1];\n\n    while (node) {\n        if (node.type === \"VariableDeclarator\") {\n            if (isInRange$1(node.init, location)) {\n                return true;\n            }\n            if (FOR_IN_OF_TYPE.test(node.parent.parent.type) &&\n                isInRange$1(node.parent.parent.right, location)\n            ) {\n                return true;\n            }\n            break;\n        } else if (node.type === \"AssignmentPattern\") {\n            if (isInRange$1(node.right, location)) {\n                return true;\n            }\n        } else if (SENTINEL_TYPE$1.test(node.type)) {\n            break;\n        }\n\n        node = node.parent;\n    }\n\n    return false;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUseBeforeDefine = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow the use of variables before they are defined\",\n            category: \"Variables\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-use-before-define\"\n        },\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        enum: [\"nofunc\"]\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            functions: { type: \"boolean\" },\n                            classes: { type: \"boolean\" },\n                            variables: { type: \"boolean\" }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ]\n    },\n\n    create(context) {\n        const options = parseOptions$1(context.options[0]);\n\n        /**\n         * Determines whether a given use-before-define case should be reported according to the options.\n         * @param {eslint-scope.Variable} variable The variable that gets used before being defined\n         * @param {eslint-scope.Reference} reference The reference to the variable\n         * @returns {boolean} `true` if the usage should be reported\n         */\n        function isForbidden(variable, reference) {\n            if (isFunction$1(variable)) {\n                return options.functions;\n            }\n            if (isOuterClass(variable, reference)) {\n                return options.classes;\n            }\n            if (isOuterVariable(variable, reference)) {\n                return options.variables;\n            }\n            return true;\n        }\n\n        /**\n         * Finds and validates all variables in a given scope.\n         * @param {Scope} scope The scope object.\n         * @returns {void}\n         * @private\n         */\n        function findVariablesInScope(scope) {\n            scope.references.forEach(reference => {\n                const variable = reference.resolved;\n\n                /*\n                 * Skips when the reference is:\n                 * - initialization's.\n                 * - referring to an undefined variable.\n                 * - referring to a global environment variable (there're no identifiers).\n                 * - located preceded by the variable (except in initializers).\n                 * - allowed by options.\n                 */\n                if (reference.init ||\n                    !variable ||\n                    variable.identifiers.length === 0 ||\n                    (variable.identifiers[0].range[1] < reference.identifier.range[1] && !isInInitializer(variable, reference)) ||\n                    !isForbidden(variable, reference)\n                ) {\n                    return;\n                }\n\n                // Reports.\n                context.report({\n                    node: reference.identifier,\n                    message: \"'{{name}}' was used before it was defined.\",\n                    data: reference.identifier\n                });\n            });\n\n            scope.childScopes.forEach(findVariablesInScope);\n        }\n\n        return {\n            Program() {\n                findVariablesInScope(context.getScope());\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not a node is a `.call()`/`.apply()`.\n * @param {ASTNode} node A CallExpression node to check.\n * @returns {boolean} Whether or not the node is a `.call()`/`.apply()`.\n */\nfunction isCallOrNonVariadicApply(node) {\n    return (\n        node.callee.type === \"MemberExpression\" &&\n        node.callee.property.type === \"Identifier\" &&\n        node.callee.computed === false &&\n        (\n            (node.callee.property.name === \"call\" && node.arguments.length >= 1) ||\n            (node.callee.property.name === \"apply\" && node.arguments.length === 2 && node.arguments[1].type === \"ArrayExpression\")\n        )\n    );\n}\n\n\n/**\n * Checks whether or not `thisArg` is not changed by `.call()`/`.apply()`.\n * @param {ASTNode|null} expectedThis The node that is the owner of the applied function.\n * @param {ASTNode} thisArg The node that is given to the first argument of the `.call()`/`.apply()`.\n * @param {SourceCode} sourceCode The ESLint source code object.\n * @returns {boolean} Whether or not `thisArg` is not changed by `.call()`/`.apply()`.\n */\nfunction isValidThisArg(expectedThis, thisArg, sourceCode) {\n    if (!expectedThis) {\n        return astUtils$1.isNullOrUndefined(thisArg);\n    }\n    return astUtils$1.equalTokens(expectedThis, thisArg, sourceCode);\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUselessCall = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow unnecessary calls to `.call()` and `.apply()`\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-useless-call\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        return {\n            CallExpression(node) {\n                if (!isCallOrNonVariadicApply(node)) {\n                    return;\n                }\n\n                const applied = node.callee.object;\n                const expectedThis = (applied.type === \"MemberExpression\") ? applied.object : null;\n                const thisArg = node.arguments[0];\n\n                if (isValidThisArg(expectedThis, thisArg, sourceCode)) {\n                    context.report({ node, message: \"unnecessary '.{{name}}()'.\", data: { name: node.callee.property.name } });\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Reports useless `catch` clauses that just rethrow their error.\n * @author Teddy Katz\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUselessCatch = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow unnecessary `catch` clauses\",\n            category: \"Best Practices\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-useless-catch\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        return {\n            CatchClause(node) {\n                if (\n                    node.param &&\n                    node.param.type === \"Identifier\" &&\n                    node.body.body.length &&\n                    node.body.body[0].type === \"ThrowStatement\" &&\n                    node.body.body[0].argument.type === \"Identifier\" &&\n                    node.body.body[0].argument.name === node.param.name\n                ) {\n                    if (node.parent.finalizer) {\n                        context.report({\n                            node,\n                            message: \"Unnecessary catch clause.\"\n                        });\n                    } else {\n                        context.report({\n                            node: node.parent,\n                            message: \"Unnecessary try/catch wrapper.\"\n                        });\n                    }\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nconst MESSAGE_UNNECESSARY_COMPUTED = \"Unnecessarily computed property [{{property}}] found.\";\n\nvar noUselessComputedKey = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow unnecessary computed property keys in objects and classes\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-useless-computed-key\"\n        },\n\n        schema: [{\n            type: \"object\",\n            properties: {\n                enforceForClassMembers: {\n                    type: \"boolean\",\n                    default: false\n                }\n            },\n            additionalProperties: false\n        }],\n        fixable: \"code\"\n    },\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const enforceForClassMembers = context.options[0] && context.options[0].enforceForClassMembers;\n\n        /**\n         * Reports a given node if it violated this rule.\n         * @param {ASTNode} node The node to check.\n         * @returns {void}\n         */\n        function check(node) {\n            if (!node.computed) {\n                return;\n            }\n\n            const key = node.key,\n                nodeType = typeof key.value;\n\n            let allowedKey;\n\n            if (node.type === \"MethodDefinition\") {\n                allowedKey = node.static ? \"prototype\" : \"constructor\";\n            } else {\n                allowedKey = \"__proto__\";\n            }\n\n            if (key.type === \"Literal\" && (nodeType === \"string\" || nodeType === \"number\") && key.value !== allowedKey) {\n                context.report({\n                    node,\n                    message: MESSAGE_UNNECESSARY_COMPUTED,\n                    data: { property: sourceCode.getText(key) },\n                    fix(fixer) {\n                        const leftSquareBracket = sourceCode.getFirstToken(node, astUtils$1.isOpeningBracketToken);\n                        const rightSquareBracket = sourceCode.getFirstTokenBetween(node.key, node.value, astUtils$1.isClosingBracketToken);\n                        const tokensBetween = sourceCode.getTokensBetween(leftSquareBracket, rightSquareBracket, 1);\n\n                        if (tokensBetween.slice(0, -1).some((token, index) =>\n                            sourceCode.getText().slice(token.range[1], tokensBetween[index + 1].range[0]).trim())) {\n\n                            // If there are comments between the brackets and the property name, don't do a fix.\n                            return null;\n                        }\n\n                        const tokenBeforeLeftBracket = sourceCode.getTokenBefore(leftSquareBracket);\n\n                        // Insert a space before the key to avoid changing identifiers, e.g. ({ get[2]() {} }) to ({ get2() {} })\n                        const needsSpaceBeforeKey = tokenBeforeLeftBracket.range[1] === leftSquareBracket.range[0] &&\n                            !astUtils$1.canTokensBeAdjacent(tokenBeforeLeftBracket, sourceCode.getFirstToken(key));\n\n                        const replacementKey = (needsSpaceBeforeKey ? \" \" : \"\") + key.raw;\n\n                        return fixer.replaceTextRange([leftSquareBracket.range[0], rightSquareBracket.range[1]], replacementKey);\n                    }\n                });\n            }\n        }\n\n        return {\n            Property: check,\n            MethodDefinition: enforceForClassMembers ? check : lodash.noop\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not a given node is a concatenation.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} `true` if the node is a concatenation.\n */\nfunction isConcatenation(node) {\n    return node.type === \"BinaryExpression\" && node.operator === \"+\";\n}\n\n/**\n * Checks if the given token is a `+` token or not.\n * @param {Token} token The token to check.\n * @returns {boolean} `true` if the token is a `+` token.\n */\nfunction isConcatOperatorToken(token) {\n    return token.value === \"+\" && token.type === \"Punctuator\";\n}\n\n/**\n * Get's the right most node on the left side of a BinaryExpression with + operator.\n * @param {ASTNode} node A BinaryExpression node to check.\n * @returns {ASTNode} node\n */\nfunction getLeft(node) {\n    let left = node.left;\n\n    while (isConcatenation(left)) {\n        left = left.right;\n    }\n    return left;\n}\n\n/**\n * Get's the left most node on the right side of a BinaryExpression with + operator.\n * @param {ASTNode} node A BinaryExpression node to check.\n * @returns {ASTNode} node\n */\nfunction getRight(node) {\n    let right = node.right;\n\n    while (isConcatenation(right)) {\n        right = right.left;\n    }\n    return right;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUselessConcat = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow unnecessary concatenation of literals or template literals\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-useless-concat\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        return {\n            BinaryExpression(node) {\n\n                // check if not concatenation\n                if (node.operator !== \"+\") {\n                    return;\n                }\n\n                // account for the `foo + \"a\" + \"b\"` case\n                const left = getLeft(node);\n                const right = getRight(node);\n\n                if (astUtils$1.isStringLiteral(left) &&\n                    astUtils$1.isStringLiteral(right) &&\n                    astUtils$1.isTokenOnSameLine(left, right)\n                ) {\n                    const operatorToken = sourceCode.getFirstTokenBetween(left, right, isConcatOperatorToken);\n\n                    context.report({\n                        node,\n                        loc: operatorToken.loc.start,\n                        message: \"Unexpected string concatenation of literals.\"\n                    });\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag the use of redundant constructors in classes.\n * @author Alberto Rodríguez\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether a given array of statements is a single call of `super`.\n * @param {ASTNode[]} body An array of statements to check.\n * @returns {boolean} `true` if the body is a single call of `super`.\n */\nfunction isSingleSuperCall(body) {\n    return (\n        body.length === 1 &&\n        body[0].type === \"ExpressionStatement\" &&\n        body[0].expression.type === \"CallExpression\" &&\n        body[0].expression.callee.type === \"Super\"\n    );\n}\n\n/**\n * Checks whether a given node is a pattern which doesn't have any side effects.\n * Default parameters and Destructuring parameters can have side effects.\n * @param {ASTNode} node A pattern node.\n * @returns {boolean} `true` if the node doesn't have any side effects.\n */\nfunction isSimple(node) {\n    return node.type === \"Identifier\" || node.type === \"RestElement\";\n}\n\n/**\n * Checks whether a given array of expressions is `...arguments` or not.\n * `super(...arguments)` passes all arguments through.\n * @param {ASTNode[]} superArgs An array of expressions to check.\n * @returns {boolean} `true` if the superArgs is `...arguments`.\n */\nfunction isSpreadArguments(superArgs) {\n    return (\n        superArgs.length === 1 &&\n        superArgs[0].type === \"SpreadElement\" &&\n        superArgs[0].argument.type === \"Identifier\" &&\n        superArgs[0].argument.name === \"arguments\"\n    );\n}\n\n/**\n * Checks whether given 2 nodes are identifiers which have the same name or not.\n * @param {ASTNode} ctorParam A node to check.\n * @param {ASTNode} superArg A node to check.\n * @returns {boolean} `true` if the nodes are identifiers which have the same\n *      name.\n */\nfunction isValidIdentifierPair(ctorParam, superArg) {\n    return (\n        ctorParam.type === \"Identifier\" &&\n        superArg.type === \"Identifier\" &&\n        ctorParam.name === superArg.name\n    );\n}\n\n/**\n * Checks whether given 2 nodes are a rest/spread pair which has the same values.\n * @param {ASTNode} ctorParam A node to check.\n * @param {ASTNode} superArg A node to check.\n * @returns {boolean} `true` if the nodes are a rest/spread pair which has the\n *      same values.\n */\nfunction isValidRestSpreadPair(ctorParam, superArg) {\n    return (\n        ctorParam.type === \"RestElement\" &&\n        superArg.type === \"SpreadElement\" &&\n        isValidIdentifierPair(ctorParam.argument, superArg.argument)\n    );\n}\n\n/**\n * Checks whether given 2 nodes have the same value or not.\n * @param {ASTNode} ctorParam A node to check.\n * @param {ASTNode} superArg A node to check.\n * @returns {boolean} `true` if the nodes have the same value or not.\n */\nfunction isValidPair(ctorParam, superArg) {\n    return (\n        isValidIdentifierPair(ctorParam, superArg) ||\n        isValidRestSpreadPair(ctorParam, superArg)\n    );\n}\n\n/**\n * Checks whether the parameters of a constructor and the arguments of `super()`\n * have the same values or not.\n * @param {ASTNode} ctorParams The parameters of a constructor to check.\n * @param {ASTNode} superArgs The arguments of `super()` to check.\n * @returns {boolean} `true` if those have the same values.\n */\nfunction isPassingThrough(ctorParams, superArgs) {\n    if (ctorParams.length !== superArgs.length) {\n        return false;\n    }\n\n    for (let i = 0; i < ctorParams.length; ++i) {\n        if (!isValidPair(ctorParams[i], superArgs[i])) {\n            return false;\n        }\n    }\n\n    return true;\n}\n\n/**\n * Checks whether the constructor body is a redundant super call.\n * @param {Array} body constructor body content.\n * @param {Array} ctorParams The params to check against super call.\n * @returns {boolean} true if the construtor body is redundant\n */\nfunction isRedundantSuperCall(body, ctorParams) {\n    return (\n        isSingleSuperCall(body) &&\n        ctorParams.every(isSimple) &&\n        (\n            isSpreadArguments(body[0].expression.arguments) ||\n            isPassingThrough(ctorParams, body[0].expression.arguments)\n        )\n    );\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUselessConstructor = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow unnecessary constructors\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-useless-constructor\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        /**\n         * Checks whether a node is a redundant constructor\n         * @param {ASTNode} node node to check\n         * @returns {void}\n         */\n        function checkForConstructor(node) {\n            if (node.kind !== \"constructor\") {\n                return;\n            }\n\n            const body = node.value.body.body;\n            const ctorParams = node.value.params;\n            const superClass = node.parent.parent.superClass;\n\n            if (superClass ? isRedundantSuperCall(body, ctorParams) : (body.length === 0)) {\n                context.report({\n                    node,\n                    message: \"Useless constructor.\"\n                });\n            }\n        }\n\n        return {\n            MethodDefinition: checkForConstructor\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\n/**\n * Returns the union of two sets.\n * @param {Set} setA The first set\n * @param {Set} setB The second set\n * @returns {Set} The union of the two sets\n */\nfunction union(setA, setB) {\n    return new Set(function *() {\n        yield* setA;\n        yield* setB;\n    }());\n}\n\nconst VALID_STRING_ESCAPES = union(new Set(\"\\\\nrvtbfux\"), astUtils$1.LINEBREAKS);\nconst REGEX_GENERAL_ESCAPES = new Set(\"\\\\bcdDfnpPrsStvwWxu0123456789]\");\nconst REGEX_NON_CHARCLASS_ESCAPES = union(REGEX_GENERAL_ESCAPES, new Set(\"^/.$*+?[{}|()Bk\"));\n\n/**\n * Parses a regular expression into a list of characters with character class info.\n * @param {string} regExpText The raw text used to create the regular expression\n * @returns {Object[]} A list of characters, each with info on escaping and whether they're in a character class.\n * @example\n *\n * parseRegExp('a\\\\b[cd-]')\n *\n * returns:\n * [\n *   {text: 'a', index: 0, escaped: false, inCharClass: false, startsCharClass: false, endsCharClass: false},\n *   {text: 'b', index: 2, escaped: true, inCharClass: false, startsCharClass: false, endsCharClass: false},\n *   {text: 'c', index: 4, escaped: false, inCharClass: true, startsCharClass: true, endsCharClass: false},\n *   {text: 'd', index: 5, escaped: false, inCharClass: true, startsCharClass: false, endsCharClass: false},\n *   {text: '-', index: 6, escaped: false, inCharClass: true, startsCharClass: false, endsCharClass: false}\n * ]\n */\nfunction parseRegExp(regExpText) {\n    const charList = [];\n\n    regExpText.split(\"\").reduce((state, char, index) => {\n        if (!state.escapeNextChar) {\n            if (char === \"\\\\\") {\n                return Object.assign(state, { escapeNextChar: true });\n            }\n            if (char === \"[\" && !state.inCharClass) {\n                return Object.assign(state, { inCharClass: true, startingCharClass: true });\n            }\n            if (char === \"]\" && state.inCharClass) {\n                if (charList.length && charList[charList.length - 1].inCharClass) {\n                    charList[charList.length - 1].endsCharClass = true;\n                }\n                return Object.assign(state, { inCharClass: false, startingCharClass: false });\n            }\n        }\n        charList.push({\n            text: char,\n            index,\n            escaped: state.escapeNextChar,\n            inCharClass: state.inCharClass,\n            startsCharClass: state.startingCharClass,\n            endsCharClass: false\n        });\n        return Object.assign(state, { escapeNextChar: false, startingCharClass: false });\n    }, { escapeNextChar: false, inCharClass: false, startingCharClass: false });\n\n    return charList;\n}\n\nvar noUselessEscape = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow unnecessary escape characters\",\n            category: \"Best Practices\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-useless-escape\",\n            suggestion: true\n        },\n\n        messages: {\n            unnecessaryEscape: \"Unnecessary escape character: \\\\{{character}}.\",\n            removeEscape: \"Remove the `\\\\`. This maintains the current functionality.\",\n            escapeBackslash: \"Replace the `\\\\` with `\\\\\\\\` to include the actual backslash character.\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Reports a node\n         * @param {ASTNode} node The node to report\n         * @param {number} startOffset The backslash's offset from the start of the node\n         * @param {string} character The uselessly escaped character (not including the backslash)\n         * @returns {void}\n         */\n        function report(node, startOffset, character) {\n            const start = sourceCode.getLocFromIndex(sourceCode.getIndexFromLoc(node.loc.start) + startOffset);\n            const rangeStart = sourceCode.getIndexFromLoc(node.loc.start) + startOffset;\n            const range = [rangeStart, rangeStart + 1];\n\n            context.report({\n                node,\n                loc: {\n                    start,\n                    end: { line: start.line, column: start.column + 1 }\n                },\n                messageId: \"unnecessaryEscape\",\n                data: { character },\n                suggest: [\n                    {\n                        messageId: \"removeEscape\",\n                        fix(fixer) {\n                            return fixer.removeRange(range);\n                        }\n                    },\n                    {\n                        messageId: \"escapeBackslash\",\n                        fix(fixer) {\n                            return fixer.insertTextBeforeRange(range, \"\\\\\");\n                        }\n                    }\n                ]\n            });\n        }\n\n        /**\n         * Checks if the escape character in given string slice is unnecessary.\n         * @private\n         * @param {ASTNode} node node to validate.\n         * @param {string} match string slice to validate.\n         * @returns {void}\n         */\n        function validateString(node, match) {\n            const isTemplateElement = node.type === \"TemplateElement\";\n            const escapedChar = match[0][1];\n            let isUnnecessaryEscape = !VALID_STRING_ESCAPES.has(escapedChar);\n            let isQuoteEscape;\n\n            if (isTemplateElement) {\n                isQuoteEscape = escapedChar === \"`\";\n\n                if (escapedChar === \"$\") {\n\n                    // Warn if `\\$` is not followed by `{`\n                    isUnnecessaryEscape = match.input[match.index + 2] !== \"{\";\n                } else if (escapedChar === \"{\") {\n\n                    /*\n                     * Warn if `\\{` is not preceded by `$`. If preceded by `$`, escaping\n                     * is necessary and the rule should not warn. If preceded by `/$`, the rule\n                     * will warn for the `/$` instead, as it is the first unnecessarily escaped character.\n                     */\n                    isUnnecessaryEscape = match.input[match.index - 1] !== \"$\";\n                }\n            } else {\n                isQuoteEscape = escapedChar === node.raw[0];\n            }\n\n            if (isUnnecessaryEscape && !isQuoteEscape) {\n                report(node, match.index + 1, match[0].slice(1));\n            }\n        }\n\n        /**\n         * Checks if a node has an escape.\n         * @param {ASTNode} node node to check.\n         * @returns {void}\n         */\n        function check(node) {\n            const isTemplateElement = node.type === \"TemplateElement\";\n\n            if (\n                isTemplateElement &&\n                node.parent &&\n                node.parent.parent &&\n                node.parent.parent.type === \"TaggedTemplateExpression\" &&\n                node.parent === node.parent.parent.quasi\n            ) {\n\n                // Don't report tagged template literals, because the backslash character is accessible to the tag function.\n                return;\n            }\n\n            if (typeof node.value === \"string\" || isTemplateElement) {\n\n                /*\n                 * JSXAttribute doesn't have any escape sequence: https://facebook.github.io/jsx/.\n                 * In addition, backticks are not supported by JSX yet: https://github.com/facebook/jsx/issues/25.\n                 */\n                if (node.parent.type === \"JSXAttribute\" || node.parent.type === \"JSXElement\" || node.parent.type === \"JSXFragment\") {\n                    return;\n                }\n\n                const value = isTemplateElement ? node.value.raw : node.raw.slice(1, -1);\n                const pattern = /\\\\[^\\d]/gu;\n                let match;\n\n                while ((match = pattern.exec(value))) {\n                    validateString(node, match);\n                }\n            } else if (node.regex) {\n                parseRegExp(node.regex.pattern)\n\n                    /*\n                     * The '-' character is a special case, because it's only valid to escape it if it's in a character\n                     * class, and is not at either edge of the character class. To account for this, don't consider '-'\n                     * characters to be valid in general, and filter out '-' characters that appear in the middle of a\n                     * character class.\n                     */\n                    .filter(charInfo => !(charInfo.text === \"-\" && charInfo.inCharClass && !charInfo.startsCharClass && !charInfo.endsCharClass))\n\n                    /*\n                     * The '^' character is also a special case; it must always be escaped outside of character classes, but\n                     * it only needs to be escaped in character classes if it's at the beginning of the character class. To\n                     * account for this, consider it to be a valid escape character outside of character classes, and filter\n                     * out '^' characters that appear at the start of a character class.\n                     */\n                    .filter(charInfo => !(charInfo.text === \"^\" && charInfo.startsCharClass))\n\n                    // Filter out characters that aren't escaped.\n                    .filter(charInfo => charInfo.escaped)\n\n                    // Filter out characters that are valid to escape, based on their position in the regular expression.\n                    .filter(charInfo => !(charInfo.inCharClass ? REGEX_GENERAL_ESCAPES : REGEX_NON_CHARCLASS_ESCAPES).has(charInfo.text))\n\n                    // Report all the remaining characters.\n                    .forEach(charInfo => report(node, charInfo.index, charInfo.text));\n            }\n\n        }\n\n        return {\n            Literal: check,\n            TemplateElement: check\n        };\n    }\n};\n\n/**\n * @fileoverview Disallow renaming import, export, and destructured assignments to the same name.\n * @author Kai Cataldo\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUselessRename = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow renaming import, export, and destructured assignments to the same name\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-useless-rename\"\n        },\n\n        fixable: \"code\",\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    ignoreDestructuring: { type: \"boolean\", default: false },\n                    ignoreImport: { type: \"boolean\", default: false },\n                    ignoreExport: { type: \"boolean\", default: false }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode(),\n            options = context.options[0] || {},\n            ignoreDestructuring = options.ignoreDestructuring === true,\n            ignoreImport = options.ignoreImport === true,\n            ignoreExport = options.ignoreExport === true;\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Reports error for unnecessarily renamed assignments\n         * @param {ASTNode} node node to report\n         * @param {ASTNode} initial node with initial name value\n         * @param {ASTNode} result node with new name value\n         * @param {string} type the type of the offending node\n         * @returns {void}\n         */\n        function reportError(node, initial, result, type) {\n            const name = initial.type === \"Identifier\" ? initial.name : initial.value;\n\n            return context.report({\n                node,\n                message: \"{{type}} {{name}} unnecessarily renamed.\",\n                data: {\n                    name,\n                    type\n                },\n                fix(fixer) {\n                    if (sourceCode.commentsExistBetween(initial, result)) {\n                        return null;\n                    }\n\n                    const replacementText = result.type === \"AssignmentPattern\"\n                        ? sourceCode.getText(result)\n                        : name;\n\n                    return fixer.replaceTextRange([\n                        initial.range[0],\n                        result.range[1]\n                    ], replacementText);\n                }\n            });\n        }\n\n        /**\n         * Checks whether a destructured assignment is unnecessarily renamed\n         * @param {ASTNode} node node to check\n         * @returns {void}\n         */\n        function checkDestructured(node) {\n            if (ignoreDestructuring) {\n                return;\n            }\n\n            for (const property of node.properties) {\n\n                /*\n                 * TODO: Remove after babel-eslint removes ExperimentalRestProperty\n                 * https://github.com/eslint/eslint/issues/12335\n                 */\n                if (property.type === \"ExperimentalRestProperty\") {\n                    continue;\n                }\n\n                /**\n                 * Properties using shorthand syntax and rest elements can not be renamed.\n                 * If the property is computed, we have no idea if a rename is useless or not.\n                 */\n                if (property.shorthand || property.type === \"RestElement\" || property.computed) {\n                    continue;\n                }\n\n                const key = (property.key.type === \"Identifier\" && property.key.name) || (property.key.type === \"Literal\" && property.key.value);\n                const renamedKey = property.value.type === \"AssignmentPattern\" ? property.value.left.name : property.value.name;\n\n                if (key === renamedKey) {\n                    reportError(property, property.key, property.value, \"Destructuring assignment\");\n                }\n            }\n        }\n\n        /**\n         * Checks whether an import is unnecessarily renamed\n         * @param {ASTNode} node node to check\n         * @returns {void}\n         */\n        function checkImport(node) {\n            if (ignoreImport) {\n                return;\n            }\n\n            if (node.imported.name === node.local.name &&\n                    node.imported.range[0] !== node.local.range[0]) {\n                reportError(node, node.imported, node.local, \"Import\");\n            }\n        }\n\n        /**\n         * Checks whether an export is unnecessarily renamed\n         * @param {ASTNode} node node to check\n         * @returns {void}\n         */\n        function checkExport(node) {\n            if (ignoreExport) {\n                return;\n            }\n\n            if (node.local.name === node.exported.name &&\n                    node.local.range[0] !== node.exported.range[0]) {\n                reportError(node, node.local, node.exported, \"Export\");\n            }\n\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            ObjectPattern: checkDestructured,\n            ImportSpecifier: checkImport,\n            ExportSpecifier: checkExport\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Removes the given element from the array.\n * @param {Array} array The source array to remove.\n * @param {any} element The target item to remove.\n * @returns {void}\n */\nfunction remove(array, element) {\n    const index = array.indexOf(element);\n\n    if (index !== -1) {\n        array.splice(index, 1);\n    }\n}\n\n/**\n * Checks whether it can remove the given return statement or not.\n * @param {ASTNode} node The return statement node to check.\n * @returns {boolean} `true` if the node is removeable.\n */\nfunction isRemovable(node) {\n    return astUtils$1.STATEMENT_LIST_PARENTS.has(node.parent.type);\n}\n\n/**\n * Checks whether the given return statement is in a `finally` block or not.\n * @param {ASTNode} node The return statement node to check.\n * @returns {boolean} `true` if the node is in a `finally` block.\n */\nfunction isInFinally(node) {\n    for (\n        let currentNode = node;\n        currentNode && currentNode.parent && !astUtils$1.isFunction(currentNode);\n        currentNode = currentNode.parent\n    ) {\n        if (currentNode.parent.type === \"TryStatement\" && currentNode.parent.finalizer === currentNode) {\n            return true;\n        }\n    }\n\n    return false;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noUselessReturn = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow redundant return statements\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-useless-return\"\n        },\n\n        fixable: \"code\",\n        schema: []\n    },\n\n    create(context) {\n        const segmentInfoMap = new WeakMap();\n        const usedUnreachableSegments = new WeakSet();\n        const sourceCode = context.getSourceCode();\n        let scopeInfo = null;\n\n        /**\n         * Checks whether the given segment is terminated by a return statement or not.\n         * @param {CodePathSegment} segment The segment to check.\n         * @returns {boolean} `true` if the segment is terminated by a return statement, or if it's still a part of unreachable.\n         */\n        function isReturned(segment) {\n            const info = segmentInfoMap.get(segment);\n\n            return !info || info.returned;\n        }\n\n        /**\n         * Collects useless return statements from the given previous segments.\n         *\n         * A previous segment may be an unreachable segment.\n         * In that case, the information object of the unreachable segment is not\n         * initialized because `onCodePathSegmentStart` event is not notified for\n         * unreachable segments.\n         * This goes to the previous segments of the unreachable segment recursively\n         * if the unreachable segment was generated by a return statement. Otherwise,\n         * this ignores the unreachable segment.\n         *\n         * This behavior would simulate code paths for the case that the return\n         * statement does not exist.\n         * @param {ASTNode[]} uselessReturns The collected return statements.\n         * @param {CodePathSegment[]} prevSegments The previous segments to traverse.\n         * @param {WeakSet<CodePathSegment>} [providedTraversedSegments] A set of segments that have already been traversed in this call\n         * @returns {ASTNode[]} `uselessReturns`.\n         */\n        function getUselessReturns(uselessReturns, prevSegments, providedTraversedSegments) {\n            const traversedSegments = providedTraversedSegments || new WeakSet();\n\n            for (const segment of prevSegments) {\n                if (!segment.reachable) {\n                    if (!traversedSegments.has(segment)) {\n                        traversedSegments.add(segment);\n                        getUselessReturns(\n                            uselessReturns,\n                            segment.allPrevSegments.filter(isReturned),\n                            traversedSegments\n                        );\n                    }\n                    continue;\n                }\n\n                uselessReturns.push(...segmentInfoMap.get(segment).uselessReturns);\n            }\n\n            return uselessReturns;\n        }\n\n        /**\n         * Removes the return statements on the given segment from the useless return\n         * statement list.\n         *\n         * This segment may be an unreachable segment.\n         * In that case, the information object of the unreachable segment is not\n         * initialized because `onCodePathSegmentStart` event is not notified for\n         * unreachable segments.\n         * This goes to the previous segments of the unreachable segment recursively\n         * if the unreachable segment was generated by a return statement. Otherwise,\n         * this ignores the unreachable segment.\n         *\n         * This behavior would simulate code paths for the case that the return\n         * statement does not exist.\n         * @param {CodePathSegment} segment The segment to get return statements.\n         * @returns {void}\n         */\n        function markReturnStatementsOnSegmentAsUsed(segment) {\n            if (!segment.reachable) {\n                usedUnreachableSegments.add(segment);\n                segment.allPrevSegments\n                    .filter(isReturned)\n                    .filter(prevSegment => !usedUnreachableSegments.has(prevSegment))\n                    .forEach(markReturnStatementsOnSegmentAsUsed);\n                return;\n            }\n\n            const info = segmentInfoMap.get(segment);\n\n            for (const node of info.uselessReturns) {\n                remove(scopeInfo.uselessReturns, node);\n            }\n            info.uselessReturns = [];\n        }\n\n        /**\n         * Removes the return statements on the current segments from the useless\n         * return statement list.\n         *\n         * This function will be called at every statement except FunctionDeclaration,\n         * BlockStatement, and BreakStatement.\n         *\n         * - FunctionDeclarations are always executed whether it's returned or not.\n         * - BlockStatements do nothing.\n         * - BreakStatements go the next merely.\n         * @returns {void}\n         */\n        function markReturnStatementsOnCurrentSegmentsAsUsed() {\n            scopeInfo\n                .codePath\n                .currentSegments\n                .forEach(markReturnStatementsOnSegmentAsUsed);\n        }\n\n        //----------------------------------------------------------------------\n        // Public\n        //----------------------------------------------------------------------\n\n        return {\n\n            // Makes and pushs a new scope information.\n            onCodePathStart(codePath) {\n                scopeInfo = {\n                    upper: scopeInfo,\n                    uselessReturns: [],\n                    codePath\n                };\n            },\n\n            // Reports useless return statements if exist.\n            onCodePathEnd() {\n                for (const node of scopeInfo.uselessReturns) {\n                    context.report({\n                        node,\n                        loc: node.loc,\n                        message: \"Unnecessary return statement.\",\n                        fix(fixer) {\n                            if (isRemovable(node) && !sourceCode.getCommentsInside(node).length) {\n\n                                /*\n                                 * Extend the replacement range to include the\n                                 * entire function to avoid conflicting with\n                                 * no-else-return.\n                                 * https://github.com/eslint/eslint/issues/8026\n                                 */\n                                return new fixTracker(fixer, sourceCode)\n                                    .retainEnclosingFunction(node)\n                                    .remove(node);\n                            }\n                            return null;\n                        }\n                    });\n                }\n\n                scopeInfo = scopeInfo.upper;\n            },\n\n            /*\n             * Initializes segments.\n             * NOTE: This event is notified for only reachable segments.\n             */\n            onCodePathSegmentStart(segment) {\n                const info = {\n                    uselessReturns: getUselessReturns([], segment.allPrevSegments),\n                    returned: false\n                };\n\n                // Stores the info.\n                segmentInfoMap.set(segment, info);\n            },\n\n            // Adds ReturnStatement node to check whether it's useless or not.\n            ReturnStatement(node) {\n                if (node.argument) {\n                    markReturnStatementsOnCurrentSegmentsAsUsed();\n                }\n                if (\n                    node.argument ||\n                    astUtils$1.isInLoop(node) ||\n                    isInFinally(node) ||\n\n                    // Ignore `return` statements in unreachable places (https://github.com/eslint/eslint/issues/11647).\n                    !scopeInfo.codePath.currentSegments.some(s => s.reachable)\n                ) {\n                    return;\n                }\n\n                for (const segment of scopeInfo.codePath.currentSegments) {\n                    const info = segmentInfoMap.get(segment);\n\n                    if (info) {\n                        info.uselessReturns.push(node);\n                        info.returned = true;\n                    }\n                }\n                scopeInfo.uselessReturns.push(node);\n            },\n\n            /*\n             * Registers for all statement nodes except FunctionDeclaration, BlockStatement, BreakStatement.\n             * Removes return statements of the current segments from the useless return statement list.\n             */\n            ClassDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,\n            ContinueStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            DebuggerStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            DoWhileStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            EmptyStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            ExpressionStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            ForInStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            ForOfStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            ForStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            IfStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            ImportDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,\n            LabeledStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            SwitchStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            ThrowStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            TryStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            VariableDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,\n            WhileStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            WithStatement: markReturnStatementsOnCurrentSegmentsAsUsed,\n            ExportNamedDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,\n            ExportDefaultDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,\n            ExportAllDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Check whether a given variable is a global variable or not.\n * @param {eslint-scope.Variable} variable The variable to check.\n * @returns {boolean} `true` if the variable is a global variable.\n */\nfunction isGlobal(variable) {\n    return Boolean(variable.scope) && variable.scope.type === \"global\";\n}\n\n/**\n * Finds the nearest function scope or global scope walking up the scope\n * hierarchy.\n * @param {eslint-scope.Scope} scope The scope to traverse.\n * @returns {eslint-scope.Scope} a function scope or global scope containing the given\n *      scope.\n */\nfunction getEnclosingFunctionScope(scope) {\n    let currentScope = scope;\n\n    while (currentScope.type !== \"function\" && currentScope.type !== \"global\") {\n        currentScope = currentScope.upper;\n    }\n    return currentScope;\n}\n\n/**\n * Checks whether the given variable has any references from a more specific\n * function expression (i.e. a closure).\n * @param {eslint-scope.Variable} variable A variable to check.\n * @returns {boolean} `true` if the variable is used from a closure.\n */\nfunction isReferencedInClosure(variable) {\n    const enclosingFunctionScope = getEnclosingFunctionScope(variable.scope);\n\n    return variable.references.some(reference =>\n        getEnclosingFunctionScope(reference.from) !== enclosingFunctionScope);\n}\n\n/**\n * Checks whether the given node is the assignee of a loop.\n * @param {ASTNode} node A VariableDeclaration node to check.\n * @returns {boolean} `true` if the declaration is assigned as part of loop\n *      iteration.\n */\nfunction isLoopAssignee(node) {\n    return (node.parent.type === \"ForOfStatement\" || node.parent.type === \"ForInStatement\") &&\n        node === node.parent.left;\n}\n\n/**\n * Checks whether the given variable declaration is immediately initialized.\n * @param {ASTNode} node A VariableDeclaration node to check.\n * @returns {boolean} `true` if the declaration has an initializer.\n */\nfunction isDeclarationInitialized(node) {\n    return node.declarations.every(declarator => declarator.init !== null);\n}\n\nconst SCOPE_NODE_TYPE = /^(?:Program|BlockStatement|SwitchStatement|ForStatement|ForInStatement|ForOfStatement)$/u;\n\n/**\n * Gets the scope node which directly contains a given node.\n * @param {ASTNode} node A node to get. This is a `VariableDeclaration` or\n *      an `Identifier`.\n * @returns {ASTNode} A scope node. This is one of `Program`, `BlockStatement`,\n *      `SwitchStatement`, `ForStatement`, `ForInStatement`, and\n *      `ForOfStatement`.\n */\nfunction getScopeNode(node) {\n    for (let currentNode = node; currentNode; currentNode = currentNode.parent) {\n        if (SCOPE_NODE_TYPE.test(currentNode.type)) {\n            return currentNode;\n        }\n    }\n\n    /* istanbul ignore next : unreachable */\n    return null;\n}\n\n/**\n * Checks whether a given variable is redeclared or not.\n * @param {eslint-scope.Variable} variable A variable to check.\n * @returns {boolean} `true` if the variable is redeclared.\n */\nfunction isRedeclared(variable) {\n    return variable.defs.length >= 2;\n}\n\n/**\n * Checks whether a given variable is used from outside of the specified scope.\n * @param {ASTNode} scopeNode A scope node to check.\n * @returns {Function} The predicate function which checks whether a given\n *      variable is used from outside of the specified scope.\n */\nfunction isUsedFromOutsideOf(scopeNode) {\n\n    /**\n     * Checks whether a given reference is inside of the specified scope or not.\n     * @param {eslint-scope.Reference} reference A reference to check.\n     * @returns {boolean} `true` if the reference is inside of the specified\n     *      scope.\n     */\n    function isOutsideOfScope(reference) {\n        const scope = scopeNode.range;\n        const id = reference.identifier.range;\n\n        return id[0] < scope[0] || id[1] > scope[1];\n    }\n\n    return function(variable) {\n        return variable.references.some(isOutsideOfScope);\n    };\n}\n\n/**\n * Creates the predicate function which checks whether a variable has their references in TDZ.\n *\n * The predicate function would return `true`:\n *\n * - if a reference is before the declarator. E.g. (var a = b, b = 1;)(var {a = b, b} = {};)\n * - if a reference is in the expression of their default value.  E.g. (var {a = a} = {};)\n * - if a reference is in the expression of their initializer.  E.g. (var a = a;)\n * @param {ASTNode} node The initializer node of VariableDeclarator.\n * @returns {Function} The predicate function.\n * @private\n */\nfunction hasReferenceInTDZ(node) {\n    const initStart = node.range[0];\n    const initEnd = node.range[1];\n\n    return variable => {\n        const id = variable.defs[0].name;\n        const idStart = id.range[0];\n        const defaultValue = (id.parent.type === \"AssignmentPattern\" ? id.parent.right : null);\n        const defaultStart = defaultValue && defaultValue.range[0];\n        const defaultEnd = defaultValue && defaultValue.range[1];\n\n        return variable.references.some(reference => {\n            const start = reference.identifier.range[0];\n            const end = reference.identifier.range[1];\n\n            return !reference.init && (\n                start < idStart ||\n                (defaultValue !== null && start >= defaultStart && end <= defaultEnd) ||\n                (start >= initStart && end <= initEnd)\n            );\n        });\n    };\n}\n\n/**\n * Checks whether a given variable has name that is allowed for 'var' declarations,\n * but disallowed for `let` declarations.\n * @param {eslint-scope.Variable} variable The variable to check.\n * @returns {boolean} `true` if the variable has a disallowed name.\n */\nfunction hasNameDisallowedForLetDeclarations(variable) {\n    return variable.name === \"let\";\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noVar = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require `let` or `const` instead of `var`\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-var\"\n        },\n\n        schema: [],\n        fixable: \"code\"\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Checks whether the variables which are defined by the given declarator node have their references in TDZ.\n         * @param {ASTNode} declarator The VariableDeclarator node to check.\n         * @returns {boolean} `true` if one of the variables which are defined by the given declarator node have their references in TDZ.\n         */\n        function hasSelfReferenceInTDZ(declarator) {\n            if (!declarator.init) {\n                return false;\n            }\n            const variables = context.getDeclaredVariables(declarator);\n\n            return variables.some(hasReferenceInTDZ(declarator.init));\n        }\n\n        /**\n         * Checks whether it can fix a given variable declaration or not.\n         * It cannot fix if the following cases:\n         *\n         * - A variable is a global variable.\n         * - A variable is declared on a SwitchCase node.\n         * - A variable is redeclared.\n         * - A variable is used from outside the scope.\n         * - A variable is used from a closure within a loop.\n         * - A variable might be used before it is assigned within a loop.\n         * - A variable might be used in TDZ.\n         * - A variable is declared in statement position (e.g. a single-line `IfStatement`)\n         * - A variable has name that is disallowed for `let` declarations.\n         *\n         * ## A variable is declared on a SwitchCase node.\n         *\n         * If this rule modifies 'var' declarations on a SwitchCase node, it\n         * would generate the warnings of 'no-case-declarations' rule. And the\n         * 'eslint:recommended' preset includes 'no-case-declarations' rule, so\n         * this rule doesn't modify those declarations.\n         *\n         * ## A variable is redeclared.\n         *\n         * The language spec disallows redeclarations of `let` declarations.\n         * Those variables would cause syntax errors.\n         *\n         * ## A variable is used from outside the scope.\n         *\n         * The language spec disallows accesses from outside of the scope for\n         * `let` declarations. Those variables would cause reference errors.\n         *\n         * ## A variable is used from a closure within a loop.\n         *\n         * A `var` declaration within a loop shares the same variable instance\n         * across all loop iterations, while a `let` declaration creates a new\n         * instance for each iteration. This means if a variable in a loop is\n         * referenced by any closure, changing it from `var` to `let` would\n         * change the behavior in a way that is generally unsafe.\n         *\n         * ## A variable might be used before it is assigned within a loop.\n         *\n         * Within a loop, a `let` declaration without an initializer will be\n         * initialized to null, while a `var` declaration will retain its value\n         * from the previous iteration, so it is only safe to change `var` to\n         * `let` if we can statically determine that the variable is always\n         * assigned a value before its first access in the loop body. To keep\n         * the implementation simple, we only convert `var` to `let` within\n         * loops when the variable is a loop assignee or the declaration has an\n         * initializer.\n         * @param {ASTNode} node A variable declaration node to check.\n         * @returns {boolean} `true` if it can fix the node.\n         */\n        function canFix(node) {\n            const variables = context.getDeclaredVariables(node);\n            const scopeNode = getScopeNode(node);\n\n            if (node.parent.type === \"SwitchCase\" ||\n                node.declarations.some(hasSelfReferenceInTDZ) ||\n                variables.some(isGlobal) ||\n                variables.some(isRedeclared) ||\n                variables.some(isUsedFromOutsideOf(scopeNode)) ||\n                variables.some(hasNameDisallowedForLetDeclarations)\n            ) {\n                return false;\n            }\n\n            if (astUtils$1.isInLoop(node)) {\n                if (variables.some(isReferencedInClosure)) {\n                    return false;\n                }\n                if (!isLoopAssignee(node) && !isDeclarationInitialized(node)) {\n                    return false;\n                }\n            }\n\n            if (\n                !isLoopAssignee(node) &&\n                !(node.parent.type === \"ForStatement\" && node.parent.init === node) &&\n                !astUtils$1.STATEMENT_LIST_PARENTS.has(node.parent.type)\n            ) {\n\n                // If the declaration is not in a block, e.g. `if (foo) var bar = 1;`, then it can't be fixed.\n                return false;\n            }\n\n            return true;\n        }\n\n        /**\n         * Reports a given variable declaration node.\n         * @param {ASTNode} node A variable declaration node to report.\n         * @returns {void}\n         */\n        function report(node) {\n            context.report({\n                node,\n                message: \"Unexpected var, use let or const instead.\",\n\n                fix(fixer) {\n                    const varToken = sourceCode.getFirstToken(node, { filter: t => t.value === \"var\" });\n\n                    return canFix(node)\n                        ? fixer.replaceText(varToken, \"let\")\n                        : null;\n                }\n            });\n        }\n\n        return {\n            \"VariableDeclaration:exit\"(node) {\n                if (node.kind === \"var\") {\n                    report(node);\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to disallow use of void operator.\n * @author Mike Sidorov\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noVoid = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `void` operators\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-void\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            UnaryExpression(node) {\n                if (node.operator === \"void\") {\n                    context.report({ node, message: \"Expected 'undefined' and instead saw 'void'.\" });\n                }\n            }\n        };\n\n    }\n};\n\nconst { escapeRegExp } = lodash;\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noWarningComments = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow specified warning terms in comments\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-warning-comments\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    terms: {\n                        type: \"array\",\n                        items: {\n                            type: \"string\"\n                        }\n                    },\n                    location: {\n                        enum: [\"start\", \"anywhere\"]\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n\n        const sourceCode = context.getSourceCode(),\n            configuration = context.options[0] || {},\n            warningTerms = configuration.terms || [\"todo\", \"fixme\", \"xxx\"],\n            location = configuration.location || \"start\",\n            selfConfigRegEx = /\\bno-warning-comments\\b/u;\n\n        /**\n         * Convert a warning term into a RegExp which will match a comment containing that whole word in the specified\n         * location (\"start\" or \"anywhere\"). If the term starts or ends with non word characters, then the match will not\n         * require word boundaries on that side.\n         * @param {string} term A term to convert to a RegExp\n         * @returns {RegExp} The term converted to a RegExp\n         */\n        function convertToRegExp(term) {\n            const escaped = escapeRegExp(term);\n            const wordBoundary = \"\\\\b\";\n            const eitherOrWordBoundary = `|${wordBoundary}`;\n            let prefix;\n\n            /*\n             * If the term ends in a word character (a-z0-9_), ensure a word\n             * boundary at the end, so that substrings do not get falsely\n             * matched. eg \"todo\" in a string such as \"mastodon\".\n             * If the term ends in a non-word character, then \\b won't match on\n             * the boundary to the next non-word character, which would likely\n             * be a space. For example `/\\bFIX!\\b/.test('FIX! blah') === false`.\n             * In these cases, use no bounding match. Same applies for the\n             * prefix, handled below.\n             */\n            const suffix = /\\w$/u.test(term) ? \"\\\\b\" : \"\";\n\n            if (location === \"start\") {\n\n                /*\n                 * When matching at the start, ignore leading whitespace, and\n                 * there's no need to worry about word boundaries.\n                 */\n                prefix = \"^\\\\s*\";\n            } else if (/^\\w/u.test(term)) {\n                prefix = wordBoundary;\n            } else {\n                prefix = \"\";\n            }\n\n            if (location === \"start\") {\n\n                /*\n                 * For location \"start\" the regex should be\n                 * ^\\s*TERM\\b.  This checks the word boundary\n                 * at the beginning of the comment.\n                 */\n                return new RegExp(prefix + escaped + suffix, \"iu\");\n            }\n\n            /*\n             * For location \"anywhere\" the regex should be\n             * \\bTERM\\b|\\bTERM\\b, this checks the entire comment\n             * for the term.\n             */\n            return new RegExp(prefix + escaped + suffix + eitherOrWordBoundary + term + wordBoundary, \"iu\");\n        }\n\n        const warningRegExps = warningTerms.map(convertToRegExp);\n\n        /**\n         * Checks the specified comment for matches of the configured warning terms and returns the matches.\n         * @param {string} comment The comment which is checked.\n         * @returns {Array} All matched warning terms for this comment.\n         */\n        function commentContainsWarningTerm(comment) {\n            const matches = [];\n\n            warningRegExps.forEach((regex, index) => {\n                if (regex.test(comment)) {\n                    matches.push(warningTerms[index]);\n                }\n            });\n\n            return matches;\n        }\n\n        /**\n         * Checks the specified node for matching warning comments and reports them.\n         * @param {ASTNode} node The AST node being checked.\n         * @returns {void} undefined.\n         */\n        function checkComment(node) {\n            if (astUtils$1.isDirectiveComment(node) && selfConfigRegEx.test(node.value)) {\n                return;\n            }\n\n            const matches = commentContainsWarningTerm(node.value);\n\n            matches.forEach(matchedTerm => {\n                context.report({\n                    node,\n                    message: \"Unexpected '{{matchedTerm}}' comment.\",\n                    data: {\n                        matchedTerm\n                    }\n                });\n            });\n        }\n\n        return {\n            Program() {\n                const comments = sourceCode.getAllComments();\n\n                comments.filter(token => token.type !== \"Shebang\").forEach(checkComment);\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noWhitespaceBeforeProperty = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"disallow whitespace before properties\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/no-whitespace-before-property\"\n        },\n\n        fixable: \"whitespace\",\n        schema: []\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Reports whitespace before property token\n         * @param {ASTNode} node the node to report in the event of an error\n         * @param {Token} leftToken the left token\n         * @param {Token} rightToken the right token\n         * @returns {void}\n         * @private\n         */\n        function reportError(node, leftToken, rightToken) {\n            const replacementText = node.computed ? \"\" : \".\";\n\n            context.report({\n                node,\n                message: \"Unexpected whitespace before property {{propName}}.\",\n                data: {\n                    propName: sourceCode.getText(node.property)\n                },\n                fix(fixer) {\n                    if (!node.computed && astUtils$1.isDecimalInteger(node.object)) {\n\n                        /*\n                         * If the object is a number literal, fixing it to something like 5.toString() would cause a SyntaxError.\n                         * Don't fix this case.\n                         */\n                        return null;\n                    }\n                    return fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], replacementText);\n                }\n            });\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            MemberExpression(node) {\n                let rightToken;\n                let leftToken;\n\n                if (!astUtils$1.isTokenOnSameLine(node.object, node.property)) {\n                    return;\n                }\n\n                if (node.computed) {\n                    rightToken = sourceCode.getTokenBefore(node.property, astUtils$1.isOpeningBracketToken);\n                    leftToken = sourceCode.getTokenBefore(rightToken);\n                } else {\n                    rightToken = sourceCode.getFirstToken(node.property);\n                    leftToken = sourceCode.getTokenBefore(rightToken, 1);\n                }\n\n                if (sourceCode.isSpaceBetweenTokens(leftToken, rightToken)) {\n                    reportError(node, leftToken, rightToken);\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag use of with statement\n * @author Nicholas C. Zakas\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar noWith = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `with` statements\",\n            category: \"Best Practices\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/no-with\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        return {\n            WithStatement(node) {\n                context.report({ node, message: \"Unexpected use of 'with' statement.\" });\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview enforce the location of single-line statements\n * @author Teddy Katz\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nconst POSITION_SCHEMA = { enum: [\"beside\", \"below\", \"any\"] };\n\nvar nonblockStatementBodyPosition = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce the location of single-line statements\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/nonblock-statement-body-position\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            POSITION_SCHEMA,\n            {\n                properties: {\n                    overrides: {\n                        properties: {\n                            if: POSITION_SCHEMA,\n                            else: POSITION_SCHEMA,\n                            while: POSITION_SCHEMA,\n                            do: POSITION_SCHEMA,\n                            for: POSITION_SCHEMA\n                        },\n                        additionalProperties: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        //----------------------------------------------------------------------\n        // Helpers\n        //----------------------------------------------------------------------\n\n        /**\n         * Gets the applicable preference for a particular keyword\n         * @param {string} keywordName The name of a keyword, e.g. 'if'\n         * @returns {string} The applicable option for the keyword, e.g. 'beside'\n         */\n        function getOption(keywordName) {\n            return context.options[1] && context.options[1].overrides && context.options[1].overrides[keywordName] ||\n                context.options[0] ||\n                \"beside\";\n        }\n\n        /**\n         * Validates the location of a single-line statement\n         * @param {ASTNode} node The single-line statement\n         * @param {string} keywordName The applicable keyword name for the single-line statement\n         * @returns {void}\n         */\n        function validateStatement(node, keywordName) {\n            const option = getOption(keywordName);\n\n            if (node.type === \"BlockStatement\" || option === \"any\") {\n                return;\n            }\n\n            const tokenBefore = sourceCode.getTokenBefore(node);\n\n            if (tokenBefore.loc.end.line === node.loc.start.line && option === \"below\") {\n                context.report({\n                    node,\n                    message: \"Expected a linebreak before this statement.\",\n                    fix: fixer => fixer.insertTextBefore(node, \"\\n\")\n                });\n            } else if (tokenBefore.loc.end.line !== node.loc.start.line && option === \"beside\") {\n                context.report({\n                    node,\n                    message: \"Expected no linebreak before this statement.\",\n                    fix(fixer) {\n                        if (sourceCode.getText().slice(tokenBefore.range[1], node.range[0]).trim()) {\n                            return null;\n                        }\n                        return fixer.replaceTextRange([tokenBefore.range[1], node.range[0]], \" \");\n                    }\n                });\n            }\n        }\n\n        //----------------------------------------------------------------------\n        // Public\n        //----------------------------------------------------------------------\n\n        return {\n            IfStatement(node) {\n                validateStatement(node.consequent, \"if\");\n\n                // Check the `else` node, but don't check 'else if' statements.\n                if (node.alternate && node.alternate.type !== \"IfStatement\") {\n                    validateStatement(node.alternate, \"else\");\n                }\n            },\n            WhileStatement: node => validateStatement(node.body, \"while\"),\n            DoWhileStatement: node => validateStatement(node.body, \"do\"),\n            ForStatement: node => validateStatement(node.body, \"for\"),\n            ForInStatement: node => validateStatement(node.body, \"for\"),\n            ForOfStatement: node => validateStatement(node.body, \"for\")\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n// Schema objects.\nconst OPTION_VALUE = {\n    oneOf: [\n        {\n            enum: [\"always\", \"never\"]\n        },\n        {\n            type: \"object\",\n            properties: {\n                multiline: {\n                    type: \"boolean\"\n                },\n                minProperties: {\n                    type: \"integer\",\n                    minimum: 0\n                },\n                consistent: {\n                    type: \"boolean\"\n                }\n            },\n            additionalProperties: false,\n            minProperties: 1\n        }\n    ]\n};\n\n/**\n * Normalizes a given option value.\n * @param {string|Object|undefined} value An option value to parse.\n * @returns {{multiline: boolean, minProperties: number, consistent: boolean}} Normalized option object.\n */\nfunction normalizeOptionValue(value) {\n    let multiline = false;\n    let minProperties = Number.POSITIVE_INFINITY;\n    let consistent = false;\n\n    if (value) {\n        if (value === \"always\") {\n            minProperties = 0;\n        } else if (value === \"never\") {\n            minProperties = Number.POSITIVE_INFINITY;\n        } else {\n            multiline = Boolean(value.multiline);\n            minProperties = value.minProperties || Number.POSITIVE_INFINITY;\n            consistent = Boolean(value.consistent);\n        }\n    } else {\n        consistent = true;\n    }\n\n    return { multiline, minProperties, consistent };\n}\n\n/**\n * Normalizes a given option value.\n * @param {string|Object|undefined} options An option value to parse.\n * @returns {{\n *   ObjectExpression: {multiline: boolean, minProperties: number, consistent: boolean},\n *   ObjectPattern: {multiline: boolean, minProperties: number, consistent: boolean},\n *   ImportDeclaration: {multiline: boolean, minProperties: number, consistent: boolean},\n *   ExportNamedDeclaration : {multiline: boolean, minProperties: number, consistent: boolean}\n * }} Normalized option object.\n */\nfunction normalizeOptions$4(options) {\n    const isNodeSpecificOption = lodash.overSome([lodash.isPlainObject, lodash.isString]);\n\n    if (lodash.isPlainObject(options) && lodash.some(options, isNodeSpecificOption)) {\n        return {\n            ObjectExpression: normalizeOptionValue(options.ObjectExpression),\n            ObjectPattern: normalizeOptionValue(options.ObjectPattern),\n            ImportDeclaration: normalizeOptionValue(options.ImportDeclaration),\n            ExportNamedDeclaration: normalizeOptionValue(options.ExportDeclaration)\n        };\n    }\n\n    const value = normalizeOptionValue(options);\n\n    return { ObjectExpression: value, ObjectPattern: value, ImportDeclaration: value, ExportNamedDeclaration: value };\n}\n\n/**\n * Determines if ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration\n * node needs to be checked for missing line breaks\n * @param {ASTNode} node Node under inspection\n * @param {Object} options option specific to node type\n * @param {Token} first First object property\n * @param {Token} last Last object property\n * @returns {boolean} `true` if node needs to be checked for missing line breaks\n */\nfunction areLineBreaksRequired(node, options, first, last) {\n    let objectProperties;\n\n    if (node.type === \"ObjectExpression\" || node.type === \"ObjectPattern\") {\n        objectProperties = node.properties;\n    } else {\n\n        // is ImportDeclaration or ExportNamedDeclaration\n        objectProperties = node.specifiers\n            .filter(s => s.type === \"ImportSpecifier\" || s.type === \"ExportSpecifier\");\n    }\n\n    return objectProperties.length >= options.minProperties ||\n        (\n            options.multiline &&\n            objectProperties.length > 0 &&\n            first.loc.start.line !== last.loc.end.line\n        );\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar objectCurlyNewline = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent line breaks inside braces\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/object-curly-newline\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                oneOf: [\n                    OPTION_VALUE,\n                    {\n                        type: \"object\",\n                        properties: {\n                            ObjectExpression: OPTION_VALUE,\n                            ObjectPattern: OPTION_VALUE,\n                            ImportDeclaration: OPTION_VALUE,\n                            ExportDeclaration: OPTION_VALUE\n                        },\n                        additionalProperties: false,\n                        minProperties: 1\n                    }\n                ]\n            }\n        ]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const normalizedOptions = normalizeOptions$4(context.options[0]);\n\n        /**\n         * Reports a given node if it violated this rule.\n         * @param {ASTNode} node A node to check. This is an ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration node.\n         * @returns {void}\n         */\n        function check(node) {\n            const options = normalizedOptions[node.type];\n\n            if (\n                (node.type === \"ImportDeclaration\" &&\n                    !node.specifiers.some(specifier => specifier.type === \"ImportSpecifier\")) ||\n                (node.type === \"ExportNamedDeclaration\" &&\n                    !node.specifiers.some(specifier => specifier.type === \"ExportSpecifier\"))\n            ) {\n                return;\n            }\n\n            const openBrace = sourceCode.getFirstToken(node, token => token.value === \"{\");\n\n            let closeBrace;\n\n            if (node.typeAnnotation) {\n                closeBrace = sourceCode.getTokenBefore(node.typeAnnotation);\n            } else {\n                closeBrace = sourceCode.getLastToken(node, token => token.value === \"}\");\n            }\n\n            let first = sourceCode.getTokenAfter(openBrace, { includeComments: true });\n            let last = sourceCode.getTokenBefore(closeBrace, { includeComments: true });\n\n            const needsLineBreaks = areLineBreaksRequired(node, options, first, last);\n\n            const hasCommentsFirstToken = astUtils$1.isCommentToken(first);\n            const hasCommentsLastToken = astUtils$1.isCommentToken(last);\n\n            /*\n             * Use tokens or comments to check multiline or not.\n             * But use only tokens to check whether line breaks are needed.\n             * This allows:\n             *     var obj = { // eslint-disable-line foo\n             *         a: 1\n             *     }\n             */\n            first = sourceCode.getTokenAfter(openBrace);\n            last = sourceCode.getTokenBefore(closeBrace);\n\n            if (needsLineBreaks) {\n                if (astUtils$1.isTokenOnSameLine(openBrace, first)) {\n                    context.report({\n                        message: \"Expected a line break after this opening brace.\",\n                        node,\n                        loc: openBrace.loc.start,\n                        fix(fixer) {\n                            if (hasCommentsFirstToken) {\n                                return null;\n                            }\n\n                            return fixer.insertTextAfter(openBrace, \"\\n\");\n                        }\n                    });\n                }\n                if (astUtils$1.isTokenOnSameLine(last, closeBrace)) {\n                    context.report({\n                        message: \"Expected a line break before this closing brace.\",\n                        node,\n                        loc: closeBrace.loc.start,\n                        fix(fixer) {\n                            if (hasCommentsLastToken) {\n                                return null;\n                            }\n\n                            return fixer.insertTextBefore(closeBrace, \"\\n\");\n                        }\n                    });\n                }\n            } else {\n                const consistent = options.consistent;\n                const hasLineBreakBetweenOpenBraceAndFirst = !astUtils$1.isTokenOnSameLine(openBrace, first);\n                const hasLineBreakBetweenCloseBraceAndLast = !astUtils$1.isTokenOnSameLine(last, closeBrace);\n\n                if (\n                    (!consistent && hasLineBreakBetweenOpenBraceAndFirst) ||\n                    (consistent && hasLineBreakBetweenOpenBraceAndFirst && !hasLineBreakBetweenCloseBraceAndLast)\n                ) {\n                    context.report({\n                        message: \"Unexpected line break after this opening brace.\",\n                        node,\n                        loc: openBrace.loc.start,\n                        fix(fixer) {\n                            if (hasCommentsFirstToken) {\n                                return null;\n                            }\n\n                            return fixer.removeRange([\n                                openBrace.range[1],\n                                first.range[0]\n                            ]);\n                        }\n                    });\n                }\n                if (\n                    (!consistent && hasLineBreakBetweenCloseBraceAndLast) ||\n                    (consistent && !hasLineBreakBetweenOpenBraceAndFirst && hasLineBreakBetweenCloseBraceAndLast)\n                ) {\n                    context.report({\n                        message: \"Unexpected line break before this closing brace.\",\n                        node,\n                        loc: closeBrace.loc.start,\n                        fix(fixer) {\n                            if (hasCommentsLastToken) {\n                                return null;\n                            }\n\n                            return fixer.removeRange([\n                                last.range[1],\n                                closeBrace.range[0]\n                            ]);\n                        }\n                    });\n                }\n            }\n        }\n\n        return {\n            ObjectExpression: check,\n            ObjectPattern: check,\n            ImportDeclaration: check,\n            ExportNamedDeclaration: check\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar objectCurlySpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent spacing inside braces\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/object-curly-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                enum: [\"always\", \"never\"]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    arraysInObjects: {\n                        type: \"boolean\"\n                    },\n                    objectsInObjects: {\n                        type: \"boolean\"\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const spaced = context.options[0] === \"always\",\n            sourceCode = context.getSourceCode();\n\n        /**\n         * Determines whether an option is set, relative to the spacing option.\n         * If spaced is \"always\", then check whether option is set to false.\n         * If spaced is \"never\", then check whether option is set to true.\n         * @param {Object} option The option to exclude.\n         * @returns {boolean} Whether or not the property is excluded.\n         */\n        function isOptionSet(option) {\n            return context.options[1] ? context.options[1][option] === !spaced : false;\n        }\n\n        const options = {\n            spaced,\n            arraysInObjectsException: isOptionSet(\"arraysInObjects\"),\n            objectsInObjectsException: isOptionSet(\"objectsInObjects\")\n        };\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Reports that there shouldn't be a space after the first token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportNoBeginningSpace(node, token) {\n            const nextToken = context.getSourceCode().getTokenAfter(token, { includeComments: true });\n\n            context.report({\n                node,\n                loc: { start: token.loc.end, end: nextToken.loc.start },\n                message: \"There should be no space after '{{token}}'.\",\n                data: {\n                    token: token.value\n                },\n                fix(fixer) {\n                    return fixer.removeRange([token.range[1], nextToken.range[0]]);\n                }\n            });\n        }\n\n        /**\n         * Reports that there shouldn't be a space before the last token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportNoEndingSpace(node, token) {\n            const previousToken = context.getSourceCode().getTokenBefore(token, { includeComments: true });\n\n            context.report({\n                node,\n                loc: { start: previousToken.loc.end, end: token.loc.start },\n                message: \"There should be no space before '{{token}}'.\",\n                data: {\n                    token: token.value\n                },\n                fix(fixer) {\n                    return fixer.removeRange([previousToken.range[1], token.range[0]]);\n                }\n            });\n        }\n\n        /**\n         * Reports that there should be a space after the first token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportRequiredBeginningSpace(node, token) {\n            context.report({\n                node,\n                loc: token.loc,\n                message: \"A space is required after '{{token}}'.\",\n                data: {\n                    token: token.value\n                },\n                fix(fixer) {\n                    return fixer.insertTextAfter(token, \" \");\n                }\n            });\n        }\n\n        /**\n         * Reports that there should be a space before the last token\n         * @param {ASTNode} node The node to report in the event of an error.\n         * @param {Token} token The token to use for the report.\n         * @returns {void}\n         */\n        function reportRequiredEndingSpace(node, token) {\n            context.report({\n                node,\n                loc: token.loc,\n                message: \"A space is required before '{{token}}'.\",\n                data: {\n                    token: token.value\n                },\n                fix(fixer) {\n                    return fixer.insertTextBefore(token, \" \");\n                }\n            });\n        }\n\n        /**\n         * Determines if spacing in curly braces is valid.\n         * @param {ASTNode} node The AST node to check.\n         * @param {Token} first The first token to check (should be the opening brace)\n         * @param {Token} second The second token to check (should be first after the opening brace)\n         * @param {Token} penultimate The penultimate token to check (should be last before closing brace)\n         * @param {Token} last The last token to check (should be closing brace)\n         * @returns {void}\n         */\n        function validateBraceSpacing(node, first, second, penultimate, last) {\n            if (astUtils$1.isTokenOnSameLine(first, second)) {\n                const firstSpaced = sourceCode.isSpaceBetweenTokens(first, second);\n\n                if (options.spaced && !firstSpaced) {\n                    reportRequiredBeginningSpace(node, first);\n                }\n                if (!options.spaced && firstSpaced && second.type !== \"Line\") {\n                    reportNoBeginningSpace(node, first);\n                }\n            }\n\n            if (astUtils$1.isTokenOnSameLine(penultimate, last)) {\n                const shouldCheckPenultimate = (\n                    options.arraysInObjectsException && astUtils$1.isClosingBracketToken(penultimate) ||\n                    options.objectsInObjectsException && astUtils$1.isClosingBraceToken(penultimate)\n                );\n                const penultimateType = shouldCheckPenultimate && sourceCode.getNodeByRangeIndex(penultimate.range[0]).type;\n\n                const closingCurlyBraceMustBeSpaced = (\n                    options.arraysInObjectsException && penultimateType === \"ArrayExpression\" ||\n                    options.objectsInObjectsException && (penultimateType === \"ObjectExpression\" || penultimateType === \"ObjectPattern\")\n                ) ? !options.spaced : options.spaced;\n\n                const lastSpaced = sourceCode.isSpaceBetweenTokens(penultimate, last);\n\n                if (closingCurlyBraceMustBeSpaced && !lastSpaced) {\n                    reportRequiredEndingSpace(node, last);\n                }\n                if (!closingCurlyBraceMustBeSpaced && lastSpaced) {\n                    reportNoEndingSpace(node, last);\n                }\n            }\n        }\n\n        /**\n         * Gets '}' token of an object node.\n         *\n         * Because the last token of object patterns might be a type annotation,\n         * this traverses tokens preceded by the last property, then returns the\n         * first '}' token.\n         * @param {ASTNode} node The node to get. This node is an\n         *      ObjectExpression or an ObjectPattern. And this node has one or\n         *      more properties.\n         * @returns {Token} '}' token.\n         */\n        function getClosingBraceOfObject(node) {\n            const lastProperty = node.properties[node.properties.length - 1];\n\n            return sourceCode.getTokenAfter(lastProperty, astUtils$1.isClosingBraceToken);\n        }\n\n        /**\n         * Reports a given object node if spacing in curly braces is invalid.\n         * @param {ASTNode} node An ObjectExpression or ObjectPattern node to check.\n         * @returns {void}\n         */\n        function checkForObject(node) {\n            if (node.properties.length === 0) {\n                return;\n            }\n\n            const first = sourceCode.getFirstToken(node),\n                last = getClosingBraceOfObject(node),\n                second = sourceCode.getTokenAfter(first, { includeComments: true }),\n                penultimate = sourceCode.getTokenBefore(last, { includeComments: true });\n\n            validateBraceSpacing(node, first, second, penultimate, last);\n        }\n\n        /**\n         * Reports a given import node if spacing in curly braces is invalid.\n         * @param {ASTNode} node An ImportDeclaration node to check.\n         * @returns {void}\n         */\n        function checkForImport(node) {\n            if (node.specifiers.length === 0) {\n                return;\n            }\n\n            let firstSpecifier = node.specifiers[0];\n            const lastSpecifier = node.specifiers[node.specifiers.length - 1];\n\n            if (lastSpecifier.type !== \"ImportSpecifier\") {\n                return;\n            }\n            if (firstSpecifier.type !== \"ImportSpecifier\") {\n                firstSpecifier = node.specifiers[1];\n            }\n\n            const first = sourceCode.getTokenBefore(firstSpecifier),\n                last = sourceCode.getTokenAfter(lastSpecifier, astUtils$1.isNotCommaToken),\n                second = sourceCode.getTokenAfter(first, { includeComments: true }),\n                penultimate = sourceCode.getTokenBefore(last, { includeComments: true });\n\n            validateBraceSpacing(node, first, second, penultimate, last);\n        }\n\n        /**\n         * Reports a given export node if spacing in curly braces is invalid.\n         * @param {ASTNode} node An ExportNamedDeclaration node to check.\n         * @returns {void}\n         */\n        function checkForExport(node) {\n            if (node.specifiers.length === 0) {\n                return;\n            }\n\n            const firstSpecifier = node.specifiers[0],\n                lastSpecifier = node.specifiers[node.specifiers.length - 1],\n                first = sourceCode.getTokenBefore(firstSpecifier),\n                last = sourceCode.getTokenAfter(lastSpecifier, astUtils$1.isNotCommaToken),\n                second = sourceCode.getTokenAfter(first, { includeComments: true }),\n                penultimate = sourceCode.getTokenBefore(last, { includeComments: true });\n\n            validateBraceSpacing(node, first, second, penultimate, last);\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n\n            // var {x} = y;\n            ObjectPattern: checkForObject,\n\n            // var y = {x: 'y'}\n            ObjectExpression: checkForObject,\n\n            // import {y} from 'x';\n            ImportDeclaration: checkForImport,\n\n            // export {name} from 'yo';\n            ExportNamedDeclaration: checkForExport\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to enforce placing object properties on separate lines.\n * @author Vitor Balocco\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar objectPropertyNewline = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce placing object properties on separate lines\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/object-property-newline\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allowAllPropertiesOnSameLine: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    allowMultiplePropertiesPerLine: { // Deprecated\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        fixable: \"whitespace\"\n    },\n\n    create(context) {\n        const allowSameLine = context.options[0] && (\n            (context.options[0].allowAllPropertiesOnSameLine || context.options[0].allowMultiplePropertiesPerLine /* Deprecated */)\n        );\n        const errorMessage = allowSameLine\n            ? \"Object properties must go on a new line if they aren't all on the same line.\"\n            : \"Object properties must go on a new line.\";\n\n        const sourceCode = context.getSourceCode();\n\n        return {\n            ObjectExpression(node) {\n                if (allowSameLine) {\n                    if (node.properties.length > 1) {\n                        const firstTokenOfFirstProperty = sourceCode.getFirstToken(node.properties[0]);\n                        const lastTokenOfLastProperty = sourceCode.getLastToken(node.properties[node.properties.length - 1]);\n\n                        if (firstTokenOfFirstProperty.loc.end.line === lastTokenOfLastProperty.loc.start.line) {\n\n                            // All keys and values are on the same line\n                            return;\n                        }\n                    }\n                }\n\n                for (let i = 1; i < node.properties.length; i++) {\n                    const lastTokenOfPreviousProperty = sourceCode.getLastToken(node.properties[i - 1]);\n                    const firstTokenOfCurrentProperty = sourceCode.getFirstToken(node.properties[i]);\n\n                    if (lastTokenOfPreviousProperty.loc.end.line === firstTokenOfCurrentProperty.loc.start.line) {\n                        context.report({\n                            node,\n                            loc: firstTokenOfCurrentProperty.loc.start,\n                            message: errorMessage,\n                            fix(fixer) {\n                                const comma = sourceCode.getTokenBefore(firstTokenOfCurrentProperty);\n                                const rangeAfterComma = [comma.range[1], firstTokenOfCurrentProperty.range[0]];\n\n                                // Don't perform a fix if there are any comments between the comma and the next property.\n                                if (sourceCode.text.slice(rangeAfterComma[0], rangeAfterComma[1]).trim()) {\n                                    return null;\n                                }\n\n                                return fixer.replaceTextRange(rangeAfterComma, \"\\n\");\n                            }\n                        });\n                    }\n                }\n            }\n        };\n    }\n};\n\nconst OPTIONS = {\n    always: \"always\",\n    never: \"never\",\n    methods: \"methods\",\n    properties: \"properties\",\n    consistent: \"consistent\",\n    consistentAsNeeded: \"consistent-as-needed\"\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\nvar objectShorthand = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require or disallow method and property shorthand syntax for object literals\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/object-shorthand\"\n        },\n\n        fixable: \"code\",\n\n        schema: {\n            anyOf: [\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"always\", \"methods\", \"properties\", \"never\", \"consistent\", \"consistent-as-needed\"]\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 1\n                },\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"always\", \"methods\", \"properties\"]\n                        },\n                        {\n                            type: \"object\",\n                            properties: {\n                                avoidQuotes: {\n                                    type: \"boolean\"\n                                }\n                            },\n                            additionalProperties: false\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 2\n                },\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"always\", \"methods\"]\n                        },\n                        {\n                            type: \"object\",\n                            properties: {\n                                ignoreConstructors: {\n                                    type: \"boolean\"\n                                },\n                                avoidQuotes: {\n                                    type: \"boolean\"\n                                },\n                                avoidExplicitReturnArrows: {\n                                    type: \"boolean\"\n                                }\n                            },\n                            additionalProperties: false\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 2\n                }\n            ]\n        }\n    },\n\n    create(context) {\n        const APPLY = context.options[0] || OPTIONS.always;\n        const APPLY_TO_METHODS = APPLY === OPTIONS.methods || APPLY === OPTIONS.always;\n        const APPLY_TO_PROPS = APPLY === OPTIONS.properties || APPLY === OPTIONS.always;\n        const APPLY_NEVER = APPLY === OPTIONS.never;\n        const APPLY_CONSISTENT = APPLY === OPTIONS.consistent;\n        const APPLY_CONSISTENT_AS_NEEDED = APPLY === OPTIONS.consistentAsNeeded;\n\n        const PARAMS = context.options[1] || {};\n        const IGNORE_CONSTRUCTORS = PARAMS.ignoreConstructors;\n        const AVOID_QUOTES = PARAMS.avoidQuotes;\n        const AVOID_EXPLICIT_RETURN_ARROWS = !!PARAMS.avoidExplicitReturnArrows;\n        const sourceCode = context.getSourceCode();\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        const CTOR_PREFIX_REGEX = /[^_$0-9]/u;\n\n        /**\n         * Determines if the first character of the name is a capital letter.\n         * @param {string} name The name of the node to evaluate.\n         * @returns {boolean} True if the first character of the property name is a capital letter, false if not.\n         * @private\n         */\n        function isConstructor(name) {\n            const match = CTOR_PREFIX_REGEX.exec(name);\n\n            // Not a constructor if name has no characters apart from '_', '$' and digits e.g. '_', '$$', '_8'\n            if (!match) {\n                return false;\n            }\n\n            const firstChar = name.charAt(match.index);\n\n            return firstChar === firstChar.toUpperCase();\n        }\n\n        /**\n         * Determines if the property can have a shorthand form.\n         * @param {ASTNode} property Property AST node\n         * @returns {boolean} True if the property can have a shorthand form\n         * @private\n         *\n         */\n        function canHaveShorthand(property) {\n            return (property.kind !== \"set\" && property.kind !== \"get\" && property.type !== \"SpreadElement\" && property.type !== \"SpreadProperty\" && property.type !== \"ExperimentalSpreadProperty\");\n        }\n\n        /**\n         * Checks whether a node is a string literal.\n         * @param   {ASTNode} node Any AST node.\n         * @returns {boolean} `true` if it is a string literal.\n         */\n        function isStringLiteral(node) {\n            return node.type === \"Literal\" && typeof node.value === \"string\";\n        }\n\n        /**\n         * Determines if the property is a shorthand or not.\n         * @param {ASTNode} property Property AST node\n         * @returns {boolean} True if the property is considered shorthand, false if not.\n         * @private\n         *\n         */\n        function isShorthand(property) {\n\n            // property.method is true when `{a(){}}`.\n            return (property.shorthand || property.method);\n        }\n\n        /**\n         * Determines if the property's key and method or value are named equally.\n         * @param {ASTNode} property Property AST node\n         * @returns {boolean} True if the key and value are named equally, false if not.\n         * @private\n         *\n         */\n        function isRedundant(property) {\n            const value = property.value;\n\n            if (value.type === \"FunctionExpression\") {\n                return !value.id; // Only anonymous should be shorthand method.\n            }\n            if (value.type === \"Identifier\") {\n                return astUtils$1.getStaticPropertyName(property) === value.name;\n            }\n\n            return false;\n        }\n\n        /**\n         * Ensures that an object's properties are consistently shorthand, or not shorthand at all.\n         * @param   {ASTNode} node Property AST node\n         * @param   {boolean} checkRedundancy Whether to check longform redundancy\n         * @returns {void}\n         *\n         */\n        function checkConsistency(node, checkRedundancy) {\n\n            // We are excluding getters/setters and spread properties as they are considered neither longform nor shorthand.\n            const properties = node.properties.filter(canHaveShorthand);\n\n            // Do we still have properties left after filtering the getters and setters?\n            if (properties.length > 0) {\n                const shorthandProperties = properties.filter(isShorthand);\n\n                /*\n                 * If we do not have an equal number of longform properties as\n                 * shorthand properties, we are using the annotations inconsistently\n                 */\n                if (shorthandProperties.length !== properties.length) {\n\n                    // We have at least 1 shorthand property\n                    if (shorthandProperties.length > 0) {\n                        context.report({ node, message: \"Unexpected mix of shorthand and non-shorthand properties.\" });\n                    } else if (checkRedundancy) {\n\n                        /*\n                         * If all properties of the object contain a method or value with a name matching it's key,\n                         * all the keys are redundant.\n                         */\n                        const canAlwaysUseShorthand = properties.every(isRedundant);\n\n                        if (canAlwaysUseShorthand) {\n                            context.report({ node, message: \"Expected shorthand for all properties.\" });\n                        }\n                    }\n                }\n            }\n        }\n\n        /**\n         * Fixes a FunctionExpression node by making it into a shorthand property.\n         * @param {SourceCodeFixer} fixer The fixer object\n         * @param {ASTNode} node A `Property` node that has a `FunctionExpression` or `ArrowFunctionExpression` as its value\n         * @returns {Object} A fix for this node\n         */\n        function makeFunctionShorthand(fixer, node) {\n            const firstKeyToken = node.computed\n                ? sourceCode.getFirstToken(node, astUtils$1.isOpeningBracketToken)\n                : sourceCode.getFirstToken(node.key);\n            const lastKeyToken = node.computed\n                ? sourceCode.getFirstTokenBetween(node.key, node.value, astUtils$1.isClosingBracketToken)\n                : sourceCode.getLastToken(node.key);\n            const keyText = sourceCode.text.slice(firstKeyToken.range[0], lastKeyToken.range[1]);\n            let keyPrefix = \"\";\n\n            // key: /* */ () => {}\n            if (sourceCode.commentsExistBetween(lastKeyToken, node.value)) {\n                return null;\n            }\n\n            if (node.value.async) {\n                keyPrefix += \"async \";\n            }\n            if (node.value.generator) {\n                keyPrefix += \"*\";\n            }\n\n            const fixRange = [firstKeyToken.range[0], node.range[1]];\n            const methodPrefix = keyPrefix + keyText;\n\n            if (node.value.type === \"FunctionExpression\") {\n                const functionToken = sourceCode.getTokens(node.value).find(token => token.type === \"Keyword\" && token.value === \"function\");\n                const tokenBeforeParams = node.value.generator ? sourceCode.getTokenAfter(functionToken) : functionToken;\n\n                return fixer.replaceTextRange(\n                    fixRange,\n                    methodPrefix + sourceCode.text.slice(tokenBeforeParams.range[1], node.value.range[1])\n                );\n            }\n\n            const arrowToken = sourceCode.getTokenBefore(node.value.body, astUtils$1.isArrowToken);\n            const fnBody = sourceCode.text.slice(arrowToken.range[1], node.value.range[1]);\n\n            let shouldAddParensAroundParameters = false;\n            let tokenBeforeParams;\n\n            if (node.value.params.length === 0) {\n                tokenBeforeParams = sourceCode.getFirstToken(node.value, astUtils$1.isOpeningParenToken);\n            } else {\n                tokenBeforeParams = sourceCode.getTokenBefore(node.value.params[0]);\n            }\n\n            if (node.value.params.length === 1) {\n                const hasParen = astUtils$1.isOpeningParenToken(tokenBeforeParams);\n                const isTokenOutsideNode = tokenBeforeParams.range[0] < node.range[0];\n\n                shouldAddParensAroundParameters = !hasParen || isTokenOutsideNode;\n            }\n\n            const sliceStart = shouldAddParensAroundParameters\n                ? node.value.params[0].range[0]\n                : tokenBeforeParams.range[0];\n            const sliceEnd = sourceCode.getTokenBefore(arrowToken).range[1];\n\n            const oldParamText = sourceCode.text.slice(sliceStart, sliceEnd);\n            const newParamText = shouldAddParensAroundParameters ? `(${oldParamText})` : oldParamText;\n\n            return fixer.replaceTextRange(\n                fixRange,\n                methodPrefix + newParamText + fnBody\n            );\n\n        }\n\n        /**\n         * Fixes a FunctionExpression node by making it into a longform property.\n         * @param {SourceCodeFixer} fixer The fixer object\n         * @param {ASTNode} node A `Property` node that has a `FunctionExpression` as its value\n         * @returns {Object} A fix for this node\n         */\n        function makeFunctionLongform(fixer, node) {\n            const firstKeyToken = node.computed ? sourceCode.getTokens(node).find(token => token.value === \"[\") : sourceCode.getFirstToken(node.key);\n            const lastKeyToken = node.computed ? sourceCode.getTokensBetween(node.key, node.value).find(token => token.value === \"]\") : sourceCode.getLastToken(node.key);\n            const keyText = sourceCode.text.slice(firstKeyToken.range[0], lastKeyToken.range[1]);\n            let functionHeader = \"function\";\n\n            if (node.value.async) {\n                functionHeader = `async ${functionHeader}`;\n            }\n            if (node.value.generator) {\n                functionHeader = `${functionHeader}*`;\n            }\n\n            return fixer.replaceTextRange([node.range[0], lastKeyToken.range[1]], `${keyText}: ${functionHeader}`);\n        }\n\n        /*\n         * To determine whether a given arrow function has a lexical identifier (`this`, `arguments`, `super`, or `new.target`),\n         * create a stack of functions that define these identifiers (i.e. all functions except arrow functions) as the AST is\n         * traversed. Whenever a new function is encountered, create a new entry on the stack (corresponding to a different lexical\n         * scope of `this`), and whenever a function is exited, pop that entry off the stack. When an arrow function is entered,\n         * keep a reference to it on the current stack entry, and remove that reference when the arrow function is exited.\n         * When a lexical identifier is encountered, mark all the arrow functions on the current stack entry by adding them\n         * to an `arrowsWithLexicalIdentifiers` set. Any arrow function in that set will not be reported by this rule,\n         * because converting it into a method would change the value of one of the lexical identifiers.\n         */\n        const lexicalScopeStack = [];\n        const arrowsWithLexicalIdentifiers = new WeakSet();\n        const argumentsIdentifiers = new WeakSet();\n\n        /**\n         * Enters a function. This creates a new lexical identifier scope, so a new Set of arrow functions is pushed onto the stack.\n         * Also, this marks all `arguments` identifiers so that they can be detected later.\n         * @returns {void}\n         */\n        function enterFunction() {\n            lexicalScopeStack.unshift(new Set());\n            context.getScope().variables.filter(variable => variable.name === \"arguments\").forEach(variable => {\n                variable.references.map(ref => ref.identifier).forEach(identifier => argumentsIdentifiers.add(identifier));\n            });\n        }\n\n        /**\n         * Exits a function. This pops the current set of arrow functions off the lexical scope stack.\n         * @returns {void}\n         */\n        function exitFunction() {\n            lexicalScopeStack.shift();\n        }\n\n        /**\n         * Marks the current function as having a lexical keyword. This implies that all arrow functions\n         * in the current lexical scope contain a reference to this lexical keyword.\n         * @returns {void}\n         */\n        function reportLexicalIdentifier() {\n            lexicalScopeStack[0].forEach(arrowFunction => arrowsWithLexicalIdentifiers.add(arrowFunction));\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            Program: enterFunction,\n            FunctionDeclaration: enterFunction,\n            FunctionExpression: enterFunction,\n            \"Program:exit\": exitFunction,\n            \"FunctionDeclaration:exit\": exitFunction,\n            \"FunctionExpression:exit\": exitFunction,\n\n            ArrowFunctionExpression(node) {\n                lexicalScopeStack[0].add(node);\n            },\n            \"ArrowFunctionExpression:exit\"(node) {\n                lexicalScopeStack[0].delete(node);\n            },\n\n            ThisExpression: reportLexicalIdentifier,\n            Super: reportLexicalIdentifier,\n            MetaProperty(node) {\n                if (node.meta.name === \"new\" && node.property.name === \"target\") {\n                    reportLexicalIdentifier();\n                }\n            },\n            Identifier(node) {\n                if (argumentsIdentifiers.has(node)) {\n                    reportLexicalIdentifier();\n                }\n            },\n\n            ObjectExpression(node) {\n                if (APPLY_CONSISTENT) {\n                    checkConsistency(node, false);\n                } else if (APPLY_CONSISTENT_AS_NEEDED) {\n                    checkConsistency(node, true);\n                }\n            },\n\n            \"Property:exit\"(node) {\n                const isConciseProperty = node.method || node.shorthand;\n\n                // Ignore destructuring assignment\n                if (node.parent.type === \"ObjectPattern\") {\n                    return;\n                }\n\n                // getters and setters are ignored\n                if (node.kind === \"get\" || node.kind === \"set\") {\n                    return;\n                }\n\n                // only computed methods can fail the following checks\n                if (node.computed && node.value.type !== \"FunctionExpression\" && node.value.type !== \"ArrowFunctionExpression\") {\n                    return;\n                }\n\n                //--------------------------------------------------------------\n                // Checks for property/method shorthand.\n                if (isConciseProperty) {\n                    if (node.method && (APPLY_NEVER || AVOID_QUOTES && isStringLiteral(node.key))) {\n                        const message = APPLY_NEVER ? \"Expected longform method syntax.\" : \"Expected longform method syntax for string literal keys.\";\n\n                        // { x() {} } should be written as { x: function() {} }\n                        context.report({\n                            node,\n                            message,\n                            fix: fixer => makeFunctionLongform(fixer, node)\n                        });\n                    } else if (APPLY_NEVER) {\n\n                        // { x } should be written as { x: x }\n                        context.report({\n                            node,\n                            message: \"Expected longform property syntax.\",\n                            fix: fixer => fixer.insertTextAfter(node.key, `: ${node.key.name}`)\n                        });\n                    }\n                } else if (APPLY_TO_METHODS && !node.value.id && (node.value.type === \"FunctionExpression\" || node.value.type === \"ArrowFunctionExpression\")) {\n                    if (IGNORE_CONSTRUCTORS && node.key.type === \"Identifier\" && isConstructor(node.key.name)) {\n                        return;\n                    }\n                    if (AVOID_QUOTES && isStringLiteral(node.key)) {\n                        return;\n                    }\n\n                    // {[x]: function(){}} should be written as {[x]() {}}\n                    if (node.value.type === \"FunctionExpression\" ||\n                        node.value.type === \"ArrowFunctionExpression\" &&\n                        node.value.body.type === \"BlockStatement\" &&\n                        AVOID_EXPLICIT_RETURN_ARROWS &&\n                        !arrowsWithLexicalIdentifiers.has(node.value)\n                    ) {\n                        context.report({\n                            node,\n                            message: \"Expected method shorthand.\",\n                            fix: fixer => makeFunctionShorthand(fixer, node)\n                        });\n                    }\n                } else if (node.value.type === \"Identifier\" && node.key.name === node.value.name && APPLY_TO_PROPS) {\n\n                    // {x: x} should be written as {x}\n                    context.report({\n                        node,\n                        message: \"Expected property shorthand.\",\n                        fix(fixer) {\n                            return fixer.replaceText(node, node.value.name);\n                        }\n                    });\n                } else if (node.value.type === \"Identifier\" && node.key.type === \"Literal\" && node.key.value === node.value.name && APPLY_TO_PROPS) {\n                    if (AVOID_QUOTES) {\n                        return;\n                    }\n\n                    // {\"x\": x} should be written as {x}\n                    context.report({\n                        node,\n                        message: \"Expected property shorthand.\",\n                        fix(fixer) {\n                            return fixer.replaceText(node, node.value.name);\n                        }\n                    });\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview A rule to control the use of single variable declarations.\n * @author Ian Christian Myers\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar oneVar = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce variables to be declared either together or separately in functions\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/one-var\"\n        },\n\n        fixable: \"code\",\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        enum: [\"always\", \"never\", \"consecutive\"]\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            separateRequires: {\n                                type: \"boolean\"\n                            },\n                            var: {\n                                enum: [\"always\", \"never\", \"consecutive\"]\n                            },\n                            let: {\n                                enum: [\"always\", \"never\", \"consecutive\"]\n                            },\n                            const: {\n                                enum: [\"always\", \"never\", \"consecutive\"]\n                            }\n                        },\n                        additionalProperties: false\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            initialized: {\n                                enum: [\"always\", \"never\", \"consecutive\"]\n                            },\n                            uninitialized: {\n                                enum: [\"always\", \"never\", \"consecutive\"]\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ]\n    },\n\n    create(context) {\n        const MODE_ALWAYS = \"always\";\n        const MODE_NEVER = \"never\";\n        const MODE_CONSECUTIVE = \"consecutive\";\n        const mode = context.options[0] || MODE_ALWAYS;\n\n        const options = {};\n\n        if (typeof mode === \"string\") { // simple options configuration with just a string\n            options.var = { uninitialized: mode, initialized: mode };\n            options.let = { uninitialized: mode, initialized: mode };\n            options.const = { uninitialized: mode, initialized: mode };\n        } else if (typeof mode === \"object\") { // options configuration is an object\n            options.separateRequires = !!mode.separateRequires;\n            options.var = { uninitialized: mode.var, initialized: mode.var };\n            options.let = { uninitialized: mode.let, initialized: mode.let };\n            options.const = { uninitialized: mode.const, initialized: mode.const };\n            if (Object.prototype.hasOwnProperty.call(mode, \"uninitialized\")) {\n                options.var.uninitialized = mode.uninitialized;\n                options.let.uninitialized = mode.uninitialized;\n                options.const.uninitialized = mode.uninitialized;\n            }\n            if (Object.prototype.hasOwnProperty.call(mode, \"initialized\")) {\n                options.var.initialized = mode.initialized;\n                options.let.initialized = mode.initialized;\n                options.const.initialized = mode.initialized;\n            }\n        }\n\n        const sourceCode = context.getSourceCode();\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        const functionStack = [];\n        const blockStack = [];\n\n        /**\n         * Increments the blockStack counter.\n         * @returns {void}\n         * @private\n         */\n        function startBlock() {\n            blockStack.push({\n                let: { initialized: false, uninitialized: false },\n                const: { initialized: false, uninitialized: false }\n            });\n        }\n\n        /**\n         * Increments the functionStack counter.\n         * @returns {void}\n         * @private\n         */\n        function startFunction() {\n            functionStack.push({ initialized: false, uninitialized: false });\n            startBlock();\n        }\n\n        /**\n         * Decrements the blockStack counter.\n         * @returns {void}\n         * @private\n         */\n        function endBlock() {\n            blockStack.pop();\n        }\n\n        /**\n         * Decrements the functionStack counter.\n         * @returns {void}\n         * @private\n         */\n        function endFunction() {\n            functionStack.pop();\n            endBlock();\n        }\n\n        /**\n         * Check if a variable declaration is a require.\n         * @param {ASTNode} decl variable declaration Node\n         * @returns {bool} if decl is a require, return true; else return false.\n         * @private\n         */\n        function isRequire(decl) {\n            return decl.init && decl.init.type === \"CallExpression\" && decl.init.callee.name === \"require\";\n        }\n\n        /**\n         * Records whether initialized/uninitialized/required variables are defined in current scope.\n         * @param {string} statementType node.kind, one of: \"var\", \"let\", or \"const\"\n         * @param {ASTNode[]} declarations List of declarations\n         * @param {Object} currentScope The scope being investigated\n         * @returns {void}\n         * @private\n         */\n        function recordTypes(statementType, declarations, currentScope) {\n            for (let i = 0; i < declarations.length; i++) {\n                if (declarations[i].init === null) {\n                    if (options[statementType] && options[statementType].uninitialized === MODE_ALWAYS) {\n                        currentScope.uninitialized = true;\n                    }\n                } else {\n                    if (options[statementType] && options[statementType].initialized === MODE_ALWAYS) {\n                        if (options.separateRequires && isRequire(declarations[i])) {\n                            currentScope.required = true;\n                        } else {\n                            currentScope.initialized = true;\n                        }\n                    }\n                }\n            }\n        }\n\n        /**\n         * Determines the current scope (function or block)\n         * @param  {string} statementType node.kind, one of: \"var\", \"let\", or \"const\"\n         * @returns {Object} The scope associated with statementType\n         */\n        function getCurrentScope(statementType) {\n            let currentScope;\n\n            if (statementType === \"var\") {\n                currentScope = functionStack[functionStack.length - 1];\n            } else if (statementType === \"let\") {\n                currentScope = blockStack[blockStack.length - 1].let;\n            } else if (statementType === \"const\") {\n                currentScope = blockStack[blockStack.length - 1].const;\n            }\n            return currentScope;\n        }\n\n        /**\n         * Counts the number of initialized and uninitialized declarations in a list of declarations\n         * @param {ASTNode[]} declarations List of declarations\n         * @returns {Object} Counts of 'uninitialized' and 'initialized' declarations\n         * @private\n         */\n        function countDeclarations(declarations) {\n            const counts = { uninitialized: 0, initialized: 0 };\n\n            for (let i = 0; i < declarations.length; i++) {\n                if (declarations[i].init === null) {\n                    counts.uninitialized++;\n                } else {\n                    counts.initialized++;\n                }\n            }\n            return counts;\n        }\n\n        /**\n         * Determines if there is more than one var statement in the current scope.\n         * @param {string} statementType node.kind, one of: \"var\", \"let\", or \"const\"\n         * @param {ASTNode[]} declarations List of declarations\n         * @returns {boolean} Returns true if it is the first var declaration, false if not.\n         * @private\n         */\n        function hasOnlyOneStatement(statementType, declarations) {\n\n            const declarationCounts = countDeclarations(declarations);\n            const currentOptions = options[statementType] || {};\n            const currentScope = getCurrentScope(statementType);\n            const hasRequires = declarations.some(isRequire);\n\n            if (currentOptions.uninitialized === MODE_ALWAYS && currentOptions.initialized === MODE_ALWAYS) {\n                if (currentScope.uninitialized || currentScope.initialized) {\n                    if (!hasRequires) {\n                        return false;\n                    }\n                }\n            }\n\n            if (declarationCounts.uninitialized > 0) {\n                if (currentOptions.uninitialized === MODE_ALWAYS && currentScope.uninitialized) {\n                    return false;\n                }\n            }\n            if (declarationCounts.initialized > 0) {\n                if (currentOptions.initialized === MODE_ALWAYS && currentScope.initialized) {\n                    if (!hasRequires) {\n                        return false;\n                    }\n                }\n            }\n            if (currentScope.required && hasRequires) {\n                return false;\n            }\n            recordTypes(statementType, declarations, currentScope);\n            return true;\n        }\n\n        /**\n         * Fixer to join VariableDeclaration's into a single declaration\n         * @param   {VariableDeclarator[]} declarations The `VariableDeclaration` to join\n         * @returns {Function}                         The fixer function\n         */\n        function joinDeclarations(declarations) {\n            const declaration = declarations[0];\n            const body = Array.isArray(declaration.parent.parent.body) ? declaration.parent.parent.body : [];\n            const currentIndex = body.findIndex(node => node.range[0] === declaration.parent.range[0]);\n            const previousNode = body[currentIndex - 1];\n\n            return fixer => {\n                const type = sourceCode.getTokenBefore(declaration);\n                const prevSemi = sourceCode.getTokenBefore(type);\n                const res = [];\n\n                if (previousNode && previousNode.kind === sourceCode.getText(type)) {\n                    if (prevSemi.value === \";\") {\n                        res.push(fixer.replaceText(prevSemi, \",\"));\n                    } else {\n                        res.push(fixer.insertTextAfter(prevSemi, \",\"));\n                    }\n                    res.push(fixer.replaceText(type, \"\"));\n                }\n\n                return res;\n            };\n        }\n\n        /**\n         * Fixer to split a VariableDeclaration into individual declarations\n         * @param   {VariableDeclaration}   declaration The `VariableDeclaration` to split\n         * @returns {Function}                          The fixer function\n         */\n        function splitDeclarations(declaration) {\n            return fixer => declaration.declarations.map(declarator => {\n                const tokenAfterDeclarator = sourceCode.getTokenAfter(declarator);\n\n                if (tokenAfterDeclarator === null) {\n                    return null;\n                }\n\n                const afterComma = sourceCode.getTokenAfter(tokenAfterDeclarator, { includeComments: true });\n\n                if (tokenAfterDeclarator.value !== \",\") {\n                    return null;\n                }\n\n                /*\n                 * `var x,y`\n                 * tokenAfterDeclarator ^^ afterComma\n                 */\n                if (afterComma.range[0] === tokenAfterDeclarator.range[1]) {\n                    return fixer.replaceText(tokenAfterDeclarator, `; ${declaration.kind} `);\n                }\n\n                /*\n                 * `var x,\n                 * tokenAfterDeclarator ^\n                 *      y`\n                 *      ^ afterComma\n                 */\n                if (\n                    afterComma.loc.start.line > tokenAfterDeclarator.loc.end.line ||\n                    afterComma.type === \"Line\" ||\n                    afterComma.type === \"Block\"\n                ) {\n                    let lastComment = afterComma;\n\n                    while (lastComment.type === \"Line\" || lastComment.type === \"Block\") {\n                        lastComment = sourceCode.getTokenAfter(lastComment, { includeComments: true });\n                    }\n\n                    return fixer.replaceTextRange(\n                        [tokenAfterDeclarator.range[0], lastComment.range[0]],\n                        `;${sourceCode.text.slice(tokenAfterDeclarator.range[1], lastComment.range[0])}${declaration.kind} `\n                    );\n                }\n\n                return fixer.replaceText(tokenAfterDeclarator, `; ${declaration.kind}`);\n            }).filter(x => x);\n        }\n\n        /**\n         * Checks a given VariableDeclaration node for errors.\n         * @param {ASTNode} node The VariableDeclaration node to check\n         * @returns {void}\n         * @private\n         */\n        function checkVariableDeclaration(node) {\n            const parent = node.parent;\n            const type = node.kind;\n\n            if (!options[type]) {\n                return;\n            }\n\n            const declarations = node.declarations;\n            const declarationCounts = countDeclarations(declarations);\n            const mixedRequires = declarations.some(isRequire) && !declarations.every(isRequire);\n\n            if (options[type].initialized === MODE_ALWAYS) {\n                if (options.separateRequires && mixedRequires) {\n                    context.report({\n                        node,\n                        message: \"Split requires to be separated into a single block.\"\n                    });\n                }\n            }\n\n            // consecutive\n            const nodeIndex = (parent.body && parent.body.length > 0 && parent.body.indexOf(node)) || 0;\n\n            if (nodeIndex > 0) {\n                const previousNode = parent.body[nodeIndex - 1];\n                const isPreviousNodeDeclaration = previousNode.type === \"VariableDeclaration\";\n                const declarationsWithPrevious = declarations.concat(previousNode.declarations || []);\n\n                if (\n                    isPreviousNodeDeclaration &&\n                    previousNode.kind === type &&\n                    !(declarationsWithPrevious.some(isRequire) && !declarationsWithPrevious.every(isRequire))\n                ) {\n                    const previousDeclCounts = countDeclarations(previousNode.declarations);\n\n                    if (options[type].initialized === MODE_CONSECUTIVE && options[type].uninitialized === MODE_CONSECUTIVE) {\n                        context.report({\n                            node,\n                            message: \"Combine this with the previous '{{type}}' statement.\",\n                            data: {\n                                type\n                            },\n                            fix: joinDeclarations(declarations)\n                        });\n                    } else if (options[type].initialized === MODE_CONSECUTIVE && declarationCounts.initialized > 0 && previousDeclCounts.initialized > 0) {\n                        context.report({\n                            node,\n                            message: \"Combine this with the previous '{{type}}' statement with initialized variables.\",\n                            data: {\n                                type\n                            },\n                            fix: joinDeclarations(declarations)\n                        });\n                    } else if (options[type].uninitialized === MODE_CONSECUTIVE &&\n                            declarationCounts.uninitialized > 0 &&\n                            previousDeclCounts.uninitialized > 0) {\n                        context.report({\n                            node,\n                            message: \"Combine this with the previous '{{type}}' statement with uninitialized variables.\",\n                            data: {\n                                type\n                            },\n                            fix: joinDeclarations(declarations)\n                        });\n                    }\n                }\n            }\n\n            // always\n            if (!hasOnlyOneStatement(type, declarations)) {\n                if (options[type].initialized === MODE_ALWAYS && options[type].uninitialized === MODE_ALWAYS) {\n                    context.report({\n                        node,\n                        message: \"Combine this with the previous '{{type}}' statement.\",\n                        data: {\n                            type\n                        },\n                        fix: joinDeclarations(declarations)\n                    });\n                } else {\n                    if (options[type].initialized === MODE_ALWAYS && declarationCounts.initialized > 0) {\n                        context.report({\n                            node,\n                            message: \"Combine this with the previous '{{type}}' statement with initialized variables.\",\n                            data: {\n                                type\n                            },\n                            fix: joinDeclarations(declarations)\n                        });\n                    }\n                    if (options[type].uninitialized === MODE_ALWAYS && declarationCounts.uninitialized > 0) {\n                        if (node.parent.left === node && (node.parent.type === \"ForInStatement\" || node.parent.type === \"ForOfStatement\")) {\n                            return;\n                        }\n                        context.report({\n                            node,\n                            message: \"Combine this with the previous '{{type}}' statement with uninitialized variables.\",\n                            data: {\n                                type\n                            },\n                            fix: joinDeclarations(declarations)\n                        });\n                    }\n                }\n            }\n\n            // never\n            if (parent.type !== \"ForStatement\" || parent.init !== node) {\n                const totalDeclarations = declarationCounts.uninitialized + declarationCounts.initialized;\n\n                if (totalDeclarations > 1) {\n                    if (options[type].initialized === MODE_NEVER && options[type].uninitialized === MODE_NEVER) {\n\n                        // both initialized and uninitialized\n                        context.report({\n                            node,\n                            message: \"Split '{{type}}' declarations into multiple statements.\",\n                            data: {\n                                type\n                            },\n                            fix: splitDeclarations(node)\n                        });\n                    } else if (options[type].initialized === MODE_NEVER && declarationCounts.initialized > 0) {\n\n                        // initialized\n                        context.report({\n                            node,\n                            message: \"Split initialized '{{type}}' declarations into multiple statements.\",\n                            data: {\n                                type\n                            },\n                            fix: splitDeclarations(node)\n                        });\n                    } else if (options[type].uninitialized === MODE_NEVER && declarationCounts.uninitialized > 0) {\n\n                        // uninitialized\n                        context.report({\n                            node,\n                            message: \"Split uninitialized '{{type}}' declarations into multiple statements.\",\n                            data: {\n                                type\n                            },\n                            fix: splitDeclarations(node)\n                        });\n                    }\n                }\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n            Program: startFunction,\n            FunctionDeclaration: startFunction,\n            FunctionExpression: startFunction,\n            ArrowFunctionExpression: startFunction,\n            BlockStatement: startBlock,\n            ForStatement: startBlock,\n            ForInStatement: startBlock,\n            ForOfStatement: startBlock,\n            SwitchStatement: startBlock,\n            VariableDeclaration: checkVariableDeclaration,\n            \"ForStatement:exit\": endBlock,\n            \"ForOfStatement:exit\": endBlock,\n            \"ForInStatement:exit\": endBlock,\n            \"SwitchStatement:exit\": endBlock,\n            \"BlockStatement:exit\": endBlock,\n            \"Program:exit\": endFunction,\n            \"FunctionDeclaration:exit\": endFunction,\n            \"FunctionExpression:exit\": endFunction,\n            \"ArrowFunctionExpression:exit\": endFunction\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to check multiple var declarations per line\n * @author Alberto Rodríguez\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar oneVarDeclarationPerLine = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require or disallow newlines around variable declarations\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/one-var-declaration-per-line\"\n        },\n\n        schema: [\n            {\n                enum: [\"always\", \"initializations\"]\n            }\n        ],\n\n        fixable: \"whitespace\"\n    },\n\n    create(context) {\n\n        const ERROR_MESSAGE = \"Expected variable declaration to be on a new line.\";\n        const always = context.options[0] === \"always\";\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n\n        /**\n         * Determine if provided keyword is a variant of for specifiers\n         * @private\n         * @param {string} keyword keyword to test\n         * @returns {boolean} True if `keyword` is a variant of for specifier\n         */\n        function isForTypeSpecifier(keyword) {\n            return keyword === \"ForStatement\" || keyword === \"ForInStatement\" || keyword === \"ForOfStatement\";\n        }\n\n        /**\n         * Checks newlines around variable declarations.\n         * @private\n         * @param {ASTNode} node `VariableDeclaration` node to test\n         * @returns {void}\n         */\n        function checkForNewLine(node) {\n            if (isForTypeSpecifier(node.parent.type)) {\n                return;\n            }\n\n            const declarations = node.declarations;\n            let prev;\n\n            declarations.forEach(current => {\n                if (prev && prev.loc.end.line === current.loc.start.line) {\n                    if (always || prev.init || current.init) {\n                        context.report({\n                            node,\n                            message: ERROR_MESSAGE,\n                            loc: current.loc.start,\n                            fix: fixer => fixer.insertTextBefore(current, \"\\n\")\n                        });\n                    }\n                }\n                prev = current;\n            });\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            VariableDeclaration: checkForNewLine\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether an operator is commutative and has an operator assignment\n * shorthand form.\n * @param   {string}  operator Operator to check.\n * @returns {boolean}          True if the operator is commutative and has a\n *     shorthand form.\n */\nfunction isCommutativeOperatorWithShorthand(operator) {\n    return [\"*\", \"&\", \"^\", \"|\"].indexOf(operator) >= 0;\n}\n\n/**\n * Checks whether an operator is not commuatative and has an operator assignment\n * shorthand form.\n * @param   {string}  operator Operator to check.\n * @returns {boolean}          True if the operator is not commuatative and has\n *     a shorthand form.\n */\nfunction isNonCommutativeOperatorWithShorthand(operator) {\n    return [\"+\", \"-\", \"/\", \"%\", \"<<\", \">>\", \">>>\", \"**\"].indexOf(operator) >= 0;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether two expressions reference the same value. For example:\n *     a = a\n *     a.b = a.b\n *     a[0] = a[0]\n *     a['b'] = a['b']\n * @param   {ASTNode} a Left side of the comparison.\n * @param   {ASTNode} b Right side of the comparison.\n * @returns {boolean}   True if both sides match and reference the same value.\n */\nfunction same(a, b) {\n    if (a.type !== b.type) {\n        return false;\n    }\n\n    switch (a.type) {\n        case \"Identifier\":\n            return a.name === b.name;\n\n        case \"Literal\":\n            return a.value === b.value;\n\n        case \"MemberExpression\":\n\n            /*\n             * x[0] = x[0]\n             * x[y] = x[y]\n             * x.y = x.y\n             */\n            return same(a.object, b.object) && same(a.property, b.property);\n\n        case \"ThisExpression\":\n            return true;\n\n        default:\n            return false;\n    }\n}\n\n/**\n * Determines if the left side of a node can be safely fixed (i.e. if it activates the same getters/setters and)\n * toString calls regardless of whether assignment shorthand is used)\n * @param {ASTNode} node The node on the left side of the expression\n * @returns {boolean} `true` if the node can be fixed\n */\nfunction canBeFixed(node) {\n    return (\n        node.type === \"Identifier\" ||\n        (\n            node.type === \"MemberExpression\" &&\n            (node.object.type === \"Identifier\" || node.object.type === \"ThisExpression\") &&\n            (!node.computed || node.property.type === \"Literal\")\n        )\n    );\n}\n\nvar operatorAssignment = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require or disallow assignment operator shorthand where possible\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/operator-assignment\"\n        },\n\n        schema: [\n            {\n                enum: [\"always\", \"never\"]\n            }\n        ],\n\n        fixable: \"code\",\n        messages: {\n            replaced: \"Assignment can be replaced with operator assignment.\",\n            unexpected: \"Unexpected operator assignment shorthand.\"\n        }\n    },\n\n    create(context) {\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Returns the operator token of an AssignmentExpression or BinaryExpression\n         * @param {ASTNode} node An AssignmentExpression or BinaryExpression node\n         * @returns {Token} The operator token in the node\n         */\n        function getOperatorToken(node) {\n            return sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);\n        }\n\n        /**\n         * Ensures that an assignment uses the shorthand form where possible.\n         * @param   {ASTNode} node An AssignmentExpression node.\n         * @returns {void}\n         */\n        function verify(node) {\n            if (node.operator !== \"=\" || node.right.type !== \"BinaryExpression\") {\n                return;\n            }\n\n            const left = node.left;\n            const expr = node.right;\n            const operator = expr.operator;\n\n            if (isCommutativeOperatorWithShorthand(operator) || isNonCommutativeOperatorWithShorthand(operator)) {\n                if (same(left, expr.left)) {\n                    context.report({\n                        node,\n                        messageId: \"replaced\",\n                        fix(fixer) {\n                            if (canBeFixed(left)) {\n                                const equalsToken = getOperatorToken(node);\n                                const operatorToken = getOperatorToken(expr);\n                                const leftText = sourceCode.getText().slice(node.range[0], equalsToken.range[0]);\n                                const rightText = sourceCode.getText().slice(operatorToken.range[1], node.right.range[1]);\n\n                                // Check for comments that would be removed.\n                                if (sourceCode.commentsExistBetween(equalsToken, operatorToken)) {\n                                    return null;\n                                }\n\n                                return fixer.replaceText(node, `${leftText}${expr.operator}=${rightText}`);\n                            }\n                            return null;\n                        }\n                    });\n                } else if (same(left, expr.right) && isCommutativeOperatorWithShorthand(operator)) {\n\n                    /*\n                     * This case can't be fixed safely.\n                     * If `a` and `b` both have custom valueOf() behavior, then fixing `a = b * a` to `a *= b` would\n                     * change the execution order of the valueOf() functions.\n                     */\n                    context.report({\n                        node,\n                        messageId: \"replaced\"\n                    });\n                }\n            }\n        }\n\n        /**\n         * Warns if an assignment expression uses operator assignment shorthand.\n         * @param   {ASTNode} node An AssignmentExpression node.\n         * @returns {void}\n         */\n        function prohibit(node) {\n            if (node.operator !== \"=\") {\n                context.report({\n                    node,\n                    messageId: \"unexpected\",\n                    fix(fixer) {\n                        if (canBeFixed(node.left)) {\n                            const firstToken = sourceCode.getFirstToken(node);\n                            const operatorToken = getOperatorToken(node);\n                            const leftText = sourceCode.getText().slice(node.range[0], operatorToken.range[0]);\n                            const newOperator = node.operator.slice(0, -1);\n                            let rightText;\n\n                            // Check for comments that would be duplicated.\n                            if (sourceCode.commentsExistBetween(firstToken, operatorToken)) {\n                                return null;\n                            }\n\n                            // If this change would modify precedence (e.g. `foo *= bar + 1` => `foo = foo * (bar + 1)`), parenthesize the right side.\n                            if (\n                                astUtils$1.getPrecedence(node.right) <= astUtils$1.getPrecedence({ type: \"BinaryExpression\", operator: newOperator }) &&\n                                !astUtils$1.isParenthesised(sourceCode, node.right)\n                            ) {\n                                rightText = `${sourceCode.text.slice(operatorToken.range[1], node.right.range[0])}(${sourceCode.getText(node.right)})`;\n                            } else {\n                                const firstRightToken = sourceCode.getFirstToken(node.right);\n                                let rightTextPrefix = \"\";\n\n                                if (\n                                    operatorToken.range[1] === firstRightToken.range[0] &&\n                                    !astUtils$1.canTokensBeAdjacent(newOperator, firstRightToken)\n                                ) {\n                                    rightTextPrefix = \" \"; // foo+=+bar -> foo= foo+ +bar\n                                }\n\n                                rightText = `${rightTextPrefix}${sourceCode.text.slice(operatorToken.range[1], node.range[1])}`;\n                            }\n\n                            return fixer.replaceText(node, `${leftText}= ${leftText}${newOperator}${rightText}`);\n                        }\n                        return null;\n                    }\n                });\n            }\n        }\n\n        return {\n            AssignmentExpression: context.options[0] !== \"never\" ? verify : prohibit\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar operatorLinebreak = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent linebreak style for operators\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/operator-linebreak\"\n        },\n\n        schema: [\n            {\n                enum: [\"after\", \"before\", \"none\", null]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    overrides: {\n                        type: \"object\",\n                        properties: {\n                            anyOf: {\n                                type: \"string\",\n                                enum: [\"after\", \"before\", \"none\", \"ignore\"]\n                            }\n                        }\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        fixable: \"code\"\n    },\n\n    create(context) {\n\n        const usedDefaultGlobal = !context.options[0];\n        const globalStyle = context.options[0] || \"after\";\n        const options = context.options[1] || {};\n        const styleOverrides = options.overrides ? Object.assign({}, options.overrides) : {};\n\n        if (usedDefaultGlobal && !styleOverrides[\"?\"]) {\n            styleOverrides[\"?\"] = \"before\";\n        }\n\n        if (usedDefaultGlobal && !styleOverrides[\":\"]) {\n            styleOverrides[\":\"] = \"before\";\n        }\n\n        const sourceCode = context.getSourceCode();\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Gets a fixer function to fix rule issues\n         * @param {Token} operatorToken The operator token of an expression\n         * @param {string} desiredStyle The style for the rule. One of 'before', 'after', 'none'\n         * @returns {Function} A fixer function\n         */\n        function getFixer(operatorToken, desiredStyle) {\n            return fixer => {\n                const tokenBefore = sourceCode.getTokenBefore(operatorToken);\n                const tokenAfter = sourceCode.getTokenAfter(operatorToken);\n                const textBefore = sourceCode.text.slice(tokenBefore.range[1], operatorToken.range[0]);\n                const textAfter = sourceCode.text.slice(operatorToken.range[1], tokenAfter.range[0]);\n                const hasLinebreakBefore = !astUtils$1.isTokenOnSameLine(tokenBefore, operatorToken);\n                const hasLinebreakAfter = !astUtils$1.isTokenOnSameLine(operatorToken, tokenAfter);\n                let newTextBefore, newTextAfter;\n\n                if (hasLinebreakBefore !== hasLinebreakAfter && desiredStyle !== \"none\") {\n\n                    // If there is a comment before and after the operator, don't do a fix.\n                    if (sourceCode.getTokenBefore(operatorToken, { includeComments: true }) !== tokenBefore &&\n                        sourceCode.getTokenAfter(operatorToken, { includeComments: true }) !== tokenAfter) {\n\n                        return null;\n                    }\n\n                    /*\n                     * If there is only one linebreak and it's on the wrong side of the operator, swap the text before and after the operator.\n                     * foo &&\n                     *           bar\n                     * would get fixed to\n                     * foo\n                     *        && bar\n                     */\n                    newTextBefore = textAfter;\n                    newTextAfter = textBefore;\n                } else {\n                    const LINEBREAK_REGEX = astUtils$1.createGlobalLinebreakMatcher();\n\n                    // Otherwise, if no linebreak is desired and no comments interfere, replace the linebreaks with empty strings.\n                    newTextBefore = desiredStyle === \"before\" || textBefore.trim() ? textBefore : textBefore.replace(LINEBREAK_REGEX, \"\");\n                    newTextAfter = desiredStyle === \"after\" || textAfter.trim() ? textAfter : textAfter.replace(LINEBREAK_REGEX, \"\");\n\n                    // If there was no change (due to interfering comments), don't output a fix.\n                    if (newTextBefore === textBefore && newTextAfter === textAfter) {\n                        return null;\n                    }\n                }\n\n                if (newTextAfter === \"\" && tokenAfter.type === \"Punctuator\" && \"+-\".includes(operatorToken.value) && tokenAfter.value === operatorToken.value) {\n\n                    // To avoid accidentally creating a ++ or -- operator, insert a space if the operator is a +/- and the following token is a unary +/-.\n                    newTextAfter += \" \";\n                }\n\n                return fixer.replaceTextRange([tokenBefore.range[1], tokenAfter.range[0]], newTextBefore + operatorToken.value + newTextAfter);\n            };\n        }\n\n        /**\n         * Checks the operator placement\n         * @param {ASTNode} node The node to check\n         * @param {ASTNode} leftSide The node that comes before the operator in `node`\n         * @private\n         * @returns {void}\n         */\n        function validateNode(node, leftSide) {\n\n            /*\n             * When the left part of a binary expression is a single expression wrapped in\n             * parentheses (ex: `(a) + b`), leftToken will be the last token of the expression\n             * and operatorToken will be the closing parenthesis.\n             * The leftToken should be the last closing parenthesis, and the operatorToken\n             * should be the token right after that.\n             */\n            const operatorToken = sourceCode.getTokenAfter(leftSide, astUtils$1.isNotClosingParenToken);\n            const leftToken = sourceCode.getTokenBefore(operatorToken);\n            const rightToken = sourceCode.getTokenAfter(operatorToken);\n            const operator = operatorToken.value;\n            const operatorStyleOverride = styleOverrides[operator];\n            const style = operatorStyleOverride || globalStyle;\n            const fix = getFixer(operatorToken, style);\n\n            // if single line\n            if (astUtils$1.isTokenOnSameLine(leftToken, operatorToken) &&\n                    astUtils$1.isTokenOnSameLine(operatorToken, rightToken)) ; else if (operatorStyleOverride !== \"ignore\" && !astUtils$1.isTokenOnSameLine(leftToken, operatorToken) &&\n                    !astUtils$1.isTokenOnSameLine(operatorToken, rightToken)) {\n\n                // lone operator\n                context.report({\n                    node,\n                    loc: {\n                        line: operatorToken.loc.end.line,\n                        column: operatorToken.loc.end.column\n                    },\n                    message: \"Bad line breaking before and after '{{operator}}'.\",\n                    data: {\n                        operator\n                    },\n                    fix\n                });\n\n            } else if (style === \"before\" && astUtils$1.isTokenOnSameLine(leftToken, operatorToken)) {\n\n                context.report({\n                    node,\n                    loc: {\n                        line: operatorToken.loc.end.line,\n                        column: operatorToken.loc.end.column\n                    },\n                    message: \"'{{operator}}' should be placed at the beginning of the line.\",\n                    data: {\n                        operator\n                    },\n                    fix\n                });\n\n            } else if (style === \"after\" && astUtils$1.isTokenOnSameLine(operatorToken, rightToken)) {\n\n                context.report({\n                    node,\n                    loc: {\n                        line: operatorToken.loc.end.line,\n                        column: operatorToken.loc.end.column\n                    },\n                    message: \"'{{operator}}' should be placed at the end of the line.\",\n                    data: {\n                        operator\n                    },\n                    fix\n                });\n\n            } else if (style === \"none\") {\n\n                context.report({\n                    node,\n                    loc: {\n                        line: operatorToken.loc.end.line,\n                        column: operatorToken.loc.end.column\n                    },\n                    message: \"There should be no line break before or after '{{operator}}'.\",\n                    data: {\n                        operator\n                    },\n                    fix\n                });\n\n            }\n        }\n\n        /**\n         * Validates a binary expression using `validateNode`\n         * @param {BinaryExpression|LogicalExpression|AssignmentExpression} node node to be validated\n         * @returns {void}\n         */\n        function validateBinaryExpression(node) {\n            validateNode(node, node.left);\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            BinaryExpression: validateBinaryExpression,\n            LogicalExpression: validateBinaryExpression,\n            AssignmentExpression: validateBinaryExpression,\n            VariableDeclarator(node) {\n                if (node.init) {\n                    validateNode(node, node.id);\n                }\n            },\n            ConditionalExpression(node) {\n                validateNode(node, node.test);\n                validateNode(node, node.consequent);\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar paddedBlocks = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require or disallow padding within blocks\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/padded-blocks\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        enum: [\"always\", \"never\"]\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            blocks: {\n                                enum: [\"always\", \"never\"]\n                            },\n                            switches: {\n                                enum: [\"always\", \"never\"]\n                            },\n                            classes: {\n                                enum: [\"always\", \"never\"]\n                            }\n                        },\n                        additionalProperties: false,\n                        minProperties: 1\n                    }\n                ]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    allowSingleLineBlocks: {\n                        type: \"boolean\"\n                    }\n                }\n            }\n        ]\n    },\n\n    create(context) {\n        const options = {};\n        const typeOptions = context.options[0] || \"always\";\n        const exceptOptions = context.options[1] || {};\n\n        if (typeof typeOptions === \"string\") {\n            const shouldHavePadding = typeOptions === \"always\";\n\n            options.blocks = shouldHavePadding;\n            options.switches = shouldHavePadding;\n            options.classes = shouldHavePadding;\n        } else {\n            if (Object.prototype.hasOwnProperty.call(typeOptions, \"blocks\")) {\n                options.blocks = typeOptions.blocks === \"always\";\n            }\n            if (Object.prototype.hasOwnProperty.call(typeOptions, \"switches\")) {\n                options.switches = typeOptions.switches === \"always\";\n            }\n            if (Object.prototype.hasOwnProperty.call(typeOptions, \"classes\")) {\n                options.classes = typeOptions.classes === \"always\";\n            }\n        }\n\n        if (Object.prototype.hasOwnProperty.call(exceptOptions, \"allowSingleLineBlocks\")) {\n            options.allowSingleLineBlocks = exceptOptions.allowSingleLineBlocks === true;\n        }\n\n        const ALWAYS_MESSAGE = \"Block must be padded by blank lines.\",\n            NEVER_MESSAGE = \"Block must not be padded by blank lines.\";\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Gets the open brace token from a given node.\n         * @param {ASTNode} node A BlockStatement or SwitchStatement node from which to get the open brace.\n         * @returns {Token} The token of the open brace.\n         */\n        function getOpenBrace(node) {\n            if (node.type === \"SwitchStatement\") {\n                return sourceCode.getTokenBefore(node.cases[0]);\n            }\n            return sourceCode.getFirstToken(node);\n        }\n\n        /**\n         * Checks if the given parameter is a comment node\n         * @param {ASTNode|Token} node An AST node or token\n         * @returns {boolean} True if node is a comment\n         */\n        function isComment(node) {\n            return node.type === \"Line\" || node.type === \"Block\";\n        }\n\n        /**\n         * Checks if there is padding between two tokens\n         * @param {Token} first The first token\n         * @param {Token} second The second token\n         * @returns {boolean} True if there is at least a line between the tokens\n         */\n        function isPaddingBetweenTokens(first, second) {\n            return second.loc.start.line - first.loc.end.line >= 2;\n        }\n\n\n        /**\n         * Checks if the given token has a blank line after it.\n         * @param {Token} token The token to check.\n         * @returns {boolean} Whether or not the token is followed by a blank line.\n         */\n        function getFirstBlockToken(token) {\n            let prev,\n                first = token;\n\n            do {\n                prev = first;\n                first = sourceCode.getTokenAfter(first, { includeComments: true });\n            } while (isComment(first) && first.loc.start.line === prev.loc.end.line);\n\n            return first;\n        }\n\n        /**\n         * Checks if the given token is preceeded by a blank line.\n         * @param {Token} token The token to check\n         * @returns {boolean} Whether or not the token is preceeded by a blank line\n         */\n        function getLastBlockToken(token) {\n            let last = token,\n                next;\n\n            do {\n                next = last;\n                last = sourceCode.getTokenBefore(last, { includeComments: true });\n            } while (isComment(last) && last.loc.end.line === next.loc.start.line);\n\n            return last;\n        }\n\n        /**\n         * Checks if a node should be padded, according to the rule config.\n         * @param {ASTNode} node The AST node to check.\n         * @returns {boolean} True if the node should be padded, false otherwise.\n         */\n        function requirePaddingFor(node) {\n            switch (node.type) {\n                case \"BlockStatement\":\n                    return options.blocks;\n                case \"SwitchStatement\":\n                    return options.switches;\n                case \"ClassBody\":\n                    return options.classes;\n\n                /* istanbul ignore next */\n                default:\n                    throw new Error(\"unreachable\");\n            }\n        }\n\n        /**\n         * Checks the given BlockStatement node to be padded if the block is not empty.\n         * @param {ASTNode} node The AST node of a BlockStatement.\n         * @returns {void} undefined.\n         */\n        function checkPadding(node) {\n            const openBrace = getOpenBrace(node),\n                firstBlockToken = getFirstBlockToken(openBrace),\n                tokenBeforeFirst = sourceCode.getTokenBefore(firstBlockToken, { includeComments: true }),\n                closeBrace = sourceCode.getLastToken(node),\n                lastBlockToken = getLastBlockToken(closeBrace),\n                tokenAfterLast = sourceCode.getTokenAfter(lastBlockToken, { includeComments: true }),\n                blockHasTopPadding = isPaddingBetweenTokens(tokenBeforeFirst, firstBlockToken),\n                blockHasBottomPadding = isPaddingBetweenTokens(lastBlockToken, tokenAfterLast);\n\n            if (options.allowSingleLineBlocks && astUtils$1.isTokenOnSameLine(tokenBeforeFirst, tokenAfterLast)) {\n                return;\n            }\n\n            if (requirePaddingFor(node)) {\n                if (!blockHasTopPadding) {\n                    context.report({\n                        node,\n                        loc: { line: tokenBeforeFirst.loc.start.line, column: tokenBeforeFirst.loc.start.column },\n                        fix(fixer) {\n                            return fixer.insertTextAfter(tokenBeforeFirst, \"\\n\");\n                        },\n                        message: ALWAYS_MESSAGE\n                    });\n                }\n                if (!blockHasBottomPadding) {\n                    context.report({\n                        node,\n                        loc: { line: tokenAfterLast.loc.end.line, column: tokenAfterLast.loc.end.column - 1 },\n                        fix(fixer) {\n                            return fixer.insertTextBefore(tokenAfterLast, \"\\n\");\n                        },\n                        message: ALWAYS_MESSAGE\n                    });\n                }\n            } else {\n                if (blockHasTopPadding) {\n\n                    context.report({\n                        node,\n                        loc: { line: tokenBeforeFirst.loc.start.line, column: tokenBeforeFirst.loc.start.column },\n                        fix(fixer) {\n                            return fixer.replaceTextRange([tokenBeforeFirst.range[1], firstBlockToken.range[0] - firstBlockToken.loc.start.column], \"\\n\");\n                        },\n                        message: NEVER_MESSAGE\n                    });\n                }\n\n                if (blockHasBottomPadding) {\n\n                    context.report({\n                        node,\n                        loc: { line: tokenAfterLast.loc.end.line, column: tokenAfterLast.loc.end.column - 1 },\n                        message: NEVER_MESSAGE,\n                        fix(fixer) {\n                            return fixer.replaceTextRange([lastBlockToken.range[1], tokenAfterLast.range[0] - tokenAfterLast.loc.start.column], \"\\n\");\n                        }\n                    });\n                }\n            }\n        }\n\n        const rule = {};\n\n        if (Object.prototype.hasOwnProperty.call(options, \"switches\")) {\n            rule.SwitchStatement = function(node) {\n                if (node.cases.length === 0) {\n                    return;\n                }\n                checkPadding(node);\n            };\n        }\n\n        if (Object.prototype.hasOwnProperty.call(options, \"blocks\")) {\n            rule.BlockStatement = function(node) {\n                if (node.body.length === 0) {\n                    return;\n                }\n                checkPadding(node);\n            };\n        }\n\n        if (Object.prototype.hasOwnProperty.call(options, \"classes\")) {\n            rule.ClassBody = function(node) {\n                if (node.body.length === 0) {\n                    return;\n                }\n                checkPadding(node);\n            };\n        }\n\n        return rule;\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst LT = `[${Array.from(astUtils$1.LINEBREAKS).join(\"\")}]`;\nconst PADDING_LINE_SEQUENCE = new RegExp(\n    String.raw`^(\\s*?${LT})\\s*${LT}(\\s*;?)$`,\n    \"u\"\n);\nconst CJS_EXPORT = /^(?:module\\s*\\.\\s*)?exports(?:\\s*\\.|\\s*\\[|$)/u;\nconst CJS_IMPORT = /^require\\(/u;\n\n/**\n * Creates tester which check if a node starts with specific keyword.\n * @param {string} keyword The keyword to test.\n * @returns {Object} the created tester.\n * @private\n */\nfunction newKeywordTester(keyword) {\n    return {\n        test: (node, sourceCode) =>\n            sourceCode.getFirstToken(node).value === keyword\n    };\n}\n\n/**\n * Creates tester which check if a node starts with specific keyword and spans a single line.\n * @param {string} keyword The keyword to test.\n * @returns {Object} the created tester.\n * @private\n */\nfunction newSinglelineKeywordTester(keyword) {\n    return {\n        test: (node, sourceCode) =>\n            node.loc.start.line === node.loc.end.line &&\n            sourceCode.getFirstToken(node).value === keyword\n    };\n}\n\n/**\n * Creates tester which check if a node starts with specific keyword and spans multiple lines.\n * @param {string} keyword The keyword to test.\n * @returns {Object} the created tester.\n * @private\n */\nfunction newMultilineKeywordTester(keyword) {\n    return {\n        test: (node, sourceCode) =>\n            node.loc.start.line !== node.loc.end.line &&\n            sourceCode.getFirstToken(node).value === keyword\n    };\n}\n\n/**\n * Creates tester which check if a node is specific type.\n * @param {string} type The node type to test.\n * @returns {Object} the created tester.\n * @private\n */\nfunction newNodeTypeTester(type) {\n    return {\n        test: node =>\n            node.type === type\n    };\n}\n\n/**\n * Checks the given node is an expression statement of IIFE.\n * @param {ASTNode} node The node to check.\n * @returns {boolean} `true` if the node is an expression statement of IIFE.\n * @private\n */\nfunction isIIFEStatement(node) {\n    if (node.type === \"ExpressionStatement\") {\n        let call = node.expression;\n\n        if (call.type === \"UnaryExpression\") {\n            call = call.argument;\n        }\n        return call.type === \"CallExpression\" && astUtils$1.isFunction(call.callee);\n    }\n    return false;\n}\n\n/**\n * Checks whether the given node is a block-like statement.\n * This checks the last token of the node is the closing brace of a block.\n * @param {SourceCode} sourceCode The source code to get tokens.\n * @param {ASTNode} node The node to check.\n * @returns {boolean} `true` if the node is a block-like statement.\n * @private\n */\nfunction isBlockLikeStatement(sourceCode, node) {\n\n    // do-while with a block is a block-like statement.\n    if (node.type === \"DoWhileStatement\" && node.body.type === \"BlockStatement\") {\n        return true;\n    }\n\n    /*\n     * IIFE is a block-like statement specially from\n     * JSCS#disallowPaddingNewLinesAfterBlocks.\n     */\n    if (isIIFEStatement(node)) {\n        return true;\n    }\n\n    // Checks the last token is a closing brace of blocks.\n    const lastToken = sourceCode.getLastToken(node, astUtils$1.isNotSemicolonToken);\n    const belongingNode = lastToken && astUtils$1.isClosingBraceToken(lastToken)\n        ? sourceCode.getNodeByRangeIndex(lastToken.range[0])\n        : null;\n\n    return Boolean(belongingNode) && (\n        belongingNode.type === \"BlockStatement\" ||\n        belongingNode.type === \"SwitchStatement\"\n    );\n}\n\n/**\n * Check whether the given node is a directive or not.\n * @param {ASTNode} node The node to check.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {boolean} `true` if the node is a directive.\n */\nfunction isDirective(node, sourceCode) {\n    return (\n        node.type === \"ExpressionStatement\" &&\n        (\n            node.parent.type === \"Program\" ||\n            (\n                node.parent.type === \"BlockStatement\" &&\n                astUtils$1.isFunction(node.parent.parent)\n            )\n        ) &&\n        node.expression.type === \"Literal\" &&\n        typeof node.expression.value === \"string\" &&\n        !astUtils$1.isParenthesised(sourceCode, node.expression)\n    );\n}\n\n/**\n * Check whether the given node is a part of directive prologue or not.\n * @param {ASTNode} node The node to check.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {boolean} `true` if the node is a part of directive prologue.\n */\nfunction isDirectivePrologue(node, sourceCode) {\n    if (isDirective(node, sourceCode)) {\n        for (const sibling of node.parent.body) {\n            if (sibling === node) {\n                break;\n            }\n            if (!isDirective(sibling, sourceCode)) {\n                return false;\n            }\n        }\n        return true;\n    }\n    return false;\n}\n\n/**\n * Gets the actual last token.\n *\n * If a semicolon is semicolon-less style's semicolon, this ignores it.\n * For example:\n *\n *     foo()\n *     ;[1, 2, 3].forEach(bar)\n * @param {SourceCode} sourceCode The source code to get tokens.\n * @param {ASTNode} node The node to get.\n * @returns {Token} The actual last token.\n * @private\n */\nfunction getActualLastToken(sourceCode, node) {\n    const semiToken = sourceCode.getLastToken(node);\n    const prevToken = sourceCode.getTokenBefore(semiToken);\n    const nextToken = sourceCode.getTokenAfter(semiToken);\n    const isSemicolonLessStyle = Boolean(\n        prevToken &&\n        nextToken &&\n        prevToken.range[0] >= node.range[0] &&\n        astUtils$1.isSemicolonToken(semiToken) &&\n        semiToken.loc.start.line !== prevToken.loc.end.line &&\n        semiToken.loc.end.line === nextToken.loc.start.line\n    );\n\n    return isSemicolonLessStyle ? prevToken : semiToken;\n}\n\n/**\n * This returns the concatenation of the first 2 captured strings.\n * @param {string} _ Unused. Whole matched string.\n * @param {string} trailingSpaces The trailing spaces of the first line.\n * @param {string} indentSpaces The indentation spaces of the last line.\n * @returns {string} The concatenation of trailingSpaces and indentSpaces.\n * @private\n */\nfunction replacerToRemovePaddingLines(_, trailingSpaces, indentSpaces) {\n    return trailingSpaces + indentSpaces;\n}\n\n/**\n * Check and report statements for `any` configuration.\n * It does nothing.\n * @returns {void}\n * @private\n */\nfunction verifyForAny() {\n}\n\n/**\n * Check and report statements for `never` configuration.\n * This autofix removes blank lines between the given 2 statements.\n * However, if comments exist between 2 blank lines, it does not remove those\n * blank lines automatically.\n * @param {RuleContext} context The rule context to report.\n * @param {ASTNode} _ Unused. The previous node to check.\n * @param {ASTNode} nextNode The next node to check.\n * @param {Array<Token[]>} paddingLines The array of token pairs that blank\n * lines exist between the pair.\n * @returns {void}\n * @private\n */\nfunction verifyForNever(context, _, nextNode, paddingLines) {\n    if (paddingLines.length === 0) {\n        return;\n    }\n\n    context.report({\n        node: nextNode,\n        message: \"Unexpected blank line before this statement.\",\n        fix(fixer) {\n            if (paddingLines.length >= 2) {\n                return null;\n            }\n\n            const prevToken = paddingLines[0][0];\n            const nextToken = paddingLines[0][1];\n            const start = prevToken.range[1];\n            const end = nextToken.range[0];\n            const text = context.getSourceCode().text\n                .slice(start, end)\n                .replace(PADDING_LINE_SEQUENCE, replacerToRemovePaddingLines);\n\n            return fixer.replaceTextRange([start, end], text);\n        }\n    });\n}\n\n/**\n * Check and report statements for `always` configuration.\n * This autofix inserts a blank line between the given 2 statements.\n * If the `prevNode` has trailing comments, it inserts a blank line after the\n * trailing comments.\n * @param {RuleContext} context The rule context to report.\n * @param {ASTNode} prevNode The previous node to check.\n * @param {ASTNode} nextNode The next node to check.\n * @param {Array<Token[]>} paddingLines The array of token pairs that blank\n * lines exist between the pair.\n * @returns {void}\n * @private\n */\nfunction verifyForAlways(context, prevNode, nextNode, paddingLines) {\n    if (paddingLines.length > 0) {\n        return;\n    }\n\n    context.report({\n        node: nextNode,\n        message: \"Expected blank line before this statement.\",\n        fix(fixer) {\n            const sourceCode = context.getSourceCode();\n            let prevToken = getActualLastToken(sourceCode, prevNode);\n            const nextToken = sourceCode.getFirstTokenBetween(\n                prevToken,\n                nextNode,\n                {\n                    includeComments: true,\n\n                    /**\n                     * Skip the trailing comments of the previous node.\n                     * This inserts a blank line after the last trailing comment.\n                     *\n                     * For example:\n                     *\n                     *     foo(); // trailing comment.\n                     *     // comment.\n                     *     bar();\n                     *\n                     * Get fixed to:\n                     *\n                     *     foo(); // trailing comment.\n                     *\n                     *     // comment.\n                     *     bar();\n                     * @param {Token} token The token to check.\n                     * @returns {boolean} `true` if the token is not a trailing comment.\n                     * @private\n                     */\n                    filter(token) {\n                        if (astUtils$1.isTokenOnSameLine(prevToken, token)) {\n                            prevToken = token;\n                            return false;\n                        }\n                        return true;\n                    }\n                }\n            ) || nextNode;\n            const insertText = astUtils$1.isTokenOnSameLine(prevToken, nextToken)\n                ? \"\\n\\n\"\n                : \"\\n\";\n\n            return fixer.insertTextAfter(prevToken, insertText);\n        }\n    });\n}\n\n/**\n * Types of blank lines.\n * `any`, `never`, and `always` are defined.\n * Those have `verify` method to check and report statements.\n * @private\n */\nconst PaddingTypes = {\n    any: { verify: verifyForAny },\n    never: { verify: verifyForNever },\n    always: { verify: verifyForAlways }\n};\n\n/**\n * Types of statements.\n * Those have `test` method to check it matches to the given statement.\n * @private\n */\nconst StatementTypes = {\n    \"*\": { test: () => true },\n    \"block-like\": {\n        test: (node, sourceCode) => isBlockLikeStatement(sourceCode, node)\n    },\n    \"cjs-export\": {\n        test: (node, sourceCode) =>\n            node.type === \"ExpressionStatement\" &&\n            node.expression.type === \"AssignmentExpression\" &&\n            CJS_EXPORT.test(sourceCode.getText(node.expression.left))\n    },\n    \"cjs-import\": {\n        test: (node, sourceCode) =>\n            node.type === \"VariableDeclaration\" &&\n            node.declarations.length > 0 &&\n            Boolean(node.declarations[0].init) &&\n            CJS_IMPORT.test(sourceCode.getText(node.declarations[0].init))\n    },\n    directive: {\n        test: isDirectivePrologue\n    },\n    expression: {\n        test: (node, sourceCode) =>\n            node.type === \"ExpressionStatement\" &&\n            !isDirectivePrologue(node, sourceCode)\n    },\n    iife: {\n        test: isIIFEStatement\n    },\n    \"multiline-block-like\": {\n        test: (node, sourceCode) =>\n            node.loc.start.line !== node.loc.end.line &&\n            isBlockLikeStatement(sourceCode, node)\n    },\n    \"multiline-expression\": {\n        test: (node, sourceCode) =>\n            node.loc.start.line !== node.loc.end.line &&\n            node.type === \"ExpressionStatement\" &&\n            !isDirectivePrologue(node, sourceCode)\n    },\n\n    \"multiline-const\": newMultilineKeywordTester(\"const\"),\n    \"multiline-let\": newMultilineKeywordTester(\"let\"),\n    \"multiline-var\": newMultilineKeywordTester(\"var\"),\n    \"singleline-const\": newSinglelineKeywordTester(\"const\"),\n    \"singleline-let\": newSinglelineKeywordTester(\"let\"),\n    \"singleline-var\": newSinglelineKeywordTester(\"var\"),\n\n    block: newNodeTypeTester(\"BlockStatement\"),\n    empty: newNodeTypeTester(\"EmptyStatement\"),\n    function: newNodeTypeTester(\"FunctionDeclaration\"),\n\n    break: newKeywordTester(\"break\"),\n    case: newKeywordTester(\"case\"),\n    class: newKeywordTester(\"class\"),\n    const: newKeywordTester(\"const\"),\n    continue: newKeywordTester(\"continue\"),\n    debugger: newKeywordTester(\"debugger\"),\n    default: newKeywordTester(\"default\"),\n    do: newKeywordTester(\"do\"),\n    export: newKeywordTester(\"export\"),\n    for: newKeywordTester(\"for\"),\n    if: newKeywordTester(\"if\"),\n    import: newKeywordTester(\"import\"),\n    let: newKeywordTester(\"let\"),\n    return: newKeywordTester(\"return\"),\n    switch: newKeywordTester(\"switch\"),\n    throw: newKeywordTester(\"throw\"),\n    try: newKeywordTester(\"try\"),\n    var: newKeywordTester(\"var\"),\n    while: newKeywordTester(\"while\"),\n    with: newKeywordTester(\"with\")\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar paddingLineBetweenStatements = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require or disallow padding lines between statements\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/padding-line-between-statements\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: {\n            definitions: {\n                paddingType: {\n                    enum: Object.keys(PaddingTypes)\n                },\n                statementType: {\n                    anyOf: [\n                        { enum: Object.keys(StatementTypes) },\n                        {\n                            type: \"array\",\n                            items: { enum: Object.keys(StatementTypes) },\n                            minItems: 1,\n                            uniqueItems: true,\n                            additionalItems: false\n                        }\n                    ]\n                }\n            },\n            type: \"array\",\n            items: {\n                type: \"object\",\n                properties: {\n                    blankLine: { $ref: \"#/definitions/paddingType\" },\n                    prev: { $ref: \"#/definitions/statementType\" },\n                    next: { $ref: \"#/definitions/statementType\" }\n                },\n                additionalProperties: false,\n                required: [\"blankLine\", \"prev\", \"next\"]\n            },\n            additionalItems: false\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const configureList = context.options || [];\n        let scopeInfo = null;\n\n        /**\n         * Processes to enter to new scope.\n         * This manages the current previous statement.\n         * @returns {void}\n         * @private\n         */\n        function enterScope() {\n            scopeInfo = {\n                upper: scopeInfo,\n                prevNode: null\n            };\n        }\n\n        /**\n         * Processes to exit from the current scope.\n         * @returns {void}\n         * @private\n         */\n        function exitScope() {\n            scopeInfo = scopeInfo.upper;\n        }\n\n        /**\n         * Checks whether the given node matches the given type.\n         * @param {ASTNode} node The statement node to check.\n         * @param {string|string[]} type The statement type to check.\n         * @returns {boolean} `true` if the statement node matched the type.\n         * @private\n         */\n        function match(node, type) {\n            let innerStatementNode = node;\n\n            while (innerStatementNode.type === \"LabeledStatement\") {\n                innerStatementNode = innerStatementNode.body;\n            }\n            if (Array.isArray(type)) {\n                return type.some(match.bind(null, innerStatementNode));\n            }\n            return StatementTypes[type].test(innerStatementNode, sourceCode);\n        }\n\n        /**\n         * Finds the last matched configure from configureList.\n         * @param {ASTNode} prevNode The previous statement to match.\n         * @param {ASTNode} nextNode The current statement to match.\n         * @returns {Object} The tester of the last matched configure.\n         * @private\n         */\n        function getPaddingType(prevNode, nextNode) {\n            for (let i = configureList.length - 1; i >= 0; --i) {\n                const configure = configureList[i];\n                const matched =\n                    match(prevNode, configure.prev) &&\n                    match(nextNode, configure.next);\n\n                if (matched) {\n                    return PaddingTypes[configure.blankLine];\n                }\n            }\n            return PaddingTypes.any;\n        }\n\n        /**\n         * Gets padding line sequences between the given 2 statements.\n         * Comments are separators of the padding line sequences.\n         * @param {ASTNode} prevNode The previous statement to count.\n         * @param {ASTNode} nextNode The current statement to count.\n         * @returns {Array<Token[]>} The array of token pairs.\n         * @private\n         */\n        function getPaddingLineSequences(prevNode, nextNode) {\n            const pairs = [];\n            let prevToken = getActualLastToken(sourceCode, prevNode);\n\n            if (nextNode.loc.start.line - prevToken.loc.end.line >= 2) {\n                do {\n                    const token = sourceCode.getTokenAfter(\n                        prevToken,\n                        { includeComments: true }\n                    );\n\n                    if (token.loc.start.line - prevToken.loc.end.line >= 2) {\n                        pairs.push([prevToken, token]);\n                    }\n                    prevToken = token;\n\n                } while (prevToken.range[0] < nextNode.range[0]);\n            }\n\n            return pairs;\n        }\n\n        /**\n         * Verify padding lines between the given node and the previous node.\n         * @param {ASTNode} node The node to verify.\n         * @returns {void}\n         * @private\n         */\n        function verify(node) {\n            const parentType = node.parent.type;\n            const validParent =\n                astUtils$1.STATEMENT_LIST_PARENTS.has(parentType) ||\n                parentType === \"SwitchStatement\";\n\n            if (!validParent) {\n                return;\n            }\n\n            // Save this node as the current previous statement.\n            const prevNode = scopeInfo.prevNode;\n\n            // Verify.\n            if (prevNode) {\n                const type = getPaddingType(prevNode, node);\n                const paddingLines = getPaddingLineSequences(prevNode, node);\n\n                type.verify(context, prevNode, node, paddingLines);\n            }\n\n            scopeInfo.prevNode = node;\n        }\n\n        /**\n         * Verify padding lines between the given node and the previous node.\n         * Then process to enter to new scope.\n         * @param {ASTNode} node The node to verify.\n         * @returns {void}\n         * @private\n         */\n        function verifyThenEnterScope(node) {\n            verify(node);\n            enterScope();\n        }\n\n        return {\n            Program: enterScope,\n            BlockStatement: enterScope,\n            SwitchStatement: enterScope,\n            \"Program:exit\": exitScope,\n            \"BlockStatement:exit\": exitScope,\n            \"SwitchStatement:exit\": exitScope,\n\n            \":statement\": verify,\n\n            SwitchCase: verifyThenEnterScope,\n            \"SwitchCase:exit\": exitScope\n        };\n    }\n};\n\n/**\n * @fileoverview A rule to suggest using arrow functions as callbacks.\n * @author Toru Nagashima\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not a given variable is a function name.\n * @param {eslint-scope.Variable} variable A variable to check.\n * @returns {boolean} `true` if the variable is a function name.\n */\nfunction isFunctionName$1(variable) {\n    return variable && variable.defs[0].type === \"FunctionName\";\n}\n\n/**\n * Checks whether or not a given MetaProperty node equals to a given value.\n * @param {ASTNode} node A MetaProperty node to check.\n * @param {string} metaName The name of `MetaProperty.meta`.\n * @param {string} propertyName The name of `MetaProperty.property`.\n * @returns {boolean} `true` if the node is the specific value.\n */\nfunction checkMetaProperty(node, metaName, propertyName) {\n    return node.meta.name === metaName && node.property.name === propertyName;\n}\n\n/**\n * Gets the variable object of `arguments` which is defined implicitly.\n * @param {eslint-scope.Scope} scope A scope to get.\n * @returns {eslint-scope.Variable} The found variable object.\n */\nfunction getVariableOfArguments(scope) {\n    const variables = scope.variables;\n\n    for (let i = 0; i < variables.length; ++i) {\n        const variable = variables[i];\n\n        if (variable.name === \"arguments\") {\n\n            /*\n             * If there was a parameter which is named \"arguments\", the\n             * implicit \"arguments\" is not defined.\n             * So does fast return with null.\n             */\n            return (variable.identifiers.length === 0) ? variable : null;\n        }\n    }\n\n    /* istanbul ignore next */\n    return null;\n}\n\n/**\n * Checkes whether or not a given node is a callback.\n * @param {ASTNode} node A node to check.\n * @returns {Object}\n *   {boolean} retv.isCallback - `true` if the node is a callback.\n *   {boolean} retv.isLexicalThis - `true` if the node is with `.bind(this)`.\n */\nfunction getCallbackInfo(node) {\n    const retv = { isCallback: false, isLexicalThis: false };\n    let currentNode = node;\n    let parent = node.parent;\n\n    while (currentNode) {\n        switch (parent.type) {\n\n            // Checks parents recursively.\n\n            case \"LogicalExpression\":\n            case \"ConditionalExpression\":\n                break;\n\n            // Checks whether the parent node is `.bind(this)` call.\n            case \"MemberExpression\":\n                if (parent.object === currentNode &&\n                    !parent.property.computed &&\n                    parent.property.type === \"Identifier\" &&\n                    parent.property.name === \"bind\" &&\n                    parent.parent.type === \"CallExpression\" &&\n                    parent.parent.callee === parent\n                ) {\n                    retv.isLexicalThis = (\n                        parent.parent.arguments.length === 1 &&\n                        parent.parent.arguments[0].type === \"ThisExpression\"\n                    );\n                    parent = parent.parent;\n                } else {\n                    return retv;\n                }\n                break;\n\n            // Checks whether the node is a callback.\n            case \"CallExpression\":\n            case \"NewExpression\":\n                if (parent.callee !== currentNode) {\n                    retv.isCallback = true;\n                }\n                return retv;\n\n            default:\n                return retv;\n        }\n\n        currentNode = parent;\n        parent = parent.parent;\n    }\n\n    /* istanbul ignore next */\n    throw new Error(\"unreachable\");\n}\n\n/**\n * Checks whether a simple list of parameters contains any duplicates. This does not handle complex\n * parameter lists (e.g. with destructuring), since complex parameter lists are a SyntaxError with duplicate\n * parameter names anyway. Instead, it always returns `false` for complex parameter lists.\n * @param {ASTNode[]} paramsList The list of parameters for a function\n * @returns {boolean} `true` if the list of parameters contains any duplicates\n */\nfunction hasDuplicateParams(paramsList) {\n    return paramsList.every(param => param.type === \"Identifier\") && paramsList.length !== new Set(paramsList.map(param => param.name)).size;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar preferArrowCallback = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require using arrow functions for callbacks\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/prefer-arrow-callback\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allowNamedFunctions: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    allowUnboundThis: {\n                        type: \"boolean\",\n                        default: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        fixable: \"code\"\n    },\n\n    create(context) {\n        const options = context.options[0] || {};\n\n        const allowUnboundThis = options.allowUnboundThis !== false; // default to true\n        const allowNamedFunctions = options.allowNamedFunctions;\n        const sourceCode = context.getSourceCode();\n\n        /*\n         * {Array<{this: boolean, super: boolean, meta: boolean}>}\n         * - this - A flag which shows there are one or more ThisExpression.\n         * - super - A flag which shows there are one or more Super.\n         * - meta - A flag which shows there are one or more MethProperty.\n         */\n        let stack = [];\n\n        /**\n         * Pushes new function scope with all `false` flags.\n         * @returns {void}\n         */\n        function enterScope() {\n            stack.push({ this: false, super: false, meta: false });\n        }\n\n        /**\n         * Pops a function scope from the stack.\n         * @returns {{this: boolean, super: boolean, meta: boolean}} The information of the last scope.\n         */\n        function exitScope() {\n            return stack.pop();\n        }\n\n        return {\n\n            // Reset internal state.\n            Program() {\n                stack = [];\n            },\n\n            // If there are below, it cannot replace with arrow functions merely.\n            ThisExpression() {\n                const info = stack[stack.length - 1];\n\n                if (info) {\n                    info.this = true;\n                }\n            },\n\n            Super() {\n                const info = stack[stack.length - 1];\n\n                if (info) {\n                    info.super = true;\n                }\n            },\n\n            MetaProperty(node) {\n                const info = stack[stack.length - 1];\n\n                if (info && checkMetaProperty(node, \"new\", \"target\")) {\n                    info.meta = true;\n                }\n            },\n\n            // To skip nested scopes.\n            FunctionDeclaration: enterScope,\n            \"FunctionDeclaration:exit\": exitScope,\n\n            // Main.\n            FunctionExpression: enterScope,\n            \"FunctionExpression:exit\"(node) {\n                const scopeInfo = exitScope();\n\n                // Skip named function expressions\n                if (allowNamedFunctions && node.id && node.id.name) {\n                    return;\n                }\n\n                // Skip generators.\n                if (node.generator) {\n                    return;\n                }\n\n                // Skip recursive functions.\n                const nameVar = context.getDeclaredVariables(node)[0];\n\n                if (isFunctionName$1(nameVar) && nameVar.references.length > 0) {\n                    return;\n                }\n\n                // Skip if it's using arguments.\n                const variable = getVariableOfArguments(context.getScope());\n\n                if (variable && variable.references.length > 0) {\n                    return;\n                }\n\n                // Reports if it's a callback which can replace with arrows.\n                const callbackInfo = getCallbackInfo(node);\n\n                if (callbackInfo.isCallback &&\n                    (!allowUnboundThis || !scopeInfo.this || callbackInfo.isLexicalThis) &&\n                    !scopeInfo.super &&\n                    !scopeInfo.meta\n                ) {\n                    context.report({\n                        node,\n                        message: \"Unexpected function expression.\",\n                        fix(fixer) {\n                            if ((!callbackInfo.isLexicalThis && scopeInfo.this) || hasDuplicateParams(node.params)) {\n\n                                /*\n                                 * If the callback function does not have .bind(this) and contains a reference to `this`, there\n                                 * is no way to determine what `this` should be, so don't perform any fixes.\n                                 * If the callback function has duplicates in its list of parameters (possible in sloppy mode),\n                                 * don't replace it with an arrow function, because this is a SyntaxError with arrow functions.\n                                 */\n                                return null;\n                            }\n\n                            const paramsLeftParen = node.params.length ? sourceCode.getTokenBefore(node.params[0]) : sourceCode.getTokenBefore(node.body, 1);\n                            const paramsRightParen = sourceCode.getTokenBefore(node.body);\n                            const asyncKeyword = node.async ? \"async \" : \"\";\n                            const paramsFullText = sourceCode.text.slice(paramsLeftParen.range[0], paramsRightParen.range[1]);\n                            const arrowFunctionText = `${asyncKeyword}${paramsFullText} => ${sourceCode.getText(node.body)}`;\n\n                            /*\n                             * If the callback function has `.bind(this)`, replace it with an arrow function and remove the binding.\n                             * Otherwise, just replace the arrow function itself.\n                             */\n                            const replacedNode = callbackInfo.isLexicalThis ? node.parent.parent : node;\n\n                            /*\n                             * If the replaced node is part of a BinaryExpression, LogicalExpression, or MemberExpression, then\n                             * the arrow function needs to be parenthesized, because `foo || () => {}` is invalid syntax even\n                             * though `foo || function() {}` is valid.\n                             */\n                            const needsParens = replacedNode.parent.type !== \"CallExpression\" && replacedNode.parent.type !== \"ConditionalExpression\";\n                            const replacementText = needsParens ? `(${arrowFunctionText})` : arrowFunctionText;\n\n                            return fixer.replaceText(replacedNode, replacementText);\n                        }\n                    });\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst PATTERN_TYPE = /^(?:.+?Pattern|RestElement|SpreadProperty|ExperimentalRestProperty|Property)$/u;\nconst DECLARATION_HOST_TYPE = /^(?:Program|BlockStatement|SwitchCase)$/u;\nconst DESTRUCTURING_HOST_TYPE = /^(?:VariableDeclarator|AssignmentExpression)$/u;\n\n/**\n * Checks whether a given node is located at `ForStatement.init` or not.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} `true` if the node is located at `ForStatement.init`.\n */\nfunction isInitOfForStatement(node) {\n    return node.parent.type === \"ForStatement\" && node.parent.init === node;\n}\n\n/**\n * Checks whether a given Identifier node becomes a VariableDeclaration or not.\n * @param {ASTNode} identifier An Identifier node to check.\n * @returns {boolean} `true` if the node can become a VariableDeclaration.\n */\nfunction canBecomeVariableDeclaration(identifier) {\n    let node = identifier.parent;\n\n    while (PATTERN_TYPE.test(node.type)) {\n        node = node.parent;\n    }\n\n    return (\n        node.type === \"VariableDeclarator\" ||\n        (\n            node.type === \"AssignmentExpression\" &&\n            node.parent.type === \"ExpressionStatement\" &&\n            DECLARATION_HOST_TYPE.test(node.parent.parent.type)\n        )\n    );\n}\n\n/**\n * Checks if an property or element is from outer scope or function parameters\n * in destructing pattern.\n * @param {string} name A variable name to be checked.\n * @param {eslint-scope.Scope} initScope A scope to start find.\n * @returns {boolean} Indicates if the variable is from outer scope or function parameters.\n */\nfunction isOuterVariableInDestructing(name, initScope) {\n\n    if (initScope.through.find(ref => ref.resolved && ref.resolved.name === name)) {\n        return true;\n    }\n\n    const variable = astUtils$1.getVariableByName(initScope, name);\n\n    if (variable !== null) {\n        return variable.defs.some(def => def.type === \"Parameter\");\n    }\n\n    return false;\n}\n\n/**\n * Gets the VariableDeclarator/AssignmentExpression node that a given reference\n * belongs to.\n * This is used to detect a mix of reassigned and never reassigned in a\n * destructuring.\n * @param {eslint-scope.Reference} reference A reference to get.\n * @returns {ASTNode|null} A VariableDeclarator/AssignmentExpression node or\n *      null.\n */\nfunction getDestructuringHost(reference) {\n    if (!reference.isWrite()) {\n        return null;\n    }\n    let node = reference.identifier.parent;\n\n    while (PATTERN_TYPE.test(node.type)) {\n        node = node.parent;\n    }\n\n    if (!DESTRUCTURING_HOST_TYPE.test(node.type)) {\n        return null;\n    }\n    return node;\n}\n\n/**\n * Determines if a destructuring assignment node contains\n * any MemberExpression nodes. This is used to determine if a\n * variable that is only written once using destructuring can be\n * safely converted into a const declaration.\n * @param {ASTNode} node The ObjectPattern or ArrayPattern node to check.\n * @returns {boolean} True if the destructuring pattern contains\n *      a MemberExpression, false if not.\n */\nfunction hasMemberExpressionAssignment(node) {\n    switch (node.type) {\n        case \"ObjectPattern\":\n            return node.properties.some(prop => {\n                if (prop) {\n\n                    /*\n                     * Spread elements have an argument property while\n                     * others have a value property. Because different\n                     * parsers use different node types for spread elements,\n                     * we just check if there is an argument property.\n                     */\n                    return hasMemberExpressionAssignment(prop.argument || prop.value);\n                }\n\n                return false;\n            });\n\n        case \"ArrayPattern\":\n            return node.elements.some(element => {\n                if (element) {\n                    return hasMemberExpressionAssignment(element);\n                }\n\n                return false;\n            });\n\n        case \"AssignmentPattern\":\n            return hasMemberExpressionAssignment(node.left);\n\n        case \"MemberExpression\":\n            return true;\n\n        // no default\n    }\n\n    return false;\n}\n\n/**\n * Gets an identifier node of a given variable.\n *\n * If the initialization exists or one or more reading references exist before\n * the first assignment, the identifier node is the node of the declaration.\n * Otherwise, the identifier node is the node of the first assignment.\n *\n * If the variable should not change to const, this function returns null.\n * - If the variable is reassigned.\n * - If the variable is never initialized nor assigned.\n * - If the variable is initialized in a different scope from the declaration.\n * - If the unique assignment of the variable cannot change to a declaration.\n *   e.g. `if (a) b = 1` / `return (b = 1)`\n * - If the variable is declared in the global scope and `eslintUsed` is `true`.\n *   `/*exported foo` directive comment makes such variables. This rule does not\n *   warn such variables because this rule cannot distinguish whether the\n *   exported variables are reassigned or not.\n * @param {eslint-scope.Variable} variable A variable to get.\n * @param {boolean} ignoreReadBeforeAssign\n *      The value of `ignoreReadBeforeAssign` option.\n * @returns {ASTNode|null}\n *      An Identifier node if the variable should change to const.\n *      Otherwise, null.\n */\nfunction getIdentifierIfShouldBeConst(variable, ignoreReadBeforeAssign) {\n    if (variable.eslintUsed && variable.scope.type === \"global\") {\n        return null;\n    }\n\n    // Finds the unique WriteReference.\n    let writer = null;\n    let isReadBeforeInit = false;\n    const references = variable.references;\n\n    for (let i = 0; i < references.length; ++i) {\n        const reference = references[i];\n\n        if (reference.isWrite()) {\n            const isReassigned = (\n                writer !== null &&\n                writer.identifier !== reference.identifier\n            );\n\n            if (isReassigned) {\n                return null;\n            }\n\n            const destructuringHost = getDestructuringHost(reference);\n\n            if (destructuringHost !== null && destructuringHost.left !== void 0) {\n                const leftNode = destructuringHost.left;\n                let hasOuterVariables = false,\n                    hasNonIdentifiers = false;\n\n                if (leftNode.type === \"ObjectPattern\") {\n                    const properties = leftNode.properties;\n\n                    hasOuterVariables = properties\n                        .filter(prop => prop.value)\n                        .map(prop => prop.value.name)\n                        .some(name => isOuterVariableInDestructing(name, variable.scope));\n\n                    hasNonIdentifiers = hasMemberExpressionAssignment(leftNode);\n\n                } else if (leftNode.type === \"ArrayPattern\") {\n                    const elements = leftNode.elements;\n\n                    hasOuterVariables = elements\n                        .map(element => element && element.name)\n                        .some(name => isOuterVariableInDestructing(name, variable.scope));\n\n                    hasNonIdentifiers = hasMemberExpressionAssignment(leftNode);\n                }\n\n                if (hasOuterVariables || hasNonIdentifiers) {\n                    return null;\n                }\n\n            }\n\n            writer = reference;\n\n        } else if (reference.isRead() && writer === null) {\n            if (ignoreReadBeforeAssign) {\n                return null;\n            }\n            isReadBeforeInit = true;\n        }\n    }\n\n    /*\n     * If the assignment is from a different scope, ignore it.\n     * If the assignment cannot change to a declaration, ignore it.\n     */\n    const shouldBeConst = (\n        writer !== null &&\n        writer.from === variable.scope &&\n        canBecomeVariableDeclaration(writer.identifier)\n    );\n\n    if (!shouldBeConst) {\n        return null;\n    }\n\n    if (isReadBeforeInit) {\n        return variable.defs[0].name;\n    }\n\n    return writer.identifier;\n}\n\n/**\n * Groups by the VariableDeclarator/AssignmentExpression node that each\n * reference of given variables belongs to.\n * This is used to detect a mix of reassigned and never reassigned in a\n * destructuring.\n * @param {eslint-scope.Variable[]} variables Variables to group by destructuring.\n * @param {boolean} ignoreReadBeforeAssign\n *      The value of `ignoreReadBeforeAssign` option.\n * @returns {Map<ASTNode, ASTNode[]>} Grouped identifier nodes.\n */\nfunction groupByDestructuring(variables, ignoreReadBeforeAssign) {\n    const identifierMap = new Map();\n\n    for (let i = 0; i < variables.length; ++i) {\n        const variable = variables[i];\n        const references = variable.references;\n        const identifier = getIdentifierIfShouldBeConst(variable, ignoreReadBeforeAssign);\n        let prevId = null;\n\n        for (let j = 0; j < references.length; ++j) {\n            const reference = references[j];\n            const id = reference.identifier;\n\n            /*\n             * Avoid counting a reference twice or more for default values of\n             * destructuring.\n             */\n            if (id === prevId) {\n                continue;\n            }\n            prevId = id;\n\n            // Add the identifier node into the destructuring group.\n            const group = getDestructuringHost(reference);\n\n            if (group) {\n                if (identifierMap.has(group)) {\n                    identifierMap.get(group).push(identifier);\n                } else {\n                    identifierMap.set(group, [identifier]);\n                }\n            }\n        }\n    }\n\n    return identifierMap;\n}\n\n/**\n * Finds the nearest parent of node with a given type.\n * @param {ASTNode} node The node to search from.\n * @param {string} type The type field of the parent node.\n * @param {Function} shouldStop A predicate that returns true if the traversal should stop, and false otherwise.\n * @returns {ASTNode} The closest ancestor with the specified type; null if no such ancestor exists.\n */\nfunction findUp(node, type, shouldStop) {\n    if (!node || shouldStop(node)) {\n        return null;\n    }\n    if (node.type === type) {\n        return node;\n    }\n    return findUp(node.parent, type, shouldStop);\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar preferConst = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require `const` declarations for variables that are never reassigned after declared\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/prefer-const\"\n        },\n\n        fixable: \"code\",\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    destructuring: { enum: [\"any\", \"all\"], default: \"any\" },\n                    ignoreReadBeforeAssign: { type: \"boolean\", default: false }\n                },\n                additionalProperties: false\n            }\n        ],\n        messages: {\n            useConst: \"'{{name}}' is never reassigned. Use 'const' instead.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options[0] || {};\n        const sourceCode = context.getSourceCode();\n        const shouldMatchAnyDestructuredVariable = options.destructuring !== \"all\";\n        const ignoreReadBeforeAssign = options.ignoreReadBeforeAssign === true;\n        const variables = [];\n        let reportCount = 0;\n        let checkedId = null;\n        let checkedName = \"\";\n\n\n        /**\n         * Reports given identifier nodes if all of the nodes should be declared\n         * as const.\n         *\n         * The argument 'nodes' is an array of Identifier nodes.\n         * This node is the result of 'getIdentifierIfShouldBeConst()', so it's\n         * nullable. In simple declaration or assignment cases, the length of\n         * the array is 1. In destructuring cases, the length of the array can\n         * be 2 or more.\n         * @param {(eslint-scope.Reference|null)[]} nodes\n         *      References which are grouped by destructuring to report.\n         * @returns {void}\n         */\n        function checkGroup(nodes) {\n            const nodesToReport = nodes.filter(Boolean);\n\n            if (nodes.length && (shouldMatchAnyDestructuredVariable || nodesToReport.length === nodes.length)) {\n                const varDeclParent = findUp(nodes[0], \"VariableDeclaration\", parentNode => parentNode.type.endsWith(\"Statement\"));\n                const isVarDecParentNull = varDeclParent === null;\n\n                if (!isVarDecParentNull && varDeclParent.declarations.length > 0) {\n                    const firstDeclaration = varDeclParent.declarations[0];\n\n                    if (firstDeclaration.init) {\n                        const firstDecParent = firstDeclaration.init.parent;\n\n                        /*\n                         * First we check the declaration type and then depending on\n                         * if the type is a \"VariableDeclarator\" or its an \"ObjectPattern\"\n                         * we compare the name and id from the first identifier, if the names are different\n                         * we assign the new name, id and reset the count of reportCount and nodeCount in\n                         * order to check each block for the number of reported errors and base our fix\n                         * based on comparing nodes.length and nodesToReport.length.\n                         */\n\n                        if (firstDecParent.type === \"VariableDeclarator\") {\n\n                            if (firstDecParent.id.name !== checkedName) {\n                                checkedName = firstDecParent.id.name;\n                                reportCount = 0;\n                            }\n\n                            if (firstDecParent.id.type === \"ObjectPattern\") {\n                                if (firstDecParent.init.name !== checkedName) {\n                                    checkedName = firstDecParent.init.name;\n                                    reportCount = 0;\n                                }\n                            }\n\n                            if (firstDecParent.id !== checkedId) {\n                                checkedId = firstDecParent.id;\n                                reportCount = 0;\n                            }\n                        }\n                    }\n                }\n\n                let shouldFix = varDeclParent &&\n\n                    // Don't do a fix unless all variables in the declarations are initialized (or it's in a for-in or for-of loop)\n                    (varDeclParent.parent.type === \"ForInStatement\" || varDeclParent.parent.type === \"ForOfStatement\" ||\n                        varDeclParent.declarations.every(declaration => declaration.init)) &&\n\n                    /*\n                     * If options.destructuring is \"all\", then this warning will not occur unless\n                     * every assignment in the destructuring should be const. In that case, it's safe\n                     * to apply the fix.\n                     */\n                    nodesToReport.length === nodes.length;\n\n                if (!isVarDecParentNull && varDeclParent.declarations && varDeclParent.declarations.length !== 1) {\n\n                    if (varDeclParent && varDeclParent.declarations && varDeclParent.declarations.length >= 1) {\n\n                        /*\n                         * Add nodesToReport.length to a count, then comparing the count to the length\n                         * of the declarations in the current block.\n                         */\n\n                        reportCount += nodesToReport.length;\n\n                        shouldFix = shouldFix && (reportCount === varDeclParent.declarations.length);\n                    }\n                }\n\n                nodesToReport.forEach(node => {\n                    context.report({\n                        node,\n                        messageId: \"useConst\",\n                        data: node,\n                        fix: shouldFix\n                            ? fixer => fixer.replaceText(\n                                sourceCode.getFirstToken(varDeclParent, t => t.value === varDeclParent.kind),\n                                \"const\"\n                            )\n                            : null\n                    });\n                });\n            }\n        }\n\n        return {\n            \"Program:exit\"() {\n                groupByDestructuring(variables, ignoreReadBeforeAssign).forEach(checkGroup);\n            },\n\n            VariableDeclaration(node) {\n                if (node.kind === \"let\" && !isInitOfForStatement(node)) {\n                    variables.push(...context.getDeclaredVariables(node));\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Prefer destructuring from arrays and objects\n * @author Alex LaFroscia\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar preferDestructuring = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require destructuring from arrays and/or objects\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/prefer-destructuring\"\n        },\n\n        fixable: \"code\",\n\n        schema: [\n            {\n\n                /*\n                 * old support {array: Boolean, object: Boolean}\n                 * new support {VariableDeclarator: {}, AssignmentExpression: {}}\n                 */\n                oneOf: [\n                    {\n                        type: \"object\",\n                        properties: {\n                            VariableDeclarator: {\n                                type: \"object\",\n                                properties: {\n                                    array: {\n                                        type: \"boolean\"\n                                    },\n                                    object: {\n                                        type: \"boolean\"\n                                    }\n                                },\n                                additionalProperties: false\n                            },\n                            AssignmentExpression: {\n                                type: \"object\",\n                                properties: {\n                                    array: {\n                                        type: \"boolean\"\n                                    },\n                                    object: {\n                                        type: \"boolean\"\n                                    }\n                                },\n                                additionalProperties: false\n                            }\n                        },\n                        additionalProperties: false\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            array: {\n                                type: \"boolean\"\n                            },\n                            object: {\n                                type: \"boolean\"\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    enforceForRenamedProperties: {\n                        type: \"boolean\"\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n    create(context) {\n\n        const enabledTypes = context.options[0];\n        const enforceForRenamedProperties = context.options[1] && context.options[1].enforceForRenamedProperties;\n        let normalizedOptions = {\n            VariableDeclarator: { array: true, object: true },\n            AssignmentExpression: { array: true, object: true }\n        };\n\n        if (enabledTypes) {\n            normalizedOptions = typeof enabledTypes.array !== \"undefined\" || typeof enabledTypes.object !== \"undefined\"\n                ? { VariableDeclarator: enabledTypes, AssignmentExpression: enabledTypes }\n                : enabledTypes;\n        }\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        // eslint-disable-next-line jsdoc/require-description\n        /**\n         * @param {string} nodeType \"AssignmentExpression\" or \"VariableDeclarator\"\n         * @param {string} destructuringType \"array\" or \"object\"\n         * @returns {boolean} `true` if the destructuring type should be checked for the given node\n         */\n        function shouldCheck(nodeType, destructuringType) {\n            return normalizedOptions &&\n                normalizedOptions[nodeType] &&\n                normalizedOptions[nodeType][destructuringType];\n        }\n\n        /**\n         * Determines if the given node is accessing an array index\n         *\n         * This is used to differentiate array index access from object property\n         * access.\n         * @param {ASTNode} node the node to evaluate\n         * @returns {boolean} whether or not the node is an integer\n         */\n        function isArrayIndexAccess(node) {\n            return Number.isInteger(node.property.value);\n        }\n\n        /**\n         * Report that the given node should use destructuring\n         * @param {ASTNode} reportNode the node to report\n         * @param {string} type the type of destructuring that should have been done\n         * @param {Function|null} fix the fix function or null to pass to context.report\n         * @returns {void}\n         */\n        function report(reportNode, type, fix) {\n            context.report({\n                node: reportNode,\n                message: \"Use {{type}} destructuring.\",\n                data: { type },\n                fix\n            });\n        }\n\n        /**\n         * Determines if a node should be fixed into object destructuring\n         *\n         * The fixer only fixes the simplest case of object destructuring,\n         * like: `let x = a.x`;\n         *\n         * Assignment expression is not fixed.\n         * Array destructuring is not fixed.\n         * Renamed property is not fixed.\n         * @param {ASTNode} node the the node to evaluate\n         * @returns {boolean} whether or not the node should be fixed\n         */\n        function shouldFix(node) {\n            return node.type === \"VariableDeclarator\" &&\n                node.id.type === \"Identifier\" &&\n                node.init.type === \"MemberExpression\" &&\n                node.id.name === node.init.property.name;\n        }\n\n        /**\n         * Fix a node into object destructuring.\n         * This function only handles the simplest case of object destructuring,\n         * see {@link shouldFix}.\n         * @param {SourceCodeFixer} fixer the fixer object\n         * @param {ASTNode} node the node to be fixed.\n         * @returns {Object} a fix for the node\n         */\n        function fixIntoObjectDestructuring(fixer, node) {\n            const rightNode = node.init;\n            const sourceCode = context.getSourceCode();\n\n            return fixer.replaceText(\n                node,\n                `{${rightNode.property.name}} = ${sourceCode.getText(rightNode.object)}`\n            );\n        }\n\n        /**\n         * Check that the `prefer-destructuring` rules are followed based on the\n         * given left- and right-hand side of the assignment.\n         *\n         * Pulled out into a separate method so that VariableDeclarators and\n         * AssignmentExpressions can share the same verification logic.\n         * @param {ASTNode} leftNode the left-hand side of the assignment\n         * @param {ASTNode} rightNode the right-hand side of the assignment\n         * @param {ASTNode} reportNode the node to report the error on\n         * @returns {void}\n         */\n        function performCheck(leftNode, rightNode, reportNode) {\n            if (rightNode.type !== \"MemberExpression\" || rightNode.object.type === \"Super\") {\n                return;\n            }\n\n            if (isArrayIndexAccess(rightNode)) {\n                if (shouldCheck(reportNode.type, \"array\")) {\n                    report(reportNode, \"array\", null);\n                }\n                return;\n            }\n\n            const fix = shouldFix(reportNode)\n                ? fixer => fixIntoObjectDestructuring(fixer, reportNode)\n                : null;\n\n            if (shouldCheck(reportNode.type, \"object\") && enforceForRenamedProperties) {\n                report(reportNode, \"object\", fix);\n                return;\n            }\n\n            if (shouldCheck(reportNode.type, \"object\")) {\n                const property = rightNode.property;\n\n                if (\n                    (property.type === \"Literal\" && leftNode.name === property.value) ||\n                    (property.type === \"Identifier\" && leftNode.name === property.name && !rightNode.computed)\n                ) {\n                    report(reportNode, \"object\", fix);\n                }\n            }\n        }\n\n        /**\n         * Check if a given variable declarator is coming from an property access\n         * that should be using destructuring instead\n         * @param {ASTNode} node the variable declarator to check\n         * @returns {void}\n         */\n        function checkVariableDeclarator(node) {\n\n            // Skip if variable is declared without assignment\n            if (!node.init) {\n                return;\n            }\n\n            // We only care about member expressions past this point\n            if (node.init.type !== \"MemberExpression\") {\n                return;\n            }\n\n            performCheck(node.id, node.init, node);\n        }\n\n        /**\n         * Run the `prefer-destructuring` check on an AssignmentExpression\n         * @param {ASTNode} node the AssignmentExpression node\n         * @returns {void}\n         */\n        function checkAssigmentExpression(node) {\n            if (node.operator === \"=\") {\n                performCheck(node.left, node.right, node);\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            VariableDeclarator: checkVariableDeclarator,\n            AssignmentExpression: checkAssigmentExpression\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\nconst { CALL: CALL$3, ReferenceTracker: ReferenceTracker$3 } = require$$0$2;\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst PRECEDENCE_OF_EXPONENTIATION_EXPR = astUtils$1.getPrecedence({ type: \"BinaryExpression\", operator: \"**\" });\n\n/**\n * Determines whether the given node needs parens if used as the base in an exponentiation binary expression.\n * @param {ASTNode} base The node to check.\n * @returns {boolean} `true` if the node needs to be parenthesised.\n */\nfunction doesBaseNeedParens(base) {\n    return (\n\n        // '**' is right-associative, parens are needed when Math.pow(a ** b, c) is converted to (a ** b) ** c\n        astUtils$1.getPrecedence(base) <= PRECEDENCE_OF_EXPONENTIATION_EXPR ||\n\n        // An unary operator cannot be used immediately before an exponentiation expression\n        base.type === \"UnaryExpression\"\n    );\n}\n\n/**\n * Determines whether the given node needs parens if used as the exponent in an exponentiation binary expression.\n * @param {ASTNode} exponent The node to check.\n * @returns {boolean} `true` if the node needs to be parenthesised.\n */\nfunction doesExponentNeedParens(exponent) {\n\n    // '**' is right-associative, there is no need for parens when Math.pow(a, b ** c) is converted to a ** b ** c\n    return astUtils$1.getPrecedence(exponent) < PRECEDENCE_OF_EXPONENTIATION_EXPR;\n}\n\n/**\n * Determines whether an exponentiation binary expression at the place of the given node would need parens.\n * @param {ASTNode} node A node that would be replaced by an exponentiation binary expression.\n * @param {SourceCode} sourceCode A SourceCode object.\n * @returns {boolean} `true` if the expression needs to be parenthesised.\n */\nfunction doesExponentiationExpressionNeedParens(node, sourceCode) {\n    const parent = node.parent;\n\n    const needsParens = (\n        parent.type === \"ClassDeclaration\" ||\n        (\n            parent.type.endsWith(\"Expression\") &&\n            astUtils$1.getPrecedence(parent) >= PRECEDENCE_OF_EXPONENTIATION_EXPR &&\n            !(parent.type === \"BinaryExpression\" && parent.operator === \"**\" && parent.right === node) &&\n            !((parent.type === \"CallExpression\" || parent.type === \"NewExpression\") && parent.arguments.includes(node)) &&\n            !(parent.type === \"MemberExpression\" && parent.computed && parent.property === node) &&\n            !(parent.type === \"ArrayExpression\")\n        )\n    );\n\n    return needsParens && !astUtils$1.isParenthesised(sourceCode, node);\n}\n\n/**\n * Optionally parenthesizes given text.\n * @param {string} text The text to parenthesize.\n * @param {boolean} shouldParenthesize If `true`, the text will be parenthesised.\n * @returns {string} parenthesised or unchanged text.\n */\nfunction parenthesizeIfShould(text, shouldParenthesize) {\n    return shouldParenthesize ? `(${text})` : text;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar preferExponentiationOperator = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow the use of `Math.pow` in favor of the `**` operator\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/prefer-exponentiation-operator\"\n        },\n\n        schema: [],\n        fixable: \"code\",\n\n        messages: {\n            useExponentiation: \"Use the '**' operator instead of 'Math.pow'.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Reports the given node.\n         * @param {ASTNode} node 'Math.pow()' node to report.\n         * @returns {void}\n         */\n        function report(node) {\n            context.report({\n                node,\n                messageId: \"useExponentiation\",\n                fix(fixer) {\n                    if (\n                        node.arguments.length !== 2 ||\n                        node.arguments.some(arg => arg.type === \"SpreadElement\") ||\n                        sourceCode.getCommentsInside(node).length > 0\n                    ) {\n                        return null;\n                    }\n\n                    const base = node.arguments[0],\n                        exponent = node.arguments[1],\n                        baseText = sourceCode.getText(base),\n                        exponentText = sourceCode.getText(exponent),\n                        shouldParenthesizeBase = doesBaseNeedParens(base),\n                        shouldParenthesizeExponent = doesExponentNeedParens(exponent),\n                        shouldParenthesizeAll = doesExponentiationExpressionNeedParens(node, sourceCode);\n\n                    let prefix = \"\",\n                        suffix = \"\";\n\n                    if (!shouldParenthesizeAll) {\n                        if (!shouldParenthesizeBase) {\n                            const firstReplacementToken = sourceCode.getFirstToken(base),\n                                tokenBefore = sourceCode.getTokenBefore(node);\n\n                            if (\n                                tokenBefore &&\n                                tokenBefore.range[1] === node.range[0] &&\n                                !astUtils$1.canTokensBeAdjacent(tokenBefore, firstReplacementToken)\n                            ) {\n                                prefix = \" \"; // a+Math.pow(++b, c) -> a+ ++b**c\n                            }\n                        }\n                        if (!shouldParenthesizeExponent) {\n                            const lastReplacementToken = sourceCode.getLastToken(exponent),\n                                tokenAfter = sourceCode.getTokenAfter(node);\n\n                            if (\n                                tokenAfter &&\n                                node.range[1] === tokenAfter.range[0] &&\n                                !astUtils$1.canTokensBeAdjacent(lastReplacementToken, tokenAfter)\n                            ) {\n                                suffix = \" \"; // Math.pow(a, b)in c -> a**b in c\n                            }\n                        }\n                    }\n\n                    const baseReplacement = parenthesizeIfShould(baseText, shouldParenthesizeBase),\n                        exponentReplacement = parenthesizeIfShould(exponentText, shouldParenthesizeExponent),\n                        replacement = parenthesizeIfShould(`${baseReplacement}**${exponentReplacement}`, shouldParenthesizeAll);\n\n                    return fixer.replaceText(node, `${prefix}${replacement}${suffix}`);\n                }\n            });\n        }\n\n        return {\n            Program() {\n                const scope = context.getScope();\n                const tracker = new ReferenceTracker$3(scope);\n                const trackMap = {\n                    Math: {\n                        pow: { [CALL$3]: true }\n                    }\n                };\n\n                for (const { node } of tracker.iterateGlobalReferences(trackMap)) {\n                    report(node);\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nconst {\n    CALL: CALL$4,\n    CONSTRUCT: CONSTRUCT$2,\n    ReferenceTracker: ReferenceTracker$4,\n    getStringIfConstant: getStringIfConstant$2\n} = require$$0$2;\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst parser = new regexpp$1.RegExpParser();\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar preferNamedCaptureGroup = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce using named capture group in regular expression\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/prefer-named-capture-group\"\n        },\n\n        schema: [],\n\n        messages: {\n            required: \"Capture group '{{group}}' should be converted to a named or non-capturing group.\"\n        }\n    },\n\n    create(context) {\n\n        /**\n         * Function to check regular expression.\n         * @param {string} pattern The regular expression pattern to be check.\n         * @param {ASTNode} node AST node which contains regular expression.\n         * @param {boolean} uFlag Flag indicates whether unicode mode is enabled or not.\n         * @returns {void}\n         */\n        function checkRegex(pattern, node, uFlag) {\n            let ast;\n\n            try {\n                ast = parser.parsePattern(pattern, 0, pattern.length, uFlag);\n            } catch (_) {\n\n                // ignore regex syntax errors\n                return;\n            }\n\n            regexpp$1.visitRegExpAST(ast, {\n                onCapturingGroupEnter(group) {\n                    if (!group.name) {\n                        context.report({\n                            node,\n                            messageId: \"required\",\n                            data: {\n                                group: group.raw\n                            }\n                        });\n                    }\n                }\n            });\n        }\n\n        return {\n            Literal(node) {\n                if (node.regex) {\n                    checkRegex(node.regex.pattern, node, node.regex.flags.includes(\"u\"));\n                }\n            },\n            Program() {\n                const scope = context.getScope();\n                const tracker = new ReferenceTracker$4(scope);\n                const traceMap = {\n                    RegExp: {\n                        [CALL$4]: true,\n                        [CONSTRUCT$2]: true\n                    }\n                };\n\n                for (const { node } of tracker.iterateGlobalReferences(traceMap)) {\n                    const regex = getStringIfConstant$2(node.arguments[0]);\n                    const flags = getStringIfConstant$2(node.arguments[1]);\n\n                    if (regex) {\n                        checkRegex(regex, node, flags && flags.includes(\"u\"));\n                    }\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst radixMap = new Map([\n    [2, { system: \"binary\", literalPrefix: \"0b\" }],\n    [8, { system: \"octal\", literalPrefix: \"0o\" }],\n    [16, { system: \"hexadecimal\", literalPrefix: \"0x\" }]\n]);\n\n/**\n * Checks to see if a CallExpression's callee node is `parseInt` or\n * `Number.parseInt`.\n * @param {ASTNode} calleeNode The callee node to evaluate.\n * @returns {boolean} True if the callee is `parseInt` or `Number.parseInt`,\n * false otherwise.\n */\nfunction isParseInt(calleeNode) {\n    switch (calleeNode.type) {\n        case \"Identifier\":\n            return calleeNode.name === \"parseInt\";\n        case \"MemberExpression\":\n            return calleeNode.object.type === \"Identifier\" &&\n                calleeNode.object.name === \"Number\" &&\n                calleeNode.property.type === \"Identifier\" &&\n                calleeNode.property.name === \"parseInt\";\n\n        // no default\n    }\n\n    return false;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar preferNumericLiterals = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/prefer-numeric-literals\"\n        },\n\n        schema: [],\n\n        messages: {\n            useLiteral: \"Use {{system}} literals instead of {{functionName}}().\"\n        },\n\n        fixable: \"code\"\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        //----------------------------------------------------------------------\n        // Public\n        //----------------------------------------------------------------------\n\n        return {\n\n            \"CallExpression[arguments.length=2]\"(node) {\n                const [strNode, radixNode] = node.arguments,\n                    str = strNode.value,\n                    radix = radixNode.value;\n\n                if (\n                    strNode.type === \"Literal\" &&\n                    radixNode.type === \"Literal\" &&\n                    typeof str === \"string\" &&\n                    typeof radix === \"number\" &&\n                    radixMap.has(radix) &&\n                    isParseInt(node.callee)\n                ) {\n\n                    const { system, literalPrefix } = radixMap.get(radix);\n\n                    context.report({\n                        node,\n                        messageId: \"useLiteral\",\n                        data: {\n                            system,\n                            functionName: sourceCode.getText(node.callee)\n                        },\n                        fix(fixer) {\n                            if (sourceCode.getCommentsInside(node).length) {\n                                return null;\n                            }\n\n                            const replacement = `${literalPrefix}${str}`;\n\n                            if (+replacement !== parseInt(str, radix)) {\n\n                                /*\n                                 * If the newly-produced literal would be invalid, (e.g. 0b1234),\n                                 * or it would yield an incorrect parseInt result for some other reason, don't make a fix.\n                                 */\n                                return null;\n                            }\n\n                            const tokenBefore = sourceCode.getTokenBefore(node),\n                                tokenAfter = sourceCode.getTokenAfter(node);\n                            let prefix = \"\",\n                                suffix = \"\";\n\n                            if (\n                                tokenBefore &&\n                                tokenBefore.range[1] === node.range[0] &&\n                                !astUtils$1.canTokensBeAdjacent(tokenBefore, replacement)\n                            ) {\n                                prefix = \" \";\n                            }\n\n                            if (\n                                tokenAfter &&\n                                node.range[1] === tokenAfter.range[0] &&\n                                !astUtils$1.canTokensBeAdjacent(replacement, tokenAfter)\n                            ) {\n                                suffix = \" \";\n                            }\n\n                            return fixer.replaceText(node, `${prefix}${replacement}${suffix}`);\n                        }\n                    });\n                }\n            }\n        };\n    }\n};\n\nconst { CALL: CALL$5, ReferenceTracker: ReferenceTracker$5 } = require$$0$2;\nconst {\n    isCommaToken: isCommaToken$1,\n    isOpeningParenToken: isOpeningParenToken$1,\n    isClosingParenToken: isClosingParenToken$1,\n    isParenthesised\n} = astUtils$1;\n\nconst ANY_SPACE = /\\s/u;\n\n/**\n * Helper that checks if the Object.assign call has array spread\n * @param {ASTNode} node The node that the rule warns on\n * @returns {boolean} - Returns true if the Object.assign call has array spread\n */\nfunction hasArraySpread(node) {\n    return node.arguments.some(arg => arg.type === \"SpreadElement\");\n}\n\n/**\n * Helper that checks if the node needs parentheses to be valid JS.\n * The default is to wrap the node in parentheses to avoid parsing errors.\n * @param {ASTNode} node The node that the rule warns on\n * @param {Object} sourceCode in context sourcecode object\n * @returns {boolean} - Returns true if the node needs parentheses\n */\nfunction needsParens(node, sourceCode) {\n    const parent = node.parent;\n\n    switch (parent.type) {\n        case \"VariableDeclarator\":\n        case \"ArrayExpression\":\n        case \"ReturnStatement\":\n        case \"CallExpression\":\n        case \"Property\":\n            return false;\n        case \"AssignmentExpression\":\n            return parent.left === node && !isParenthesised(sourceCode, node);\n        default:\n            return !isParenthesised(sourceCode, node);\n    }\n}\n\n/**\n * Determines if an argument needs parentheses. The default is to not add parens.\n * @param {ASTNode} node The node to be checked.\n * @param {Object} sourceCode in context sourcecode object\n * @returns {boolean} True if the node needs parentheses\n */\nfunction argNeedsParens(node, sourceCode) {\n    switch (node.type) {\n        case \"AssignmentExpression\":\n        case \"ArrowFunctionExpression\":\n        case \"ConditionalExpression\":\n            return !isParenthesised(sourceCode, node);\n        default:\n            return false;\n    }\n}\n\n/**\n * Get the parenthesis tokens of a given ObjectExpression node.\n * This incldues the braces of the object literal and enclosing parentheses.\n * @param {ASTNode} node The node to get.\n * @param {Token} leftArgumentListParen The opening paren token of the argument list.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {Token[]} The parenthesis tokens of the node. This is sorted by the location.\n */\nfunction getParenTokens(node, leftArgumentListParen, sourceCode) {\n    const parens = [sourceCode.getFirstToken(node), sourceCode.getLastToken(node)];\n    let leftNext = sourceCode.getTokenBefore(node);\n    let rightNext = sourceCode.getTokenAfter(node);\n\n    // Note: don't include the parens of the argument list.\n    while (\n        leftNext &&\n        rightNext &&\n        leftNext.range[0] > leftArgumentListParen.range[0] &&\n        isOpeningParenToken$1(leftNext) &&\n        isClosingParenToken$1(rightNext)\n    ) {\n        parens.push(leftNext, rightNext);\n        leftNext = sourceCode.getTokenBefore(leftNext);\n        rightNext = sourceCode.getTokenAfter(rightNext);\n    }\n\n    return parens.sort((a, b) => a.range[0] - b.range[0]);\n}\n\n/**\n * Get the range of a given token and around whitespaces.\n * @param {Token} token The token to get range.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {number} The end of the range of the token and around whitespaces.\n */\nfunction getStartWithSpaces(token, sourceCode) {\n    const text = sourceCode.text;\n    let start = token.range[0];\n\n    // If the previous token is a line comment then skip this step to avoid commenting this token out.\n    {\n        const prevToken = sourceCode.getTokenBefore(token, { includeComments: true });\n\n        if (prevToken && prevToken.type === \"Line\") {\n            return start;\n        }\n    }\n\n    // Detect spaces before the token.\n    while (ANY_SPACE.test(text[start - 1] || \"\")) {\n        start -= 1;\n    }\n\n    return start;\n}\n\n/**\n * Get the range of a given token and around whitespaces.\n * @param {Token} token The token to get range.\n * @param {SourceCode} sourceCode The source code object to get tokens.\n * @returns {number} The start of the range of the token and around whitespaces.\n */\nfunction getEndWithSpaces(token, sourceCode) {\n    const text = sourceCode.text;\n    let end = token.range[1];\n\n    // Detect spaces after the token.\n    while (ANY_SPACE.test(text[end] || \"\")) {\n        end += 1;\n    }\n\n    return end;\n}\n\n/**\n * Autofixes the Object.assign call to use an object spread instead.\n * @param {ASTNode|null} node The node that the rule warns on, i.e. the Object.assign call\n * @param {string} sourceCode sourceCode of the Object.assign call\n * @returns {Function} autofixer - replaces the Object.assign with a spread object.\n */\nfunction defineFixer(node, sourceCode) {\n    return function *(fixer) {\n        const leftParen = sourceCode.getTokenAfter(node.callee, isOpeningParenToken$1);\n        const rightParen = sourceCode.getLastToken(node);\n\n        // Remove the callee `Object.assign`\n        yield fixer.remove(node.callee);\n\n        // Replace the parens of argument list to braces.\n        if (needsParens(node, sourceCode)) {\n            yield fixer.replaceText(leftParen, \"({\");\n            yield fixer.replaceText(rightParen, \"})\");\n        } else {\n            yield fixer.replaceText(leftParen, \"{\");\n            yield fixer.replaceText(rightParen, \"}\");\n        }\n\n        // Process arguments.\n        for (const argNode of node.arguments) {\n            const innerParens = getParenTokens(argNode, leftParen, sourceCode);\n            const left = innerParens.shift();\n            const right = innerParens.pop();\n\n            if (argNode.type === \"ObjectExpression\") {\n                const maybeTrailingComma = sourceCode.getLastToken(argNode, 1);\n                const maybeArgumentComma = sourceCode.getTokenAfter(right);\n\n                /*\n                 * Make bare this object literal.\n                 * And remove spaces inside of the braces for better formatting.\n                 */\n                for (const innerParen of innerParens) {\n                    yield fixer.remove(innerParen);\n                }\n                const leftRange = [left.range[0], getEndWithSpaces(left, sourceCode)];\n                const rightRange = [\n                    Math.max(getStartWithSpaces(right, sourceCode), leftRange[1]), // Ensure ranges don't overlap\n                    right.range[1]\n                ];\n\n                yield fixer.removeRange(leftRange);\n                yield fixer.removeRange(rightRange);\n\n                // Remove the comma of this argument if it's duplication.\n                if (\n                    (argNode.properties.length === 0 || isCommaToken$1(maybeTrailingComma)) &&\n                    isCommaToken$1(maybeArgumentComma)\n                ) {\n                    yield fixer.remove(maybeArgumentComma);\n                }\n            } else {\n\n                // Make spread.\n                if (argNeedsParens(argNode, sourceCode)) {\n                    yield fixer.insertTextBefore(left, \"...(\");\n                    yield fixer.insertTextAfter(right, \")\");\n                } else {\n                    yield fixer.insertTextBefore(left, \"...\");\n                }\n            }\n        }\n    };\n}\n\nvar preferObjectSpread = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description:\n                \"disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead.\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/prefer-object-spread\"\n        },\n\n        schema: [],\n        fixable: \"code\",\n\n        messages: {\n            useSpreadMessage: \"Use an object spread instead of `Object.assign` eg: `{ ...foo }`.\",\n            useLiteralMessage: \"Use an object literal instead of `Object.assign`. eg: `{ foo: bar }`.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        return {\n            Program() {\n                const scope = context.getScope();\n                const tracker = new ReferenceTracker$5(scope);\n                const trackMap = {\n                    Object: {\n                        assign: { [CALL$5]: true }\n                    }\n                };\n\n                // Iterate all calls of `Object.assign` (only of the global variable `Object`).\n                for (const { node } of tracker.iterateGlobalReferences(trackMap)) {\n                    if (\n                        node.arguments.length >= 1 &&\n                        node.arguments[0].type === \"ObjectExpression\" &&\n                        !hasArraySpread(node)\n                    ) {\n                        const messageId = node.arguments.length === 1\n                            ? \"useLiteralMessage\"\n                            : \"useSpreadMessage\";\n                        const fix = defineFixer(node, sourceCode);\n\n                        context.report({ node, messageId, fix });\n                    }\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar preferPromiseRejectErrors = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require using Error objects as Promise rejection reasons\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/prefer-promise-reject-errors\"\n        },\n\n        fixable: null,\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    allowEmptyReject: { type: \"boolean\", default: false }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n\n        const ALLOW_EMPTY_REJECT = context.options.length && context.options[0].allowEmptyReject;\n\n        //----------------------------------------------------------------------\n        // Helpers\n        //----------------------------------------------------------------------\n\n        /**\n         * Checks the argument of a reject() or Promise.reject() CallExpression, and reports it if it can't be an Error\n         * @param {ASTNode} callExpression A CallExpression node which is used to reject a Promise\n         * @returns {void}\n         */\n        function checkRejectCall(callExpression) {\n            if (!callExpression.arguments.length && ALLOW_EMPTY_REJECT) {\n                return;\n            }\n            if (\n                !callExpression.arguments.length ||\n                !astUtils$1.couldBeError(callExpression.arguments[0]) ||\n                callExpression.arguments[0].type === \"Identifier\" && callExpression.arguments[0].name === \"undefined\"\n            ) {\n                context.report({\n                    node: callExpression,\n                    message: \"Expected the Promise rejection reason to be an Error.\"\n                });\n            }\n        }\n\n        /**\n         * Determines whether a function call is a Promise.reject() call\n         * @param {ASTNode} node A CallExpression node\n         * @returns {boolean} `true` if the call is a Promise.reject() call\n         */\n        function isPromiseRejectCall(node) {\n            return node.callee.type === \"MemberExpression\" &&\n                node.callee.object.type === \"Identifier\" && node.callee.object.name === \"Promise\" &&\n                node.callee.property.type === \"Identifier\" && node.callee.property.name === \"reject\";\n        }\n\n        //----------------------------------------------------------------------\n        // Public\n        //----------------------------------------------------------------------\n\n        return {\n\n            // Check `Promise.reject(value)` calls.\n            CallExpression(node) {\n                if (isPromiseRejectCall(node)) {\n                    checkRejectCall(node);\n                }\n            },\n\n            /*\n             * Check for `new Promise((resolve, reject) => {})`, and check for reject() calls.\n             * This function is run on \"NewExpression:exit\" instead of \"NewExpression\" to ensure that\n             * the nodes in the expression already have the `parent` property.\n             */\n            \"NewExpression:exit\"(node) {\n                if (\n                    node.callee.type === \"Identifier\" && node.callee.name === \"Promise\" &&\n                    node.arguments.length && astUtils$1.isFunction(node.arguments[0]) &&\n                    node.arguments[0].params.length > 1 && node.arguments[0].params[1].type === \"Identifier\"\n                ) {\n                    context.getDeclaredVariables(node.arguments[0])\n\n                        /*\n                         * Find the first variable that matches the second parameter's name.\n                         * If the first parameter has the same name as the second parameter, then the variable will actually\n                         * be \"declared\" when the first parameter is evaluated, but then it will be immediately overwritten\n                         * by the second parameter. It's not possible for an expression with the variable to be evaluated before\n                         * the variable is overwritten, because functions with duplicate parameters cannot have destructuring or\n                         * default assignments in their parameter lists. Therefore, it's not necessary to explicitly account for\n                         * this case.\n                         */\n                        .find(variable => variable.name === node.arguments[0].params[1].name)\n\n                        // Get the references to that variable.\n                        .references\n\n                        // Only check the references that read the parameter's value.\n                        .filter(ref => ref.isRead())\n\n                        // Only check the references that are used as the callee in a function call, e.g. `reject(foo)`.\n                        .filter(ref => ref.identifier.parent.type === \"CallExpression\" && ref.identifier === ref.identifier.parent.callee)\n\n                        // Check the argument of the function call to determine whether it's an Error.\n                        .forEach(ref => checkRejectCall(ref.identifier.parent));\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to suggest using \"Reflect\" api over Function/Object methods\n * @author Keith Cirkel <http://keithcirkel.co.uk>\n * @deprecated in ESLint v3.9.0\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar preferReflect = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require `Reflect` methods where applicable\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/prefer-reflect\"\n        },\n\n        deprecated: true,\n\n        replacedBy: [],\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    exceptions: {\n                        type: \"array\",\n                        items: {\n                            enum: [\n                                \"apply\",\n                                \"call\",\n                                \"delete\",\n                                \"defineProperty\",\n                                \"getOwnPropertyDescriptor\",\n                                \"getPrototypeOf\",\n                                \"setPrototypeOf\",\n                                \"isExtensible\",\n                                \"getOwnPropertyNames\",\n                                \"preventExtensions\"\n                            ]\n                        },\n                        uniqueItems: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const existingNames = {\n            apply: \"Function.prototype.apply\",\n            call: \"Function.prototype.call\",\n            defineProperty: \"Object.defineProperty\",\n            getOwnPropertyDescriptor: \"Object.getOwnPropertyDescriptor\",\n            getPrototypeOf: \"Object.getPrototypeOf\",\n            setPrototypeOf: \"Object.setPrototypeOf\",\n            isExtensible: \"Object.isExtensible\",\n            getOwnPropertyNames: \"Object.getOwnPropertyNames\",\n            preventExtensions: \"Object.preventExtensions\"\n        };\n\n        const reflectSubsitutes = {\n            apply: \"Reflect.apply\",\n            call: \"Reflect.apply\",\n            defineProperty: \"Reflect.defineProperty\",\n            getOwnPropertyDescriptor: \"Reflect.getOwnPropertyDescriptor\",\n            getPrototypeOf: \"Reflect.getPrototypeOf\",\n            setPrototypeOf: \"Reflect.setPrototypeOf\",\n            isExtensible: \"Reflect.isExtensible\",\n            getOwnPropertyNames: \"Reflect.getOwnPropertyNames\",\n            preventExtensions: \"Reflect.preventExtensions\"\n        };\n\n        const exceptions = (context.options[0] || {}).exceptions || [];\n\n        /**\n         * Reports the Reflect violation based on the `existing` and `substitute`\n         * @param {Object} node The node that violates the rule.\n         * @param {string} existing The existing method name that has been used.\n         * @param {string} substitute The Reflect substitute that should be used.\n         * @returns {void}\n         */\n        function report(node, existing, substitute) {\n            context.report({\n                node,\n                message: \"Avoid using {{existing}}, instead use {{substitute}}.\",\n                data: {\n                    existing,\n                    substitute\n                }\n            });\n        }\n\n        return {\n            CallExpression(node) {\n                const methodName = (node.callee.property || {}).name;\n                const isReflectCall = (node.callee.object || {}).name === \"Reflect\";\n                const hasReflectSubsitute = Object.prototype.hasOwnProperty.call(reflectSubsitutes, methodName);\n                const userConfiguredException = exceptions.indexOf(methodName) !== -1;\n\n                if (hasReflectSubsitute && !isReflectCall && !userConfiguredException) {\n                    report(node, existingNames[methodName], reflectSubsitutes[methodName]);\n                }\n            },\n            UnaryExpression(node) {\n                const isDeleteOperator = node.operator === \"delete\";\n                const targetsIdentifier = node.argument.type === \"Identifier\";\n                const userConfiguredException = exceptions.indexOf(\"delete\") !== -1;\n\n                if (isDeleteOperator && !targetsIdentifier && !userConfiguredException) {\n                    report(node, \"the delete keyword\", \"Reflect.deleteProperty\");\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\nconst { CALL: CALL$6, CONSTRUCT: CONSTRUCT$3, ReferenceTracker: ReferenceTracker$6, findVariable: findVariable$3 } = require$$0$2;\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Determines whether the given node is a string literal.\n * @param {ASTNode} node Node to check.\n * @returns {boolean} True if the node is a string literal.\n */\nfunction isStringLiteral(node) {\n    return node.type === \"Literal\" && typeof node.value === \"string\";\n}\n\n/**\n * Determines whether the given node is a template literal without expressions.\n * @param {ASTNode} node Node to check.\n * @returns {boolean} True if the node is a template literal without expressions.\n */\nfunction isStaticTemplateLiteral(node) {\n    return node.type === \"TemplateLiteral\" && node.expressions.length === 0;\n}\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar preferRegexLiterals = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow use of the `RegExp` constructor in favor of regular expression literals\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/prefer-regex-literals\"\n        },\n\n        schema: [],\n\n        messages: {\n            unexpectedRegExp: \"Use a regular expression literal instead of the 'RegExp' constructor.\"\n        }\n    },\n\n    create(context) {\n\n        /**\n         * Determines whether the given identifier node is a reference to a global variable.\n         * @param {ASTNode} node `Identifier` node to check.\n         * @returns {boolean} True if the identifier is a reference to a global variable.\n         */\n        function isGlobalReference(node) {\n            const scope = context.getScope();\n            const variable = findVariable$3(scope, node);\n\n            return variable !== null && variable.scope.type === \"global\" && variable.defs.length === 0;\n        }\n\n        /**\n         * Determines whether the given node is a String.raw`` tagged template expression\n         * with a static template literal.\n         * @param {ASTNode} node Node to check.\n         * @returns {boolean} True if the node is String.raw`` with a static template.\n         */\n        function isStringRawTaggedStaticTemplateLiteral(node) {\n            return node.type === \"TaggedTemplateExpression\" &&\n                node.tag.type === \"MemberExpression\" &&\n                node.tag.object.type === \"Identifier\" &&\n                node.tag.object.name === \"String\" &&\n                isGlobalReference(node.tag.object) &&\n                astUtils$1.getStaticPropertyName(node.tag) === \"raw\" &&\n                isStaticTemplateLiteral(node.quasi);\n        }\n\n        /**\n         * Determines whether the given node is considered to be a static string by the logic of this rule.\n         * @param {ASTNode} node Node to check.\n         * @returns {boolean} True if the node is a static string.\n         */\n        function isStaticString(node) {\n            return isStringLiteral(node) ||\n                isStaticTemplateLiteral(node) ||\n                isStringRawTaggedStaticTemplateLiteral(node);\n        }\n\n        return {\n            Program() {\n                const scope = context.getScope();\n                const tracker = new ReferenceTracker$6(scope);\n                const traceMap = {\n                    RegExp: {\n                        [CALL$6]: true,\n                        [CONSTRUCT$3]: true\n                    }\n                };\n\n                for (const { node } of tracker.iterateGlobalReferences(traceMap)) {\n                    const args = node.arguments;\n\n                    if (\n                        (args.length === 1 || args.length === 2) &&\n                        args.every(isStaticString)\n                    ) {\n                        context.report({ node, messageId: \"unexpectedRegExp\" });\n                    }\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to\n * @author Toru Nagashima\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Gets the variable object of `arguments` which is defined implicitly.\n * @param {eslint-scope.Scope} scope A scope to get.\n * @returns {eslint-scope.Variable} The found variable object.\n */\nfunction getVariableOfArguments$1(scope) {\n    const variables = scope.variables;\n\n    for (let i = 0; i < variables.length; ++i) {\n        const variable = variables[i];\n\n        if (variable.name === \"arguments\") {\n\n            /*\n             * If there was a parameter which is named \"arguments\", the implicit \"arguments\" is not defined.\n             * So does fast return with null.\n             */\n            return (variable.identifiers.length === 0) ? variable : null;\n        }\n    }\n\n    /* istanbul ignore next : unreachable */\n    return null;\n}\n\n/**\n * Checks if the given reference is not normal member access.\n *\n * - arguments         .... true    // not member access\n * - arguments[i]      .... true    // computed member access\n * - arguments[0]      .... true    // computed member access\n * - arguments.length  .... false   // normal member access\n * @param {eslint-scope.Reference} reference The reference to check.\n * @returns {boolean} `true` if the reference is not normal member access.\n */\nfunction isNotNormalMemberAccess(reference) {\n    const id = reference.identifier;\n    const parent = id.parent;\n\n    return !(\n        parent.type === \"MemberExpression\" &&\n        parent.object === id &&\n        !parent.computed\n    );\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar preferRestParams = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require rest parameters instead of `arguments`\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/prefer-rest-params\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n\n        /**\n         * Reports a given reference.\n         * @param {eslint-scope.Reference} reference A reference to report.\n         * @returns {void}\n         */\n        function report(reference) {\n            context.report({\n                node: reference.identifier,\n                loc: reference.identifier.loc,\n                message: \"Use the rest parameters instead of 'arguments'.\"\n            });\n        }\n\n        /**\n         * Reports references of the implicit `arguments` variable if exist.\n         * @returns {void}\n         */\n        function checkForArguments() {\n            const argumentsVar = getVariableOfArguments$1(context.getScope());\n\n            if (argumentsVar) {\n                argumentsVar\n                    .references\n                    .filter(isNotNormalMemberAccess)\n                    .forEach(report);\n            }\n        }\n\n        return {\n            \"FunctionDeclaration:exit\": checkForArguments,\n            \"FunctionExpression:exit\": checkForArguments\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not a node is a `.apply()` for variadic.\n * @param {ASTNode} node A CallExpression node to check.\n * @returns {boolean} Whether or not the node is a `.apply()` for variadic.\n */\nfunction isVariadicApplyCalling(node) {\n    return (\n        node.callee.type === \"MemberExpression\" &&\n        node.callee.property.type === \"Identifier\" &&\n        node.callee.property.name === \"apply\" &&\n        node.callee.computed === false &&\n        node.arguments.length === 2 &&\n        node.arguments[1].type !== \"ArrayExpression\" &&\n        node.arguments[1].type !== \"SpreadElement\"\n    );\n}\n\n\n/**\n * Checks whether or not `thisArg` is not changed by `.apply()`.\n * @param {ASTNode|null} expectedThis The node that is the owner of the applied function.\n * @param {ASTNode} thisArg The node that is given to the first argument of the `.apply()`.\n * @param {RuleContext} context The ESLint rule context object.\n * @returns {boolean} Whether or not `thisArg` is not changed by `.apply()`.\n */\nfunction isValidThisArg$1(expectedThis, thisArg, context) {\n    if (!expectedThis) {\n        return astUtils$1.isNullOrUndefined(thisArg);\n    }\n    return astUtils$1.equalTokens(expectedThis, thisArg, context);\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar preferSpread = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require spread operators instead of `.apply()`\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/prefer-spread\"\n        },\n\n        schema: [],\n        fixable: null\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        return {\n            CallExpression(node) {\n                if (!isVariadicApplyCalling(node)) {\n                    return;\n                }\n\n                const applied = node.callee.object;\n                const expectedThis = (applied.type === \"MemberExpression\") ? applied.object : null;\n                const thisArg = node.arguments[0];\n\n                if (isValidThisArg$1(expectedThis, thisArg, sourceCode)) {\n                    context.report({\n                        node,\n                        message: \"Use the spread operator instead of '.apply()'.\"\n                    });\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not a given node is a concatenation.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} `true` if the node is a concatenation.\n */\nfunction isConcatenation$1(node) {\n    return node.type === \"BinaryExpression\" && node.operator === \"+\";\n}\n\n/**\n * Gets the top binary expression node for concatenation in parents of a given node.\n * @param {ASTNode} node A node to get.\n * @returns {ASTNode} the top binary expression node in parents of a given node.\n */\nfunction getTopConcatBinaryExpression(node) {\n    let currentNode = node;\n\n    while (isConcatenation$1(currentNode.parent)) {\n        currentNode = currentNode.parent;\n    }\n    return currentNode;\n}\n\n/**\n * Determines whether a given node is a octal escape sequence\n * @param {ASTNode} node A node to check\n * @returns {boolean} `true` if the node is an octal escape sequence\n */\nfunction isOctalEscapeSequence(node) {\n\n    // No need to check TemplateLiterals – would throw error with octal escape\n    const isStringLiteral = node.type === \"Literal\" && typeof node.value === \"string\";\n\n    if (!isStringLiteral) {\n        return false;\n    }\n\n    return astUtils$1.hasOctalEscapeSequence(node.raw);\n}\n\n/**\n * Checks whether or not a node contains a octal escape sequence\n * @param {ASTNode} node A node to check\n * @returns {boolean} `true` if the node contains an octal escape sequence\n */\nfunction hasOctalEscapeSequence(node) {\n    if (isConcatenation$1(node)) {\n        return hasOctalEscapeSequence(node.left) || hasOctalEscapeSequence(node.right);\n    }\n\n    return isOctalEscapeSequence(node);\n}\n\n/**\n * Checks whether or not a given binary expression has string literals.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} `true` if the node has string literals.\n */\nfunction hasStringLiteral(node) {\n    if (isConcatenation$1(node)) {\n\n        // `left` is deeper than `right` normally.\n        return hasStringLiteral(node.right) || hasStringLiteral(node.left);\n    }\n    return astUtils$1.isStringLiteral(node);\n}\n\n/**\n * Checks whether or not a given binary expression has non string literals.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} `true` if the node has non string literals.\n */\nfunction hasNonStringLiteral(node) {\n    if (isConcatenation$1(node)) {\n\n        // `left` is deeper than `right` normally.\n        return hasNonStringLiteral(node.right) || hasNonStringLiteral(node.left);\n    }\n    return !astUtils$1.isStringLiteral(node);\n}\n\n/**\n * Determines whether a given node will start with a template curly expression (`${}`) when being converted to a template literal.\n * @param {ASTNode} node The node that will be fixed to a template literal\n * @returns {boolean} `true` if the node will start with a template curly.\n */\nfunction startsWithTemplateCurly(node) {\n    if (node.type === \"BinaryExpression\") {\n        return startsWithTemplateCurly(node.left);\n    }\n    if (node.type === \"TemplateLiteral\") {\n        return node.expressions.length && node.quasis.length && node.quasis[0].range[0] === node.quasis[0].range[1];\n    }\n    return node.type !== \"Literal\" || typeof node.value !== \"string\";\n}\n\n/**\n * Determines whether a given node end with a template curly expression (`${}`) when being converted to a template literal.\n * @param {ASTNode} node The node that will be fixed to a template literal\n * @returns {boolean} `true` if the node will end with a template curly.\n */\nfunction endsWithTemplateCurly(node) {\n    if (node.type === \"BinaryExpression\") {\n        return startsWithTemplateCurly(node.right);\n    }\n    if (node.type === \"TemplateLiteral\") {\n        return node.expressions.length && node.quasis.length && node.quasis[node.quasis.length - 1].range[0] === node.quasis[node.quasis.length - 1].range[1];\n    }\n    return node.type !== \"Literal\" || typeof node.value !== \"string\";\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar preferTemplate = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require template literals instead of string concatenation\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/prefer-template\"\n        },\n\n        schema: [],\n        fixable: \"code\"\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        let done = Object.create(null);\n\n        /**\n         * Gets the non-token text between two nodes, ignoring any other tokens that appear between the two tokens.\n         * @param {ASTNode} node1 The first node\n         * @param {ASTNode} node2 The second node\n         * @returns {string} The text between the nodes, excluding other tokens\n         */\n        function getTextBetween(node1, node2) {\n            const allTokens = [node1].concat(sourceCode.getTokensBetween(node1, node2)).concat(node2);\n            const sourceText = sourceCode.getText();\n\n            return allTokens.slice(0, -1).reduce((accumulator, token, index) => accumulator + sourceText.slice(token.range[1], allTokens[index + 1].range[0]), \"\");\n        }\n\n        /**\n         * Returns a template literal form of the given node.\n         * @param {ASTNode} currentNode A node that should be converted to a template literal\n         * @param {string} textBeforeNode Text that should appear before the node\n         * @param {string} textAfterNode Text that should appear after the node\n         * @returns {string} A string form of this node, represented as a template literal\n         */\n        function getTemplateLiteral(currentNode, textBeforeNode, textAfterNode) {\n            if (currentNode.type === \"Literal\" && typeof currentNode.value === \"string\") {\n\n                /*\n                 * If the current node is a string literal, escape any instances of ${ or ` to prevent them from being interpreted\n                 * as a template placeholder. However, if the code already contains a backslash before the ${ or `\n                 * for some reason, don't add another backslash, because that would change the meaning of the code (it would cause\n                 * an actual backslash character to appear before the dollar sign).\n                 */\n                return `\\`${currentNode.raw.slice(1, -1).replace(/\\\\*(\\$\\{|`)/gu, matched => {\n                    if (matched.lastIndexOf(\"\\\\\") % 2) {\n                        return `\\\\${matched}`;\n                    }\n                    return matched;\n\n                // Unescape any quotes that appear in the original Literal that no longer need to be escaped.\n                }).replace(new RegExp(`\\\\\\\\${currentNode.raw[0]}`, \"gu\"), currentNode.raw[0])}\\``;\n            }\n\n            if (currentNode.type === \"TemplateLiteral\") {\n                return sourceCode.getText(currentNode);\n            }\n\n            if (isConcatenation$1(currentNode) && hasStringLiteral(currentNode) && hasNonStringLiteral(currentNode)) {\n                const plusSign = sourceCode.getFirstTokenBetween(currentNode.left, currentNode.right, token => token.value === \"+\");\n                const textBeforePlus = getTextBetween(currentNode.left, plusSign);\n                const textAfterPlus = getTextBetween(plusSign, currentNode.right);\n                const leftEndsWithCurly = endsWithTemplateCurly(currentNode.left);\n                const rightStartsWithCurly = startsWithTemplateCurly(currentNode.right);\n\n                if (leftEndsWithCurly) {\n\n                    // If the left side of the expression ends with a template curly, add the extra text to the end of the curly bracket.\n                    // `foo${bar}` /* comment */ + 'baz' --> `foo${bar /* comment */  }${baz}`\n                    return getTemplateLiteral(currentNode.left, textBeforeNode, textBeforePlus + textAfterPlus).slice(0, -1) +\n                        getTemplateLiteral(currentNode.right, null, textAfterNode).slice(1);\n                }\n                if (rightStartsWithCurly) {\n\n                    // Otherwise, if the right side of the expression starts with a template curly, add the text there.\n                    // 'foo' /* comment */ + `${bar}baz` --> `foo${ /* comment */  bar}baz`\n                    return getTemplateLiteral(currentNode.left, textBeforeNode, null).slice(0, -1) +\n                        getTemplateLiteral(currentNode.right, textBeforePlus + textAfterPlus, textAfterNode).slice(1);\n                }\n\n                /*\n                 * Otherwise, these nodes should not be combined into a template curly, since there is nowhere to put\n                 * the text between them.\n                 */\n                return `${getTemplateLiteral(currentNode.left, textBeforeNode, null)}${textBeforePlus}+${textAfterPlus}${getTemplateLiteral(currentNode.right, textAfterNode, null)}`;\n            }\n\n            return `\\`\\${${textBeforeNode || \"\"}${sourceCode.getText(currentNode)}${textAfterNode || \"\"}}\\``;\n        }\n\n        /**\n         * Returns a fixer object that converts a non-string binary expression to a template literal\n         * @param {SourceCodeFixer} fixer The fixer object\n         * @param {ASTNode} node A node that should be converted to a template literal\n         * @returns {Object} A fix for this binary expression\n         */\n        function fixNonStringBinaryExpression(fixer, node) {\n            const topBinaryExpr = getTopConcatBinaryExpression(node.parent);\n\n            if (hasOctalEscapeSequence(topBinaryExpr)) {\n                return null;\n            }\n\n            return fixer.replaceText(topBinaryExpr, getTemplateLiteral(topBinaryExpr, null, null));\n        }\n\n        /**\n         * Reports if a given node is string concatenation with non string literals.\n         * @param {ASTNode} node A node to check.\n         * @returns {void}\n         */\n        function checkForStringConcat(node) {\n            if (!astUtils$1.isStringLiteral(node) || !isConcatenation$1(node.parent)) {\n                return;\n            }\n\n            const topBinaryExpr = getTopConcatBinaryExpression(node.parent);\n\n            // Checks whether or not this node had been checked already.\n            if (done[topBinaryExpr.range[0]]) {\n                return;\n            }\n            done[topBinaryExpr.range[0]] = true;\n\n            if (hasNonStringLiteral(topBinaryExpr)) {\n                context.report({\n                    node: topBinaryExpr,\n                    message: \"Unexpected string concatenation.\",\n                    fix: fixer => fixNonStringBinaryExpression(fixer, node)\n                });\n            }\n        }\n\n        return {\n            Program() {\n                done = Object.create(null);\n            },\n\n            Literal: checkForStringConcat,\n            TemplateLiteral: checkForStringConcat\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar quoteProps = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require quotes around object literal property names\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/quote-props\"\n        },\n\n        schema: {\n            anyOf: [\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"always\", \"as-needed\", \"consistent\", \"consistent-as-needed\"]\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 1\n                },\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"always\", \"as-needed\", \"consistent\", \"consistent-as-needed\"]\n                        },\n                        {\n                            type: \"object\",\n                            properties: {\n                                keywords: {\n                                    type: \"boolean\"\n                                },\n                                unnecessary: {\n                                    type: \"boolean\"\n                                },\n                                numbers: {\n                                    type: \"boolean\"\n                                }\n                            },\n                            additionalProperties: false\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 2\n                }\n            ]\n        },\n\n        fixable: \"code\"\n    },\n\n    create(context) {\n\n        const MODE = context.options[0],\n            KEYWORDS = context.options[1] && context.options[1].keywords,\n            CHECK_UNNECESSARY = !context.options[1] || context.options[1].unnecessary !== false,\n            NUMBERS = context.options[1] && context.options[1].numbers,\n\n            MESSAGE_UNNECESSARY = \"Unnecessarily quoted property '{{property}}' found.\",\n            MESSAGE_UNQUOTED = \"Unquoted property '{{property}}' found.\",\n            MESSAGE_NUMERIC = \"Unquoted number literal '{{property}}' used as key.\",\n            MESSAGE_RESERVED = \"Unquoted reserved word '{{property}}' used as key.\",\n            sourceCode = context.getSourceCode();\n\n\n        /**\n         * Checks whether a certain string constitutes an ES3 token\n         * @param   {string} tokenStr The string to be checked.\n         * @returns {boolean} `true` if it is an ES3 token.\n         */\n        function isKeyword(tokenStr) {\n            return keywords$3.indexOf(tokenStr) >= 0;\n        }\n\n        /**\n         * Checks if an espree-tokenized key has redundant quotes (i.e. whether quotes are unnecessary)\n         * @param   {string} rawKey The raw key value from the source\n         * @param   {espreeTokens} tokens The espree-tokenized node key\n         * @param   {boolean} [skipNumberLiterals=false] Indicates whether number literals should be checked\n         * @returns {boolean} Whether or not a key has redundant quotes.\n         * @private\n         */\n        function areQuotesRedundant(rawKey, tokens, skipNumberLiterals) {\n            return tokens.length === 1 && tokens[0].start === 0 && tokens[0].end === rawKey.length &&\n                ([\"Identifier\", \"Keyword\", \"Null\", \"Boolean\"].indexOf(tokens[0].type) >= 0 ||\n                (tokens[0].type === \"Numeric\" && !skipNumberLiterals && String(+tokens[0].value) === tokens[0].value));\n        }\n\n        /**\n         * Returns a string representation of a property node with quotes removed\n         * @param {ASTNode} key Key AST Node, which may or may not be quoted\n         * @returns {string} A replacement string for this property\n         */\n        function getUnquotedKey(key) {\n            return key.type === \"Identifier\" ? key.name : key.value;\n        }\n\n        /**\n         * Returns a string representation of a property node with quotes added\n         * @param {ASTNode} key Key AST Node, which may or may not be quoted\n         * @returns {string} A replacement string for this property\n         */\n        function getQuotedKey(key) {\n            if (key.type === \"Literal\" && typeof key.value === \"string\") {\n\n                // If the key is already a string literal, don't replace the quotes with double quotes.\n                return sourceCode.getText(key);\n            }\n\n            // Otherwise, the key is either an identifier or a number literal.\n            return `\"${key.type === \"Identifier\" ? key.name : key.value}\"`;\n        }\n\n        /**\n         * Ensures that a property's key is quoted only when necessary\n         * @param   {ASTNode} node Property AST node\n         * @returns {void}\n         */\n        function checkUnnecessaryQuotes(node) {\n            const key = node.key;\n\n            if (node.method || node.computed || node.shorthand) {\n                return;\n            }\n\n            if (key.type === \"Literal\" && typeof key.value === \"string\") {\n                let tokens;\n\n                try {\n                    tokens = espree_1.tokenize(key.value);\n                } catch (e) {\n                    return;\n                }\n\n                if (tokens.length !== 1) {\n                    return;\n                }\n\n                const isKeywordToken = isKeyword(tokens[0].value);\n\n                if (isKeywordToken && KEYWORDS) {\n                    return;\n                }\n\n                if (CHECK_UNNECESSARY && areQuotesRedundant(key.value, tokens, NUMBERS)) {\n                    context.report({\n                        node,\n                        message: MESSAGE_UNNECESSARY,\n                        data: { property: key.value },\n                        fix: fixer => fixer.replaceText(key, getUnquotedKey(key))\n                    });\n                }\n            } else if (KEYWORDS && key.type === \"Identifier\" && isKeyword(key.name)) {\n                context.report({\n                    node,\n                    message: MESSAGE_RESERVED,\n                    data: { property: key.name },\n                    fix: fixer => fixer.replaceText(key, getQuotedKey(key))\n                });\n            } else if (NUMBERS && key.type === \"Literal\" && typeof key.value === \"number\") {\n                context.report({\n                    node,\n                    message: MESSAGE_NUMERIC,\n                    data: { property: key.value },\n                    fix: fixer => fixer.replaceText(key, getQuotedKey(key))\n                });\n            }\n        }\n\n        /**\n         * Ensures that a property's key is quoted\n         * @param   {ASTNode} node Property AST node\n         * @returns {void}\n         */\n        function checkOmittedQuotes(node) {\n            const key = node.key;\n\n            if (!node.method && !node.computed && !node.shorthand && !(key.type === \"Literal\" && typeof key.value === \"string\")) {\n                context.report({\n                    node,\n                    message: MESSAGE_UNQUOTED,\n                    data: { property: key.name || key.value },\n                    fix: fixer => fixer.replaceText(key, getQuotedKey(key))\n                });\n            }\n        }\n\n        /**\n         * Ensures that an object's keys are consistently quoted, optionally checks for redundancy of quotes\n         * @param   {ASTNode} node Property AST node\n         * @param   {boolean} checkQuotesRedundancy Whether to check quotes' redundancy\n         * @returns {void}\n         */\n        function checkConsistency(node, checkQuotesRedundancy) {\n            const quotedProps = [],\n                unquotedProps = [];\n            let keywordKeyName = null,\n                necessaryQuotes = false;\n\n            node.properties.forEach(property => {\n                const key = property.key;\n\n                if (!key || property.method || property.computed || property.shorthand) {\n                    return;\n                }\n\n                if (key.type === \"Literal\" && typeof key.value === \"string\") {\n\n                    quotedProps.push(property);\n\n                    if (checkQuotesRedundancy) {\n                        let tokens;\n\n                        try {\n                            tokens = espree_1.tokenize(key.value);\n                        } catch (e) {\n                            necessaryQuotes = true;\n                            return;\n                        }\n\n                        necessaryQuotes = necessaryQuotes || !areQuotesRedundant(key.value, tokens) || KEYWORDS && isKeyword(tokens[0].value);\n                    }\n                } else if (KEYWORDS && checkQuotesRedundancy && key.type === \"Identifier\" && isKeyword(key.name)) {\n                    unquotedProps.push(property);\n                    necessaryQuotes = true;\n                    keywordKeyName = key.name;\n                } else {\n                    unquotedProps.push(property);\n                }\n            });\n\n            if (checkQuotesRedundancy && quotedProps.length && !necessaryQuotes) {\n                quotedProps.forEach(property => {\n                    context.report({\n                        node: property,\n                        message: \"Properties shouldn't be quoted as all quotes are redundant.\",\n                        fix: fixer => fixer.replaceText(property.key, getUnquotedKey(property.key))\n                    });\n                });\n            } else if (unquotedProps.length && keywordKeyName) {\n                unquotedProps.forEach(property => {\n                    context.report({\n                        node: property,\n                        message: \"Properties should be quoted as '{{property}}' is a reserved word.\",\n                        data: { property: keywordKeyName },\n                        fix: fixer => fixer.replaceText(property.key, getQuotedKey(property.key))\n                    });\n                });\n            } else if (quotedProps.length && unquotedProps.length) {\n                unquotedProps.forEach(property => {\n                    context.report({\n                        node: property,\n                        message: \"Inconsistently quoted property '{{key}}' found.\",\n                        data: { key: property.key.name || property.key.value },\n                        fix: fixer => fixer.replaceText(property.key, getQuotedKey(property.key))\n                    });\n                });\n            }\n        }\n\n        return {\n            Property(node) {\n                if (MODE === \"always\" || !MODE) {\n                    checkOmittedQuotes(node);\n                }\n                if (MODE === \"as-needed\") {\n                    checkUnnecessaryQuotes(node);\n                }\n            },\n            ObjectExpression(node) {\n                if (MODE === \"consistent\") {\n                    checkConsistency(node, false);\n                }\n                if (MODE === \"consistent-as-needed\") {\n                    checkConsistency(node, true);\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Constants\n//------------------------------------------------------------------------------\n\nconst QUOTE_SETTINGS$1 = {\n    double: {\n        quote: \"\\\"\",\n        alternateQuote: \"'\",\n        description: \"doublequote\"\n    },\n    single: {\n        quote: \"'\",\n        alternateQuote: \"\\\"\",\n        description: \"singlequote\"\n    },\n    backtick: {\n        quote: \"`\",\n        alternateQuote: \"\\\"\",\n        description: \"backtick\"\n    }\n};\n\n// An unescaped newline is a newline preceded by an even number of backslashes.\nconst UNESCAPED_LINEBREAK_PATTERN = new RegExp(String.raw`(^|[^\\\\])(\\\\\\\\)*[${Array.from(astUtils$1.LINEBREAKS).join(\"\")}]`, \"u\");\n\n/**\n * Switches quoting of javascript string between ' \" and `\n * escaping and unescaping as necessary.\n * Only escaping of the minimal set of characters is changed.\n * Note: escaping of newlines when switching from backtick to other quotes is not handled.\n * @param {string} str A string to convert.\n * @returns {string} The string with changed quotes.\n * @private\n */\nQUOTE_SETTINGS$1.double.convert =\nQUOTE_SETTINGS$1.single.convert =\nQUOTE_SETTINGS$1.backtick.convert = function(str) {\n    const newQuote = this.quote;\n    const oldQuote = str[0];\n\n    if (newQuote === oldQuote) {\n        return str;\n    }\n    return newQuote + str.slice(1, -1).replace(/\\\\(\\$\\{|\\r\\n?|\\n|.)|[\"'`]|\\$\\{|(\\r\\n?|\\n)/gu, (match, escaped, newline) => {\n        if (escaped === oldQuote || oldQuote === \"`\" && escaped === \"${\") {\n            return escaped; // unescape\n        }\n        if (match === newQuote || newQuote === \"`\" && match === \"${\") {\n            return `\\\\${match}`; // escape\n        }\n        if (newline && oldQuote === \"`\") {\n            return \"\\\\n\"; // escape newlines\n        }\n        return match;\n    }) + newQuote;\n};\n\nconst AVOID_ESCAPE = \"avoid-escape\";\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar quotes = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce the consistent use of either backticks, double, or single quotes\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/quotes\"\n        },\n\n        fixable: \"code\",\n\n        schema: [\n            {\n                enum: [\"single\", \"double\", \"backtick\"]\n            },\n            {\n                anyOf: [\n                    {\n                        enum: [\"avoid-escape\"]\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            avoidEscape: {\n                                type: \"boolean\"\n                            },\n                            allowTemplateLiterals: {\n                                type: \"boolean\"\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ]\n    },\n\n    create(context) {\n\n        const quoteOption = context.options[0],\n            settings = QUOTE_SETTINGS$1[quoteOption || \"double\"],\n            options = context.options[1],\n            allowTemplateLiterals = options && options.allowTemplateLiterals === true,\n            sourceCode = context.getSourceCode();\n        let avoidEscape = options && options.avoidEscape === true;\n\n        // deprecated\n        if (options === AVOID_ESCAPE) {\n            avoidEscape = true;\n        }\n\n        /**\n         * Determines if a given node is part of JSX syntax.\n         *\n         * This function returns `true` in the following cases:\n         *\n         * - `<div className=\"foo\"></div>` ... If the literal is an attribute value, the parent of the literal is `JSXAttribute`.\n         * - `<div>foo</div>` ... If the literal is a text content, the parent of the literal is `JSXElement`.\n         * - `<>foo</>` ... If the literal is a text content, the parent of the literal is `JSXFragment`.\n         *\n         * In particular, this function returns `false` in the following cases:\n         *\n         * - `<div className={\"foo\"}></div>`\n         * - `<div>{\"foo\"}</div>`\n         *\n         * In both cases, inside of the braces is handled as normal JavaScript.\n         * The braces are `JSXExpressionContainer` nodes.\n         * @param {ASTNode} node The Literal node to check.\n         * @returns {boolean} True if the node is a part of JSX, false if not.\n         * @private\n         */\n        function isJSXLiteral(node) {\n            return node.parent.type === \"JSXAttribute\" || node.parent.type === \"JSXElement\" || node.parent.type === \"JSXFragment\";\n        }\n\n        /**\n         * Checks whether or not a given node is a directive.\n         * The directive is a `ExpressionStatement` which has only a string literal.\n         * @param {ASTNode} node A node to check.\n         * @returns {boolean} Whether or not the node is a directive.\n         * @private\n         */\n        function isDirective(node) {\n            return (\n                node.type === \"ExpressionStatement\" &&\n                node.expression.type === \"Literal\" &&\n                typeof node.expression.value === \"string\"\n            );\n        }\n\n        /**\n         * Checks whether or not a given node is a part of directive prologues.\n         * See also: http://www.ecma-international.org/ecma-262/6.0/#sec-directive-prologues-and-the-use-strict-directive\n         * @param {ASTNode} node A node to check.\n         * @returns {boolean} Whether or not the node is a part of directive prologues.\n         * @private\n         */\n        function isPartOfDirectivePrologue(node) {\n            const block = node.parent.parent;\n\n            if (block.type !== \"Program\" && (block.type !== \"BlockStatement\" || !astUtils$1.isFunction(block.parent))) {\n                return false;\n            }\n\n            // Check the node is at a prologue.\n            for (let i = 0; i < block.body.length; ++i) {\n                const statement = block.body[i];\n\n                if (statement === node.parent) {\n                    return true;\n                }\n                if (!isDirective(statement)) {\n                    break;\n                }\n            }\n\n            return false;\n        }\n\n        /**\n         * Checks whether or not a given node is allowed as non backtick.\n         * @param {ASTNode} node A node to check.\n         * @returns {boolean} Whether or not the node is allowed as non backtick.\n         * @private\n         */\n        function isAllowedAsNonBacktick(node) {\n            const parent = node.parent;\n\n            switch (parent.type) {\n\n                // Directive Prologues.\n                case \"ExpressionStatement\":\n                    return isPartOfDirectivePrologue(node);\n\n                // LiteralPropertyName.\n                case \"Property\":\n                case \"MethodDefinition\":\n                    return parent.key === node && !parent.computed;\n\n                // ModuleSpecifier.\n                case \"ImportDeclaration\":\n                case \"ExportNamedDeclaration\":\n                case \"ExportAllDeclaration\":\n                    return parent.source === node;\n\n                // Others don't allow.\n                default:\n                    return false;\n            }\n        }\n\n        /**\n         * Checks whether or not a given TemplateLiteral node is actually using any of the special features provided by template literal strings.\n         * @param {ASTNode} node A TemplateLiteral node to check.\n         * @returns {boolean} Whether or not the TemplateLiteral node is using any of the special features provided by template literal strings.\n         * @private\n         */\n        function isUsingFeatureOfTemplateLiteral(node) {\n            const hasTag = node.parent.type === \"TaggedTemplateExpression\" && node === node.parent.quasi;\n\n            if (hasTag) {\n                return true;\n            }\n\n            const hasStringInterpolation = node.expressions.length > 0;\n\n            if (hasStringInterpolation) {\n                return true;\n            }\n\n            const isMultilineString = node.quasis.length >= 1 && UNESCAPED_LINEBREAK_PATTERN.test(node.quasis[0].value.raw);\n\n            if (isMultilineString) {\n                return true;\n            }\n\n            return false;\n        }\n\n        return {\n\n            Literal(node) {\n                const val = node.value,\n                    rawVal = node.raw;\n\n                if (settings && typeof val === \"string\") {\n                    let isValid = (quoteOption === \"backtick\" && isAllowedAsNonBacktick(node)) ||\n                        isJSXLiteral(node) ||\n                        astUtils$1.isSurroundedBy(rawVal, settings.quote);\n\n                    if (!isValid && avoidEscape) {\n                        isValid = astUtils$1.isSurroundedBy(rawVal, settings.alternateQuote) && rawVal.indexOf(settings.quote) >= 0;\n                    }\n\n                    if (!isValid) {\n                        context.report({\n                            node,\n                            message: \"Strings must use {{description}}.\",\n                            data: {\n                                description: settings.description\n                            },\n                            fix(fixer) {\n                                if (quoteOption === \"backtick\" && astUtils$1.hasOctalEscapeSequence(rawVal)) {\n\n                                    // An octal escape sequence in a template literal would produce syntax error, even in non-strict mode.\n                                    return null;\n                                }\n\n                                return fixer.replaceText(node, settings.convert(node.raw));\n                            }\n                        });\n                    }\n                }\n            },\n\n            TemplateLiteral(node) {\n\n                // Don't throw an error if backticks are expected or a template literal feature is in use.\n                if (\n                    allowTemplateLiterals ||\n                    quoteOption === \"backtick\" ||\n                    isUsingFeatureOfTemplateLiteral(node)\n                ) {\n                    return;\n                }\n\n                context.report({\n                    node,\n                    message: \"Strings must use {{description}}.\",\n                    data: {\n                        description: settings.description\n                    },\n                    fix(fixer) {\n                        if (isPartOfDirectivePrologue(node)) {\n\n                            /*\n                             * TemplateLiterals in a directive prologue aren't actually directives, but if they're\n                             * in the directive prologue, then fixing them might turn them into directives and change\n                             * the behavior of the code.\n                             */\n                            return null;\n                        }\n                        return fixer.replaceText(node, settings.convert(sourceCode.getText(node)));\n                    }\n                });\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst MODE_ALWAYS = \"always\",\n    MODE_AS_NEEDED = \"as-needed\";\n\n/**\n * Checks whether a given variable is shadowed or not.\n * @param {eslint-scope.Variable} variable A variable to check.\n * @returns {boolean} `true` if the variable is shadowed.\n */\nfunction isShadowed$2(variable) {\n    return variable.defs.length >= 1;\n}\n\n/**\n * Checks whether a given node is a MemberExpression of `parseInt` method or not.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} `true` if the node is a MemberExpression of `parseInt`\n *      method.\n */\nfunction isParseIntMethod(node) {\n    return (\n        node.type === \"MemberExpression\" &&\n        !node.computed &&\n        node.property.type === \"Identifier\" &&\n        node.property.name === \"parseInt\"\n    );\n}\n\n/**\n * Checks whether a given node is a valid value of radix or not.\n *\n * The following values are invalid.\n *\n * - A literal except numbers.\n * - undefined.\n * @param {ASTNode} radix A node of radix to check.\n * @returns {boolean} `true` if the node is valid.\n */\nfunction isValidRadix(radix) {\n    return !(\n        (radix.type === \"Literal\" && typeof radix.value !== \"number\") ||\n        (radix.type === \"Identifier\" && radix.name === \"undefined\")\n    );\n}\n\n/**\n * Checks whether a given node is a default value of radix or not.\n * @param {ASTNode} radix A node of radix to check.\n * @returns {boolean} `true` if the node is the literal node of `10`.\n */\nfunction isDefaultRadix(radix) {\n    return radix.type === \"Literal\" && radix.value === 10;\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar radix = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce the consistent use of the radix argument when using `parseInt()`\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/radix\"\n        },\n\n        schema: [\n            {\n                enum: [\"always\", \"as-needed\"]\n            }\n        ]\n    },\n\n    create(context) {\n        const mode = context.options[0] || MODE_ALWAYS;\n\n        /**\n         * Checks the arguments of a given CallExpression node and reports it if it\n         * offends this rule.\n         * @param {ASTNode} node A CallExpression node to check.\n         * @returns {void}\n         */\n        function checkArguments(node) {\n            const args = node.arguments;\n\n            switch (args.length) {\n                case 0:\n                    context.report({\n                        node,\n                        message: \"Missing parameters.\"\n                    });\n                    break;\n\n                case 1:\n                    if (mode === MODE_ALWAYS) {\n                        context.report({\n                            node,\n                            message: \"Missing radix parameter.\"\n                        });\n                    }\n                    break;\n\n                default:\n                    if (mode === MODE_AS_NEEDED && isDefaultRadix(args[1])) {\n                        context.report({\n                            node,\n                            message: \"Redundant radix parameter.\"\n                        });\n                    } else if (!isValidRadix(args[1])) {\n                        context.report({\n                            node,\n                            message: \"Invalid radix parameter.\"\n                        });\n                    }\n                    break;\n            }\n        }\n\n        return {\n            \"Program:exit\"() {\n                const scope = context.getScope();\n                let variable;\n\n                // Check `parseInt()`\n                variable = astUtils$1.getVariableByName(scope, \"parseInt\");\n                if (!isShadowed$2(variable)) {\n                    variable.references.forEach(reference => {\n                        const node = reference.identifier;\n\n                        if (astUtils$1.isCallee(node)) {\n                            checkArguments(node.parent);\n                        }\n                    });\n                }\n\n                // Check `Number.parseInt()`\n                variable = astUtils$1.getVariableByName(scope, \"Number\");\n                if (!isShadowed$2(variable)) {\n                    variable.references.forEach(reference => {\n                        const node = reference.identifier.parent;\n\n                        if (isParseIntMethod(node) && astUtils$1.isCallee(node)) {\n                            checkArguments(node.parent);\n                        }\n                    });\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview disallow assignments that can lead to race conditions due to usage of `await` or `yield`\n * @author Teddy Katz\n * @author Toru Nagashima\n */\n\n/**\n * Make the map from identifiers to each reference.\n * @param {escope.Scope} scope The scope to get references.\n * @param {Map<Identifier, escope.Reference>} [outReferenceMap] The map from identifier nodes to each reference object.\n * @returns {Map<Identifier, escope.Reference>} `referenceMap`.\n */\nfunction createReferenceMap(scope, outReferenceMap = new Map()) {\n    for (const reference of scope.references) {\n        outReferenceMap.set(reference.identifier, reference);\n    }\n    for (const childScope of scope.childScopes) {\n        if (childScope.type !== \"function\") {\n            createReferenceMap(childScope, outReferenceMap);\n        }\n    }\n\n    return outReferenceMap;\n}\n\n/**\n * Get `reference.writeExpr` of a given reference.\n * If it's the read reference of MemberExpression in LHS, returns RHS in order to address `a.b = await a`\n * @param {escope.Reference} reference The reference to get.\n * @returns {Expression|null} The `reference.writeExpr`.\n */\nfunction getWriteExpr(reference) {\n    if (reference.writeExpr) {\n        return reference.writeExpr;\n    }\n    let node = reference.identifier;\n\n    while (node) {\n        const t = node.parent.type;\n\n        if (t === \"AssignmentExpression\" && node.parent.left === node) {\n            return node.parent.right;\n        }\n        if (t === \"MemberExpression\" && node.parent.object === node) {\n            node = node.parent;\n            continue;\n        }\n\n        break;\n    }\n\n    return null;\n}\n\n/**\n * Checks if an expression is a variable that can only be observed within the given function.\n * @param {Variable|null} variable The variable to check\n * @param {boolean} isMemberAccess If `true` then this is a member access.\n * @returns {boolean} `true` if the variable is local to the given function, and is never referenced in a closure.\n */\nfunction isLocalVariableWithoutEscape(variable, isMemberAccess) {\n    if (!variable) {\n        return false; // A global variable which was not defined.\n    }\n\n    // If the reference is a property access and the variable is a parameter, it handles the variable is not local.\n    if (isMemberAccess && variable.defs.some(d => d.type === \"Parameter\")) {\n        return false;\n    }\n\n    const functionScope = variable.scope.variableScope;\n\n    return variable.references.every(reference =>\n        reference.from.variableScope === functionScope);\n}\n\nclass SegmentInfo {\n    constructor() {\n        this.info = new WeakMap();\n    }\n\n    /**\n     * Initialize the segment information.\n     * @param {PathSegment} segment The segment to initialize.\n     * @returns {void}\n     */\n    initialize(segment) {\n        const outdatedReadVariableNames = new Set();\n        const freshReadVariableNames = new Set();\n\n        for (const prevSegment of segment.prevSegments) {\n            const info = this.info.get(prevSegment);\n\n            if (info) {\n                info.outdatedReadVariableNames.forEach(Set.prototype.add, outdatedReadVariableNames);\n                info.freshReadVariableNames.forEach(Set.prototype.add, freshReadVariableNames);\n            }\n        }\n\n        this.info.set(segment, { outdatedReadVariableNames, freshReadVariableNames });\n    }\n\n    /**\n     * Mark a given variable as read on given segments.\n     * @param {PathSegment[]} segments The segments that it read the variable on.\n     * @param {string} variableName The variable name to be read.\n     * @returns {void}\n     */\n    markAsRead(segments, variableName) {\n        for (const segment of segments) {\n            const info = this.info.get(segment);\n\n            if (info) {\n                info.freshReadVariableNames.add(variableName);\n            }\n        }\n    }\n\n    /**\n     * Move `freshReadVariableNames` to `outdatedReadVariableNames`.\n     * @param {PathSegment[]} segments The segments to process.\n     * @returns {void}\n     */\n    makeOutdated(segments) {\n        for (const segment of segments) {\n            const info = this.info.get(segment);\n\n            if (info) {\n                info.freshReadVariableNames.forEach(Set.prototype.add, info.outdatedReadVariableNames);\n                info.freshReadVariableNames.clear();\n            }\n        }\n    }\n\n    /**\n     * Check if a given variable is outdated on the current segments.\n     * @param {PathSegment[]} segments The current segments.\n     * @param {string} variableName The variable name to check.\n     * @returns {boolean} `true` if the variable is outdated on the segments.\n     */\n    isOutdated(segments, variableName) {\n        for (const segment of segments) {\n            const info = this.info.get(segment);\n\n            if (info && info.outdatedReadVariableNames.has(variableName)) {\n                return true;\n            }\n        }\n        return false;\n    }\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar requireAtomicUpdates = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"disallow assignments that can lead to race conditions due to usage of `await` or `yield`\",\n            category: \"Possible Errors\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/require-atomic-updates\"\n        },\n\n        fixable: null,\n        schema: [],\n\n        messages: {\n            nonAtomicUpdate: \"Possible race condition: `{{value}}` might be reassigned based on an outdated value of `{{value}}`.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const assignmentReferences = new Map();\n        const segmentInfo = new SegmentInfo();\n        let stack = null;\n\n        return {\n            onCodePathStart(codePath) {\n                const scope = context.getScope();\n                const shouldVerify =\n                    scope.type === \"function\" &&\n                    (scope.block.async || scope.block.generator);\n\n                stack = {\n                    upper: stack,\n                    codePath,\n                    referenceMap: shouldVerify ? createReferenceMap(scope) : null\n                };\n            },\n            onCodePathEnd() {\n                stack = stack.upper;\n            },\n\n            // Initialize the segment information.\n            onCodePathSegmentStart(segment) {\n                segmentInfo.initialize(segment);\n            },\n\n            // Handle references to prepare verification.\n            Identifier(node) {\n                const { codePath, referenceMap } = stack;\n                const reference = referenceMap && referenceMap.get(node);\n\n                // Ignore if this is not a valid variable reference.\n                if (!reference) {\n                    return;\n                }\n                const name = reference.identifier.name;\n                const variable = reference.resolved;\n                const writeExpr = getWriteExpr(reference);\n                const isMemberAccess = reference.identifier.parent.type === \"MemberExpression\";\n\n                // Add a fresh read variable.\n                if (reference.isRead() && !(writeExpr && writeExpr.parent.operator === \"=\")) {\n                    segmentInfo.markAsRead(codePath.currentSegments, name);\n                }\n\n                /*\n                 * Register the variable to verify after ESLint traversed the `writeExpr` node\n                 * if this reference is an assignment to a variable which is referred from other clausure.\n                 */\n                if (writeExpr &&\n                    writeExpr.parent.right === writeExpr && // ← exclude variable declarations.\n                    !isLocalVariableWithoutEscape(variable, isMemberAccess)\n                ) {\n                    let refs = assignmentReferences.get(writeExpr);\n\n                    if (!refs) {\n                        refs = [];\n                        assignmentReferences.set(writeExpr, refs);\n                    }\n\n                    refs.push(reference);\n                }\n            },\n\n            /*\n             * Verify assignments.\n             * If the reference exists in `outdatedReadVariableNames` list, report it.\n             */\n            \":expression:exit\"(node) {\n                const { codePath, referenceMap } = stack;\n\n                // referenceMap exists if this is in a resumable function scope.\n                if (!referenceMap) {\n                    return;\n                }\n\n                // Mark the read variables on this code path as outdated.\n                if (node.type === \"AwaitExpression\" || node.type === \"YieldExpression\") {\n                    segmentInfo.makeOutdated(codePath.currentSegments);\n                }\n\n                // Verify.\n                const references = assignmentReferences.get(node);\n\n                if (references) {\n                    assignmentReferences.delete(node);\n\n                    for (const reference of references) {\n                        const name = reference.identifier.name;\n\n                        if (segmentInfo.isOutdated(codePath.currentSegments, name)) {\n                            context.report({\n                                node: node.parent,\n                                messageId: \"nonAtomicUpdate\",\n                                data: {\n                                    value: sourceCode.getText(node.parent.left)\n                                }\n                            });\n                        }\n                    }\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Capitalize the 1st letter of the given text.\n * @param {string} text The text to capitalize.\n * @returns {string} The text that the 1st letter was capitalized.\n */\nfunction capitalizeFirstLetter(text) {\n    return text[0].toUpperCase() + text.slice(1);\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar requireAwait = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"disallow async functions which have no `await` expression\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/require-await\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        let scopeInfo = null;\n\n        /**\n         * Push the scope info object to the stack.\n         * @returns {void}\n         */\n        function enterFunction() {\n            scopeInfo = {\n                upper: scopeInfo,\n                hasAwait: false\n            };\n        }\n\n        /**\n         * Pop the top scope info object from the stack.\n         * Also, it reports the function if needed.\n         * @param {ASTNode} node The node to report.\n         * @returns {void}\n         */\n        function exitFunction(node) {\n            if (node.async && !scopeInfo.hasAwait && !astUtils$1.isEmptyFunction(node)) {\n                context.report({\n                    node,\n                    loc: astUtils$1.getFunctionHeadLoc(node, sourceCode),\n                    message: \"{{name}} has no 'await' expression.\",\n                    data: {\n                        name: capitalizeFirstLetter(\n                            astUtils$1.getFunctionNameWithKind(node)\n                        )\n                    }\n                });\n            }\n\n            scopeInfo = scopeInfo.upper;\n        }\n\n        return {\n            FunctionDeclaration: enterFunction,\n            FunctionExpression: enterFunction,\n            ArrowFunctionExpression: enterFunction,\n            \"FunctionDeclaration:exit\": exitFunction,\n            \"FunctionExpression:exit\": exitFunction,\n            \"ArrowFunctionExpression:exit\": exitFunction,\n\n            AwaitExpression() {\n                if (!scopeInfo) {\n                    return;\n                }\n\n                scopeInfo.hasAwait = true;\n            },\n            ForOfStatement(node) {\n                if (!scopeInfo) {\n                    return;\n                }\n\n                if (node.await) {\n                    scopeInfo.hasAwait = true;\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to check for jsdoc presence.\n * @author Gyandeep Singh\n */\n\nvar requireJsdoc = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require JSDoc comments\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/require-jsdoc\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    require: {\n                        type: \"object\",\n                        properties: {\n                            ClassDeclaration: {\n                                type: \"boolean\",\n                                default: false\n                            },\n                            MethodDefinition: {\n                                type: \"boolean\",\n                                default: false\n                            },\n                            FunctionDeclaration: {\n                                type: \"boolean\",\n                                default: true\n                            },\n                            ArrowFunctionExpression: {\n                                type: \"boolean\",\n                                default: false\n                            },\n                            FunctionExpression: {\n                                type: \"boolean\",\n                                default: false\n                            }\n                        },\n                        additionalProperties: false,\n                        default: {}\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        deprecated: true,\n        replacedBy: []\n    },\n\n    create(context) {\n        const source = context.getSourceCode();\n        const DEFAULT_OPTIONS = {\n            FunctionDeclaration: true,\n            MethodDefinition: false,\n            ClassDeclaration: false,\n            ArrowFunctionExpression: false,\n            FunctionExpression: false\n        };\n        const options = Object.assign(DEFAULT_OPTIONS, context.options[0] && context.options[0].require);\n\n        /**\n         * Report the error message\n         * @param {ASTNode} node node to report\n         * @returns {void}\n         */\n        function report(node) {\n            context.report({ node, message: \"Missing JSDoc comment.\" });\n        }\n\n        /**\n         * Check if the jsdoc comment is present or not.\n         * @param {ASTNode} node node to examine\n         * @returns {void}\n         */\n        function checkJsDoc(node) {\n            const jsdocComment = source.getJSDocComment(node);\n\n            if (!jsdocComment) {\n                report(node);\n            }\n        }\n\n        return {\n            FunctionDeclaration(node) {\n                if (options.FunctionDeclaration) {\n                    checkJsDoc(node);\n                }\n            },\n            FunctionExpression(node) {\n                if (\n                    (options.MethodDefinition && node.parent.type === \"MethodDefinition\") ||\n                    (options.FunctionExpression && (node.parent.type === \"VariableDeclarator\" || (node.parent.type === \"Property\" && node === node.parent.value)))\n                ) {\n                    checkJsDoc(node);\n                }\n            },\n            ClassDeclaration(node) {\n                if (options.ClassDeclaration) {\n                    checkJsDoc(node);\n                }\n            },\n            ArrowFunctionExpression(node) {\n                if (options.ArrowFunctionExpression && node.parent.type === \"VariableDeclarator\") {\n                    checkJsDoc(node);\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nconst {\n    CALL: CALL$7,\n    CONSTRUCT: CONSTRUCT$4,\n    ReferenceTracker: ReferenceTracker$7,\n    getStringIfConstant: getStringIfConstant$3\n} = require$$0$2;\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar requireUnicodeRegexp = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce the use of `u` flag on RegExp\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/require-unicode-regexp\"\n        },\n\n        messages: {\n            requireUFlag: \"Use the 'u' flag.\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        return {\n            \"Literal[regex]\"(node) {\n                const flags = node.regex.flags || \"\";\n\n                if (!flags.includes(\"u\")) {\n                    context.report({ node, messageId: \"requireUFlag\" });\n                }\n            },\n\n            Program() {\n                const scope = context.getScope();\n                const tracker = new ReferenceTracker$7(scope);\n                const trackMap = {\n                    RegExp: { [CALL$7]: true, [CONSTRUCT$4]: true }\n                };\n\n                for (const { node } of tracker.iterateGlobalReferences(trackMap)) {\n                    const flagsNode = node.arguments[1];\n                    const flags = getStringIfConstant$3(flagsNode, scope);\n\n                    if (!flagsNode || (typeof flags === \"string\" && !flags.includes(\"u\"))) {\n                        context.report({ node, messageId: \"requireUFlag\" });\n                    }\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to flag the generator functions that does not have yield.\n * @author Toru Nagashima\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar requireYield = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require generator functions to contain `yield`\",\n            category: \"ECMAScript 6\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/require-yield\"\n        },\n\n        schema: []\n    },\n\n    create(context) {\n        const stack = [];\n\n        /**\n         * If the node is a generator function, start counting `yield` keywords.\n         * @param {Node} node A function node to check.\n         * @returns {void}\n         */\n        function beginChecking(node) {\n            if (node.generator) {\n                stack.push(0);\n            }\n        }\n\n        /**\n         * If the node is a generator function, end counting `yield` keywords, then\n         * reports result.\n         * @param {Node} node A function node to check.\n         * @returns {void}\n         */\n        function endChecking(node) {\n            if (!node.generator) {\n                return;\n            }\n\n            const countYield = stack.pop();\n\n            if (countYield === 0 && node.body.body.length > 0) {\n                context.report({ node, message: \"This generator function does not have 'yield'.\" });\n            }\n        }\n\n        return {\n            FunctionDeclaration: beginChecking,\n            \"FunctionDeclaration:exit\": endChecking,\n            FunctionExpression: beginChecking,\n            \"FunctionExpression:exit\": endChecking,\n\n            // Increases the count of `yield` keyword.\n            YieldExpression() {\n\n                /* istanbul ignore else */\n                if (stack.length > 0) {\n                    stack[stack.length - 1] += 1;\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Enforce spacing between rest and spread operators and their expressions.\n * @author Kai Cataldo\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar restSpreadSpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce spacing between rest and spread operators and their expressions\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/rest-spread-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                enum: [\"always\", \"never\"]\n            }\n        ]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode(),\n            alwaysSpace = context.options[0] === \"always\";\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Checks whitespace between rest/spread operators and their expressions\n         * @param {ASTNode} node The node to check\n         * @returns {void}\n         */\n        function checkWhiteSpace(node) {\n            const operator = sourceCode.getFirstToken(node),\n                nextToken = sourceCode.getTokenAfter(operator),\n                hasWhitespace = sourceCode.isSpaceBetweenTokens(operator, nextToken);\n            let type;\n\n            switch (node.type) {\n                case \"SpreadElement\":\n                    type = \"spread\";\n                    if (node.parent.type === \"ObjectExpression\") {\n                        type += \" property\";\n                    }\n                    break;\n                case \"RestElement\":\n                    type = \"rest\";\n                    if (node.parent.type === \"ObjectPattern\") {\n                        type += \" property\";\n                    }\n                    break;\n                case \"ExperimentalSpreadProperty\":\n                    type = \"spread property\";\n                    break;\n                case \"ExperimentalRestProperty\":\n                    type = \"rest property\";\n                    break;\n                default:\n                    return;\n            }\n\n            if (alwaysSpace && !hasWhitespace) {\n                context.report({\n                    node,\n                    loc: {\n                        line: operator.loc.end.line,\n                        column: operator.loc.end.column\n                    },\n                    message: \"Expected whitespace after {{type}} operator.\",\n                    data: {\n                        type\n                    },\n                    fix(fixer) {\n                        return fixer.replaceTextRange([operator.range[1], nextToken.range[0]], \" \");\n                    }\n                });\n            } else if (!alwaysSpace && hasWhitespace) {\n                context.report({\n                    node,\n                    loc: {\n                        line: operator.loc.end.line,\n                        column: operator.loc.end.column\n                    },\n                    message: \"Unexpected whitespace after {{type}} operator.\",\n                    data: {\n                        type\n                    },\n                    fix(fixer) {\n                        return fixer.removeRange([operator.range[1], nextToken.range[0]]);\n                    }\n                });\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            SpreadElement: checkWhiteSpace,\n            RestElement: checkWhiteSpace,\n            ExperimentalSpreadProperty: checkWhiteSpace,\n            ExperimentalRestProperty: checkWhiteSpace\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar semi = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require or disallow semicolons instead of ASI\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/semi\"\n        },\n\n        fixable: \"code\",\n\n        schema: {\n            anyOf: [\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"never\"]\n                        },\n                        {\n                            type: \"object\",\n                            properties: {\n                                beforeStatementContinuationChars: {\n                                    enum: [\"always\", \"any\", \"never\"]\n                                }\n                            },\n                            additionalProperties: false\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 2\n                },\n                {\n                    type: \"array\",\n                    items: [\n                        {\n                            enum: [\"always\"]\n                        },\n                        {\n                            type: \"object\",\n                            properties: {\n                                omitLastInOneLineBlock: { type: \"boolean\" }\n                            },\n                            additionalProperties: false\n                        }\n                    ],\n                    minItems: 0,\n                    maxItems: 2\n                }\n            ]\n        }\n    },\n\n    create(context) {\n\n        const OPT_OUT_PATTERN = /^[-[(/+`]/u; // One of [(/+-`\n        const options = context.options[1];\n        const never = context.options[0] === \"never\";\n        const exceptOneLine = Boolean(options && options.omitLastInOneLineBlock);\n        const beforeStatementContinuationChars = options && options.beforeStatementContinuationChars || \"any\";\n        const sourceCode = context.getSourceCode();\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Reports a semicolon error with appropriate location and message.\n         * @param {ASTNode} node The node with an extra or missing semicolon.\n         * @param {boolean} missing True if the semicolon is missing.\n         * @returns {void}\n         */\n        function report(node, missing) {\n            const lastToken = sourceCode.getLastToken(node);\n            let message,\n                fix,\n                loc;\n\n            if (!missing) {\n                message = \"Missing semicolon.\";\n                loc = {\n                    start: lastToken.loc.end,\n                    end: astUtils$1.getNextLocation(sourceCode, lastToken.loc.end)\n                };\n                fix = function(fixer) {\n                    return fixer.insertTextAfter(lastToken, \";\");\n                };\n            } else {\n                message = \"Extra semicolon.\";\n                loc = lastToken.loc;\n                fix = function(fixer) {\n\n                    /*\n                     * Expand the replacement range to include the surrounding\n                     * tokens to avoid conflicting with no-extra-semi.\n                     * https://github.com/eslint/eslint/issues/7928\n                     */\n                    return new fixTracker(fixer, sourceCode)\n                        .retainSurroundingTokens(lastToken)\n                        .remove(lastToken);\n                };\n            }\n\n            context.report({\n                node,\n                loc,\n                message,\n                fix\n            });\n\n        }\n\n        /**\n         * Check whether a given semicolon token is redandant.\n         * @param {Token} semiToken A semicolon token to check.\n         * @returns {boolean} `true` if the next token is `;` or `}`.\n         */\n        function isRedundantSemi(semiToken) {\n            const nextToken = sourceCode.getTokenAfter(semiToken);\n\n            return (\n                !nextToken ||\n                astUtils$1.isClosingBraceToken(nextToken) ||\n                astUtils$1.isSemicolonToken(nextToken)\n            );\n        }\n\n        /**\n         * Check whether a given token is the closing brace of an arrow function.\n         * @param {Token} lastToken A token to check.\n         * @returns {boolean} `true` if the token is the closing brace of an arrow function.\n         */\n        function isEndOfArrowBlock(lastToken) {\n            if (!astUtils$1.isClosingBraceToken(lastToken)) {\n                return false;\n            }\n            const node = sourceCode.getNodeByRangeIndex(lastToken.range[0]);\n\n            return (\n                node.type === \"BlockStatement\" &&\n                node.parent.type === \"ArrowFunctionExpression\"\n            );\n        }\n\n        /**\n         * Check whether a given node is on the same line with the next token.\n         * @param {Node} node A statement node to check.\n         * @returns {boolean} `true` if the node is on the same line with the next token.\n         */\n        function isOnSameLineWithNextToken(node) {\n            const prevToken = sourceCode.getLastToken(node, 1);\n            const nextToken = sourceCode.getTokenAfter(node);\n\n            return !!nextToken && astUtils$1.isTokenOnSameLine(prevToken, nextToken);\n        }\n\n        /**\n         * Check whether a given node can connect the next line if the next line is unreliable.\n         * @param {Node} node A statement node to check.\n         * @returns {boolean} `true` if the node can connect the next line.\n         */\n        function maybeAsiHazardAfter(node) {\n            const t = node.type;\n\n            if (t === \"DoWhileStatement\" ||\n                t === \"BreakStatement\" ||\n                t === \"ContinueStatement\" ||\n                t === \"DebuggerStatement\" ||\n                t === \"ImportDeclaration\" ||\n                t === \"ExportAllDeclaration\"\n            ) {\n                return false;\n            }\n            if (t === \"ReturnStatement\") {\n                return Boolean(node.argument);\n            }\n            if (t === \"ExportNamedDeclaration\") {\n                return Boolean(node.declaration);\n            }\n            if (isEndOfArrowBlock(sourceCode.getLastToken(node, 1))) {\n                return false;\n            }\n\n            return true;\n        }\n\n        /**\n         * Check whether a given token can connect the previous statement.\n         * @param {Token} token A token to check.\n         * @returns {boolean} `true` if the token is one of `[`, `(`, `/`, `+`, `-`, ```, `++`, and `--`.\n         */\n        function maybeAsiHazardBefore(token) {\n            return (\n                Boolean(token) &&\n                OPT_OUT_PATTERN.test(token.value) &&\n                token.value !== \"++\" &&\n                token.value !== \"--\"\n            );\n        }\n\n        /**\n         * Check if the semicolon of a given node is unnecessary, only true if:\n         *   - next token is a valid statement divider (`;` or `}`).\n         *   - next token is on a new line and the node is not connectable to the new line.\n         * @param {Node} node A statement node to check.\n         * @returns {boolean} whether the semicolon is unnecessary.\n         */\n        function canRemoveSemicolon(node) {\n            if (isRedundantSemi(sourceCode.getLastToken(node))) {\n                return true; // `;;` or `;}`\n            }\n            if (isOnSameLineWithNextToken(node)) {\n                return false; // One liner.\n            }\n            if (beforeStatementContinuationChars === \"never\" && !maybeAsiHazardAfter(node)) {\n                return true; // ASI works. This statement doesn't connect to the next.\n            }\n            if (!maybeAsiHazardBefore(sourceCode.getTokenAfter(node))) {\n                return true; // ASI works. The next token doesn't connect to this statement.\n            }\n\n            return false;\n        }\n\n        /**\n         * Checks a node to see if it's in a one-liner block statement.\n         * @param {ASTNode} node The node to check.\n         * @returns {boolean} whether the node is in a one-liner block statement.\n         */\n        function isOneLinerBlock(node) {\n            const parent = node.parent;\n            const nextToken = sourceCode.getTokenAfter(node);\n\n            if (!nextToken || nextToken.value !== \"}\") {\n                return false;\n            }\n            return (\n                !!parent &&\n                parent.type === \"BlockStatement\" &&\n                parent.loc.start.line === parent.loc.end.line\n            );\n        }\n\n        /**\n         * Checks a node to see if it's followed by a semicolon.\n         * @param {ASTNode} node The node to check.\n         * @returns {void}\n         */\n        function checkForSemicolon(node) {\n            const isSemi = astUtils$1.isSemicolonToken(sourceCode.getLastToken(node));\n\n            if (never) {\n                if (isSemi && canRemoveSemicolon(node)) {\n                    report(node, true);\n                } else if (!isSemi && beforeStatementContinuationChars === \"always\" && maybeAsiHazardBefore(sourceCode.getTokenAfter(node))) {\n                    report(node);\n                }\n            } else {\n                const oneLinerBlock = (exceptOneLine && isOneLinerBlock(node));\n\n                if (isSemi && oneLinerBlock) {\n                    report(node, true);\n                } else if (!isSemi && !oneLinerBlock) {\n                    report(node);\n                }\n            }\n        }\n\n        /**\n         * Checks to see if there's a semicolon after a variable declaration.\n         * @param {ASTNode} node The node to check.\n         * @returns {void}\n         */\n        function checkForSemicolonForVariableDeclaration(node) {\n            const parent = node.parent;\n\n            if ((parent.type !== \"ForStatement\" || parent.init !== node) &&\n                (!/^For(?:In|Of)Statement/u.test(parent.type) || parent.left !== node)\n            ) {\n                checkForSemicolon(node);\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n            VariableDeclaration: checkForSemicolonForVariableDeclaration,\n            ExpressionStatement: checkForSemicolon,\n            ReturnStatement: checkForSemicolon,\n            ThrowStatement: checkForSemicolon,\n            DoWhileStatement: checkForSemicolon,\n            DebuggerStatement: checkForSemicolon,\n            BreakStatement: checkForSemicolon,\n            ContinueStatement: checkForSemicolon,\n            ImportDeclaration: checkForSemicolon,\n            ExportAllDeclaration: checkForSemicolon,\n            ExportNamedDeclaration(node) {\n                if (!node.declaration) {\n                    checkForSemicolon(node);\n                }\n            },\n            ExportDefaultDeclaration(node) {\n                if (!/(?:Class|Function)Declaration/u.test(node.declaration.type)) {\n                    checkForSemicolon(node);\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar semiSpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent spacing before and after semicolons\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/semi-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    before: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    after: {\n                        type: \"boolean\",\n                        default: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n\n        const config = context.options[0],\n            sourceCode = context.getSourceCode();\n        let requireSpaceBefore = false,\n            requireSpaceAfter = true;\n\n        if (typeof config === \"object\") {\n            requireSpaceBefore = config.before;\n            requireSpaceAfter = config.after;\n        }\n\n        /**\n         * Checks if a given token has leading whitespace.\n         * @param {Object} token The token to check.\n         * @returns {boolean} True if the given token has leading space, false if not.\n         */\n        function hasLeadingSpace(token) {\n            const tokenBefore = sourceCode.getTokenBefore(token);\n\n            return tokenBefore && astUtils$1.isTokenOnSameLine(tokenBefore, token) && sourceCode.isSpaceBetweenTokens(tokenBefore, token);\n        }\n\n        /**\n         * Checks if a given token has trailing whitespace.\n         * @param {Object} token The token to check.\n         * @returns {boolean} True if the given token has trailing space, false if not.\n         */\n        function hasTrailingSpace(token) {\n            const tokenAfter = sourceCode.getTokenAfter(token);\n\n            return tokenAfter && astUtils$1.isTokenOnSameLine(token, tokenAfter) && sourceCode.isSpaceBetweenTokens(token, tokenAfter);\n        }\n\n        /**\n         * Checks if the given token is the last token in its line.\n         * @param {Token} token The token to check.\n         * @returns {boolean} Whether or not the token is the last in its line.\n         */\n        function isLastTokenInCurrentLine(token) {\n            const tokenAfter = sourceCode.getTokenAfter(token);\n\n            return !(tokenAfter && astUtils$1.isTokenOnSameLine(token, tokenAfter));\n        }\n\n        /**\n         * Checks if the given token is the first token in its line\n         * @param {Token} token The token to check.\n         * @returns {boolean} Whether or not the token is the first in its line.\n         */\n        function isFirstTokenInCurrentLine(token) {\n            const tokenBefore = sourceCode.getTokenBefore(token);\n\n            return !(tokenBefore && astUtils$1.isTokenOnSameLine(token, tokenBefore));\n        }\n\n        /**\n         * Checks if the next token of a given token is a closing parenthesis.\n         * @param {Token} token The token to check.\n         * @returns {boolean} Whether or not the next token of a given token is a closing parenthesis.\n         */\n        function isBeforeClosingParen(token) {\n            const nextToken = sourceCode.getTokenAfter(token);\n\n            return (nextToken && astUtils$1.isClosingBraceToken(nextToken) || astUtils$1.isClosingParenToken(nextToken));\n        }\n\n        /**\n         * Reports if the given token has invalid spacing.\n         * @param {Token} token The semicolon token to check.\n         * @param {ASTNode} node The corresponding node of the token.\n         * @returns {void}\n         */\n        function checkSemicolonSpacing(token, node) {\n            if (astUtils$1.isSemicolonToken(token)) {\n                const location = token.loc.start;\n\n                if (hasLeadingSpace(token)) {\n                    if (!requireSpaceBefore) {\n                        context.report({\n                            node,\n                            loc: location,\n                            message: \"Unexpected whitespace before semicolon.\",\n                            fix(fixer) {\n                                const tokenBefore = sourceCode.getTokenBefore(token);\n\n                                return fixer.removeRange([tokenBefore.range[1], token.range[0]]);\n                            }\n                        });\n                    }\n                } else {\n                    if (requireSpaceBefore) {\n                        context.report({\n                            node,\n                            loc: location,\n                            message: \"Missing whitespace before semicolon.\",\n                            fix(fixer) {\n                                return fixer.insertTextBefore(token, \" \");\n                            }\n                        });\n                    }\n                }\n\n                if (!isFirstTokenInCurrentLine(token) && !isLastTokenInCurrentLine(token) && !isBeforeClosingParen(token)) {\n                    if (hasTrailingSpace(token)) {\n                        if (!requireSpaceAfter) {\n                            context.report({\n                                node,\n                                loc: location,\n                                message: \"Unexpected whitespace after semicolon.\",\n                                fix(fixer) {\n                                    const tokenAfter = sourceCode.getTokenAfter(token);\n\n                                    return fixer.removeRange([token.range[1], tokenAfter.range[0]]);\n                                }\n                            });\n                        }\n                    } else {\n                        if (requireSpaceAfter) {\n                            context.report({\n                                node,\n                                loc: location,\n                                message: \"Missing whitespace after semicolon.\",\n                                fix(fixer) {\n                                    return fixer.insertTextAfter(token, \" \");\n                                }\n                            });\n                        }\n                    }\n                }\n            }\n        }\n\n        /**\n         * Checks the spacing of the semicolon with the assumption that the last token is the semicolon.\n         * @param {ASTNode} node The node to check.\n         * @returns {void}\n         */\n        function checkNode(node) {\n            const token = sourceCode.getLastToken(node);\n\n            checkSemicolonSpacing(token, node);\n        }\n\n        return {\n            VariableDeclaration: checkNode,\n            ExpressionStatement: checkNode,\n            BreakStatement: checkNode,\n            ContinueStatement: checkNode,\n            DebuggerStatement: checkNode,\n            ReturnStatement: checkNode,\n            ThrowStatement: checkNode,\n            ImportDeclaration: checkNode,\n            ExportNamedDeclaration: checkNode,\n            ExportAllDeclaration: checkNode,\n            ExportDefaultDeclaration: checkNode,\n            ForStatement(node) {\n                if (node.init) {\n                    checkSemicolonSpacing(sourceCode.getTokenAfter(node.init), node);\n                }\n\n                if (node.test) {\n                    checkSemicolonSpacing(sourceCode.getTokenAfter(node.test), node);\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nconst SELECTOR = `:matches(${\n    [\n        \"BreakStatement\", \"ContinueStatement\", \"DebuggerStatement\",\n        \"DoWhileStatement\", \"ExportAllDeclaration\",\n        \"ExportDefaultDeclaration\", \"ExportNamedDeclaration\",\n        \"ExpressionStatement\", \"ImportDeclaration\", \"ReturnStatement\",\n        \"ThrowStatement\", \"VariableDeclaration\"\n    ].join(\",\")\n})`;\n\n/**\n * Get the child node list of a given node.\n * This returns `Program#body`, `BlockStatement#body`, or `SwitchCase#consequent`.\n * This is used to check whether a node is the first/last child.\n * @param {Node} node A node to get child node list.\n * @returns {Node[]|null} The child node list.\n */\nfunction getChildren(node) {\n    const t = node.type;\n\n    if (t === \"BlockStatement\" || t === \"Program\") {\n        return node.body;\n    }\n    if (t === \"SwitchCase\") {\n        return node.consequent;\n    }\n    return null;\n}\n\n/**\n * Check whether a given node is the last statement in the parent block.\n * @param {Node} node A node to check.\n * @returns {boolean} `true` if the node is the last statement in the parent block.\n */\nfunction isLastChild(node) {\n    const t = node.parent.type;\n\n    if (t === \"IfStatement\" && node.parent.consequent === node && node.parent.alternate) { // before `else` keyword.\n        return true;\n    }\n    if (t === \"DoWhileStatement\") { // before `while` keyword.\n        return true;\n    }\n    const nodeList = getChildren(node.parent);\n\n    return nodeList !== null && nodeList[nodeList.length - 1] === node; // before `}` or etc.\n}\n\nvar semiStyle = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce location of semicolons\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/semi-style\"\n        },\n\n        schema: [{ enum: [\"last\", \"first\"] }],\n        fixable: \"whitespace\"\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const option = context.options[0] || \"last\";\n\n        /**\n         * Check the given semicolon token.\n         * @param {Token} semiToken The semicolon token to check.\n         * @param {\"first\"|\"last\"} expected The expected location to check.\n         * @returns {void}\n         */\n        function check(semiToken, expected) {\n            const prevToken = sourceCode.getTokenBefore(semiToken);\n            const nextToken = sourceCode.getTokenAfter(semiToken);\n            const prevIsSameLine = !prevToken || astUtils$1.isTokenOnSameLine(prevToken, semiToken);\n            const nextIsSameLine = !nextToken || astUtils$1.isTokenOnSameLine(semiToken, nextToken);\n\n            if ((expected === \"last\" && !prevIsSameLine) || (expected === \"first\" && !nextIsSameLine)) {\n                context.report({\n                    loc: semiToken.loc,\n                    message: \"Expected this semicolon to be at {{pos}}.\",\n                    data: {\n                        pos: (expected === \"last\")\n                            ? \"the end of the previous line\"\n                            : \"the beginning of the next line\"\n                    },\n                    fix(fixer) {\n                        if (prevToken && nextToken && sourceCode.commentsExistBetween(prevToken, nextToken)) {\n                            return null;\n                        }\n\n                        const start = prevToken ? prevToken.range[1] : semiToken.range[0];\n                        const end = nextToken ? nextToken.range[0] : semiToken.range[1];\n                        const text = (expected === \"last\") ? \";\\n\" : \"\\n;\";\n\n                        return fixer.replaceTextRange([start, end], text);\n                    }\n                });\n            }\n        }\n\n        return {\n            [SELECTOR](node) {\n                if (option === \"first\" && isLastChild(node)) {\n                    return;\n                }\n\n                const lastToken = sourceCode.getLastToken(node);\n\n                if (astUtils$1.isSemicolonToken(lastToken)) {\n                    check(lastToken, option);\n                }\n            },\n\n            ForStatement(node) {\n                const firstSemi = node.init && sourceCode.getTokenAfter(node.init, astUtils$1.isSemicolonToken);\n                const secondSemi = node.test && sourceCode.getTokenAfter(node.test, astUtils$1.isSemicolonToken);\n\n                if (firstSemi) {\n                    check(firstSemi, \"last\");\n                }\n                if (secondSemi) {\n                    check(secondSemi, \"last\");\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to require sorting of import declarations\n * @author Christian Schuller\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar sortImports = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce sorted import declarations within modules\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/sort-imports\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    ignoreCase: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    memberSyntaxSortOrder: {\n                        type: \"array\",\n                        items: {\n                            enum: [\"none\", \"all\", \"multiple\", \"single\"]\n                        },\n                        uniqueItems: true,\n                        minItems: 4,\n                        maxItems: 4\n                    },\n                    ignoreDeclarationSort: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    ignoreMemberSort: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        fixable: \"code\"\n    },\n\n    create(context) {\n\n        const configuration = context.options[0] || {},\n            ignoreCase = configuration.ignoreCase || false,\n            ignoreDeclarationSort = configuration.ignoreDeclarationSort || false,\n            ignoreMemberSort = configuration.ignoreMemberSort || false,\n            memberSyntaxSortOrder = configuration.memberSyntaxSortOrder || [\"none\", \"all\", \"multiple\", \"single\"],\n            sourceCode = context.getSourceCode();\n        let previousDeclaration = null;\n\n        /**\n         * Gets the used member syntax style.\n         *\n         * import \"my-module.js\" --> none\n         * import * as myModule from \"my-module.js\" --> all\n         * import {myMember} from \"my-module.js\" --> single\n         * import {foo, bar} from  \"my-module.js\" --> multiple\n         * @param {ASTNode} node the ImportDeclaration node.\n         * @returns {string} used member parameter style, [\"all\", \"multiple\", \"single\"]\n         */\n        function usedMemberSyntax(node) {\n            if (node.specifiers.length === 0) {\n                return \"none\";\n            }\n            if (node.specifiers[0].type === \"ImportNamespaceSpecifier\") {\n                return \"all\";\n            }\n            if (node.specifiers.length === 1) {\n                return \"single\";\n            }\n            return \"multiple\";\n\n        }\n\n        /**\n         * Gets the group by member parameter index for given declaration.\n         * @param {ASTNode} node the ImportDeclaration node.\n         * @returns {number} the declaration group by member index.\n         */\n        function getMemberParameterGroupIndex(node) {\n            return memberSyntaxSortOrder.indexOf(usedMemberSyntax(node));\n        }\n\n        /**\n         * Gets the local name of the first imported module.\n         * @param {ASTNode} node the ImportDeclaration node.\n         * @returns {?string} the local name of the first imported module.\n         */\n        function getFirstLocalMemberName(node) {\n            if (node.specifiers[0]) {\n                return node.specifiers[0].local.name;\n            }\n            return null;\n\n        }\n\n        return {\n            ImportDeclaration(node) {\n                if (!ignoreDeclarationSort) {\n                    if (previousDeclaration) {\n                        const currentMemberSyntaxGroupIndex = getMemberParameterGroupIndex(node),\n                            previousMemberSyntaxGroupIndex = getMemberParameterGroupIndex(previousDeclaration);\n                        let currentLocalMemberName = getFirstLocalMemberName(node),\n                            previousLocalMemberName = getFirstLocalMemberName(previousDeclaration);\n\n                        if (ignoreCase) {\n                            previousLocalMemberName = previousLocalMemberName && previousLocalMemberName.toLowerCase();\n                            currentLocalMemberName = currentLocalMemberName && currentLocalMemberName.toLowerCase();\n                        }\n\n                        /*\n                         * When the current declaration uses a different member syntax,\n                         * then check if the ordering is correct.\n                         * Otherwise, make a default string compare (like rule sort-vars to be consistent) of the first used local member name.\n                         */\n                        if (currentMemberSyntaxGroupIndex !== previousMemberSyntaxGroupIndex) {\n                            if (currentMemberSyntaxGroupIndex < previousMemberSyntaxGroupIndex) {\n                                context.report({\n                                    node,\n                                    message: \"Expected '{{syntaxA}}' syntax before '{{syntaxB}}' syntax.\",\n                                    data: {\n                                        syntaxA: memberSyntaxSortOrder[currentMemberSyntaxGroupIndex],\n                                        syntaxB: memberSyntaxSortOrder[previousMemberSyntaxGroupIndex]\n                                    }\n                                });\n                            }\n                        } else {\n                            if (previousLocalMemberName &&\n                                currentLocalMemberName &&\n                                currentLocalMemberName < previousLocalMemberName\n                            ) {\n                                context.report({\n                                    node,\n                                    message: \"Imports should be sorted alphabetically.\"\n                                });\n                            }\n                        }\n                    }\n\n                    previousDeclaration = node;\n                }\n\n                if (!ignoreMemberSort) {\n                    const importSpecifiers = node.specifiers.filter(specifier => specifier.type === \"ImportSpecifier\");\n                    const getSortableName = ignoreCase ? specifier => specifier.local.name.toLowerCase() : specifier => specifier.local.name;\n                    const firstUnsortedIndex = importSpecifiers.map(getSortableName).findIndex((name, index, array) => array[index - 1] > name);\n\n                    if (firstUnsortedIndex !== -1) {\n                        context.report({\n                            node: importSpecifiers[firstUnsortedIndex],\n                            message: \"Member '{{memberName}}' of the import declaration should be sorted alphabetically.\",\n                            data: { memberName: importSpecifiers[firstUnsortedIndex].local.name },\n                            fix(fixer) {\n                                if (importSpecifiers.some(specifier =>\n                                    sourceCode.getCommentsBefore(specifier).length || sourceCode.getCommentsAfter(specifier).length)) {\n\n                                    // If there are comments in the ImportSpecifier list, don't rearrange the specifiers.\n                                    return null;\n                                }\n\n                                return fixer.replaceTextRange(\n                                    [importSpecifiers[0].range[0], importSpecifiers[importSpecifiers.length - 1].range[1]],\n                                    importSpecifiers\n\n                                        // Clone the importSpecifiers array to avoid mutating it\n                                        .slice()\n\n                                        // Sort the array into the desired order\n                                        .sort((specifierA, specifierB) => {\n                                            const aName = getSortableName(specifierA);\n                                            const bName = getSortableName(specifierB);\n\n                                            return aName > bName ? 1 : -1;\n                                        })\n\n                                        // Build a string out of the sorted list of import specifiers and the text between the originals\n                                        .reduce((sourceText, specifier, index) => {\n                                            const textAfterSpecifier = index === importSpecifiers.length - 1\n                                                ? \"\"\n                                                : sourceCode.getText().slice(importSpecifiers[index].range[1], importSpecifiers[index + 1].range[0]);\n\n                                            return sourceText + sourceCode.getText(specifier) + textAfterSpecifier;\n                                        }, \"\")\n                                );\n                            }\n                        });\n                    }\n                }\n            }\n        };\n    }\n};\n\nvar naturalCompare_1 = createCommonjsModule(function (module) {\n/*\n * @version    1.4.0\n * @date       2015-10-26\n * @stability  3 - Stable\n * @author     Lauri Rooden (https://github.com/litejs/natural-compare-lite)\n * @license    MIT License\n */\n\n\nvar naturalCompare = function(a, b) {\n\tvar i, codeA\n\t, codeB = 1\n\t, posA = 0\n\t, posB = 0\n\t, alphabet = String.alphabet;\n\n\tfunction getCode(str, pos, code) {\n\t\tif (code) {\n\t\t\tfor (i = pos; code = getCode(str, i), code < 76 && code > 65;) ++i;\n\t\t\treturn +str.slice(pos - 1, i)\n\t\t}\n\t\tcode = alphabet && alphabet.indexOf(str.charAt(pos));\n\t\treturn code > -1 ? code + 76 : ((code = str.charCodeAt(pos) || 0), code < 45 || code > 127) ? code\n\t\t\t: code < 46 ? 65               // -\n\t\t\t: code < 48 ? code - 1\n\t\t\t: code < 58 ? code + 18        // 0-9\n\t\t\t: code < 65 ? code - 11\n\t\t\t: code < 91 ? code + 11        // A-Z\n\t\t\t: code < 97 ? code - 37\n\t\t\t: code < 123 ? code + 5        // a-z\n\t\t\t: code - 63\n\t}\n\n\n\tif ((a+=\"\") != (b+=\"\")) for (;codeB;) {\n\t\tcodeA = getCode(a, posA++);\n\t\tcodeB = getCode(b, posB++);\n\n\t\tif (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {\n\t\t\tcodeA = getCode(a, posA, posA);\n\t\t\tcodeB = getCode(b, posB, posA = i);\n\t\t\tposB = i;\n\t\t}\n\n\t\tif (codeA != codeB) return (codeA < codeB) ? -1 : 1\n\t}\n\treturn 0\n};\n\ntry {\n\tmodule.exports = naturalCompare;\n} catch (e) {\n\tString.naturalCompare = naturalCompare;\n}\n});\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Gets the property name of the given `Property` node.\n *\n * - If the property's key is an `Identifier` node, this returns the key's name\n *   whether it's a computed property or not.\n * - If the property has a static name, this returns the static name.\n * - Otherwise, this returns null.\n * @param {ASTNode} node The `Property` node to get.\n * @returns {string|null} The property name or null.\n * @private\n */\nfunction getPropertyName$3(node) {\n    const staticName = astUtils$1.getStaticPropertyName(node);\n\n    if (staticName !== null) {\n        return staticName;\n    }\n\n    return node.key.name || null;\n}\n\n/**\n * Functions which check that the given 2 names are in specific order.\n *\n * Postfix `I` is meant insensitive.\n * Postfix `N` is meant natual.\n * @private\n */\nconst isValidOrders = {\n    asc(a, b) {\n        return a <= b;\n    },\n    ascI(a, b) {\n        return a.toLowerCase() <= b.toLowerCase();\n    },\n    ascN(a, b) {\n        return naturalCompare_1(a, b) <= 0;\n    },\n    ascIN(a, b) {\n        return naturalCompare_1(a.toLowerCase(), b.toLowerCase()) <= 0;\n    },\n    desc(a, b) {\n        return isValidOrders.asc(b, a);\n    },\n    descI(a, b) {\n        return isValidOrders.ascI(b, a);\n    },\n    descN(a, b) {\n        return isValidOrders.ascN(b, a);\n    },\n    descIN(a, b) {\n        return isValidOrders.ascIN(b, a);\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar sortKeys = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require object keys to be sorted\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/sort-keys\"\n        },\n\n        schema: [\n            {\n                enum: [\"asc\", \"desc\"]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    caseSensitive: {\n                        type: \"boolean\",\n                        default: true\n                    },\n                    natural: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    minKeys: {\n                        type: \"integer\",\n                        minimum: 2,\n                        default: 2\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n\n        // Parse options.\n        const order = context.options[0] || \"asc\";\n        const options = context.options[1];\n        const insensitive = options && options.caseSensitive === false;\n        const natual = options && options.natural;\n        const minKeys = options && options.minKeys;\n        const isValidOrder = isValidOrders[\n            order + (insensitive ? \"I\" : \"\") + (natual ? \"N\" : \"\")\n        ];\n\n        // The stack to save the previous property's name for each object literals.\n        let stack = null;\n\n        return {\n            ObjectExpression(node) {\n                stack = {\n                    upper: stack,\n                    prevName: null,\n                    numKeys: node.properties.length\n                };\n            },\n\n            \"ObjectExpression:exit\"() {\n                stack = stack.upper;\n            },\n\n            SpreadElement(node) {\n                if (node.parent.type === \"ObjectExpression\") {\n                    stack.prevName = null;\n                }\n            },\n\n            Property(node) {\n                if (node.parent.type === \"ObjectPattern\") {\n                    return;\n                }\n\n                const prevName = stack.prevName;\n                const numKeys = stack.numKeys;\n                const thisName = getPropertyName$3(node);\n\n                if (thisName !== null) {\n                    stack.prevName = thisName;\n                }\n\n                if (prevName === null || thisName === null || numKeys < minKeys) {\n                    return;\n                }\n\n                if (!isValidOrder(prevName, thisName)) {\n                    context.report({\n                        node,\n                        loc: node.key.loc,\n                        message: \"Expected object keys to be in {{natual}}{{insensitive}}{{order}}ending order. '{{thisName}}' should be before '{{prevName}}'.\",\n                        data: {\n                            thisName,\n                            prevName,\n                            order,\n                            insensitive: insensitive ? \"insensitive \" : \"\",\n                            natual: natual ? \"natural \" : \"\"\n                        }\n                    });\n                }\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to require sorting of variables within a single Variable Declaration block\n * @author Ilya Volodin\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar sortVars = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require variables within the same declaration block to be sorted\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/sort-vars\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    ignoreCase: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        fixable: \"code\"\n    },\n\n    create(context) {\n\n        const configuration = context.options[0] || {},\n            ignoreCase = configuration.ignoreCase || false,\n            sourceCode = context.getSourceCode();\n\n        return {\n            VariableDeclaration(node) {\n                const idDeclarations = node.declarations.filter(decl => decl.id.type === \"Identifier\");\n                const getSortableName = ignoreCase ? decl => decl.id.name.toLowerCase() : decl => decl.id.name;\n                const unfixable = idDeclarations.some(decl => decl.init !== null && decl.init.type !== \"Literal\");\n                let fixed = false;\n\n                idDeclarations.slice(1).reduce((memo, decl) => {\n                    const lastVariableName = getSortableName(memo),\n                        currentVariableName = getSortableName(decl);\n\n                    if (currentVariableName < lastVariableName) {\n                        context.report({\n                            node: decl,\n                            message: \"Variables within the same declaration block should be sorted alphabetically.\",\n                            fix(fixer) {\n                                if (unfixable || fixed) {\n                                    return null;\n                                }\n                                return fixer.replaceTextRange(\n                                    [idDeclarations[0].range[0], idDeclarations[idDeclarations.length - 1].range[1]],\n                                    idDeclarations\n\n                                        // Clone the idDeclarations array to avoid mutating it\n                                        .slice()\n\n                                        // Sort the array into the desired order\n                                        .sort((declA, declB) => {\n                                            const aName = getSortableName(declA);\n                                            const bName = getSortableName(declB);\n\n                                            return aName > bName ? 1 : -1;\n                                        })\n\n                                        // Build a string out of the sorted list of identifier declarations and the text between the originals\n                                        .reduce((sourceText, identifier, index) => {\n                                            const textAfterIdentifier = index === idDeclarations.length - 1\n                                                ? \"\"\n                                                : sourceCode.getText().slice(idDeclarations[index].range[1], idDeclarations[index + 1].range[0]);\n\n                                            return sourceText + sourceCode.getText(identifier) + textAfterIdentifier;\n                                        }, \"\")\n\n                                );\n                            }\n                        });\n                        fixed = true;\n                        return memo;\n                    }\n                    return decl;\n\n                }, idDeclarations[0]);\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar spaceBeforeBlocks = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent spacing before blocks\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/space-before-blocks\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        enum: [\"always\", \"never\"]\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            keywords: {\n                                enum: [\"always\", \"never\", \"off\"]\n                            },\n                            functions: {\n                                enum: [\"always\", \"never\", \"off\"]\n                            },\n                            classes: {\n                                enum: [\"always\", \"never\", \"off\"]\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ]\n    },\n\n    create(context) {\n        const config = context.options[0],\n            sourceCode = context.getSourceCode();\n        let alwaysFunctions = true,\n            alwaysKeywords = true,\n            alwaysClasses = true,\n            neverFunctions = false,\n            neverKeywords = false,\n            neverClasses = false;\n\n        if (typeof config === \"object\") {\n            alwaysFunctions = config.functions === \"always\";\n            alwaysKeywords = config.keywords === \"always\";\n            alwaysClasses = config.classes === \"always\";\n            neverFunctions = config.functions === \"never\";\n            neverKeywords = config.keywords === \"never\";\n            neverClasses = config.classes === \"never\";\n        } else if (config === \"never\") {\n            alwaysFunctions = false;\n            alwaysKeywords = false;\n            alwaysClasses = false;\n            neverFunctions = true;\n            neverKeywords = true;\n            neverClasses = true;\n        }\n\n        /**\n         * Checks whether or not a given token is an arrow operator (=>) or a keyword\n         * in order to avoid to conflict with `arrow-spacing` and `keyword-spacing`.\n         * @param {Token} token A token to check.\n         * @returns {boolean} `true` if the token is an arrow operator.\n         */\n        function isConflicted(token) {\n            return (token.type === \"Punctuator\" && token.value === \"=>\") || token.type === \"Keyword\";\n        }\n\n        /**\n         * Checks the given BlockStatement node has a preceding space if it doesn’t start on a new line.\n         * @param {ASTNode|Token} node The AST node of a BlockStatement.\n         * @returns {void} undefined.\n         */\n        function checkPrecedingSpace(node) {\n            const precedingToken = sourceCode.getTokenBefore(node);\n\n            if (precedingToken && !isConflicted(precedingToken) && astUtils$1.isTokenOnSameLine(precedingToken, node)) {\n                const hasSpace = sourceCode.isSpaceBetweenTokens(precedingToken, node);\n                const parent = context.getAncestors().pop();\n                let requireSpace;\n                let requireNoSpace;\n\n                if (parent.type === \"FunctionExpression\" || parent.type === \"FunctionDeclaration\") {\n                    requireSpace = alwaysFunctions;\n                    requireNoSpace = neverFunctions;\n                } else if (node.type === \"ClassBody\") {\n                    requireSpace = alwaysClasses;\n                    requireNoSpace = neverClasses;\n                } else {\n                    requireSpace = alwaysKeywords;\n                    requireNoSpace = neverKeywords;\n                }\n\n                if (requireSpace && !hasSpace) {\n                    context.report({\n                        node,\n                        message: \"Missing space before opening brace.\",\n                        fix(fixer) {\n                            return fixer.insertTextBefore(node, \" \");\n                        }\n                    });\n                } else if (requireNoSpace && hasSpace) {\n                    context.report({\n                        node,\n                        message: \"Unexpected space before opening brace.\",\n                        fix(fixer) {\n                            return fixer.removeRange([precedingToken.range[1], node.range[0]]);\n                        }\n                    });\n                }\n            }\n        }\n\n        /**\n         * Checks if the CaseBlock of an given SwitchStatement node has a preceding space.\n         * @param {ASTNode} node The node of a SwitchStatement.\n         * @returns {void} undefined.\n         */\n        function checkSpaceBeforeCaseBlock(node) {\n            const cases = node.cases;\n            let openingBrace;\n\n            if (cases.length > 0) {\n                openingBrace = sourceCode.getTokenBefore(cases[0]);\n            } else {\n                openingBrace = sourceCode.getLastToken(node, 1);\n            }\n\n            checkPrecedingSpace(openingBrace);\n        }\n\n        return {\n            BlockStatement: checkPrecedingSpace,\n            ClassBody: checkPrecedingSpace,\n            SwitchStatement: checkSpaceBeforeCaseBlock\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar spaceBeforeFunctionParen = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent spacing before `function` definition opening parenthesis\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/space-before-function-paren\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        enum: [\"always\", \"never\"]\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            anonymous: {\n                                enum: [\"always\", \"never\", \"ignore\"]\n                            },\n                            named: {\n                                enum: [\"always\", \"never\", \"ignore\"]\n                            },\n                            asyncArrow: {\n                                enum: [\"always\", \"never\", \"ignore\"]\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ]\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const baseConfig = typeof context.options[0] === \"string\" ? context.options[0] : \"always\";\n        const overrideConfig = typeof context.options[0] === \"object\" ? context.options[0] : {};\n\n        /**\n         * Determines whether a function has a name.\n         * @param {ASTNode} node The function node.\n         * @returns {boolean} Whether the function has a name.\n         */\n        function isNamedFunction(node) {\n            if (node.id) {\n                return true;\n            }\n\n            const parent = node.parent;\n\n            return parent.type === \"MethodDefinition\" ||\n                (parent.type === \"Property\" &&\n                    (\n                        parent.kind === \"get\" ||\n                        parent.kind === \"set\" ||\n                        parent.method\n                    )\n                );\n        }\n\n        /**\n         * Gets the config for a given function\n         * @param {ASTNode} node The function node\n         * @returns {string} \"always\", \"never\", or \"ignore\"\n         */\n        function getConfigForFunction(node) {\n            if (node.type === \"ArrowFunctionExpression\") {\n\n                // Always ignore non-async functions and arrow functions without parens, e.g. async foo => bar\n                if (node.async && astUtils$1.isOpeningParenToken(sourceCode.getFirstToken(node, { skip: 1 }))) {\n                    return overrideConfig.asyncArrow || baseConfig;\n                }\n            } else if (isNamedFunction(node)) {\n                return overrideConfig.named || baseConfig;\n\n            // `generator-star-spacing` should warn anonymous generators. E.g. `function* () {}`\n            } else if (!node.generator) {\n                return overrideConfig.anonymous || baseConfig;\n            }\n\n            return \"ignore\";\n        }\n\n        /**\n         * Checks the parens of a function node\n         * @param {ASTNode} node A function node\n         * @returns {void}\n         */\n        function checkFunction(node) {\n            const functionConfig = getConfigForFunction(node);\n\n            if (functionConfig === \"ignore\") {\n                return;\n            }\n\n            const rightToken = sourceCode.getFirstToken(node, astUtils$1.isOpeningParenToken);\n            const leftToken = sourceCode.getTokenBefore(rightToken);\n            const hasSpacing = sourceCode.isSpaceBetweenTokens(leftToken, rightToken);\n\n            if (hasSpacing && functionConfig === \"never\") {\n                context.report({\n                    node,\n                    loc: leftToken.loc.end,\n                    message: \"Unexpected space before function parentheses.\",\n                    fix(fixer) {\n                        const comments = sourceCode.getCommentsBefore(rightToken);\n\n                        // Don't fix anything if there's a single line comment between the left and the right token\n                        if (comments.some(comment => comment.type === \"Line\")) {\n                            return null;\n                        }\n                        return fixer.replaceTextRange(\n                            [leftToken.range[1], rightToken.range[0]],\n                            comments.reduce((text, comment) => text + sourceCode.getText(comment), \"\")\n                        );\n                    }\n                });\n            } else if (!hasSpacing && functionConfig === \"always\") {\n                context.report({\n                    node,\n                    loc: leftToken.loc.end,\n                    message: \"Missing space before function parentheses.\",\n                    fix: fixer => fixer.insertTextAfter(leftToken, \" \")\n                });\n            }\n        }\n\n        return {\n            ArrowFunctionExpression: checkFunction,\n            FunctionDeclaration: checkFunction,\n            FunctionExpression: checkFunction\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar spaceInParens = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent spacing inside parentheses\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/space-in-parens\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                enum: [\"always\", \"never\"]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    exceptions: {\n                        type: \"array\",\n                        items: {\n                            enum: [\"{}\", \"[]\", \"()\", \"empty\"]\n                        },\n                        uniqueItems: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            missingOpeningSpace: \"There must be a space after this paren.\",\n            missingClosingSpace: \"There must be a space before this paren.\",\n            rejectedOpeningSpace: \"There should be no space after this paren.\",\n            rejectedClosingSpace: \"There should be no space before this paren.\"\n        }\n    },\n\n    create(context) {\n        const ALWAYS = context.options[0] === \"always\",\n            exceptionsArrayOptions = (context.options[1] && context.options[1].exceptions) || [],\n            options = {};\n\n        let exceptions;\n\n        if (exceptionsArrayOptions.length) {\n            options.braceException = exceptionsArrayOptions.includes(\"{}\");\n            options.bracketException = exceptionsArrayOptions.includes(\"[]\");\n            options.parenException = exceptionsArrayOptions.includes(\"()\");\n            options.empty = exceptionsArrayOptions.includes(\"empty\");\n        }\n\n        /**\n         * Produces an object with the opener and closer exception values\n         * @returns {Object} `openers` and `closers` exception values\n         * @private\n         */\n        function getExceptions() {\n            const openers = [],\n                closers = [];\n\n            if (options.braceException) {\n                openers.push(\"{\");\n                closers.push(\"}\");\n            }\n\n            if (options.bracketException) {\n                openers.push(\"[\");\n                closers.push(\"]\");\n            }\n\n            if (options.parenException) {\n                openers.push(\"(\");\n                closers.push(\")\");\n            }\n\n            if (options.empty) {\n                openers.push(\")\");\n                closers.push(\"(\");\n            }\n\n            return {\n                openers,\n                closers\n            };\n        }\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Determines if a token is one of the exceptions for the opener paren\n         * @param {Object} token The token to check\n         * @returns {boolean} True if the token is one of the exceptions for the opener paren\n         */\n        function isOpenerException(token) {\n            return exceptions.openers.includes(token.value);\n        }\n\n        /**\n         * Determines if a token is one of the exceptions for the closer paren\n         * @param {Object} token The token to check\n         * @returns {boolean} True if the token is one of the exceptions for the closer paren\n         */\n        function isCloserException(token) {\n            return exceptions.closers.includes(token.value);\n        }\n\n        /**\n         * Determines if an opening paren is immediately followed by a required space\n         * @param {Object} openingParenToken The paren token\n         * @param {Object} tokenAfterOpeningParen The token after it\n         * @returns {boolean} True if the opening paren is missing a required space\n         */\n        function openerMissingSpace(openingParenToken, tokenAfterOpeningParen) {\n            if (sourceCode.isSpaceBetweenTokens(openingParenToken, tokenAfterOpeningParen)) {\n                return false;\n            }\n\n            if (!options.empty && astUtils$1.isClosingParenToken(tokenAfterOpeningParen)) {\n                return false;\n            }\n\n            if (ALWAYS) {\n                return !isOpenerException(tokenAfterOpeningParen);\n            }\n            return isOpenerException(tokenAfterOpeningParen);\n        }\n\n        /**\n         * Determines if an opening paren is immediately followed by a disallowed space\n         * @param {Object} openingParenToken The paren token\n         * @param {Object} tokenAfterOpeningParen The token after it\n         * @returns {boolean} True if the opening paren has a disallowed space\n         */\n        function openerRejectsSpace(openingParenToken, tokenAfterOpeningParen) {\n            if (!astUtils$1.isTokenOnSameLine(openingParenToken, tokenAfterOpeningParen)) {\n                return false;\n            }\n\n            if (tokenAfterOpeningParen.type === \"Line\") {\n                return false;\n            }\n\n            if (!sourceCode.isSpaceBetweenTokens(openingParenToken, tokenAfterOpeningParen)) {\n                return false;\n            }\n\n            if (ALWAYS) {\n                return isOpenerException(tokenAfterOpeningParen);\n            }\n            return !isOpenerException(tokenAfterOpeningParen);\n        }\n\n        /**\n         * Determines if a closing paren is immediately preceeded by a required space\n         * @param {Object} tokenBeforeClosingParen The token before the paren\n         * @param {Object} closingParenToken The paren token\n         * @returns {boolean} True if the closing paren is missing a required space\n         */\n        function closerMissingSpace(tokenBeforeClosingParen, closingParenToken) {\n            if (sourceCode.isSpaceBetweenTokens(tokenBeforeClosingParen, closingParenToken)) {\n                return false;\n            }\n\n            if (!options.empty && astUtils$1.isOpeningParenToken(tokenBeforeClosingParen)) {\n                return false;\n            }\n\n            if (ALWAYS) {\n                return !isCloserException(tokenBeforeClosingParen);\n            }\n            return isCloserException(tokenBeforeClosingParen);\n        }\n\n        /**\n         * Determines if a closer paren is immediately preceeded by a disallowed space\n         * @param {Object} tokenBeforeClosingParen The token before the paren\n         * @param {Object} closingParenToken The paren token\n         * @returns {boolean} True if the closing paren has a disallowed space\n         */\n        function closerRejectsSpace(tokenBeforeClosingParen, closingParenToken) {\n            if (!astUtils$1.isTokenOnSameLine(tokenBeforeClosingParen, closingParenToken)) {\n                return false;\n            }\n\n            if (!sourceCode.isSpaceBetweenTokens(tokenBeforeClosingParen, closingParenToken)) {\n                return false;\n            }\n\n            if (ALWAYS) {\n                return isCloserException(tokenBeforeClosingParen);\n            }\n            return !isCloserException(tokenBeforeClosingParen);\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            Program: function checkParenSpaces(node) {\n                exceptions = getExceptions();\n                const tokens = sourceCode.tokensAndComments;\n\n                tokens.forEach((token, i) => {\n                    const prevToken = tokens[i - 1];\n                    const nextToken = tokens[i + 1];\n\n                    // if token is not an opening or closing paren token, do nothing\n                    if (!astUtils$1.isOpeningParenToken(token) && !astUtils$1.isClosingParenToken(token)) {\n                        return;\n                    }\n\n                    // if token is an opening paren and is not followed by a required space\n                    if (token.value === \"(\" && openerMissingSpace(token, nextToken)) {\n                        context.report({\n                            node,\n                            loc: token.loc,\n                            messageId: \"missingOpeningSpace\",\n                            fix(fixer) {\n                                return fixer.insertTextAfter(token, \" \");\n                            }\n                        });\n                    }\n\n                    // if token is an opening paren and is followed by a disallowed space\n                    if (token.value === \"(\" && openerRejectsSpace(token, nextToken)) {\n                        context.report({\n                            node,\n                            loc: { start: token.loc.end, end: nextToken.loc.start },\n                            messageId: \"rejectedOpeningSpace\",\n                            fix(fixer) {\n                                return fixer.removeRange([token.range[1], nextToken.range[0]]);\n                            }\n                        });\n                    }\n\n                    // if token is a closing paren and is not preceded by a required space\n                    if (token.value === \")\" && closerMissingSpace(prevToken, token)) {\n                        context.report({\n                            node,\n                            loc: token.loc,\n                            messageId: \"missingClosingSpace\",\n                            fix(fixer) {\n                                return fixer.insertTextBefore(token, \" \");\n                            }\n                        });\n                    }\n\n                    // if token is a closing paren and is preceded by a disallowed space\n                    if (token.value === \")\" && closerRejectsSpace(prevToken, token)) {\n                        context.report({\n                            node,\n                            loc: { start: prevToken.loc.end, end: token.loc.start },\n                            messageId: \"rejectedClosingSpace\",\n                            fix(fixer) {\n                                return fixer.removeRange([prevToken.range[1], token.range[0]]);\n                            }\n                        });\n                    }\n                });\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Require spaces around infix operators\n * @author Michael Ficarra\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar spaceInfixOps = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require spacing around infix operators\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/space-infix-ops\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    int32Hint: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n        const int32Hint = context.options[0] ? context.options[0].int32Hint === true : false;\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Returns the first token which violates the rule\n         * @param {ASTNode} left The left node of the main node\n         * @param {ASTNode} right The right node of the main node\n         * @param {string} op The operator of the main node\n         * @returns {Object} The violator token or null\n         * @private\n         */\n        function getFirstNonSpacedToken(left, right, op) {\n            const operator = sourceCode.getFirstTokenBetween(left, right, token => token.value === op);\n            const prev = sourceCode.getTokenBefore(operator);\n            const next = sourceCode.getTokenAfter(operator);\n\n            if (!sourceCode.isSpaceBetweenTokens(prev, operator) || !sourceCode.isSpaceBetweenTokens(operator, next)) {\n                return operator;\n            }\n\n            return null;\n        }\n\n        /**\n         * Reports an AST node as a rule violation\n         * @param {ASTNode} mainNode The node to report\n         * @param {Object} culpritToken The token which has a problem\n         * @returns {void}\n         * @private\n         */\n        function report(mainNode, culpritToken) {\n            context.report({\n                node: mainNode,\n                loc: culpritToken.loc,\n                message: \"Operator '{{operator}}' must be spaced.\",\n                data: {\n                    operator: culpritToken.value\n                },\n                fix(fixer) {\n                    const previousToken = sourceCode.getTokenBefore(culpritToken);\n                    const afterToken = sourceCode.getTokenAfter(culpritToken);\n                    let fixString = \"\";\n\n                    if (culpritToken.range[0] - previousToken.range[1] === 0) {\n                        fixString = \" \";\n                    }\n\n                    fixString += culpritToken.value;\n\n                    if (afterToken.range[0] - culpritToken.range[1] === 0) {\n                        fixString += \" \";\n                    }\n\n                    return fixer.replaceText(culpritToken, fixString);\n                }\n            });\n        }\n\n        /**\n         * Check if the node is binary then report\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function checkBinary(node) {\n            const leftNode = (node.left.typeAnnotation) ? node.left.typeAnnotation : node.left;\n            const rightNode = node.right;\n\n            // search for = in AssignmentPattern nodes\n            const operator = node.operator || \"=\";\n\n            const nonSpacedNode = getFirstNonSpacedToken(leftNode, rightNode, operator);\n\n            if (nonSpacedNode) {\n                if (!(int32Hint && sourceCode.getText(node).endsWith(\"|0\"))) {\n                    report(node, nonSpacedNode);\n                }\n            }\n        }\n\n        /**\n         * Check if the node is conditional\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function checkConditional(node) {\n            const nonSpacedConsequesntNode = getFirstNonSpacedToken(node.test, node.consequent, \"?\");\n            const nonSpacedAlternateNode = getFirstNonSpacedToken(node.consequent, node.alternate, \":\");\n\n            if (nonSpacedConsequesntNode) {\n                report(node, nonSpacedConsequesntNode);\n            } else if (nonSpacedAlternateNode) {\n                report(node, nonSpacedAlternateNode);\n            }\n        }\n\n        /**\n         * Check if the node is a variable\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function checkVar(node) {\n            const leftNode = (node.id.typeAnnotation) ? node.id.typeAnnotation : node.id;\n            const rightNode = node.init;\n\n            if (rightNode) {\n                const nonSpacedNode = getFirstNonSpacedToken(leftNode, rightNode, \"=\");\n\n                if (nonSpacedNode) {\n                    report(node, nonSpacedNode);\n                }\n            }\n        }\n\n        return {\n            AssignmentExpression: checkBinary,\n            AssignmentPattern: checkBinary,\n            BinaryExpression: checkBinary,\n            LogicalExpression: checkBinary,\n            ConditionalExpression: checkConditional,\n            VariableDeclarator: checkVar\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar spaceUnaryOps = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce consistent spacing before or after unary operators\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/space-unary-ops\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    words: {\n                        type: \"boolean\",\n                        default: true\n                    },\n                    nonwords: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    overrides: {\n                        type: \"object\",\n                        additionalProperties: {\n                            type: \"boolean\"\n                        }\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n        messages: {\n            unexpectedBefore: \"Unexpected space before unary operator '{{operator}}'.\",\n            unexpectedAfter: \"Unexpected space after unary operator '{{operator}}'.\",\n            unexpectedAfterWord: \"Unexpected space after unary word operator '{{word}}'.\",\n            wordOperator: \"Unary word operator '{{word}}' must be followed by whitespace.\",\n            operator: \"Unary operator '{{operator}}' must be followed by whitespace.\",\n            beforeUnaryExpressions: \"Space is required before unary expressions '{{token}}'.\"\n        }\n    },\n\n    create(context) {\n        const options = context.options[0] || { words: true, nonwords: false };\n\n        const sourceCode = context.getSourceCode();\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        /**\n         * Check if the node is the first \"!\" in a \"!!\" convert to Boolean expression\n         * @param {ASTnode} node AST node\n         * @returns {boolean} Whether or not the node is first \"!\" in \"!!\"\n         */\n        function isFirstBangInBangBangExpression(node) {\n            return node && node.type === \"UnaryExpression\" && node.argument.operator === \"!\" &&\n                node.argument && node.argument.type === \"UnaryExpression\" && node.argument.operator === \"!\";\n        }\n\n        /**\n         * Checks if an override exists for a given operator.\n         * @param {string} operator Operator\n         * @returns {boolean} Whether or not an override has been provided for the operator\n         */\n        function overrideExistsForOperator(operator) {\n            return options.overrides && Object.prototype.hasOwnProperty.call(options.overrides, operator);\n        }\n\n        /**\n         * Gets the value that the override was set to for this operator\n         * @param {string} operator Operator\n         * @returns {boolean} Whether or not an override enforces a space with this operator\n         */\n        function overrideEnforcesSpaces(operator) {\n            return options.overrides[operator];\n        }\n\n        /**\n         * Verify Unary Word Operator has spaces after the word operator\n         * @param {ASTnode} node AST node\n         * @param {Object} firstToken first token from the AST node\n         * @param {Object} secondToken second token from the AST node\n         * @param {string} word The word to be used for reporting\n         * @returns {void}\n         */\n        function verifyWordHasSpaces(node, firstToken, secondToken, word) {\n            if (secondToken.range[0] === firstToken.range[1]) {\n                context.report({\n                    node,\n                    messageId: \"wordOperator\",\n                    data: {\n                        word\n                    },\n                    fix(fixer) {\n                        return fixer.insertTextAfter(firstToken, \" \");\n                    }\n                });\n            }\n        }\n\n        /**\n         * Verify Unary Word Operator doesn't have spaces after the word operator\n         * @param {ASTnode} node AST node\n         * @param {Object} firstToken first token from the AST node\n         * @param {Object} secondToken second token from the AST node\n         * @param {string} word The word to be used for reporting\n         * @returns {void}\n         */\n        function verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word) {\n            if (astUtils$1.canTokensBeAdjacent(firstToken, secondToken)) {\n                if (secondToken.range[0] > firstToken.range[1]) {\n                    context.report({\n                        node,\n                        messageId: \"unexpectedAfterWord\",\n                        data: {\n                            word\n                        },\n                        fix(fixer) {\n                            return fixer.removeRange([firstToken.range[1], secondToken.range[0]]);\n                        }\n                    });\n                }\n            }\n        }\n\n        /**\n         * Check Unary Word Operators for spaces after the word operator\n         * @param {ASTnode} node AST node\n         * @param {Object} firstToken first token from the AST node\n         * @param {Object} secondToken second token from the AST node\n         * @param {string} word The word to be used for reporting\n         * @returns {void}\n         */\n        function checkUnaryWordOperatorForSpaces(node, firstToken, secondToken, word) {\n            if (overrideExistsForOperator(word)) {\n                if (overrideEnforcesSpaces(word)) {\n                    verifyWordHasSpaces(node, firstToken, secondToken, word);\n                } else {\n                    verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word);\n                }\n            } else if (options.words) {\n                verifyWordHasSpaces(node, firstToken, secondToken, word);\n            } else {\n                verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word);\n            }\n        }\n\n        /**\n         * Verifies YieldExpressions satisfy spacing requirements\n         * @param {ASTnode} node AST node\n         * @returns {void}\n         */\n        function checkForSpacesAfterYield(node) {\n            const tokens = sourceCode.getFirstTokens(node, 3),\n                word = \"yield\";\n\n            if (!node.argument || node.delegate) {\n                return;\n            }\n\n            checkUnaryWordOperatorForSpaces(node, tokens[0], tokens[1], word);\n        }\n\n        /**\n         * Verifies AwaitExpressions satisfy spacing requirements\n         * @param {ASTNode} node AwaitExpression AST node\n         * @returns {void}\n         */\n        function checkForSpacesAfterAwait(node) {\n            const tokens = sourceCode.getFirstTokens(node, 3);\n\n            checkUnaryWordOperatorForSpaces(node, tokens[0], tokens[1], \"await\");\n        }\n\n        /**\n         * Verifies UnaryExpression, UpdateExpression and NewExpression have spaces before or after the operator\n         * @param {ASTnode} node AST node\n         * @param {Object} firstToken First token in the expression\n         * @param {Object} secondToken Second token in the expression\n         * @returns {void}\n         */\n        function verifyNonWordsHaveSpaces(node, firstToken, secondToken) {\n            if (node.prefix) {\n                if (isFirstBangInBangBangExpression(node)) {\n                    return;\n                }\n                if (firstToken.range[1] === secondToken.range[0]) {\n                    context.report({\n                        node,\n                        messageId: \"operator\",\n                        data: {\n                            operator: firstToken.value\n                        },\n                        fix(fixer) {\n                            return fixer.insertTextAfter(firstToken, \" \");\n                        }\n                    });\n                }\n            } else {\n                if (firstToken.range[1] === secondToken.range[0]) {\n                    context.report({\n                        node,\n                        messageId: \"beforeUnaryExpressions\",\n                        data: {\n                            token: secondToken.value\n                        },\n                        fix(fixer) {\n                            return fixer.insertTextBefore(secondToken, \" \");\n                        }\n                    });\n                }\n            }\n        }\n\n        /**\n         * Verifies UnaryExpression, UpdateExpression and NewExpression don't have spaces before or after the operator\n         * @param {ASTnode} node AST node\n         * @param {Object} firstToken First token in the expression\n         * @param {Object} secondToken Second token in the expression\n         * @returns {void}\n         */\n        function verifyNonWordsDontHaveSpaces(node, firstToken, secondToken) {\n            if (node.prefix) {\n                if (secondToken.range[0] > firstToken.range[1]) {\n                    context.report({\n                        node,\n                        messageId: \"unexpectedAfter\",\n                        data: {\n                            operator: firstToken.value\n                        },\n                        fix(fixer) {\n                            if (astUtils$1.canTokensBeAdjacent(firstToken, secondToken)) {\n                                return fixer.removeRange([firstToken.range[1], secondToken.range[0]]);\n                            }\n                            return null;\n                        }\n                    });\n                }\n            } else {\n                if (secondToken.range[0] > firstToken.range[1]) {\n                    context.report({\n                        node,\n                        messageId: \"unexpectedBefore\",\n                        data: {\n                            operator: secondToken.value\n                        },\n                        fix(fixer) {\n                            return fixer.removeRange([firstToken.range[1], secondToken.range[0]]);\n                        }\n                    });\n                }\n            }\n        }\n\n        /**\n         * Verifies UnaryExpression, UpdateExpression and NewExpression satisfy spacing requirements\n         * @param {ASTnode} node AST node\n         * @returns {void}\n         */\n        function checkForSpaces(node) {\n            const tokens = node.type === \"UpdateExpression\" && !node.prefix\n                ? sourceCode.getLastTokens(node, 2)\n                : sourceCode.getFirstTokens(node, 2);\n            const firstToken = tokens[0];\n            const secondToken = tokens[1];\n\n            if ((node.type === \"NewExpression\" || node.prefix) && firstToken.type === \"Keyword\") {\n                checkUnaryWordOperatorForSpaces(node, firstToken, secondToken, firstToken.value);\n                return;\n            }\n\n            const operator = node.prefix ? tokens[0].value : tokens[1].value;\n\n            if (overrideExistsForOperator(operator)) {\n                if (overrideEnforcesSpaces(operator)) {\n                    verifyNonWordsHaveSpaces(node, firstToken, secondToken);\n                } else {\n                    verifyNonWordsDontHaveSpaces(node, firstToken, secondToken);\n                }\n            } else if (options.nonwords) {\n                verifyNonWordsHaveSpaces(node, firstToken, secondToken);\n            } else {\n                verifyNonWordsDontHaveSpaces(node, firstToken, secondToken);\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            UnaryExpression: checkForSpaces,\n            UpdateExpression: checkForSpaces,\n            NewExpression: checkForSpaces,\n            YieldExpression: checkForSpacesAfterYield,\n            AwaitExpression: checkForSpacesAfterAwait\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Escapes the control characters of a given string.\n * @param {string} s A string to escape.\n * @returns {string} An escaped string.\n */\nfunction escape$1(s) {\n    return `(?:${lodash.escapeRegExp(s)})`;\n}\n\n/**\n * Escapes the control characters of a given string.\n * And adds a repeat flag.\n * @param {string} s A string to escape.\n * @returns {string} An escaped string.\n */\nfunction escapeAndRepeat(s) {\n    return `${escape$1(s)}+`;\n}\n\n/**\n * Parses `markers` option.\n * If markers don't include `\"*\"`, this adds `\"*\"` to allow JSDoc comments.\n * @param {string[]} [markers] A marker list.\n * @returns {string[]} A marker list.\n */\nfunction parseMarkersOption(markers) {\n\n    // `*` is a marker for JSDoc comments.\n    if (markers.indexOf(\"*\") === -1) {\n        return markers.concat(\"*\");\n    }\n\n    return markers;\n}\n\n/**\n * Creates string pattern for exceptions.\n * Generated pattern:\n *\n * 1. A space or an exception pattern sequence.\n * @param {string[]} exceptions An exception pattern list.\n * @returns {string} A regular expression string for exceptions.\n */\nfunction createExceptionsPattern(exceptions) {\n    let pattern = \"\";\n\n    /*\n     * A space or an exception pattern sequence.\n     * []                 ==> \"\\s\"\n     * [\"-\"]              ==> \"(?:\\s|\\-+$)\"\n     * [\"-\", \"=\"]         ==> \"(?:\\s|(?:\\-+|=+)$)\"\n     * [\"-\", \"=\", \"--==\"] ==> \"(?:\\s|(?:\\-+|=+|(?:\\-\\-==)+)$)\" ==> https://jex.im/regulex/#!embed=false&flags=&re=(%3F%3A%5Cs%7C(%3F%3A%5C-%2B%7C%3D%2B%7C(%3F%3A%5C-%5C-%3D%3D)%2B)%24)\n     */\n    if (exceptions.length === 0) {\n\n        // a space.\n        pattern += \"\\\\s\";\n    } else {\n\n        // a space or...\n        pattern += \"(?:\\\\s|\";\n\n        if (exceptions.length === 1) {\n\n            // a sequence of the exception pattern.\n            pattern += escapeAndRepeat(exceptions[0]);\n        } else {\n\n            // a sequence of one of the exception patterns.\n            pattern += \"(?:\";\n            pattern += exceptions.map(escapeAndRepeat).join(\"|\");\n            pattern += \")\";\n        }\n        pattern += `(?:$|[${Array.from(astUtils$1.LINEBREAKS).join(\"\")}]))`;\n    }\n\n    return pattern;\n}\n\n/**\n * Creates RegExp object for `always` mode.\n * Generated pattern for beginning of comment:\n *\n * 1. First, a marker or nothing.\n * 2. Next, a space or an exception pattern sequence.\n * @param {string[]} markers A marker list.\n * @param {string[]} exceptions An exception pattern list.\n * @returns {RegExp} A RegExp object for the beginning of a comment in `always` mode.\n */\nfunction createAlwaysStylePattern(markers, exceptions) {\n    let pattern = \"^\";\n\n    /*\n     * A marker or nothing.\n     * [\"*\"]            ==> \"\\*?\"\n     * [\"*\", \"!\"]       ==> \"(?:\\*|!)?\"\n     * [\"*\", \"/\", \"!<\"] ==> \"(?:\\*|\\/|(?:!<))?\" ==> https://jex.im/regulex/#!embed=false&flags=&re=(%3F%3A%5C*%7C%5C%2F%7C(%3F%3A!%3C))%3F\n     */\n    if (markers.length === 1) {\n\n        // the marker.\n        pattern += escape$1(markers[0]);\n    } else {\n\n        // one of markers.\n        pattern += \"(?:\";\n        pattern += markers.map(escape$1).join(\"|\");\n        pattern += \")\";\n    }\n\n    pattern += \"?\"; // or nothing.\n    pattern += createExceptionsPattern(exceptions);\n\n    return new RegExp(pattern, \"u\");\n}\n\n/**\n * Creates RegExp object for `never` mode.\n * Generated pattern for beginning of comment:\n *\n * 1. First, a marker or nothing (captured).\n * 2. Next, a space or a tab.\n * @param {string[]} markers A marker list.\n * @returns {RegExp} A RegExp object for `never` mode.\n */\nfunction createNeverStylePattern(markers) {\n    const pattern = `^(${markers.map(escape$1).join(\"|\")})?[ \\t]+`;\n\n    return new RegExp(pattern, \"u\");\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar spacedComment = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce consistent spacing after the `//` or `/*` in a comment\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/spaced-comment\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                enum: [\"always\", \"never\"]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    exceptions: {\n                        type: \"array\",\n                        items: {\n                            type: \"string\"\n                        }\n                    },\n                    markers: {\n                        type: \"array\",\n                        items: {\n                            type: \"string\"\n                        }\n                    },\n                    line: {\n                        type: \"object\",\n                        properties: {\n                            exceptions: {\n                                type: \"array\",\n                                items: {\n                                    type: \"string\"\n                                }\n                            },\n                            markers: {\n                                type: \"array\",\n                                items: {\n                                    type: \"string\"\n                                }\n                            }\n                        },\n                        additionalProperties: false\n                    },\n                    block: {\n                        type: \"object\",\n                        properties: {\n                            exceptions: {\n                                type: \"array\",\n                                items: {\n                                    type: \"string\"\n                                }\n                            },\n                            markers: {\n                                type: \"array\",\n                                items: {\n                                    type: \"string\"\n                                }\n                            },\n                            balanced: {\n                                type: \"boolean\",\n                                default: false\n                            }\n                        },\n                        additionalProperties: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ]\n    },\n\n    create(context) {\n\n        const sourceCode = context.getSourceCode();\n\n        // Unless the first option is never, require a space\n        const requireSpace = context.options[0] !== \"never\";\n\n        /*\n         * Parse the second options.\n         * If markers don't include `\"*\"`, it's added automatically for JSDoc\n         * comments.\n         */\n        const config = context.options[1] || {};\n        const balanced = config.block && config.block.balanced;\n\n        const styleRules = [\"block\", \"line\"].reduce((rule, type) => {\n            const markers = parseMarkersOption(config[type] && config[type].markers || config.markers || []);\n            const exceptions = config[type] && config[type].exceptions || config.exceptions || [];\n            const endNeverPattern = \"[ \\t]+$\";\n\n            // Create RegExp object for valid patterns.\n            rule[type] = {\n                beginRegex: requireSpace ? createAlwaysStylePattern(markers, exceptions) : createNeverStylePattern(markers),\n                endRegex: balanced && requireSpace ? new RegExp(`${createExceptionsPattern(exceptions)}$`, \"u\") : new RegExp(endNeverPattern, \"u\"),\n                hasExceptions: exceptions.length > 0,\n                captureMarker: new RegExp(`^(${markers.map(escape$1).join(\"|\")})`, \"u\"),\n                markers: new Set(markers)\n            };\n\n            return rule;\n        }, {});\n\n        /**\n         * Reports a beginning spacing error with an appropriate message.\n         * @param {ASTNode} node A comment node to check.\n         * @param {string} message An error message to report.\n         * @param {Array} match An array of match results for markers.\n         * @param {string} refChar Character used for reference in the error message.\n         * @returns {void}\n         */\n        function reportBegin(node, message, match, refChar) {\n            const type = node.type.toLowerCase(),\n                commentIdentifier = type === \"block\" ? \"/*\" : \"//\";\n\n            context.report({\n                node,\n                fix(fixer) {\n                    const start = node.range[0];\n                    let end = start + 2;\n\n                    if (requireSpace) {\n                        if (match) {\n                            end += match[0].length;\n                        }\n                        return fixer.insertTextAfterRange([start, end], \" \");\n                    }\n                    end += match[0].length;\n                    return fixer.replaceTextRange([start, end], commentIdentifier + (match[1] ? match[1] : \"\"));\n\n                },\n                message,\n                data: { refChar }\n            });\n        }\n\n        /**\n         * Reports an ending spacing error with an appropriate message.\n         * @param {ASTNode} node A comment node to check.\n         * @param {string} message An error message to report.\n         * @param {string} match An array of the matched whitespace characters.\n         * @returns {void}\n         */\n        function reportEnd(node, message, match) {\n            context.report({\n                node,\n                fix(fixer) {\n                    if (requireSpace) {\n                        return fixer.insertTextAfterRange([node.range[0], node.range[1] - 2], \" \");\n                    }\n                    const end = node.range[1] - 2,\n                        start = end - match[0].length;\n\n                    return fixer.replaceTextRange([start, end], \"\");\n\n                },\n                message\n            });\n        }\n\n        /**\n         * Reports a given comment if it's invalid.\n         * @param {ASTNode} node a comment node to check.\n         * @returns {void}\n         */\n        function checkCommentForSpace(node) {\n            const type = node.type.toLowerCase(),\n                rule = styleRules[type],\n                commentIdentifier = type === \"block\" ? \"/*\" : \"//\";\n\n            // Ignores empty comments and comments that consist only of a marker.\n            if (node.value.length === 0 || rule.markers.has(node.value)) {\n                return;\n            }\n\n            const beginMatch = rule.beginRegex.exec(node.value);\n            const endMatch = rule.endRegex.exec(node.value);\n\n            // Checks.\n            if (requireSpace) {\n                if (!beginMatch) {\n                    const hasMarker = rule.captureMarker.exec(node.value);\n                    const marker = hasMarker ? commentIdentifier + hasMarker[0] : commentIdentifier;\n\n                    if (rule.hasExceptions) {\n                        reportBegin(node, \"Expected exception block, space or tab after '{{refChar}}' in comment.\", hasMarker, marker);\n                    } else {\n                        reportBegin(node, \"Expected space or tab after '{{refChar}}' in comment.\", hasMarker, marker);\n                    }\n                }\n\n                if (balanced && type === \"block\" && !endMatch) {\n                    reportEnd(node, \"Expected space or tab before '*/' in comment.\");\n                }\n            } else {\n                if (beginMatch) {\n                    if (!beginMatch[1]) {\n                        reportBegin(node, \"Unexpected space or tab after '{{refChar}}' in comment.\", beginMatch, commentIdentifier);\n                    } else {\n                        reportBegin(node, \"Unexpected space or tab after marker ({{refChar}}) in comment.\", beginMatch, beginMatch[1]);\n                    }\n                }\n\n                if (balanced && type === \"block\" && endMatch) {\n                    reportEnd(node, \"Unexpected space or tab before '*/' in comment.\", endMatch);\n                }\n            }\n        }\n\n        return {\n            Program() {\n                const comments = sourceCode.getAllComments();\n\n                comments.filter(token => token.type !== \"Shebang\").forEach(checkCommentForSpace);\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Gets all of the Use Strict Directives in the Directive Prologue of a group of\n * statements.\n * @param {ASTNode[]} statements Statements in the program or function body.\n * @returns {ASTNode[]} All of the Use Strict Directives.\n */\nfunction getUseStrictDirectives(statements) {\n    const directives = [];\n\n    for (let i = 0; i < statements.length; i++) {\n        const statement = statements[i];\n\n        if (\n            statement.type === \"ExpressionStatement\" &&\n            statement.expression.type === \"Literal\" &&\n            statement.expression.value === \"use strict\"\n        ) {\n            directives[i] = statement;\n        } else {\n            break;\n        }\n    }\n\n    return directives;\n}\n\n/**\n * Checks whether a given parameter is a simple parameter.\n * @param {ASTNode} node A pattern node to check.\n * @returns {boolean} `true` if the node is an Identifier node.\n */\nfunction isSimpleParameter(node) {\n    return node.type === \"Identifier\";\n}\n\n/**\n * Checks whether a given parameter list is a simple parameter list.\n * @param {ASTNode[]} params A parameter list to check.\n * @returns {boolean} `true` if the every parameter is an Identifier node.\n */\nfunction isSimpleParameterList(params) {\n    return params.every(isSimpleParameter);\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar strict = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require or disallow strict mode directives\",\n            category: \"Strict Mode\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/strict\"\n        },\n\n        schema: [\n            {\n                enum: [\"never\", \"global\", \"function\", \"safe\"]\n            }\n        ],\n\n        fixable: \"code\",\n        messages: {\n            function: \"Use the function form of 'use strict'.\",\n            global: \"Use the global form of 'use strict'.\",\n            multiple: \"Multiple 'use strict' directives.\",\n            never: \"Strict mode is not permitted.\",\n            unnecessary: \"Unnecessary 'use strict' directive.\",\n            module: \"'use strict' is unnecessary inside of modules.\",\n            implied: \"'use strict' is unnecessary when implied strict mode is enabled.\",\n            unnecessaryInClasses: \"'use strict' is unnecessary inside of classes.\",\n            nonSimpleParameterList: \"'use strict' directive inside a function with non-simple parameter list throws a syntax error since ES2016.\",\n            wrap: \"Wrap {{name}} in a function with 'use strict' directive.\"\n        }\n    },\n\n    create(context) {\n\n        const ecmaFeatures = context.parserOptions.ecmaFeatures || {},\n            scopes = [],\n            classScopes = [];\n        let mode = context.options[0] || \"safe\";\n\n        if (ecmaFeatures.impliedStrict) {\n            mode = \"implied\";\n        } else if (mode === \"safe\") {\n            mode = ecmaFeatures.globalReturn ? \"global\" : \"function\";\n        }\n\n        /**\n         * Determines whether a reported error should be fixed, depending on the error type.\n         * @param {string} errorType The type of error\n         * @returns {boolean} `true` if the reported error should be fixed\n         */\n        function shouldFix(errorType) {\n            return errorType === \"multiple\" || errorType === \"unnecessary\" || errorType === \"module\" || errorType === \"implied\" || errorType === \"unnecessaryInClasses\";\n        }\n\n        /**\n         * Gets a fixer function to remove a given 'use strict' directive.\n         * @param {ASTNode} node The directive that should be removed\n         * @returns {Function} A fixer function\n         */\n        function getFixFunction(node) {\n            return fixer => fixer.remove(node);\n        }\n\n        /**\n         * Report a slice of an array of nodes with a given message.\n         * @param {ASTNode[]} nodes Nodes.\n         * @param {string} start Index to start from.\n         * @param {string} end Index to end before.\n         * @param {string} messageId Message to display.\n         * @param {boolean} fix `true` if the directive should be fixed (i.e. removed)\n         * @returns {void}\n         */\n        function reportSlice(nodes, start, end, messageId, fix) {\n            nodes.slice(start, end).forEach(node => {\n                context.report({ node, messageId, fix: fix ? getFixFunction(node) : null });\n            });\n        }\n\n        /**\n         * Report all nodes in an array with a given message.\n         * @param {ASTNode[]} nodes Nodes.\n         * @param {string} messageId Message id to display.\n         * @param {boolean} fix `true` if the directive should be fixed (i.e. removed)\n         * @returns {void}\n         */\n        function reportAll(nodes, messageId, fix) {\n            reportSlice(nodes, 0, nodes.length, messageId, fix);\n        }\n\n        /**\n         * Report all nodes in an array, except the first, with a given message.\n         * @param {ASTNode[]} nodes Nodes.\n         * @param {string} messageId Message id to display.\n         * @param {boolean} fix `true` if the directive should be fixed (i.e. removed)\n         * @returns {void}\n         */\n        function reportAllExceptFirst(nodes, messageId, fix) {\n            reportSlice(nodes, 1, nodes.length, messageId, fix);\n        }\n\n        /**\n         * Entering a function in 'function' mode pushes a new nested scope onto the\n         * stack. The new scope is true if the nested function is strict mode code.\n         * @param {ASTNode} node The function declaration or expression.\n         * @param {ASTNode[]} useStrictDirectives The Use Strict Directives of the node.\n         * @returns {void}\n         */\n        function enterFunctionInFunctionMode(node, useStrictDirectives) {\n            const isInClass = classScopes.length > 0,\n                isParentGlobal = scopes.length === 0 && classScopes.length === 0,\n                isParentStrict = scopes.length > 0 && scopes[scopes.length - 1],\n                isStrict = useStrictDirectives.length > 0;\n\n            if (isStrict) {\n                if (!isSimpleParameterList(node.params)) {\n                    context.report({ node: useStrictDirectives[0], messageId: \"nonSimpleParameterList\" });\n                } else if (isParentStrict) {\n                    context.report({ node: useStrictDirectives[0], messageId: \"unnecessary\", fix: getFixFunction(useStrictDirectives[0]) });\n                } else if (isInClass) {\n                    context.report({ node: useStrictDirectives[0], messageId: \"unnecessaryInClasses\", fix: getFixFunction(useStrictDirectives[0]) });\n                }\n\n                reportAllExceptFirst(useStrictDirectives, \"multiple\", true);\n            } else if (isParentGlobal) {\n                if (isSimpleParameterList(node.params)) {\n                    context.report({ node, messageId: \"function\" });\n                } else {\n                    context.report({\n                        node,\n                        messageId: \"wrap\",\n                        data: { name: astUtils$1.getFunctionNameWithKind(node) }\n                    });\n                }\n            }\n\n            scopes.push(isParentStrict || isStrict);\n        }\n\n        /**\n         * Exiting a function in 'function' mode pops its scope off the stack.\n         * @returns {void}\n         */\n        function exitFunctionInFunctionMode() {\n            scopes.pop();\n        }\n\n        /**\n         * Enter a function and either:\n         * - Push a new nested scope onto the stack (in 'function' mode).\n         * - Report all the Use Strict Directives (in the other modes).\n         * @param {ASTNode} node The function declaration or expression.\n         * @returns {void}\n         */\n        function enterFunction(node) {\n            const isBlock = node.body.type === \"BlockStatement\",\n                useStrictDirectives = isBlock\n                    ? getUseStrictDirectives(node.body.body) : [];\n\n            if (mode === \"function\") {\n                enterFunctionInFunctionMode(node, useStrictDirectives);\n            } else if (useStrictDirectives.length > 0) {\n                if (isSimpleParameterList(node.params)) {\n                    reportAll(useStrictDirectives, mode, shouldFix(mode));\n                } else {\n                    context.report({ node: useStrictDirectives[0], messageId: \"nonSimpleParameterList\" });\n                    reportAllExceptFirst(useStrictDirectives, \"multiple\", true);\n                }\n            }\n        }\n\n        const rule = {\n            Program(node) {\n                const useStrictDirectives = getUseStrictDirectives(node.body);\n\n                if (node.sourceType === \"module\") {\n                    mode = \"module\";\n                }\n\n                if (mode === \"global\") {\n                    if (node.body.length > 0 && useStrictDirectives.length === 0) {\n                        context.report({ node, messageId: \"global\" });\n                    }\n                    reportAllExceptFirst(useStrictDirectives, \"multiple\", true);\n                } else {\n                    reportAll(useStrictDirectives, mode, shouldFix(mode));\n                }\n            },\n            FunctionDeclaration: enterFunction,\n            FunctionExpression: enterFunction,\n            ArrowFunctionExpression: enterFunction\n        };\n\n        if (mode === \"function\") {\n            Object.assign(rule, {\n\n                // Inside of class bodies are always strict mode.\n                ClassBody() {\n                    classScopes.push(true);\n                },\n                \"ClassBody:exit\"() {\n                    classScopes.pop();\n                },\n\n                \"FunctionDeclaration:exit\": exitFunctionInFunctionMode,\n                \"FunctionExpression:exit\": exitFunctionInFunctionMode,\n                \"ArrowFunctionExpression:exit\": exitFunctionInFunctionMode\n            });\n        }\n\n        return rule;\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar switchColonSpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"enforce spacing around colons of switch statements\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/switch-colon-spacing\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    before: { type: \"boolean\", default: false },\n                    after: { type: \"boolean\", default: true }\n                },\n                additionalProperties: false\n            }\n        ],\n        fixable: \"whitespace\",\n        messages: {\n            expectedBefore: \"Expected space(s) before this colon.\",\n            expectedAfter: \"Expected space(s) after this colon.\",\n            unexpectedBefore: \"Unexpected space(s) before this colon.\",\n            unexpectedAfter: \"Unexpected space(s) after this colon.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const options = context.options[0] || {};\n        const beforeSpacing = options.before === true; // false by default\n        const afterSpacing = options.after !== false; // true by default\n\n        /**\n         * Get the colon token of the given SwitchCase node.\n         * @param {ASTNode} node The SwitchCase node to get.\n         * @returns {Token} The colon token of the node.\n         */\n        function getColonToken(node) {\n            if (node.test) {\n                return sourceCode.getTokenAfter(node.test, astUtils$1.isColonToken);\n            }\n            return sourceCode.getFirstToken(node, 1);\n        }\n\n        /**\n         * Check whether the spacing between the given 2 tokens is valid or not.\n         * @param {Token} left The left token to check.\n         * @param {Token} right The right token to check.\n         * @param {boolean} expected The expected spacing to check. `true` if there should be a space.\n         * @returns {boolean} `true` if the spacing between the tokens is valid.\n         */\n        function isValidSpacing(left, right, expected) {\n            return (\n                astUtils$1.isClosingBraceToken(right) ||\n                !astUtils$1.isTokenOnSameLine(left, right) ||\n                sourceCode.isSpaceBetweenTokens(left, right) === expected\n            );\n        }\n\n        /**\n         * Check whether comments exist between the given 2 tokens.\n         * @param {Token} left The left token to check.\n         * @param {Token} right The right token to check.\n         * @returns {boolean} `true` if comments exist between the given 2 tokens.\n         */\n        function commentsExistBetween(left, right) {\n            return sourceCode.getFirstTokenBetween(\n                left,\n                right,\n                {\n                    includeComments: true,\n                    filter: astUtils$1.isCommentToken\n                }\n            ) !== null;\n        }\n\n        /**\n         * Fix the spacing between the given 2 tokens.\n         * @param {RuleFixer} fixer The fixer to fix.\n         * @param {Token} left The left token of fix range.\n         * @param {Token} right The right token of fix range.\n         * @param {boolean} spacing The spacing style. `true` if there should be a space.\n         * @returns {Fix|null} The fix object.\n         */\n        function fix(fixer, left, right, spacing) {\n            if (commentsExistBetween(left, right)) {\n                return null;\n            }\n            if (spacing) {\n                return fixer.insertTextAfter(left, \" \");\n            }\n            return fixer.removeRange([left.range[1], right.range[0]]);\n        }\n\n        return {\n            SwitchCase(node) {\n                const colonToken = getColonToken(node);\n                const beforeToken = sourceCode.getTokenBefore(colonToken);\n                const afterToken = sourceCode.getTokenAfter(colonToken);\n\n                if (!isValidSpacing(beforeToken, colonToken, beforeSpacing)) {\n                    context.report({\n                        node,\n                        loc: colonToken.loc,\n                        messageId: beforeSpacing ? \"expectedBefore\" : \"unexpectedBefore\",\n                        fix: fixer => fix(fixer, beforeToken, colonToken, beforeSpacing)\n                    });\n                }\n                if (!isValidSpacing(colonToken, afterToken, afterSpacing)) {\n                    context.report({\n                        node,\n                        loc: colonToken.loc,\n                        messageId: afterSpacing ? \"expectedAfter\" : \"unexpectedAfter\",\n                        fix: fixer => fix(fixer, colonToken, afterToken, afterSpacing)\n                    });\n                }\n            }\n        };\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\n\nvar symbolDescription = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require symbol descriptions\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/symbol-description\"\n        },\n        fixable: null,\n        schema: [],\n        messages: {\n            expected: \"Expected Symbol to have a description.\"\n        }\n    },\n\n    create(context) {\n\n        /**\n         * Reports if node does not conform the rule in case rule is set to\n         * report missing description\n         * @param {ASTNode} node A CallExpression node to check.\n         * @returns {void}\n         */\n        function checkArgument(node) {\n            if (node.arguments.length === 0) {\n                context.report({\n                    node,\n                    messageId: \"expected\"\n                });\n            }\n        }\n\n        return {\n            \"Program:exit\"() {\n                const scope = context.getScope();\n                const variable = astUtils$1.getVariableByName(scope, \"Symbol\");\n\n                if (variable && variable.defs.length === 0) {\n                    variable.references.forEach(reference => {\n                        const node = reference.identifier;\n\n                        if (astUtils$1.isCallee(node)) {\n                            checkArgument(node.parent);\n                        }\n                    });\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst OPEN_PAREN = /\\$\\{$/u;\nconst CLOSE_PAREN = /^\\}/u;\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar templateCurlySpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require or disallow spacing around embedded expressions of template strings\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/template-curly-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            { enum: [\"always\", \"never\"] }\n        ],\n        messages: {\n            expectedBefore: \"Expected space(s) before '}'.\",\n            expectedAfter: \"Expected space(s) after '${'.\",\n            unexpectedBefore: \"Unexpected space(s) before '}'.\",\n            unexpectedAfter: \"Unexpected space(s) after '${'.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n        const always = context.options[0] === \"always\";\n        const prefix = always ? \"expected\" : \"unexpected\";\n\n        /**\n         * Checks spacing before `}` of a given token.\n         * @param {Token} token A token to check. This is a Template token.\n         * @returns {void}\n         */\n        function checkSpacingBefore(token) {\n            const prevToken = sourceCode.getTokenBefore(token);\n\n            if (prevToken &&\n                CLOSE_PAREN.test(token.value) &&\n                astUtils$1.isTokenOnSameLine(prevToken, token) &&\n                sourceCode.isSpaceBetweenTokens(prevToken, token) !== always\n            ) {\n                context.report({\n                    loc: token.loc.start,\n                    messageId: `${prefix}Before`,\n                    fix(fixer) {\n                        if (always) {\n                            return fixer.insertTextBefore(token, \" \");\n                        }\n                        return fixer.removeRange([\n                            prevToken.range[1],\n                            token.range[0]\n                        ]);\n                    }\n                });\n            }\n        }\n\n        /**\n         * Checks spacing after `${` of a given token.\n         * @param {Token} token A token to check. This is a Template token.\n         * @returns {void}\n         */\n        function checkSpacingAfter(token) {\n            const nextToken = sourceCode.getTokenAfter(token);\n\n            if (nextToken &&\n                OPEN_PAREN.test(token.value) &&\n                astUtils$1.isTokenOnSameLine(token, nextToken) &&\n                sourceCode.isSpaceBetweenTokens(token, nextToken) !== always\n            ) {\n                context.report({\n                    loc: {\n                        line: token.loc.end.line,\n                        column: token.loc.end.column - 2\n                    },\n                    messageId: `${prefix}After`,\n                    fix(fixer) {\n                        if (always) {\n                            return fixer.insertTextAfter(token, \" \");\n                        }\n                        return fixer.removeRange([\n                            token.range[1],\n                            nextToken.range[0]\n                        ]);\n                    }\n                });\n            }\n        }\n\n        return {\n            TemplateElement(node) {\n                const token = sourceCode.getFirstToken(node);\n\n                checkSpacingBefore(token);\n                checkSpacingAfter(token);\n            }\n        };\n    }\n};\n\n/**\n * @fileoverview Rule to check spacing between template tags and their literals\n * @author Jonathan Wilsson\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar templateTagSpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require or disallow spacing between template tags and their literals\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/template-tag-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            { enum: [\"always\", \"never\"] }\n        ],\n        messages: {\n            unexpected: \"Unexpected space between template tag and template literal.\",\n            missing: \"Missing space between template tag and template literal.\"\n        }\n    },\n\n    create(context) {\n        const never = context.options[0] !== \"always\";\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Check if a space is present between a template tag and its literal\n         * @param {ASTNode} node node to evaluate\n         * @returns {void}\n         * @private\n         */\n        function checkSpacing(node) {\n            const tagToken = sourceCode.getTokenBefore(node.quasi);\n            const literalToken = sourceCode.getFirstToken(node.quasi);\n            const hasWhitespace = sourceCode.isSpaceBetweenTokens(tagToken, literalToken);\n\n            if (never && hasWhitespace) {\n                context.report({\n                    node,\n                    loc: tagToken.loc.start,\n                    messageId: \"unexpected\",\n                    fix(fixer) {\n                        const comments = sourceCode.getCommentsBefore(node.quasi);\n\n                        // Don't fix anything if there's a single line comment after the template tag\n                        if (comments.some(comment => comment.type === \"Line\")) {\n                            return null;\n                        }\n\n                        return fixer.replaceTextRange(\n                            [tagToken.range[1], literalToken.range[0]],\n                            comments.reduce((text, comment) => text + sourceCode.getText(comment), \"\")\n                        );\n                    }\n                });\n            } else if (!never && !hasWhitespace) {\n                context.report({\n                    node,\n                    loc: tagToken.loc.start,\n                    messageId: \"missing\",\n                    fix(fixer) {\n                        return fixer.insertTextAfter(tagToken, \" \");\n                    }\n                });\n            }\n        }\n\n        return {\n            TaggedTemplateExpression: checkSpacing\n        };\n    }\n};\n\n/**\n * @fileoverview Require or disallow Unicode BOM\n * @author Andrew Johnston <https://github.com/ehjay>\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar unicodeBom = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require or disallow Unicode byte order mark (BOM)\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/unicode-bom\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                enum: [\"always\", \"never\"]\n            }\n        ],\n        messages: {\n            expected: \"Expected Unicode BOM (Byte Order Mark).\",\n            unexpected: \"Unexpected Unicode BOM (Byte Order Mark).\"\n        }\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n\n            Program: function checkUnicodeBOM(node) {\n\n                const sourceCode = context.getSourceCode(),\n                    location = { column: 0, line: 1 },\n                    requireBOM = context.options[0] || \"never\";\n\n                if (!sourceCode.hasBOM && (requireBOM === \"always\")) {\n                    context.report({\n                        node,\n                        loc: location,\n                        messageId: \"expected\",\n                        fix(fixer) {\n                            return fixer.insertTextBeforeRange([0, 1], \"\\uFEFF\");\n                        }\n                    });\n                } else if (sourceCode.hasBOM && (requireBOM === \"never\")) {\n                    context.report({\n                        node,\n                        loc: location,\n                        messageId: \"unexpected\",\n                        fix(fixer) {\n                            return fixer.removeRange([-1, 0]);\n                        }\n                    });\n                }\n            }\n\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Determines if the given node is a NaN `Identifier` node.\n * @param {ASTNode|null} node The node to check.\n * @returns {boolean} `true` if the node is 'NaN' identifier.\n */\nfunction isNaNIdentifier(node) {\n    return Boolean(node) && node.type === \"Identifier\" && node.name === \"NaN\";\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar useIsnan = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"require calls to `isNaN()` when checking for `NaN`\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/use-isnan\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    enforceForSwitchCase: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    enforceForIndexOf: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        messages: {\n            comparisonWithNaN: \"Use the isNaN function to compare with NaN.\",\n            switchNaN: \"'switch(NaN)' can never match a case clause. Use Number.isNaN instead of the switch.\",\n            caseNaN: \"'case NaN' can never match. Use Number.isNaN before the switch.\",\n            indexOfNaN: \"Array prototype method '{{ methodName }}' cannot find NaN.\"\n        }\n    },\n\n    create(context) {\n\n        const enforceForSwitchCase = context.options[0] && context.options[0].enforceForSwitchCase;\n        const enforceForIndexOf = context.options[0] && context.options[0].enforceForIndexOf;\n\n        /**\n         * Checks the given `BinaryExpression` node for `foo === NaN` and other comparisons.\n         * @param {ASTNode} node The node to check.\n         * @returns {void}\n         */\n        function checkBinaryExpression(node) {\n            if (\n                /^(?:[<>]|[!=]=)=?$/u.test(node.operator) &&\n                (isNaNIdentifier(node.left) || isNaNIdentifier(node.right))\n            ) {\n                context.report({ node, messageId: \"comparisonWithNaN\" });\n            }\n        }\n\n        /**\n         * Checks the discriminant and all case clauses of the given `SwitchStatement` node for `switch(NaN)` and `case NaN:`\n         * @param {ASTNode} node The node to check.\n         * @returns {void}\n         */\n        function checkSwitchStatement(node) {\n            if (isNaNIdentifier(node.discriminant)) {\n                context.report({ node, messageId: \"switchNaN\" });\n            }\n\n            for (const switchCase of node.cases) {\n                if (isNaNIdentifier(switchCase.test)) {\n                    context.report({ node: switchCase, messageId: \"caseNaN\" });\n                }\n            }\n        }\n\n        /**\n         * Checks the the given `CallExpression` node for `.indexOf(NaN)` and `.lastIndexOf(NaN)`.\n         * @param {ASTNode} node The node to check.\n         * @returns {void}\n         */\n        function checkCallExpression(node) {\n            const callee = node.callee;\n\n            if (callee.type === \"MemberExpression\") {\n                const methodName = astUtils$1.getStaticPropertyName(callee);\n\n                if (\n                    (methodName === \"indexOf\" || methodName === \"lastIndexOf\") &&\n                    node.arguments.length === 1 &&\n                    isNaNIdentifier(node.arguments[0])\n                ) {\n                    context.report({ node, messageId: \"indexOfNaN\", data: { methodName } });\n                }\n            }\n        }\n\n        const listeners = {\n            BinaryExpression: checkBinaryExpression\n        };\n\n        if (enforceForSwitchCase) {\n            listeners.SwitchStatement = checkSwitchStatement;\n        }\n\n        if (enforceForIndexOf) {\n            listeners.CallExpression = checkCallExpression;\n        }\n\n        return listeners;\n    }\n};\n\nvar name$5 = \"doctrine\";\nvar description$5 = \"JSDoc parser\";\nvar homepage$5 = \"https://github.com/eslint/doctrine\";\nvar main$5 = \"lib/doctrine.js\";\nvar version$8 = \"3.0.0\";\nvar engines$5 = {\n\tnode: \">=6.0.0\"\n};\nvar directories = {\n\tlib: \"./lib\"\n};\nvar files$3 = [\n\t\"lib\"\n];\nvar maintainers$2 = [\n\t{\n\t\tname: \"Nicholas C. Zakas\",\n\t\temail: \"nicholas+npm@nczconsulting.com\",\n\t\tweb: \"https://www.nczonline.net\"\n\t},\n\t{\n\t\tname: \"Yusuke Suzuki\",\n\t\temail: \"utatane.tea@gmail.com\",\n\t\tweb: \"https://github.com/Constellation\"\n\t}\n];\nvar repository$5 = \"eslint/doctrine\";\nvar devDependencies$5 = {\n\tcoveralls: \"^3.0.1\",\n\tdateformat: \"^1.0.11\",\n\teslint: \"^1.10.3\",\n\t\"eslint-release\": \"^1.0.0\",\n\tlinefix: \"^0.1.1\",\n\tmocha: \"^3.4.2\",\n\t\"npm-license\": \"^0.3.1\",\n\tnyc: \"^10.3.2\",\n\tsemver: \"^5.0.3\",\n\tshelljs: \"^0.5.3\",\n\t\"shelljs-nodecli\": \"^0.1.1\",\n\tshould: \"^5.0.1\"\n};\nvar license$5 = \"Apache-2.0\";\nvar scripts$5 = {\n\tpretest: \"npm run lint\",\n\ttest: \"nyc mocha\",\n\tcoveralls: \"nyc report --reporter=text-lcov | coveralls\",\n\tlint: \"eslint lib/\",\n\t\"generate-release\": \"eslint-generate-release\",\n\t\"generate-alpharelease\": \"eslint-generate-prerelease alpha\",\n\t\"generate-betarelease\": \"eslint-generate-prerelease beta\",\n\t\"generate-rcrelease\": \"eslint-generate-prerelease rc\",\n\t\"publish-release\": \"eslint-publish-release\"\n};\nvar dependencies$4 = {\n\tesutils: \"^2.0.2\"\n};\nvar _package$a = {\n\tname: name$5,\n\tdescription: description$5,\n\thomepage: homepage$5,\n\tmain: main$5,\n\tversion: version$8,\n\tengines: engines$5,\n\tdirectories: directories,\n\tfiles: files$3,\n\tmaintainers: maintainers$2,\n\trepository: repository$5,\n\tdevDependencies: devDependencies$5,\n\tlicense: license$5,\n\tscripts: scripts$5,\n\tdependencies: dependencies$4\n};\n\nvar _package$b = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  name: name$5,\n  description: description$5,\n  homepage: homepage$5,\n  main: main$5,\n  version: version$8,\n  engines: engines$5,\n  directories: directories,\n  files: files$3,\n  maintainers: maintainers$2,\n  repository: repository$5,\n  devDependencies: devDependencies$5,\n  license: license$5,\n  scripts: scripts$5,\n  dependencies: dependencies$4,\n  'default': _package$a\n});\n\nvar require$$0$3 = getCjsExportFromNamespace(_package$b);\n\nvar utility = createCommonjsModule(function (module, exports) {\n/*\n * @fileoverview Utilities for Doctrine\n * @author Yusuke Suzuki <utatane.tea@gmail.com>\n */\n\n\n(function () {\n\n    var VERSION;\n\n    VERSION = require$$0$3.version;\n    exports.VERSION = VERSION;\n\n    function DoctrineError(message) {\n        this.name = 'DoctrineError';\n        this.message = message;\n    }\n    DoctrineError.prototype = (function () {\n        var Middle = function () { };\n        Middle.prototype = Error.prototype;\n        return new Middle();\n    }());\n    DoctrineError.prototype.constructor = DoctrineError;\n    exports.DoctrineError = DoctrineError;\n\n    function throwError(message) {\n        throw new DoctrineError(message);\n    }\n    exports.throwError = throwError;\n\n    exports.assert = assert;\n}());\n\n/* vim: set sw=4 ts=4 et tw=80 : */\n});\nvar utility_1 = utility.VERSION;\nvar utility_2 = utility.DoctrineError;\nvar utility_3 = utility.throwError;\nvar utility_4 = utility.assert;\n\nvar typed = createCommonjsModule(function (module, exports) {\n/*\n * @fileoverview Type expression parser.\n * @author Yusuke Suzuki <utatane.tea@gmail.com>\n * @author Dan Tao <daniel.tao@gmail.com>\n * @author Andrew Eisenberg <andrew@eisenberg.as>\n */\n\n// \"typed\", the Type Expression Parser for doctrine.\n\n(function () {\n\n    var Syntax,\n        Token,\n        source,\n        length,\n        index,\n        previous,\n        token,\n        value,\n        esutils,\n        utility$1,\n        rangeOffset,\n        addRange;\n\n    esutils = utils;\n    utility$1 = utility;\n\n    Syntax = {\n        NullableLiteral: 'NullableLiteral',\n        AllLiteral: 'AllLiteral',\n        NullLiteral: 'NullLiteral',\n        UndefinedLiteral: 'UndefinedLiteral',\n        VoidLiteral: 'VoidLiteral',\n        UnionType: 'UnionType',\n        ArrayType: 'ArrayType',\n        RecordType: 'RecordType',\n        FieldType: 'FieldType',\n        FunctionType: 'FunctionType',\n        ParameterType: 'ParameterType',\n        RestType: 'RestType',\n        NonNullableType: 'NonNullableType',\n        OptionalType: 'OptionalType',\n        NullableType: 'NullableType',\n        NameExpression: 'NameExpression',\n        TypeApplication: 'TypeApplication',\n        StringLiteralType: 'StringLiteralType',\n        NumericLiteralType: 'NumericLiteralType',\n        BooleanLiteralType: 'BooleanLiteralType'\n    };\n\n    Token = {\n        ILLEGAL: 0,    // ILLEGAL\n        DOT_LT: 1,     // .<\n        REST: 2,       // ...\n        LT: 3,         // <\n        GT: 4,         // >\n        LPAREN: 5,     // (\n        RPAREN: 6,     // )\n        LBRACE: 7,     // {\n        RBRACE: 8,     // }\n        LBRACK: 9,    // [\n        RBRACK: 10,    // ]\n        COMMA: 11,     // ,\n        COLON: 12,     // :\n        STAR: 13,      // *\n        PIPE: 14,      // |\n        QUESTION: 15,  // ?\n        BANG: 16,      // !\n        EQUAL: 17,     // =\n        NAME: 18,      // name token\n        STRING: 19,    // string\n        NUMBER: 20,    // number\n        EOF: 21\n    };\n\n    function isTypeName(ch) {\n        return '><(){}[],:*|?!='.indexOf(String.fromCharCode(ch)) === -1 && !esutils.code.isWhiteSpace(ch) && !esutils.code.isLineTerminator(ch);\n    }\n\n    function Context(previous, index, token, value) {\n        this._previous = previous;\n        this._index = index;\n        this._token = token;\n        this._value = value;\n    }\n\n    Context.prototype.restore = function () {\n        previous = this._previous;\n        index = this._index;\n        token = this._token;\n        value = this._value;\n    };\n\n    Context.save = function () {\n        return new Context(previous, index, token, value);\n    };\n\n    function maybeAddRange(node, range) {\n        if (addRange) {\n            node.range = [range[0] + rangeOffset, range[1] + rangeOffset];\n        }\n        return node;\n    }\n\n    function advance() {\n        var ch = source.charAt(index);\n        index += 1;\n        return ch;\n    }\n\n    function scanHexEscape(prefix) {\n        var i, len, ch, code = 0;\n\n        len = (prefix === 'u') ? 4 : 2;\n        for (i = 0; i < len; ++i) {\n            if (index < length && esutils.code.isHexDigit(source.charCodeAt(index))) {\n                ch = advance();\n                code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase());\n            } else {\n                return '';\n            }\n        }\n        return String.fromCharCode(code);\n    }\n\n    function scanString() {\n        var str = '', quote, ch, code, unescaped, restore; //TODO review removal octal = false\n        quote = source.charAt(index);\n        ++index;\n\n        while (index < length) {\n            ch = advance();\n\n            if (ch === quote) {\n                quote = '';\n                break;\n            } else if (ch === '\\\\') {\n                ch = advance();\n                if (!esutils.code.isLineTerminator(ch.charCodeAt(0))) {\n                    switch (ch) {\n                    case 'n':\n                        str += '\\n';\n                        break;\n                    case 'r':\n                        str += '\\r';\n                        break;\n                    case 't':\n                        str += '\\t';\n                        break;\n                    case 'u':\n                    case 'x':\n                        restore = index;\n                        unescaped = scanHexEscape(ch);\n                        if (unescaped) {\n                            str += unescaped;\n                        } else {\n                            index = restore;\n                            str += ch;\n                        }\n                        break;\n                    case 'b':\n                        str += '\\b';\n                        break;\n                    case 'f':\n                        str += '\\f';\n                        break;\n                    case 'v':\n                        str += '\\v';\n                        break;\n\n                    default:\n                        if (esutils.code.isOctalDigit(ch.charCodeAt(0))) {\n                            code = '01234567'.indexOf(ch);\n\n                            // \\0 is not octal escape sequence\n                            // Deprecating unused code. TODO review removal\n                            //if (code !== 0) {\n                            //    octal = true;\n                            //}\n\n                            if (index < length && esutils.code.isOctalDigit(source.charCodeAt(index))) {\n                                //TODO Review Removal octal = true;\n                                code = code * 8 + '01234567'.indexOf(advance());\n\n                                // 3 digits are only allowed when string starts\n                                // with 0, 1, 2, 3\n                                if ('0123'.indexOf(ch) >= 0 &&\n                                        index < length &&\n                                        esutils.code.isOctalDigit(source.charCodeAt(index))) {\n                                    code = code * 8 + '01234567'.indexOf(advance());\n                                }\n                            }\n                            str += String.fromCharCode(code);\n                        } else {\n                            str += ch;\n                        }\n                        break;\n                    }\n                } else {\n                    if (ch ===  '\\r' && source.charCodeAt(index) === 0x0A  /* '\\n' */) {\n                        ++index;\n                    }\n                }\n            } else if (esutils.code.isLineTerminator(ch.charCodeAt(0))) {\n                break;\n            } else {\n                str += ch;\n            }\n        }\n\n        if (quote !== '') {\n            utility$1.throwError('unexpected quote');\n        }\n\n        value = str;\n        return Token.STRING;\n    }\n\n    function scanNumber() {\n        var number, ch;\n\n        number = '';\n        ch = source.charCodeAt(index);\n\n        if (ch !== 0x2E  /* '.' */) {\n            number = advance();\n            ch = source.charCodeAt(index);\n\n            if (number === '0') {\n                if (ch === 0x78  /* 'x' */ || ch === 0x58  /* 'X' */) {\n                    number += advance();\n                    while (index < length) {\n                        ch = source.charCodeAt(index);\n                        if (!esutils.code.isHexDigit(ch)) {\n                            break;\n                        }\n                        number += advance();\n                    }\n\n                    if (number.length <= 2) {\n                        // only 0x\n                        utility$1.throwError('unexpected token');\n                    }\n\n                    if (index < length) {\n                        ch = source.charCodeAt(index);\n                        if (esutils.code.isIdentifierStartES5(ch)) {\n                            utility$1.throwError('unexpected token');\n                        }\n                    }\n                    value = parseInt(number, 16);\n                    return Token.NUMBER;\n                }\n\n                if (esutils.code.isOctalDigit(ch)) {\n                    number += advance();\n                    while (index < length) {\n                        ch = source.charCodeAt(index);\n                        if (!esutils.code.isOctalDigit(ch)) {\n                            break;\n                        }\n                        number += advance();\n                    }\n\n                    if (index < length) {\n                        ch = source.charCodeAt(index);\n                        if (esutils.code.isIdentifierStartES5(ch) || esutils.code.isDecimalDigit(ch)) {\n                            utility$1.throwError('unexpected token');\n                        }\n                    }\n                    value = parseInt(number, 8);\n                    return Token.NUMBER;\n                }\n\n                if (esutils.code.isDecimalDigit(ch)) {\n                    utility$1.throwError('unexpected token');\n                }\n            }\n\n            while (index < length) {\n                ch = source.charCodeAt(index);\n                if (!esutils.code.isDecimalDigit(ch)) {\n                    break;\n                }\n                number += advance();\n            }\n        }\n\n        if (ch === 0x2E  /* '.' */) {\n            number += advance();\n            while (index < length) {\n                ch = source.charCodeAt(index);\n                if (!esutils.code.isDecimalDigit(ch)) {\n                    break;\n                }\n                number += advance();\n            }\n        }\n\n        if (ch === 0x65  /* 'e' */ || ch === 0x45  /* 'E' */) {\n            number += advance();\n\n            ch = source.charCodeAt(index);\n            if (ch === 0x2B  /* '+' */ || ch === 0x2D  /* '-' */) {\n                number += advance();\n            }\n\n            ch = source.charCodeAt(index);\n            if (esutils.code.isDecimalDigit(ch)) {\n                number += advance();\n                while (index < length) {\n                    ch = source.charCodeAt(index);\n                    if (!esutils.code.isDecimalDigit(ch)) {\n                        break;\n                    }\n                    number += advance();\n                }\n            } else {\n                utility$1.throwError('unexpected token');\n            }\n        }\n\n        if (index < length) {\n            ch = source.charCodeAt(index);\n            if (esutils.code.isIdentifierStartES5(ch)) {\n                utility$1.throwError('unexpected token');\n            }\n        }\n\n        value = parseFloat(number);\n        return Token.NUMBER;\n    }\n\n\n    function scanTypeName() {\n        var ch, ch2;\n\n        value = advance();\n        while (index < length && isTypeName(source.charCodeAt(index))) {\n            ch = source.charCodeAt(index);\n            if (ch === 0x2E  /* '.' */) {\n                if ((index + 1) >= length) {\n                    return Token.ILLEGAL;\n                }\n                ch2 = source.charCodeAt(index + 1);\n                if (ch2 === 0x3C  /* '<' */) {\n                    break;\n                }\n            }\n            value += advance();\n        }\n        return Token.NAME;\n    }\n\n    function next() {\n        var ch;\n\n        previous = index;\n\n        while (index < length && esutils.code.isWhiteSpace(source.charCodeAt(index))) {\n            advance();\n        }\n        if (index >= length) {\n            token = Token.EOF;\n            return token;\n        }\n\n        ch = source.charCodeAt(index);\n        switch (ch) {\n        case 0x27:  /* ''' */\n        case 0x22:  /* '\"' */\n            token = scanString();\n            return token;\n\n        case 0x3A:  /* ':' */\n            advance();\n            token = Token.COLON;\n            return token;\n\n        case 0x2C:  /* ',' */\n            advance();\n            token = Token.COMMA;\n            return token;\n\n        case 0x28:  /* '(' */\n            advance();\n            token = Token.LPAREN;\n            return token;\n\n        case 0x29:  /* ')' */\n            advance();\n            token = Token.RPAREN;\n            return token;\n\n        case 0x5B:  /* '[' */\n            advance();\n            token = Token.LBRACK;\n            return token;\n\n        case 0x5D:  /* ']' */\n            advance();\n            token = Token.RBRACK;\n            return token;\n\n        case 0x7B:  /* '{' */\n            advance();\n            token = Token.LBRACE;\n            return token;\n\n        case 0x7D:  /* '}' */\n            advance();\n            token = Token.RBRACE;\n            return token;\n\n        case 0x2E:  /* '.' */\n            if (index + 1 < length) {\n                ch = source.charCodeAt(index + 1);\n                if (ch === 0x3C  /* '<' */) {\n                    advance();  // '.'\n                    advance();  // '<'\n                    token = Token.DOT_LT;\n                    return token;\n                }\n\n                if (ch === 0x2E  /* '.' */ && index + 2 < length && source.charCodeAt(index + 2) === 0x2E  /* '.' */) {\n                    advance();  // '.'\n                    advance();  // '.'\n                    advance();  // '.'\n                    token = Token.REST;\n                    return token;\n                }\n\n                if (esutils.code.isDecimalDigit(ch)) {\n                    token = scanNumber();\n                    return token;\n                }\n            }\n            token = Token.ILLEGAL;\n            return token;\n\n        case 0x3C:  /* '<' */\n            advance();\n            token = Token.LT;\n            return token;\n\n        case 0x3E:  /* '>' */\n            advance();\n            token = Token.GT;\n            return token;\n\n        case 0x2A:  /* '*' */\n            advance();\n            token = Token.STAR;\n            return token;\n\n        case 0x7C:  /* '|' */\n            advance();\n            token = Token.PIPE;\n            return token;\n\n        case 0x3F:  /* '?' */\n            advance();\n            token = Token.QUESTION;\n            return token;\n\n        case 0x21:  /* '!' */\n            advance();\n            token = Token.BANG;\n            return token;\n\n        case 0x3D:  /* '=' */\n            advance();\n            token = Token.EQUAL;\n            return token;\n\n        case 0x2D: /* '-' */\n            token = scanNumber();\n            return token;\n\n        default:\n            if (esutils.code.isDecimalDigit(ch)) {\n                token = scanNumber();\n                return token;\n            }\n\n            // type string permits following case,\n            //\n            // namespace.module.MyClass\n            //\n            // this reduced 1 token TK_NAME\n            utility$1.assert(isTypeName(ch));\n            token = scanTypeName();\n            return token;\n        }\n    }\n\n    function consume(target, text) {\n        utility$1.assert(token === target, text || 'consumed token not matched');\n        next();\n    }\n\n    function expect(target, message) {\n        if (token !== target) {\n            utility$1.throwError(message || 'unexpected token');\n        }\n        next();\n    }\n\n    // UnionType := '(' TypeUnionList ')'\n    //\n    // TypeUnionList :=\n    //     <<empty>>\n    //   | NonemptyTypeUnionList\n    //\n    // NonemptyTypeUnionList :=\n    //     TypeExpression\n    //   | TypeExpression '|' NonemptyTypeUnionList\n    function parseUnionType() {\n        var elements, startIndex = index - 1;\n        consume(Token.LPAREN, 'UnionType should start with (');\n        elements = [];\n        if (token !== Token.RPAREN) {\n            while (true) {\n                elements.push(parseTypeExpression());\n                if (token === Token.RPAREN) {\n                    break;\n                }\n                expect(Token.PIPE);\n            }\n        }\n        consume(Token.RPAREN, 'UnionType should end with )');\n        return maybeAddRange({\n            type: Syntax.UnionType,\n            elements: elements\n        }, [startIndex, previous]);\n    }\n\n    // ArrayType := '[' ElementTypeList ']'\n    //\n    // ElementTypeList :=\n    //     <<empty>>\n    //  | TypeExpression\n    //  | '...' TypeExpression\n    //  | TypeExpression ',' ElementTypeList\n    function parseArrayType() {\n        var elements, startIndex = index - 1, restStartIndex;\n        consume(Token.LBRACK, 'ArrayType should start with [');\n        elements = [];\n        while (token !== Token.RBRACK) {\n            if (token === Token.REST) {\n                restStartIndex = index - 3;\n                consume(Token.REST);\n                elements.push(maybeAddRange({\n                    type: Syntax.RestType,\n                    expression: parseTypeExpression()\n                }, [restStartIndex, previous]));\n                break;\n            } else {\n                elements.push(parseTypeExpression());\n            }\n            if (token !== Token.RBRACK) {\n                expect(Token.COMMA);\n            }\n        }\n        expect(Token.RBRACK);\n        return maybeAddRange({\n            type: Syntax.ArrayType,\n            elements: elements\n        }, [startIndex, previous]);\n    }\n\n    function parseFieldName() {\n        var v = value;\n        if (token === Token.NAME || token === Token.STRING) {\n            next();\n            return v;\n        }\n\n        if (token === Token.NUMBER) {\n            consume(Token.NUMBER);\n            return String(v);\n        }\n\n        utility$1.throwError('unexpected token');\n    }\n\n    // FieldType :=\n    //     FieldName\n    //   | FieldName ':' TypeExpression\n    //\n    // FieldName :=\n    //     NameExpression\n    //   | StringLiteral\n    //   | NumberLiteral\n    //   | ReservedIdentifier\n    function parseFieldType() {\n        var key, rangeStart = previous;\n\n        key = parseFieldName();\n        if (token === Token.COLON) {\n            consume(Token.COLON);\n            return maybeAddRange({\n                type: Syntax.FieldType,\n                key: key,\n                value: parseTypeExpression()\n            }, [rangeStart, previous]);\n        }\n        return maybeAddRange({\n            type: Syntax.FieldType,\n            key: key,\n            value: null\n        }, [rangeStart, previous]);\n    }\n\n    // RecordType := '{' FieldTypeList '}'\n    //\n    // FieldTypeList :=\n    //     <<empty>>\n    //   | FieldType\n    //   | FieldType ',' FieldTypeList\n    function parseRecordType() {\n        var fields, rangeStart = index - 1, rangeEnd;\n\n        consume(Token.LBRACE, 'RecordType should start with {');\n        fields = [];\n        if (token === Token.COMMA) {\n            consume(Token.COMMA);\n        } else {\n            while (token !== Token.RBRACE) {\n                fields.push(parseFieldType());\n                if (token !== Token.RBRACE) {\n                    expect(Token.COMMA);\n                }\n            }\n        }\n        rangeEnd = index;\n        expect(Token.RBRACE);\n        return maybeAddRange({\n            type: Syntax.RecordType,\n            fields: fields\n        }, [rangeStart, rangeEnd]);\n    }\n\n    // NameExpression :=\n    //    Identifier\n    //  | TagIdentifier ':' Identifier\n    //\n    // Tag identifier is one of \"module\", \"external\" or \"event\"\n    // Identifier is the same as Token.NAME, including any dots, something like\n    // namespace.module.MyClass\n    function parseNameExpression() {\n        var name = value, rangeStart = index - name.length;\n        expect(Token.NAME);\n\n        if (token === Token.COLON && (\n                name === 'module' ||\n                name === 'external' ||\n                name === 'event')) {\n            consume(Token.COLON);\n            name += ':' + value;\n            expect(Token.NAME);\n        }\n\n        return maybeAddRange({\n            type: Syntax.NameExpression,\n            name: name\n        }, [rangeStart, previous]);\n    }\n\n    // TypeExpressionList :=\n    //     TopLevelTypeExpression\n    //   | TopLevelTypeExpression ',' TypeExpressionList\n    function parseTypeExpressionList() {\n        var elements = [];\n\n        elements.push(parseTop());\n        while (token === Token.COMMA) {\n            consume(Token.COMMA);\n            elements.push(parseTop());\n        }\n        return elements;\n    }\n\n    // TypeName :=\n    //     NameExpression\n    //   | NameExpression TypeApplication\n    //\n    // TypeApplication :=\n    //     '.<' TypeExpressionList '>'\n    //   | '<' TypeExpressionList '>'   // this is extension of doctrine\n    function parseTypeName() {\n        var expr, applications, startIndex = index - value.length;\n\n        expr = parseNameExpression();\n        if (token === Token.DOT_LT || token === Token.LT) {\n            next();\n            applications = parseTypeExpressionList();\n            expect(Token.GT);\n            return maybeAddRange({\n                type: Syntax.TypeApplication,\n                expression: expr,\n                applications: applications\n            }, [startIndex, previous]);\n        }\n        return expr;\n    }\n\n    // ResultType :=\n    //     <<empty>>\n    //   | ':' void\n    //   | ':' TypeExpression\n    //\n    // BNF is above\n    // but, we remove <<empty>> pattern, so token is always TypeToken::COLON\n    function parseResultType() {\n        consume(Token.COLON, 'ResultType should start with :');\n        if (token === Token.NAME && value === 'void') {\n            consume(Token.NAME);\n            return {\n                type: Syntax.VoidLiteral\n            };\n        }\n        return parseTypeExpression();\n    }\n\n    // ParametersType :=\n    //     RestParameterType\n    //   | NonRestParametersType\n    //   | NonRestParametersType ',' RestParameterType\n    //\n    // RestParameterType :=\n    //     '...'\n    //     '...' Identifier\n    //\n    // NonRestParametersType :=\n    //     ParameterType ',' NonRestParametersType\n    //   | ParameterType\n    //   | OptionalParametersType\n    //\n    // OptionalParametersType :=\n    //     OptionalParameterType\n    //   | OptionalParameterType, OptionalParametersType\n    //\n    // OptionalParameterType := ParameterType=\n    //\n    // ParameterType := TypeExpression | Identifier ':' TypeExpression\n    //\n    // Identifier is \"new\" or \"this\"\n    function parseParametersType() {\n        var params = [], optionalSequence = false, expr, rest = false, startIndex, restStartIndex = index - 3, nameStartIndex;\n\n        while (token !== Token.RPAREN) {\n            if (token === Token.REST) {\n                // RestParameterType\n                consume(Token.REST);\n                rest = true;\n            }\n\n            startIndex = previous;\n\n            expr = parseTypeExpression();\n            if (expr.type === Syntax.NameExpression && token === Token.COLON) {\n                nameStartIndex = previous - expr.name.length;\n                // Identifier ':' TypeExpression\n                consume(Token.COLON);\n                expr = maybeAddRange({\n                    type: Syntax.ParameterType,\n                    name: expr.name,\n                    expression: parseTypeExpression()\n                }, [nameStartIndex, previous]);\n            }\n            if (token === Token.EQUAL) {\n                consume(Token.EQUAL);\n                expr = maybeAddRange({\n                    type: Syntax.OptionalType,\n                    expression: expr\n                }, [startIndex, previous]);\n                optionalSequence = true;\n            } else {\n                if (optionalSequence) {\n                    utility$1.throwError('unexpected token');\n                }\n            }\n            if (rest) {\n                expr = maybeAddRange({\n                    type: Syntax.RestType,\n                    expression: expr\n                }, [restStartIndex, previous]);\n            }\n            params.push(expr);\n            if (token !== Token.RPAREN) {\n                expect(Token.COMMA);\n            }\n        }\n        return params;\n    }\n\n    // FunctionType := 'function' FunctionSignatureType\n    //\n    // FunctionSignatureType :=\n    //   | TypeParameters '(' ')' ResultType\n    //   | TypeParameters '(' ParametersType ')' ResultType\n    //   | TypeParameters '(' 'this' ':' TypeName ')' ResultType\n    //   | TypeParameters '(' 'this' ':' TypeName ',' ParametersType ')' ResultType\n    function parseFunctionType() {\n        var isNew, thisBinding, params, result, fnType, startIndex = index - value.length;\n        utility$1.assert(token === Token.NAME && value === 'function', 'FunctionType should start with \\'function\\'');\n        consume(Token.NAME);\n\n        // Google Closure Compiler is not implementing TypeParameters.\n        // So we do not. if we don't get '(', we see it as error.\n        expect(Token.LPAREN);\n\n        isNew = false;\n        params = [];\n        thisBinding = null;\n        if (token !== Token.RPAREN) {\n            // ParametersType or 'this'\n            if (token === Token.NAME &&\n                    (value === 'this' || value === 'new')) {\n                // 'this' or 'new'\n                // 'new' is Closure Compiler extension\n                isNew = value === 'new';\n                consume(Token.NAME);\n                expect(Token.COLON);\n                thisBinding = parseTypeName();\n                if (token === Token.COMMA) {\n                    consume(Token.COMMA);\n                    params = parseParametersType();\n                }\n            } else {\n                params = parseParametersType();\n            }\n        }\n\n        expect(Token.RPAREN);\n\n        result = null;\n        if (token === Token.COLON) {\n            result = parseResultType();\n        }\n\n        fnType = maybeAddRange({\n            type: Syntax.FunctionType,\n            params: params,\n            result: result\n        }, [startIndex, previous]);\n        if (thisBinding) {\n            // avoid adding null 'new' and 'this' properties\n            fnType['this'] = thisBinding;\n            if (isNew) {\n                fnType['new'] = true;\n            }\n        }\n        return fnType;\n    }\n\n    // BasicTypeExpression :=\n    //     '*'\n    //   | 'null'\n    //   | 'undefined'\n    //   | TypeName\n    //   | FunctionType\n    //   | UnionType\n    //   | RecordType\n    //   | ArrayType\n    function parseBasicTypeExpression() {\n        var context, startIndex;\n        switch (token) {\n        case Token.STAR:\n            consume(Token.STAR);\n            return maybeAddRange({\n                type: Syntax.AllLiteral\n            }, [previous - 1, previous]);\n\n        case Token.LPAREN:\n            return parseUnionType();\n\n        case Token.LBRACK:\n            return parseArrayType();\n\n        case Token.LBRACE:\n            return parseRecordType();\n\n        case Token.NAME:\n            startIndex = index - value.length;\n\n            if (value === 'null') {\n                consume(Token.NAME);\n                return maybeAddRange({\n                    type: Syntax.NullLiteral\n                }, [startIndex, previous]);\n            }\n\n            if (value === 'undefined') {\n                consume(Token.NAME);\n                return maybeAddRange({\n                    type: Syntax.UndefinedLiteral\n                }, [startIndex, previous]);\n            }\n\n            if (value === 'true' || value === 'false') {\n                consume(Token.NAME);\n                return maybeAddRange({\n                    type: Syntax.BooleanLiteralType,\n                    value: value === 'true'\n                }, [startIndex, previous]);\n            }\n\n            context = Context.save();\n            if (value === 'function') {\n                try {\n                    return parseFunctionType();\n                } catch (e) {\n                    context.restore();\n                }\n            }\n\n            return parseTypeName();\n\n        case Token.STRING:\n            next();\n            return maybeAddRange({\n                type: Syntax.StringLiteralType,\n                value: value\n            }, [previous - value.length - 2, previous]);\n\n        case Token.NUMBER:\n            next();\n            return maybeAddRange({\n                type: Syntax.NumericLiteralType,\n                value: value\n            }, [previous - String(value).length, previous]);\n\n        default:\n            utility$1.throwError('unexpected token');\n        }\n    }\n\n    // TypeExpression :=\n    //     BasicTypeExpression\n    //   | '?' BasicTypeExpression\n    //   | '!' BasicTypeExpression\n    //   | BasicTypeExpression '?'\n    //   | BasicTypeExpression '!'\n    //   | '?'\n    //   | BasicTypeExpression '[]'\n    function parseTypeExpression() {\n        var expr, rangeStart;\n\n        if (token === Token.QUESTION) {\n            rangeStart = index - 1;\n            consume(Token.QUESTION);\n            if (token === Token.COMMA || token === Token.EQUAL || token === Token.RBRACE ||\n                    token === Token.RPAREN || token === Token.PIPE || token === Token.EOF ||\n                    token === Token.RBRACK || token === Token.GT) {\n                return maybeAddRange({\n                    type: Syntax.NullableLiteral\n                }, [rangeStart, previous]);\n            }\n            return maybeAddRange({\n                type: Syntax.NullableType,\n                expression: parseBasicTypeExpression(),\n                prefix: true\n            }, [rangeStart, previous]);\n        } else if (token === Token.BANG) {\n            rangeStart = index - 1;\n            consume(Token.BANG);\n            return maybeAddRange({\n                type: Syntax.NonNullableType,\n                expression: parseBasicTypeExpression(),\n                prefix: true\n            }, [rangeStart, previous]);\n        } else {\n            rangeStart = previous;\n        }\n\n        expr = parseBasicTypeExpression();\n        if (token === Token.BANG) {\n            consume(Token.BANG);\n            return maybeAddRange({\n                type: Syntax.NonNullableType,\n                expression: expr,\n                prefix: false\n            }, [rangeStart, previous]);\n        }\n\n        if (token === Token.QUESTION) {\n            consume(Token.QUESTION);\n            return maybeAddRange({\n                type: Syntax.NullableType,\n                expression: expr,\n                prefix: false\n            }, [rangeStart, previous]);\n        }\n\n        if (token === Token.LBRACK) {\n            consume(Token.LBRACK);\n            expect(Token.RBRACK, 'expected an array-style type declaration (' + value + '[])');\n            return maybeAddRange({\n                type: Syntax.TypeApplication,\n                expression: maybeAddRange({\n                    type: Syntax.NameExpression,\n                    name: 'Array'\n                }, [rangeStart, previous]),\n                applications: [expr]\n            }, [rangeStart, previous]);\n        }\n\n        return expr;\n    }\n\n    // TopLevelTypeExpression :=\n    //      TypeExpression\n    //    | TypeUnionList\n    //\n    // This rule is Google Closure Compiler extension, not ES4\n    // like,\n    //   { number | string }\n    // If strict to ES4, we should write it as\n    //   { (number|string) }\n    function parseTop() {\n        var expr, elements;\n\n        expr = parseTypeExpression();\n        if (token !== Token.PIPE) {\n            return expr;\n        }\n\n        elements = [expr];\n        consume(Token.PIPE);\n        while (true) {\n            elements.push(parseTypeExpression());\n            if (token !== Token.PIPE) {\n                break;\n            }\n            consume(Token.PIPE);\n        }\n\n        return maybeAddRange({\n            type: Syntax.UnionType,\n            elements: elements\n        }, [0, index]);\n    }\n\n    function parseTopParamType() {\n        var expr;\n\n        if (token === Token.REST) {\n            consume(Token.REST);\n            return maybeAddRange({\n                type: Syntax.RestType,\n                expression: parseTop()\n            }, [0, index]);\n        }\n\n        expr = parseTop();\n        if (token === Token.EQUAL) {\n            consume(Token.EQUAL);\n            return maybeAddRange({\n                type: Syntax.OptionalType,\n                expression: expr\n            }, [0, index]);\n        }\n\n        return expr;\n    }\n\n    function parseType(src, opt) {\n        var expr;\n\n        source = src;\n        length = source.length;\n        index = 0;\n        previous = 0;\n        addRange = opt && opt.range;\n        rangeOffset = opt && opt.startIndex || 0;\n\n        next();\n        expr = parseTop();\n\n        if (opt && opt.midstream) {\n            return {\n                expression: expr,\n                index: previous\n            };\n        }\n\n        if (token !== Token.EOF) {\n            utility$1.throwError('not reach to EOF');\n        }\n\n        return expr;\n    }\n\n    function parseParamType(src, opt) {\n        var expr;\n\n        source = src;\n        length = source.length;\n        index = 0;\n        previous = 0;\n        addRange = opt && opt.range;\n        rangeOffset = opt && opt.startIndex || 0;\n\n        next();\n        expr = parseTopParamType();\n\n        if (opt && opt.midstream) {\n            return {\n                expression: expr,\n                index: previous\n            };\n        }\n\n        if (token !== Token.EOF) {\n            utility$1.throwError('not reach to EOF');\n        }\n\n        return expr;\n    }\n\n    function stringifyImpl(node, compact, topLevel) {\n        var result, i, iz;\n\n        switch (node.type) {\n        case Syntax.NullableLiteral:\n            result = '?';\n            break;\n\n        case Syntax.AllLiteral:\n            result = '*';\n            break;\n\n        case Syntax.NullLiteral:\n            result = 'null';\n            break;\n\n        case Syntax.UndefinedLiteral:\n            result = 'undefined';\n            break;\n\n        case Syntax.VoidLiteral:\n            result = 'void';\n            break;\n\n        case Syntax.UnionType:\n            if (!topLevel) {\n                result = '(';\n            } else {\n                result = '';\n            }\n\n            for (i = 0, iz = node.elements.length; i < iz; ++i) {\n                result += stringifyImpl(node.elements[i], compact);\n                if ((i + 1) !== iz) {\n                    result += compact ? '|' : ' | ';\n                }\n            }\n\n            if (!topLevel) {\n                result += ')';\n            }\n            break;\n\n        case Syntax.ArrayType:\n            result = '[';\n            for (i = 0, iz = node.elements.length; i < iz; ++i) {\n                result += stringifyImpl(node.elements[i], compact);\n                if ((i + 1) !== iz) {\n                    result += compact ? ',' : ', ';\n                }\n            }\n            result += ']';\n            break;\n\n        case Syntax.RecordType:\n            result = '{';\n            for (i = 0, iz = node.fields.length; i < iz; ++i) {\n                result += stringifyImpl(node.fields[i], compact);\n                if ((i + 1) !== iz) {\n                    result += compact ? ',' : ', ';\n                }\n            }\n            result += '}';\n            break;\n\n        case Syntax.FieldType:\n            if (node.value) {\n                result = node.key + (compact ? ':' : ': ') + stringifyImpl(node.value, compact);\n            } else {\n                result = node.key;\n            }\n            break;\n\n        case Syntax.FunctionType:\n            result = compact ? 'function(' : 'function (';\n\n            if (node['this']) {\n                if (node['new']) {\n                    result += (compact ? 'new:' : 'new: ');\n                } else {\n                    result += (compact ? 'this:' : 'this: ');\n                }\n\n                result += stringifyImpl(node['this'], compact);\n\n                if (node.params.length !== 0) {\n                    result += compact ? ',' : ', ';\n                }\n            }\n\n            for (i = 0, iz = node.params.length; i < iz; ++i) {\n                result += stringifyImpl(node.params[i], compact);\n                if ((i + 1) !== iz) {\n                    result += compact ? ',' : ', ';\n                }\n            }\n\n            result += ')';\n\n            if (node.result) {\n                result += (compact ? ':' : ': ') + stringifyImpl(node.result, compact);\n            }\n            break;\n\n        case Syntax.ParameterType:\n            result = node.name + (compact ? ':' : ': ') + stringifyImpl(node.expression, compact);\n            break;\n\n        case Syntax.RestType:\n            result = '...';\n            if (node.expression) {\n                result += stringifyImpl(node.expression, compact);\n            }\n            break;\n\n        case Syntax.NonNullableType:\n            if (node.prefix) {\n                result = '!' + stringifyImpl(node.expression, compact);\n            } else {\n                result = stringifyImpl(node.expression, compact) + '!';\n            }\n            break;\n\n        case Syntax.OptionalType:\n            result = stringifyImpl(node.expression, compact) + '=';\n            break;\n\n        case Syntax.NullableType:\n            if (node.prefix) {\n                result = '?' + stringifyImpl(node.expression, compact);\n            } else {\n                result = stringifyImpl(node.expression, compact) + '?';\n            }\n            break;\n\n        case Syntax.NameExpression:\n            result = node.name;\n            break;\n\n        case Syntax.TypeApplication:\n            result = stringifyImpl(node.expression, compact) + '.<';\n            for (i = 0, iz = node.applications.length; i < iz; ++i) {\n                result += stringifyImpl(node.applications[i], compact);\n                if ((i + 1) !== iz) {\n                    result += compact ? ',' : ', ';\n                }\n            }\n            result += '>';\n            break;\n\n        case Syntax.StringLiteralType:\n            result = '\"' + node.value + '\"';\n            break;\n\n        case Syntax.NumericLiteralType:\n            result = String(node.value);\n            break;\n\n        case Syntax.BooleanLiteralType:\n            result = String(node.value);\n            break;\n\n        default:\n            utility$1.throwError('Unknown type ' + node.type);\n        }\n\n        return result;\n    }\n\n    function stringify(node, options) {\n        if (options == null) {\n            options = {};\n        }\n        return stringifyImpl(node, options.compact, options.topLevel);\n    }\n\n    exports.parseType = parseType;\n    exports.parseParamType = parseParamType;\n    exports.stringify = stringify;\n    exports.Syntax = Syntax;\n}());\n/* vim: set sw=4 ts=4 et tw=80 : */\n});\nvar typed_1 = typed.parseType;\nvar typed_2 = typed.parseParamType;\nvar typed_3 = typed.stringify;\nvar typed_4 = typed.Syntax;\n\nvar doctrine = createCommonjsModule(function (module, exports) {\n/*\n * @fileoverview Main Doctrine object\n * @author Yusuke Suzuki <utatane.tea@gmail.com>\n * @author Dan Tao <daniel.tao@gmail.com>\n * @author Andrew Eisenberg <andrew@eisenberg.as>\n */\n\n(function () {\n\n    var typed$1,\n        utility$1,\n        jsdoc,\n        esutils,\n        hasOwnProperty;\n\n    esutils = utils;\n    typed$1 = typed;\n    utility$1 = utility;\n\n    function sliceSource(source, index, last) {\n        return source.slice(index, last);\n    }\n\n    hasOwnProperty = (function () {\n        var func = Object.prototype.hasOwnProperty;\n        return function hasOwnProperty(obj, name) {\n            return func.call(obj, name);\n        };\n    }());\n    function shallowCopy(obj) {\n        var ret = {}, key;\n        for (key in obj) {\n            if (obj.hasOwnProperty(key)) {\n                ret[key] = obj[key];\n            }\n        }\n        return ret;\n    }\n\n    function isASCIIAlphanumeric(ch) {\n        return (ch >= 0x61  /* 'a' */ && ch <= 0x7A  /* 'z' */) ||\n            (ch >= 0x41  /* 'A' */ && ch <= 0x5A  /* 'Z' */) ||\n            (ch >= 0x30  /* '0' */ && ch <= 0x39  /* '9' */);\n    }\n\n    function isParamTitle(title) {\n        return title === 'param' || title === 'argument' || title === 'arg';\n    }\n\n    function isReturnTitle(title) {\n        return title === 'return' || title === 'returns';\n    }\n\n    function isProperty(title) {\n        return title === 'property' || title === 'prop';\n    }\n\n    function isNameParameterRequired(title) {\n        return isParamTitle(title) || isProperty(title) ||\n            title === 'alias' || title === 'this' || title === 'mixes' || title === 'requires';\n    }\n\n    function isAllowedName(title) {\n        return isNameParameterRequired(title) || title === 'const' || title === 'constant';\n    }\n\n    function isAllowedNested(title) {\n        return isProperty(title) || isParamTitle(title);\n    }\n\n    function isAllowedOptional(title) {\n        return isProperty(title) || isParamTitle(title);\n    }\n\n    function isTypeParameterRequired(title) {\n        return isParamTitle(title) || isReturnTitle(title) ||\n            title === 'define' || title === 'enum' ||\n            title === 'implements' || title === 'this' ||\n            title === 'type' || title === 'typedef' || isProperty(title);\n    }\n\n    // Consider deprecation instead using 'isTypeParameterRequired' and 'Rules' declaration to pick when a type is optional/required\n    // This would require changes to 'parseType'\n    function isAllowedType(title) {\n        return isTypeParameterRequired(title) || title === 'throws' || title === 'const' || title === 'constant' ||\n            title === 'namespace' || title === 'member' || title === 'var' || title === 'module' ||\n            title === 'constructor' || title === 'class' || title === 'extends' || title === 'augments' ||\n            title === 'public' || title === 'private' || title === 'protected';\n    }\n\n    // A regex character class that contains all whitespace except linebreak characters (\\r, \\n, \\u2028, \\u2029)\n    var WHITESPACE = '[ \\\\f\\\\t\\\\v\\\\u00a0\\\\u1680\\\\u180e\\\\u2000-\\\\u200a\\\\u202f\\\\u205f\\\\u3000\\\\ufeff]';\n\n    var STAR_MATCHER = '(' + WHITESPACE + '*(?:\\\\*' + WHITESPACE + '?)?)(.+|[\\r\\n\\u2028\\u2029])';\n\n    function unwrapComment(doc) {\n        // JSDoc comment is following form\n        //   /**\n        //    * .......\n        //    */\n\n        return doc.\n            // remove /**\n            replace(/^\\/\\*\\*?/, '').\n            // remove */\n            replace(/\\*\\/$/, '').\n            // remove ' * ' at the beginning of a line\n            replace(new RegExp(STAR_MATCHER, 'g'), '$2').\n            // remove trailing whitespace\n            replace(/\\s*$/, '');\n    }\n\n    /**\n     * Converts an index in an \"unwrapped\" JSDoc comment to the corresponding index in the original \"wrapped\" version\n     * @param {string} originalSource The original wrapped comment\n     * @param {number} unwrappedIndex The index of a character in the unwrapped string\n     * @returns {number} The index of the corresponding character in the original wrapped string\n     */\n    function convertUnwrappedCommentIndex(originalSource, unwrappedIndex) {\n        var replacedSource = originalSource.replace(/^\\/\\*\\*?/, '');\n        var numSkippedChars = 0;\n        var matcher = new RegExp(STAR_MATCHER, 'g');\n        var match;\n\n        while ((match = matcher.exec(replacedSource))) {\n            numSkippedChars += match[1].length;\n\n            if (match.index + match[0].length > unwrappedIndex + numSkippedChars) {\n                return unwrappedIndex + numSkippedChars + originalSource.length - replacedSource.length;\n            }\n        }\n\n        return originalSource.replace(/\\*\\/$/, '').replace(/\\s*$/, '').length;\n    }\n\n    // JSDoc Tag Parser\n\n    (function (exports) {\n        var Rules,\n            index,\n            lineNumber,\n            length,\n            source,\n            originalSource,\n            recoverable,\n            sloppy,\n            strict;\n\n        function advance() {\n            var ch = source.charCodeAt(index);\n            index += 1;\n            if (esutils.code.isLineTerminator(ch) && !(ch === 0x0D  /* '\\r' */ && source.charCodeAt(index) === 0x0A  /* '\\n' */)) {\n                lineNumber += 1;\n            }\n            return String.fromCharCode(ch);\n        }\n\n        function scanTitle() {\n            var title = '';\n            // waste '@'\n            advance();\n\n            while (index < length && isASCIIAlphanumeric(source.charCodeAt(index))) {\n                title += advance();\n            }\n\n            return title;\n        }\n\n        function seekContent() {\n            var ch, waiting, last = index;\n\n            waiting = false;\n            while (last < length) {\n                ch = source.charCodeAt(last);\n                if (esutils.code.isLineTerminator(ch) && !(ch === 0x0D  /* '\\r' */ && source.charCodeAt(last + 1) === 0x0A  /* '\\n' */)) {\n                    waiting = true;\n                } else if (waiting) {\n                    if (ch === 0x40  /* '@' */) {\n                        break;\n                    }\n                    if (!esutils.code.isWhiteSpace(ch)) {\n                        waiting = false;\n                    }\n                }\n                last += 1;\n            }\n            return last;\n        }\n\n        // type expression may have nest brace, such as,\n        // { { ok: string } }\n        //\n        // therefore, scanning type expression with balancing braces.\n        function parseType(title, last, addRange) {\n            var ch, brace, type, startIndex, direct = false;\n\n\n            // search '{'\n            while (index < last) {\n                ch = source.charCodeAt(index);\n                if (esutils.code.isWhiteSpace(ch)) {\n                    advance();\n                } else if (ch === 0x7B  /* '{' */) {\n                    advance();\n                    break;\n                } else {\n                    // this is direct pattern\n                    direct = true;\n                    break;\n                }\n            }\n\n\n            if (direct) {\n                return null;\n            }\n\n            // type expression { is found\n            brace = 1;\n            type = '';\n            while (index < last) {\n                ch = source.charCodeAt(index);\n                if (esutils.code.isLineTerminator(ch)) {\n                    advance();\n                } else {\n                    if (ch === 0x7D  /* '}' */) {\n                        brace -= 1;\n                        if (brace === 0) {\n                            advance();\n                            break;\n                        }\n                    } else if (ch === 0x7B  /* '{' */) {\n                        brace += 1;\n                    }\n                    if (type === '') {\n                        startIndex = index;\n                    }\n                    type += advance();\n                }\n            }\n\n            if (brace !== 0) {\n                // braces is not balanced\n                return utility$1.throwError('Braces are not balanced');\n            }\n\n            if (isAllowedOptional(title)) {\n                return typed$1.parseParamType(type, {startIndex: convertIndex(startIndex), range: addRange});\n            }\n\n            return typed$1.parseType(type, {startIndex: convertIndex(startIndex), range: addRange});\n        }\n\n        function scanIdentifier(last) {\n            var identifier;\n            if (!esutils.code.isIdentifierStartES5(source.charCodeAt(index)) && !source[index].match(/[0-9]/)) {\n                return null;\n            }\n            identifier = advance();\n            while (index < last && esutils.code.isIdentifierPartES5(source.charCodeAt(index))) {\n                identifier += advance();\n            }\n            return identifier;\n        }\n\n        function skipWhiteSpace(last) {\n            while (index < last && (esutils.code.isWhiteSpace(source.charCodeAt(index)) || esutils.code.isLineTerminator(source.charCodeAt(index)))) {\n                advance();\n            }\n        }\n\n        function parseName(last, allowBrackets, allowNestedParams) {\n            var name = '',\n                useBrackets,\n                insideString;\n\n\n            skipWhiteSpace(last);\n\n            if (index >= last) {\n                return null;\n            }\n\n            if (source.charCodeAt(index) === 0x5B  /* '[' */) {\n                if (allowBrackets) {\n                    useBrackets = true;\n                    name = advance();\n                } else {\n                    return null;\n                }\n            }\n\n            name += scanIdentifier(last);\n\n            if (allowNestedParams) {\n                if (source.charCodeAt(index) === 0x3A /* ':' */ && (\n                        name === 'module' ||\n                        name === 'external' ||\n                        name === 'event')) {\n                    name += advance();\n                    name += scanIdentifier(last);\n\n                }\n                if(source.charCodeAt(index) === 0x5B  /* '[' */ && source.charCodeAt(index + 1) === 0x5D  /* ']' */){\n                    name += advance();\n                    name += advance();\n                }\n                while (source.charCodeAt(index) === 0x2E  /* '.' */ ||\n                        source.charCodeAt(index) === 0x2F  /* '/' */ ||\n                        source.charCodeAt(index) === 0x23  /* '#' */ ||\n                        source.charCodeAt(index) === 0x2D  /* '-' */ ||\n                        source.charCodeAt(index) === 0x7E  /* '~' */) {\n                    name += advance();\n                    name += scanIdentifier(last);\n                }\n            }\n\n            if (useBrackets) {\n                skipWhiteSpace(last);\n                // do we have a default value for this?\n                if (source.charCodeAt(index) === 0x3D  /* '=' */) {\n                    // consume the '='' symbol\n                    name += advance();\n                    skipWhiteSpace(last);\n\n                    var ch;\n                    var bracketDepth = 1;\n\n                    // scan in the default value\n                    while (index < last) {\n                        ch = source.charCodeAt(index);\n\n                        if (esutils.code.isWhiteSpace(ch)) {\n                            if (!insideString) {\n                                skipWhiteSpace(last);\n                                ch = source.charCodeAt(index);\n                            }\n                        }\n\n                        if (ch === 0x27 /* ''' */) {\n                            if (!insideString) {\n                                insideString = '\\'';\n                            } else {\n                                if (insideString === '\\'') {\n                                    insideString = '';\n                                }\n                            }\n                        }\n\n                        if (ch === 0x22 /* '\"' */) {\n                            if (!insideString) {\n                                insideString = '\"';\n                            } else {\n                                if (insideString === '\"') {\n                                    insideString = '';\n                                }\n                            }\n                        }\n\n                        if (ch === 0x5B /* '[' */) {\n                            bracketDepth++;\n                        } else if (ch === 0x5D  /* ']' */ &&\n                            --bracketDepth === 0) {\n                            break;\n                        }\n\n                        name += advance();\n                    }\n                }\n\n                skipWhiteSpace(last);\n\n                if (index >= last || source.charCodeAt(index) !== 0x5D  /* ']' */) {\n                    // we never found a closing ']'\n                    return null;\n                }\n\n                // collect the last ']'\n                name += advance();\n            }\n\n            return name;\n        }\n\n        function skipToTag() {\n            while (index < length && source.charCodeAt(index) !== 0x40  /* '@' */) {\n                advance();\n            }\n            if (index >= length) {\n                return false;\n            }\n            utility$1.assert(source.charCodeAt(index) === 0x40  /* '@' */);\n            return true;\n        }\n\n        function convertIndex(rangeIndex) {\n            if (source === originalSource) {\n                return rangeIndex;\n            }\n            return convertUnwrappedCommentIndex(originalSource, rangeIndex);\n        }\n\n        function TagParser(options, title) {\n            this._options = options;\n            this._title = title.toLowerCase();\n            this._tag = {\n                title: title,\n                description: null\n            };\n            if (this._options.lineNumbers) {\n                this._tag.lineNumber = lineNumber;\n            }\n            this._first = index - title.length - 1;\n            this._last = 0;\n            // space to save special information for title parsers.\n            this._extra = { };\n        }\n\n        // addError(err, ...)\n        TagParser.prototype.addError = function addError(errorText) {\n            var args = Array.prototype.slice.call(arguments, 1),\n                msg = errorText.replace(\n                    /%(\\d)/g,\n                    function (whole, index) {\n                        utility$1.assert(index < args.length, 'Message reference must be in range');\n                        return args[index];\n                    }\n                );\n\n            if (!this._tag.errors) {\n                this._tag.errors = [];\n            }\n            if (strict) {\n                utility$1.throwError(msg);\n            }\n            this._tag.errors.push(msg);\n            return recoverable;\n        };\n\n        TagParser.prototype.parseType = function () {\n            // type required titles\n            if (isTypeParameterRequired(this._title)) {\n                try {\n                    this._tag.type = parseType(this._title, this._last, this._options.range);\n                    if (!this._tag.type) {\n                        if (!isParamTitle(this._title) && !isReturnTitle(this._title)) {\n                            if (!this.addError('Missing or invalid tag type')) {\n                                return false;\n                            }\n                        }\n                    }\n                } catch (error) {\n                    this._tag.type = null;\n                    if (!this.addError(error.message)) {\n                        return false;\n                    }\n                }\n            } else if (isAllowedType(this._title)) {\n                // optional types\n                try {\n                    this._tag.type = parseType(this._title, this._last, this._options.range);\n                } catch (e) {\n                    //For optional types, lets drop the thrown error when we hit the end of the file\n                }\n            }\n            return true;\n        };\n\n        TagParser.prototype._parseNamePath = function (optional) {\n            var name;\n            name = parseName(this._last, sloppy && isAllowedOptional(this._title), true);\n            if (!name) {\n                if (!optional) {\n                    if (!this.addError('Missing or invalid tag name')) {\n                        return false;\n                    }\n                }\n            }\n            this._tag.name = name;\n            return true;\n        };\n\n        TagParser.prototype.parseNamePath = function () {\n            return this._parseNamePath(false);\n        };\n\n        TagParser.prototype.parseNamePathOptional = function () {\n            return this._parseNamePath(true);\n        };\n\n\n        TagParser.prototype.parseName = function () {\n            var assign, name;\n\n            // param, property requires name\n            if (isAllowedName(this._title)) {\n                this._tag.name = parseName(this._last, sloppy && isAllowedOptional(this._title), isAllowedNested(this._title));\n                if (!this._tag.name) {\n                    if (!isNameParameterRequired(this._title)) {\n                        return true;\n                    }\n\n                    // it's possible the name has already been parsed but interpreted as a type\n                    // it's also possible this is a sloppy declaration, in which case it will be\n                    // fixed at the end\n                    if (isParamTitle(this._title) && this._tag.type && this._tag.type.name) {\n                        this._extra.name = this._tag.type;\n                        this._tag.name = this._tag.type.name;\n                        this._tag.type = null;\n                    } else {\n                        if (!this.addError('Missing or invalid tag name')) {\n                            return false;\n                        }\n                    }\n                } else {\n                    name = this._tag.name;\n                    if (name.charAt(0) === '[' && name.charAt(name.length - 1) === ']') {\n                        // extract the default value if there is one\n                        // example: @param {string} [somebody=John Doe] description\n                        assign = name.substring(1, name.length - 1).split('=');\n                        if (assign.length > 1) {\n                            this._tag['default'] = assign.slice(1).join('=');\n                        }\n                        this._tag.name = assign[0];\n\n                        // convert to an optional type\n                        if (this._tag.type && this._tag.type.type !== 'OptionalType') {\n                            this._tag.type = {\n                                type: 'OptionalType',\n                                expression: this._tag.type\n                            };\n                        }\n                    }\n                }\n            }\n\n\n            return true;\n        };\n\n        TagParser.prototype.parseDescription = function parseDescription() {\n            var description = sliceSource(source, index, this._last).trim();\n            if (description) {\n                if ((/^-\\s+/).test(description)) {\n                    description = description.substring(2);\n                }\n                this._tag.description = description;\n            }\n            return true;\n        };\n\n        TagParser.prototype.parseCaption = function parseDescription() {\n            var description = sliceSource(source, index, this._last).trim();\n            var captionStartTag = '<caption>';\n            var captionEndTag = '</caption>';\n            var captionStart = description.indexOf(captionStartTag);\n            var captionEnd = description.indexOf(captionEndTag);\n            if (captionStart >= 0 && captionEnd >= 0) {\n                this._tag.caption = description.substring(\n                    captionStart + captionStartTag.length, captionEnd).trim();\n                this._tag.description = description.substring(captionEnd + captionEndTag.length).trim();\n            } else {\n                this._tag.description = description;\n            }\n            return true;\n        };\n\n        TagParser.prototype.parseKind = function parseKind() {\n            var kind, kinds;\n            kinds = {\n                'class': true,\n                'constant': true,\n                'event': true,\n                'external': true,\n                'file': true,\n                'function': true,\n                'member': true,\n                'mixin': true,\n                'module': true,\n                'namespace': true,\n                'typedef': true\n            };\n            kind = sliceSource(source, index, this._last).trim();\n            this._tag.kind = kind;\n            if (!hasOwnProperty(kinds, kind)) {\n                if (!this.addError('Invalid kind name \\'%0\\'', kind)) {\n                    return false;\n                }\n            }\n            return true;\n        };\n\n        TagParser.prototype.parseAccess = function parseAccess() {\n            var access;\n            access = sliceSource(source, index, this._last).trim();\n            this._tag.access = access;\n            if (access !== 'private' && access !== 'protected' && access !== 'public') {\n                if (!this.addError('Invalid access name \\'%0\\'', access)) {\n                    return false;\n                }\n            }\n            return true;\n        };\n\n        TagParser.prototype.parseThis = function parseThis() {\n            // this name may be a name expression (e.g. {foo.bar}),\n            // an union (e.g. {foo.bar|foo.baz}) or a name path (e.g. foo.bar)\n            var value = sliceSource(source, index, this._last).trim();\n            if (value && value.charAt(0) === '{') {\n                var gotType = this.parseType();\n                if (gotType && this._tag.type.type === 'NameExpression' || this._tag.type.type === 'UnionType') {\n                    this._tag.name = this._tag.type.name;\n                    return true;\n                } else {\n                    return this.addError('Invalid name for this');\n                }\n            } else {\n                return this.parseNamePath();\n            }\n        };\n\n        TagParser.prototype.parseVariation = function parseVariation() {\n            var variation, text;\n            text = sliceSource(source, index, this._last).trim();\n            variation = parseFloat(text, 10);\n            this._tag.variation = variation;\n            if (isNaN(variation)) {\n                if (!this.addError('Invalid variation \\'%0\\'', text)) {\n                    return false;\n                }\n            }\n            return true;\n        };\n\n        TagParser.prototype.ensureEnd = function () {\n            var shouldBeEmpty = sliceSource(source, index, this._last).trim();\n            if (shouldBeEmpty) {\n                if (!this.addError('Unknown content \\'%0\\'', shouldBeEmpty)) {\n                    return false;\n                }\n            }\n            return true;\n        };\n\n        TagParser.prototype.epilogue = function epilogue() {\n            var description;\n\n            description = this._tag.description;\n            // un-fix potentially sloppy declaration\n            if (isAllowedOptional(this._title) && !this._tag.type && description && description.charAt(0) === '[') {\n                this._tag.type = this._extra.name;\n                if (!this._tag.name) {\n                    this._tag.name = undefined;\n                }\n\n                if (!sloppy) {\n                    if (!this.addError('Missing or invalid tag name')) {\n                        return false;\n                    }\n                }\n            }\n\n            return true;\n        };\n\n        Rules = {\n            // http://usejsdoc.org/tags-access.html\n            'access': ['parseAccess'],\n            // http://usejsdoc.org/tags-alias.html\n            'alias': ['parseNamePath', 'ensureEnd'],\n            // http://usejsdoc.org/tags-augments.html\n            'augments': ['parseType', 'parseNamePathOptional', 'ensureEnd'],\n            // http://usejsdoc.org/tags-constructor.html\n            'constructor': ['parseType', 'parseNamePathOptional', 'ensureEnd'],\n            // Synonym: http://usejsdoc.org/tags-constructor.html\n            'class': ['parseType', 'parseNamePathOptional', 'ensureEnd'],\n            // Synonym: http://usejsdoc.org/tags-extends.html\n            'extends': ['parseType', 'parseNamePathOptional', 'ensureEnd'],\n            // http://usejsdoc.org/tags-example.html\n            'example': ['parseCaption'],\n            // http://usejsdoc.org/tags-deprecated.html\n            'deprecated': ['parseDescription'],\n            // http://usejsdoc.org/tags-global.html\n            'global': ['ensureEnd'],\n            // http://usejsdoc.org/tags-inner.html\n            'inner': ['ensureEnd'],\n            // http://usejsdoc.org/tags-instance.html\n            'instance': ['ensureEnd'],\n            // http://usejsdoc.org/tags-kind.html\n            'kind': ['parseKind'],\n            // http://usejsdoc.org/tags-mixes.html\n            'mixes': ['parseNamePath', 'ensureEnd'],\n            // http://usejsdoc.org/tags-mixin.html\n            'mixin': ['parseNamePathOptional', 'ensureEnd'],\n            // http://usejsdoc.org/tags-member.html\n            'member': ['parseType', 'parseNamePathOptional', 'ensureEnd'],\n            // http://usejsdoc.org/tags-method.html\n            'method': ['parseNamePathOptional', 'ensureEnd'],\n            // http://usejsdoc.org/tags-module.html\n            'module': ['parseType', 'parseNamePathOptional', 'ensureEnd'],\n            // Synonym: http://usejsdoc.org/tags-method.html\n            'func': ['parseNamePathOptional', 'ensureEnd'],\n            // Synonym: http://usejsdoc.org/tags-method.html\n            'function': ['parseNamePathOptional', 'ensureEnd'],\n            // Synonym: http://usejsdoc.org/tags-member.html\n            'var': ['parseType', 'parseNamePathOptional', 'ensureEnd'],\n            // http://usejsdoc.org/tags-name.html\n            'name': ['parseNamePath', 'ensureEnd'],\n            // http://usejsdoc.org/tags-namespace.html\n            'namespace': ['parseType', 'parseNamePathOptional', 'ensureEnd'],\n            // http://usejsdoc.org/tags-private.html\n            'private': ['parseType', 'parseDescription'],\n            // http://usejsdoc.org/tags-protected.html\n            'protected': ['parseType', 'parseDescription'],\n            // http://usejsdoc.org/tags-public.html\n            'public': ['parseType', 'parseDescription'],\n            // http://usejsdoc.org/tags-readonly.html\n            'readonly': ['ensureEnd'],\n            // http://usejsdoc.org/tags-requires.html\n            'requires': ['parseNamePath', 'ensureEnd'],\n            // http://usejsdoc.org/tags-since.html\n            'since': ['parseDescription'],\n            // http://usejsdoc.org/tags-static.html\n            'static': ['ensureEnd'],\n            // http://usejsdoc.org/tags-summary.html\n            'summary': ['parseDescription'],\n            // http://usejsdoc.org/tags-this.html\n            'this': ['parseThis', 'ensureEnd'],\n            // http://usejsdoc.org/tags-todo.html\n            'todo': ['parseDescription'],\n            // http://usejsdoc.org/tags-typedef.html\n            'typedef': ['parseType', 'parseNamePathOptional'],\n            // http://usejsdoc.org/tags-variation.html\n            'variation': ['parseVariation'],\n            // http://usejsdoc.org/tags-version.html\n            'version': ['parseDescription']\n        };\n\n        TagParser.prototype.parse = function parse() {\n            var i, iz, sequences, method;\n\n\n            // empty title\n            if (!this._title) {\n                if (!this.addError('Missing or invalid title')) {\n                    return null;\n                }\n            }\n\n            // Seek to content last index.\n            this._last = seekContent(this._title);\n\n            if (this._options.range) {\n                this._tag.range = [this._first, source.slice(0, this._last).replace(/\\s*$/, '').length].map(convertIndex);\n            }\n\n            if (hasOwnProperty(Rules, this._title)) {\n                sequences = Rules[this._title];\n            } else {\n                // default sequences\n                sequences = ['parseType', 'parseName', 'parseDescription', 'epilogue'];\n            }\n\n            for (i = 0, iz = sequences.length; i < iz; ++i) {\n                method = sequences[i];\n                if (!this[method]()) {\n                    return null;\n                }\n            }\n\n            return this._tag;\n        };\n\n        function parseTag(options) {\n            var title, parser, tag;\n\n            // skip to tag\n            if (!skipToTag()) {\n                return null;\n            }\n\n            // scan title\n            title = scanTitle();\n\n            // construct tag parser\n            parser = new TagParser(options, title);\n            tag = parser.parse();\n\n            // Seek global index to end of this tag.\n            while (index < parser._last) {\n                advance();\n            }\n\n            return tag;\n        }\n\n        //\n        // Parse JSDoc\n        //\n\n        function scanJSDocDescription(preserveWhitespace) {\n            var description = '', ch, atAllowed;\n\n            atAllowed = true;\n            while (index < length) {\n                ch = source.charCodeAt(index);\n\n                if (atAllowed && ch === 0x40  /* '@' */) {\n                    break;\n                }\n\n                if (esutils.code.isLineTerminator(ch)) {\n                    atAllowed = true;\n                } else if (atAllowed && !esutils.code.isWhiteSpace(ch)) {\n                    atAllowed = false;\n                }\n\n                description += advance();\n            }\n\n            return preserveWhitespace ? description : description.trim();\n        }\n\n        function parse(comment, options) {\n            var tags = [], tag, description, interestingTags, i, iz;\n\n            if (options === undefined) {\n                options = {};\n            }\n\n            if (typeof options.unwrap === 'boolean' && options.unwrap) {\n                source = unwrapComment(comment);\n            } else {\n                source = comment;\n            }\n\n            originalSource = comment;\n\n            // array of relevant tags\n            if (options.tags) {\n                if (Array.isArray(options.tags)) {\n                    interestingTags = { };\n                    for (i = 0, iz = options.tags.length; i < iz; i++) {\n                        if (typeof options.tags[i] === 'string') {\n                            interestingTags[options.tags[i]] = true;\n                        } else {\n                            utility$1.throwError('Invalid \"tags\" parameter: ' + options.tags);\n                        }\n                    }\n                } else {\n                    utility$1.throwError('Invalid \"tags\" parameter: ' + options.tags);\n                }\n            }\n\n            length = source.length;\n            index = 0;\n            lineNumber = 0;\n            recoverable = options.recoverable;\n            sloppy = options.sloppy;\n            strict = options.strict;\n\n            description = scanJSDocDescription(options.preserveWhitespace);\n\n            while (true) {\n                tag = parseTag(options);\n                if (!tag) {\n                    break;\n                }\n                if (!interestingTags || interestingTags.hasOwnProperty(tag.title)) {\n                    tags.push(tag);\n                }\n            }\n\n            return {\n                description: description,\n                tags: tags\n            };\n        }\n        exports.parse = parse;\n    }(jsdoc = {}));\n\n    exports.version = utility$1.VERSION;\n    exports.parse = jsdoc.parse;\n    exports.parseType = typed$1.parseType;\n    exports.parseParamType = typed$1.parseParamType;\n    exports.unwrapComment = unwrapComment;\n    exports.Syntax = shallowCopy(typed$1.Syntax);\n    exports.Error = utility$1.DoctrineError;\n    exports.type = {\n        Syntax: exports.Syntax,\n        parseType: typed$1.parseType,\n        parseParamType: typed$1.parseParamType,\n        stringify: typed$1.stringify\n    };\n}());\n/* vim: set sw=4 ts=4 et tw=80 : */\n});\nvar doctrine_1 = doctrine.version;\nvar doctrine_2 = doctrine.parse;\nvar doctrine_3 = doctrine.parseType;\nvar doctrine_4 = doctrine.parseParamType;\nvar doctrine_5 = doctrine.unwrapComment;\nvar doctrine_6 = doctrine.Syntax;\nvar doctrine_7 = doctrine.Error;\nvar doctrine_8 = doctrine.type;\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar validJsdoc = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"enforce valid JSDoc comments\",\n            category: \"Possible Errors\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/valid-jsdoc\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    prefer: {\n                        type: \"object\",\n                        additionalProperties: {\n                            type: \"string\"\n                        }\n                    },\n                    preferType: {\n                        type: \"object\",\n                        additionalProperties: {\n                            type: \"string\"\n                        }\n                    },\n                    requireReturn: {\n                        type: \"boolean\",\n                        default: true\n                    },\n                    requireParamDescription: {\n                        type: \"boolean\",\n                        default: true\n                    },\n                    requireReturnDescription: {\n                        type: \"boolean\",\n                        default: true\n                    },\n                    matchDescription: {\n                        type: \"string\"\n                    },\n                    requireReturnType: {\n                        type: \"boolean\",\n                        default: true\n                    },\n                    requireParamType: {\n                        type: \"boolean\",\n                        default: true\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        fixable: \"code\",\n        messages: {\n            unexpectedTag: \"Unexpected @{{title}} tag; function has no return statement.\",\n            expected: \"Expected JSDoc for '{{name}}' but found '{{jsdocName}}'.\",\n            use: \"Use @{{name}} instead.\",\n            useType: \"Use '{{expectedTypeName}}' instead of '{{currentTypeName}}'.\",\n            syntaxError: \"JSDoc syntax error.\",\n            missingBrace: \"JSDoc type missing brace.\",\n            missingParamDesc: \"Missing JSDoc parameter description for '{{name}}'.\",\n            missingParamType: \"Missing JSDoc parameter type for '{{name}}'.\",\n            missingReturnType: \"Missing JSDoc return type.\",\n            missingReturnDesc: \"Missing JSDoc return description.\",\n            missingReturn: \"Missing JSDoc @{{returns}} for function.\",\n            missingParam: \"Missing JSDoc for parameter '{{name}}'.\",\n            duplicateParam: \"Duplicate JSDoc parameter '{{name}}'.\",\n            unsatisfiedDesc: \"JSDoc description does not satisfy the regex pattern.\"\n        },\n\n        deprecated: true,\n        replacedBy: []\n    },\n\n    create(context) {\n\n        const options = context.options[0] || {},\n            prefer = options.prefer || {},\n            sourceCode = context.getSourceCode(),\n\n            // these both default to true, so you have to explicitly make them false\n            requireReturn = options.requireReturn !== false,\n            requireParamDescription = options.requireParamDescription !== false,\n            requireReturnDescription = options.requireReturnDescription !== false,\n            requireReturnType = options.requireReturnType !== false,\n            requireParamType = options.requireParamType !== false,\n            preferType = options.preferType || {},\n            checkPreferType = Object.keys(preferType).length !== 0;\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        // Using a stack to store if a function returns or not (handling nested functions)\n        const fns = [];\n\n        /**\n         * Check if node type is a Class\n         * @param {ASTNode} node node to check.\n         * @returns {boolean} True is its a class\n         * @private\n         */\n        function isTypeClass(node) {\n            return node.type === \"ClassExpression\" || node.type === \"ClassDeclaration\";\n        }\n\n        /**\n         * When parsing a new function, store it in our function stack.\n         * @param {ASTNode} node A function node to check.\n         * @returns {void}\n         * @private\n         */\n        function startFunction(node) {\n            fns.push({\n                returnPresent: (node.type === \"ArrowFunctionExpression\" && node.body.type !== \"BlockStatement\") ||\n                    isTypeClass(node) || node.async\n            });\n        }\n\n        /**\n         * Indicate that return has been found in the current function.\n         * @param {ASTNode} node The return node.\n         * @returns {void}\n         * @private\n         */\n        function addReturn(node) {\n            const functionState = fns[fns.length - 1];\n\n            if (functionState && node.argument !== null) {\n                functionState.returnPresent = true;\n            }\n        }\n\n        /**\n         * Check if return tag type is void or undefined\n         * @param {Object} tag JSDoc tag\n         * @returns {boolean} True if its of type void or undefined\n         * @private\n         */\n        function isValidReturnType(tag) {\n            return tag.type === null || tag.type.name === \"void\" || tag.type.type === \"UndefinedLiteral\";\n        }\n\n        /**\n         * Check if type should be validated based on some exceptions\n         * @param {Object} type JSDoc tag\n         * @returns {boolean} True if it can be validated\n         * @private\n         */\n        function canTypeBeValidated(type) {\n            return type !== \"UndefinedLiteral\" && // {undefined} as there is no name property available.\n                   type !== \"NullLiteral\" && // {null}\n                   type !== \"NullableLiteral\" && // {?}\n                   type !== \"FunctionType\" && // {function(a)}\n                   type !== \"AllLiteral\"; // {*}\n        }\n\n        /**\n         * Extract the current and expected type based on the input type object\n         * @param {Object} type JSDoc tag\n         * @returns {{currentType: Doctrine.Type, expectedTypeName: string}} The current type annotation and\n         * the expected name of the annotation\n         * @private\n         */\n        function getCurrentExpectedTypes(type) {\n            let currentType;\n\n            if (type.name) {\n                currentType = type;\n            } else if (type.expression) {\n                currentType = type.expression;\n            }\n\n            return {\n                currentType,\n                expectedTypeName: currentType && preferType[currentType.name]\n            };\n        }\n\n        /**\n         * Gets the location of a JSDoc node in a file\n         * @param {Token} jsdocComment The comment that this node is parsed from\n         * @param {{range: number[]}} parsedJsdocNode A tag or other node which was parsed from this comment\n         * @returns {{start: SourceLocation, end: SourceLocation}} The 0-based source location for the tag\n         */\n        function getAbsoluteRange(jsdocComment, parsedJsdocNode) {\n            return {\n                start: sourceCode.getLocFromIndex(jsdocComment.range[0] + 2 + parsedJsdocNode.range[0]),\n                end: sourceCode.getLocFromIndex(jsdocComment.range[0] + 2 + parsedJsdocNode.range[1])\n            };\n        }\n\n        /**\n         * Validate type for a given JSDoc node\n         * @param {Object} jsdocNode JSDoc node\n         * @param {Object} type JSDoc tag\n         * @returns {void}\n         * @private\n         */\n        function validateType(jsdocNode, type) {\n            if (!type || !canTypeBeValidated(type.type)) {\n                return;\n            }\n\n            const typesToCheck = [];\n            let elements = [];\n\n            switch (type.type) {\n                case \"TypeApplication\": // {Array.<String>}\n                    elements = type.applications[0].type === \"UnionType\" ? type.applications[0].elements : type.applications;\n                    typesToCheck.push(getCurrentExpectedTypes(type));\n                    break;\n                case \"RecordType\": // {{20:String}}\n                    elements = type.fields;\n                    break;\n                case \"UnionType\": // {String|number|Test}\n                case \"ArrayType\": // {[String, number, Test]}\n                    elements = type.elements;\n                    break;\n                case \"FieldType\": // Array.<{count: number, votes: number}>\n                    if (type.value) {\n                        typesToCheck.push(getCurrentExpectedTypes(type.value));\n                    }\n                    break;\n                default:\n                    typesToCheck.push(getCurrentExpectedTypes(type));\n            }\n\n            elements.forEach(validateType.bind(null, jsdocNode));\n\n            typesToCheck.forEach(typeToCheck => {\n                if (typeToCheck.expectedTypeName &&\n                    typeToCheck.expectedTypeName !== typeToCheck.currentType.name) {\n                    context.report({\n                        node: jsdocNode,\n                        messageId: \"useType\",\n                        loc: getAbsoluteRange(jsdocNode, typeToCheck.currentType),\n                        data: {\n                            currentTypeName: typeToCheck.currentType.name,\n                            expectedTypeName: typeToCheck.expectedTypeName\n                        },\n                        fix(fixer) {\n                            return fixer.replaceTextRange(\n                                typeToCheck.currentType.range.map(indexInComment => jsdocNode.range[0] + 2 + indexInComment),\n                                typeToCheck.expectedTypeName\n                            );\n                        }\n                    });\n                }\n            });\n        }\n\n        /**\n         * Validate the JSDoc node and output warnings if anything is wrong.\n         * @param {ASTNode} node The AST node to check.\n         * @returns {void}\n         * @private\n         */\n        function checkJSDoc(node) {\n            const jsdocNode = sourceCode.getJSDocComment(node),\n                functionData = fns.pop(),\n                paramTagsByName = Object.create(null),\n                paramTags = [];\n            let hasReturns = false,\n                returnsTag,\n                hasConstructor = false,\n                isInterface = false,\n                isOverride = false,\n                isAbstract = false;\n\n            // make sure only to validate JSDoc comments\n            if (jsdocNode) {\n                let jsdoc;\n\n                try {\n                    jsdoc = doctrine.parse(jsdocNode.value, {\n                        strict: true,\n                        unwrap: true,\n                        sloppy: true,\n                        range: true\n                    });\n                } catch (ex) {\n\n                    if (/braces/iu.test(ex.message)) {\n                        context.report({ node: jsdocNode, messageId: \"missingBrace\" });\n                    } else {\n                        context.report({ node: jsdocNode, messageId: \"syntaxError\" });\n                    }\n\n                    return;\n                }\n\n                jsdoc.tags.forEach(tag => {\n\n                    switch (tag.title.toLowerCase()) {\n\n                        case \"param\":\n                        case \"arg\":\n                        case \"argument\":\n                            paramTags.push(tag);\n                            break;\n\n                        case \"return\":\n                        case \"returns\":\n                            hasReturns = true;\n                            returnsTag = tag;\n                            break;\n\n                        case \"constructor\":\n                        case \"class\":\n                            hasConstructor = true;\n                            break;\n\n                        case \"override\":\n                        case \"inheritdoc\":\n                            isOverride = true;\n                            break;\n\n                        case \"abstract\":\n                        case \"virtual\":\n                            isAbstract = true;\n                            break;\n\n                        case \"interface\":\n                            isInterface = true;\n                            break;\n\n                        // no default\n                    }\n\n                    // check tag preferences\n                    if (Object.prototype.hasOwnProperty.call(prefer, tag.title) && tag.title !== prefer[tag.title]) {\n                        const entireTagRange = getAbsoluteRange(jsdocNode, tag);\n\n                        context.report({\n                            node: jsdocNode,\n                            messageId: \"use\",\n                            loc: {\n                                start: entireTagRange.start,\n                                end: {\n                                    line: entireTagRange.start.line,\n                                    column: entireTagRange.start.column + `@${tag.title}`.length\n                                }\n                            },\n                            data: { name: prefer[tag.title] },\n                            fix(fixer) {\n                                return fixer.replaceTextRange(\n                                    [\n                                        jsdocNode.range[0] + tag.range[0] + 3,\n                                        jsdocNode.range[0] + tag.range[0] + tag.title.length + 3\n                                    ],\n                                    prefer[tag.title]\n                                );\n                            }\n                        });\n                    }\n\n                    // validate the types\n                    if (checkPreferType && tag.type) {\n                        validateType(jsdocNode, tag.type);\n                    }\n                });\n\n                paramTags.forEach(param => {\n                    if (requireParamType && !param.type) {\n                        context.report({\n                            node: jsdocNode,\n                            messageId: \"missingParamType\",\n                            loc: getAbsoluteRange(jsdocNode, param),\n                            data: { name: param.name }\n                        });\n                    }\n                    if (!param.description && requireParamDescription) {\n                        context.report({\n                            node: jsdocNode,\n                            messageId: \"missingParamDesc\",\n                            loc: getAbsoluteRange(jsdocNode, param),\n                            data: { name: param.name }\n                        });\n                    }\n                    if (paramTagsByName[param.name]) {\n                        context.report({\n                            node: jsdocNode,\n                            messageId: \"duplicateParam\",\n                            loc: getAbsoluteRange(jsdocNode, param),\n                            data: { name: param.name }\n                        });\n                    } else if (param.name.indexOf(\".\") === -1) {\n                        paramTagsByName[param.name] = param;\n                    }\n                });\n\n                if (hasReturns) {\n                    if (!requireReturn && !functionData.returnPresent && (returnsTag.type === null || !isValidReturnType(returnsTag)) && !isAbstract) {\n                        context.report({\n                            node: jsdocNode,\n                            messageId: \"unexpectedTag\",\n                            loc: getAbsoluteRange(jsdocNode, returnsTag),\n                            data: {\n                                title: returnsTag.title\n                            }\n                        });\n                    } else {\n                        if (requireReturnType && !returnsTag.type) {\n                            context.report({ node: jsdocNode, messageId: \"missingReturnType\" });\n                        }\n\n                        if (!isValidReturnType(returnsTag) && !returnsTag.description && requireReturnDescription) {\n                            context.report({ node: jsdocNode, messageId: \"missingReturnDesc\" });\n                        }\n                    }\n                }\n\n                // check for functions missing @returns\n                if (!isOverride && !hasReturns && !hasConstructor && !isInterface &&\n                    node.parent.kind !== \"get\" && node.parent.kind !== \"constructor\" &&\n                    node.parent.kind !== \"set\" && !isTypeClass(node)) {\n                    if (requireReturn || (functionData.returnPresent && !node.async)) {\n                        context.report({\n                            node: jsdocNode,\n                            messageId: \"missingReturn\",\n                            data: {\n                                returns: prefer.returns || \"returns\"\n                            }\n                        });\n                    }\n                }\n\n                // check the parameters\n                const jsdocParamNames = Object.keys(paramTagsByName);\n\n                if (node.params) {\n                    node.params.forEach((param, paramsIndex) => {\n                        const bindingParam = param.type === \"AssignmentPattern\"\n                            ? param.left\n                            : param;\n\n                        // TODO(nzakas): Figure out logical things to do with destructured, default, rest params\n                        if (bindingParam.type === \"Identifier\") {\n                            const name = bindingParam.name;\n\n                            if (jsdocParamNames[paramsIndex] && (name !== jsdocParamNames[paramsIndex])) {\n                                context.report({\n                                    node: jsdocNode,\n                                    messageId: \"expected\",\n                                    loc: getAbsoluteRange(jsdocNode, paramTagsByName[jsdocParamNames[paramsIndex]]),\n                                    data: {\n                                        name,\n                                        jsdocName: jsdocParamNames[paramsIndex]\n                                    }\n                                });\n                            } else if (!paramTagsByName[name] && !isOverride) {\n                                context.report({\n                                    node: jsdocNode,\n                                    messageId: \"missingParam\",\n                                    data: {\n                                        name\n                                    }\n                                });\n                            }\n                        }\n                    });\n                }\n\n                if (options.matchDescription) {\n                    const regex = new RegExp(options.matchDescription, \"u\");\n\n                    if (!regex.test(jsdoc.description)) {\n                        context.report({ node: jsdocNode, messageId: \"unsatisfiedDesc\" });\n                    }\n                }\n\n            }\n\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            ArrowFunctionExpression: startFunction,\n            FunctionExpression: startFunction,\n            FunctionDeclaration: startFunction,\n            ClassExpression: startFunction,\n            ClassDeclaration: startFunction,\n            \"ArrowFunctionExpression:exit\": checkJSDoc,\n            \"FunctionExpression:exit\": checkJSDoc,\n            \"FunctionDeclaration:exit\": checkJSDoc,\n            \"ClassExpression:exit\": checkJSDoc,\n            \"ClassDeclaration:exit\": checkJSDoc,\n            ReturnStatement: addReturn\n        };\n\n    }\n};\n\n/**\n * @fileoverview Ensures that the results of typeof are compared against a valid string\n * @author Ian Christian Myers\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar validTypeof = {\n    meta: {\n        type: \"problem\",\n\n        docs: {\n            description: \"enforce comparing `typeof` expressions against valid strings\",\n            category: \"Possible Errors\",\n            recommended: true,\n            url: \"https://eslint.org/docs/rules/valid-typeof\"\n        },\n\n        schema: [\n            {\n                type: \"object\",\n                properties: {\n                    requireStringLiterals: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n        messages: {\n            invalidValue: \"Invalid typeof comparison value.\",\n            notString: \"Typeof comparisons should be to string literals.\"\n        }\n    },\n\n    create(context) {\n\n        const VALID_TYPES = [\"symbol\", \"undefined\", \"object\", \"boolean\", \"number\", \"string\", \"function\", \"bigint\"],\n            OPERATORS = [\"==\", \"===\", \"!=\", \"!==\"];\n\n        const requireStringLiterals = context.options[0] && context.options[0].requireStringLiterals;\n\n        /**\n         * Determines whether a node is a typeof expression.\n         * @param {ASTNode} node The node\n         * @returns {boolean} `true` if the node is a typeof expression\n         */\n        function isTypeofExpression(node) {\n            return node.type === \"UnaryExpression\" && node.operator === \"typeof\";\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n\n            UnaryExpression(node) {\n                if (isTypeofExpression(node)) {\n                    const parent = context.getAncestors().pop();\n\n                    if (parent.type === \"BinaryExpression\" && OPERATORS.indexOf(parent.operator) !== -1) {\n                        const sibling = parent.left === node ? parent.right : parent.left;\n\n                        if (sibling.type === \"Literal\" || sibling.type === \"TemplateLiteral\" && !sibling.expressions.length) {\n                            const value = sibling.type === \"Literal\" ? sibling.value : sibling.quasis[0].value.cooked;\n\n                            if (VALID_TYPES.indexOf(value) === -1) {\n                                context.report({ node: sibling, messageId: \"invalidValue\" });\n                            }\n                        } else if (requireStringLiterals && !isTypeofExpression(sibling)) {\n                            context.report({ node: sibling, messageId: \"notString\" });\n                        }\n                    }\n                }\n            }\n\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to enforce var declarations are only at the top of a function.\n * @author Danny Fritz\n * @author Gyandeep Singh\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar varsOnTop = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require `var` declarations be placed at the top of their containing scope\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/vars-on-top\"\n        },\n\n        schema: [],\n        messages: {\n            top: \"All 'var' declarations must be at the top of the function scope.\"\n        }\n    },\n\n    create(context) {\n\n        //--------------------------------------------------------------------------\n        // Helpers\n        //--------------------------------------------------------------------------\n\n        // eslint-disable-next-line jsdoc/require-description\n        /**\n         * @param {ASTNode} node any node\n         * @returns {boolean} whether the given node structurally represents a directive\n         */\n        function looksLikeDirective(node) {\n            return node.type === \"ExpressionStatement\" &&\n                node.expression.type === \"Literal\" && typeof node.expression.value === \"string\";\n        }\n\n        /**\n         * Check to see if its a ES6 import declaration\n         * @param {ASTNode} node any node\n         * @returns {boolean} whether the given node represents a import declaration\n         */\n        function looksLikeImport(node) {\n            return node.type === \"ImportDeclaration\" || node.type === \"ImportSpecifier\" ||\n                node.type === \"ImportDefaultSpecifier\" || node.type === \"ImportNamespaceSpecifier\";\n        }\n\n        /**\n         * Checks whether a given node is a variable declaration or not.\n         * @param {ASTNode} node any node\n         * @returns {boolean} `true` if the node is a variable declaration.\n         */\n        function isVariableDeclaration(node) {\n            return (\n                node.type === \"VariableDeclaration\" ||\n                (\n                    node.type === \"ExportNamedDeclaration\" &&\n                    node.declaration &&\n                    node.declaration.type === \"VariableDeclaration\"\n                )\n            );\n        }\n\n        /**\n         * Checks whether this variable is on top of the block body\n         * @param {ASTNode} node The node to check\n         * @param {ASTNode[]} statements collection of ASTNodes for the parent node block\n         * @returns {boolean} True if var is on top otherwise false\n         */\n        function isVarOnTop(node, statements) {\n            const l = statements.length;\n            let i = 0;\n\n            // skip over directives\n            for (; i < l; ++i) {\n                if (!looksLikeDirective(statements[i]) && !looksLikeImport(statements[i])) {\n                    break;\n                }\n            }\n\n            for (; i < l; ++i) {\n                if (!isVariableDeclaration(statements[i])) {\n                    return false;\n                }\n                if (statements[i] === node) {\n                    return true;\n                }\n            }\n\n            return false;\n        }\n\n        /**\n         * Checks whether variable is on top at the global level\n         * @param {ASTNode} node The node to check\n         * @param {ASTNode} parent Parent of the node\n         * @returns {void}\n         */\n        function globalVarCheck(node, parent) {\n            if (!isVarOnTop(node, parent.body)) {\n                context.report({ node, messageId: \"top\" });\n            }\n        }\n\n        /**\n         * Checks whether variable is on top at functional block scope level\n         * @param {ASTNode} node The node to check\n         * @param {ASTNode} parent Parent of the node\n         * @param {ASTNode} grandParent Parent of the node's parent\n         * @returns {void}\n         */\n        function blockScopeVarCheck(node, parent, grandParent) {\n            if (!(/Function/u.test(grandParent.type) &&\n                    parent.type === \"BlockStatement\" &&\n                    isVarOnTop(node, parent.body))) {\n                context.report({ node, messageId: \"top\" });\n            }\n        }\n\n        //--------------------------------------------------------------------------\n        // Public API\n        //--------------------------------------------------------------------------\n\n        return {\n            \"VariableDeclaration[kind='var']\"(node) {\n                if (node.parent.type === \"ExportNamedDeclaration\") {\n                    globalVarCheck(node.parent, node.parent.parent);\n                } else if (node.parent.type === \"Program\") {\n                    globalVarCheck(node, node.parent);\n                } else {\n                    blockScopeVarCheck(node, node.parent, node.parent.parent);\n                }\n            }\n        };\n\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar wrapIife = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require parentheses around immediate `function` invocations\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/wrap-iife\"\n        },\n\n        schema: [\n            {\n                enum: [\"outside\", \"inside\", \"any\"]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    functionPrototypeMethods: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        fixable: \"code\",\n        messages: {\n            wrapInvocation: \"Wrap an immediate function invocation in parentheses.\",\n            wrapExpression: \"Wrap only the function expression in parens.\",\n            moveInvocation: \"Move the invocation into the parens that contain the function.\"\n        }\n    },\n\n    create(context) {\n\n        const style = context.options[0] || \"outside\";\n        const includeFunctionPrototypeMethods = context.options[1] && context.options[1].functionPrototypeMethods;\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Check if the node is wrapped in ()\n         * @param {ASTNode} node node to evaluate\n         * @returns {boolean} True if it is wrapped\n         * @private\n         */\n        function wrapped(node) {\n            return astUtils$1.isParenthesised(sourceCode, node);\n        }\n\n        /**\n         * Get the function node from an IIFE\n         * @param {ASTNode} node node to evaluate\n         * @returns {ASTNode} node that is the function expression of the given IIFE, or null if none exist\n         */\n        function getFunctionNodeFromIIFE(node) {\n            const callee = node.callee;\n\n            if (callee.type === \"FunctionExpression\") {\n                return callee;\n            }\n\n            if (includeFunctionPrototypeMethods &&\n                callee.type === \"MemberExpression\" &&\n                callee.object.type === \"FunctionExpression\" &&\n                (astUtils$1.getStaticPropertyName(callee) === \"call\" || astUtils$1.getStaticPropertyName(callee) === \"apply\")\n            ) {\n                return callee.object;\n            }\n\n            return null;\n        }\n\n\n        return {\n            CallExpression(node) {\n                const innerNode = getFunctionNodeFromIIFE(node);\n\n                if (!innerNode) {\n                    return;\n                }\n\n                const callExpressionWrapped = wrapped(node),\n                    functionExpressionWrapped = wrapped(innerNode);\n\n                if (!callExpressionWrapped && !functionExpressionWrapped) {\n                    context.report({\n                        node,\n                        messageId: \"wrapInvocation\",\n                        fix(fixer) {\n                            const nodeToSurround = style === \"inside\" ? innerNode : node;\n\n                            return fixer.replaceText(nodeToSurround, `(${sourceCode.getText(nodeToSurround)})`);\n                        }\n                    });\n                } else if (style === \"inside\" && !functionExpressionWrapped) {\n                    context.report({\n                        node,\n                        messageId: \"wrapExpression\",\n                        fix(fixer) {\n\n                            /*\n                             * The outer call expression will always be wrapped at this point.\n                             * Replace the range between the end of the function expression and the end of the call expression.\n                             * for example, in `(function(foo) {}(bar))`, the range `(bar))` should get replaced with `)(bar)`.\n                             * Replace the parens from the outer expression, and parenthesize the function expression.\n                             */\n                            const parenAfter = sourceCode.getTokenAfter(node);\n\n                            return fixer.replaceTextRange(\n                                [innerNode.range[1], parenAfter.range[1]],\n                                `)${sourceCode.getText().slice(innerNode.range[1], parenAfter.range[0])}`\n                            );\n                        }\n                    });\n                } else if (style === \"outside\" && !callExpressionWrapped) {\n                    context.report({\n                        node,\n                        messageId: \"moveInvocation\",\n                        fix(fixer) {\n\n                            /*\n                             * The inner function expression will always be wrapped at this point.\n                             * It's only necessary to replace the range between the end of the function expression\n                             * and the call expression. For example, in `(function(foo) {})(bar)`, the range `)(bar)`\n                             * should get replaced with `(bar))`.\n                             */\n                            const parenAfter = sourceCode.getTokenAfter(innerNode);\n\n                            return fixer.replaceTextRange(\n                                [parenAfter.range[0], node.range[1]],\n                                `${sourceCode.getText().slice(parenAfter.range[1], node.range[1])})`\n                            );\n                        }\n                    });\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to flag when regex literals are not wrapped in parens\n * @author Matt DuVall <http://www.mattduvall.com>\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar wrapRegex = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require parenthesis around regex literals\",\n            category: \"Stylistic Issues\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/wrap-regex\"\n        },\n\n        schema: [],\n        fixable: \"code\",\n\n        messages: {\n            requireParens: \"Wrap the regexp literal in parens to disambiguate the slash.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        return {\n\n            Literal(node) {\n                const token = sourceCode.getFirstToken(node),\n                    nodeType = token.type;\n\n                if (nodeType === \"RegularExpression\") {\n                    const beforeToken = sourceCode.getTokenBefore(node);\n                    const afterToken = sourceCode.getTokenAfter(node);\n                    const ancestors = context.getAncestors();\n                    const grandparent = ancestors[ancestors.length - 1];\n\n                    if (grandparent.type === \"MemberExpression\" && grandparent.object === node &&\n                        !(beforeToken && beforeToken.value === \"(\" && afterToken && afterToken.value === \")\")) {\n                        context.report({\n                            node,\n                            messageId: \"requireParens\",\n                            fix: fixer => fixer.replaceText(node, `(${sourceCode.getText(node)})`)\n                        });\n                    }\n                }\n            }\n        };\n\n    }\n};\n\n/**\n * @fileoverview Rule to check the spacing around the * in yield* expressions.\n * @author Bryan Smith\n */\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar yieldStarSpacing = {\n    meta: {\n        type: \"layout\",\n\n        docs: {\n            description: \"require or disallow spacing around the `*` in `yield*` expressions\",\n            category: \"ECMAScript 6\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/yield-star-spacing\"\n        },\n\n        fixable: \"whitespace\",\n\n        schema: [\n            {\n                oneOf: [\n                    {\n                        enum: [\"before\", \"after\", \"both\", \"neither\"]\n                    },\n                    {\n                        type: \"object\",\n                        properties: {\n                            before: { type: \"boolean\" },\n                            after: { type: \"boolean\" }\n                        },\n                        additionalProperties: false\n                    }\n                ]\n            }\n        ],\n        messages: {\n            missingBefore: \"Missing space before *.\",\n            missingAfter: \"Missing space after *.\",\n            unexpectedBefore: \"Unexpected space before *.\",\n            unexpectedAfter: \"Unexpected space after *.\"\n        }\n    },\n\n    create(context) {\n        const sourceCode = context.getSourceCode();\n\n        const mode = (function(option) {\n            if (!option || typeof option === \"string\") {\n                return {\n                    before: { before: true, after: false },\n                    after: { before: false, after: true },\n                    both: { before: true, after: true },\n                    neither: { before: false, after: false }\n                }[option || \"after\"];\n            }\n            return option;\n        }(context.options[0]));\n\n        /**\n         * Checks the spacing between two tokens before or after the star token.\n         * @param {string} side Either \"before\" or \"after\".\n         * @param {Token} leftToken `function` keyword token if side is \"before\", or\n         *     star token if side is \"after\".\n         * @param {Token} rightToken Star token if side is \"before\", or identifier\n         *     token if side is \"after\".\n         * @returns {void}\n         */\n        function checkSpacing(side, leftToken, rightToken) {\n            if (sourceCode.isSpaceBetweenTokens(leftToken, rightToken) !== mode[side]) {\n                const after = leftToken.value === \"*\";\n                const spaceRequired = mode[side];\n                const node = after ? leftToken : rightToken;\n                let messageId = \"\";\n\n                if (spaceRequired) {\n                    messageId = side === \"before\" ? \"missingBefore\" : \"missingAfter\";\n                } else {\n                    messageId = side === \"before\" ? \"unexpectedBefore\" : \"unexpectedAfter\";\n                }\n\n                context.report({\n                    node,\n                    messageId,\n                    fix(fixer) {\n                        if (spaceRequired) {\n                            if (after) {\n                                return fixer.insertTextAfter(node, \" \");\n                            }\n                            return fixer.insertTextBefore(node, \" \");\n                        }\n                        return fixer.removeRange([leftToken.range[1], rightToken.range[0]]);\n                    }\n                });\n            }\n        }\n\n        /**\n         * Enforces the spacing around the star if node is a yield* expression.\n         * @param {ASTNode} node A yield expression node.\n         * @returns {void}\n         */\n        function checkExpression(node) {\n            if (!node.delegate) {\n                return;\n            }\n\n            const tokens = sourceCode.getFirstTokens(node, 3);\n            const yieldToken = tokens[0];\n            const starToken = tokens[1];\n            const nextToken = tokens[2];\n\n            checkSpacing(\"before\", yieldToken, starToken);\n            checkSpacing(\"after\", starToken, nextToken);\n        }\n\n        return {\n            YieldExpression: checkExpression\n        };\n\n    }\n};\n\n//--------------------------------------------------------------------------\n// Requirements\n//--------------------------------------------------------------------------\n\n\n\n//--------------------------------------------------------------------------\n// Helpers\n//--------------------------------------------------------------------------\n\n/**\n * Determines whether an operator is a comparison operator.\n * @param {string} operator The operator to check.\n * @returns {boolean} Whether or not it is a comparison operator.\n */\nfunction isComparisonOperator(operator) {\n    return (/^(==|===|!=|!==|<|>|<=|>=)$/u).test(operator);\n}\n\n/**\n * Determines whether an operator is an equality operator.\n * @param {string} operator The operator to check.\n * @returns {boolean} Whether or not it is an equality operator.\n */\nfunction isEqualityOperator(operator) {\n    return (/^(==|===)$/u).test(operator);\n}\n\n/**\n * Determines whether an operator is one used in a range test.\n * Allowed operators are `<` and `<=`.\n * @param {string} operator The operator to check.\n * @returns {boolean} Whether the operator is used in range tests.\n */\nfunction isRangeTestOperator(operator) {\n    return [\"<\", \"<=\"].indexOf(operator) >= 0;\n}\n\n/**\n * Determines whether a non-Literal node is a negative number that should be\n * treated as if it were a single Literal node.\n * @param {ASTNode} node Node to test.\n * @returns {boolean} True if the node is a negative number that looks like a\n *                    real literal and should be treated as such.\n */\nfunction looksLikeLiteral(node) {\n    return (node.type === \"UnaryExpression\" &&\n        node.operator === \"-\" &&\n        node.prefix &&\n        node.argument.type === \"Literal\" &&\n        typeof node.argument.value === \"number\");\n}\n\n/**\n * Attempts to derive a Literal node from nodes that are treated like literals.\n * @param {ASTNode} node Node to normalize.\n * @param {number} [defaultValue] The default value to be returned if the node\n *                                is not a Literal.\n * @returns {ASTNode} One of the following options.\n *  1. The original node if the node is already a Literal\n *  2. A normalized Literal node with the negative number as the value if the\n *     node represents a negative number literal.\n *  3. The Literal node which has the `defaultValue` argument if it exists.\n *  4. Otherwise `null`.\n */\nfunction getNormalizedLiteral(node, defaultValue) {\n    if (node.type === \"Literal\") {\n        return node;\n    }\n\n    if (looksLikeLiteral(node)) {\n        return {\n            type: \"Literal\",\n            value: -node.argument.value,\n            raw: `-${node.argument.value}`\n        };\n    }\n\n    if (defaultValue) {\n        return {\n            type: \"Literal\",\n            value: defaultValue,\n            raw: String(defaultValue)\n        };\n    }\n\n    return null;\n}\n\n/**\n * Checks whether two expressions reference the same value. For example:\n *     a = a\n *     a.b = a.b\n *     a[0] = a[0]\n *     a['b'] = a['b']\n * @param   {ASTNode} a Left side of the comparison.\n * @param   {ASTNode} b Right side of the comparison.\n * @returns {boolean}   True if both sides match and reference the same value.\n */\nfunction same$1(a, b) {\n    if (a.type !== b.type) {\n        return false;\n    }\n\n    switch (a.type) {\n        case \"Identifier\":\n            return a.name === b.name;\n\n        case \"Literal\":\n            return a.value === b.value;\n\n        case \"MemberExpression\": {\n            const nameA = astUtils$1.getStaticPropertyName(a);\n\n            // x.y = x[\"y\"]\n            if (nameA !== null) {\n                return (\n                    same$1(a.object, b.object) &&\n                    nameA === astUtils$1.getStaticPropertyName(b)\n                );\n            }\n\n            /*\n             * x[0] = x[0]\n             * x[y] = x[y]\n             * x.y = x.y\n             */\n            return (\n                a.computed === b.computed &&\n                same$1(a.object, b.object) &&\n                same$1(a.property, b.property)\n            );\n        }\n\n        case \"ThisExpression\":\n            return true;\n\n        default:\n            return false;\n    }\n}\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nvar yoda = {\n    meta: {\n        type: \"suggestion\",\n\n        docs: {\n            description: \"require or disallow \\\"Yoda\\\" conditions\",\n            category: \"Best Practices\",\n            recommended: false,\n            url: \"https://eslint.org/docs/rules/yoda\"\n        },\n\n        schema: [\n            {\n                enum: [\"always\", \"never\"]\n            },\n            {\n                type: \"object\",\n                properties: {\n                    exceptRange: {\n                        type: \"boolean\",\n                        default: false\n                    },\n                    onlyEquality: {\n                        type: \"boolean\",\n                        default: false\n                    }\n                },\n                additionalProperties: false\n            }\n        ],\n\n        fixable: \"code\",\n        messages: {\n            expected: \"Expected literal to be on the {{expectedSide}} side of {{operator}}.\"\n        }\n    },\n\n    create(context) {\n\n        // Default to \"never\" (!always) if no option\n        const always = (context.options[0] === \"always\");\n        const exceptRange = (context.options[1] && context.options[1].exceptRange);\n        const onlyEquality = (context.options[1] && context.options[1].onlyEquality);\n\n        const sourceCode = context.getSourceCode();\n\n        /**\n         * Determines whether node represents a range test.\n         * A range test is a \"between\" test like `(0 <= x && x < 1)` or an \"outside\"\n         * test like `(x < 0 || 1 <= x)`. It must be wrapped in parentheses, and\n         * both operators must be `<` or `<=`. Finally, the literal on the left side\n         * must be less than or equal to the literal on the right side so that the\n         * test makes any sense.\n         * @param {ASTNode} node LogicalExpression node to test.\n         * @returns {boolean} Whether node is a range test.\n         */\n        function isRangeTest(node) {\n            const left = node.left,\n                right = node.right;\n\n            /**\n             * Determines whether node is of the form `0 <= x && x < 1`.\n             * @returns {boolean} Whether node is a \"between\" range test.\n             */\n            function isBetweenTest() {\n                let leftLiteral, rightLiteral;\n\n                return (node.operator === \"&&\" &&\n                    (leftLiteral = getNormalizedLiteral(left.left)) &&\n                    (rightLiteral = getNormalizedLiteral(right.right, Number.POSITIVE_INFINITY)) &&\n                    leftLiteral.value <= rightLiteral.value &&\n                    same$1(left.right, right.left));\n            }\n\n            /**\n             * Determines whether node is of the form `x < 0 || 1 <= x`.\n             * @returns {boolean} Whether node is an \"outside\" range test.\n             */\n            function isOutsideTest() {\n                let leftLiteral, rightLiteral;\n\n                return (node.operator === \"||\" &&\n                    (leftLiteral = getNormalizedLiteral(left.right, Number.NEGATIVE_INFINITY)) &&\n                    (rightLiteral = getNormalizedLiteral(right.left)) &&\n                    leftLiteral.value <= rightLiteral.value &&\n                    same$1(left.left, right.right));\n            }\n\n            /**\n             * Determines whether node is wrapped in parentheses.\n             * @returns {boolean} Whether node is preceded immediately by an open\n             *                    paren token and followed immediately by a close\n             *                    paren token.\n             */\n            function isParenWrapped() {\n                return astUtils$1.isParenthesised(sourceCode, node);\n            }\n\n            return (node.type === \"LogicalExpression\" &&\n                left.type === \"BinaryExpression\" &&\n                right.type === \"BinaryExpression\" &&\n                isRangeTestOperator(left.operator) &&\n                isRangeTestOperator(right.operator) &&\n                (isBetweenTest() || isOutsideTest()) &&\n                isParenWrapped());\n        }\n\n        const OPERATOR_FLIP_MAP = {\n            \"===\": \"===\",\n            \"!==\": \"!==\",\n            \"==\": \"==\",\n            \"!=\": \"!=\",\n            \"<\": \">\",\n            \">\": \"<\",\n            \"<=\": \">=\",\n            \">=\": \"<=\"\n        };\n\n        /**\n         * Returns a string representation of a BinaryExpression node with its sides/operator flipped around.\n         * @param {ASTNode} node The BinaryExpression node\n         * @returns {string} A string representation of the node with the sides and operator flipped\n         */\n        function getFlippedString(node) {\n            const tokenBefore = sourceCode.getTokenBefore(node);\n            const operatorToken = sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);\n            const textBeforeOperator = sourceCode.getText().slice(sourceCode.getTokenBefore(operatorToken).range[1], operatorToken.range[0]);\n            const textAfterOperator = sourceCode.getText().slice(operatorToken.range[1], sourceCode.getTokenAfter(operatorToken).range[0]);\n            const leftText = sourceCode.getText().slice(node.range[0], sourceCode.getTokenBefore(operatorToken).range[1]);\n            const firstRightToken = sourceCode.getTokenAfter(operatorToken);\n            const rightText = sourceCode.getText().slice(firstRightToken.range[0], node.range[1]);\n\n            let prefix = \"\";\n\n            if (tokenBefore && tokenBefore.range[1] === node.range[0] &&\n                    !astUtils$1.canTokensBeAdjacent(tokenBefore, firstRightToken)) {\n                prefix = \" \";\n            }\n\n            return prefix + rightText + textBeforeOperator + OPERATOR_FLIP_MAP[operatorToken.value] + textAfterOperator + leftText;\n        }\n\n        //--------------------------------------------------------------------------\n        // Public\n        //--------------------------------------------------------------------------\n\n        return {\n            BinaryExpression(node) {\n                const expectedLiteral = always ? node.left : node.right;\n                const expectedNonLiteral = always ? node.right : node.left;\n\n                // If `expectedLiteral` is not a literal, and `expectedNonLiteral` is a literal, raise an error.\n                if (\n                    (expectedNonLiteral.type === \"Literal\" || looksLikeLiteral(expectedNonLiteral)) &&\n                    !(expectedLiteral.type === \"Literal\" || looksLikeLiteral(expectedLiteral)) &&\n                    !(!isEqualityOperator(node.operator) && onlyEquality) &&\n                    isComparisonOperator(node.operator) &&\n                    !(exceptRange && isRangeTest(context.getAncestors().pop()))\n                ) {\n                    context.report({\n                        node,\n                        messageId: \"expected\",\n                        data: {\n                            operator: node.operator,\n                            expectedSide: always ? \"left\" : \"right\"\n                        },\n                        fix: fixer => fixer.replaceText(node, getFlippedString(node))\n                    });\n                }\n\n            }\n        };\n\n    }\n};\n\n/* eslint sort-keys: [\"error\", \"asc\"] */\n\nconst { LazyLoadingRuleMap: LazyLoadingRuleMap$1 } = lazyLoadingRuleMap;\n\n/** @type {Map<string, import(\"../shared/types\").Rule>} */\nvar rules = new LazyLoadingRuleMap$1(Object.entries({\n    \"accessor-pairs\": () => accessorPairs,\n    \"array-bracket-newline\": () => arrayBracketNewline,\n    \"array-bracket-spacing\": () => arrayBracketSpacing,\n    \"array-callback-return\": () => arrayCallbackReturn,\n    \"array-element-newline\": () => arrayElementNewline,\n    \"arrow-body-style\": () => arrowBodyStyle,\n    \"arrow-parens\": () => arrowParens,\n    \"arrow-spacing\": () => arrowSpacing,\n    \"block-scoped-var\": () => blockScopedVar,\n    \"block-spacing\": () => blockSpacing,\n    \"brace-style\": () => braceStyle,\n    \"callback-return\": () => callbackReturn,\n    camelcase: () => camelcase,\n    \"capitalized-comments\": () => capitalizedComments,\n    \"class-methods-use-this\": () => classMethodsUseThis,\n    \"comma-dangle\": () => commaDangle,\n    \"comma-spacing\": () => commaSpacing,\n    \"comma-style\": () => commaStyle,\n    complexity: () => complexity,\n    \"computed-property-spacing\": () => computedPropertySpacing,\n    \"consistent-return\": () => consistentReturn,\n    \"consistent-this\": () => consistentThis,\n    \"constructor-super\": () => constructorSuper,\n    curly: () => curly,\n    \"default-case\": () => defaultCase,\n    \"default-param-last\": () => defaultParamLast,\n    \"dot-location\": () => dotLocation,\n    \"dot-notation\": () => dotNotation,\n    \"eol-last\": () => eolLast,\n    eqeqeq: () => eqeqeq,\n    \"for-direction\": () => forDirection,\n    \"func-call-spacing\": () => funcCallSpacing,\n    \"func-name-matching\": () => funcNameMatching,\n    \"func-names\": () => funcNames,\n    \"func-style\": () => funcStyle,\n    \"function-call-argument-newline\": () => functionCallArgumentNewline,\n    \"function-paren-newline\": () => functionParenNewline,\n    \"generator-star-spacing\": () => generatorStarSpacing,\n    \"getter-return\": () => getterReturn,\n    \"global-require\": () => globalRequire,\n    \"grouped-accessor-pairs\": () => groupedAccessorPairs,\n    \"guard-for-in\": () => guardForIn,\n    \"handle-callback-err\": () => handleCallbackErr,\n    \"id-blacklist\": () => idBlacklist,\n    \"id-length\": () => idLength,\n    \"id-match\": () => idMatch,\n    \"implicit-arrow-linebreak\": () => implicitArrowLinebreak,\n    indent: () => indent,\n    \"indent-legacy\": () => indentLegacy,\n    \"init-declarations\": () => initDeclarations,\n    \"jsx-quotes\": () => jsxQuotes,\n    \"key-spacing\": () => keySpacing,\n    \"keyword-spacing\": () => keywordSpacing,\n    \"line-comment-position\": () => lineCommentPosition,\n    \"linebreak-style\": () => linebreakStyle,\n    \"lines-around-comment\": () => linesAroundComment,\n    \"lines-around-directive\": () => linesAroundDirective,\n    \"lines-between-class-members\": () => linesBetweenClassMembers,\n    \"max-classes-per-file\": () => maxClassesPerFile,\n    \"max-depth\": () => maxDepth,\n    \"max-len\": () => maxLen,\n    \"max-lines\": () => maxLines,\n    \"max-lines-per-function\": () => maxLinesPerFunction,\n    \"max-nested-callbacks\": () => maxNestedCallbacks,\n    \"max-params\": () => maxParams,\n    \"max-statements\": () => maxStatements,\n    \"max-statements-per-line\": () => maxStatementsPerLine,\n    \"multiline-comment-style\": () => multilineCommentStyle,\n    \"multiline-ternary\": () => multilineTernary,\n    \"new-cap\": () => newCap,\n    \"new-parens\": () => newParens,\n    \"newline-after-var\": () => newlineAfterVar,\n    \"newline-before-return\": () => newlineBeforeReturn,\n    \"newline-per-chained-call\": () => newlinePerChainedCall,\n    \"no-alert\": () => noAlert,\n    \"no-array-constructor\": () => noArrayConstructor,\n    \"no-async-promise-executor\": () => noAsyncPromiseExecutor,\n    \"no-await-in-loop\": () => noAwaitInLoop,\n    \"no-bitwise\": () => noBitwise,\n    \"no-buffer-constructor\": () => noBufferConstructor,\n    \"no-caller\": () => noCaller,\n    \"no-case-declarations\": () => noCaseDeclarations,\n    \"no-catch-shadow\": () => noCatchShadow,\n    \"no-class-assign\": () => noClassAssign,\n    \"no-compare-neg-zero\": () => noCompareNegZero,\n    \"no-cond-assign\": () => noCondAssign,\n    \"no-confusing-arrow\": () => noConfusingArrow,\n    \"no-console\": () => noConsole,\n    \"no-const-assign\": () => noConstAssign,\n    \"no-constant-condition\": () => noConstantCondition,\n    \"no-constructor-return\": () => noConstructorReturn,\n    \"no-continue\": () => noContinue,\n    \"no-control-regex\": () => noControlRegex,\n    \"no-debugger\": () => noDebugger,\n    \"no-delete-var\": () => noDeleteVar,\n    \"no-div-regex\": () => noDivRegex,\n    \"no-dupe-args\": () => noDupeArgs,\n    \"no-dupe-class-members\": () => noDupeClassMembers,\n    \"no-dupe-else-if\": () => noDupeElseIf,\n    \"no-dupe-keys\": () => noDupeKeys,\n    \"no-duplicate-case\": () => noDuplicateCase,\n    \"no-duplicate-imports\": () => noDuplicateImports,\n    \"no-else-return\": () => noElseReturn,\n    \"no-empty\": () => noEmpty,\n    \"no-empty-character-class\": () => noEmptyCharacterClass,\n    \"no-empty-function\": () => noEmptyFunction,\n    \"no-empty-pattern\": () => noEmptyPattern,\n    \"no-eq-null\": () => noEqNull,\n    \"no-eval\": () => noEval,\n    \"no-ex-assign\": () => noExAssign,\n    \"no-extend-native\": () => noExtendNative,\n    \"no-extra-bind\": () => noExtraBind,\n    \"no-extra-boolean-cast\": () => noExtraBooleanCast,\n    \"no-extra-label\": () => noExtraLabel,\n    \"no-extra-parens\": () => noExtraParens,\n    \"no-extra-semi\": () => noExtraSemi,\n    \"no-fallthrough\": () => noFallthrough,\n    \"no-floating-decimal\": () => noFloatingDecimal,\n    \"no-func-assign\": () => noFuncAssign,\n    \"no-global-assign\": () => noGlobalAssign,\n    \"no-implicit-coercion\": () => noImplicitCoercion,\n    \"no-implicit-globals\": () => noImplicitGlobals,\n    \"no-implied-eval\": () => noImpliedEval,\n    \"no-import-assign\": () => noImportAssign,\n    \"no-inline-comments\": () => noInlineComments,\n    \"no-inner-declarations\": () => noInnerDeclarations,\n    \"no-invalid-regexp\": () => noInvalidRegexp,\n    \"no-invalid-this\": () => noInvalidThis,\n    \"no-irregular-whitespace\": () => noIrregularWhitespace,\n    \"no-iterator\": () => noIterator,\n    \"no-label-var\": () => noLabelVar,\n    \"no-labels\": () => noLabels,\n    \"no-lone-blocks\": () => noLoneBlocks,\n    \"no-lonely-if\": () => noLonelyIf,\n    \"no-loop-func\": () => noLoopFunc,\n    \"no-magic-numbers\": () => noMagicNumbers,\n    \"no-misleading-character-class\": () => noMisleadingCharacterClass,\n    \"no-mixed-operators\": () => noMixedOperators,\n    \"no-mixed-requires\": () => noMixedRequires,\n    \"no-mixed-spaces-and-tabs\": () => noMixedSpacesAndTabs,\n    \"no-multi-assign\": () => noMultiAssign,\n    \"no-multi-spaces\": () => noMultiSpaces,\n    \"no-multi-str\": () => noMultiStr,\n    \"no-multiple-empty-lines\": () => noMultipleEmptyLines,\n    \"no-native-reassign\": () => noNativeReassign,\n    \"no-negated-condition\": () => noNegatedCondition,\n    \"no-negated-in-lhs\": () => noNegatedInLhs,\n    \"no-nested-ternary\": () => noNestedTernary,\n    \"no-new\": () => noNew,\n    \"no-new-func\": () => noNewFunc,\n    \"no-new-object\": () => noNewObject,\n    \"no-new-require\": () => noNewRequire,\n    \"no-new-symbol\": () => noNewSymbol,\n    \"no-new-wrappers\": () => noNewWrappers,\n    \"no-obj-calls\": () => noObjCalls,\n    \"no-octal\": () => noOctal,\n    \"no-octal-escape\": () => noOctalEscape,\n    \"no-param-reassign\": () => noParamReassign,\n    \"no-path-concat\": () => noPathConcat,\n    \"no-plusplus\": () => noPlusplus,\n    \"no-process-env\": () => noProcessEnv,\n    \"no-process-exit\": () => noProcessExit,\n    \"no-proto\": () => noProto,\n    \"no-prototype-builtins\": () => noPrototypeBuiltins,\n    \"no-redeclare\": () => noRedeclare,\n    \"no-regex-spaces\": () => noRegexSpaces,\n    \"no-restricted-globals\": () => noRestrictedGlobals,\n    \"no-restricted-imports\": () => noRestrictedImports,\n    \"no-restricted-modules\": () => noRestrictedModules,\n    \"no-restricted-properties\": () => noRestrictedProperties,\n    \"no-restricted-syntax\": () => noRestrictedSyntax,\n    \"no-return-assign\": () => noReturnAssign,\n    \"no-return-await\": () => noReturnAwait,\n    \"no-script-url\": () => noScriptUrl,\n    \"no-self-assign\": () => noSelfAssign,\n    \"no-self-compare\": () => noSelfCompare,\n    \"no-sequences\": () => noSequences,\n    \"no-setter-return\": () => noSetterReturn,\n    \"no-shadow\": () => noShadow,\n    \"no-shadow-restricted-names\": () => noShadowRestrictedNames,\n    \"no-spaced-func\": () => noSpacedFunc,\n    \"no-sparse-arrays\": () => noSparseArrays,\n    \"no-sync\": () => noSync,\n    \"no-tabs\": () => noTabs,\n    \"no-template-curly-in-string\": () => noTemplateCurlyInString,\n    \"no-ternary\": () => noTernary,\n    \"no-this-before-super\": () => noThisBeforeSuper,\n    \"no-throw-literal\": () => noThrowLiteral,\n    \"no-trailing-spaces\": () => noTrailingSpaces,\n    \"no-undef\": () => noUndef,\n    \"no-undef-init\": () => noUndefInit,\n    \"no-undefined\": () => noUndefined,\n    \"no-underscore-dangle\": () => noUnderscoreDangle,\n    \"no-unexpected-multiline\": () => noUnexpectedMultiline,\n    \"no-unmodified-loop-condition\": () => noUnmodifiedLoopCondition,\n    \"no-unneeded-ternary\": () => noUnneededTernary,\n    \"no-unreachable\": () => noUnreachable,\n    \"no-unsafe-finally\": () => noUnsafeFinally,\n    \"no-unsafe-negation\": () => noUnsafeNegation,\n    \"no-unused-expressions\": () => noUnusedExpressions,\n    \"no-unused-labels\": () => noUnusedLabels,\n    \"no-unused-vars\": () => noUnusedVars,\n    \"no-use-before-define\": () => noUseBeforeDefine,\n    \"no-useless-call\": () => noUselessCall,\n    \"no-useless-catch\": () => noUselessCatch,\n    \"no-useless-computed-key\": () => noUselessComputedKey,\n    \"no-useless-concat\": () => noUselessConcat,\n    \"no-useless-constructor\": () => noUselessConstructor,\n    \"no-useless-escape\": () => noUselessEscape,\n    \"no-useless-rename\": () => noUselessRename,\n    \"no-useless-return\": () => noUselessReturn,\n    \"no-var\": () => noVar,\n    \"no-void\": () => noVoid,\n    \"no-warning-comments\": () => noWarningComments,\n    \"no-whitespace-before-property\": () => noWhitespaceBeforeProperty,\n    \"no-with\": () => noWith,\n    \"nonblock-statement-body-position\": () => nonblockStatementBodyPosition,\n    \"object-curly-newline\": () => objectCurlyNewline,\n    \"object-curly-spacing\": () => objectCurlySpacing,\n    \"object-property-newline\": () => objectPropertyNewline,\n    \"object-shorthand\": () => objectShorthand,\n    \"one-var\": () => oneVar,\n    \"one-var-declaration-per-line\": () => oneVarDeclarationPerLine,\n    \"operator-assignment\": () => operatorAssignment,\n    \"operator-linebreak\": () => operatorLinebreak,\n    \"padded-blocks\": () => paddedBlocks,\n    \"padding-line-between-statements\": () => paddingLineBetweenStatements,\n    \"prefer-arrow-callback\": () => preferArrowCallback,\n    \"prefer-const\": () => preferConst,\n    \"prefer-destructuring\": () => preferDestructuring,\n    \"prefer-exponentiation-operator\": () => preferExponentiationOperator,\n    \"prefer-named-capture-group\": () => preferNamedCaptureGroup,\n    \"prefer-numeric-literals\": () => preferNumericLiterals,\n    \"prefer-object-spread\": () => preferObjectSpread,\n    \"prefer-promise-reject-errors\": () => preferPromiseRejectErrors,\n    \"prefer-reflect\": () => preferReflect,\n    \"prefer-regex-literals\": () => preferRegexLiterals,\n    \"prefer-rest-params\": () => preferRestParams,\n    \"prefer-spread\": () => preferSpread,\n    \"prefer-template\": () => preferTemplate,\n    \"quote-props\": () => quoteProps,\n    quotes: () => quotes,\n    radix: () => radix,\n    \"require-atomic-updates\": () => requireAtomicUpdates,\n    \"require-await\": () => requireAwait,\n    \"require-jsdoc\": () => requireJsdoc,\n    \"require-unicode-regexp\": () => requireUnicodeRegexp,\n    \"require-yield\": () => requireYield,\n    \"rest-spread-spacing\": () => restSpreadSpacing,\n    semi: () => semi,\n    \"semi-spacing\": () => semiSpacing,\n    \"semi-style\": () => semiStyle,\n    \"sort-imports\": () => sortImports,\n    \"sort-keys\": () => sortKeys,\n    \"sort-vars\": () => sortVars,\n    \"space-before-blocks\": () => spaceBeforeBlocks,\n    \"space-before-function-paren\": () => spaceBeforeFunctionParen,\n    \"space-in-parens\": () => spaceInParens,\n    \"space-infix-ops\": () => spaceInfixOps,\n    \"space-unary-ops\": () => spaceUnaryOps,\n    \"spaced-comment\": () => spacedComment,\n    strict: () => strict,\n    \"switch-colon-spacing\": () => switchColonSpacing,\n    \"symbol-description\": () => symbolDescription,\n    \"template-curly-spacing\": () => templateCurlySpacing,\n    \"template-tag-spacing\": () => templateTagSpacing,\n    \"unicode-bom\": () => unicodeBom,\n    \"use-isnan\": () => useIsnan,\n    \"valid-jsdoc\": () => validJsdoc,\n    \"valid-typeof\": () => validTypeof,\n    \"vars-on-top\": () => varsOnTop,\n    \"wrap-iife\": () => wrapIife,\n    \"wrap-regex\": () => wrapRegex,\n    \"yield-star-spacing\": () => yieldStarSpacing,\n    yoda: () => yoda\n}));\n\nvar uri_all = createCommonjsModule(function (module, exports) {\n/** @license URI.js v4.2.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js */\n(function (global, factory) {\n\t factory(exports) ;\n}(this, (function (exports) {\nfunction merge() {\n    for (var _len = arguments.length, sets = Array(_len), _key = 0; _key < _len; _key++) {\n        sets[_key] = arguments[_key];\n    }\n\n    if (sets.length > 1) {\n        sets[0] = sets[0].slice(0, -1);\n        var xl = sets.length - 1;\n        for (var x = 1; x < xl; ++x) {\n            sets[x] = sets[x].slice(1, -1);\n        }\n        sets[xl] = sets[xl].slice(1);\n        return sets.join('');\n    } else {\n        return sets[0];\n    }\n}\nfunction subexp(str) {\n    return \"(?:\" + str + \")\";\n}\nfunction typeOf(o) {\n    return o === undefined ? \"undefined\" : o === null ? \"null\" : Object.prototype.toString.call(o).split(\" \").pop().split(\"]\").shift().toLowerCase();\n}\nfunction toUpperCase(str) {\n    return str.toUpperCase();\n}\nfunction toArray(obj) {\n    return obj !== undefined && obj !== null ? obj instanceof Array ? obj : typeof obj.length !== \"number\" || obj.split || obj.setInterval || obj.call ? [obj] : Array.prototype.slice.call(obj) : [];\n}\nfunction assign(target, source) {\n    var obj = target;\n    if (source) {\n        for (var key in source) {\n            obj[key] = source[key];\n        }\n    }\n    return obj;\n}\n\nfunction buildExps(isIRI) {\n    var ALPHA$$ = \"[A-Za-z]\",\n        DIGIT$$ = \"[0-9]\",\n        HEXDIG$$ = merge(DIGIT$$, \"[A-Fa-f]\"),\n        PCT_ENCODED$ = subexp(subexp(\"%[EFef]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%[89A-Fa-f]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%\" + HEXDIG$$ + HEXDIG$$)),\n        //expanded\n    GEN_DELIMS$$ = \"[\\\\:\\\\/\\\\?\\\\#\\\\[\\\\]\\\\@]\",\n        SUB_DELIMS$$ = \"[\\\\!\\\\$\\\\&\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\;\\\\=]\",\n        RESERVED$$ = merge(GEN_DELIMS$$, SUB_DELIMS$$),\n        UCSCHAR$$ = isIRI ? \"[\\\\xA0-\\\\u200D\\\\u2010-\\\\u2029\\\\u202F-\\\\uD7FF\\\\uF900-\\\\uFDCF\\\\uFDF0-\\\\uFFEF]\" : \"[]\",\n        //subset, excludes bidi control characters\n    IPRIVATE$$ = isIRI ? \"[\\\\uE000-\\\\uF8FF]\" : \"[]\",\n        //subset\n    UNRESERVED$$ = merge(ALPHA$$, DIGIT$$, \"[\\\\-\\\\.\\\\_\\\\~]\", UCSCHAR$$),\n        SCHEME$ = subexp(ALPHA$$ + merge(ALPHA$$, DIGIT$$, \"[\\\\+\\\\-\\\\.]\") + \"*\"),\n        USERINFO$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:]\")) + \"*\"),\n        DEC_OCTET_RELAXED$ = subexp(subexp(\"25[0-5]\") + \"|\" + subexp(\"2[0-4]\" + DIGIT$$) + \"|\" + subexp(\"1\" + DIGIT$$ + DIGIT$$) + \"|\" + subexp(\"0?[1-9]\" + DIGIT$$) + \"|0?0?\" + DIGIT$$),\n        //relaxed parsing rules\n    IPV4ADDRESS$ = subexp(DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$),\n        H16$ = subexp(HEXDIG$$ + \"{1,4}\"),\n        LS32$ = subexp(subexp(H16$ + \"\\\\:\" + H16$) + \"|\" + IPV4ADDRESS$),\n        IPV6ADDRESS1$ = subexp(subexp(H16$ + \"\\\\:\") + \"{6}\" + LS32$),\n        //                           6( h16 \":\" ) ls32\n    IPV6ADDRESS2$ = subexp(\"\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{5}\" + LS32$),\n        //                      \"::\" 5( h16 \":\" ) ls32\n    IPV6ADDRESS3$ = subexp(subexp(H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{4}\" + LS32$),\n        //[               h16 ] \"::\" 4( h16 \":\" ) ls32\n    IPV6ADDRESS4$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,1}\" + H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{3}\" + LS32$),\n        //[ *1( h16 \":\" ) h16 ] \"::\" 3( h16 \":\" ) ls32\n    IPV6ADDRESS5$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,2}\" + H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{2}\" + LS32$),\n        //[ *2( h16 \":\" ) h16 ] \"::\" 2( h16 \":\" ) ls32\n    IPV6ADDRESS6$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,3}\" + H16$) + \"?\\\\:\\\\:\" + H16$ + \"\\\\:\" + LS32$),\n        //[ *3( h16 \":\" ) h16 ] \"::\"    h16 \":\"   ls32\n    IPV6ADDRESS7$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,4}\" + H16$) + \"?\\\\:\\\\:\" + LS32$),\n        //[ *4( h16 \":\" ) h16 ] \"::\"              ls32\n    IPV6ADDRESS8$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,5}\" + H16$) + \"?\\\\:\\\\:\" + H16$),\n        //[ *5( h16 \":\" ) h16 ] \"::\"              h16\n    IPV6ADDRESS9$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,6}\" + H16$) + \"?\\\\:\\\\:\"),\n        //[ *6( h16 \":\" ) h16 ] \"::\"\n    IPV6ADDRESS$ = subexp([IPV6ADDRESS1$, IPV6ADDRESS2$, IPV6ADDRESS3$, IPV6ADDRESS4$, IPV6ADDRESS5$, IPV6ADDRESS6$, IPV6ADDRESS7$, IPV6ADDRESS8$, IPV6ADDRESS9$].join(\"|\")),\n        ZONEID$ = subexp(subexp(UNRESERVED$$ + \"|\" + PCT_ENCODED$) + \"+\"),\n        //RFC 6874, with relaxed parsing rules\n    IPVFUTURE$ = subexp(\"[vV]\" + HEXDIG$$ + \"+\\\\.\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:]\") + \"+\"),\n        //RFC 6874\n    REG_NAME$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$)) + \"*\"),\n        PCHAR$ = subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@]\")),\n        SEGMENT_NZ_NC$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\@]\")) + \"+\"),\n        QUERY$ = subexp(subexp(PCHAR$ + \"|\" + merge(\"[\\\\/\\\\?]\", IPRIVATE$$)) + \"*\");\n    return {\n        NOT_SCHEME: new RegExp(merge(\"[^]\", ALPHA$$, DIGIT$$, \"[\\\\+\\\\-\\\\.]\"), \"g\"),\n        NOT_USERINFO: new RegExp(merge(\"[^\\\\%\\\\:]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        NOT_HOST: new RegExp(merge(\"[^\\\\%\\\\[\\\\]\\\\:]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        NOT_PATH: new RegExp(merge(\"[^\\\\%\\\\/\\\\:\\\\@]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        NOT_PATH_NOSCHEME: new RegExp(merge(\"[^\\\\%\\\\/\\\\@]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        NOT_QUERY: new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@\\\\/\\\\?]\", IPRIVATE$$), \"g\"),\n        NOT_FRAGMENT: new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@\\\\/\\\\?]\"), \"g\"),\n        ESCAPE: new RegExp(merge(\"[^]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        UNRESERVED: new RegExp(UNRESERVED$$, \"g\"),\n        OTHER_CHARS: new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, RESERVED$$), \"g\"),\n        PCT_ENCODED: new RegExp(PCT_ENCODED$, \"g\"),\n        IPV4ADDRESS: new RegExp(\"^(\" + IPV4ADDRESS$ + \")$\"),\n        IPV6ADDRESS: new RegExp(\"^\\\\[?(\" + IPV6ADDRESS$ + \")\" + subexp(subexp(\"\\\\%25|\\\\%(?!\" + HEXDIG$$ + \"{2})\") + \"(\" + ZONEID$ + \")\") + \"?\\\\]?$\") //RFC 6874, with relaxed parsing rules\n    };\n}\nvar URI_PROTOCOL = buildExps(false);\n\nvar IRI_PROTOCOL = buildExps(true);\n\nvar slicedToArray = function () {\n  function sliceIterator(arr, i) {\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n    var _e = undefined;\n\n    try {\n      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n        _arr.push(_s.value);\n\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i[\"return\"]) _i[\"return\"]();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n\n    return _arr;\n  }\n\n  return function (arr, i) {\n    if (Array.isArray(arr)) {\n      return arr;\n    } else if (Symbol.iterator in Object(arr)) {\n      return sliceIterator(arr, i);\n    } else {\n      throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n    }\n  };\n}();\n\n\n\n\n\n\n\n\n\n\n\n\n\nvar toConsumableArray = function (arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n    return arr2;\n  } else {\n    return Array.from(arr);\n  }\n};\n\n/** Highest positive signed 32-bit float value */\n\nvar maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1\n\n/** Bootstring parameters */\nvar base = 36;\nvar tMin = 1;\nvar tMax = 26;\nvar skew = 38;\nvar damp = 700;\nvar initialBias = 72;\nvar initialN = 128; // 0x80\nvar delimiter = '-'; // '\\x2D'\n\n/** Regular expressions */\nvar regexPunycode = /^xn--/;\nvar regexNonASCII = /[^\\0-\\x7E]/; // non-ASCII chars\nvar regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g; // RFC 3490 separators\n\n/** Error messages */\nvar errors = {\n\t'overflow': 'Overflow: input needs wider integers to process',\n\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t'invalid-input': 'Invalid input'\n};\n\n/** Convenience shortcuts */\nvar baseMinusTMin = base - tMin;\nvar floor = Math.floor;\nvar stringFromCharCode = String.fromCharCode;\n\n/*--------------------------------------------------------------------------*/\n\n/**\n * A generic error utility function.\n * @private\n * @param {String} type The error type.\n * @returns {Error} Throws a `RangeError` with the applicable error message.\n */\nfunction error$1(type) {\n\tthrow new RangeError(errors[type]);\n}\n\n/**\n * A generic `Array#map` utility function.\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} callback The function that gets called for every array\n * item.\n * @returns {Array} A new array of values returned by the callback function.\n */\nfunction map(array, fn) {\n\tvar result = [];\n\tvar length = array.length;\n\twhile (length--) {\n\t\tresult[length] = fn(array[length]);\n\t}\n\treturn result;\n}\n\n/**\n * A simple `Array#map`-like wrapper to work with domain name strings or email\n * addresses.\n * @private\n * @param {String} domain The domain name or email address.\n * @param {Function} callback The function that gets called for every\n * character.\n * @returns {Array} A new string of characters returned by the callback\n * function.\n */\nfunction mapDomain(string, fn) {\n\tvar parts = string.split('@');\n\tvar result = '';\n\tif (parts.length > 1) {\n\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t// the local part (i.e. everything up to `@`) intact.\n\t\tresult = parts[0] + '@';\n\t\tstring = parts[1];\n\t}\n\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\tstring = string.replace(regexSeparators, '\\x2E');\n\tvar labels = string.split('.');\n\tvar encoded = map(labels, fn).join('.');\n\treturn result + encoded;\n}\n\n/**\n * Creates an array containing the numeric code points of each Unicode\n * character in the string. While JavaScript uses UCS-2 internally,\n * this function will convert a pair of surrogate halves (each of which\n * UCS-2 exposes as separate characters) into a single code point,\n * matching UTF-16.\n * @see `punycode.ucs2.encode`\n * @see <https://mathiasbynens.be/notes/javascript-encoding>\n * @memberOf punycode.ucs2\n * @name decode\n * @param {String} string The Unicode input string (UCS-2).\n * @returns {Array} The new array of code points.\n */\nfunction ucs2decode(string) {\n\tvar output = [];\n\tvar counter = 0;\n\tvar length = string.length;\n\twhile (counter < length) {\n\t\tvar value = string.charCodeAt(counter++);\n\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t// It's a high surrogate, and there is a next character.\n\t\t\tvar extra = string.charCodeAt(counter++);\n\t\t\tif ((extra & 0xFC00) == 0xDC00) {\n\t\t\t\t// Low surrogate.\n\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t} else {\n\t\t\t\t// It's an unmatched surrogate; only append this code unit, in case the\n\t\t\t\t// next code unit is the high surrogate of a surrogate pair.\n\t\t\t\toutput.push(value);\n\t\t\t\tcounter--;\n\t\t\t}\n\t\t} else {\n\t\t\toutput.push(value);\n\t\t}\n\t}\n\treturn output;\n}\n\n/**\n * Creates a string based on an array of numeric code points.\n * @see `punycode.ucs2.decode`\n * @memberOf punycode.ucs2\n * @name encode\n * @param {Array} codePoints The array of numeric code points.\n * @returns {String} The new Unicode string (UCS-2).\n */\nvar ucs2encode = function ucs2encode(array) {\n\treturn String.fromCodePoint.apply(String, toConsumableArray(array));\n};\n\n/**\n * Converts a basic code point into a digit/integer.\n * @see `digitToBasic()`\n * @private\n * @param {Number} codePoint The basic numeric code point value.\n * @returns {Number} The numeric value of a basic code point (for use in\n * representing integers) in the range `0` to `base - 1`, or `base` if\n * the code point does not represent a value.\n */\nvar basicToDigit = function basicToDigit(codePoint) {\n\tif (codePoint - 0x30 < 0x0A) {\n\t\treturn codePoint - 0x16;\n\t}\n\tif (codePoint - 0x41 < 0x1A) {\n\t\treturn codePoint - 0x41;\n\t}\n\tif (codePoint - 0x61 < 0x1A) {\n\t\treturn codePoint - 0x61;\n\t}\n\treturn base;\n};\n\n/**\n * Converts a digit/integer into a basic code point.\n * @see `basicToDigit()`\n * @private\n * @param {Number} digit The numeric value of a basic code point.\n * @returns {Number} The basic code point whose value (when used for\n * representing integers) is `digit`, which needs to be in the range\n * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n * used; else, the lowercase form is used. The behavior is undefined\n * if `flag` is non-zero and `digit` has no uppercase form.\n */\nvar digitToBasic = function digitToBasic(digit, flag) {\n\t//  0..25 map to ASCII a..z or A..Z\n\t// 26..35 map to ASCII 0..9\n\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n};\n\n/**\n * Bias adaptation function as per section 3.4 of RFC 3492.\n * https://tools.ietf.org/html/rfc3492#section-3.4\n * @private\n */\nvar adapt = function adapt(delta, numPoints, firstTime) {\n\tvar k = 0;\n\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\tdelta += floor(delta / numPoints);\n\tfor (; /* no initialization */delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\tdelta = floor(delta / baseMinusTMin);\n\t}\n\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n};\n\n/**\n * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n * symbols.\n * @memberOf punycode\n * @param {String} input The Punycode string of ASCII-only symbols.\n * @returns {String} The resulting string of Unicode symbols.\n */\nvar decode = function decode(input) {\n\t// Don't use UCS-2.\n\tvar output = [];\n\tvar inputLength = input.length;\n\tvar i = 0;\n\tvar n = initialN;\n\tvar bias = initialBias;\n\n\t// Handle the basic code points: let `basic` be the number of input code\n\t// points before the last delimiter, or `0` if there is none, then copy\n\t// the first basic code points to the output.\n\n\tvar basic = input.lastIndexOf(delimiter);\n\tif (basic < 0) {\n\t\tbasic = 0;\n\t}\n\n\tfor (var j = 0; j < basic; ++j) {\n\t\t// if it's not a basic code point\n\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\terror$1('not-basic');\n\t\t}\n\t\toutput.push(input.charCodeAt(j));\n\t}\n\n\t// Main decoding loop: start just after the last delimiter if any basic code\n\t// points were copied; start at the beginning otherwise.\n\n\tfor (var index = basic > 0 ? basic + 1 : 0; index < inputLength;) /* no final expression */{\n\n\t\t// `index` is the index of the next character to be consumed.\n\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t// which gets added to `i`. The overflow checking is easier\n\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t// value at the end to obtain `delta`.\n\t\tvar oldi = i;\n\t\tfor (var w = 1, k = base;; /* no condition */k += base) {\n\n\t\t\tif (index >= inputLength) {\n\t\t\t\terror$1('invalid-input');\n\t\t\t}\n\n\t\t\tvar digit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\terror$1('overflow');\n\t\t\t}\n\n\t\t\ti += digit * w;\n\t\t\tvar t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n\n\t\t\tif (digit < t) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tvar baseMinusT = base - t;\n\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\terror$1('overflow');\n\t\t\t}\n\n\t\t\tw *= baseMinusT;\n\t\t}\n\n\t\tvar out = output.length + 1;\n\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t// incrementing `n` each time, so we'll fix that now:\n\t\tif (floor(i / out) > maxInt - n) {\n\t\t\terror$1('overflow');\n\t\t}\n\n\t\tn += floor(i / out);\n\t\ti %= out;\n\n\t\t// Insert `n` at position `i` of the output.\n\t\toutput.splice(i++, 0, n);\n\t}\n\n\treturn String.fromCodePoint.apply(String, output);\n};\n\n/**\n * Converts a string of Unicode symbols (e.g. a domain name label) to a\n * Punycode string of ASCII-only symbols.\n * @memberOf punycode\n * @param {String} input The string of Unicode symbols.\n * @returns {String} The resulting Punycode string of ASCII-only symbols.\n */\nvar encode = function encode(input) {\n\tvar output = [];\n\n\t// Convert the input in UCS-2 to an array of Unicode code points.\n\tinput = ucs2decode(input);\n\n\t// Cache the length.\n\tvar inputLength = input.length;\n\n\t// Initialize the state.\n\tvar n = initialN;\n\tvar delta = 0;\n\tvar bias = initialBias;\n\n\t// Handle the basic code points.\n\tvar _iteratorNormalCompletion = true;\n\tvar _didIteratorError = false;\n\tvar _iteratorError = undefined;\n\n\ttry {\n\t\tfor (var _iterator = input[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n\t\t\tvar _currentValue2 = _step.value;\n\n\t\t\tif (_currentValue2 < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(_currentValue2));\n\t\t\t}\n\t\t}\n\t} catch (err) {\n\t\t_didIteratorError = true;\n\t\t_iteratorError = err;\n\t} finally {\n\t\ttry {\n\t\t\tif (!_iteratorNormalCompletion && _iterator.return) {\n\t\t\t\t_iterator.return();\n\t\t\t}\n\t\t} finally {\n\t\t\tif (_didIteratorError) {\n\t\t\t\tthrow _iteratorError;\n\t\t\t}\n\t\t}\n\t}\n\n\tvar basicLength = output.length;\n\tvar handledCPCount = basicLength;\n\n\t// `handledCPCount` is the number of code points that have been handled;\n\t// `basicLength` is the number of basic code points.\n\n\t// Finish the basic string with a delimiter unless it's empty.\n\tif (basicLength) {\n\t\toutput.push(delimiter);\n\t}\n\n\t// Main encoding loop:\n\twhile (handledCPCount < inputLength) {\n\n\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t// larger one:\n\t\tvar m = maxInt;\n\t\tvar _iteratorNormalCompletion2 = true;\n\t\tvar _didIteratorError2 = false;\n\t\tvar _iteratorError2 = undefined;\n\n\t\ttry {\n\t\t\tfor (var _iterator2 = input[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n\t\t\t\tvar currentValue = _step2.value;\n\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow.\n\t\t} catch (err) {\n\t\t\t_didIteratorError2 = true;\n\t\t\t_iteratorError2 = err;\n\t\t} finally {\n\t\t\ttry {\n\t\t\t\tif (!_iteratorNormalCompletion2 && _iterator2.return) {\n\t\t\t\t\t_iterator2.return();\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tif (_didIteratorError2) {\n\t\t\t\t\tthrow _iteratorError2;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tvar handledCPCountPlusOne = handledCPCount + 1;\n\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\terror$1('overflow');\n\t\t}\n\n\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\tn = m;\n\n\t\tvar _iteratorNormalCompletion3 = true;\n\t\tvar _didIteratorError3 = false;\n\t\tvar _iteratorError3 = undefined;\n\n\t\ttry {\n\t\t\tfor (var _iterator3 = input[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {\n\t\t\t\tvar _currentValue = _step3.value;\n\n\t\t\t\tif (_currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror$1('overflow');\n\t\t\t\t}\n\t\t\t\tif (_currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer.\n\t\t\t\t\tvar q = delta;\n\t\t\t\t\tfor (var k = base;; /* no condition */k += base) {\n\t\t\t\t\t\tvar t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tvar qMinusT = q - t;\n\t\t\t\t\t\tvar baseMinusT = base - t;\n\t\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\t\t} catch (err) {\n\t\t\t_didIteratorError3 = true;\n\t\t\t_iteratorError3 = err;\n\t\t} finally {\n\t\t\ttry {\n\t\t\t\tif (!_iteratorNormalCompletion3 && _iterator3.return) {\n\t\t\t\t\t_iterator3.return();\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tif (_didIteratorError3) {\n\t\t\t\t\tthrow _iteratorError3;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t++delta;\n\t\t++n;\n\t}\n\treturn output.join('');\n};\n\n/**\n * Converts a Punycode string representing a domain name or an email address\n * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n * it doesn't matter if you call it on a string that has already been\n * converted to Unicode.\n * @memberOf punycode\n * @param {String} input The Punycoded domain name or email address to\n * convert to Unicode.\n * @returns {String} The Unicode representation of the given Punycode\n * string.\n */\nvar toUnicode = function toUnicode(input) {\n\treturn mapDomain(input, function (string) {\n\t\treturn regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;\n\t});\n};\n\n/**\n * Converts a Unicode string representing a domain name or an email address to\n * Punycode. Only the non-ASCII parts of the domain name will be converted,\n * i.e. it doesn't matter if you call it with a domain that's already in\n * ASCII.\n * @memberOf punycode\n * @param {String} input The domain name or email address to convert, as a\n * Unicode string.\n * @returns {String} The Punycode representation of the given domain name or\n * email address.\n */\nvar toASCII = function toASCII(input) {\n\treturn mapDomain(input, function (string) {\n\t\treturn regexNonASCII.test(string) ? 'xn--' + encode(string) : string;\n\t});\n};\n\n/*--------------------------------------------------------------------------*/\n\n/** Define the public API */\nvar punycode = {\n\t/**\n  * A string representing the current Punycode.js version number.\n  * @memberOf punycode\n  * @type String\n  */\n\t'version': '2.1.0',\n\t/**\n  * An object of methods to convert from JavaScript's internal character\n  * representation (UCS-2) to Unicode code points, and back.\n  * @see <https://mathiasbynens.be/notes/javascript-encoding>\n  * @memberOf punycode\n  * @type Object\n  */\n\t'ucs2': {\n\t\t'decode': ucs2decode,\n\t\t'encode': ucs2encode\n\t},\n\t'decode': decode,\n\t'encode': encode,\n\t'toASCII': toASCII,\n\t'toUnicode': toUnicode\n};\n\n/**\n * URI.js\n *\n * @fileoverview An RFC 3986 compliant, scheme extendable URI parsing/validating/resolving library for JavaScript.\n * @author <a href=\"mailto:gary.court@gmail.com\">Gary Court</a>\n * @see http://github.com/garycourt/uri-js\n */\n/**\n * Copyright 2011 Gary Court. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without modification, are\n * permitted provided that the following conditions are met:\n *\n *    1. Redistributions of source code must retain the above copyright notice, this list of\n *       conditions and the following disclaimer.\n *\n *    2. Redistributions in binary form must reproduce the above copyright notice, this list\n *       of conditions and the following disclaimer in the documentation and/or other materials\n *       provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY GARY COURT ``AS IS'' AND ANY EXPRESS OR IMPLIED\n * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND\n * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARY COURT OR\n * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\n * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\n * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *\n * The views and conclusions contained in the software and documentation are those of the\n * authors and should not be interpreted as representing official policies, either expressed\n * or implied, of Gary Court.\n */\nvar SCHEMES = {};\nfunction pctEncChar(chr) {\n    var c = chr.charCodeAt(0);\n    var e = void 0;\n    if (c < 16) e = \"%0\" + c.toString(16).toUpperCase();else if (c < 128) e = \"%\" + c.toString(16).toUpperCase();else if (c < 2048) e = \"%\" + (c >> 6 | 192).toString(16).toUpperCase() + \"%\" + (c & 63 | 128).toString(16).toUpperCase();else e = \"%\" + (c >> 12 | 224).toString(16).toUpperCase() + \"%\" + (c >> 6 & 63 | 128).toString(16).toUpperCase() + \"%\" + (c & 63 | 128).toString(16).toUpperCase();\n    return e;\n}\nfunction pctDecChars(str) {\n    var newStr = \"\";\n    var i = 0;\n    var il = str.length;\n    while (i < il) {\n        var c = parseInt(str.substr(i + 1, 2), 16);\n        if (c < 128) {\n            newStr += String.fromCharCode(c);\n            i += 3;\n        } else if (c >= 194 && c < 224) {\n            if (il - i >= 6) {\n                var c2 = parseInt(str.substr(i + 4, 2), 16);\n                newStr += String.fromCharCode((c & 31) << 6 | c2 & 63);\n            } else {\n                newStr += str.substr(i, 6);\n            }\n            i += 6;\n        } else if (c >= 224) {\n            if (il - i >= 9) {\n                var _c = parseInt(str.substr(i + 4, 2), 16);\n                var c3 = parseInt(str.substr(i + 7, 2), 16);\n                newStr += String.fromCharCode((c & 15) << 12 | (_c & 63) << 6 | c3 & 63);\n            } else {\n                newStr += str.substr(i, 9);\n            }\n            i += 9;\n        } else {\n            newStr += str.substr(i, 3);\n            i += 3;\n        }\n    }\n    return newStr;\n}\nfunction _normalizeComponentEncoding(components, protocol) {\n    function decodeUnreserved(str) {\n        var decStr = pctDecChars(str);\n        return !decStr.match(protocol.UNRESERVED) ? str : decStr;\n    }\n    if (components.scheme) components.scheme = String(components.scheme).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_SCHEME, \"\");\n    if (components.userinfo !== undefined) components.userinfo = String(components.userinfo).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_USERINFO, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n    if (components.host !== undefined) components.host = String(components.host).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_HOST, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n    if (components.path !== undefined) components.path = String(components.path).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(components.scheme ? protocol.NOT_PATH : protocol.NOT_PATH_NOSCHEME, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n    if (components.query !== undefined) components.query = String(components.query).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_QUERY, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n    if (components.fragment !== undefined) components.fragment = String(components.fragment).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_FRAGMENT, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n    return components;\n}\n\nfunction _stripLeadingZeros(str) {\n    return str.replace(/^0*(.*)/, \"$1\") || \"0\";\n}\nfunction _normalizeIPv4(host, protocol) {\n    var matches = host.match(protocol.IPV4ADDRESS) || [];\n\n    var _matches = slicedToArray(matches, 2),\n        address = _matches[1];\n\n    if (address) {\n        return address.split(\".\").map(_stripLeadingZeros).join(\".\");\n    } else {\n        return host;\n    }\n}\nfunction _normalizeIPv6(host, protocol) {\n    var matches = host.match(protocol.IPV6ADDRESS) || [];\n\n    var _matches2 = slicedToArray(matches, 3),\n        address = _matches2[1],\n        zone = _matches2[2];\n\n    if (address) {\n        var _address$toLowerCase$ = address.toLowerCase().split('::').reverse(),\n            _address$toLowerCase$2 = slicedToArray(_address$toLowerCase$, 2),\n            last = _address$toLowerCase$2[0],\n            first = _address$toLowerCase$2[1];\n\n        var firstFields = first ? first.split(\":\").map(_stripLeadingZeros) : [];\n        var lastFields = last.split(\":\").map(_stripLeadingZeros);\n        var isLastFieldIPv4Address = protocol.IPV4ADDRESS.test(lastFields[lastFields.length - 1]);\n        var fieldCount = isLastFieldIPv4Address ? 7 : 8;\n        var lastFieldsStart = lastFields.length - fieldCount;\n        var fields = Array(fieldCount);\n        for (var x = 0; x < fieldCount; ++x) {\n            fields[x] = firstFields[x] || lastFields[lastFieldsStart + x] || '';\n        }\n        if (isLastFieldIPv4Address) {\n            fields[fieldCount - 1] = _normalizeIPv4(fields[fieldCount - 1], protocol);\n        }\n        var allZeroFields = fields.reduce(function (acc, field, index) {\n            if (!field || field === \"0\") {\n                var lastLongest = acc[acc.length - 1];\n                if (lastLongest && lastLongest.index + lastLongest.length === index) {\n                    lastLongest.length++;\n                } else {\n                    acc.push({ index: index, length: 1 });\n                }\n            }\n            return acc;\n        }, []);\n        var longestZeroFields = allZeroFields.sort(function (a, b) {\n            return b.length - a.length;\n        })[0];\n        var newHost = void 0;\n        if (longestZeroFields && longestZeroFields.length > 1) {\n            var newFirst = fields.slice(0, longestZeroFields.index);\n            var newLast = fields.slice(longestZeroFields.index + longestZeroFields.length);\n            newHost = newFirst.join(\":\") + \"::\" + newLast.join(\":\");\n        } else {\n            newHost = fields.join(\":\");\n        }\n        if (zone) {\n            newHost += \"%\" + zone;\n        }\n        return newHost;\n    } else {\n        return host;\n    }\n}\nvar URI_PARSE = /^(?:([^:\\/?#]+):)?(?:\\/\\/((?:([^\\/?#@]*)@)?(\\[[^\\/?#\\]]+\\]|[^\\/?#:]*)(?:\\:(\\d*))?))?([^?#]*)(?:\\?([^#]*))?(?:#((?:.|\\n|\\r)*))?/i;\nvar NO_MATCH_IS_UNDEFINED = \"\".match(/(){0}/)[1] === undefined;\nfunction parse(uriString) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    var components = {};\n    var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;\n    if (options.reference === \"suffix\") uriString = (options.scheme ? options.scheme + \":\" : \"\") + \"//\" + uriString;\n    var matches = uriString.match(URI_PARSE);\n    if (matches) {\n        if (NO_MATCH_IS_UNDEFINED) {\n            //store each component\n            components.scheme = matches[1];\n            components.userinfo = matches[3];\n            components.host = matches[4];\n            components.port = parseInt(matches[5], 10);\n            components.path = matches[6] || \"\";\n            components.query = matches[7];\n            components.fragment = matches[8];\n            //fix port number\n            if (isNaN(components.port)) {\n                components.port = matches[5];\n            }\n        } else {\n            //IE FIX for improper RegExp matching\n            //store each component\n            components.scheme = matches[1] || undefined;\n            components.userinfo = uriString.indexOf(\"@\") !== -1 ? matches[3] : undefined;\n            components.host = uriString.indexOf(\"//\") !== -1 ? matches[4] : undefined;\n            components.port = parseInt(matches[5], 10);\n            components.path = matches[6] || \"\";\n            components.query = uriString.indexOf(\"?\") !== -1 ? matches[7] : undefined;\n            components.fragment = uriString.indexOf(\"#\") !== -1 ? matches[8] : undefined;\n            //fix port number\n            if (isNaN(components.port)) {\n                components.port = uriString.match(/\\/\\/(?:.|\\n)*\\:(?:\\/|\\?|\\#|$)/) ? matches[4] : undefined;\n            }\n        }\n        if (components.host) {\n            //normalize IP hosts\n            components.host = _normalizeIPv6(_normalizeIPv4(components.host, protocol), protocol);\n        }\n        //determine reference type\n        if (components.scheme === undefined && components.userinfo === undefined && components.host === undefined && components.port === undefined && !components.path && components.query === undefined) {\n            components.reference = \"same-document\";\n        } else if (components.scheme === undefined) {\n            components.reference = \"relative\";\n        } else if (components.fragment === undefined) {\n            components.reference = \"absolute\";\n        } else {\n            components.reference = \"uri\";\n        }\n        //check for reference errors\n        if (options.reference && options.reference !== \"suffix\" && options.reference !== components.reference) {\n            components.error = components.error || \"URI is not a \" + options.reference + \" reference.\";\n        }\n        //find scheme handler\n        var schemeHandler = SCHEMES[(options.scheme || components.scheme || \"\").toLowerCase()];\n        //check if scheme can't handle IRIs\n        if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {\n            //if host component is a domain name\n            if (components.host && (options.domainHost || schemeHandler && schemeHandler.domainHost)) {\n                //convert Unicode IDN -> ASCII IDN\n                try {\n                    components.host = punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase());\n                } catch (e) {\n                    components.error = components.error || \"Host's domain name can not be converted to ASCII via punycode: \" + e;\n                }\n            }\n            //convert IRI -> URI\n            _normalizeComponentEncoding(components, URI_PROTOCOL);\n        } else {\n            //normalize encodings\n            _normalizeComponentEncoding(components, protocol);\n        }\n        //perform scheme specific parsing\n        if (schemeHandler && schemeHandler.parse) {\n            schemeHandler.parse(components, options);\n        }\n    } else {\n        components.error = components.error || \"URI can not be parsed.\";\n    }\n    return components;\n}\n\nfunction _recomposeAuthority(components, options) {\n    var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;\n    var uriTokens = [];\n    if (components.userinfo !== undefined) {\n        uriTokens.push(components.userinfo);\n        uriTokens.push(\"@\");\n    }\n    if (components.host !== undefined) {\n        //normalize IP hosts, add brackets and escape zone separator for IPv6\n        uriTokens.push(_normalizeIPv6(_normalizeIPv4(String(components.host), protocol), protocol).replace(protocol.IPV6ADDRESS, function (_, $1, $2) {\n            return \"[\" + $1 + ($2 ? \"%25\" + $2 : \"\") + \"]\";\n        }));\n    }\n    if (typeof components.port === \"number\") {\n        uriTokens.push(\":\");\n        uriTokens.push(components.port.toString(10));\n    }\n    return uriTokens.length ? uriTokens.join(\"\") : undefined;\n}\n\nvar RDS1 = /^\\.\\.?\\//;\nvar RDS2 = /^\\/\\.(\\/|$)/;\nvar RDS3 = /^\\/\\.\\.(\\/|$)/;\nvar RDS5 = /^\\/?(?:.|\\n)*?(?=\\/|$)/;\nfunction removeDotSegments(input) {\n    var output = [];\n    while (input.length) {\n        if (input.match(RDS1)) {\n            input = input.replace(RDS1, \"\");\n        } else if (input.match(RDS2)) {\n            input = input.replace(RDS2, \"/\");\n        } else if (input.match(RDS3)) {\n            input = input.replace(RDS3, \"/\");\n            output.pop();\n        } else if (input === \".\" || input === \"..\") {\n            input = \"\";\n        } else {\n            var im = input.match(RDS5);\n            if (im) {\n                var s = im[0];\n                input = input.slice(s.length);\n                output.push(s);\n            } else {\n                throw new Error(\"Unexpected dot segment condition\");\n            }\n        }\n    }\n    return output.join(\"\");\n}\n\nfunction serialize(components) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    var protocol = options.iri ? IRI_PROTOCOL : URI_PROTOCOL;\n    var uriTokens = [];\n    //find scheme handler\n    var schemeHandler = SCHEMES[(options.scheme || components.scheme || \"\").toLowerCase()];\n    //perform scheme specific serialization\n    if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options);\n    if (components.host) {\n        //if host component is an IPv6 address\n        if (protocol.IPV6ADDRESS.test(components.host)) ;\n        //TODO: normalize IPv6 address as per RFC 5952\n\n        //if host component is a domain name\n        else if (options.domainHost || schemeHandler && schemeHandler.domainHost) {\n                //convert IDN via punycode\n                try {\n                    components.host = !options.iri ? punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode.toUnicode(components.host);\n                } catch (e) {\n                    components.error = components.error || \"Host's domain name can not be converted to \" + (!options.iri ? \"ASCII\" : \"Unicode\") + \" via punycode: \" + e;\n                }\n            }\n    }\n    //normalize encoding\n    _normalizeComponentEncoding(components, protocol);\n    if (options.reference !== \"suffix\" && components.scheme) {\n        uriTokens.push(components.scheme);\n        uriTokens.push(\":\");\n    }\n    var authority = _recomposeAuthority(components, options);\n    if (authority !== undefined) {\n        if (options.reference !== \"suffix\") {\n            uriTokens.push(\"//\");\n        }\n        uriTokens.push(authority);\n        if (components.path && components.path.charAt(0) !== \"/\") {\n            uriTokens.push(\"/\");\n        }\n    }\n    if (components.path !== undefined) {\n        var s = components.path;\n        if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {\n            s = removeDotSegments(s);\n        }\n        if (authority === undefined) {\n            s = s.replace(/^\\/\\//, \"/%2F\"); //don't allow the path to start with \"//\"\n        }\n        uriTokens.push(s);\n    }\n    if (components.query !== undefined) {\n        uriTokens.push(\"?\");\n        uriTokens.push(components.query);\n    }\n    if (components.fragment !== undefined) {\n        uriTokens.push(\"#\");\n        uriTokens.push(components.fragment);\n    }\n    return uriTokens.join(\"\"); //merge tokens into a string\n}\n\nfunction resolveComponents(base, relative) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var skipNormalization = arguments[3];\n\n    var target = {};\n    if (!skipNormalization) {\n        base = parse(serialize(base, options), options); //normalize base components\n        relative = parse(serialize(relative, options), options); //normalize relative components\n    }\n    options = options || {};\n    if (!options.tolerant && relative.scheme) {\n        target.scheme = relative.scheme;\n        //target.authority = relative.authority;\n        target.userinfo = relative.userinfo;\n        target.host = relative.host;\n        target.port = relative.port;\n        target.path = removeDotSegments(relative.path || \"\");\n        target.query = relative.query;\n    } else {\n        if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {\n            //target.authority = relative.authority;\n            target.userinfo = relative.userinfo;\n            target.host = relative.host;\n            target.port = relative.port;\n            target.path = removeDotSegments(relative.path || \"\");\n            target.query = relative.query;\n        } else {\n            if (!relative.path) {\n                target.path = base.path;\n                if (relative.query !== undefined) {\n                    target.query = relative.query;\n                } else {\n                    target.query = base.query;\n                }\n            } else {\n                if (relative.path.charAt(0) === \"/\") {\n                    target.path = removeDotSegments(relative.path);\n                } else {\n                    if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {\n                        target.path = \"/\" + relative.path;\n                    } else if (!base.path) {\n                        target.path = relative.path;\n                    } else {\n                        target.path = base.path.slice(0, base.path.lastIndexOf(\"/\") + 1) + relative.path;\n                    }\n                    target.path = removeDotSegments(target.path);\n                }\n                target.query = relative.query;\n            }\n            //target.authority = base.authority;\n            target.userinfo = base.userinfo;\n            target.host = base.host;\n            target.port = base.port;\n        }\n        target.scheme = base.scheme;\n    }\n    target.fragment = relative.fragment;\n    return target;\n}\n\nfunction resolve(baseURI, relativeURI, options) {\n    var schemelessOptions = assign({ scheme: 'null' }, options);\n    return serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);\n}\n\nfunction normalize(uri, options) {\n    if (typeof uri === \"string\") {\n        uri = serialize(parse(uri, options), options);\n    } else if (typeOf(uri) === \"object\") {\n        uri = parse(serialize(uri, options), options);\n    }\n    return uri;\n}\n\nfunction equal(uriA, uriB, options) {\n    if (typeof uriA === \"string\") {\n        uriA = serialize(parse(uriA, options), options);\n    } else if (typeOf(uriA) === \"object\") {\n        uriA = serialize(uriA, options);\n    }\n    if (typeof uriB === \"string\") {\n        uriB = serialize(parse(uriB, options), options);\n    } else if (typeOf(uriB) === \"object\") {\n        uriB = serialize(uriB, options);\n    }\n    return uriA === uriB;\n}\n\nfunction escapeComponent(str, options) {\n    return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.ESCAPE : IRI_PROTOCOL.ESCAPE, pctEncChar);\n}\n\nfunction unescapeComponent(str, options) {\n    return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.PCT_ENCODED : IRI_PROTOCOL.PCT_ENCODED, pctDecChars);\n}\n\nvar handler = {\n    scheme: \"http\",\n    domainHost: true,\n    parse: function parse(components, options) {\n        //report missing host\n        if (!components.host) {\n            components.error = components.error || \"HTTP URIs must have a host.\";\n        }\n        return components;\n    },\n    serialize: function serialize(components, options) {\n        //normalize the default port\n        if (components.port === (String(components.scheme).toLowerCase() !== \"https\" ? 80 : 443) || components.port === \"\") {\n            components.port = undefined;\n        }\n        //normalize the empty path\n        if (!components.path) {\n            components.path = \"/\";\n        }\n        //NOTE: We do not parse query strings for HTTP URIs\n        //as WWW Form Url Encoded query strings are part of the HTML4+ spec,\n        //and not the HTTP spec.\n        return components;\n    }\n};\n\nvar handler$1 = {\n    scheme: \"https\",\n    domainHost: handler.domainHost,\n    parse: handler.parse,\n    serialize: handler.serialize\n};\n\nvar O = {};\n//RFC 3986\nvar UNRESERVED$$ = \"[A-Za-z0-9\\\\-\\\\.\\\\_\\\\~\" + ( \"\\\\xA0-\\\\u200D\\\\u2010-\\\\u2029\\\\u202F-\\\\uD7FF\\\\uF900-\\\\uFDCF\\\\uFDF0-\\\\uFFEF\" ) + \"]\";\nvar HEXDIG$$ = \"[0-9A-Fa-f]\"; //case-insensitive\nvar PCT_ENCODED$ = subexp(subexp(\"%[EFef]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%[89A-Fa-f]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%\" + HEXDIG$$ + HEXDIG$$)); //expanded\n//RFC 5322, except these symbols as per RFC 6068: @ : / ? # [ ] & ; =\n//const ATEXT$$ = \"[A-Za-z0-9\\\\!\\\\#\\\\$\\\\%\\\\&\\\\'\\\\*\\\\+\\\\-\\\\/\\\\=\\\\?\\\\^\\\\_\\\\`\\\\{\\\\|\\\\}\\\\~]\";\n//const WSP$$ = \"[\\\\x20\\\\x09]\";\n//const OBS_QTEXT$$ = \"[\\\\x01-\\\\x08\\\\x0B\\\\x0C\\\\x0E-\\\\x1F\\\\x7F]\";  //(%d1-8 / %d11-12 / %d14-31 / %d127)\n//const QTEXT$$ = merge(\"[\\\\x21\\\\x23-\\\\x5B\\\\x5D-\\\\x7E]\", OBS_QTEXT$$);  //%d33 / %d35-91 / %d93-126 / obs-qtext\n//const VCHAR$$ = \"[\\\\x21-\\\\x7E]\";\n//const WSP$$ = \"[\\\\x20\\\\x09]\";\n//const OBS_QP$ = subexp(\"\\\\\\\\\" + merge(\"[\\\\x00\\\\x0D\\\\x0A]\", OBS_QTEXT$$));  //%d0 / CR / LF / obs-qtext\n//const FWS$ = subexp(subexp(WSP$$ + \"*\" + \"\\\\x0D\\\\x0A\") + \"?\" + WSP$$ + \"+\");\n//const QUOTED_PAIR$ = subexp(subexp(\"\\\\\\\\\" + subexp(VCHAR$$ + \"|\" + WSP$$)) + \"|\" + OBS_QP$);\n//const QUOTED_STRING$ = subexp('\\\\\"' + subexp(FWS$ + \"?\" + QCONTENT$) + \"*\" + FWS$ + \"?\" + '\\\\\"');\nvar ATEXT$$ = \"[A-Za-z0-9\\\\!\\\\$\\\\%\\\\'\\\\*\\\\+\\\\-\\\\^\\\\_\\\\`\\\\{\\\\|\\\\}\\\\~]\";\nvar QTEXT$$ = \"[\\\\!\\\\$\\\\%\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\-\\\\.0-9\\\\<\\\\>A-Z\\\\x5E-\\\\x7E]\";\nvar VCHAR$$ = merge(QTEXT$$, \"[\\\\\\\"\\\\\\\\]\");\nvar SOME_DELIMS$$ = \"[\\\\!\\\\$\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\;\\\\:\\\\@]\";\nvar UNRESERVED = new RegExp(UNRESERVED$$, \"g\");\nvar PCT_ENCODED = new RegExp(PCT_ENCODED$, \"g\");\nvar NOT_LOCAL_PART = new RegExp(merge(\"[^]\", ATEXT$$, \"[\\\\.]\", '[\\\\\"]', VCHAR$$), \"g\");\nvar NOT_HFNAME = new RegExp(merge(\"[^]\", UNRESERVED$$, SOME_DELIMS$$), \"g\");\nvar NOT_HFVALUE = NOT_HFNAME;\nfunction decodeUnreserved(str) {\n    var decStr = pctDecChars(str);\n    return !decStr.match(UNRESERVED) ? str : decStr;\n}\nvar handler$2 = {\n    scheme: \"mailto\",\n    parse: function parse$$1(components, options) {\n        var mailtoComponents = components;\n        var to = mailtoComponents.to = mailtoComponents.path ? mailtoComponents.path.split(\",\") : [];\n        mailtoComponents.path = undefined;\n        if (mailtoComponents.query) {\n            var unknownHeaders = false;\n            var headers = {};\n            var hfields = mailtoComponents.query.split(\"&\");\n            for (var x = 0, xl = hfields.length; x < xl; ++x) {\n                var hfield = hfields[x].split(\"=\");\n                switch (hfield[0]) {\n                    case \"to\":\n                        var toAddrs = hfield[1].split(\",\");\n                        for (var _x = 0, _xl = toAddrs.length; _x < _xl; ++_x) {\n                            to.push(toAddrs[_x]);\n                        }\n                        break;\n                    case \"subject\":\n                        mailtoComponents.subject = unescapeComponent(hfield[1], options);\n                        break;\n                    case \"body\":\n                        mailtoComponents.body = unescapeComponent(hfield[1], options);\n                        break;\n                    default:\n                        unknownHeaders = true;\n                        headers[unescapeComponent(hfield[0], options)] = unescapeComponent(hfield[1], options);\n                        break;\n                }\n            }\n            if (unknownHeaders) mailtoComponents.headers = headers;\n        }\n        mailtoComponents.query = undefined;\n        for (var _x2 = 0, _xl2 = to.length; _x2 < _xl2; ++_x2) {\n            var addr = to[_x2].split(\"@\");\n            addr[0] = unescapeComponent(addr[0]);\n            if (!options.unicodeSupport) {\n                //convert Unicode IDN -> ASCII IDN\n                try {\n                    addr[1] = punycode.toASCII(unescapeComponent(addr[1], options).toLowerCase());\n                } catch (e) {\n                    mailtoComponents.error = mailtoComponents.error || \"Email address's domain name can not be converted to ASCII via punycode: \" + e;\n                }\n            } else {\n                addr[1] = unescapeComponent(addr[1], options).toLowerCase();\n            }\n            to[_x2] = addr.join(\"@\");\n        }\n        return mailtoComponents;\n    },\n    serialize: function serialize$$1(mailtoComponents, options) {\n        var components = mailtoComponents;\n        var to = toArray(mailtoComponents.to);\n        if (to) {\n            for (var x = 0, xl = to.length; x < xl; ++x) {\n                var toAddr = String(to[x]);\n                var atIdx = toAddr.lastIndexOf(\"@\");\n                var localPart = toAddr.slice(0, atIdx).replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_LOCAL_PART, pctEncChar);\n                var domain = toAddr.slice(atIdx + 1);\n                //convert IDN via punycode\n                try {\n                    domain = !options.iri ? punycode.toASCII(unescapeComponent(domain, options).toLowerCase()) : punycode.toUnicode(domain);\n                } catch (e) {\n                    components.error = components.error || \"Email address's domain name can not be converted to \" + (!options.iri ? \"ASCII\" : \"Unicode\") + \" via punycode: \" + e;\n                }\n                to[x] = localPart + \"@\" + domain;\n            }\n            components.path = to.join(\",\");\n        }\n        var headers = mailtoComponents.headers = mailtoComponents.headers || {};\n        if (mailtoComponents.subject) headers[\"subject\"] = mailtoComponents.subject;\n        if (mailtoComponents.body) headers[\"body\"] = mailtoComponents.body;\n        var fields = [];\n        for (var name in headers) {\n            if (headers[name] !== O[name]) {\n                fields.push(name.replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFNAME, pctEncChar) + \"=\" + headers[name].replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFVALUE, pctEncChar));\n            }\n        }\n        if (fields.length) {\n            components.query = fields.join(\"&\");\n        }\n        return components;\n    }\n};\n\nvar URN_PARSE = /^([^\\:]+)\\:(.*)/;\n//RFC 2141\nvar handler$3 = {\n    scheme: \"urn\",\n    parse: function parse$$1(components, options) {\n        var matches = components.path && components.path.match(URN_PARSE);\n        var urnComponents = components;\n        if (matches) {\n            var scheme = options.scheme || urnComponents.scheme || \"urn\";\n            var nid = matches[1].toLowerCase();\n            var nss = matches[2];\n            var urnScheme = scheme + \":\" + (options.nid || nid);\n            var schemeHandler = SCHEMES[urnScheme];\n            urnComponents.nid = nid;\n            urnComponents.nss = nss;\n            urnComponents.path = undefined;\n            if (schemeHandler) {\n                urnComponents = schemeHandler.parse(urnComponents, options);\n            }\n        } else {\n            urnComponents.error = urnComponents.error || \"URN can not be parsed.\";\n        }\n        return urnComponents;\n    },\n    serialize: function serialize$$1(urnComponents, options) {\n        var scheme = options.scheme || urnComponents.scheme || \"urn\";\n        var nid = urnComponents.nid;\n        var urnScheme = scheme + \":\" + (options.nid || nid);\n        var schemeHandler = SCHEMES[urnScheme];\n        if (schemeHandler) {\n            urnComponents = schemeHandler.serialize(urnComponents, options);\n        }\n        var uriComponents = urnComponents;\n        var nss = urnComponents.nss;\n        uriComponents.path = (nid || options.nid) + \":\" + nss;\n        return uriComponents;\n    }\n};\n\nvar UUID = /^[0-9A-Fa-f]{8}(?:\\-[0-9A-Fa-f]{4}){3}\\-[0-9A-Fa-f]{12}$/;\n//RFC 4122\nvar handler$4 = {\n    scheme: \"urn:uuid\",\n    parse: function parse(urnComponents, options) {\n        var uuidComponents = urnComponents;\n        uuidComponents.uuid = uuidComponents.nss;\n        uuidComponents.nss = undefined;\n        if (!options.tolerant && (!uuidComponents.uuid || !uuidComponents.uuid.match(UUID))) {\n            uuidComponents.error = uuidComponents.error || \"UUID is not valid.\";\n        }\n        return uuidComponents;\n    },\n    serialize: function serialize(uuidComponents, options) {\n        var urnComponents = uuidComponents;\n        //normalize UUID\n        urnComponents.nss = (uuidComponents.uuid || \"\").toLowerCase();\n        return urnComponents;\n    }\n};\n\nSCHEMES[handler.scheme] = handler;\nSCHEMES[handler$1.scheme] = handler$1;\nSCHEMES[handler$2.scheme] = handler$2;\nSCHEMES[handler$3.scheme] = handler$3;\nSCHEMES[handler$4.scheme] = handler$4;\n\nexports.SCHEMES = SCHEMES;\nexports.pctEncChar = pctEncChar;\nexports.pctDecChars = pctDecChars;\nexports.parse = parse;\nexports.removeDotSegments = removeDotSegments;\nexports.serialize = serialize;\nexports.resolveComponents = resolveComponents;\nexports.resolve = resolve;\nexports.normalize = normalize;\nexports.equal = equal;\nexports.escapeComponent = escapeComponent;\nexports.unescapeComponent = unescapeComponent;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n\n});\n\nunwrapExports(uri_all);\n\n// do not edit .js files directly - edit src/index.jst\n\n\n\nvar fastDeepEqual = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n\n// https://mathiasbynens.be/notes/javascript-encoding\n// https://github.com/bestiejs/punycode.js - punycode.ucs2.decode\nvar ucs2length = function ucs2length(str) {\n  var length = 0\n    , len = str.length\n    , pos = 0\n    , value;\n  while (pos < len) {\n    length++;\n    value = str.charCodeAt(pos++);\n    if (value >= 0xD800 && value <= 0xDBFF && pos < len) {\n      // high surrogate, and there is a next character\n      value = str.charCodeAt(pos);\n      if ((value & 0xFC00) == 0xDC00) pos++; // low surrogate\n    }\n  }\n  return length;\n};\n\nvar util$1 = {\n  copy: copy,\n  checkDataType: checkDataType,\n  checkDataTypes: checkDataTypes,\n  coerceToTypes: coerceToTypes,\n  toHash: toHash,\n  getProperty: getProperty,\n  escapeQuotes: escapeQuotes,\n  equal: fastDeepEqual,\n  ucs2length: ucs2length,\n  varOccurences: varOccurences,\n  varReplace: varReplace,\n  cleanUpCode: cleanUpCode,\n  finalCleanUpCode: finalCleanUpCode,\n  schemaHasRules: schemaHasRules,\n  schemaHasRulesExcept: schemaHasRulesExcept,\n  schemaUnknownRules: schemaUnknownRules,\n  toQuotedString: toQuotedString,\n  getPathExpr: getPathExpr,\n  getPath: getPath,\n  getData: getData,\n  unescapeFragment: unescapeFragment,\n  unescapeJsonPointer: unescapeJsonPointer,\n  escapeFragment: escapeFragment,\n  escapeJsonPointer: escapeJsonPointer\n};\n\n\nfunction copy(o, to) {\n  to = to || {};\n  for (var key in o) to[key] = o[key];\n  return to;\n}\n\n\nfunction checkDataType(dataType, data, negate) {\n  var EQUAL = negate ? ' !== ' : ' === '\n    , AND = negate ? ' || ' : ' && '\n    , OK = negate ? '!' : ''\n    , NOT = negate ? '' : '!';\n  switch (dataType) {\n    case 'null': return data + EQUAL + 'null';\n    case 'array': return OK + 'Array.isArray(' + data + ')';\n    case 'object': return '(' + OK + data + AND +\n                          'typeof ' + data + EQUAL + '\"object\"' + AND +\n                          NOT + 'Array.isArray(' + data + '))';\n    case 'integer': return '(typeof ' + data + EQUAL + '\"number\"' + AND +\n                           NOT + '(' + data + ' % 1)' +\n                           AND + data + EQUAL + data + ')';\n    default: return 'typeof ' + data + EQUAL + '\"' + dataType + '\"';\n  }\n}\n\n\nfunction checkDataTypes(dataTypes, data) {\n  switch (dataTypes.length) {\n    case 1: return checkDataType(dataTypes[0], data, true);\n    default:\n      var code = '';\n      var types = toHash(dataTypes);\n      if (types.array && types.object) {\n        code = types.null ? '(': '(!' + data + ' || ';\n        code += 'typeof ' + data + ' !== \"object\")';\n        delete types.null;\n        delete types.array;\n        delete types.object;\n      }\n      if (types.number) delete types.integer;\n      for (var t in types)\n        code += (code ? ' && ' : '' ) + checkDataType(t, data, true);\n\n      return code;\n  }\n}\n\n\nvar COERCE_TO_TYPES = toHash([ 'string', 'number', 'integer', 'boolean', 'null' ]);\nfunction coerceToTypes(optionCoerceTypes, dataTypes) {\n  if (Array.isArray(dataTypes)) {\n    var types = [];\n    for (var i=0; i<dataTypes.length; i++) {\n      var t = dataTypes[i];\n      if (COERCE_TO_TYPES[t]) types[types.length] = t;\n      else if (optionCoerceTypes === 'array' && t === 'array') types[types.length] = t;\n    }\n    if (types.length) return types;\n  } else if (COERCE_TO_TYPES[dataTypes]) {\n    return [dataTypes];\n  } else if (optionCoerceTypes === 'array' && dataTypes === 'array') {\n    return ['array'];\n  }\n}\n\n\nfunction toHash(arr) {\n  var hash = {};\n  for (var i=0; i<arr.length; i++) hash[arr[i]] = true;\n  return hash;\n}\n\n\nvar IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;\nvar SINGLE_QUOTE = /'|\\\\/g;\nfunction getProperty(key) {\n  return typeof key == 'number'\n          ? '[' + key + ']'\n          : IDENTIFIER.test(key)\n            ? '.' + key\n            : \"['\" + escapeQuotes(key) + \"']\";\n}\n\n\nfunction escapeQuotes(str) {\n  return str.replace(SINGLE_QUOTE, '\\\\$&')\n            .replace(/\\n/g, '\\\\n')\n            .replace(/\\r/g, '\\\\r')\n            .replace(/\\f/g, '\\\\f')\n            .replace(/\\t/g, '\\\\t');\n}\n\n\nfunction varOccurences(str, dataVar) {\n  dataVar += '[^0-9]';\n  var matches = str.match(new RegExp(dataVar, 'g'));\n  return matches ? matches.length : 0;\n}\n\n\nfunction varReplace(str, dataVar, expr) {\n  dataVar += '([^0-9])';\n  expr = expr.replace(/\\$/g, '$$$$');\n  return str.replace(new RegExp(dataVar, 'g'), expr + '$1');\n}\n\n\nvar EMPTY_ELSE = /else\\s*{\\s*}/g\n  , EMPTY_IF_NO_ELSE = /if\\s*\\([^)]+\\)\\s*\\{\\s*\\}(?!\\s*else)/g\n  , EMPTY_IF_WITH_ELSE = /if\\s*\\(([^)]+)\\)\\s*\\{\\s*\\}\\s*else(?!\\s*if)/g;\nfunction cleanUpCode(out) {\n  return out.replace(EMPTY_ELSE, '')\n            .replace(EMPTY_IF_NO_ELSE, '')\n            .replace(EMPTY_IF_WITH_ELSE, 'if (!($1))');\n}\n\n\nvar ERRORS_REGEXP = /[^v.]errors/g\n  , REMOVE_ERRORS = /var errors = 0;|var vErrors = null;|validate.errors = vErrors;/g\n  , REMOVE_ERRORS_ASYNC = /var errors = 0;|var vErrors = null;/g\n  , RETURN_VALID = 'return errors === 0;'\n  , RETURN_TRUE = 'validate.errors = null; return true;'\n  , RETURN_ASYNC = /if \\(errors === 0\\) return data;\\s*else throw new ValidationError\\(vErrors\\);/\n  , RETURN_DATA_ASYNC = 'return data;'\n  , ROOTDATA_REGEXP = /[^A-Za-z_$]rootData[^A-Za-z0-9_$]/g\n  , REMOVE_ROOTDATA = /if \\(rootData === undefined\\) rootData = data;/;\n\nfunction finalCleanUpCode(out, async) {\n  var matches = out.match(ERRORS_REGEXP);\n  if (matches && matches.length == 2) {\n    out = async\n          ? out.replace(REMOVE_ERRORS_ASYNC, '')\n               .replace(RETURN_ASYNC, RETURN_DATA_ASYNC)\n          : out.replace(REMOVE_ERRORS, '')\n               .replace(RETURN_VALID, RETURN_TRUE);\n  }\n\n  matches = out.match(ROOTDATA_REGEXP);\n  if (!matches || matches.length !== 3) return out;\n  return out.replace(REMOVE_ROOTDATA, '');\n}\n\n\nfunction schemaHasRules(schema, rules) {\n  if (typeof schema == 'boolean') return !schema;\n  for (var key in schema) if (rules[key]) return true;\n}\n\n\nfunction schemaHasRulesExcept(schema, rules, exceptKeyword) {\n  if (typeof schema == 'boolean') return !schema && exceptKeyword != 'not';\n  for (var key in schema) if (key != exceptKeyword && rules[key]) return true;\n}\n\n\nfunction schemaUnknownRules(schema, rules) {\n  if (typeof schema == 'boolean') return;\n  for (var key in schema) if (!rules[key]) return key;\n}\n\n\nfunction toQuotedString(str) {\n  return '\\'' + escapeQuotes(str) + '\\'';\n}\n\n\nfunction getPathExpr(currentPath, expr, jsonPointers, isNumber) {\n  var path = jsonPointers // false by default\n              ? '\\'/\\' + ' + expr + (isNumber ? '' : '.replace(/~/g, \\'~0\\').replace(/\\\\//g, \\'~1\\')')\n              : (isNumber ? '\\'[\\' + ' + expr + ' + \\']\\'' : '\\'[\\\\\\'\\' + ' + expr + ' + \\'\\\\\\']\\'');\n  return joinPaths(currentPath, path);\n}\n\n\nfunction getPath(currentPath, prop, jsonPointers) {\n  var path = jsonPointers // false by default\n              ? toQuotedString('/' + escapeJsonPointer(prop))\n              : toQuotedString(getProperty(prop));\n  return joinPaths(currentPath, path);\n}\n\n\nvar JSON_POINTER = /^\\/(?:[^~]|~0|~1)*$/;\nvar RELATIVE_JSON_POINTER = /^([0-9]+)(#|\\/(?:[^~]|~0|~1)*)?$/;\nfunction getData($data, lvl, paths) {\n  var up, jsonPointer, data, matches;\n  if ($data === '') return 'rootData';\n  if ($data[0] == '/') {\n    if (!JSON_POINTER.test($data)) throw new Error('Invalid JSON-pointer: ' + $data);\n    jsonPointer = $data;\n    data = 'rootData';\n  } else {\n    matches = $data.match(RELATIVE_JSON_POINTER);\n    if (!matches) throw new Error('Invalid JSON-pointer: ' + $data);\n    up = +matches[1];\n    jsonPointer = matches[2];\n    if (jsonPointer == '#') {\n      if (up >= lvl) throw new Error('Cannot access property/index ' + up + ' levels up, current level is ' + lvl);\n      return paths[lvl - up];\n    }\n\n    if (up > lvl) throw new Error('Cannot access data ' + up + ' levels up, current level is ' + lvl);\n    data = 'data' + ((lvl - up) || '');\n    if (!jsonPointer) return data;\n  }\n\n  var expr = data;\n  var segments = jsonPointer.split('/');\n  for (var i=0; i<segments.length; i++) {\n    var segment = segments[i];\n    if (segment) {\n      data += getProperty(unescapeJsonPointer(segment));\n      expr += ' && ' + data;\n    }\n  }\n  return expr;\n}\n\n\nfunction joinPaths (a, b) {\n  if (a == '\"\"') return b;\n  return (a + ' + ' + b).replace(/' \\+ '/g, '');\n}\n\n\nfunction unescapeFragment(str) {\n  return unescapeJsonPointer(decodeURIComponent(str));\n}\n\n\nfunction escapeFragment(str) {\n  return encodeURIComponent(escapeJsonPointer(str));\n}\n\n\nfunction escapeJsonPointer(str) {\n  return str.replace(/~/g, '~0').replace(/\\//g, '~1');\n}\n\n\nfunction unescapeJsonPointer(str) {\n  return str.replace(/~1/g, '/').replace(/~0/g, '~');\n}\n\nvar schema_obj = SchemaObject;\n\nfunction SchemaObject(obj) {\n  util$1.copy(obj, this);\n}\n\nvar jsonSchemaTraverse = createCommonjsModule(function (module) {\n\nvar traverse = module.exports = function (schema, opts, cb) {\n  // Legacy support for v0.3.1 and earlier.\n  if (typeof opts == 'function') {\n    cb = opts;\n    opts = {};\n  }\n\n  cb = opts.cb || cb;\n  var pre = (typeof cb == 'function') ? cb : cb.pre || function() {};\n  var post = cb.post || function() {};\n\n  _traverse(opts, pre, post, schema, '', schema);\n};\n\n\ntraverse.keywords = {\n  additionalItems: true,\n  items: true,\n  contains: true,\n  additionalProperties: true,\n  propertyNames: true,\n  not: true\n};\n\ntraverse.arrayKeywords = {\n  items: true,\n  allOf: true,\n  anyOf: true,\n  oneOf: true\n};\n\ntraverse.propsKeywords = {\n  definitions: true,\n  properties: true,\n  patternProperties: true,\n  dependencies: true\n};\n\ntraverse.skipKeywords = {\n  default: true,\n  enum: true,\n  const: true,\n  required: true,\n  maximum: true,\n  minimum: true,\n  exclusiveMaximum: true,\n  exclusiveMinimum: true,\n  multipleOf: true,\n  maxLength: true,\n  minLength: true,\n  pattern: true,\n  format: true,\n  maxItems: true,\n  minItems: true,\n  uniqueItems: true,\n  maxProperties: true,\n  minProperties: true\n};\n\n\nfunction _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {\n  if (schema && typeof schema == 'object' && !Array.isArray(schema)) {\n    pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);\n    for (var key in schema) {\n      var sch = schema[key];\n      if (Array.isArray(sch)) {\n        if (key in traverse.arrayKeywords) {\n          for (var i=0; i<sch.length; i++)\n            _traverse(opts, pre, post, sch[i], jsonPtr + '/' + key + '/' + i, rootSchema, jsonPtr, key, schema, i);\n        }\n      } else if (key in traverse.propsKeywords) {\n        if (sch && typeof sch == 'object') {\n          for (var prop in sch)\n            _traverse(opts, pre, post, sch[prop], jsonPtr + '/' + key + '/' + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);\n        }\n      } else if (key in traverse.keywords || (opts.allKeys && !(key in traverse.skipKeywords))) {\n        _traverse(opts, pre, post, sch, jsonPtr + '/' + key, rootSchema, jsonPtr, key, schema);\n      }\n    }\n    post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);\n  }\n}\n\n\nfunction escapeJsonPtr(str) {\n  return str.replace(/~/g, '~0').replace(/\\//g, '~1');\n}\n});\n\nvar resolve_1 = resolve;\n\nresolve.normalizeId = normalizeId;\nresolve.fullPath = getFullPath;\nresolve.url = resolveUrl;\nresolve.ids = resolveIds;\nresolve.inlineRef = inlineRef;\nresolve.schema = resolveSchema;\n\n/**\n * [resolve and compile the references ($ref)]\n * @this   Ajv\n * @param  {Function} compile reference to schema compilation funciton (localCompile)\n * @param  {Object} root object with information about the root schema for the current schema\n * @param  {String} ref reference to resolve\n * @return {Object|Function} schema object (if the schema can be inlined) or validation function\n */\nfunction resolve(compile, root, ref) {\n  /* jshint validthis: true */\n  var refVal = this._refs[ref];\n  if (typeof refVal == 'string') {\n    if (this._refs[refVal]) refVal = this._refs[refVal];\n    else return resolve.call(this, compile, root, refVal);\n  }\n\n  refVal = refVal || this._schemas[ref];\n  if (refVal instanceof schema_obj) {\n    return inlineRef(refVal.schema, this._opts.inlineRefs)\n            ? refVal.schema\n            : refVal.validate || this._compile(refVal);\n  }\n\n  var res = resolveSchema.call(this, root, ref);\n  var schema, v, baseId;\n  if (res) {\n    schema = res.schema;\n    root = res.root;\n    baseId = res.baseId;\n  }\n\n  if (schema instanceof schema_obj) {\n    v = schema.validate || compile.call(this, schema.schema, root, undefined, baseId);\n  } else if (schema !== undefined) {\n    v = inlineRef(schema, this._opts.inlineRefs)\n        ? schema\n        : compile.call(this, schema, root, undefined, baseId);\n  }\n\n  return v;\n}\n\n\n/**\n * Resolve schema, its root and baseId\n * @this Ajv\n * @param  {Object} root root object with properties schema, refVal, refs\n * @param  {String} ref  reference to resolve\n * @return {Object} object with properties schema, root, baseId\n */\nfunction resolveSchema(root, ref) {\n  /* jshint validthis: true */\n  var p = uri_all.parse(ref)\n    , refPath = _getFullPath(p)\n    , baseId = getFullPath(this._getId(root.schema));\n  if (Object.keys(root.schema).length === 0 || refPath !== baseId) {\n    var id = normalizeId(refPath);\n    var refVal = this._refs[id];\n    if (typeof refVal == 'string') {\n      return resolveRecursive.call(this, root, refVal, p);\n    } else if (refVal instanceof schema_obj) {\n      if (!refVal.validate) this._compile(refVal);\n      root = refVal;\n    } else {\n      refVal = this._schemas[id];\n      if (refVal instanceof schema_obj) {\n        if (!refVal.validate) this._compile(refVal);\n        if (id == normalizeId(ref))\n          return { schema: refVal, root: root, baseId: baseId };\n        root = refVal;\n      } else {\n        return;\n      }\n    }\n    if (!root.schema) return;\n    baseId = getFullPath(this._getId(root.schema));\n  }\n  return getJsonPointer.call(this, p, baseId, root.schema, root);\n}\n\n\n/* @this Ajv */\nfunction resolveRecursive(root, ref, parsedRef) {\n  /* jshint validthis: true */\n  var res = resolveSchema.call(this, root, ref);\n  if (res) {\n    var schema = res.schema;\n    var baseId = res.baseId;\n    root = res.root;\n    var id = this._getId(schema);\n    if (id) baseId = resolveUrl(baseId, id);\n    return getJsonPointer.call(this, parsedRef, baseId, schema, root);\n  }\n}\n\n\nvar PREVENT_SCOPE_CHANGE = util$1.toHash(['properties', 'patternProperties', 'enum', 'dependencies', 'definitions']);\n/* @this Ajv */\nfunction getJsonPointer(parsedRef, baseId, schema, root) {\n  /* jshint validthis: true */\n  parsedRef.fragment = parsedRef.fragment || '';\n  if (parsedRef.fragment.slice(0,1) != '/') return;\n  var parts = parsedRef.fragment.split('/');\n\n  for (var i = 1; i < parts.length; i++) {\n    var part = parts[i];\n    if (part) {\n      part = util$1.unescapeFragment(part);\n      schema = schema[part];\n      if (schema === undefined) break;\n      var id;\n      if (!PREVENT_SCOPE_CHANGE[part]) {\n        id = this._getId(schema);\n        if (id) baseId = resolveUrl(baseId, id);\n        if (schema.$ref) {\n          var $ref = resolveUrl(baseId, schema.$ref);\n          var res = resolveSchema.call(this, root, $ref);\n          if (res) {\n            schema = res.schema;\n            root = res.root;\n            baseId = res.baseId;\n          }\n        }\n      }\n    }\n  }\n  if (schema !== undefined && schema !== root.schema)\n    return { schema: schema, root: root, baseId: baseId };\n}\n\n\nvar SIMPLE_INLINED = util$1.toHash([\n  'type', 'format', 'pattern',\n  'maxLength', 'minLength',\n  'maxProperties', 'minProperties',\n  'maxItems', 'minItems',\n  'maximum', 'minimum',\n  'uniqueItems', 'multipleOf',\n  'required', 'enum'\n]);\nfunction inlineRef(schema, limit) {\n  if (limit === false) return false;\n  if (limit === undefined || limit === true) return checkNoRef(schema);\n  else if (limit) return countKeys(schema) <= limit;\n}\n\n\nfunction checkNoRef(schema) {\n  var item;\n  if (Array.isArray(schema)) {\n    for (var i=0; i<schema.length; i++) {\n      item = schema[i];\n      if (typeof item == 'object' && !checkNoRef(item)) return false;\n    }\n  } else {\n    for (var key in schema) {\n      if (key == '$ref') return false;\n      item = schema[key];\n      if (typeof item == 'object' && !checkNoRef(item)) return false;\n    }\n  }\n  return true;\n}\n\n\nfunction countKeys(schema) {\n  var count = 0, item;\n  if (Array.isArray(schema)) {\n    for (var i=0; i<schema.length; i++) {\n      item = schema[i];\n      if (typeof item == 'object') count += countKeys(item);\n      if (count == Infinity) return Infinity;\n    }\n  } else {\n    for (var key in schema) {\n      if (key == '$ref') return Infinity;\n      if (SIMPLE_INLINED[key]) {\n        count++;\n      } else {\n        item = schema[key];\n        if (typeof item == 'object') count += countKeys(item) + 1;\n        if (count == Infinity) return Infinity;\n      }\n    }\n  }\n  return count;\n}\n\n\nfunction getFullPath(id, normalize) {\n  if (normalize !== false) id = normalizeId(id);\n  var p = uri_all.parse(id);\n  return _getFullPath(p);\n}\n\n\nfunction _getFullPath(p) {\n  return uri_all.serialize(p).split('#')[0] + '#';\n}\n\n\nvar TRAILING_SLASH_HASH = /#\\/?$/;\nfunction normalizeId(id) {\n  return id ? id.replace(TRAILING_SLASH_HASH, '') : '';\n}\n\n\nfunction resolveUrl(baseId, id) {\n  id = normalizeId(id);\n  return uri_all.resolve(baseId, id);\n}\n\n\n/* @this Ajv */\nfunction resolveIds(schema) {\n  var schemaId = normalizeId(this._getId(schema));\n  var baseIds = {'': schemaId};\n  var fullPaths = {'': getFullPath(schemaId, false)};\n  var localRefs = {};\n  var self = this;\n\n  jsonSchemaTraverse(schema, {allKeys: true}, function(sch, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {\n    if (jsonPtr === '') return;\n    var id = self._getId(sch);\n    var baseId = baseIds[parentJsonPtr];\n    var fullPath = fullPaths[parentJsonPtr] + '/' + parentKeyword;\n    if (keyIndex !== undefined)\n      fullPath += '/' + (typeof keyIndex == 'number' ? keyIndex : util$1.escapeFragment(keyIndex));\n\n    if (typeof id == 'string') {\n      id = baseId = normalizeId(baseId ? uri_all.resolve(baseId, id) : id);\n\n      var refVal = self._refs[id];\n      if (typeof refVal == 'string') refVal = self._refs[refVal];\n      if (refVal && refVal.schema) {\n        if (!fastDeepEqual(sch, refVal.schema))\n          throw new Error('id \"' + id + '\" resolves to more than one schema');\n      } else if (id != normalizeId(fullPath)) {\n        if (id[0] == '#') {\n          if (localRefs[id] && !fastDeepEqual(sch, localRefs[id]))\n            throw new Error('id \"' + id + '\" resolves to more than one schema');\n          localRefs[id] = sch;\n        } else {\n          self._refs[id] = fullPath;\n        }\n      }\n    }\n    baseIds[jsonPtr] = baseId;\n    fullPaths[jsonPtr] = fullPath;\n  });\n\n  return localRefs;\n}\n\nvar error_classes = {\n  Validation: errorSubclass(ValidationError),\n  MissingRef: errorSubclass(MissingRefError)\n};\n\n\nfunction ValidationError(errors) {\n  this.message = 'validation failed';\n  this.errors = errors;\n  this.ajv = this.validation = true;\n}\n\n\nMissingRefError.message = function (baseId, ref) {\n  return 'can\\'t resolve reference ' + ref + ' from id ' + baseId;\n};\n\n\nfunction MissingRefError(baseId, ref, message) {\n  this.message = message || MissingRefError.message(baseId, ref);\n  this.missingRef = resolve_1.url(baseId, ref);\n  this.missingSchema = resolve_1.normalizeId(resolve_1.fullPath(this.missingRef));\n}\n\n\nfunction errorSubclass(Subclass) {\n  Subclass.prototype = Object.create(Error.prototype);\n  Subclass.prototype.constructor = Subclass;\n  return Subclass;\n}\n\nvar fastJsonStableStringify = function (data, opts) {\n    if (!opts) opts = {};\n    if (typeof opts === 'function') opts = { cmp: opts };\n    var cycles = (typeof opts.cycles === 'boolean') ? opts.cycles : false;\n\n    var cmp = opts.cmp && (function (f) {\n        return function (node) {\n            return function (a, b) {\n                var aobj = { key: a, value: node[a] };\n                var bobj = { key: b, value: node[b] };\n                return f(aobj, bobj);\n            };\n        };\n    })(opts.cmp);\n\n    var seen = [];\n    return (function stringify (node) {\n        if (node && node.toJSON && typeof node.toJSON === 'function') {\n            node = node.toJSON();\n        }\n\n        if (node === undefined) return;\n        if (typeof node == 'number') return isFinite(node) ? '' + node : 'null';\n        if (typeof node !== 'object') return JSON.stringify(node);\n\n        var i, out;\n        if (Array.isArray(node)) {\n            out = '[';\n            for (i = 0; i < node.length; i++) {\n                if (i) out += ',';\n                out += stringify(node[i]) || 'null';\n            }\n            return out + ']';\n        }\n\n        if (node === null) return 'null';\n\n        if (seen.indexOf(node) !== -1) {\n            if (cycles) return JSON.stringify('__cycle__');\n            throw new TypeError('Converting circular structure to JSON');\n        }\n\n        var seenIndex = seen.push(node) - 1;\n        var keys = Object.keys(node).sort(cmp && cmp(node));\n        out = '';\n        for (i = 0; i < keys.length; i++) {\n            var key = keys[i];\n            var value = stringify(node[key]);\n\n            if (!value) continue;\n            if (out) out += ',';\n            out += JSON.stringify(key) + ':' + value;\n        }\n        seen.splice(seenIndex, 1);\n        return '{' + out + '}';\n    })(data);\n};\n\nvar validate = function generate_validate(it, $keyword, $ruleType) {\n  var out = '';\n  var $async = it.schema.$async === true,\n    $refKeywords = it.util.schemaHasRulesExcept(it.schema, it.RULES.all, '$ref'),\n    $id = it.self._getId(it.schema);\n  if (it.opts.strictKeywords) {\n    var $unknownKwd = it.util.schemaUnknownRules(it.schema, it.RULES.keywords);\n    if ($unknownKwd) {\n      var $keywordsMsg = 'unknown keyword: ' + $unknownKwd;\n      if (it.opts.strictKeywords === 'log') it.logger.warn($keywordsMsg);\n      else throw new Error($keywordsMsg);\n    }\n  }\n  if (it.isTop) {\n    out += ' var validate = ';\n    if ($async) {\n      it.async = true;\n      out += 'async ';\n    }\n    out += 'function(data, dataPath, parentData, parentDataProperty, rootData) { \\'use strict\\'; ';\n    if ($id && (it.opts.sourceCode || it.opts.processCode)) {\n      out += ' ' + ('/\\*# sourceURL=' + $id + ' */') + ' ';\n    }\n  }\n  if (typeof it.schema == 'boolean' || !($refKeywords || it.schema.$ref)) {\n    var $keyword = 'false schema';\n    var $lvl = it.level;\n    var $dataLvl = it.dataLevel;\n    var $schema = it.schema[$keyword];\n    var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n    var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n    var $breakOnError = !it.opts.allErrors;\n    var $errorKeyword;\n    var $data = 'data' + ($dataLvl || '');\n    var $valid = 'valid' + $lvl;\n    if (it.schema === false) {\n      if (it.isTop) {\n        $breakOnError = true;\n      } else {\n        out += ' var ' + ($valid) + ' = false; ';\n      }\n      var $$outStack = $$outStack || [];\n      $$outStack.push(out);\n      out = ''; /* istanbul ignore else */\n      if (it.createErrors !== false) {\n        out += ' { keyword: \\'' + ($errorKeyword || 'false schema') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n        if (it.opts.messages !== false) {\n          out += ' , message: \\'boolean schema is false\\' ';\n        }\n        if (it.opts.verbose) {\n          out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n        }\n        out += ' } ';\n      } else {\n        out += ' {} ';\n      }\n      var __err = out;\n      out = $$outStack.pop();\n      if (!it.compositeRule && $breakOnError) {\n        /* istanbul ignore if */\n        if (it.async) {\n          out += ' throw new ValidationError([' + (__err) + ']); ';\n        } else {\n          out += ' validate.errors = [' + (__err) + ']; return false; ';\n        }\n      } else {\n        out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n      }\n    } else {\n      if (it.isTop) {\n        if ($async) {\n          out += ' return data; ';\n        } else {\n          out += ' validate.errors = null; return true; ';\n        }\n      } else {\n        out += ' var ' + ($valid) + ' = true; ';\n      }\n    }\n    if (it.isTop) {\n      out += ' }; return validate; ';\n    }\n    return out;\n  }\n  if (it.isTop) {\n    var $top = it.isTop,\n      $lvl = it.level = 0,\n      $dataLvl = it.dataLevel = 0,\n      $data = 'data';\n    it.rootId = it.resolve.fullPath(it.self._getId(it.root.schema));\n    it.baseId = it.baseId || it.rootId;\n    delete it.isTop;\n    it.dataPathArr = [undefined];\n    if (it.schema.default !== undefined && it.opts.useDefaults && it.opts.strictDefaults) {\n      var $defaultMsg = 'default is ignored in the schema root';\n      if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg);\n      else throw new Error($defaultMsg);\n    }\n    out += ' var vErrors = null; ';\n    out += ' var errors = 0;     ';\n    out += ' if (rootData === undefined) rootData = data; ';\n  } else {\n    var $lvl = it.level,\n      $dataLvl = it.dataLevel,\n      $data = 'data' + ($dataLvl || '');\n    if ($id) it.baseId = it.resolve.url(it.baseId, $id);\n    if ($async && !it.async) throw new Error('async schema in sync schema');\n    out += ' var errs_' + ($lvl) + ' = errors;';\n  }\n  var $valid = 'valid' + $lvl,\n    $breakOnError = !it.opts.allErrors,\n    $closingBraces1 = '',\n    $closingBraces2 = '';\n  var $errorKeyword;\n  var $typeSchema = it.schema.type,\n    $typeIsArray = Array.isArray($typeSchema);\n  if ($typeSchema && it.opts.nullable && it.schema.nullable === true) {\n    if ($typeIsArray) {\n      if ($typeSchema.indexOf('null') == -1) $typeSchema = $typeSchema.concat('null');\n    } else if ($typeSchema != 'null') {\n      $typeSchema = [$typeSchema, 'null'];\n      $typeIsArray = true;\n    }\n  }\n  if ($typeIsArray && $typeSchema.length == 1) {\n    $typeSchema = $typeSchema[0];\n    $typeIsArray = false;\n  }\n  if (it.schema.$ref && $refKeywords) {\n    if (it.opts.extendRefs == 'fail') {\n      throw new Error('$ref: validation keywords used in schema at path \"' + it.errSchemaPath + '\" (see option extendRefs)');\n    } else if (it.opts.extendRefs !== true) {\n      $refKeywords = false;\n      it.logger.warn('$ref: keywords ignored in schema at path \"' + it.errSchemaPath + '\"');\n    }\n  }\n  if (it.schema.$comment && it.opts.$comment) {\n    out += ' ' + (it.RULES.all.$comment.code(it, '$comment'));\n  }\n  if ($typeSchema) {\n    if (it.opts.coerceTypes) {\n      var $coerceToTypes = it.util.coerceToTypes(it.opts.coerceTypes, $typeSchema);\n    }\n    var $rulesGroup = it.RULES.types[$typeSchema];\n    if ($coerceToTypes || $typeIsArray || $rulesGroup === true || ($rulesGroup && !$shouldUseGroup($rulesGroup))) {\n      var $schemaPath = it.schemaPath + '.type',\n        $errSchemaPath = it.errSchemaPath + '/type';\n      var $schemaPath = it.schemaPath + '.type',\n        $errSchemaPath = it.errSchemaPath + '/type',\n        $method = $typeIsArray ? 'checkDataTypes' : 'checkDataType';\n      out += ' if (' + (it.util[$method]($typeSchema, $data, true)) + ') { ';\n      if ($coerceToTypes) {\n        var $dataType = 'dataType' + $lvl,\n          $coerced = 'coerced' + $lvl;\n        out += ' var ' + ($dataType) + ' = typeof ' + ($data) + '; ';\n        if (it.opts.coerceTypes == 'array') {\n          out += ' if (' + ($dataType) + ' == \\'object\\' && Array.isArray(' + ($data) + ')) ' + ($dataType) + ' = \\'array\\'; ';\n        }\n        out += ' var ' + ($coerced) + ' = undefined; ';\n        var $bracesCoercion = '';\n        var arr1 = $coerceToTypes;\n        if (arr1) {\n          var $type, $i = -1,\n            l1 = arr1.length - 1;\n          while ($i < l1) {\n            $type = arr1[$i += 1];\n            if ($i) {\n              out += ' if (' + ($coerced) + ' === undefined) { ';\n              $bracesCoercion += '}';\n            }\n            if (it.opts.coerceTypes == 'array' && $type != 'array') {\n              out += ' if (' + ($dataType) + ' == \\'array\\' && ' + ($data) + '.length == 1) { ' + ($coerced) + ' = ' + ($data) + ' = ' + ($data) + '[0]; ' + ($dataType) + ' = typeof ' + ($data) + ';  } ';\n            }\n            if ($type == 'string') {\n              out += ' if (' + ($dataType) + ' == \\'number\\' || ' + ($dataType) + ' == \\'boolean\\') ' + ($coerced) + ' = \\'\\' + ' + ($data) + '; else if (' + ($data) + ' === null) ' + ($coerced) + ' = \\'\\'; ';\n            } else if ($type == 'number' || $type == 'integer') {\n              out += ' if (' + ($dataType) + ' == \\'boolean\\' || ' + ($data) + ' === null || (' + ($dataType) + ' == \\'string\\' && ' + ($data) + ' && ' + ($data) + ' == +' + ($data) + ' ';\n              if ($type == 'integer') {\n                out += ' && !(' + ($data) + ' % 1)';\n              }\n              out += ')) ' + ($coerced) + ' = +' + ($data) + '; ';\n            } else if ($type == 'boolean') {\n              out += ' if (' + ($data) + ' === \\'false\\' || ' + ($data) + ' === 0 || ' + ($data) + ' === null) ' + ($coerced) + ' = false; else if (' + ($data) + ' === \\'true\\' || ' + ($data) + ' === 1) ' + ($coerced) + ' = true; ';\n            } else if ($type == 'null') {\n              out += ' if (' + ($data) + ' === \\'\\' || ' + ($data) + ' === 0 || ' + ($data) + ' === false) ' + ($coerced) + ' = null; ';\n            } else if (it.opts.coerceTypes == 'array' && $type == 'array') {\n              out += ' if (' + ($dataType) + ' == \\'string\\' || ' + ($dataType) + ' == \\'number\\' || ' + ($dataType) + ' == \\'boolean\\' || ' + ($data) + ' == null) ' + ($coerced) + ' = [' + ($data) + ']; ';\n            }\n          }\n        }\n        out += ' ' + ($bracesCoercion) + ' if (' + ($coerced) + ' === undefined) {   ';\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ($errorKeyword || 'type') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \\'';\n          if ($typeIsArray) {\n            out += '' + ($typeSchema.join(\",\"));\n          } else {\n            out += '' + ($typeSchema);\n          }\n          out += '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'should be ';\n            if ($typeIsArray) {\n              out += '' + ($typeSchema.join(\",\"));\n            } else {\n              out += '' + ($typeSchema);\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n        out += ' } else {  ';\n        var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData',\n          $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty';\n        out += ' ' + ($data) + ' = ' + ($coerced) + '; ';\n        if (!$dataLvl) {\n          out += 'if (' + ($parentData) + ' !== undefined)';\n        }\n        out += ' ' + ($parentData) + '[' + ($parentDataProperty) + '] = ' + ($coerced) + '; } ';\n      } else {\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ($errorKeyword || 'type') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \\'';\n          if ($typeIsArray) {\n            out += '' + ($typeSchema.join(\",\"));\n          } else {\n            out += '' + ($typeSchema);\n          }\n          out += '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'should be ';\n            if ($typeIsArray) {\n              out += '' + ($typeSchema.join(\",\"));\n            } else {\n              out += '' + ($typeSchema);\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n      }\n      out += ' } ';\n    }\n  }\n  if (it.schema.$ref && !$refKeywords) {\n    out += ' ' + (it.RULES.all.$ref.code(it, '$ref')) + ' ';\n    if ($breakOnError) {\n      out += ' } if (errors === ';\n      if ($top) {\n        out += '0';\n      } else {\n        out += 'errs_' + ($lvl);\n      }\n      out += ') { ';\n      $closingBraces2 += '}';\n    }\n  } else {\n    var arr2 = it.RULES;\n    if (arr2) {\n      var $rulesGroup, i2 = -1,\n        l2 = arr2.length - 1;\n      while (i2 < l2) {\n        $rulesGroup = arr2[i2 += 1];\n        if ($shouldUseGroup($rulesGroup)) {\n          if ($rulesGroup.type) {\n            out += ' if (' + (it.util.checkDataType($rulesGroup.type, $data)) + ') { ';\n          }\n          if (it.opts.useDefaults) {\n            if ($rulesGroup.type == 'object' && it.schema.properties) {\n              var $schema = it.schema.properties,\n                $schemaKeys = Object.keys($schema);\n              var arr3 = $schemaKeys;\n              if (arr3) {\n                var $propertyKey, i3 = -1,\n                  l3 = arr3.length - 1;\n                while (i3 < l3) {\n                  $propertyKey = arr3[i3 += 1];\n                  var $sch = $schema[$propertyKey];\n                  if ($sch.default !== undefined) {\n                    var $passData = $data + it.util.getProperty($propertyKey);\n                    if (it.compositeRule) {\n                      if (it.opts.strictDefaults) {\n                        var $defaultMsg = 'default is ignored for: ' + $passData;\n                        if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg);\n                        else throw new Error($defaultMsg);\n                      }\n                    } else {\n                      out += ' if (' + ($passData) + ' === undefined ';\n                      if (it.opts.useDefaults == 'empty') {\n                        out += ' || ' + ($passData) + ' === null || ' + ($passData) + ' === \\'\\' ';\n                      }\n                      out += ' ) ' + ($passData) + ' = ';\n                      if (it.opts.useDefaults == 'shared') {\n                        out += ' ' + (it.useDefault($sch.default)) + ' ';\n                      } else {\n                        out += ' ' + (JSON.stringify($sch.default)) + ' ';\n                      }\n                      out += '; ';\n                    }\n                  }\n                }\n              }\n            } else if ($rulesGroup.type == 'array' && Array.isArray(it.schema.items)) {\n              var arr4 = it.schema.items;\n              if (arr4) {\n                var $sch, $i = -1,\n                  l4 = arr4.length - 1;\n                while ($i < l4) {\n                  $sch = arr4[$i += 1];\n                  if ($sch.default !== undefined) {\n                    var $passData = $data + '[' + $i + ']';\n                    if (it.compositeRule) {\n                      if (it.opts.strictDefaults) {\n                        var $defaultMsg = 'default is ignored for: ' + $passData;\n                        if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg);\n                        else throw new Error($defaultMsg);\n                      }\n                    } else {\n                      out += ' if (' + ($passData) + ' === undefined ';\n                      if (it.opts.useDefaults == 'empty') {\n                        out += ' || ' + ($passData) + ' === null || ' + ($passData) + ' === \\'\\' ';\n                      }\n                      out += ' ) ' + ($passData) + ' = ';\n                      if (it.opts.useDefaults == 'shared') {\n                        out += ' ' + (it.useDefault($sch.default)) + ' ';\n                      } else {\n                        out += ' ' + (JSON.stringify($sch.default)) + ' ';\n                      }\n                      out += '; ';\n                    }\n                  }\n                }\n              }\n            }\n          }\n          var arr5 = $rulesGroup.rules;\n          if (arr5) {\n            var $rule, i5 = -1,\n              l5 = arr5.length - 1;\n            while (i5 < l5) {\n              $rule = arr5[i5 += 1];\n              if ($shouldUseRule($rule)) {\n                var $code = $rule.code(it, $rule.keyword, $rulesGroup.type);\n                if ($code) {\n                  out += ' ' + ($code) + ' ';\n                  if ($breakOnError) {\n                    $closingBraces1 += '}';\n                  }\n                }\n              }\n            }\n          }\n          if ($breakOnError) {\n            out += ' ' + ($closingBraces1) + ' ';\n            $closingBraces1 = '';\n          }\n          if ($rulesGroup.type) {\n            out += ' } ';\n            if ($typeSchema && $typeSchema === $rulesGroup.type && !$coerceToTypes) {\n              out += ' else { ';\n              var $schemaPath = it.schemaPath + '.type',\n                $errSchemaPath = it.errSchemaPath + '/type';\n              var $$outStack = $$outStack || [];\n              $$outStack.push(out);\n              out = ''; /* istanbul ignore else */\n              if (it.createErrors !== false) {\n                out += ' { keyword: \\'' + ($errorKeyword || 'type') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \\'';\n                if ($typeIsArray) {\n                  out += '' + ($typeSchema.join(\",\"));\n                } else {\n                  out += '' + ($typeSchema);\n                }\n                out += '\\' } ';\n                if (it.opts.messages !== false) {\n                  out += ' , message: \\'should be ';\n                  if ($typeIsArray) {\n                    out += '' + ($typeSchema.join(\",\"));\n                  } else {\n                    out += '' + ($typeSchema);\n                  }\n                  out += '\\' ';\n                }\n                if (it.opts.verbose) {\n                  out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n                }\n                out += ' } ';\n              } else {\n                out += ' {} ';\n              }\n              var __err = out;\n              out = $$outStack.pop();\n              if (!it.compositeRule && $breakOnError) {\n                /* istanbul ignore if */\n                if (it.async) {\n                  out += ' throw new ValidationError([' + (__err) + ']); ';\n                } else {\n                  out += ' validate.errors = [' + (__err) + ']; return false; ';\n                }\n              } else {\n                out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n              }\n              out += ' } ';\n            }\n          }\n          if ($breakOnError) {\n            out += ' if (errors === ';\n            if ($top) {\n              out += '0';\n            } else {\n              out += 'errs_' + ($lvl);\n            }\n            out += ') { ';\n            $closingBraces2 += '}';\n          }\n        }\n      }\n    }\n  }\n  if ($breakOnError) {\n    out += ' ' + ($closingBraces2) + ' ';\n  }\n  if ($top) {\n    if ($async) {\n      out += ' if (errors === 0) return data;           ';\n      out += ' else throw new ValidationError(vErrors); ';\n    } else {\n      out += ' validate.errors = vErrors; ';\n      out += ' return errors === 0;       ';\n    }\n    out += ' }; return validate;';\n  } else {\n    out += ' var ' + ($valid) + ' = errors === errs_' + ($lvl) + ';';\n  }\n  out = it.util.cleanUpCode(out);\n  if ($top) {\n    out = it.util.finalCleanUpCode(out, $async);\n  }\n\n  function $shouldUseGroup($rulesGroup) {\n    var rules = $rulesGroup.rules;\n    for (var i = 0; i < rules.length; i++)\n      if ($shouldUseRule(rules[i])) return true;\n  }\n\n  function $shouldUseRule($rule) {\n    return it.schema[$rule.keyword] !== undefined || ($rule.implements && $ruleImplementsSomeKeyword($rule));\n  }\n\n  function $ruleImplementsSomeKeyword($rule) {\n    var impl = $rule.implements;\n    for (var i = 0; i < impl.length; i++)\n      if (it.schema[impl[i]] !== undefined) return true;\n  }\n  return out;\n};\n\n/**\n * Functions below are used inside compiled validations function\n */\n\nvar ucs2length$1 = util$1.ucs2length;\n\n\n// this error is thrown by async schemas to return validation errors via exception\nvar ValidationError$1 = error_classes.Validation;\n\nvar compile_1 = compile;\n\n\n/**\n * Compiles schema to validation function\n * @this   Ajv\n * @param  {Object} schema schema object\n * @param  {Object} root object with information about the root schema for this schema\n * @param  {Object} localRefs the hash of local references inside the schema (created by resolve.id), used for inline resolution\n * @param  {String} baseId base ID for IDs in the schema\n * @return {Function} validation function\n */\nfunction compile(schema, root, localRefs, baseId) {\n  /* jshint validthis: true, evil: true */\n  /* eslint no-shadow: 0 */\n  var self = this\n    , opts = this._opts\n    , refVal = [ undefined ]\n    , refs = {}\n    , patterns = []\n    , patternsHash = {}\n    , defaults = []\n    , defaultsHash = {}\n    , customRules = [];\n\n  root = root || { schema: schema, refVal: refVal, refs: refs };\n\n  var c = checkCompiling.call(this, schema, root, baseId);\n  var compilation = this._compilations[c.index];\n  if (c.compiling) return (compilation.callValidate = callValidate);\n\n  var formats = this._formats;\n  var RULES = this.RULES;\n\n  try {\n    var v = localCompile(schema, root, localRefs, baseId);\n    compilation.validate = v;\n    var cv = compilation.callValidate;\n    if (cv) {\n      cv.schema = v.schema;\n      cv.errors = null;\n      cv.refs = v.refs;\n      cv.refVal = v.refVal;\n      cv.root = v.root;\n      cv.$async = v.$async;\n      if (opts.sourceCode) cv.source = v.source;\n    }\n    return v;\n  } finally {\n    endCompiling.call(this, schema, root, baseId);\n  }\n\n  /* @this   {*} - custom context, see passContext option */\n  function callValidate() {\n    /* jshint validthis: true */\n    var validate = compilation.validate;\n    var result = validate.apply(this, arguments);\n    callValidate.errors = validate.errors;\n    return result;\n  }\n\n  function localCompile(_schema, _root, localRefs, baseId) {\n    var isRoot = !_root || (_root && _root.schema == _schema);\n    if (_root.schema != root.schema)\n      return compile.call(self, _schema, _root, localRefs, baseId);\n\n    var $async = _schema.$async === true;\n\n    var sourceCode = validate({\n      isTop: true,\n      schema: _schema,\n      isRoot: isRoot,\n      baseId: baseId,\n      root: _root,\n      schemaPath: '',\n      errSchemaPath: '#',\n      errorPath: '\"\"',\n      MissingRefError: error_classes.MissingRef,\n      RULES: RULES,\n      validate: validate,\n      util: util$1,\n      resolve: resolve_1,\n      resolveRef: resolveRef,\n      usePattern: usePattern,\n      useDefault: useDefault,\n      useCustomRule: useCustomRule,\n      opts: opts,\n      formats: formats,\n      logger: self.logger,\n      self: self\n    });\n\n    sourceCode = vars(refVal, refValCode) + vars(patterns, patternCode)\n                   + vars(defaults, defaultCode) + vars(customRules, customRuleCode)\n                   + sourceCode;\n\n    if (opts.processCode) sourceCode = opts.processCode(sourceCode);\n    // console.log('\\n\\n\\n *** \\n', JSON.stringify(sourceCode));\n    var validate$1;\n    try {\n      var makeValidate = new Function(\n        'self',\n        'RULES',\n        'formats',\n        'root',\n        'refVal',\n        'defaults',\n        'customRules',\n        'equal',\n        'ucs2length',\n        'ValidationError',\n        sourceCode\n      );\n\n      validate$1 = makeValidate(\n        self,\n        RULES,\n        formats,\n        root,\n        refVal,\n        defaults,\n        customRules,\n        fastDeepEqual,\n        ucs2length$1,\n        ValidationError$1\n      );\n\n      refVal[0] = validate$1;\n    } catch(e) {\n      self.logger.error('Error compiling schema, function code:', sourceCode);\n      throw e;\n    }\n\n    validate$1.schema = _schema;\n    validate$1.errors = null;\n    validate$1.refs = refs;\n    validate$1.refVal = refVal;\n    validate$1.root = isRoot ? validate$1 : _root;\n    if ($async) validate$1.$async = true;\n    if (opts.sourceCode === true) {\n      validate$1.source = {\n        code: sourceCode,\n        patterns: patterns,\n        defaults: defaults\n      };\n    }\n\n    return validate$1;\n  }\n\n  function resolveRef(baseId, ref, isRoot) {\n    ref = resolve_1.url(baseId, ref);\n    var refIndex = refs[ref];\n    var _refVal, refCode;\n    if (refIndex !== undefined) {\n      _refVal = refVal[refIndex];\n      refCode = 'refVal[' + refIndex + ']';\n      return resolvedRef(_refVal, refCode);\n    }\n    if (!isRoot && root.refs) {\n      var rootRefId = root.refs[ref];\n      if (rootRefId !== undefined) {\n        _refVal = root.refVal[rootRefId];\n        refCode = addLocalRef(ref, _refVal);\n        return resolvedRef(_refVal, refCode);\n      }\n    }\n\n    refCode = addLocalRef(ref);\n    var v = resolve_1.call(self, localCompile, root, ref);\n    if (v === undefined) {\n      var localSchema = localRefs && localRefs[ref];\n      if (localSchema) {\n        v = resolve_1.inlineRef(localSchema, opts.inlineRefs)\n            ? localSchema\n            : compile.call(self, localSchema, root, localRefs, baseId);\n      }\n    }\n\n    if (v === undefined) {\n      removeLocalRef(ref);\n    } else {\n      replaceLocalRef(ref, v);\n      return resolvedRef(v, refCode);\n    }\n  }\n\n  function addLocalRef(ref, v) {\n    var refId = refVal.length;\n    refVal[refId] = v;\n    refs[ref] = refId;\n    return 'refVal' + refId;\n  }\n\n  function removeLocalRef(ref) {\n    delete refs[ref];\n  }\n\n  function replaceLocalRef(ref, v) {\n    var refId = refs[ref];\n    refVal[refId] = v;\n  }\n\n  function resolvedRef(refVal, code) {\n    return typeof refVal == 'object' || typeof refVal == 'boolean'\n            ? { code: code, schema: refVal, inline: true }\n            : { code: code, $async: refVal && !!refVal.$async };\n  }\n\n  function usePattern(regexStr) {\n    var index = patternsHash[regexStr];\n    if (index === undefined) {\n      index = patternsHash[regexStr] = patterns.length;\n      patterns[index] = regexStr;\n    }\n    return 'pattern' + index;\n  }\n\n  function useDefault(value) {\n    switch (typeof value) {\n      case 'boolean':\n      case 'number':\n        return '' + value;\n      case 'string':\n        return util$1.toQuotedString(value);\n      case 'object':\n        if (value === null) return 'null';\n        var valueStr = fastJsonStableStringify(value);\n        var index = defaultsHash[valueStr];\n        if (index === undefined) {\n          index = defaultsHash[valueStr] = defaults.length;\n          defaults[index] = value;\n        }\n        return 'default' + index;\n    }\n  }\n\n  function useCustomRule(rule, schema, parentSchema, it) {\n    if (self._opts.validateSchema !== false) {\n      var deps = rule.definition.dependencies;\n      if (deps && !deps.every(function(keyword) {\n        return Object.prototype.hasOwnProperty.call(parentSchema, keyword);\n      }))\n        throw new Error('parent schema must have all required keywords: ' + deps.join(','));\n\n      var validateSchema = rule.definition.validateSchema;\n      if (validateSchema) {\n        var valid = validateSchema(schema);\n        if (!valid) {\n          var message = 'keyword schema is invalid: ' + self.errorsText(validateSchema.errors);\n          if (self._opts.validateSchema == 'log') self.logger.error(message);\n          else throw new Error(message);\n        }\n      }\n    }\n\n    var compile = rule.definition.compile\n      , inline = rule.definition.inline\n      , macro = rule.definition.macro;\n\n    var validate;\n    if (compile) {\n      validate = compile.call(self, schema, parentSchema, it);\n    } else if (macro) {\n      validate = macro.call(self, schema, parentSchema, it);\n      if (opts.validateSchema !== false) self.validateSchema(validate, true);\n    } else if (inline) {\n      validate = inline.call(self, it, rule.keyword, schema, parentSchema);\n    } else {\n      validate = rule.definition.validate;\n      if (!validate) return;\n    }\n\n    if (validate === undefined)\n      throw new Error('custom keyword \"' + rule.keyword + '\"failed to compile');\n\n    var index = customRules.length;\n    customRules[index] = validate;\n\n    return {\n      code: 'customRule' + index,\n      validate: validate\n    };\n  }\n}\n\n\n/**\n * Checks if the schema is currently compiled\n * @this   Ajv\n * @param  {Object} schema schema to compile\n * @param  {Object} root root object\n * @param  {String} baseId base schema ID\n * @return {Object} object with properties \"index\" (compilation index) and \"compiling\" (boolean)\n */\nfunction checkCompiling(schema, root, baseId) {\n  /* jshint validthis: true */\n  var index = compIndex.call(this, schema, root, baseId);\n  if (index >= 0) return { index: index, compiling: true };\n  index = this._compilations.length;\n  this._compilations[index] = {\n    schema: schema,\n    root: root,\n    baseId: baseId\n  };\n  return { index: index, compiling: false };\n}\n\n\n/**\n * Removes the schema from the currently compiled list\n * @this   Ajv\n * @param  {Object} schema schema to compile\n * @param  {Object} root root object\n * @param  {String} baseId base schema ID\n */\nfunction endCompiling(schema, root, baseId) {\n  /* jshint validthis: true */\n  var i = compIndex.call(this, schema, root, baseId);\n  if (i >= 0) this._compilations.splice(i, 1);\n}\n\n\n/**\n * Index of schema compilation in the currently compiled list\n * @this   Ajv\n * @param  {Object} schema schema to compile\n * @param  {Object} root root object\n * @param  {String} baseId base schema ID\n * @return {Integer} compilation index\n */\nfunction compIndex(schema, root, baseId) {\n  /* jshint validthis: true */\n  for (var i=0; i<this._compilations.length; i++) {\n    var c = this._compilations[i];\n    if (c.schema == schema && c.root == root && c.baseId == baseId) return i;\n  }\n  return -1;\n}\n\n\nfunction patternCode(i, patterns) {\n  return 'var pattern' + i + ' = new RegExp(' + util$1.toQuotedString(patterns[i]) + ');';\n}\n\n\nfunction defaultCode(i) {\n  return 'var default' + i + ' = defaults[' + i + '];';\n}\n\n\nfunction refValCode(i, refVal) {\n  return refVal[i] === undefined ? '' : 'var refVal' + i + ' = refVal[' + i + '];';\n}\n\n\nfunction customRuleCode(i) {\n  return 'var customRule' + i + ' = customRules[' + i + '];';\n}\n\n\nfunction vars(arr, statement) {\n  if (!arr.length) return '';\n  var code = '';\n  for (var i=0; i<arr.length; i++)\n    code += statement(i, arr);\n  return code;\n}\n\nvar cache$1 = createCommonjsModule(function (module) {\n\n\nvar Cache = module.exports = function Cache() {\n  this._cache = {};\n};\n\n\nCache.prototype.put = function Cache_put(key, value) {\n  this._cache[key] = value;\n};\n\n\nCache.prototype.get = function Cache_get(key) {\n  return this._cache[key];\n};\n\n\nCache.prototype.del = function Cache_del(key) {\n  delete this._cache[key];\n};\n\n\nCache.prototype.clear = function Cache_clear() {\n  this._cache = {};\n};\n});\n\nvar DATE = /^(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)$/;\nvar DAYS = [0,31,28,31,30,31,30,31,31,30,31,30,31];\nvar TIME = /^(\\d\\d):(\\d\\d):(\\d\\d)(\\.\\d+)?(z|[+-]\\d\\d(?::?\\d\\d)?)?$/i;\nvar HOSTNAME = /^(?=.{1,253}\\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\\.?$/i;\nvar URI = /^(?:[a-z][a-z0-9+\\-.]*:)(?:\\/?\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)|(?:[a-z0-9\\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\\?(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;\nvar URIREF = /^(?:[a-z][a-z0-9+\\-.]*:)?(?:\\/?\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)|(?:[a-z0-9\\-._~!$&'\"()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\\?(?:[a-z0-9\\-._~!$&'\"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'\"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;\n// uri-template: https://tools.ietf.org/html/rfc6570\nvar URITEMPLATE = /^(?:(?:[^\\x00-\\x20\"'<>%\\\\^`{|}]|%[0-9a-f]{2})|\\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\\*)?)*\\})*$/i;\n// For the source: https://gist.github.com/dperini/729294\n// For test cases: https://mathiasbynens.be/demo/url-regex\n// @todo Delete current URL in favour of the commented out URL rule when this issue is fixed https://github.com/eslint/eslint/issues/7983.\n// var URL = /^(?:(?:https?|ftp):\\/\\/)(?:\\S+(?::\\S*)?@)?(?:(?!10(?:\\.\\d{1,3}){3})(?!127(?:\\.\\d{1,3}){3})(?!169\\.254(?:\\.\\d{1,3}){2})(?!192\\.168(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u{00a1}-\\u{ffff}0-9]+-?)*[a-z\\u{00a1}-\\u{ffff}0-9]+)(?:\\.(?:[a-z\\u{00a1}-\\u{ffff}0-9]+-?)*[a-z\\u{00a1}-\\u{ffff}0-9]+)*(?:\\.(?:[a-z\\u{00a1}-\\u{ffff}]{2,})))(?::\\d{2,5})?(?:\\/[^\\s]*)?$/iu;\nvar URL = /^(?:(?:http[s\\u017F]?|ftp):\\/\\/)(?:(?:[\\0-\\x08\\x0E-\\x1F!-\\x9F\\xA1-\\u167F\\u1681-\\u1FFF\\u200B-\\u2027\\u202A-\\u202E\\u2030-\\u205E\\u2060-\\u2FFF\\u3001-\\uD7FF\\uE000-\\uFEFE\\uFF00-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+(?::(?:[\\0-\\x08\\x0E-\\x1F!-\\x9F\\xA1-\\u167F\\u1681-\\u1FFF\\u200B-\\u2027\\u202A-\\u202E\\u2030-\\u205E\\u2060-\\u2FFF\\u3001-\\uD7FF\\uE000-\\uFEFE\\uFF00-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*)?@)?(?:(?!10(?:\\.[0-9]{1,3}){3})(?!127(?:\\.[0-9]{1,3}){3})(?!169\\.254(?:\\.[0-9]{1,3}){2})(?!192\\.168(?:\\.[0-9]{1,3}){2})(?!172\\.(?:1[6-9]|2[0-9]|3[01])(?:\\.[0-9]{1,3}){2})(?:[1-9][0-9]?|1[0-9][0-9]|2[01][0-9]|22[0-3])(?:\\.(?:1?[0-9]{1,2}|2[0-4][0-9]|25[0-5])){2}(?:\\.(?:[1-9][0-9]?|1[0-9][0-9]|2[0-4][0-9]|25[0-4]))|(?:(?:(?:[0-9KSa-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+-?)*(?:[0-9KSa-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+)(?:\\.(?:(?:[0-9KSa-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+-?)*(?:[0-9KSa-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+)*(?:\\.(?:(?:[KSa-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]){2,})))(?::[0-9]{2,5})?(?:\\/(?:[\\0-\\x08\\x0E-\\x1F!-\\x9F\\xA1-\\u167F\\u1681-\\u1FFF\\u200B-\\u2027\\u202A-\\u202E\\u2030-\\u205E\\u2060-\\u2FFF\\u3001-\\uD7FF\\uE000-\\uFEFE\\uFF00-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*)?$/i;\nvar UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;\nvar JSON_POINTER$1 = /^(?:\\/(?:[^~/]|~0|~1)*)*$/;\nvar JSON_POINTER_URI_FRAGMENT = /^#(?:\\/(?:[a-z0-9_\\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;\nvar RELATIVE_JSON_POINTER$1 = /^(?:0|[1-9][0-9]*)(?:#|(?:\\/(?:[^~/]|~0|~1)*)*)$/;\n\n\nvar formats_1 = formats;\n\nfunction formats(mode) {\n  mode = mode == 'full' ? 'full' : 'fast';\n  return util$1.copy(formats[mode]);\n}\n\n\nformats.fast = {\n  // date: http://tools.ietf.org/html/rfc3339#section-5.6\n  date: /^\\d\\d\\d\\d-[0-1]\\d-[0-3]\\d$/,\n  // date-time: http://tools.ietf.org/html/rfc3339#section-5.6\n  time: /^(?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)(?:\\.\\d+)?(?:z|[+-]\\d\\d(?::?\\d\\d)?)?$/i,\n  'date-time': /^\\d\\d\\d\\d-[0-1]\\d-[0-3]\\d[t\\s](?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)(?:\\.\\d+)?(?:z|[+-]\\d\\d(?::?\\d\\d)?)$/i,\n  // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js\n  uri: /^(?:[a-z][a-z0-9+-.]*:)(?:\\/?\\/)?[^\\s]*$/i,\n  'uri-reference': /^(?:(?:[a-z][a-z0-9+-.]*:)?\\/?\\/)?(?:[^\\\\\\s#][^\\s#]*)?(?:#[^\\\\\\s]*)?$/i,\n  'uri-template': URITEMPLATE,\n  url: URL,\n  // email (sources from jsen validator):\n  // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363\n  // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'willful violation')\n  email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i,\n  hostname: HOSTNAME,\n  // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html\n  ipv4: /^(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)$/,\n  // optimized http://stackoverflow.com/questions/53497/regular-expression-that-matches-valid-ipv6-addresses\n  ipv6: /^\\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(?:%.+)?\\s*$/i,\n  regex: regex$1,\n  // uuid: http://tools.ietf.org/html/rfc4122\n  uuid: UUID,\n  // JSON-pointer: https://tools.ietf.org/html/rfc6901\n  // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A\n  'json-pointer': JSON_POINTER$1,\n  'json-pointer-uri-fragment': JSON_POINTER_URI_FRAGMENT,\n  // relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00\n  'relative-json-pointer': RELATIVE_JSON_POINTER$1\n};\n\n\nformats.full = {\n  date: date,\n  time: time,\n  'date-time': date_time,\n  uri: uri,\n  'uri-reference': URIREF,\n  'uri-template': URITEMPLATE,\n  url: URL,\n  email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,\n  hostname: HOSTNAME,\n  ipv4: /^(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)$/,\n  ipv6: /^\\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(?:%.+)?\\s*$/i,\n  regex: regex$1,\n  uuid: UUID,\n  'json-pointer': JSON_POINTER$1,\n  'json-pointer-uri-fragment': JSON_POINTER_URI_FRAGMENT,\n  'relative-json-pointer': RELATIVE_JSON_POINTER$1\n};\n\n\nfunction isLeapYear(year) {\n  // https://tools.ietf.org/html/rfc3339#appendix-C\n  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);\n}\n\n\nfunction date(str) {\n  // full-date from http://tools.ietf.org/html/rfc3339#section-5.6\n  var matches = str.match(DATE);\n  if (!matches) return false;\n\n  var year = +matches[1];\n  var month = +matches[2];\n  var day = +matches[3];\n\n  return month >= 1 && month <= 12 && day >= 1 &&\n          day <= (month == 2 && isLeapYear(year) ? 29 : DAYS[month]);\n}\n\n\nfunction time(str, full) {\n  var matches = str.match(TIME);\n  if (!matches) return false;\n\n  var hour = matches[1];\n  var minute = matches[2];\n  var second = matches[3];\n  var timeZone = matches[5];\n  return ((hour <= 23 && minute <= 59 && second <= 59) ||\n          (hour == 23 && minute == 59 && second == 60)) &&\n         (!full || timeZone);\n}\n\n\nvar DATE_TIME_SEPARATOR = /t|\\s/i;\nfunction date_time(str) {\n  // http://tools.ietf.org/html/rfc3339#section-5.6\n  var dateTime = str.split(DATE_TIME_SEPARATOR);\n  return dateTime.length == 2 && date(dateTime[0]) && time(dateTime[1], true);\n}\n\n\nvar NOT_URI_FRAGMENT = /\\/|:/;\nfunction uri(str) {\n  // http://jmrware.com/articles/2009/uri_regexp/URI_regex.html + optional protocol + required \".\"\n  return NOT_URI_FRAGMENT.test(str) && URI.test(str);\n}\n\n\nvar Z_ANCHOR = /[^\\\\]\\\\Z/;\nfunction regex$1(str) {\n  if (Z_ANCHOR.test(str)) return false;\n  try {\n    new RegExp(str);\n    return true;\n  } catch(e) {\n    return false;\n  }\n}\n\nvar ref$1 = function generate_ref(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $async, $refCode;\n  if ($schema == '#' || $schema == '#/') {\n    if (it.isRoot) {\n      $async = it.async;\n      $refCode = 'validate';\n    } else {\n      $async = it.root.schema.$async === true;\n      $refCode = 'root.refVal[0]';\n    }\n  } else {\n    var $refVal = it.resolveRef(it.baseId, $schema, it.isRoot);\n    if ($refVal === undefined) {\n      var $message = it.MissingRefError.message(it.baseId, $schema);\n      if (it.opts.missingRefs == 'fail') {\n        it.logger.error($message);\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ('$ref') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { ref: \\'' + (it.util.escapeQuotes($schema)) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'can\\\\\\'t resolve reference ' + (it.util.escapeQuotes($schema)) + '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: ' + (it.util.toQuotedString($schema)) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n        if ($breakOnError) {\n          out += ' if (false) { ';\n        }\n      } else if (it.opts.missingRefs == 'ignore') {\n        it.logger.warn($message);\n        if ($breakOnError) {\n          out += ' if (true) { ';\n        }\n      } else {\n        throw new it.MissingRefError(it.baseId, $schema, $message);\n      }\n    } else if ($refVal.inline) {\n      var $it = it.util.copy(it);\n      $it.level++;\n      var $nextValid = 'valid' + $it.level;\n      $it.schema = $refVal.schema;\n      $it.schemaPath = '';\n      $it.errSchemaPath = $schema;\n      var $code = it.validate($it).replace(/validate\\.schema/g, $refVal.code);\n      out += ' ' + ($code) + ' ';\n      if ($breakOnError) {\n        out += ' if (' + ($nextValid) + ') { ';\n      }\n    } else {\n      $async = $refVal.$async === true || (it.async && $refVal.$async !== false);\n      $refCode = $refVal.code;\n    }\n  }\n  if ($refCode) {\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = '';\n    if (it.opts.passContext) {\n      out += ' ' + ($refCode) + '.call(this, ';\n    } else {\n      out += ' ' + ($refCode) + '( ';\n    }\n    out += ' ' + ($data) + ', (dataPath || \\'\\')';\n    if (it.errorPath != '\"\"') {\n      out += ' + ' + (it.errorPath);\n    }\n    var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData',\n      $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty';\n    out += ' , ' + ($parentData) + ' , ' + ($parentDataProperty) + ', rootData)  ';\n    var __callValidate = out;\n    out = $$outStack.pop();\n    if ($async) {\n      if (!it.async) throw new Error('async schema referenced by sync schema');\n      if ($breakOnError) {\n        out += ' var ' + ($valid) + '; ';\n      }\n      out += ' try { await ' + (__callValidate) + '; ';\n      if ($breakOnError) {\n        out += ' ' + ($valid) + ' = true; ';\n      }\n      out += ' } catch (e) { if (!(e instanceof ValidationError)) throw e; if (vErrors === null) vErrors = e.errors; else vErrors = vErrors.concat(e.errors); errors = vErrors.length; ';\n      if ($breakOnError) {\n        out += ' ' + ($valid) + ' = false; ';\n      }\n      out += ' } ';\n      if ($breakOnError) {\n        out += ' if (' + ($valid) + ') { ';\n      }\n    } else {\n      out += ' if (!' + (__callValidate) + ') { if (vErrors === null) vErrors = ' + ($refCode) + '.errors; else vErrors = vErrors.concat(' + ($refCode) + '.errors); errors = vErrors.length; } ';\n      if ($breakOnError) {\n        out += ' else { ';\n      }\n    }\n  }\n  return out;\n};\n\nvar allOf = function generate_allOf(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $currentBaseId = $it.baseId,\n    $allSchemasEmpty = true;\n  var arr1 = $schema;\n  if (arr1) {\n    var $sch, $i = -1,\n      l1 = arr1.length - 1;\n    while ($i < l1) {\n      $sch = arr1[$i += 1];\n      if ((it.opts.strictKeywords ? typeof $sch == 'object' && Object.keys($sch).length > 0 : it.util.schemaHasRules($sch, it.RULES.all))) {\n        $allSchemasEmpty = false;\n        $it.schema = $sch;\n        $it.schemaPath = $schemaPath + '[' + $i + ']';\n        $it.errSchemaPath = $errSchemaPath + '/' + $i;\n        out += '  ' + (it.validate($it)) + ' ';\n        $it.baseId = $currentBaseId;\n        if ($breakOnError) {\n          out += ' if (' + ($nextValid) + ') { ';\n          $closingBraces += '}';\n        }\n      }\n    }\n  }\n  if ($breakOnError) {\n    if ($allSchemasEmpty) {\n      out += ' if (true) { ';\n    } else {\n      out += ' ' + ($closingBraces.slice(0, -1)) + ' ';\n    }\n  }\n  out = it.util.cleanUpCode(out);\n  return out;\n};\n\nvar anyOf = function generate_anyOf(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $noEmptySchema = $schema.every(function($sch) {\n    return (it.opts.strictKeywords ? typeof $sch == 'object' && Object.keys($sch).length > 0 : it.util.schemaHasRules($sch, it.RULES.all));\n  });\n  if ($noEmptySchema) {\n    var $currentBaseId = $it.baseId;\n    out += ' var ' + ($errs) + ' = errors; var ' + ($valid) + ' = false;  ';\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    var arr1 = $schema;\n    if (arr1) {\n      var $sch, $i = -1,\n        l1 = arr1.length - 1;\n      while ($i < l1) {\n        $sch = arr1[$i += 1];\n        $it.schema = $sch;\n        $it.schemaPath = $schemaPath + '[' + $i + ']';\n        $it.errSchemaPath = $errSchemaPath + '/' + $i;\n        out += '  ' + (it.validate($it)) + ' ';\n        $it.baseId = $currentBaseId;\n        out += ' ' + ($valid) + ' = ' + ($valid) + ' || ' + ($nextValid) + '; if (!' + ($valid) + ') { ';\n        $closingBraces += '}';\n      }\n    }\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' ' + ($closingBraces) + ' if (!' + ($valid) + ') {   var err =   '; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('anyOf') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should match some schema in anyOf\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError(vErrors); ';\n      } else {\n        out += ' validate.errors = vErrors; return false; ';\n      }\n    }\n    out += ' } else {  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } ';\n    if (it.opts.allErrors) {\n      out += ' } ';\n    }\n    out = it.util.cleanUpCode(out);\n  } else {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n  }\n  return out;\n};\n\nvar comment = function generate_comment(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $schema = it.schema[$keyword];\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $comment = it.util.toQuotedString($schema);\n  if (it.opts.$comment === true) {\n    out += ' console.log(' + ($comment) + ');';\n  } else if (typeof it.opts.$comment == 'function') {\n    out += ' self._opts.$comment(' + ($comment) + ', ' + (it.util.toQuotedString($errSchemaPath)) + ', validate.root.schema);';\n  }\n  return out;\n};\n\nvar _const = function generate_const(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n  }\n  if (!$isData) {\n    out += ' var schema' + ($lvl) + ' = validate.schema' + ($schemaPath) + ';';\n  }\n  out += 'var ' + ($valid) + ' = equal(' + ($data) + ', schema' + ($lvl) + '); if (!' + ($valid) + ') {   ';\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('const') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { allowedValue: schema' + ($lvl) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should be equal to constant\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' }';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n};\n\nvar contains = function generate_contains(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $idx = 'i' + $lvl,\n    $dataNxt = $it.dataLevel = it.dataLevel + 1,\n    $nextData = 'data' + $dataNxt,\n    $currentBaseId = it.baseId,\n    $nonEmptySchema = (it.opts.strictKeywords ? typeof $schema == 'object' && Object.keys($schema).length > 0 : it.util.schemaHasRules($schema, it.RULES.all));\n  out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';';\n  if ($nonEmptySchema) {\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    out += ' var ' + ($nextValid) + ' = false; for (var ' + ($idx) + ' = 0; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { ';\n    $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true);\n    var $passData = $data + '[' + $idx + ']';\n    $it.dataPathArr[$dataNxt] = $idx;\n    var $code = it.validate($it);\n    $it.baseId = $currentBaseId;\n    if (it.util.varOccurences($code, $nextData) < 2) {\n      out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n    } else {\n      out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n    }\n    out += ' if (' + ($nextValid) + ') break; }  ';\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' ' + ($closingBraces) + ' if (!' + ($nextValid) + ') {';\n  } else {\n    out += ' if (' + ($data) + '.length == 0) {';\n  }\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('contains') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should contain a valid item\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' } else { ';\n  if ($nonEmptySchema) {\n    out += '  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } ';\n  }\n  if (it.opts.allErrors) {\n    out += ' } ';\n  }\n  out = it.util.cleanUpCode(out);\n  return out;\n};\n\nvar dependencies$5 = function generate_dependencies(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $schemaDeps = {},\n    $propertyDeps = {},\n    $ownProperties = it.opts.ownProperties;\n  for ($property in $schema) {\n    var $sch = $schema[$property];\n    var $deps = Array.isArray($sch) ? $propertyDeps : $schemaDeps;\n    $deps[$property] = $sch;\n  }\n  out += 'var ' + ($errs) + ' = errors;';\n  var $currentErrorPath = it.errorPath;\n  out += 'var missing' + ($lvl) + ';';\n  for (var $property in $propertyDeps) {\n    $deps = $propertyDeps[$property];\n    if ($deps.length) {\n      out += ' if ( ' + ($data) + (it.util.getProperty($property)) + ' !== undefined ';\n      if ($ownProperties) {\n        out += ' && Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($property)) + '\\') ';\n      }\n      if ($breakOnError) {\n        out += ' && ( ';\n        var arr1 = $deps;\n        if (arr1) {\n          var $propertyKey, $i = -1,\n            l1 = arr1.length - 1;\n          while ($i < l1) {\n            $propertyKey = arr1[$i += 1];\n            if ($i) {\n              out += ' || ';\n            }\n            var $prop = it.util.getProperty($propertyKey),\n              $useData = $data + $prop;\n            out += ' ( ( ' + ($useData) + ' === undefined ';\n            if ($ownProperties) {\n              out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n            }\n            out += ') && (missing' + ($lvl) + ' = ' + (it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop)) + ') ) ';\n          }\n        }\n        out += ')) {  ';\n        var $propertyPath = 'missing' + $lvl,\n          $missingProperty = '\\' + ' + $propertyPath + ' + \\'';\n        if (it.opts._errorDataPathProperty) {\n          it.errorPath = it.opts.jsonPointers ? it.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + ' + ' + $propertyPath;\n        }\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ('dependencies') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { property: \\'' + (it.util.escapeQuotes($property)) + '\\', missingProperty: \\'' + ($missingProperty) + '\\', depsCount: ' + ($deps.length) + ', deps: \\'' + (it.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(\", \"))) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'should have ';\n            if ($deps.length == 1) {\n              out += 'property ' + (it.util.escapeQuotes($deps[0]));\n            } else {\n              out += 'properties ' + (it.util.escapeQuotes($deps.join(\", \")));\n            }\n            out += ' when property ' + (it.util.escapeQuotes($property)) + ' is present\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n      } else {\n        out += ' ) { ';\n        var arr2 = $deps;\n        if (arr2) {\n          var $propertyKey, i2 = -1,\n            l2 = arr2.length - 1;\n          while (i2 < l2) {\n            $propertyKey = arr2[i2 += 1];\n            var $prop = it.util.getProperty($propertyKey),\n              $missingProperty = it.util.escapeQuotes($propertyKey),\n              $useData = $data + $prop;\n            if (it.opts._errorDataPathProperty) {\n              it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers);\n            }\n            out += ' if ( ' + ($useData) + ' === undefined ';\n            if ($ownProperties) {\n              out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n            }\n            out += ') {  var err =   '; /* istanbul ignore else */\n            if (it.createErrors !== false) {\n              out += ' { keyword: \\'' + ('dependencies') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { property: \\'' + (it.util.escapeQuotes($property)) + '\\', missingProperty: \\'' + ($missingProperty) + '\\', depsCount: ' + ($deps.length) + ', deps: \\'' + (it.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(\", \"))) + '\\' } ';\n              if (it.opts.messages !== false) {\n                out += ' , message: \\'should have ';\n                if ($deps.length == 1) {\n                  out += 'property ' + (it.util.escapeQuotes($deps[0]));\n                } else {\n                  out += 'properties ' + (it.util.escapeQuotes($deps.join(\", \")));\n                }\n                out += ' when property ' + (it.util.escapeQuotes($property)) + ' is present\\' ';\n              }\n              if (it.opts.verbose) {\n                out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n              }\n              out += ' } ';\n            } else {\n              out += ' {} ';\n            }\n            out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } ';\n          }\n        }\n      }\n      out += ' }   ';\n      if ($breakOnError) {\n        $closingBraces += '}';\n        out += ' else { ';\n      }\n    }\n  }\n  it.errorPath = $currentErrorPath;\n  var $currentBaseId = $it.baseId;\n  for (var $property in $schemaDeps) {\n    var $sch = $schemaDeps[$property];\n    if ((it.opts.strictKeywords ? typeof $sch == 'object' && Object.keys($sch).length > 0 : it.util.schemaHasRules($sch, it.RULES.all))) {\n      out += ' ' + ($nextValid) + ' = true; if ( ' + ($data) + (it.util.getProperty($property)) + ' !== undefined ';\n      if ($ownProperties) {\n        out += ' && Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($property)) + '\\') ';\n      }\n      out += ') { ';\n      $it.schema = $sch;\n      $it.schemaPath = $schemaPath + it.util.getProperty($property);\n      $it.errSchemaPath = $errSchemaPath + '/' + it.util.escapeFragment($property);\n      out += '  ' + (it.validate($it)) + ' ';\n      $it.baseId = $currentBaseId;\n      out += ' }  ';\n      if ($breakOnError) {\n        out += ' if (' + ($nextValid) + ') { ';\n        $closingBraces += '}';\n      }\n    }\n  }\n  if ($breakOnError) {\n    out += '   ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {';\n  }\n  out = it.util.cleanUpCode(out);\n  return out;\n};\n\nvar _enum = function generate_enum(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n  }\n  var $i = 'i' + $lvl,\n    $vSchema = 'schema' + $lvl;\n  if (!$isData) {\n    out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + ';';\n  }\n  out += 'var ' + ($valid) + ';';\n  if ($isData) {\n    out += ' if (schema' + ($lvl) + ' === undefined) ' + ($valid) + ' = true; else if (!Array.isArray(schema' + ($lvl) + ')) ' + ($valid) + ' = false; else {';\n  }\n  out += '' + ($valid) + ' = false;for (var ' + ($i) + '=0; ' + ($i) + '<' + ($vSchema) + '.length; ' + ($i) + '++) if (equal(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + '])) { ' + ($valid) + ' = true; break; }';\n  if ($isData) {\n    out += '  }  ';\n  }\n  out += ' if (!' + ($valid) + ') {   ';\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('enum') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { allowedValues: schema' + ($lvl) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should be equal to one of the allowed values\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' }';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n};\n\nvar format = function generate_format(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  if (it.opts.format === false) {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n    return out;\n  }\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $unknownFormats = it.opts.unknownFormats,\n    $allowUnknown = Array.isArray($unknownFormats);\n  if ($isData) {\n    var $format = 'format' + $lvl,\n      $isObject = 'isObject' + $lvl,\n      $formatType = 'formatType' + $lvl;\n    out += ' var ' + ($format) + ' = formats[' + ($schemaValue) + ']; var ' + ($isObject) + ' = typeof ' + ($format) + ' == \\'object\\' && !(' + ($format) + ' instanceof RegExp) && ' + ($format) + '.validate; var ' + ($formatType) + ' = ' + ($isObject) + ' && ' + ($format) + '.type || \\'string\\'; if (' + ($isObject) + ') { ';\n    if (it.async) {\n      out += ' var async' + ($lvl) + ' = ' + ($format) + '.async; ';\n    }\n    out += ' ' + ($format) + ' = ' + ($format) + '.validate; } if (  ';\n    if ($isData) {\n      out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'string\\') || ';\n    }\n    out += ' (';\n    if ($unknownFormats != 'ignore') {\n      out += ' (' + ($schemaValue) + ' && !' + ($format) + ' ';\n      if ($allowUnknown) {\n        out += ' && self._opts.unknownFormats.indexOf(' + ($schemaValue) + ') == -1 ';\n      }\n      out += ') || ';\n    }\n    out += ' (' + ($format) + ' && ' + ($formatType) + ' == \\'' + ($ruleType) + '\\' && !(typeof ' + ($format) + ' == \\'function\\' ? ';\n    if (it.async) {\n      out += ' (async' + ($lvl) + ' ? await ' + ($format) + '(' + ($data) + ') : ' + ($format) + '(' + ($data) + ')) ';\n    } else {\n      out += ' ' + ($format) + '(' + ($data) + ') ';\n    }\n    out += ' : ' + ($format) + '.test(' + ($data) + '))))) {';\n  } else {\n    var $format = it.formats[$schema];\n    if (!$format) {\n      if ($unknownFormats == 'ignore') {\n        it.logger.warn('unknown format \"' + $schema + '\" ignored in schema at path \"' + it.errSchemaPath + '\"');\n        if ($breakOnError) {\n          out += ' if (true) { ';\n        }\n        return out;\n      } else if ($allowUnknown && $unknownFormats.indexOf($schema) >= 0) {\n        if ($breakOnError) {\n          out += ' if (true) { ';\n        }\n        return out;\n      } else {\n        throw new Error('unknown format \"' + $schema + '\" is used in schema at path \"' + it.errSchemaPath + '\"');\n      }\n    }\n    var $isObject = typeof $format == 'object' && !($format instanceof RegExp) && $format.validate;\n    var $formatType = $isObject && $format.type || 'string';\n    if ($isObject) {\n      var $async = $format.async === true;\n      $format = $format.validate;\n    }\n    if ($formatType != $ruleType) {\n      if ($breakOnError) {\n        out += ' if (true) { ';\n      }\n      return out;\n    }\n    if ($async) {\n      if (!it.async) throw new Error('async format in sync schema');\n      var $formatRef = 'formats' + it.util.getProperty($schema) + '.validate';\n      out += ' if (!(await ' + ($formatRef) + '(' + ($data) + '))) { ';\n    } else {\n      out += ' if (! ';\n      var $formatRef = 'formats' + it.util.getProperty($schema);\n      if ($isObject) $formatRef += '.validate';\n      if (typeof $format == 'function') {\n        out += ' ' + ($formatRef) + '(' + ($data) + ') ';\n      } else {\n        out += ' ' + ($formatRef) + '.test(' + ($data) + ') ';\n      }\n      out += ') { ';\n    }\n  }\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('format') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { format:  ';\n    if ($isData) {\n      out += '' + ($schemaValue);\n    } else {\n      out += '' + (it.util.toQuotedString($schema));\n    }\n    out += '  } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should match format \"';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + (it.util.escapeQuotes($schema));\n      }\n      out += '\"\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + (it.util.toQuotedString($schema));\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' } ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n};\n\nvar _if = function generate_if(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $thenSch = it.schema['then'],\n    $elseSch = it.schema['else'],\n    $thenPresent = $thenSch !== undefined && (it.opts.strictKeywords ? typeof $thenSch == 'object' && Object.keys($thenSch).length > 0 : it.util.schemaHasRules($thenSch, it.RULES.all)),\n    $elsePresent = $elseSch !== undefined && (it.opts.strictKeywords ? typeof $elseSch == 'object' && Object.keys($elseSch).length > 0 : it.util.schemaHasRules($elseSch, it.RULES.all)),\n    $currentBaseId = $it.baseId;\n  if ($thenPresent || $elsePresent) {\n    var $ifClause;\n    $it.createErrors = false;\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    out += ' var ' + ($errs) + ' = errors; var ' + ($valid) + ' = true;  ';\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    out += '  ' + (it.validate($it)) + ' ';\n    $it.baseId = $currentBaseId;\n    $it.createErrors = true;\n    out += '  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; }  ';\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    if ($thenPresent) {\n      out += ' if (' + ($nextValid) + ') {  ';\n      $it.schema = it.schema['then'];\n      $it.schemaPath = it.schemaPath + '.then';\n      $it.errSchemaPath = it.errSchemaPath + '/then';\n      out += '  ' + (it.validate($it)) + ' ';\n      $it.baseId = $currentBaseId;\n      out += ' ' + ($valid) + ' = ' + ($nextValid) + '; ';\n      if ($thenPresent && $elsePresent) {\n        $ifClause = 'ifClause' + $lvl;\n        out += ' var ' + ($ifClause) + ' = \\'then\\'; ';\n      } else {\n        $ifClause = '\\'then\\'';\n      }\n      out += ' } ';\n      if ($elsePresent) {\n        out += ' else { ';\n      }\n    } else {\n      out += ' if (!' + ($nextValid) + ') { ';\n    }\n    if ($elsePresent) {\n      $it.schema = it.schema['else'];\n      $it.schemaPath = it.schemaPath + '.else';\n      $it.errSchemaPath = it.errSchemaPath + '/else';\n      out += '  ' + (it.validate($it)) + ' ';\n      $it.baseId = $currentBaseId;\n      out += ' ' + ($valid) + ' = ' + ($nextValid) + '; ';\n      if ($thenPresent && $elsePresent) {\n        $ifClause = 'ifClause' + $lvl;\n        out += ' var ' + ($ifClause) + ' = \\'else\\'; ';\n      } else {\n        $ifClause = '\\'else\\'';\n      }\n      out += ' } ';\n    }\n    out += ' if (!' + ($valid) + ') {   var err =   '; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('if') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { failingKeyword: ' + ($ifClause) + ' } ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should match \"\\' + ' + ($ifClause) + ' + \\'\" schema\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError(vErrors); ';\n      } else {\n        out += ' validate.errors = vErrors; return false; ';\n      }\n    }\n    out += ' }   ';\n    if ($breakOnError) {\n      out += ' else { ';\n    }\n    out = it.util.cleanUpCode(out);\n  } else {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n  }\n  return out;\n};\n\nvar items = function generate_items(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $idx = 'i' + $lvl,\n    $dataNxt = $it.dataLevel = it.dataLevel + 1,\n    $nextData = 'data' + $dataNxt,\n    $currentBaseId = it.baseId;\n  out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';';\n  if (Array.isArray($schema)) {\n    var $additionalItems = it.schema.additionalItems;\n    if ($additionalItems === false) {\n      out += ' ' + ($valid) + ' = ' + ($data) + '.length <= ' + ($schema.length) + '; ';\n      var $currErrSchemaPath = $errSchemaPath;\n      $errSchemaPath = it.errSchemaPath + '/additionalItems';\n      out += '  if (!' + ($valid) + ') {   ';\n      var $$outStack = $$outStack || [];\n      $$outStack.push(out);\n      out = ''; /* istanbul ignore else */\n      if (it.createErrors !== false) {\n        out += ' { keyword: \\'' + ('additionalItems') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schema.length) + ' } ';\n        if (it.opts.messages !== false) {\n          out += ' , message: \\'should NOT have more than ' + ($schema.length) + ' items\\' ';\n        }\n        if (it.opts.verbose) {\n          out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n        }\n        out += ' } ';\n      } else {\n        out += ' {} ';\n      }\n      var __err = out;\n      out = $$outStack.pop();\n      if (!it.compositeRule && $breakOnError) {\n        /* istanbul ignore if */\n        if (it.async) {\n          out += ' throw new ValidationError([' + (__err) + ']); ';\n        } else {\n          out += ' validate.errors = [' + (__err) + ']; return false; ';\n        }\n      } else {\n        out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n      }\n      out += ' } ';\n      $errSchemaPath = $currErrSchemaPath;\n      if ($breakOnError) {\n        $closingBraces += '}';\n        out += ' else { ';\n      }\n    }\n    var arr1 = $schema;\n    if (arr1) {\n      var $sch, $i = -1,\n        l1 = arr1.length - 1;\n      while ($i < l1) {\n        $sch = arr1[$i += 1];\n        if ((it.opts.strictKeywords ? typeof $sch == 'object' && Object.keys($sch).length > 0 : it.util.schemaHasRules($sch, it.RULES.all))) {\n          out += ' ' + ($nextValid) + ' = true; if (' + ($data) + '.length > ' + ($i) + ') { ';\n          var $passData = $data + '[' + $i + ']';\n          $it.schema = $sch;\n          $it.schemaPath = $schemaPath + '[' + $i + ']';\n          $it.errSchemaPath = $errSchemaPath + '/' + $i;\n          $it.errorPath = it.util.getPathExpr(it.errorPath, $i, it.opts.jsonPointers, true);\n          $it.dataPathArr[$dataNxt] = $i;\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n          } else {\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n          }\n          out += ' }  ';\n          if ($breakOnError) {\n            out += ' if (' + ($nextValid) + ') { ';\n            $closingBraces += '}';\n          }\n        }\n      }\n    }\n    if (typeof $additionalItems == 'object' && (it.opts.strictKeywords ? typeof $additionalItems == 'object' && Object.keys($additionalItems).length > 0 : it.util.schemaHasRules($additionalItems, it.RULES.all))) {\n      $it.schema = $additionalItems;\n      $it.schemaPath = it.schemaPath + '.additionalItems';\n      $it.errSchemaPath = it.errSchemaPath + '/additionalItems';\n      out += ' ' + ($nextValid) + ' = true; if (' + ($data) + '.length > ' + ($schema.length) + ') {  for (var ' + ($idx) + ' = ' + ($schema.length) + '; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { ';\n      $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true);\n      var $passData = $data + '[' + $idx + ']';\n      $it.dataPathArr[$dataNxt] = $idx;\n      var $code = it.validate($it);\n      $it.baseId = $currentBaseId;\n      if (it.util.varOccurences($code, $nextData) < 2) {\n        out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n      } else {\n        out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n      }\n      if ($breakOnError) {\n        out += ' if (!' + ($nextValid) + ') break; ';\n      }\n      out += ' } }  ';\n      if ($breakOnError) {\n        out += ' if (' + ($nextValid) + ') { ';\n        $closingBraces += '}';\n      }\n    }\n  } else if ((it.opts.strictKeywords ? typeof $schema == 'object' && Object.keys($schema).length > 0 : it.util.schemaHasRules($schema, it.RULES.all))) {\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    out += '  for (var ' + ($idx) + ' = ' + (0) + '; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { ';\n    $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true);\n    var $passData = $data + '[' + $idx + ']';\n    $it.dataPathArr[$dataNxt] = $idx;\n    var $code = it.validate($it);\n    $it.baseId = $currentBaseId;\n    if (it.util.varOccurences($code, $nextData) < 2) {\n      out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n    } else {\n      out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n    }\n    if ($breakOnError) {\n      out += ' if (!' + ($nextValid) + ') break; ';\n    }\n    out += ' }';\n  }\n  if ($breakOnError) {\n    out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {';\n  }\n  out = it.util.cleanUpCode(out);\n  return out;\n};\n\nvar _limit = function generate__limit(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $isMax = $keyword == 'maximum',\n    $exclusiveKeyword = $isMax ? 'exclusiveMaximum' : 'exclusiveMinimum',\n    $schemaExcl = it.schema[$exclusiveKeyword],\n    $isDataExcl = it.opts.$data && $schemaExcl && $schemaExcl.$data,\n    $op = $isMax ? '<' : '>',\n    $notOp = $isMax ? '>' : '<',\n    $errorKeyword = undefined;\n  if ($isDataExcl) {\n    var $schemaValueExcl = it.util.getData($schemaExcl.$data, $dataLvl, it.dataPathArr),\n      $exclusive = 'exclusive' + $lvl,\n      $exclType = 'exclType' + $lvl,\n      $exclIsNumber = 'exclIsNumber' + $lvl,\n      $opExpr = 'op' + $lvl,\n      $opStr = '\\' + ' + $opExpr + ' + \\'';\n    out += ' var schemaExcl' + ($lvl) + ' = ' + ($schemaValueExcl) + '; ';\n    $schemaValueExcl = 'schemaExcl' + $lvl;\n    out += ' var ' + ($exclusive) + '; var ' + ($exclType) + ' = typeof ' + ($schemaValueExcl) + '; if (' + ($exclType) + ' != \\'boolean\\' && ' + ($exclType) + ' != \\'undefined\\' && ' + ($exclType) + ' != \\'number\\') { ';\n    var $errorKeyword = $exclusiveKeyword;\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = ''; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ($errorKeyword || '_exclusiveLimit') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'' + ($exclusiveKeyword) + ' should be boolean\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    var __err = out;\n    out = $$outStack.pop();\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError([' + (__err) + ']); ';\n      } else {\n        out += ' validate.errors = [' + (__err) + ']; return false; ';\n      }\n    } else {\n      out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    }\n    out += ' } else if ( ';\n    if ($isData) {\n      out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n    }\n    out += ' ' + ($exclType) + ' == \\'number\\' ? ( (' + ($exclusive) + ' = ' + ($schemaValue) + ' === undefined || ' + ($schemaValueExcl) + ' ' + ($op) + '= ' + ($schemaValue) + ') ? ' + ($data) + ' ' + ($notOp) + '= ' + ($schemaValueExcl) + ' : ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' ) : ( (' + ($exclusive) + ' = ' + ($schemaValueExcl) + ' === true) ? ' + ($data) + ' ' + ($notOp) + '= ' + ($schemaValue) + ' : ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' ) || ' + ($data) + ' !== ' + ($data) + ') { var op' + ($lvl) + ' = ' + ($exclusive) + ' ? \\'' + ($op) + '\\' : \\'' + ($op) + '=\\'; ';\n    if ($schema === undefined) {\n      $errorKeyword = $exclusiveKeyword;\n      $errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword;\n      $schemaValue = $schemaValueExcl;\n      $isData = $isDataExcl;\n    }\n  } else {\n    var $exclIsNumber = typeof $schemaExcl == 'number',\n      $opStr = $op;\n    if ($exclIsNumber && $isData) {\n      var $opExpr = '\\'' + $opStr + '\\'';\n      out += ' if ( ';\n      if ($isData) {\n        out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n      }\n      out += ' ( ' + ($schemaValue) + ' === undefined || ' + ($schemaExcl) + ' ' + ($op) + '= ' + ($schemaValue) + ' ? ' + ($data) + ' ' + ($notOp) + '= ' + ($schemaExcl) + ' : ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' ) || ' + ($data) + ' !== ' + ($data) + ') { ';\n    } else {\n      if ($exclIsNumber && $schema === undefined) {\n        $exclusive = true;\n        $errorKeyword = $exclusiveKeyword;\n        $errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword;\n        $schemaValue = $schemaExcl;\n        $notOp += '=';\n      } else {\n        if ($exclIsNumber) $schemaValue = Math[$isMax ? 'min' : 'max']($schemaExcl, $schema);\n        if ($schemaExcl === ($exclIsNumber ? $schemaValue : true)) {\n          $exclusive = true;\n          $errorKeyword = $exclusiveKeyword;\n          $errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword;\n          $notOp += '=';\n        } else {\n          $exclusive = false;\n          $opStr += '=';\n        }\n      }\n      var $opExpr = '\\'' + $opStr + '\\'';\n      out += ' if ( ';\n      if ($isData) {\n        out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n      }\n      out += ' ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' || ' + ($data) + ' !== ' + ($data) + ') { ';\n    }\n  }\n  $errorKeyword = $errorKeyword || $keyword;\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ($errorKeyword || '_limit') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { comparison: ' + ($opExpr) + ', limit: ' + ($schemaValue) + ', exclusive: ' + ($exclusive) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should be ' + ($opStr) + ' ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue);\n      } else {\n        out += '' + ($schemaValue) + '\\'';\n      }\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' } ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n};\n\nvar _limitItems = function generate__limitItems(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $op = $keyword == 'maxItems' ? '>' : '<';\n  out += 'if ( ';\n  if ($isData) {\n    out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n  }\n  out += ' ' + ($data) + '.length ' + ($op) + ' ' + ($schemaValue) + ') { ';\n  var $errorKeyword = $keyword;\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ($errorKeyword || '_limitItems') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should NOT have ';\n      if ($keyword == 'maxItems') {\n        out += 'more';\n      } else {\n        out += 'fewer';\n      }\n      out += ' than ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + ($schema);\n      }\n      out += ' items\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n};\n\nvar _limitLength = function generate__limitLength(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $op = $keyword == 'maxLength' ? '>' : '<';\n  out += 'if ( ';\n  if ($isData) {\n    out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n  }\n  if (it.opts.unicode === false) {\n    out += ' ' + ($data) + '.length ';\n  } else {\n    out += ' ucs2length(' + ($data) + ') ';\n  }\n  out += ' ' + ($op) + ' ' + ($schemaValue) + ') { ';\n  var $errorKeyword = $keyword;\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ($errorKeyword || '_limitLength') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should NOT be ';\n      if ($keyword == 'maxLength') {\n        out += 'longer';\n      } else {\n        out += 'shorter';\n      }\n      out += ' than ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + ($schema);\n      }\n      out += ' characters\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n};\n\nvar _limitProperties = function generate__limitProperties(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $op = $keyword == 'maxProperties' ? '>' : '<';\n  out += 'if ( ';\n  if ($isData) {\n    out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n  }\n  out += ' Object.keys(' + ($data) + ').length ' + ($op) + ' ' + ($schemaValue) + ') { ';\n  var $errorKeyword = $keyword;\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ($errorKeyword || '_limitProperties') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should NOT have ';\n      if ($keyword == 'maxProperties') {\n        out += 'more';\n      } else {\n        out += 'fewer';\n      }\n      out += ' than ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + ($schema);\n      }\n      out += ' properties\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n};\n\nvar multipleOf = function generate_multipleOf(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  out += 'var division' + ($lvl) + ';if (';\n  if ($isData) {\n    out += ' ' + ($schemaValue) + ' !== undefined && ( typeof ' + ($schemaValue) + ' != \\'number\\' || ';\n  }\n  out += ' (division' + ($lvl) + ' = ' + ($data) + ' / ' + ($schemaValue) + ', ';\n  if (it.opts.multipleOfPrecision) {\n    out += ' Math.abs(Math.round(division' + ($lvl) + ') - division' + ($lvl) + ') > 1e-' + (it.opts.multipleOfPrecision) + ' ';\n  } else {\n    out += ' division' + ($lvl) + ' !== parseInt(division' + ($lvl) + ') ';\n  }\n  out += ' ) ';\n  if ($isData) {\n    out += '  )  ';\n  }\n  out += ' ) {   ';\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('multipleOf') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { multipleOf: ' + ($schemaValue) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should be multiple of ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue);\n      } else {\n        out += '' + ($schemaValue) + '\\'';\n      }\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n};\n\nvar not = function generate_not(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  if ((it.opts.strictKeywords ? typeof $schema == 'object' && Object.keys($schema).length > 0 : it.util.schemaHasRules($schema, it.RULES.all))) {\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    out += ' var ' + ($errs) + ' = errors;  ';\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    $it.createErrors = false;\n    var $allErrorsOption;\n    if ($it.opts.allErrors) {\n      $allErrorsOption = $it.opts.allErrors;\n      $it.opts.allErrors = false;\n    }\n    out += ' ' + (it.validate($it)) + ' ';\n    $it.createErrors = true;\n    if ($allErrorsOption) $it.opts.allErrors = $allErrorsOption;\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' if (' + ($nextValid) + ') {   ';\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = ''; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('not') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should NOT be valid\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    var __err = out;\n    out = $$outStack.pop();\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError([' + (__err) + ']); ';\n      } else {\n        out += ' validate.errors = [' + (__err) + ']; return false; ';\n      }\n    } else {\n      out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    }\n    out += ' } else {  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } ';\n    if (it.opts.allErrors) {\n      out += ' } ';\n    }\n  } else {\n    out += '  var err =   '; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('not') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should NOT be valid\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    if ($breakOnError) {\n      out += ' if (false) { ';\n    }\n  }\n  return out;\n};\n\nvar oneOf = function generate_oneOf(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $currentBaseId = $it.baseId,\n    $prevValid = 'prevValid' + $lvl,\n    $passingSchemas = 'passingSchemas' + $lvl;\n  out += 'var ' + ($errs) + ' = errors , ' + ($prevValid) + ' = false , ' + ($valid) + ' = false , ' + ($passingSchemas) + ' = null; ';\n  var $wasComposite = it.compositeRule;\n  it.compositeRule = $it.compositeRule = true;\n  var arr1 = $schema;\n  if (arr1) {\n    var $sch, $i = -1,\n      l1 = arr1.length - 1;\n    while ($i < l1) {\n      $sch = arr1[$i += 1];\n      if ((it.opts.strictKeywords ? typeof $sch == 'object' && Object.keys($sch).length > 0 : it.util.schemaHasRules($sch, it.RULES.all))) {\n        $it.schema = $sch;\n        $it.schemaPath = $schemaPath + '[' + $i + ']';\n        $it.errSchemaPath = $errSchemaPath + '/' + $i;\n        out += '  ' + (it.validate($it)) + ' ';\n        $it.baseId = $currentBaseId;\n      } else {\n        out += ' var ' + ($nextValid) + ' = true; ';\n      }\n      if ($i) {\n        out += ' if (' + ($nextValid) + ' && ' + ($prevValid) + ') { ' + ($valid) + ' = false; ' + ($passingSchemas) + ' = [' + ($passingSchemas) + ', ' + ($i) + ']; } else { ';\n        $closingBraces += '}';\n      }\n      out += ' if (' + ($nextValid) + ') { ' + ($valid) + ' = ' + ($prevValid) + ' = true; ' + ($passingSchemas) + ' = ' + ($i) + '; }';\n    }\n  }\n  it.compositeRule = $it.compositeRule = $wasComposite;\n  out += '' + ($closingBraces) + 'if (!' + ($valid) + ') {   var err =   '; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('oneOf') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { passingSchemas: ' + ($passingSchemas) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should match exactly one schema in oneOf\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError(vErrors); ';\n    } else {\n      out += ' validate.errors = vErrors; return false; ';\n    }\n  }\n  out += '} else {  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; }';\n  if (it.opts.allErrors) {\n    out += ' } ';\n  }\n  return out;\n};\n\nvar pattern = function generate_pattern(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $regexp = $isData ? '(new RegExp(' + $schemaValue + '))' : it.usePattern($schema);\n  out += 'if ( ';\n  if ($isData) {\n    out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'string\\') || ';\n  }\n  out += ' !' + ($regexp) + '.test(' + ($data) + ') ) {   ';\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('pattern') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { pattern:  ';\n    if ($isData) {\n      out += '' + ($schemaValue);\n    } else {\n      out += '' + (it.util.toQuotedString($schema));\n    }\n    out += '  } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should match pattern \"';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + (it.util.escapeQuotes($schema));\n      }\n      out += '\"\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + (it.util.toQuotedString($schema));\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n};\n\nvar properties = function generate_properties(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $key = 'key' + $lvl,\n    $idx = 'idx' + $lvl,\n    $dataNxt = $it.dataLevel = it.dataLevel + 1,\n    $nextData = 'data' + $dataNxt,\n    $dataProperties = 'dataProperties' + $lvl;\n  var $schemaKeys = Object.keys($schema || {}),\n    $pProperties = it.schema.patternProperties || {},\n    $pPropertyKeys = Object.keys($pProperties),\n    $aProperties = it.schema.additionalProperties,\n    $someProperties = $schemaKeys.length || $pPropertyKeys.length,\n    $noAdditional = $aProperties === false,\n    $additionalIsSchema = typeof $aProperties == 'object' && Object.keys($aProperties).length,\n    $removeAdditional = it.opts.removeAdditional,\n    $checkAdditional = $noAdditional || $additionalIsSchema || $removeAdditional,\n    $ownProperties = it.opts.ownProperties,\n    $currentBaseId = it.baseId;\n  var $required = it.schema.required;\n  if ($required && !(it.opts.$data && $required.$data) && $required.length < it.opts.loopRequired) var $requiredHash = it.util.toHash($required);\n  out += 'var ' + ($errs) + ' = errors;var ' + ($nextValid) + ' = true;';\n  if ($ownProperties) {\n    out += ' var ' + ($dataProperties) + ' = undefined;';\n  }\n  if ($checkAdditional) {\n    if ($ownProperties) {\n      out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; ';\n    } else {\n      out += ' for (var ' + ($key) + ' in ' + ($data) + ') { ';\n    }\n    if ($someProperties) {\n      out += ' var isAdditional' + ($lvl) + ' = !(false ';\n      if ($schemaKeys.length) {\n        if ($schemaKeys.length > 8) {\n          out += ' || validate.schema' + ($schemaPath) + '.hasOwnProperty(' + ($key) + ') ';\n        } else {\n          var arr1 = $schemaKeys;\n          if (arr1) {\n            var $propertyKey, i1 = -1,\n              l1 = arr1.length - 1;\n            while (i1 < l1) {\n              $propertyKey = arr1[i1 += 1];\n              out += ' || ' + ($key) + ' == ' + (it.util.toQuotedString($propertyKey)) + ' ';\n            }\n          }\n        }\n      }\n      if ($pPropertyKeys.length) {\n        var arr2 = $pPropertyKeys;\n        if (arr2) {\n          var $pProperty, $i = -1,\n            l2 = arr2.length - 1;\n          while ($i < l2) {\n            $pProperty = arr2[$i += 1];\n            out += ' || ' + (it.usePattern($pProperty)) + '.test(' + ($key) + ') ';\n          }\n        }\n      }\n      out += ' ); if (isAdditional' + ($lvl) + ') { ';\n    }\n    if ($removeAdditional == 'all') {\n      out += ' delete ' + ($data) + '[' + ($key) + ']; ';\n    } else {\n      var $currentErrorPath = it.errorPath;\n      var $additionalProperty = '\\' + ' + $key + ' + \\'';\n      if (it.opts._errorDataPathProperty) {\n        it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);\n      }\n      if ($noAdditional) {\n        if ($removeAdditional) {\n          out += ' delete ' + ($data) + '[' + ($key) + ']; ';\n        } else {\n          out += ' ' + ($nextValid) + ' = false; ';\n          var $currErrSchemaPath = $errSchemaPath;\n          $errSchemaPath = it.errSchemaPath + '/additionalProperties';\n          var $$outStack = $$outStack || [];\n          $$outStack.push(out);\n          out = ''; /* istanbul ignore else */\n          if (it.createErrors !== false) {\n            out += ' { keyword: \\'' + ('additionalProperties') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { additionalProperty: \\'' + ($additionalProperty) + '\\' } ';\n            if (it.opts.messages !== false) {\n              out += ' , message: \\'';\n              if (it.opts._errorDataPathProperty) {\n                out += 'is an invalid additional property';\n              } else {\n                out += 'should NOT have additional properties';\n              }\n              out += '\\' ';\n            }\n            if (it.opts.verbose) {\n              out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n            }\n            out += ' } ';\n          } else {\n            out += ' {} ';\n          }\n          var __err = out;\n          out = $$outStack.pop();\n          if (!it.compositeRule && $breakOnError) {\n            /* istanbul ignore if */\n            if (it.async) {\n              out += ' throw new ValidationError([' + (__err) + ']); ';\n            } else {\n              out += ' validate.errors = [' + (__err) + ']; return false; ';\n            }\n          } else {\n            out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n          }\n          $errSchemaPath = $currErrSchemaPath;\n          if ($breakOnError) {\n            out += ' break; ';\n          }\n        }\n      } else if ($additionalIsSchema) {\n        if ($removeAdditional == 'failing') {\n          out += ' var ' + ($errs) + ' = errors;  ';\n          var $wasComposite = it.compositeRule;\n          it.compositeRule = $it.compositeRule = true;\n          $it.schema = $aProperties;\n          $it.schemaPath = it.schemaPath + '.additionalProperties';\n          $it.errSchemaPath = it.errSchemaPath + '/additionalProperties';\n          $it.errorPath = it.opts._errorDataPathProperty ? it.errorPath : it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);\n          var $passData = $data + '[' + $key + ']';\n          $it.dataPathArr[$dataNxt] = $key;\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n          } else {\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n          }\n          out += ' if (!' + ($nextValid) + ') { errors = ' + ($errs) + '; if (validate.errors !== null) { if (errors) validate.errors.length = errors; else validate.errors = null; } delete ' + ($data) + '[' + ($key) + ']; }  ';\n          it.compositeRule = $it.compositeRule = $wasComposite;\n        } else {\n          $it.schema = $aProperties;\n          $it.schemaPath = it.schemaPath + '.additionalProperties';\n          $it.errSchemaPath = it.errSchemaPath + '/additionalProperties';\n          $it.errorPath = it.opts._errorDataPathProperty ? it.errorPath : it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);\n          var $passData = $data + '[' + $key + ']';\n          $it.dataPathArr[$dataNxt] = $key;\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n          } else {\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n          }\n          if ($breakOnError) {\n            out += ' if (!' + ($nextValid) + ') break; ';\n          }\n        }\n      }\n      it.errorPath = $currentErrorPath;\n    }\n    if ($someProperties) {\n      out += ' } ';\n    }\n    out += ' }  ';\n    if ($breakOnError) {\n      out += ' if (' + ($nextValid) + ') { ';\n      $closingBraces += '}';\n    }\n  }\n  var $useDefaults = it.opts.useDefaults && !it.compositeRule;\n  if ($schemaKeys.length) {\n    var arr3 = $schemaKeys;\n    if (arr3) {\n      var $propertyKey, i3 = -1,\n        l3 = arr3.length - 1;\n      while (i3 < l3) {\n        $propertyKey = arr3[i3 += 1];\n        var $sch = $schema[$propertyKey];\n        if ((it.opts.strictKeywords ? typeof $sch == 'object' && Object.keys($sch).length > 0 : it.util.schemaHasRules($sch, it.RULES.all))) {\n          var $prop = it.util.getProperty($propertyKey),\n            $passData = $data + $prop,\n            $hasDefault = $useDefaults && $sch.default !== undefined;\n          $it.schema = $sch;\n          $it.schemaPath = $schemaPath + $prop;\n          $it.errSchemaPath = $errSchemaPath + '/' + it.util.escapeFragment($propertyKey);\n          $it.errorPath = it.util.getPath(it.errorPath, $propertyKey, it.opts.jsonPointers);\n          $it.dataPathArr[$dataNxt] = it.util.toQuotedString($propertyKey);\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            $code = it.util.varReplace($code, $nextData, $passData);\n            var $useData = $passData;\n          } else {\n            var $useData = $nextData;\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ';\n          }\n          if ($hasDefault) {\n            out += ' ' + ($code) + ' ';\n          } else {\n            if ($requiredHash && $requiredHash[$propertyKey]) {\n              out += ' if ( ' + ($useData) + ' === undefined ';\n              if ($ownProperties) {\n                out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n              }\n              out += ') { ' + ($nextValid) + ' = false; ';\n              var $currentErrorPath = it.errorPath,\n                $currErrSchemaPath = $errSchemaPath,\n                $missingProperty = it.util.escapeQuotes($propertyKey);\n              if (it.opts._errorDataPathProperty) {\n                it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers);\n              }\n              $errSchemaPath = it.errSchemaPath + '/required';\n              var $$outStack = $$outStack || [];\n              $$outStack.push(out);\n              out = ''; /* istanbul ignore else */\n              if (it.createErrors !== false) {\n                out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n                if (it.opts.messages !== false) {\n                  out += ' , message: \\'';\n                  if (it.opts._errorDataPathProperty) {\n                    out += 'is a required property';\n                  } else {\n                    out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n                  }\n                  out += '\\' ';\n                }\n                if (it.opts.verbose) {\n                  out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n                }\n                out += ' } ';\n              } else {\n                out += ' {} ';\n              }\n              var __err = out;\n              out = $$outStack.pop();\n              if (!it.compositeRule && $breakOnError) {\n                /* istanbul ignore if */\n                if (it.async) {\n                  out += ' throw new ValidationError([' + (__err) + ']); ';\n                } else {\n                  out += ' validate.errors = [' + (__err) + ']; return false; ';\n                }\n              } else {\n                out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n              }\n              $errSchemaPath = $currErrSchemaPath;\n              it.errorPath = $currentErrorPath;\n              out += ' } else { ';\n            } else {\n              if ($breakOnError) {\n                out += ' if ( ' + ($useData) + ' === undefined ';\n                if ($ownProperties) {\n                  out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n                }\n                out += ') { ' + ($nextValid) + ' = true; } else { ';\n              } else {\n                out += ' if (' + ($useData) + ' !== undefined ';\n                if ($ownProperties) {\n                  out += ' &&   Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n                }\n                out += ' ) { ';\n              }\n            }\n            out += ' ' + ($code) + ' } ';\n          }\n        }\n        if ($breakOnError) {\n          out += ' if (' + ($nextValid) + ') { ';\n          $closingBraces += '}';\n        }\n      }\n    }\n  }\n  if ($pPropertyKeys.length) {\n    var arr4 = $pPropertyKeys;\n    if (arr4) {\n      var $pProperty, i4 = -1,\n        l4 = arr4.length - 1;\n      while (i4 < l4) {\n        $pProperty = arr4[i4 += 1];\n        var $sch = $pProperties[$pProperty];\n        if ((it.opts.strictKeywords ? typeof $sch == 'object' && Object.keys($sch).length > 0 : it.util.schemaHasRules($sch, it.RULES.all))) {\n          $it.schema = $sch;\n          $it.schemaPath = it.schemaPath + '.patternProperties' + it.util.getProperty($pProperty);\n          $it.errSchemaPath = it.errSchemaPath + '/patternProperties/' + it.util.escapeFragment($pProperty);\n          if ($ownProperties) {\n            out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; ';\n          } else {\n            out += ' for (var ' + ($key) + ' in ' + ($data) + ') { ';\n          }\n          out += ' if (' + (it.usePattern($pProperty)) + '.test(' + ($key) + ')) { ';\n          $it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);\n          var $passData = $data + '[' + $key + ']';\n          $it.dataPathArr[$dataNxt] = $key;\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n          } else {\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n          }\n          if ($breakOnError) {\n            out += ' if (!' + ($nextValid) + ') break; ';\n          }\n          out += ' } ';\n          if ($breakOnError) {\n            out += ' else ' + ($nextValid) + ' = true; ';\n          }\n          out += ' }  ';\n          if ($breakOnError) {\n            out += ' if (' + ($nextValid) + ') { ';\n            $closingBraces += '}';\n          }\n        }\n      }\n    }\n  }\n  if ($breakOnError) {\n    out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {';\n  }\n  out = it.util.cleanUpCode(out);\n  return out;\n};\n\nvar propertyNames = function generate_propertyNames(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  out += 'var ' + ($errs) + ' = errors;';\n  if ((it.opts.strictKeywords ? typeof $schema == 'object' && Object.keys($schema).length > 0 : it.util.schemaHasRules($schema, it.RULES.all))) {\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    var $key = 'key' + $lvl,\n      $idx = 'idx' + $lvl,\n      $i = 'i' + $lvl,\n      $invalidName = '\\' + ' + $key + ' + \\'',\n      $dataNxt = $it.dataLevel = it.dataLevel + 1,\n      $nextData = 'data' + $dataNxt,\n      $dataProperties = 'dataProperties' + $lvl,\n      $ownProperties = it.opts.ownProperties,\n      $currentBaseId = it.baseId;\n    if ($ownProperties) {\n      out += ' var ' + ($dataProperties) + ' = undefined; ';\n    }\n    if ($ownProperties) {\n      out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; ';\n    } else {\n      out += ' for (var ' + ($key) + ' in ' + ($data) + ') { ';\n    }\n    out += ' var startErrs' + ($lvl) + ' = errors; ';\n    var $passData = $key;\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    var $code = it.validate($it);\n    $it.baseId = $currentBaseId;\n    if (it.util.varOccurences($code, $nextData) < 2) {\n      out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n    } else {\n      out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n    }\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' if (!' + ($nextValid) + ') { for (var ' + ($i) + '=startErrs' + ($lvl) + '; ' + ($i) + '<errors; ' + ($i) + '++) { vErrors[' + ($i) + '].propertyName = ' + ($key) + '; }   var err =   '; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('propertyNames') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { propertyName: \\'' + ($invalidName) + '\\' } ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'property name \\\\\\'' + ($invalidName) + '\\\\\\' is invalid\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError(vErrors); ';\n      } else {\n        out += ' validate.errors = vErrors; return false; ';\n      }\n    }\n    if ($breakOnError) {\n      out += ' break; ';\n    }\n    out += ' } }';\n  }\n  if ($breakOnError) {\n    out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {';\n  }\n  out = it.util.cleanUpCode(out);\n  return out;\n};\n\nvar required = function generate_required(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n  }\n  var $vSchema = 'schema' + $lvl;\n  if (!$isData) {\n    if ($schema.length < it.opts.loopRequired && it.schema.properties && Object.keys(it.schema.properties).length) {\n      var $required = [];\n      var arr1 = $schema;\n      if (arr1) {\n        var $property, i1 = -1,\n          l1 = arr1.length - 1;\n        while (i1 < l1) {\n          $property = arr1[i1 += 1];\n          var $propertySch = it.schema.properties[$property];\n          if (!($propertySch && (it.opts.strictKeywords ? typeof $propertySch == 'object' && Object.keys($propertySch).length > 0 : it.util.schemaHasRules($propertySch, it.RULES.all)))) {\n            $required[$required.length] = $property;\n          }\n        }\n      }\n    } else {\n      var $required = $schema;\n    }\n  }\n  if ($isData || $required.length) {\n    var $currentErrorPath = it.errorPath,\n      $loopRequired = $isData || $required.length >= it.opts.loopRequired,\n      $ownProperties = it.opts.ownProperties;\n    if ($breakOnError) {\n      out += ' var missing' + ($lvl) + '; ';\n      if ($loopRequired) {\n        if (!$isData) {\n          out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + '; ';\n        }\n        var $i = 'i' + $lvl,\n          $propertyPath = 'schema' + $lvl + '[' + $i + ']',\n          $missingProperty = '\\' + ' + $propertyPath + ' + \\'';\n        if (it.opts._errorDataPathProperty) {\n          it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers);\n        }\n        out += ' var ' + ($valid) + ' = true; ';\n        if ($isData) {\n          out += ' if (schema' + ($lvl) + ' === undefined) ' + ($valid) + ' = true; else if (!Array.isArray(schema' + ($lvl) + ')) ' + ($valid) + ' = false; else {';\n        }\n        out += ' for (var ' + ($i) + ' = 0; ' + ($i) + ' < ' + ($vSchema) + '.length; ' + ($i) + '++) { ' + ($valid) + ' = ' + ($data) + '[' + ($vSchema) + '[' + ($i) + ']] !== undefined ';\n        if ($ownProperties) {\n          out += ' &&   Object.prototype.hasOwnProperty.call(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + ']) ';\n        }\n        out += '; if (!' + ($valid) + ') break; } ';\n        if ($isData) {\n          out += '  }  ';\n        }\n        out += '  if (!' + ($valid) + ') {   ';\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'';\n            if (it.opts._errorDataPathProperty) {\n              out += 'is a required property';\n            } else {\n              out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n        out += ' } else { ';\n      } else {\n        out += ' if ( ';\n        var arr2 = $required;\n        if (arr2) {\n          var $propertyKey, $i = -1,\n            l2 = arr2.length - 1;\n          while ($i < l2) {\n            $propertyKey = arr2[$i += 1];\n            if ($i) {\n              out += ' || ';\n            }\n            var $prop = it.util.getProperty($propertyKey),\n              $useData = $data + $prop;\n            out += ' ( ( ' + ($useData) + ' === undefined ';\n            if ($ownProperties) {\n              out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n            }\n            out += ') && (missing' + ($lvl) + ' = ' + (it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop)) + ') ) ';\n          }\n        }\n        out += ') {  ';\n        var $propertyPath = 'missing' + $lvl,\n          $missingProperty = '\\' + ' + $propertyPath + ' + \\'';\n        if (it.opts._errorDataPathProperty) {\n          it.errorPath = it.opts.jsonPointers ? it.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + ' + ' + $propertyPath;\n        }\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'';\n            if (it.opts._errorDataPathProperty) {\n              out += 'is a required property';\n            } else {\n              out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n        out += ' } else { ';\n      }\n    } else {\n      if ($loopRequired) {\n        if (!$isData) {\n          out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + '; ';\n        }\n        var $i = 'i' + $lvl,\n          $propertyPath = 'schema' + $lvl + '[' + $i + ']',\n          $missingProperty = '\\' + ' + $propertyPath + ' + \\'';\n        if (it.opts._errorDataPathProperty) {\n          it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers);\n        }\n        if ($isData) {\n          out += ' if (' + ($vSchema) + ' && !Array.isArray(' + ($vSchema) + ')) {  var err =   '; /* istanbul ignore else */\n          if (it.createErrors !== false) {\n            out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n            if (it.opts.messages !== false) {\n              out += ' , message: \\'';\n              if (it.opts._errorDataPathProperty) {\n                out += 'is a required property';\n              } else {\n                out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n              }\n              out += '\\' ';\n            }\n            if (it.opts.verbose) {\n              out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n            }\n            out += ' } ';\n          } else {\n            out += ' {} ';\n          }\n          out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } else if (' + ($vSchema) + ' !== undefined) { ';\n        }\n        out += ' for (var ' + ($i) + ' = 0; ' + ($i) + ' < ' + ($vSchema) + '.length; ' + ($i) + '++) { if (' + ($data) + '[' + ($vSchema) + '[' + ($i) + ']] === undefined ';\n        if ($ownProperties) {\n          out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + ']) ';\n        }\n        out += ') {  var err =   '; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'';\n            if (it.opts._errorDataPathProperty) {\n              out += 'is a required property';\n            } else {\n              out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } } ';\n        if ($isData) {\n          out += '  }  ';\n        }\n      } else {\n        var arr3 = $required;\n        if (arr3) {\n          var $propertyKey, i3 = -1,\n            l3 = arr3.length - 1;\n          while (i3 < l3) {\n            $propertyKey = arr3[i3 += 1];\n            var $prop = it.util.getProperty($propertyKey),\n              $missingProperty = it.util.escapeQuotes($propertyKey),\n              $useData = $data + $prop;\n            if (it.opts._errorDataPathProperty) {\n              it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers);\n            }\n            out += ' if ( ' + ($useData) + ' === undefined ';\n            if ($ownProperties) {\n              out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n            }\n            out += ') {  var err =   '; /* istanbul ignore else */\n            if (it.createErrors !== false) {\n              out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n              if (it.opts.messages !== false) {\n                out += ' , message: \\'';\n                if (it.opts._errorDataPathProperty) {\n                  out += 'is a required property';\n                } else {\n                  out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n                }\n                out += '\\' ';\n              }\n              if (it.opts.verbose) {\n                out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n              }\n              out += ' } ';\n            } else {\n              out += ' {} ';\n            }\n            out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } ';\n          }\n        }\n      }\n    }\n    it.errorPath = $currentErrorPath;\n  } else if ($breakOnError) {\n    out += ' if (true) {';\n  }\n  return out;\n};\n\nvar uniqueItems = function generate_uniqueItems(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  if (($schema || $isData) && it.opts.uniqueItems !== false) {\n    if ($isData) {\n      out += ' var ' + ($valid) + '; if (' + ($schemaValue) + ' === false || ' + ($schemaValue) + ' === undefined) ' + ($valid) + ' = true; else if (typeof ' + ($schemaValue) + ' != \\'boolean\\') ' + ($valid) + ' = false; else { ';\n    }\n    out += ' var i = ' + ($data) + '.length , ' + ($valid) + ' = true , j; if (i > 1) { ';\n    var $itemType = it.schema.items && it.schema.items.type,\n      $typeIsArray = Array.isArray($itemType);\n    if (!$itemType || $itemType == 'object' || $itemType == 'array' || ($typeIsArray && ($itemType.indexOf('object') >= 0 || $itemType.indexOf('array') >= 0))) {\n      out += ' outer: for (;i--;) { for (j = i; j--;) { if (equal(' + ($data) + '[i], ' + ($data) + '[j])) { ' + ($valid) + ' = false; break outer; } } } ';\n    } else {\n      out += ' var itemIndices = {}, item; for (;i--;) { var item = ' + ($data) + '[i]; ';\n      var $method = 'checkDataType' + ($typeIsArray ? 's' : '');\n      out += ' if (' + (it.util[$method]($itemType, 'item', true)) + ') continue; ';\n      if ($typeIsArray) {\n        out += ' if (typeof item == \\'string\\') item = \\'\"\\' + item; ';\n      }\n      out += ' if (typeof itemIndices[item] == \\'number\\') { ' + ($valid) + ' = false; j = itemIndices[item]; break; } itemIndices[item] = i; } ';\n    }\n    out += ' } ';\n    if ($isData) {\n      out += '  }  ';\n    }\n    out += ' if (!' + ($valid) + ') {   ';\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = ''; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('uniqueItems') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { i: i, j: j } ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should NOT have duplicate items (items ## \\' + j + \\' and \\' + i + \\' are identical)\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema:  ';\n        if ($isData) {\n          out += 'validate.schema' + ($schemaPath);\n        } else {\n          out += '' + ($schema);\n        }\n        out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    var __err = out;\n    out = $$outStack.pop();\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError([' + (__err) + ']); ';\n      } else {\n        out += ' validate.errors = [' + (__err) + ']; return false; ';\n      }\n    } else {\n      out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    }\n    out += ' } ';\n    if ($breakOnError) {\n      out += ' else { ';\n    }\n  } else {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n  }\n  return out;\n};\n\n//all requires must be explicit because browserify won't work with dynamic requires\nvar dotjs = {\n  '$ref': ref$1,\n  allOf: allOf,\n  anyOf: anyOf,\n  '$comment': comment,\n  const: _const,\n  contains: contains,\n  dependencies: dependencies$5,\n  'enum': _enum,\n  format: format,\n  'if': _if,\n  items: items,\n  maximum: _limit,\n  minimum: _limit,\n  maxItems: _limitItems,\n  minItems: _limitItems,\n  maxLength: _limitLength,\n  minLength: _limitLength,\n  maxProperties: _limitProperties,\n  minProperties: _limitProperties,\n  multipleOf: multipleOf,\n  not: not,\n  oneOf: oneOf,\n  pattern: pattern,\n  properties: properties,\n  propertyNames: propertyNames,\n  required: required,\n  uniqueItems: uniqueItems,\n  validate: validate\n};\n\nvar toHash$1 = util$1.toHash;\n\nvar rules$1 = function rules() {\n  var RULES = [\n    { type: 'number',\n      rules: [ { 'maximum': ['exclusiveMaximum'] },\n               { 'minimum': ['exclusiveMinimum'] }, 'multipleOf', 'format'] },\n    { type: 'string',\n      rules: [ 'maxLength', 'minLength', 'pattern', 'format' ] },\n    { type: 'array',\n      rules: [ 'maxItems', 'minItems', 'items', 'contains', 'uniqueItems' ] },\n    { type: 'object',\n      rules: [ 'maxProperties', 'minProperties', 'required', 'dependencies', 'propertyNames',\n               { 'properties': ['additionalProperties', 'patternProperties'] } ] },\n    { rules: [ '$ref', 'const', 'enum', 'not', 'anyOf', 'oneOf', 'allOf', 'if' ] }\n  ];\n\n  var ALL = [ 'type', '$comment' ];\n  var KEYWORDS = [\n    '$schema', '$id', 'id', '$data', '$async', 'title',\n    'description', 'default', 'definitions',\n    'examples', 'readOnly', 'writeOnly',\n    'contentMediaType', 'contentEncoding',\n    'additionalItems', 'then', 'else'\n  ];\n  var TYPES = [ 'number', 'integer', 'string', 'array', 'object', 'boolean', 'null' ];\n  RULES.all = toHash$1(ALL);\n  RULES.types = toHash$1(TYPES);\n\n  RULES.forEach(function (group) {\n    group.rules = group.rules.map(function (keyword) {\n      var implKeywords;\n      if (typeof keyword == 'object') {\n        var key = Object.keys(keyword)[0];\n        implKeywords = keyword[key];\n        keyword = key;\n        implKeywords.forEach(function (k) {\n          ALL.push(k);\n          RULES.all[k] = true;\n        });\n      }\n      ALL.push(keyword);\n      var rule = RULES.all[keyword] = {\n        keyword: keyword,\n        code: dotjs[keyword],\n        implements: implKeywords\n      };\n      return rule;\n    });\n\n    RULES.all.$comment = {\n      keyword: '$comment',\n      code: dotjs.$comment\n    };\n\n    if (group.type) RULES.types[group.type] = group;\n  });\n\n  RULES.keywords = toHash$1(ALL.concat(KEYWORDS));\n  RULES.custom = {};\n\n  return RULES;\n};\n\nvar KEYWORDS = [\n  'multipleOf',\n  'maximum',\n  'exclusiveMaximum',\n  'minimum',\n  'exclusiveMinimum',\n  'maxLength',\n  'minLength',\n  'pattern',\n  'additionalItems',\n  'maxItems',\n  'minItems',\n  'uniqueItems',\n  'maxProperties',\n  'minProperties',\n  'required',\n  'additionalProperties',\n  'enum',\n  'format',\n  'const'\n];\n\nvar data$1 = function (metaSchema, keywordsJsonPointers) {\n  for (var i=0; i<keywordsJsonPointers.length; i++) {\n    metaSchema = JSON.parse(JSON.stringify(metaSchema));\n    var segments = keywordsJsonPointers[i].split('/');\n    var keywords = metaSchema;\n    var j;\n    for (j=1; j<segments.length; j++)\n      keywords = keywords[segments[j]];\n\n    for (j=0; j<KEYWORDS.length; j++) {\n      var key = KEYWORDS[j];\n      var schema = keywords[key];\n      if (schema) {\n        keywords[key] = {\n          anyOf: [\n            schema,\n            { $ref: 'https://raw.githubusercontent.com/epoberezkin/ajv/master/lib/refs/data.json#' }\n          ]\n        };\n      }\n    }\n  }\n\n  return metaSchema;\n};\n\nvar MissingRefError$1 = error_classes.MissingRef;\n\nvar async = compileAsync;\n\n\n/**\n * Creates validating function for passed schema with asynchronous loading of missing schemas.\n * `loadSchema` option should be a function that accepts schema uri and returns promise that resolves with the schema.\n * @this  Ajv\n * @param {Object}   schema schema object\n * @param {Boolean}  meta optional true to compile meta-schema; this parameter can be skipped\n * @param {Function} callback an optional node-style callback, it is called with 2 parameters: error (or null) and validating function.\n * @return {Promise} promise that resolves with a validating function.\n */\nfunction compileAsync(schema, meta, callback) {\n  /* eslint no-shadow: 0 */\n  /* global Promise */\n  /* jshint validthis: true */\n  var self = this;\n  if (typeof this._opts.loadSchema != 'function')\n    throw new Error('options.loadSchema should be a function');\n\n  if (typeof meta == 'function') {\n    callback = meta;\n    meta = undefined;\n  }\n\n  var p = loadMetaSchemaOf(schema).then(function () {\n    var schemaObj = self._addSchema(schema, undefined, meta);\n    return schemaObj.validate || _compileAsync(schemaObj);\n  });\n\n  if (callback) {\n    p.then(\n      function(v) { callback(null, v); },\n      callback\n    );\n  }\n\n  return p;\n\n\n  function loadMetaSchemaOf(sch) {\n    var $schema = sch.$schema;\n    return $schema && !self.getSchema($schema)\n            ? compileAsync.call(self, { $ref: $schema }, true)\n            : Promise.resolve();\n  }\n\n\n  function _compileAsync(schemaObj) {\n    try { return self._compile(schemaObj); }\n    catch(e) {\n      if (e instanceof MissingRefError$1) return loadMissingSchema(e);\n      throw e;\n    }\n\n\n    function loadMissingSchema(e) {\n      var ref = e.missingSchema;\n      if (added(ref)) throw new Error('Schema ' + ref + ' is loaded but ' + e.missingRef + ' cannot be resolved');\n\n      var schemaPromise = self._loadingSchemas[ref];\n      if (!schemaPromise) {\n        schemaPromise = self._loadingSchemas[ref] = self._opts.loadSchema(ref);\n        schemaPromise.then(removePromise, removePromise);\n      }\n\n      return schemaPromise.then(function (sch) {\n        if (!added(ref)) {\n          return loadMetaSchemaOf(sch).then(function () {\n            if (!added(ref)) self.addSchema(sch, ref, undefined, meta);\n          });\n        }\n      }).then(function() {\n        return _compileAsync(schemaObj);\n      });\n\n      function removePromise() {\n        delete self._loadingSchemas[ref];\n      }\n\n      function added(ref) {\n        return self._refs[ref] || self._schemas[ref];\n      }\n    }\n  }\n}\n\nvar custom = function generate_custom(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $rule = this,\n    $definition = 'definition' + $lvl,\n    $rDef = $rule.definition,\n    $closingBraces = '';\n  var $compile, $inline, $macro, $ruleValidate, $validateCode;\n  if ($isData && $rDef.$data) {\n    $validateCode = 'keywordValidate' + $lvl;\n    var $validateSchema = $rDef.validateSchema;\n    out += ' var ' + ($definition) + ' = RULES.custom[\\'' + ($keyword) + '\\'].definition; var ' + ($validateCode) + ' = ' + ($definition) + '.validate;';\n  } else {\n    $ruleValidate = it.useCustomRule($rule, $schema, it.schema, it);\n    if (!$ruleValidate) return;\n    $schemaValue = 'validate.schema' + $schemaPath;\n    $validateCode = $ruleValidate.code;\n    $compile = $rDef.compile;\n    $inline = $rDef.inline;\n    $macro = $rDef.macro;\n  }\n  var $ruleErrs = $validateCode + '.errors',\n    $i = 'i' + $lvl,\n    $ruleErr = 'ruleErr' + $lvl,\n    $asyncKeyword = $rDef.async;\n  if ($asyncKeyword && !it.async) throw new Error('async keyword in sync schema');\n  if (!($inline || $macro)) {\n    out += '' + ($ruleErrs) + ' = null;';\n  }\n  out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';';\n  if ($isData && $rDef.$data) {\n    $closingBraces += '}';\n    out += ' if (' + ($schemaValue) + ' === undefined) { ' + ($valid) + ' = true; } else { ';\n    if ($validateSchema) {\n      $closingBraces += '}';\n      out += ' ' + ($valid) + ' = ' + ($definition) + '.validateSchema(' + ($schemaValue) + '); if (' + ($valid) + ') { ';\n    }\n  }\n  if ($inline) {\n    if ($rDef.statements) {\n      out += ' ' + ($ruleValidate.validate) + ' ';\n    } else {\n      out += ' ' + ($valid) + ' = ' + ($ruleValidate.validate) + '; ';\n    }\n  } else if ($macro) {\n    var $it = it.util.copy(it);\n    var $closingBraces = '';\n    $it.level++;\n    var $nextValid = 'valid' + $it.level;\n    $it.schema = $ruleValidate.validate;\n    $it.schemaPath = '';\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    var $code = it.validate($it).replace(/validate\\.schema/g, $validateCode);\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' ' + ($code);\n  } else {\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = '';\n    out += '  ' + ($validateCode) + '.call( ';\n    if (it.opts.passContext) {\n      out += 'this';\n    } else {\n      out += 'self';\n    }\n    if ($compile || $rDef.schema === false) {\n      out += ' , ' + ($data) + ' ';\n    } else {\n      out += ' , ' + ($schemaValue) + ' , ' + ($data) + ' , validate.schema' + (it.schemaPath) + ' ';\n    }\n    out += ' , (dataPath || \\'\\')';\n    if (it.errorPath != '\"\"') {\n      out += ' + ' + (it.errorPath);\n    }\n    var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData',\n      $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty';\n    out += ' , ' + ($parentData) + ' , ' + ($parentDataProperty) + ' , rootData )  ';\n    var def_callRuleValidate = out;\n    out = $$outStack.pop();\n    if ($rDef.errors === false) {\n      out += ' ' + ($valid) + ' = ';\n      if ($asyncKeyword) {\n        out += 'await ';\n      }\n      out += '' + (def_callRuleValidate) + '; ';\n    } else {\n      if ($asyncKeyword) {\n        $ruleErrs = 'customErrors' + $lvl;\n        out += ' var ' + ($ruleErrs) + ' = null; try { ' + ($valid) + ' = await ' + (def_callRuleValidate) + '; } catch (e) { ' + ($valid) + ' = false; if (e instanceof ValidationError) ' + ($ruleErrs) + ' = e.errors; else throw e; } ';\n      } else {\n        out += ' ' + ($ruleErrs) + ' = null; ' + ($valid) + ' = ' + (def_callRuleValidate) + '; ';\n      }\n    }\n  }\n  if ($rDef.modifying) {\n    out += ' if (' + ($parentData) + ') ' + ($data) + ' = ' + ($parentData) + '[' + ($parentDataProperty) + '];';\n  }\n  out += '' + ($closingBraces);\n  if ($rDef.valid) {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n  } else {\n    out += ' if ( ';\n    if ($rDef.valid === undefined) {\n      out += ' !';\n      if ($macro) {\n        out += '' + ($nextValid);\n      } else {\n        out += '' + ($valid);\n      }\n    } else {\n      out += ' ' + (!$rDef.valid) + ' ';\n    }\n    out += ') { ';\n    $errorKeyword = $rule.keyword;\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = '';\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = ''; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ($errorKeyword || 'custom') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { keyword: \\'' + ($rule.keyword) + '\\' } ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should pass \"' + ($rule.keyword) + '\" keyword validation\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    var __err = out;\n    out = $$outStack.pop();\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError([' + (__err) + ']); ';\n      } else {\n        out += ' validate.errors = [' + (__err) + ']; return false; ';\n      }\n    } else {\n      out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    }\n    var def_customError = out;\n    out = $$outStack.pop();\n    if ($inline) {\n      if ($rDef.errors) {\n        if ($rDef.errors != 'full') {\n          out += '  for (var ' + ($i) + '=' + ($errs) + '; ' + ($i) + '<errors; ' + ($i) + '++) { var ' + ($ruleErr) + ' = vErrors[' + ($i) + ']; if (' + ($ruleErr) + '.dataPath === undefined) ' + ($ruleErr) + '.dataPath = (dataPath || \\'\\') + ' + (it.errorPath) + '; if (' + ($ruleErr) + '.schemaPath === undefined) { ' + ($ruleErr) + '.schemaPath = \"' + ($errSchemaPath) + '\"; } ';\n          if (it.opts.verbose) {\n            out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; ';\n          }\n          out += ' } ';\n        }\n      } else {\n        if ($rDef.errors === false) {\n          out += ' ' + (def_customError) + ' ';\n        } else {\n          out += ' if (' + ($errs) + ' == errors) { ' + (def_customError) + ' } else {  for (var ' + ($i) + '=' + ($errs) + '; ' + ($i) + '<errors; ' + ($i) + '++) { var ' + ($ruleErr) + ' = vErrors[' + ($i) + ']; if (' + ($ruleErr) + '.dataPath === undefined) ' + ($ruleErr) + '.dataPath = (dataPath || \\'\\') + ' + (it.errorPath) + '; if (' + ($ruleErr) + '.schemaPath === undefined) { ' + ($ruleErr) + '.schemaPath = \"' + ($errSchemaPath) + '\"; } ';\n          if (it.opts.verbose) {\n            out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; ';\n          }\n          out += ' } } ';\n        }\n      }\n    } else if ($macro) {\n      out += '   var err =   '; /* istanbul ignore else */\n      if (it.createErrors !== false) {\n        out += ' { keyword: \\'' + ($errorKeyword || 'custom') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { keyword: \\'' + ($rule.keyword) + '\\' } ';\n        if (it.opts.messages !== false) {\n          out += ' , message: \\'should pass \"' + ($rule.keyword) + '\" keyword validation\\' ';\n        }\n        if (it.opts.verbose) {\n          out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n        }\n        out += ' } ';\n      } else {\n        out += ' {} ';\n      }\n      out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n      if (!it.compositeRule && $breakOnError) {\n        /* istanbul ignore if */\n        if (it.async) {\n          out += ' throw new ValidationError(vErrors); ';\n        } else {\n          out += ' validate.errors = vErrors; return false; ';\n        }\n      }\n    } else {\n      if ($rDef.errors === false) {\n        out += ' ' + (def_customError) + ' ';\n      } else {\n        out += ' if (Array.isArray(' + ($ruleErrs) + ')) { if (vErrors === null) vErrors = ' + ($ruleErrs) + '; else vErrors = vErrors.concat(' + ($ruleErrs) + '); errors = vErrors.length;  for (var ' + ($i) + '=' + ($errs) + '; ' + ($i) + '<errors; ' + ($i) + '++) { var ' + ($ruleErr) + ' = vErrors[' + ($i) + ']; if (' + ($ruleErr) + '.dataPath === undefined) ' + ($ruleErr) + '.dataPath = (dataPath || \\'\\') + ' + (it.errorPath) + ';  ' + ($ruleErr) + '.schemaPath = \"' + ($errSchemaPath) + '\";  ';\n        if (it.opts.verbose) {\n          out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; ';\n        }\n        out += ' } } else { ' + (def_customError) + ' } ';\n      }\n    }\n    out += ' } ';\n    if ($breakOnError) {\n      out += ' else { ';\n    }\n  }\n  return out;\n};\n\nvar $schema = \"http://json-schema.org/draft-07/schema#\";\nvar $id = \"http://json-schema.org/draft-07/schema#\";\nvar title = \"Core schema meta-schema\";\nvar definitions = {\n\tschemaArray: {\n\t\ttype: \"array\",\n\t\tminItems: 1,\n\t\titems: {\n\t\t\t$ref: \"#\"\n\t\t}\n\t},\n\tnonNegativeInteger: {\n\t\ttype: \"integer\",\n\t\tminimum: 0\n\t},\n\tnonNegativeIntegerDefault0: {\n\t\tallOf: [\n\t\t\t{\n\t\t\t\t$ref: \"#/definitions/nonNegativeInteger\"\n\t\t\t},\n\t\t\t{\n\t\t\t\t\"default\": 0\n\t\t\t}\n\t\t]\n\t},\n\tsimpleTypes: {\n\t\t\"enum\": [\n\t\t\t\"array\",\n\t\t\t\"boolean\",\n\t\t\t\"integer\",\n\t\t\t\"null\",\n\t\t\t\"number\",\n\t\t\t\"object\",\n\t\t\t\"string\"\n\t\t]\n\t},\n\tstringArray: {\n\t\ttype: \"array\",\n\t\titems: {\n\t\t\ttype: \"string\"\n\t\t},\n\t\tuniqueItems: true,\n\t\t\"default\": [\n\t\t]\n\t}\n};\nvar type$1 = [\n\t\"object\",\n\t\"boolean\"\n];\nvar properties$1 = {\n\t$id: {\n\t\ttype: \"string\",\n\t\tformat: \"uri-reference\"\n\t},\n\t$schema: {\n\t\ttype: \"string\",\n\t\tformat: \"uri\"\n\t},\n\t$ref: {\n\t\ttype: \"string\",\n\t\tformat: \"uri-reference\"\n\t},\n\t$comment: {\n\t\ttype: \"string\"\n\t},\n\ttitle: {\n\t\ttype: \"string\"\n\t},\n\tdescription: {\n\t\ttype: \"string\"\n\t},\n\t\"default\": true,\n\treadOnly: {\n\t\ttype: \"boolean\",\n\t\t\"default\": false\n\t},\n\texamples: {\n\t\ttype: \"array\",\n\t\titems: true\n\t},\n\tmultipleOf: {\n\t\ttype: \"number\",\n\t\texclusiveMinimum: 0\n\t},\n\tmaximum: {\n\t\ttype: \"number\"\n\t},\n\texclusiveMaximum: {\n\t\ttype: \"number\"\n\t},\n\tminimum: {\n\t\ttype: \"number\"\n\t},\n\texclusiveMinimum: {\n\t\ttype: \"number\"\n\t},\n\tmaxLength: {\n\t\t$ref: \"#/definitions/nonNegativeInteger\"\n\t},\n\tminLength: {\n\t\t$ref: \"#/definitions/nonNegativeIntegerDefault0\"\n\t},\n\tpattern: {\n\t\ttype: \"string\",\n\t\tformat: \"regex\"\n\t},\n\tadditionalItems: {\n\t\t$ref: \"#\"\n\t},\n\titems: {\n\t\tanyOf: [\n\t\t\t{\n\t\t\t\t$ref: \"#\"\n\t\t\t},\n\t\t\t{\n\t\t\t\t$ref: \"#/definitions/schemaArray\"\n\t\t\t}\n\t\t],\n\t\t\"default\": true\n\t},\n\tmaxItems: {\n\t\t$ref: \"#/definitions/nonNegativeInteger\"\n\t},\n\tminItems: {\n\t\t$ref: \"#/definitions/nonNegativeIntegerDefault0\"\n\t},\n\tuniqueItems: {\n\t\ttype: \"boolean\",\n\t\t\"default\": false\n\t},\n\tcontains: {\n\t\t$ref: \"#\"\n\t},\n\tmaxProperties: {\n\t\t$ref: \"#/definitions/nonNegativeInteger\"\n\t},\n\tminProperties: {\n\t\t$ref: \"#/definitions/nonNegativeIntegerDefault0\"\n\t},\n\trequired: {\n\t\t$ref: \"#/definitions/stringArray\"\n\t},\n\tadditionalProperties: {\n\t\t$ref: \"#\"\n\t},\n\tdefinitions: {\n\t\ttype: \"object\",\n\t\tadditionalProperties: {\n\t\t\t$ref: \"#\"\n\t\t},\n\t\t\"default\": {\n\t\t}\n\t},\n\tproperties: {\n\t\ttype: \"object\",\n\t\tadditionalProperties: {\n\t\t\t$ref: \"#\"\n\t\t},\n\t\t\"default\": {\n\t\t}\n\t},\n\tpatternProperties: {\n\t\ttype: \"object\",\n\t\tadditionalProperties: {\n\t\t\t$ref: \"#\"\n\t\t},\n\t\tpropertyNames: {\n\t\t\tformat: \"regex\"\n\t\t},\n\t\t\"default\": {\n\t\t}\n\t},\n\tdependencies: {\n\t\ttype: \"object\",\n\t\tadditionalProperties: {\n\t\t\tanyOf: [\n\t\t\t\t{\n\t\t\t\t\t$ref: \"#\"\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\t$ref: \"#/definitions/stringArray\"\n\t\t\t\t}\n\t\t\t]\n\t\t}\n\t},\n\tpropertyNames: {\n\t\t$ref: \"#\"\n\t},\n\t\"const\": true,\n\t\"enum\": {\n\t\ttype: \"array\",\n\t\titems: true,\n\t\tminItems: 1,\n\t\tuniqueItems: true\n\t},\n\ttype: {\n\t\tanyOf: [\n\t\t\t{\n\t\t\t\t$ref: \"#/definitions/simpleTypes\"\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: \"array\",\n\t\t\t\titems: {\n\t\t\t\t\t$ref: \"#/definitions/simpleTypes\"\n\t\t\t\t},\n\t\t\t\tminItems: 1,\n\t\t\t\tuniqueItems: true\n\t\t\t}\n\t\t]\n\t},\n\tformat: {\n\t\ttype: \"string\"\n\t},\n\tcontentMediaType: {\n\t\ttype: \"string\"\n\t},\n\tcontentEncoding: {\n\t\ttype: \"string\"\n\t},\n\t\"if\": {\n\t\t$ref: \"#\"\n\t},\n\tthen: {\n\t\t$ref: \"#\"\n\t},\n\t\"else\": {\n\t\t$ref: \"#\"\n\t},\n\tallOf: {\n\t\t$ref: \"#/definitions/schemaArray\"\n\t},\n\tanyOf: {\n\t\t$ref: \"#/definitions/schemaArray\"\n\t},\n\toneOf: {\n\t\t$ref: \"#/definitions/schemaArray\"\n\t},\n\tnot: {\n\t\t$ref: \"#\"\n\t}\n};\nvar jsonSchemaDraft07 = {\n\t$schema: $schema,\n\t$id: $id,\n\ttitle: title,\n\tdefinitions: definitions,\n\ttype: type$1,\n\tproperties: properties$1,\n\t\"default\": true\n};\n\nvar jsonSchemaDraft07$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  $schema: $schema,\n  $id: $id,\n  title: title,\n  definitions: definitions,\n  type: type$1,\n  properties: properties$1,\n  'default': jsonSchemaDraft07\n});\n\nvar require$$2 = getCjsExportFromNamespace(jsonSchemaDraft07$1);\n\nvar definition_schema = {\n  $id: 'https://github.com/epoberezkin/ajv/blob/master/lib/definition_schema.js',\n  definitions: {\n    simpleTypes: require$$2.definitions.simpleTypes\n  },\n  type: 'object',\n  dependencies: {\n    schema: ['validate'],\n    $data: ['validate'],\n    statements: ['inline'],\n    valid: {not: {required: ['macro']}}\n  },\n  properties: {\n    type: require$$2.properties.type,\n    schema: {type: 'boolean'},\n    statements: {type: 'boolean'},\n    dependencies: {\n      type: 'array',\n      items: {type: 'string'}\n    },\n    metaSchema: {type: 'object'},\n    modifying: {type: 'boolean'},\n    valid: {type: 'boolean'},\n    $data: {type: 'boolean'},\n    async: {type: 'boolean'},\n    errors: {\n      anyOf: [\n        {type: 'boolean'},\n        {const: 'full'}\n      ]\n    }\n  }\n};\n\nvar IDENTIFIER$1 = /^[a-z_$][a-z0-9_$-]*$/i;\n\n\n\nvar keyword$1 = {\n  add: addKeyword,\n  get: getKeyword,\n  remove: removeKeyword,\n  validate: validateKeyword\n};\n\n\n/**\n * Define custom keyword\n * @this  Ajv\n * @param {String} keyword custom keyword, should be unique (including different from all standard, custom and macro keywords).\n * @param {Object} definition keyword definition object with properties `type` (type(s) which the keyword applies to), `validate` or `compile`.\n * @return {Ajv} this for method chaining\n */\nfunction addKeyword(keyword, definition) {\n  /* jshint validthis: true */\n  /* eslint no-shadow: 0 */\n  var RULES = this.RULES;\n  if (RULES.keywords[keyword])\n    throw new Error('Keyword ' + keyword + ' is already defined');\n\n  if (!IDENTIFIER$1.test(keyword))\n    throw new Error('Keyword ' + keyword + ' is not a valid identifier');\n\n  if (definition) {\n    this.validateKeyword(definition, true);\n\n    var dataType = definition.type;\n    if (Array.isArray(dataType)) {\n      for (var i=0; i<dataType.length; i++)\n        _addRule(keyword, dataType[i], definition);\n    } else {\n      _addRule(keyword, dataType, definition);\n    }\n\n    var metaSchema = definition.metaSchema;\n    if (metaSchema) {\n      if (definition.$data && this._opts.$data) {\n        metaSchema = {\n          anyOf: [\n            metaSchema,\n            { '$ref': 'https://raw.githubusercontent.com/epoberezkin/ajv/master/lib/refs/data.json#' }\n          ]\n        };\n      }\n      definition.validateSchema = this.compile(metaSchema, true);\n    }\n  }\n\n  RULES.keywords[keyword] = RULES.all[keyword] = true;\n\n\n  function _addRule(keyword, dataType, definition) {\n    var ruleGroup;\n    for (var i=0; i<RULES.length; i++) {\n      var rg = RULES[i];\n      if (rg.type == dataType) {\n        ruleGroup = rg;\n        break;\n      }\n    }\n\n    if (!ruleGroup) {\n      ruleGroup = { type: dataType, rules: [] };\n      RULES.push(ruleGroup);\n    }\n\n    var rule = {\n      keyword: keyword,\n      definition: definition,\n      custom: true,\n      code: custom,\n      implements: definition.implements\n    };\n    ruleGroup.rules.push(rule);\n    RULES.custom[keyword] = rule;\n  }\n\n  return this;\n}\n\n\n/**\n * Get keyword\n * @this  Ajv\n * @param {String} keyword pre-defined or custom keyword.\n * @return {Object|Boolean} custom keyword definition, `true` if it is a predefined keyword, `false` otherwise.\n */\nfunction getKeyword(keyword) {\n  /* jshint validthis: true */\n  var rule = this.RULES.custom[keyword];\n  return rule ? rule.definition : this.RULES.keywords[keyword] || false;\n}\n\n\n/**\n * Remove keyword\n * @this  Ajv\n * @param {String} keyword pre-defined or custom keyword.\n * @return {Ajv} this for method chaining\n */\nfunction removeKeyword(keyword) {\n  /* jshint validthis: true */\n  var RULES = this.RULES;\n  delete RULES.keywords[keyword];\n  delete RULES.all[keyword];\n  delete RULES.custom[keyword];\n  for (var i=0; i<RULES.length; i++) {\n    var rules = RULES[i].rules;\n    for (var j=0; j<rules.length; j++) {\n      if (rules[j].keyword == keyword) {\n        rules.splice(j, 1);\n        break;\n      }\n    }\n  }\n  return this;\n}\n\n\n/**\n * Validate keyword definition\n * @this  Ajv\n * @param {Object} definition keyword definition object.\n * @param {Boolean} throwError true to throw exception if definition is invalid\n * @return {boolean} validation result\n */\nfunction validateKeyword(definition, throwError) {\n  validateKeyword.errors = null;\n  var v = this._validateKeyword = this._validateKeyword\n                                  || this.compile(definition_schema, true);\n\n  if (v(definition)) return true;\n  validateKeyword.errors = v.errors;\n  if (throwError)\n    throw new Error('custom keyword definition is invalid: '  + this.errorsText(v.errors));\n  else\n    return false;\n}\n\nvar $schema$1 = \"http://json-schema.org/draft-07/schema#\";\nvar $id$1 = \"https://raw.githubusercontent.com/epoberezkin/ajv/master/lib/refs/data.json#\";\nvar description$6 = \"Meta-schema for $data reference (JSON Schema extension proposal)\";\nvar type$2 = \"object\";\nvar required$1 = [\n\t\"$data\"\n];\nvar properties$2 = {\n\t$data: {\n\t\ttype: \"string\",\n\t\tanyOf: [\n\t\t\t{\n\t\t\t\tformat: \"relative-json-pointer\"\n\t\t\t},\n\t\t\t{\n\t\t\t\tformat: \"json-pointer\"\n\t\t\t}\n\t\t]\n\t}\n};\nvar additionalProperties = false;\nvar data$2 = {\n\t$schema: $schema$1,\n\t$id: $id$1,\n\tdescription: description$6,\n\ttype: type$2,\n\trequired: required$1,\n\tproperties: properties$2,\n\tadditionalProperties: additionalProperties\n};\n\nvar data$3 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  $schema: $schema$1,\n  $id: $id$1,\n  description: description$6,\n  type: type$2,\n  required: required$1,\n  properties: properties$2,\n  additionalProperties: additionalProperties,\n  'default': data$2\n});\n\nvar require$$1$3 = getCjsExportFromNamespace(data$3);\n\nvar ajv = Ajv;\n\nAjv.prototype.validate = validate$1;\nAjv.prototype.compile = compile$1;\nAjv.prototype.addSchema = addSchema;\nAjv.prototype.addMetaSchema = addMetaSchema;\nAjv.prototype.validateSchema = validateSchema;\nAjv.prototype.getSchema = getSchema;\nAjv.prototype.removeSchema = removeSchema;\nAjv.prototype.addFormat = addFormat;\nAjv.prototype.errorsText = errorsText;\n\nAjv.prototype._addSchema = _addSchema;\nAjv.prototype._compile = _compile;\n\nAjv.prototype.compileAsync = async;\n\nAjv.prototype.addKeyword = keyword$1.add;\nAjv.prototype.getKeyword = keyword$1.get;\nAjv.prototype.removeKeyword = keyword$1.remove;\nAjv.prototype.validateKeyword = keyword$1.validate;\n\n\nAjv.ValidationError = error_classes.Validation;\nAjv.MissingRefError = error_classes.MissingRef;\nAjv.$dataMetaSchema = data$1;\n\nvar META_SCHEMA_ID = 'http://json-schema.org/draft-07/schema';\n\nvar META_IGNORE_OPTIONS = [ 'removeAdditional', 'useDefaults', 'coerceTypes', 'strictDefaults' ];\nvar META_SUPPORT_DATA = ['/properties'];\n\n/**\n * Creates validator instance.\n * Usage: `Ajv(opts)`\n * @param {Object} opts optional options\n * @return {Object} ajv instance\n */\nfunction Ajv(opts) {\n  if (!(this instanceof Ajv)) return new Ajv(opts);\n  opts = this._opts = util$1.copy(opts) || {};\n  setLogger(this);\n  this._schemas = {};\n  this._refs = {};\n  this._fragments = {};\n  this._formats = formats_1(opts.format);\n\n  this._cache = opts.cache || new cache$1;\n  this._loadingSchemas = {};\n  this._compilations = [];\n  this.RULES = rules$1();\n  this._getId = chooseGetId(opts);\n\n  opts.loopRequired = opts.loopRequired || Infinity;\n  if (opts.errorDataPath == 'property') opts._errorDataPathProperty = true;\n  if (opts.serialize === undefined) opts.serialize = fastJsonStableStringify;\n  this._metaOpts = getMetaSchemaOptions(this);\n\n  if (opts.formats) addInitialFormats(this);\n  if (opts.keywords) addInitialKeywords(this);\n  addDefaultMetaSchema(this);\n  if (typeof opts.meta == 'object') this.addMetaSchema(opts.meta);\n  if (opts.nullable) this.addKeyword('nullable', {metaSchema: {type: 'boolean'}});\n  addInitialSchemas(this);\n}\n\n\n\n/**\n * Validate data using schema\n * Schema will be compiled and cached (using serialized JSON as key. [fast-json-stable-stringify](https://github.com/epoberezkin/fast-json-stable-stringify) is used to serialize.\n * @this   Ajv\n * @param  {String|Object} schemaKeyRef key, ref or schema object\n * @param  {Any} data to be validated\n * @return {Boolean} validation result. Errors from the last validation will be available in `ajv.errors` (and also in compiled schema: `schema.errors`).\n */\nfunction validate$1(schemaKeyRef, data) {\n  var v;\n  if (typeof schemaKeyRef == 'string') {\n    v = this.getSchema(schemaKeyRef);\n    if (!v) throw new Error('no schema with key or ref \"' + schemaKeyRef + '\"');\n  } else {\n    var schemaObj = this._addSchema(schemaKeyRef);\n    v = schemaObj.validate || this._compile(schemaObj);\n  }\n\n  var valid = v(data);\n  if (v.$async !== true) this.errors = v.errors;\n  return valid;\n}\n\n\n/**\n * Create validating function for passed schema.\n * @this   Ajv\n * @param  {Object} schema schema object\n * @param  {Boolean} _meta true if schema is a meta-schema. Used internally to compile meta schemas of custom keywords.\n * @return {Function} validating function\n */\nfunction compile$1(schema, _meta) {\n  var schemaObj = this._addSchema(schema, undefined, _meta);\n  return schemaObj.validate || this._compile(schemaObj);\n}\n\n\n/**\n * Adds schema to the instance.\n * @this   Ajv\n * @param {Object|Array} schema schema or array of schemas. If array is passed, `key` and other parameters will be ignored.\n * @param {String} key Optional schema key. Can be passed to `validate` method instead of schema object or id/ref. One schema per instance can have empty `id` and `key`.\n * @param {Boolean} _skipValidation true to skip schema validation. Used internally, option validateSchema should be used instead.\n * @param {Boolean} _meta true if schema is a meta-schema. Used internally, addMetaSchema should be used instead.\n * @return {Ajv} this for method chaining\n */\nfunction addSchema(schema, key, _skipValidation, _meta) {\n  if (Array.isArray(schema)){\n    for (var i=0; i<schema.length; i++) this.addSchema(schema[i], undefined, _skipValidation, _meta);\n    return this;\n  }\n  var id = this._getId(schema);\n  if (id !== undefined && typeof id != 'string')\n    throw new Error('schema id must be string');\n  key = resolve_1.normalizeId(key || id);\n  checkUnique(this, key);\n  this._schemas[key] = this._addSchema(schema, _skipValidation, _meta, true);\n  return this;\n}\n\n\n/**\n * Add schema that will be used to validate other schemas\n * options in META_IGNORE_OPTIONS are alway set to false\n * @this   Ajv\n * @param {Object} schema schema object\n * @param {String} key optional schema key\n * @param {Boolean} skipValidation true to skip schema validation, can be used to override validateSchema option for meta-schema\n * @return {Ajv} this for method chaining\n */\nfunction addMetaSchema(schema, key, skipValidation) {\n  this.addSchema(schema, key, skipValidation, true);\n  return this;\n}\n\n\n/**\n * Validate schema\n * @this   Ajv\n * @param {Object} schema schema to validate\n * @param {Boolean} throwOrLogError pass true to throw (or log) an error if invalid\n * @return {Boolean} true if schema is valid\n */\nfunction validateSchema(schema, throwOrLogError) {\n  var $schema = schema.$schema;\n  if ($schema !== undefined && typeof $schema != 'string')\n    throw new Error('$schema must be a string');\n  $schema = $schema || this._opts.defaultMeta || defaultMeta(this);\n  if (!$schema) {\n    this.logger.warn('meta-schema not available');\n    this.errors = null;\n    return true;\n  }\n  var valid = this.validate($schema, schema);\n  if (!valid && throwOrLogError) {\n    var message = 'schema is invalid: ' + this.errorsText();\n    if (this._opts.validateSchema == 'log') this.logger.error(message);\n    else throw new Error(message);\n  }\n  return valid;\n}\n\n\nfunction defaultMeta(self) {\n  var meta = self._opts.meta;\n  self._opts.defaultMeta = typeof meta == 'object'\n                            ? self._getId(meta) || meta\n                            : self.getSchema(META_SCHEMA_ID)\n                              ? META_SCHEMA_ID\n                              : undefined;\n  return self._opts.defaultMeta;\n}\n\n\n/**\n * Get compiled schema from the instance by `key` or `ref`.\n * @this   Ajv\n * @param  {String} keyRef `key` that was passed to `addSchema` or full schema reference (`schema.id` or resolved id).\n * @return {Function} schema validating function (with property `schema`).\n */\nfunction getSchema(keyRef) {\n  var schemaObj = _getSchemaObj(this, keyRef);\n  switch (typeof schemaObj) {\n    case 'object': return schemaObj.validate || this._compile(schemaObj);\n    case 'string': return this.getSchema(schemaObj);\n    case 'undefined': return _getSchemaFragment(this, keyRef);\n  }\n}\n\n\nfunction _getSchemaFragment(self, ref) {\n  var res = resolve_1.schema.call(self, { schema: {} }, ref);\n  if (res) {\n    var schema = res.schema\n      , root = res.root\n      , baseId = res.baseId;\n    var v = compile_1.call(self, schema, root, undefined, baseId);\n    self._fragments[ref] = new schema_obj({\n      ref: ref,\n      fragment: true,\n      schema: schema,\n      root: root,\n      baseId: baseId,\n      validate: v\n    });\n    return v;\n  }\n}\n\n\nfunction _getSchemaObj(self, keyRef) {\n  keyRef = resolve_1.normalizeId(keyRef);\n  return self._schemas[keyRef] || self._refs[keyRef] || self._fragments[keyRef];\n}\n\n\n/**\n * Remove cached schema(s).\n * If no parameter is passed all schemas but meta-schemas are removed.\n * If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.\n * Even if schema is referenced by other schemas it still can be removed as other schemas have local references.\n * @this   Ajv\n * @param  {String|Object|RegExp} schemaKeyRef key, ref, pattern to match key/ref or schema object\n * @return {Ajv} this for method chaining\n */\nfunction removeSchema(schemaKeyRef) {\n  if (schemaKeyRef instanceof RegExp) {\n    _removeAllSchemas(this, this._schemas, schemaKeyRef);\n    _removeAllSchemas(this, this._refs, schemaKeyRef);\n    return this;\n  }\n  switch (typeof schemaKeyRef) {\n    case 'undefined':\n      _removeAllSchemas(this, this._schemas);\n      _removeAllSchemas(this, this._refs);\n      this._cache.clear();\n      return this;\n    case 'string':\n      var schemaObj = _getSchemaObj(this, schemaKeyRef);\n      if (schemaObj) this._cache.del(schemaObj.cacheKey);\n      delete this._schemas[schemaKeyRef];\n      delete this._refs[schemaKeyRef];\n      return this;\n    case 'object':\n      var serialize = this._opts.serialize;\n      var cacheKey = serialize ? serialize(schemaKeyRef) : schemaKeyRef;\n      this._cache.del(cacheKey);\n      var id = this._getId(schemaKeyRef);\n      if (id) {\n        id = resolve_1.normalizeId(id);\n        delete this._schemas[id];\n        delete this._refs[id];\n      }\n  }\n  return this;\n}\n\n\nfunction _removeAllSchemas(self, schemas, regex) {\n  for (var keyRef in schemas) {\n    var schemaObj = schemas[keyRef];\n    if (!schemaObj.meta && (!regex || regex.test(keyRef))) {\n      self._cache.del(schemaObj.cacheKey);\n      delete schemas[keyRef];\n    }\n  }\n}\n\n\n/* @this   Ajv */\nfunction _addSchema(schema, skipValidation, meta, shouldAddSchema) {\n  if (typeof schema != 'object' && typeof schema != 'boolean')\n    throw new Error('schema should be object or boolean');\n  var serialize = this._opts.serialize;\n  var cacheKey = serialize ? serialize(schema) : schema;\n  var cached = this._cache.get(cacheKey);\n  if (cached) return cached;\n\n  shouldAddSchema = shouldAddSchema || this._opts.addUsedSchema !== false;\n\n  var id = resolve_1.normalizeId(this._getId(schema));\n  if (id && shouldAddSchema) checkUnique(this, id);\n\n  var willValidate = this._opts.validateSchema !== false && !skipValidation;\n  var recursiveMeta;\n  if (willValidate && !(recursiveMeta = id && id == resolve_1.normalizeId(schema.$schema)))\n    this.validateSchema(schema, true);\n\n  var localRefs = resolve_1.ids.call(this, schema);\n\n  var schemaObj = new schema_obj({\n    id: id,\n    schema: schema,\n    localRefs: localRefs,\n    cacheKey: cacheKey,\n    meta: meta\n  });\n\n  if (id[0] != '#' && shouldAddSchema) this._refs[id] = schemaObj;\n  this._cache.put(cacheKey, schemaObj);\n\n  if (willValidate && recursiveMeta) this.validateSchema(schema, true);\n\n  return schemaObj;\n}\n\n\n/* @this   Ajv */\nfunction _compile(schemaObj, root) {\n  if (schemaObj.compiling) {\n    schemaObj.validate = callValidate;\n    callValidate.schema = schemaObj.schema;\n    callValidate.errors = null;\n    callValidate.root = root ? root : callValidate;\n    if (schemaObj.schema.$async === true)\n      callValidate.$async = true;\n    return callValidate;\n  }\n  schemaObj.compiling = true;\n\n  var currentOpts;\n  if (schemaObj.meta) {\n    currentOpts = this._opts;\n    this._opts = this._metaOpts;\n  }\n\n  var v;\n  try { v = compile_1.call(this, schemaObj.schema, root, schemaObj.localRefs); }\n  catch(e) {\n    delete schemaObj.validate;\n    throw e;\n  }\n  finally {\n    schemaObj.compiling = false;\n    if (schemaObj.meta) this._opts = currentOpts;\n  }\n\n  schemaObj.validate = v;\n  schemaObj.refs = v.refs;\n  schemaObj.refVal = v.refVal;\n  schemaObj.root = v.root;\n  return v;\n\n\n  /* @this   {*} - custom context, see passContext option */\n  function callValidate() {\n    /* jshint validthis: true */\n    var _validate = schemaObj.validate;\n    var result = _validate.apply(this, arguments);\n    callValidate.errors = _validate.errors;\n    return result;\n  }\n}\n\n\nfunction chooseGetId(opts) {\n  switch (opts.schemaId) {\n    case 'auto': return _get$IdOrId;\n    case 'id': return _getId;\n    default: return _get$Id;\n  }\n}\n\n/* @this   Ajv */\nfunction _getId(schema) {\n  if (schema.$id) this.logger.warn('schema $id ignored', schema.$id);\n  return schema.id;\n}\n\n/* @this   Ajv */\nfunction _get$Id(schema) {\n  if (schema.id) this.logger.warn('schema id ignored', schema.id);\n  return schema.$id;\n}\n\n\nfunction _get$IdOrId(schema) {\n  if (schema.$id && schema.id && schema.$id != schema.id)\n    throw new Error('schema $id is different from id');\n  return schema.$id || schema.id;\n}\n\n\n/**\n * Convert array of error message objects to string\n * @this   Ajv\n * @param  {Array<Object>} errors optional array of validation errors, if not passed errors from the instance are used.\n * @param  {Object} options optional options with properties `separator` and `dataVar`.\n * @return {String} human readable string with all errors descriptions\n */\nfunction errorsText(errors, options) {\n  errors = errors || this.errors;\n  if (!errors) return 'No errors';\n  options = options || {};\n  var separator = options.separator === undefined ? ', ' : options.separator;\n  var dataVar = options.dataVar === undefined ? 'data' : options.dataVar;\n\n  var text = '';\n  for (var i=0; i<errors.length; i++) {\n    var e = errors[i];\n    if (e) text += dataVar + e.dataPath + ' ' + e.message + separator;\n  }\n  return text.slice(0, -separator.length);\n}\n\n\n/**\n * Add custom format\n * @this   Ajv\n * @param {String} name format name\n * @param {String|RegExp|Function} format string is converted to RegExp; function should return boolean (true when valid)\n * @return {Ajv} this for method chaining\n */\nfunction addFormat(name, format) {\n  if (typeof format == 'string') format = new RegExp(format);\n  this._formats[name] = format;\n  return this;\n}\n\n\nfunction addDefaultMetaSchema(self) {\n  var $dataSchema;\n  if (self._opts.$data) {\n    $dataSchema = require$$1$3;\n    self.addMetaSchema($dataSchema, $dataSchema.$id, true);\n  }\n  if (self._opts.meta === false) return;\n  var metaSchema = require$$2;\n  if (self._opts.$data) metaSchema = data$1(metaSchema, META_SUPPORT_DATA);\n  self.addMetaSchema(metaSchema, META_SCHEMA_ID, true);\n  self._refs['http://json-schema.org/schema'] = META_SCHEMA_ID;\n}\n\n\nfunction addInitialSchemas(self) {\n  var optsSchemas = self._opts.schemas;\n  if (!optsSchemas) return;\n  if (Array.isArray(optsSchemas)) self.addSchema(optsSchemas);\n  else for (var key in optsSchemas) self.addSchema(optsSchemas[key], key);\n}\n\n\nfunction addInitialFormats(self) {\n  for (var name in self._opts.formats) {\n    var format = self._opts.formats[name];\n    self.addFormat(name, format);\n  }\n}\n\n\nfunction addInitialKeywords(self) {\n  for (var name in self._opts.keywords) {\n    var keyword = self._opts.keywords[name];\n    self.addKeyword(name, keyword);\n  }\n}\n\n\nfunction checkUnique(self, id) {\n  if (self._schemas[id] || self._refs[id])\n    throw new Error('schema with key or id \"' + id + '\" already exists');\n}\n\n\nfunction getMetaSchemaOptions(self) {\n  var metaOpts = util$1.copy(self._opts);\n  for (var i=0; i<META_IGNORE_OPTIONS.length; i++)\n    delete metaOpts[META_IGNORE_OPTIONS[i]];\n  return metaOpts;\n}\n\n\nfunction setLogger(self) {\n  var logger = self._opts.logger;\n  if (logger === false) {\n    self.logger = {log: noop$1, warn: noop$1, error: noop$1};\n  } else {\n    if (logger === undefined) logger = console;\n    if (!(typeof logger == 'object' && logger.log && logger.warn && logger.error))\n      throw new Error('logger must implement log, warn and error methods');\n    self.logger = logger;\n  }\n}\n\n\nfunction noop$1() {}\n\nvar id = \"http://json-schema.org/draft-04/schema#\";\nvar $schema$2 = \"http://json-schema.org/draft-04/schema#\";\nvar description$7 = \"Core schema meta-schema\";\nvar definitions$1 = {\n\tschemaArray: {\n\t\ttype: \"array\",\n\t\tminItems: 1,\n\t\titems: {\n\t\t\t$ref: \"#\"\n\t\t}\n\t},\n\tpositiveInteger: {\n\t\ttype: \"integer\",\n\t\tminimum: 0\n\t},\n\tpositiveIntegerDefault0: {\n\t\tallOf: [\n\t\t\t{\n\t\t\t\t$ref: \"#/definitions/positiveInteger\"\n\t\t\t},\n\t\t\t{\n\t\t\t\t\"default\": 0\n\t\t\t}\n\t\t]\n\t},\n\tsimpleTypes: {\n\t\t\"enum\": [\n\t\t\t\"array\",\n\t\t\t\"boolean\",\n\t\t\t\"integer\",\n\t\t\t\"null\",\n\t\t\t\"number\",\n\t\t\t\"object\",\n\t\t\t\"string\"\n\t\t]\n\t},\n\tstringArray: {\n\t\ttype: \"array\",\n\t\titems: {\n\t\t\ttype: \"string\"\n\t\t},\n\t\tminItems: 1,\n\t\tuniqueItems: true\n\t}\n};\nvar type$3 = \"object\";\nvar properties$3 = {\n\tid: {\n\t\ttype: \"string\"\n\t},\n\t$schema: {\n\t\ttype: \"string\"\n\t},\n\ttitle: {\n\t\ttype: \"string\"\n\t},\n\tdescription: {\n\t\ttype: \"string\"\n\t},\n\t\"default\": {\n\t},\n\tmultipleOf: {\n\t\ttype: \"number\",\n\t\tminimum: 0,\n\t\texclusiveMinimum: true\n\t},\n\tmaximum: {\n\t\ttype: \"number\"\n\t},\n\texclusiveMaximum: {\n\t\ttype: \"boolean\",\n\t\t\"default\": false\n\t},\n\tminimum: {\n\t\ttype: \"number\"\n\t},\n\texclusiveMinimum: {\n\t\ttype: \"boolean\",\n\t\t\"default\": false\n\t},\n\tmaxLength: {\n\t\t$ref: \"#/definitions/positiveInteger\"\n\t},\n\tminLength: {\n\t\t$ref: \"#/definitions/positiveIntegerDefault0\"\n\t},\n\tpattern: {\n\t\ttype: \"string\",\n\t\tformat: \"regex\"\n\t},\n\tadditionalItems: {\n\t\tanyOf: [\n\t\t\t{\n\t\t\t\ttype: \"boolean\"\n\t\t\t},\n\t\t\t{\n\t\t\t\t$ref: \"#\"\n\t\t\t}\n\t\t],\n\t\t\"default\": {\n\t\t}\n\t},\n\titems: {\n\t\tanyOf: [\n\t\t\t{\n\t\t\t\t$ref: \"#\"\n\t\t\t},\n\t\t\t{\n\t\t\t\t$ref: \"#/definitions/schemaArray\"\n\t\t\t}\n\t\t],\n\t\t\"default\": {\n\t\t}\n\t},\n\tmaxItems: {\n\t\t$ref: \"#/definitions/positiveInteger\"\n\t},\n\tminItems: {\n\t\t$ref: \"#/definitions/positiveIntegerDefault0\"\n\t},\n\tuniqueItems: {\n\t\ttype: \"boolean\",\n\t\t\"default\": false\n\t},\n\tmaxProperties: {\n\t\t$ref: \"#/definitions/positiveInteger\"\n\t},\n\tminProperties: {\n\t\t$ref: \"#/definitions/positiveIntegerDefault0\"\n\t},\n\trequired: {\n\t\t$ref: \"#/definitions/stringArray\"\n\t},\n\tadditionalProperties: {\n\t\tanyOf: [\n\t\t\t{\n\t\t\t\ttype: \"boolean\"\n\t\t\t},\n\t\t\t{\n\t\t\t\t$ref: \"#\"\n\t\t\t}\n\t\t],\n\t\t\"default\": {\n\t\t}\n\t},\n\tdefinitions: {\n\t\ttype: \"object\",\n\t\tadditionalProperties: {\n\t\t\t$ref: \"#\"\n\t\t},\n\t\t\"default\": {\n\t\t}\n\t},\n\tproperties: {\n\t\ttype: \"object\",\n\t\tadditionalProperties: {\n\t\t\t$ref: \"#\"\n\t\t},\n\t\t\"default\": {\n\t\t}\n\t},\n\tpatternProperties: {\n\t\ttype: \"object\",\n\t\tadditionalProperties: {\n\t\t\t$ref: \"#\"\n\t\t},\n\t\t\"default\": {\n\t\t}\n\t},\n\tdependencies: {\n\t\ttype: \"object\",\n\t\tadditionalProperties: {\n\t\t\tanyOf: [\n\t\t\t\t{\n\t\t\t\t\t$ref: \"#\"\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\t$ref: \"#/definitions/stringArray\"\n\t\t\t\t}\n\t\t\t]\n\t\t}\n\t},\n\t\"enum\": {\n\t\ttype: \"array\",\n\t\tminItems: 1,\n\t\tuniqueItems: true\n\t},\n\ttype: {\n\t\tanyOf: [\n\t\t\t{\n\t\t\t\t$ref: \"#/definitions/simpleTypes\"\n\t\t\t},\n\t\t\t{\n\t\t\t\ttype: \"array\",\n\t\t\t\titems: {\n\t\t\t\t\t$ref: \"#/definitions/simpleTypes\"\n\t\t\t\t},\n\t\t\t\tminItems: 1,\n\t\t\t\tuniqueItems: true\n\t\t\t}\n\t\t]\n\t},\n\tformat: {\n\t\ttype: \"string\"\n\t},\n\tallOf: {\n\t\t$ref: \"#/definitions/schemaArray\"\n\t},\n\tanyOf: {\n\t\t$ref: \"#/definitions/schemaArray\"\n\t},\n\toneOf: {\n\t\t$ref: \"#/definitions/schemaArray\"\n\t},\n\tnot: {\n\t\t$ref: \"#\"\n\t}\n};\nvar dependencies$6 = {\n\texclusiveMaximum: [\n\t\t\"maximum\"\n\t],\n\texclusiveMinimum: [\n\t\t\"minimum\"\n\t]\n};\nvar jsonSchemaDraft04 = {\n\tid: id,\n\t$schema: $schema$2,\n\tdescription: description$7,\n\tdefinitions: definitions$1,\n\ttype: type$3,\n\tproperties: properties$3,\n\tdependencies: dependencies$6,\n\t\"default\": {\n}\n};\n\nvar jsonSchemaDraft04$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  id: id,\n  $schema: $schema$2,\n  description: description$7,\n  definitions: definitions$1,\n  type: type$3,\n  properties: properties$3,\n  dependencies: dependencies$6,\n  'default': jsonSchemaDraft04\n});\n\nvar metaSchema = getCjsExportFromNamespace(jsonSchemaDraft04$1);\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nvar ajv$1 = (additionalOptions = {}) => {\n    const ajv$1 = new ajv({\n        meta: false,\n        useDefaults: true,\n        validateSchema: false,\n        missingRefs: \"ignore\",\n        verbose: true,\n        schemaId: \"auto\",\n        ...additionalOptions\n    });\n\n    ajv$1.addMetaSchema(metaSchema);\n    // eslint-disable-next-line no-underscore-dangle\n    ajv$1._opts.defaultMeta = metaSchema.id;\n\n    return ajv$1;\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\nconst ajv$2 = ajv$1();\nconst ruleValidators = new WeakMap();\nconst noop$2 = Function.prototype;\n\n//------------------------------------------------------------------------------\n// Private\n//------------------------------------------------------------------------------\nlet validateSchema$1;\n\n// Defitions for deprecation warnings.\nconst deprecationWarningMessages = {\n    ESLINT_LEGACY_ECMAFEATURES: \"The 'ecmaFeatures' config file property is deprecated, and has no effect.\"\n};\nconst severityMap = {\n    error: 2,\n    warn: 1,\n    off: 0\n};\n\n/**\n * Gets a complete options schema for a rule.\n * @param {{create: Function, schema: (Array|null)}} rule A new-style rule object\n * @returns {Object} JSON Schema for the rule's options.\n */\nfunction getRuleOptionsSchema(rule) {\n    if (!rule) {\n        return null;\n    }\n\n    const schema = rule.schema || rule.meta && rule.meta.schema;\n\n    // Given a tuple of schemas, insert warning level at the beginning\n    if (Array.isArray(schema)) {\n        if (schema.length) {\n            return {\n                type: \"array\",\n                items: schema,\n                minItems: 0,\n                maxItems: schema.length\n            };\n        }\n        return {\n            type: \"array\",\n            minItems: 0,\n            maxItems: 0\n        };\n\n    }\n\n    // Given a full schema, leave it alone\n    return schema || null;\n}\n\n/**\n * Validates a rule's severity and returns the severity value. Throws an error if the severity is invalid.\n * @param {options} options The given options for the rule.\n * @returns {number|string} The rule's severity value\n */\nfunction validateRuleSeverity(options) {\n    const severity = Array.isArray(options) ? options[0] : options;\n    const normSeverity = typeof severity === \"string\" ? severityMap[severity.toLowerCase()] : severity;\n\n    if (normSeverity === 0 || normSeverity === 1 || normSeverity === 2) {\n        return normSeverity;\n    }\n\n    throw new Error(`\\tSeverity should be one of the following: 0 = off, 1 = warn, 2 = error (you passed '${util$2.inspect(severity).replace(/'/gu, \"\\\"\").replace(/\\n/gu, \"\")}').\\n`);\n\n}\n\n/**\n * Validates the non-severity options passed to a rule, based on its schema.\n * @param {{create: Function}} rule The rule to validate\n * @param {Array} localOptions The options for the rule, excluding severity\n * @returns {void}\n */\nfunction validateRuleSchema(rule, localOptions) {\n    if (!ruleValidators.has(rule)) {\n        const schema = getRuleOptionsSchema(rule);\n\n        if (schema) {\n            ruleValidators.set(rule, ajv$2.compile(schema));\n        }\n    }\n\n    const validateRule = ruleValidators.get(rule);\n\n    if (validateRule) {\n        validateRule(localOptions);\n        if (validateRule.errors) {\n            throw new Error(validateRule.errors.map(\n                error => `\\tValue ${JSON.stringify(error.data)} ${error.message}.\\n`\n            ).join(\"\"));\n        }\n    }\n}\n\n/**\n * Validates a rule's options against its schema.\n * @param {{create: Function}|null} rule The rule that the config is being validated for\n * @param {string} ruleId The rule's unique name.\n * @param {Array|number} options The given options for the rule.\n * @param {string|null} source The name of the configuration source to report in any errors. If null or undefined,\n * no source is prepended to the message.\n * @returns {void}\n */\nfunction validateRuleOptions(rule, ruleId, options, source = null) {\n    try {\n        const severity = validateRuleSeverity(options);\n\n        if (severity !== 0) {\n            validateRuleSchema(rule, Array.isArray(options) ? options.slice(1) : []);\n        }\n    } catch (err) {\n        const enhancedMessage = `Configuration for rule \"${ruleId}\" is invalid:\\n${err.message}`;\n\n        if (typeof source === \"string\") {\n            throw new Error(`${source}:\\n\\t${enhancedMessage}`);\n        } else {\n            throw new Error(enhancedMessage);\n        }\n    }\n}\n\n/**\n * Validates an environment object\n * @param {Object} environment The environment config object to validate.\n * @param {string} source The name of the configuration source to report in any errors.\n * @param {function(envId:string): Object} [getAdditionalEnv] A map from strings to loaded environments.\n * @returns {void}\n */\nfunction validateEnvironment(\n    environment,\n    source,\n    getAdditionalEnv = noop$2\n) {\n\n    // not having an environment is ok\n    if (!environment) {\n        return;\n    }\n\n    Object.keys(environment).forEach(id => {\n        const env = getAdditionalEnv(id) || environments.get(id) || null;\n\n        if (!env) {\n            const message = `${source}:\\n\\tEnvironment key \"${id}\" is unknown\\n`;\n\n            throw new Error(message);\n        }\n    });\n}\n\n/**\n * Validates a rules config object\n * @param {Object} rulesConfig The rules config object to validate.\n * @param {string} source The name of the configuration source to report in any errors.\n * @param {function(ruleId:string): Object} getAdditionalRule A map from strings to loaded rules\n * @returns {void}\n */\nfunction validateRules(\n    rulesConfig,\n    source,\n    getAdditionalRule = noop$2\n) {\n    if (!rulesConfig) {\n        return;\n    }\n\n    Object.keys(rulesConfig).forEach(id => {\n        const rule = getAdditionalRule(id) || rules.get(id) || null;\n\n        validateRuleOptions(rule, id, rulesConfig[id], source);\n    });\n}\n\n/**\n * Validates a `globals` section of a config file\n * @param {Object} globalsConfig The `glboals` section\n * @param {string|null} source The name of the configuration source to report in the event of an error.\n * @returns {void}\n */\nfunction validateGlobals(globalsConfig, source = null) {\n    if (!globalsConfig) {\n        return;\n    }\n\n    Object.entries(globalsConfig)\n        .forEach(([configuredGlobal, configuredValue]) => {\n            try {\n                configOps.normalizeConfigGlobal(configuredValue);\n            } catch (err) {\n                throw new Error(`ESLint configuration of global '${configuredGlobal}' in ${source} is invalid:\\n${err.message}`);\n            }\n        });\n}\n\n/**\n * Validate `processor` configuration.\n * @param {string|undefined} processorName The processor name.\n * @param {string} source The name of config file.\n * @param {function(id:string): Processor} getProcessor The getter of defined processors.\n * @returns {void}\n */\nfunction validateProcessor(processorName, source, getProcessor) {\n    if (processorName && !getProcessor(processorName)) {\n        throw new Error(`ESLint configuration of processor in '${source}' is invalid: '${processorName}' was not found.`);\n    }\n}\n\n/**\n * Formats an array of schema validation errors.\n * @param {Array} errors An array of error messages to format.\n * @returns {string} Formatted error message\n */\nfunction formatErrors(errors) {\n    return errors.map(error => {\n        if (error.keyword === \"additionalProperties\") {\n            const formattedPropertyPath = error.dataPath.length ? `${error.dataPath.slice(1)}.${error.params.additionalProperty}` : error.params.additionalProperty;\n\n            return `Unexpected top-level property \"${formattedPropertyPath}\"`;\n        }\n        if (error.keyword === \"type\") {\n            const formattedField = error.dataPath.slice(1);\n            const formattedExpectedType = Array.isArray(error.schema) ? error.schema.join(\"/\") : error.schema;\n            const formattedValue = JSON.stringify(error.data);\n\n            return `Property \"${formattedField}\" is the wrong type (expected ${formattedExpectedType} but got \\`${formattedValue}\\`)`;\n        }\n\n        const field = error.dataPath[0] === \".\" ? error.dataPath.slice(1) : error.dataPath;\n\n        return `\"${field}\" ${error.message}. Value: ${JSON.stringify(error.data)}`;\n    }).map(message => `\\t- ${message}.\\n`).join(\"\");\n}\n\n/**\n * Emits a deprecation warning containing a given filepath. A new deprecation warning is emitted\n * for each unique file path, but repeated invocations with the same file path have no effect.\n * No warnings are emitted if the `--no-deprecation` or `--no-warnings` Node runtime flags are active.\n * @param {string} source The name of the configuration source to report the warning for.\n * @param {string} errorCode The warning message to show.\n * @returns {void}\n */\nconst emitDeprecationWarning = lodash.memoize((source, errorCode) => {\n    const rel = path$1.relative(process.cwd(), source);\n    const message = deprecationWarningMessages[errorCode];\n\n    process.emitWarning(\n        `${message} (found in \"${rel}\")`,\n        \"DeprecationWarning\",\n        errorCode\n    );\n});\n\n/**\n * Validates the top level properties of the config object.\n * @param {Object} config The config object to validate.\n * @param {string} source The name of the configuration source to report in any errors.\n * @returns {void}\n */\nfunction validateConfigSchema(config, source = null) {\n    validateSchema$1 = validateSchema$1 || ajv$2.compile(configSchema_1);\n\n    if (!validateSchema$1(config)) {\n        throw new Error(`ESLint configuration in ${source} is invalid:\\n${formatErrors(validateSchema$1.errors)}`);\n    }\n\n    if (Object.hasOwnProperty.call(config, \"ecmaFeatures\")) {\n        emitDeprecationWarning(source, \"ESLINT_LEGACY_ECMAFEATURES\");\n    }\n}\n\n/**\n * Validates an entire config object.\n * @param {Object} config The config object to validate.\n * @param {string} source The name of the configuration source to report in any errors.\n * @param {function(ruleId:string): Object} [getAdditionalRule] A map from strings to loaded rules.\n * @param {function(envId:string): Object} [getAdditionalEnv] A map from strings to loaded envs.\n * @returns {void}\n */\nfunction validate$2(config, source, getAdditionalRule, getAdditionalEnv) {\n    validateConfigSchema(config, source);\n    validateRules(config.rules, source, getAdditionalRule);\n    validateEnvironment(config.env, source, getAdditionalEnv);\n    validateGlobals(config.globals, source);\n\n    for (const override of config.overrides || []) {\n        validateRules(override.rules, source, getAdditionalRule);\n        validateEnvironment(override.env, source, getAdditionalEnv);\n        validateGlobals(config.globals, source);\n    }\n}\n\nconst validated = new WeakSet();\n\n/**\n * Validate config array object.\n * @param {ConfigArray} configArray The config array to validate.\n * @returns {void}\n */\nfunction validateConfigArray(configArray) {\n    const getPluginEnv = Map.prototype.get.bind(configArray.pluginEnvironments);\n    const getPluginProcessor = Map.prototype.get.bind(configArray.pluginProcessors);\n    const getPluginRule = Map.prototype.get.bind(configArray.pluginRules);\n\n    // Validate.\n    for (const element of configArray) {\n        if (validated.has(element)) {\n            continue;\n        }\n        validated.add(element);\n\n        validateEnvironment(element.env, element.name, getPluginEnv);\n        validateGlobals(element.globals, element.name);\n        validateProcessor(element.processor, element.name, getPluginProcessor);\n        validateRules(element.rules, element.name, getPluginRule);\n    }\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nvar configValidator = {\n    getRuleOptionsSchema,\n    validate: validate$2,\n    validateConfigArray,\n    validateConfigSchema,\n    validateRuleOptions\n};\n\n/**\n * @fileoverview Define the abstract class about cursors which iterate tokens.\n * @author Toru Nagashima\n */\n\n//------------------------------------------------------------------------------\n// Exports\n//------------------------------------------------------------------------------\n\n/**\n * The abstract class about cursors which iterate tokens.\n *\n * This class has 2 abstract methods.\n *\n * - `current: Token | Comment | null` ... The current token.\n * - `moveNext(): boolean` ... Moves this cursor to the next token. If the next token didn't exist, it returns `false`.\n *\n * This is similar to ES2015 Iterators.\n * However, Iterators were slow (at 2017-01), so I created this class as similar to C# IEnumerable.\n *\n * There are the following known sub classes.\n *\n * - ForwardTokenCursor .......... The cursor which iterates tokens only.\n * - BackwardTokenCursor ......... The cursor which iterates tokens only in reverse.\n * - ForwardTokenCommentCursor ... The cursor which iterates tokens and comments.\n * - BackwardTokenCommentCursor .. The cursor which iterates tokens and comments in reverse.\n * - DecorativeCursor\n *     - FilterCursor ............ The cursor which ignores the specified tokens.\n *     - SkipCursor .............. The cursor which ignores the first few tokens.\n *     - LimitCursor ............. The cursor which limits the count of tokens.\n *\n */\nvar cursor = class Cursor {\n\n    /**\n     * Initializes this cursor.\n     */\n    constructor() {\n        this.current = null;\n    }\n\n    /**\n     * Gets the first token.\n     * This consumes this cursor.\n     * @returns {Token|Comment} The first token or null.\n     */\n    getOneToken() {\n        return this.moveNext() ? this.current : null;\n    }\n\n    /**\n     * Gets the first tokens.\n     * This consumes this cursor.\n     * @returns {(Token|Comment)[]} All tokens.\n     */\n    getAllTokens() {\n        const tokens = [];\n\n        while (this.moveNext()) {\n            tokens.push(this.current);\n        }\n\n        return tokens;\n    }\n\n    /**\n     * Moves this cursor to the next token.\n     * @returns {boolean} `true` if the next token exists.\n     * @abstract\n     */\n    /* istanbul ignore next */\n    moveNext() { // eslint-disable-line class-methods-use-this\n        throw new Error(\"Not implemented.\");\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Gets `token.range[0]` from the given token.\n * @param {Node|Token|Comment} token The token to get.\n * @returns {number} The start location.\n * @private\n */\nfunction getStartLocation(token) {\n    return token.range[0];\n}\n\n//------------------------------------------------------------------------------\n// Exports\n//------------------------------------------------------------------------------\n\n/**\n * Binary-searches the index of the first token which is after the given location.\n * If it was not found, this returns `tokens.length`.\n * @param {(Token|Comment)[]} tokens It searches the token in this list.\n * @param {number} location The location to search.\n * @returns {number} The found index or `tokens.length`.\n */\nvar search = function search(tokens, location) {\n    return lodash.sortedIndexBy(\n        tokens,\n        { range: [location] },\n        getStartLocation\n    );\n};\n\n/**\n * Gets the index of the `startLoc` in `tokens`.\n * `startLoc` can be the value of `node.range[1]`, so this checks about `startLoc - 1` as well.\n * @param {(Token|Comment)[]} tokens The tokens to find an index.\n * @param {Object} indexMap The map from locations to indices.\n * @param {number} startLoc The location to get an index.\n * @returns {number} The index.\n */\nvar getFirstIndex = function getFirstIndex(tokens, indexMap, startLoc) {\n    if (startLoc in indexMap) {\n        return indexMap[startLoc];\n    }\n    if ((startLoc - 1) in indexMap) {\n        const index = indexMap[startLoc - 1];\n        const token = (index >= 0 && index < tokens.length) ? tokens[index] : null;\n\n        /*\n         * For the map of \"comment's location -> token's index\", it points the next token of a comment.\n         * In that case, +1 is unnecessary.\n         */\n        if (token && token.range[0] >= startLoc) {\n            return index;\n        }\n        return index + 1;\n    }\n    return 0;\n};\n\n/**\n * Gets the index of the `endLoc` in `tokens`.\n * The information of end locations are recorded at `endLoc - 1` in `indexMap`, so this checks about `endLoc - 1` as well.\n * @param {(Token|Comment)[]} tokens The tokens to find an index.\n * @param {Object} indexMap The map from locations to indices.\n * @param {number} endLoc The location to get an index.\n * @returns {number} The index.\n */\nvar getLastIndex = function getLastIndex(tokens, indexMap, endLoc) {\n    if (endLoc in indexMap) {\n        return indexMap[endLoc] - 1;\n    }\n    if ((endLoc - 1) in indexMap) {\n        const index = indexMap[endLoc - 1];\n        const token = (index >= 0 && index < tokens.length) ? tokens[index] : null;\n\n        /*\n         * For the map of \"comment's location -> token's index\", it points the next token of a comment.\n         * In that case, -1 is necessary.\n         */\n        if (token && token.range[1] > endLoc) {\n            return index - 1;\n        }\n        return index;\n    }\n    return tokens.length - 1;\n};\n\nvar utils$1 = {\n\tsearch: search,\n\tgetFirstIndex: getFirstIndex,\n\tgetLastIndex: getLastIndex\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Exports\n//------------------------------------------------------------------------------\n\n/**\n * The cursor which iterates tokens and comments in reverse.\n */\nvar backwardTokenCommentCursor = class BackwardTokenCommentCursor extends cursor {\n\n    /**\n     * Initializes this cursor.\n     * @param {Token[]} tokens The array of tokens.\n     * @param {Comment[]} comments The array of comments.\n     * @param {Object} indexMap The map from locations to indices in `tokens`.\n     * @param {number} startLoc The start location of the iteration range.\n     * @param {number} endLoc The end location of the iteration range.\n     */\n    constructor(tokens, comments, indexMap, startLoc, endLoc) {\n        super();\n        this.tokens = tokens;\n        this.comments = comments;\n        this.tokenIndex = utils$1.getLastIndex(tokens, indexMap, endLoc);\n        this.commentIndex = utils$1.search(comments, endLoc) - 1;\n        this.border = startLoc;\n    }\n\n    /** @inheritdoc */\n    moveNext() {\n        const token = (this.tokenIndex >= 0) ? this.tokens[this.tokenIndex] : null;\n        const comment = (this.commentIndex >= 0) ? this.comments[this.commentIndex] : null;\n\n        if (token && (!comment || token.range[1] > comment.range[1])) {\n            this.current = token;\n            this.tokenIndex -= 1;\n        } else if (comment) {\n            this.current = comment;\n            this.commentIndex -= 1;\n        } else {\n            this.current = null;\n        }\n\n        return Boolean(this.current) && (this.border === -1 || this.current.range[0] >= this.border);\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Exports\n//------------------------------------------------------------------------------\n\n/**\n * The cursor which iterates tokens only in reverse.\n */\nvar backwardTokenCursor = class BackwardTokenCursor extends cursor {\n\n    /**\n     * Initializes this cursor.\n     * @param {Token[]} tokens The array of tokens.\n     * @param {Comment[]} comments The array of comments.\n     * @param {Object} indexMap The map from locations to indices in `tokens`.\n     * @param {number} startLoc The start location of the iteration range.\n     * @param {number} endLoc The end location of the iteration range.\n     */\n    constructor(tokens, comments, indexMap, startLoc, endLoc) {\n        super();\n        this.tokens = tokens;\n        this.index = utils$1.getLastIndex(tokens, indexMap, endLoc);\n        this.indexEnd = utils$1.getFirstIndex(tokens, indexMap, startLoc);\n    }\n\n    /** @inheritdoc */\n    moveNext() {\n        if (this.index >= this.indexEnd) {\n            this.current = this.tokens[this.index];\n            this.index -= 1;\n            return true;\n        }\n        return false;\n    }\n\n    /*\n     *\n     * Shorthand for performance.\n     *\n     */\n\n    /** @inheritdoc */\n    getOneToken() {\n        return (this.index >= this.indexEnd) ? this.tokens[this.index] : null;\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Exports\n//------------------------------------------------------------------------------\n\n/**\n * The abstract class about cursors which manipulate another cursor.\n */\nvar decorativeCursor = class DecorativeCursor extends cursor {\n\n    /**\n     * Initializes this cursor.\n     * @param {Cursor} cursor The cursor to be decorated.\n     */\n    constructor(cursor) {\n        super();\n        this.cursor = cursor;\n    }\n\n    /** @inheritdoc */\n    moveNext() {\n        const retv = this.cursor.moveNext();\n\n        this.current = this.cursor.current;\n\n        return retv;\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Exports\n//------------------------------------------------------------------------------\n\n/**\n * The decorative cursor which ignores specified tokens.\n */\nvar filterCursor = class FilterCursor extends decorativeCursor {\n\n    /**\n     * Initializes this cursor.\n     * @param {Cursor} cursor The cursor to be decorated.\n     * @param {Function} predicate The predicate function to decide tokens this cursor iterates.\n     */\n    constructor(cursor, predicate) {\n        super(cursor);\n        this.predicate = predicate;\n    }\n\n    /** @inheritdoc */\n    moveNext() {\n        const predicate = this.predicate;\n\n        while (super.moveNext()) {\n            if (predicate(this.current)) {\n                return true;\n            }\n        }\n        return false;\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Exports\n//------------------------------------------------------------------------------\n\n/**\n * The cursor which iterates tokens and comments.\n */\nvar forwardTokenCommentCursor = class ForwardTokenCommentCursor extends cursor {\n\n    /**\n     * Initializes this cursor.\n     * @param {Token[]} tokens The array of tokens.\n     * @param {Comment[]} comments The array of comments.\n     * @param {Object} indexMap The map from locations to indices in `tokens`.\n     * @param {number} startLoc The start location of the iteration range.\n     * @param {number} endLoc The end location of the iteration range.\n     */\n    constructor(tokens, comments, indexMap, startLoc, endLoc) {\n        super();\n        this.tokens = tokens;\n        this.comments = comments;\n        this.tokenIndex = utils$1.getFirstIndex(tokens, indexMap, startLoc);\n        this.commentIndex = utils$1.search(comments, startLoc);\n        this.border = endLoc;\n    }\n\n    /** @inheritdoc */\n    moveNext() {\n        const token = (this.tokenIndex < this.tokens.length) ? this.tokens[this.tokenIndex] : null;\n        const comment = (this.commentIndex < this.comments.length) ? this.comments[this.commentIndex] : null;\n\n        if (token && (!comment || token.range[0] < comment.range[0])) {\n            this.current = token;\n            this.tokenIndex += 1;\n        } else if (comment) {\n            this.current = comment;\n            this.commentIndex += 1;\n        } else {\n            this.current = null;\n        }\n\n        return Boolean(this.current) && (this.border === -1 || this.current.range[1] <= this.border);\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Exports\n//------------------------------------------------------------------------------\n\n/**\n * The cursor which iterates tokens only.\n */\nvar forwardTokenCursor = class ForwardTokenCursor extends cursor {\n\n    /**\n     * Initializes this cursor.\n     * @param {Token[]} tokens The array of tokens.\n     * @param {Comment[]} comments The array of comments.\n     * @param {Object} indexMap The map from locations to indices in `tokens`.\n     * @param {number} startLoc The start location of the iteration range.\n     * @param {number} endLoc The end location of the iteration range.\n     */\n    constructor(tokens, comments, indexMap, startLoc, endLoc) {\n        super();\n        this.tokens = tokens;\n        this.index = utils$1.getFirstIndex(tokens, indexMap, startLoc);\n        this.indexEnd = utils$1.getLastIndex(tokens, indexMap, endLoc);\n    }\n\n    /** @inheritdoc */\n    moveNext() {\n        if (this.index <= this.indexEnd) {\n            this.current = this.tokens[this.index];\n            this.index += 1;\n            return true;\n        }\n        return false;\n    }\n\n    /*\n     *\n     * Shorthand for performance.\n     *\n     */\n\n    /** @inheritdoc */\n    getOneToken() {\n        return (this.index <= this.indexEnd) ? this.tokens[this.index] : null;\n    }\n\n    /** @inheritdoc */\n    getAllTokens() {\n        return this.tokens.slice(this.index, this.indexEnd + 1);\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Exports\n//------------------------------------------------------------------------------\n\n/**\n * The decorative cursor which limits the number of tokens.\n */\nvar limitCursor = class LimitCursor extends decorativeCursor {\n\n    /**\n     * Initializes this cursor.\n     * @param {Cursor} cursor The cursor to be decorated.\n     * @param {number} count The count of tokens this cursor iterates.\n     */\n    constructor(cursor, count) {\n        super(cursor);\n        this.count = count;\n    }\n\n    /** @inheritdoc */\n    moveNext() {\n        if (this.count > 0) {\n            this.count -= 1;\n            return super.moveNext();\n        }\n        return false;\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Exports\n//------------------------------------------------------------------------------\n\n/**\n * The decorative cursor which ignores the first few tokens.\n */\nvar skipCursor = class SkipCursor extends decorativeCursor {\n\n    /**\n     * Initializes this cursor.\n     * @param {Cursor} cursor The cursor to be decorated.\n     * @param {number} count The count of tokens this cursor skips.\n     */\n    constructor(cursor, count) {\n        super(cursor);\n        this.count = count;\n    }\n\n    /** @inheritdoc */\n    moveNext() {\n        while (this.count > 0) {\n            this.count -= 1;\n            if (!super.moveNext()) {\n                return false;\n            }\n        }\n        return super.moveNext();\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n\n\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * The cursor factory.\n * @private\n */\nclass CursorFactory {\n\n    /**\n     * Initializes this cursor.\n     * @param {Function} TokenCursor The class of the cursor which iterates tokens only.\n     * @param {Function} TokenCommentCursor The class of the cursor which iterates the mix of tokens and comments.\n     */\n    constructor(TokenCursor, TokenCommentCursor) {\n        this.TokenCursor = TokenCursor;\n        this.TokenCommentCursor = TokenCommentCursor;\n    }\n\n    /**\n     * Creates a base cursor instance that can be decorated by createCursor.\n     * @param {Token[]} tokens The array of tokens.\n     * @param {Comment[]} comments The array of comments.\n     * @param {Object} indexMap The map from locations to indices in `tokens`.\n     * @param {number} startLoc The start location of the iteration range.\n     * @param {number} endLoc The end location of the iteration range.\n     * @param {boolean} includeComments The flag to iterate comments as well.\n     * @returns {Cursor} The created base cursor.\n     */\n    createBaseCursor(tokens, comments, indexMap, startLoc, endLoc, includeComments) {\n        const Cursor = includeComments ? this.TokenCommentCursor : this.TokenCursor;\n\n        return new Cursor(tokens, comments, indexMap, startLoc, endLoc);\n    }\n\n    /**\n     * Creates a cursor that iterates tokens with normalized options.\n     * @param {Token[]} tokens The array of tokens.\n     * @param {Comment[]} comments The array of comments.\n     * @param {Object} indexMap The map from locations to indices in `tokens`.\n     * @param {number} startLoc The start location of the iteration range.\n     * @param {number} endLoc The end location of the iteration range.\n     * @param {boolean} includeComments The flag to iterate comments as well.\n     * @param {Function|null} filter The predicate function to choose tokens.\n     * @param {number} skip The count of tokens the cursor skips.\n     * @param {number} count The maximum count of tokens the cursor iterates. Zero is no iteration for backward compatibility.\n     * @returns {Cursor} The created cursor.\n     */\n    createCursor(tokens, comments, indexMap, startLoc, endLoc, includeComments, filter, skip, count) {\n        let cursor = this.createBaseCursor(tokens, comments, indexMap, startLoc, endLoc, includeComments);\n\n        if (filter) {\n            cursor = new filterCursor(cursor, filter);\n        }\n        if (skip >= 1) {\n            cursor = new skipCursor(cursor, skip);\n        }\n        if (count >= 0) {\n            cursor = new limitCursor(cursor, count);\n        }\n\n        return cursor;\n    }\n}\n\n//------------------------------------------------------------------------------\n// Exports\n//------------------------------------------------------------------------------\n\nvar forward = new CursorFactory(forwardTokenCursor, forwardTokenCommentCursor);\nvar backward = new CursorFactory(backwardTokenCursor, backwardTokenCommentCursor);\n\nvar cursors = {\n\tforward: forward,\n\tbackward: backward\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Exports\n//------------------------------------------------------------------------------\n\n/**\n * The cursor which iterates tokens only, with inflated range.\n * This is for the backward compatibility of padding options.\n */\nvar paddedTokenCursor = class PaddedTokenCursor extends forwardTokenCursor {\n\n    /**\n     * Initializes this cursor.\n     * @param {Token[]} tokens The array of tokens.\n     * @param {Comment[]} comments The array of comments.\n     * @param {Object} indexMap The map from locations to indices in `tokens`.\n     * @param {number} startLoc The start location of the iteration range.\n     * @param {number} endLoc The end location of the iteration range.\n     * @param {number} beforeCount The number of tokens this cursor iterates before start.\n     * @param {number} afterCount The number of tokens this cursor iterates after end.\n     */\n    constructor(tokens, comments, indexMap, startLoc, endLoc, beforeCount, afterCount) {\n        super(tokens, comments, indexMap, startLoc, endLoc);\n        this.index = Math.max(0, this.index - beforeCount);\n        this.indexEnd = Math.min(tokens.length - 1, this.indexEnd + afterCount);\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\nconst { isCommentToken: isCommentToken$2 } = require$$0$2;\n\n\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst TOKENS = Symbol(\"tokens\");\nconst COMMENTS = Symbol(\"comments\");\nconst INDEX_MAP = Symbol(\"indexMap\");\n\n/**\n * Creates the map from locations to indices in `tokens`.\n *\n * The first/last location of tokens is mapped to the index of the token.\n * The first/last location of comments is mapped to the index of the next token of each comment.\n * @param {Token[]} tokens The array of tokens.\n * @param {Comment[]} comments The array of comments.\n * @returns {Object} The map from locations to indices in `tokens`.\n * @private\n */\nfunction createIndexMap(tokens, comments) {\n    const map = Object.create(null);\n    let tokenIndex = 0;\n    let commentIndex = 0;\n    let nextStart = 0;\n    let range = null;\n\n    while (tokenIndex < tokens.length || commentIndex < comments.length) {\n        nextStart = (commentIndex < comments.length) ? comments[commentIndex].range[0] : Number.MAX_SAFE_INTEGER;\n        while (tokenIndex < tokens.length && (range = tokens[tokenIndex].range)[0] < nextStart) {\n            map[range[0]] = tokenIndex;\n            map[range[1] - 1] = tokenIndex;\n            tokenIndex += 1;\n        }\n\n        nextStart = (tokenIndex < tokens.length) ? tokens[tokenIndex].range[0] : Number.MAX_SAFE_INTEGER;\n        while (commentIndex < comments.length && (range = comments[commentIndex].range)[0] < nextStart) {\n            map[range[0]] = tokenIndex;\n            map[range[1] - 1] = tokenIndex;\n            commentIndex += 1;\n        }\n    }\n\n    return map;\n}\n\n/**\n * Creates the cursor iterates tokens with options.\n * @param {CursorFactory} factory The cursor factory to initialize cursor.\n * @param {Token[]} tokens The array of tokens.\n * @param {Comment[]} comments The array of comments.\n * @param {Object} indexMap The map from locations to indices in `tokens`.\n * @param {number} startLoc The start location of the iteration range.\n * @param {number} endLoc The end location of the iteration range.\n * @param {number|Function|Object} [opts=0] The option object. If this is a number then it's `opts.skip`. If this is a function then it's `opts.filter`.\n * @param {boolean} [opts.includeComments=false] The flag to iterate comments as well.\n * @param {Function|null} [opts.filter=null] The predicate function to choose tokens.\n * @param {number} [opts.skip=0] The count of tokens the cursor skips.\n * @returns {Cursor} The created cursor.\n * @private\n */\nfunction createCursorWithSkip(factory, tokens, comments, indexMap, startLoc, endLoc, opts) {\n    let includeComments = false;\n    let skip = 0;\n    let filter = null;\n\n    if (typeof opts === \"number\") {\n        skip = opts | 0;\n    } else if (typeof opts === \"function\") {\n        filter = opts;\n    } else if (opts) {\n        includeComments = !!opts.includeComments;\n        skip = opts.skip | 0;\n        filter = opts.filter || null;\n    }\n    assert(skip >= 0, \"options.skip should be zero or a positive integer.\");\n    assert(!filter || typeof filter === \"function\", \"options.filter should be a function.\");\n\n    return factory.createCursor(tokens, comments, indexMap, startLoc, endLoc, includeComments, filter, skip, -1);\n}\n\n/**\n * Creates the cursor iterates tokens with options.\n * @param {CursorFactory} factory The cursor factory to initialize cursor.\n * @param {Token[]} tokens The array of tokens.\n * @param {Comment[]} comments The array of comments.\n * @param {Object} indexMap The map from locations to indices in `tokens`.\n * @param {number} startLoc The start location of the iteration range.\n * @param {number} endLoc The end location of the iteration range.\n * @param {number|Function|Object} [opts=0] The option object. If this is a number then it's `opts.count`. If this is a function then it's `opts.filter`.\n * @param {boolean} [opts.includeComments] The flag to iterate comments as well.\n * @param {Function|null} [opts.filter=null] The predicate function to choose tokens.\n * @param {number} [opts.count=0] The maximum count of tokens the cursor iterates. Zero is no iteration for backward compatibility.\n * @returns {Cursor} The created cursor.\n * @private\n */\nfunction createCursorWithCount(factory, tokens, comments, indexMap, startLoc, endLoc, opts) {\n    let includeComments = false;\n    let count = 0;\n    let countExists = false;\n    let filter = null;\n\n    if (typeof opts === \"number\") {\n        count = opts | 0;\n        countExists = true;\n    } else if (typeof opts === \"function\") {\n        filter = opts;\n    } else if (opts) {\n        includeComments = !!opts.includeComments;\n        count = opts.count | 0;\n        countExists = typeof opts.count === \"number\";\n        filter = opts.filter || null;\n    }\n    assert(count >= 0, \"options.count should be zero or a positive integer.\");\n    assert(!filter || typeof filter === \"function\", \"options.filter should be a function.\");\n\n    return factory.createCursor(tokens, comments, indexMap, startLoc, endLoc, includeComments, filter, 0, countExists ? count : -1);\n}\n\n/**\n * Creates the cursor iterates tokens with options.\n * This is overload function of the below.\n * @param {Token[]} tokens The array of tokens.\n * @param {Comment[]} comments The array of comments.\n * @param {Object} indexMap The map from locations to indices in `tokens`.\n * @param {number} startLoc The start location of the iteration range.\n * @param {number} endLoc The end location of the iteration range.\n * @param {Function|Object} opts The option object. If this is a function then it's `opts.filter`.\n * @param {boolean} [opts.includeComments] The flag to iterate comments as well.\n * @param {Function|null} [opts.filter=null] The predicate function to choose tokens.\n * @param {number} [opts.count=0] The maximum count of tokens the cursor iterates. Zero is no iteration for backward compatibility.\n * @returns {Cursor} The created cursor.\n * @private\n */\n/**\n * Creates the cursor iterates tokens with options.\n * @param {Token[]} tokens The array of tokens.\n * @param {Comment[]} comments The array of comments.\n * @param {Object} indexMap The map from locations to indices in `tokens`.\n * @param {number} startLoc The start location of the iteration range.\n * @param {number} endLoc The end location of the iteration range.\n * @param {number} [beforeCount=0] The number of tokens before the node to retrieve.\n * @param {boolean} [afterCount=0] The number of tokens after the node to retrieve.\n * @returns {Cursor} The created cursor.\n * @private\n */\nfunction createCursorWithPadding(tokens, comments, indexMap, startLoc, endLoc, beforeCount, afterCount) {\n    if (typeof beforeCount === \"undefined\" && typeof afterCount === \"undefined\") {\n        return new forwardTokenCursor(tokens, comments, indexMap, startLoc, endLoc);\n    }\n    if (typeof beforeCount === \"number\" || typeof beforeCount === \"undefined\") {\n        return new paddedTokenCursor(tokens, comments, indexMap, startLoc, endLoc, beforeCount | 0, afterCount | 0);\n    }\n    return createCursorWithCount(cursors.forward, tokens, comments, indexMap, startLoc, endLoc, beforeCount);\n}\n\n/**\n * Gets comment tokens that are adjacent to the current cursor position.\n * @param {Cursor} cursor A cursor instance.\n * @returns {Array} An array of comment tokens adjacent to the current cursor position.\n * @private\n */\nfunction getAdjacentCommentTokensFromCursor(cursor) {\n    const tokens = [];\n    let currentToken = cursor.getOneToken();\n\n    while (currentToken && isCommentToken$2(currentToken)) {\n        tokens.push(currentToken);\n        currentToken = cursor.getOneToken();\n    }\n\n    return tokens;\n}\n\n//------------------------------------------------------------------------------\n// Exports\n//------------------------------------------------------------------------------\n\n/**\n * The token store.\n *\n * This class provides methods to get tokens by locations as fast as possible.\n * The methods are a part of public API, so we should be careful if it changes this class.\n *\n * People can get tokens in O(1) by the hash map which is mapping from the location of tokens/comments to tokens.\n * Also people can get a mix of tokens and comments in O(log k), the k is the number of comments.\n * Assuming that comments to be much fewer than tokens, this does not make hash map from token's locations to comments to reduce memory cost.\n * This uses binary-searching instead for comments.\n */\nvar tokenStore = class TokenStore {\n\n    /**\n     * Initializes this token store.\n     * @param {Token[]} tokens The array of tokens.\n     * @param {Comment[]} comments The array of comments.\n     */\n    constructor(tokens, comments) {\n        this[TOKENS] = tokens;\n        this[COMMENTS] = comments;\n        this[INDEX_MAP] = createIndexMap(tokens, comments);\n    }\n\n    //--------------------------------------------------------------------------\n    // Gets single token.\n    //--------------------------------------------------------------------------\n\n    /**\n     * Gets the token starting at the specified index.\n     * @param {number} offset Index of the start of the token's range.\n     * @param {Object} [options=0] The option object.\n     * @param {boolean} [options.includeComments=false] The flag to iterate comments as well.\n     * @returns {Token|null} The token starting at index, or null if no such token.\n     */\n    getTokenByRangeStart(offset, options) {\n        const includeComments = options && options.includeComments;\n        const token = cursors.forward.createBaseCursor(\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            offset,\n            -1,\n            includeComments\n        ).getOneToken();\n\n        if (token && token.range[0] === offset) {\n            return token;\n        }\n        return null;\n    }\n\n    /**\n     * Gets the first token of the given node.\n     * @param {ASTNode} node The AST node.\n     * @param {number|Function|Object} [options=0] The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`.\n     * @param {boolean} [options.includeComments=false] The flag to iterate comments as well.\n     * @param {Function|null} [options.filter=null] The predicate function to choose tokens.\n     * @param {number} [options.skip=0] The count of tokens the cursor skips.\n     * @returns {Token|null} An object representing the token.\n     */\n    getFirstToken(node, options) {\n        return createCursorWithSkip(\n            cursors.forward,\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            node.range[0],\n            node.range[1],\n            options\n        ).getOneToken();\n    }\n\n    /**\n     * Gets the last token of the given node.\n     * @param {ASTNode} node The AST node.\n     * @param {number|Function|Object} [options=0] The option object. Same options as getFirstToken()\n     * @returns {Token|null} An object representing the token.\n     */\n    getLastToken(node, options) {\n        return createCursorWithSkip(\n            cursors.backward,\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            node.range[0],\n            node.range[1],\n            options\n        ).getOneToken();\n    }\n\n    /**\n     * Gets the token that precedes a given node or token.\n     * @param {ASTNode|Token|Comment} node The AST node or token.\n     * @param {number|Function|Object} [options=0] The option object. Same options as getFirstToken()\n     * @returns {Token|null} An object representing the token.\n     */\n    getTokenBefore(node, options) {\n        return createCursorWithSkip(\n            cursors.backward,\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            -1,\n            node.range[0],\n            options\n        ).getOneToken();\n    }\n\n    /**\n     * Gets the token that follows a given node or token.\n     * @param {ASTNode|Token|Comment} node The AST node or token.\n     * @param {number|Function|Object} [options=0] The option object. Same options as getFirstToken()\n     * @returns {Token|null} An object representing the token.\n     */\n    getTokenAfter(node, options) {\n        return createCursorWithSkip(\n            cursors.forward,\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            node.range[1],\n            -1,\n            options\n        ).getOneToken();\n    }\n\n    /**\n     * Gets the first token between two non-overlapping nodes.\n     * @param {ASTNode|Token|Comment} left Node before the desired token range.\n     * @param {ASTNode|Token|Comment} right Node after the desired token range.\n     * @param {number|Function|Object} [options=0] The option object. Same options as getFirstToken()\n     * @returns {Token|null} An object representing the token.\n     */\n    getFirstTokenBetween(left, right, options) {\n        return createCursorWithSkip(\n            cursors.forward,\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            left.range[1],\n            right.range[0],\n            options\n        ).getOneToken();\n    }\n\n    /**\n     * Gets the last token between two non-overlapping nodes.\n     * @param {ASTNode|Token|Comment} left Node before the desired token range.\n     * @param {ASTNode|Token|Comment} right Node after the desired token range.\n     * @param {number|Function|Object} [options=0] The option object. Same options as getFirstToken()\n     * @returns {Token|null} An object representing the token.\n     */\n    getLastTokenBetween(left, right, options) {\n        return createCursorWithSkip(\n            cursors.backward,\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            left.range[1],\n            right.range[0],\n            options\n        ).getOneToken();\n    }\n\n    /**\n     * Gets the token that precedes a given node or token in the token stream.\n     * This is defined for backward compatibility. Use `includeComments` option instead.\n     * TODO: We have a plan to remove this in a future major version.\n     * @param {ASTNode|Token|Comment} node The AST node or token.\n     * @param {number} [skip=0] A number of tokens to skip.\n     * @returns {Token|null} An object representing the token.\n     * @deprecated\n     */\n    getTokenOrCommentBefore(node, skip) {\n        return this.getTokenBefore(node, { includeComments: true, skip });\n    }\n\n    /**\n     * Gets the token that follows a given node or token in the token stream.\n     * This is defined for backward compatibility. Use `includeComments` option instead.\n     * TODO: We have a plan to remove this in a future major version.\n     * @param {ASTNode|Token|Comment} node The AST node or token.\n     * @param {number} [skip=0] A number of tokens to skip.\n     * @returns {Token|null} An object representing the token.\n     * @deprecated\n     */\n    getTokenOrCommentAfter(node, skip) {\n        return this.getTokenAfter(node, { includeComments: true, skip });\n    }\n\n    //--------------------------------------------------------------------------\n    // Gets multiple tokens.\n    //--------------------------------------------------------------------------\n\n    /**\n     * Gets the first `count` tokens of the given node.\n     * @param {ASTNode} node The AST node.\n     * @param {number|Function|Object} [options=0] The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`.\n     * @param {boolean} [options.includeComments=false] The flag to iterate comments as well.\n     * @param {Function|null} [options.filter=null] The predicate function to choose tokens.\n     * @param {number} [options.count=0] The maximum count of tokens the cursor iterates.\n     * @returns {Token[]} Tokens.\n     */\n    getFirstTokens(node, options) {\n        return createCursorWithCount(\n            cursors.forward,\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            node.range[0],\n            node.range[1],\n            options\n        ).getAllTokens();\n    }\n\n    /**\n     * Gets the last `count` tokens of the given node.\n     * @param {ASTNode} node The AST node.\n     * @param {number|Function|Object} [options=0] The option object. Same options as getFirstTokens()\n     * @returns {Token[]} Tokens.\n     */\n    getLastTokens(node, options) {\n        return createCursorWithCount(\n            cursors.backward,\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            node.range[0],\n            node.range[1],\n            options\n        ).getAllTokens().reverse();\n    }\n\n    /**\n     * Gets the `count` tokens that precedes a given node or token.\n     * @param {ASTNode|Token|Comment} node The AST node or token.\n     * @param {number|Function|Object} [options=0] The option object. Same options as getFirstTokens()\n     * @returns {Token[]} Tokens.\n     */\n    getTokensBefore(node, options) {\n        return createCursorWithCount(\n            cursors.backward,\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            -1,\n            node.range[0],\n            options\n        ).getAllTokens().reverse();\n    }\n\n    /**\n     * Gets the `count` tokens that follows a given node or token.\n     * @param {ASTNode|Token|Comment} node The AST node or token.\n     * @param {number|Function|Object} [options=0] The option object. Same options as getFirstTokens()\n     * @returns {Token[]} Tokens.\n     */\n    getTokensAfter(node, options) {\n        return createCursorWithCount(\n            cursors.forward,\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            node.range[1],\n            -1,\n            options\n        ).getAllTokens();\n    }\n\n    /**\n     * Gets the first `count` tokens between two non-overlapping nodes.\n     * @param {ASTNode|Token|Comment} left Node before the desired token range.\n     * @param {ASTNode|Token|Comment} right Node after the desired token range.\n     * @param {number|Function|Object} [options=0] The option object. Same options as getFirstTokens()\n     * @returns {Token[]} Tokens between left and right.\n     */\n    getFirstTokensBetween(left, right, options) {\n        return createCursorWithCount(\n            cursors.forward,\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            left.range[1],\n            right.range[0],\n            options\n        ).getAllTokens();\n    }\n\n    /**\n     * Gets the last `count` tokens between two non-overlapping nodes.\n     * @param {ASTNode|Token|Comment} left Node before the desired token range.\n     * @param {ASTNode|Token|Comment} right Node after the desired token range.\n     * @param {number|Function|Object} [options=0] The option object. Same options as getFirstTokens()\n     * @returns {Token[]} Tokens between left and right.\n     */\n    getLastTokensBetween(left, right, options) {\n        return createCursorWithCount(\n            cursors.backward,\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            left.range[1],\n            right.range[0],\n            options\n        ).getAllTokens().reverse();\n    }\n\n    /**\n     * Gets all tokens that are related to the given node.\n     * @param {ASTNode} node The AST node.\n     * @param {Function|Object} options The option object. If this is a function then it's `options.filter`.\n     * @param {boolean} [options.includeComments=false] The flag to iterate comments as well.\n     * @param {Function|null} [options.filter=null] The predicate function to choose tokens.\n     * @param {number} [options.count=0] The maximum count of tokens the cursor iterates.\n     * @returns {Token[]} Array of objects representing tokens.\n     */\n    /**\n     * Gets all tokens that are related to the given node.\n     * @param {ASTNode} node The AST node.\n     * @param {int} [beforeCount=0] The number of tokens before the node to retrieve.\n     * @param {int} [afterCount=0] The number of tokens after the node to retrieve.\n     * @returns {Token[]} Array of objects representing tokens.\n     */\n    getTokens(node, beforeCount, afterCount) {\n        return createCursorWithPadding(\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            node.range[0],\n            node.range[1],\n            beforeCount,\n            afterCount\n        ).getAllTokens();\n    }\n\n    /**\n     * Gets all of the tokens between two non-overlapping nodes.\n     * @param {ASTNode|Token|Comment} left Node before the desired token range.\n     * @param {ASTNode|Token|Comment} right Node after the desired token range.\n     * @param {Function|Object} options The option object. If this is a function then it's `options.filter`.\n     * @param {boolean} [options.includeComments=false] The flag to iterate comments as well.\n     * @param {Function|null} [options.filter=null] The predicate function to choose tokens.\n     * @param {number} [options.count=0] The maximum count of tokens the cursor iterates.\n     * @returns {Token[]} Tokens between left and right.\n     */\n    /**\n     * Gets all of the tokens between two non-overlapping nodes.\n     * @param {ASTNode|Token|Comment} left Node before the desired token range.\n     * @param {ASTNode|Token|Comment} right Node after the desired token range.\n     * @param {int} [padding=0] Number of extra tokens on either side of center.\n     * @returns {Token[]} Tokens between left and right.\n     */\n    getTokensBetween(left, right, padding) {\n        return createCursorWithPadding(\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            left.range[1],\n            right.range[0],\n            padding,\n            padding\n        ).getAllTokens();\n    }\n\n    //--------------------------------------------------------------------------\n    // Others.\n    //--------------------------------------------------------------------------\n\n    /**\n     * Checks whether any comments exist or not between the given 2 nodes.\n     * @param {ASTNode} left The node to check.\n     * @param {ASTNode} right The node to check.\n     * @returns {boolean} `true` if one or more comments exist.\n     */\n    commentsExistBetween(left, right) {\n        const index = utils$1.search(this[COMMENTS], left.range[1]);\n\n        return (\n            index < this[COMMENTS].length &&\n            this[COMMENTS][index].range[1] <= right.range[0]\n        );\n    }\n\n    /**\n     * Gets all comment tokens directly before the given node or token.\n     * @param {ASTNode|token} nodeOrToken The AST node or token to check for adjacent comment tokens.\n     * @returns {Array} An array of comments in occurrence order.\n     */\n    getCommentsBefore(nodeOrToken) {\n        const cursor = createCursorWithCount(\n            cursors.backward,\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            -1,\n            nodeOrToken.range[0],\n            { includeComments: true }\n        );\n\n        return getAdjacentCommentTokensFromCursor(cursor).reverse();\n    }\n\n    /**\n     * Gets all comment tokens directly after the given node or token.\n     * @param {ASTNode|token} nodeOrToken The AST node or token to check for adjacent comment tokens.\n     * @returns {Array} An array of comments in occurrence order.\n     */\n    getCommentsAfter(nodeOrToken) {\n        const cursor = createCursorWithCount(\n            cursors.forward,\n            this[TOKENS],\n            this[COMMENTS],\n            this[INDEX_MAP],\n            nodeOrToken.range[1],\n            -1,\n            { includeComments: true }\n        );\n\n        return getAdjacentCommentTokensFromCursor(cursor);\n    }\n\n    /**\n     * Gets all comment tokens inside the given node.\n     * @param {ASTNode} node The AST node to get the comments for.\n     * @returns {Array} An array of comments in occurrence order.\n     */\n    getCommentsInside(node) {\n        return this.getTokens(node, {\n            includeComments: true,\n            filter: isCommentToken$2\n        });\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nconst\n    { isCommentToken: isCommentToken$3 } = require$$0$2;\n\n//------------------------------------------------------------------------------\n// Private\n//------------------------------------------------------------------------------\n\n/**\n * Validates that the given AST has the required information.\n * @param {ASTNode} ast The Program node of the AST to check.\n * @throws {Error} If the AST doesn't contain the correct information.\n * @returns {void}\n * @private\n */\nfunction validate$3(ast) {\n    if (!ast.tokens) {\n        throw new Error(\"AST is missing the tokens array.\");\n    }\n\n    if (!ast.comments) {\n        throw new Error(\"AST is missing the comments array.\");\n    }\n\n    if (!ast.loc) {\n        throw new Error(\"AST is missing location information.\");\n    }\n\n    if (!ast.range) {\n        throw new Error(\"AST is missing range information\");\n    }\n}\n\n/**\n * Check to see if its a ES6 export declaration.\n * @param {ASTNode} astNode An AST node.\n * @returns {boolean} whether the given node represents an export declaration.\n * @private\n */\nfunction looksLikeExport(astNode) {\n    return astNode.type === \"ExportDefaultDeclaration\" || astNode.type === \"ExportNamedDeclaration\" ||\n        astNode.type === \"ExportAllDeclaration\" || astNode.type === \"ExportSpecifier\";\n}\n\n/**\n * Merges two sorted lists into a larger sorted list in O(n) time.\n * @param {Token[]} tokens The list of tokens.\n * @param {Token[]} comments The list of comments.\n * @returns {Token[]} A sorted list of tokens and comments.\n * @private\n */\nfunction sortedMerge(tokens, comments) {\n    const result = [];\n    let tokenIndex = 0;\n    let commentIndex = 0;\n\n    while (tokenIndex < tokens.length || commentIndex < comments.length) {\n        if (commentIndex >= comments.length || tokenIndex < tokens.length && tokens[tokenIndex].range[0] < comments[commentIndex].range[0]) {\n            result.push(tokens[tokenIndex++]);\n        } else {\n            result.push(comments[commentIndex++]);\n        }\n    }\n\n    return result;\n}\n\n/**\n * Determines if two nodes or tokens overlap.\n * @param {ASTNode|Token} first The first node or token to check.\n * @param {ASTNode|Token} second The second node or token to check.\n * @returns {boolean} True if the two nodes or tokens overlap.\n * @private\n */\nfunction nodesOrTokensOverlap(first, second) {\n    return (first.range[0] <= second.range[0] && first.range[1] >= second.range[0]) ||\n        (second.range[0] <= first.range[0] && second.range[1] >= first.range[0]);\n}\n\n/**\n * Determines if two nodes or tokens have at least one whitespace character\n * between them. Order does not matter. Returns false if the given nodes or\n * tokens overlap.\n * @param {SourceCode} sourceCode The source code object.\n * @param {ASTNode|Token} first The first node or token to check between.\n * @param {ASTNode|Token} second The second node or token to check between.\n * @param {boolean} checkInsideOfJSXText If `true` is present, check inside of JSXText tokens for backward compatibility.\n * @returns {boolean} True if there is a whitespace character between\n * any of the tokens found between the two given nodes or tokens.\n * @public\n */\nfunction isSpaceBetween(sourceCode, first, second, checkInsideOfJSXText) {\n    if (nodesOrTokensOverlap(first, second)) {\n        return false;\n    }\n\n    const [startingNodeOrToken, endingNodeOrToken] = first.range[1] <= second.range[0]\n        ? [first, second]\n        : [second, first];\n    const firstToken = sourceCode.getLastToken(startingNodeOrToken) || startingNodeOrToken;\n    const finalToken = sourceCode.getFirstToken(endingNodeOrToken) || endingNodeOrToken;\n    let currentToken = firstToken;\n\n    while (currentToken !== finalToken) {\n        const nextToken = sourceCode.getTokenAfter(currentToken, { includeComments: true });\n\n        if (\n            currentToken.range[1] !== nextToken.range[0] ||\n\n                /*\n                 * For backward compatibility, check speces in JSXText.\n                 * https://github.com/eslint/eslint/issues/12614\n                 */\n                (\n                    checkInsideOfJSXText &&\n                    nextToken !== finalToken &&\n                    nextToken.type === \"JSXText\" &&\n                    /\\s/u.test(nextToken.value)\n                )\n        ) {\n            return true;\n        }\n\n        currentToken = nextToken;\n    }\n\n    return false;\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nclass SourceCode extends tokenStore {\n\n    /**\n     * Represents parsed source code.\n     * @param {string|Object} textOrConfig The source code text or config object.\n     * @param {string} textOrConfig.text The source code text.\n     * @param {ASTNode} textOrConfig.ast The Program node of the AST representing the code. This AST should be created from the text that BOM was stripped.\n     * @param {Object|null} textOrConfig.parserServices The parser services.\n     * @param {ScopeManager|null} textOrConfig.scopeManager The scope of this source code.\n     * @param {Object|null} textOrConfig.visitorKeys The visitor keys to traverse AST.\n     * @param {ASTNode} [astIfNoConfig] The Program node of the AST representing the code. This AST should be created from the text that BOM was stripped.\n     */\n    constructor(textOrConfig, astIfNoConfig) {\n        let text, ast, parserServices, scopeManager, visitorKeys;\n\n        // Process overloading.\n        if (typeof textOrConfig === \"string\") {\n            text = textOrConfig;\n            ast = astIfNoConfig;\n        } else if (typeof textOrConfig === \"object\" && textOrConfig !== null) {\n            text = textOrConfig.text;\n            ast = textOrConfig.ast;\n            parserServices = textOrConfig.parserServices;\n            scopeManager = textOrConfig.scopeManager;\n            visitorKeys = textOrConfig.visitorKeys;\n        }\n\n        validate$3(ast);\n        super(ast.tokens, ast.comments);\n\n        /**\n         * The flag to indicate that the source code has Unicode BOM.\n         * @type boolean\n         */\n        this.hasBOM = (text.charCodeAt(0) === 0xFEFF);\n\n        /**\n         * The original text source code.\n         * BOM was stripped from this text.\n         * @type string\n         */\n        this.text = (this.hasBOM ? text.slice(1) : text);\n\n        /**\n         * The parsed AST for the source code.\n         * @type ASTNode\n         */\n        this.ast = ast;\n\n        /**\n         * The parser services of this source code.\n         * @type {Object}\n         */\n        this.parserServices = parserServices || {};\n\n        /**\n         * The scope of this source code.\n         * @type {ScopeManager|null}\n         */\n        this.scopeManager = scopeManager || null;\n\n        /**\n         * The visitor keys to traverse AST.\n         * @type {Object}\n         */\n        this.visitorKeys = visitorKeys || traverser.DEFAULT_VISITOR_KEYS;\n\n        // Check the source text for the presence of a shebang since it is parsed as a standard line comment.\n        const shebangMatched = this.text.match(astUtils.shebangPattern);\n        const hasShebang = shebangMatched && ast.comments.length && ast.comments[0].value === shebangMatched[1];\n\n        if (hasShebang) {\n            ast.comments[0].type = \"Shebang\";\n        }\n\n        this.tokensAndComments = sortedMerge(ast.tokens, ast.comments);\n\n        /**\n         * The source code split into lines according to ECMA-262 specification.\n         * This is done to avoid each rule needing to do so separately.\n         * @type string[]\n         */\n        this.lines = [];\n        this.lineStartIndices = [0];\n\n        const lineEndingPattern = astUtils.createGlobalLinebreakMatcher();\n        let match;\n\n        /*\n         * Previously, this was implemented using a regex that\n         * matched a sequence of non-linebreak characters followed by a\n         * linebreak, then adding the lengths of the matches. However,\n         * this caused a catastrophic backtracking issue when the end\n         * of a file contained a large number of non-newline characters.\n         * To avoid this, the current implementation just matches newlines\n         * and uses match.index to get the correct line start indices.\n         */\n        while ((match = lineEndingPattern.exec(this.text))) {\n            this.lines.push(this.text.slice(this.lineStartIndices[this.lineStartIndices.length - 1], match.index));\n            this.lineStartIndices.push(match.index + match[0].length);\n        }\n        this.lines.push(this.text.slice(this.lineStartIndices[this.lineStartIndices.length - 1]));\n\n        // Cache for comments found using getComments().\n        this._commentCache = new WeakMap();\n\n        // don't allow modification of this object\n        Object.freeze(this);\n        Object.freeze(this.lines);\n    }\n\n    /**\n     * Split the source code into multiple lines based on the line delimiters.\n     * @param {string} text Source code as a string.\n     * @returns {string[]} Array of source code lines.\n     * @public\n     */\n    static splitLines(text) {\n        return text.split(astUtils.createGlobalLinebreakMatcher());\n    }\n\n    /**\n     * Gets the source code for the given node.\n     * @param {ASTNode} [node] The AST node to get the text for.\n     * @param {int} [beforeCount] The number of characters before the node to retrieve.\n     * @param {int} [afterCount] The number of characters after the node to retrieve.\n     * @returns {string} The text representing the AST node.\n     * @public\n     */\n    getText(node, beforeCount, afterCount) {\n        if (node) {\n            return this.text.slice(Math.max(node.range[0] - (beforeCount || 0), 0),\n                node.range[1] + (afterCount || 0));\n        }\n        return this.text;\n    }\n\n    /**\n     * Gets the entire source text split into an array of lines.\n     * @returns {Array} The source text as an array of lines.\n     * @public\n     */\n    getLines() {\n        return this.lines;\n    }\n\n    /**\n     * Retrieves an array containing all comments in the source code.\n     * @returns {ASTNode[]} An array of comment nodes.\n     * @public\n     */\n    getAllComments() {\n        return this.ast.comments;\n    }\n\n    /**\n     * Gets all comments for the given node.\n     * @param {ASTNode} node The AST node to get the comments for.\n     * @returns {Object} An object containing a leading and trailing array\n     *      of comments indexed by their position.\n     * @public\n     */\n    getComments(node) {\n        if (this._commentCache.has(node)) {\n            return this._commentCache.get(node);\n        }\n\n        const comments = {\n            leading: [],\n            trailing: []\n        };\n\n        /*\n         * Return all comments as leading comments of the Program node when\n         * there is no executable code.\n         */\n        if (node.type === \"Program\") {\n            if (node.body.length === 0) {\n                comments.leading = node.comments;\n            }\n        } else {\n\n            /*\n             * Return comments as trailing comments of nodes that only contain\n             * comments (to mimic the comment attachment behavior present in Espree).\n             */\n            if ((node.type === \"BlockStatement\" || node.type === \"ClassBody\") && node.body.length === 0 ||\n                node.type === \"ObjectExpression\" && node.properties.length === 0 ||\n                node.type === \"ArrayExpression\" && node.elements.length === 0 ||\n                node.type === \"SwitchStatement\" && node.cases.length === 0\n            ) {\n                comments.trailing = this.getTokens(node, {\n                    includeComments: true,\n                    filter: isCommentToken$3\n                });\n            }\n\n            /*\n             * Iterate over tokens before and after node and collect comment tokens.\n             * Do not include comments that exist outside of the parent node\n             * to avoid duplication.\n             */\n            let currentToken = this.getTokenBefore(node, { includeComments: true });\n\n            while (currentToken && isCommentToken$3(currentToken)) {\n                if (node.parent && (currentToken.start < node.parent.start)) {\n                    break;\n                }\n                comments.leading.push(currentToken);\n                currentToken = this.getTokenBefore(currentToken, { includeComments: true });\n            }\n\n            comments.leading.reverse();\n\n            currentToken = this.getTokenAfter(node, { includeComments: true });\n\n            while (currentToken && isCommentToken$3(currentToken)) {\n                if (node.parent && (currentToken.end > node.parent.end)) {\n                    break;\n                }\n                comments.trailing.push(currentToken);\n                currentToken = this.getTokenAfter(currentToken, { includeComments: true });\n            }\n        }\n\n        this._commentCache.set(node, comments);\n        return comments;\n    }\n\n    /**\n     * Retrieves the JSDoc comment for a given node.\n     * @param {ASTNode} node The AST node to get the comment for.\n     * @returns {Token|null} The Block comment token containing the JSDoc comment\n     *      for the given node or null if not found.\n     * @public\n     * @deprecated\n     */\n    getJSDocComment(node) {\n\n        /**\n         * Checks for the presence of a JSDoc comment for the given node and returns it.\n         * @param {ASTNode} astNode The AST node to get the comment for.\n         * @returns {Token|null} The Block comment token containing the JSDoc comment\n         *      for the given node or null if not found.\n         * @private\n         */\n        const findJSDocComment = astNode => {\n            const tokenBefore = this.getTokenBefore(astNode, { includeComments: true });\n\n            if (\n                tokenBefore &&\n                isCommentToken$3(tokenBefore) &&\n                tokenBefore.type === \"Block\" &&\n                tokenBefore.value.charAt(0) === \"*\" &&\n                astNode.loc.start.line - tokenBefore.loc.end.line <= 1\n            ) {\n                return tokenBefore;\n            }\n\n            return null;\n        };\n        let parent = node.parent;\n\n        switch (node.type) {\n            case \"ClassDeclaration\":\n            case \"FunctionDeclaration\":\n                return findJSDocComment(looksLikeExport(parent) ? parent : node);\n\n            case \"ClassExpression\":\n                return findJSDocComment(parent.parent);\n\n            case \"ArrowFunctionExpression\":\n            case \"FunctionExpression\":\n                if (parent.type !== \"CallExpression\" && parent.type !== \"NewExpression\") {\n                    while (\n                        !this.getCommentsBefore(parent).length &&\n                        !/Function/u.test(parent.type) &&\n                        parent.type !== \"MethodDefinition\" &&\n                        parent.type !== \"Property\"\n                    ) {\n                        parent = parent.parent;\n\n                        if (!parent) {\n                            break;\n                        }\n                    }\n\n                    if (parent && parent.type !== \"FunctionDeclaration\" && parent.type !== \"Program\") {\n                        return findJSDocComment(parent);\n                    }\n                }\n\n                return findJSDocComment(node);\n\n            // falls through\n            default:\n                return null;\n        }\n    }\n\n    /**\n     * Gets the deepest node containing a range index.\n     * @param {int} index Range index of the desired node.\n     * @returns {ASTNode} The node if found or null if not found.\n     * @public\n     */\n    getNodeByRangeIndex(index) {\n        let result = null;\n\n        traverser.traverse(this.ast, {\n            visitorKeys: this.visitorKeys,\n            enter(node) {\n                if (node.range[0] <= index && index < node.range[1]) {\n                    result = node;\n                } else {\n                    this.skip();\n                }\n            },\n            leave(node) {\n                if (node === result) {\n                    this.break();\n                }\n            }\n        });\n\n        return result;\n    }\n\n    /**\n     * Determines if two nodes or tokens have at least one whitespace character\n     * between them. Order does not matter. Returns false if the given nodes or\n     * tokens overlap.\n     * @param {ASTNode|Token} first The first node or token to check between.\n     * @param {ASTNode|Token} second The second node or token to check between.\n     * @returns {boolean} True if there is a whitespace character between\n     * any of the tokens found between the two given nodes or tokens.\n     * @public\n     */\n    isSpaceBetween(first, second) {\n        return isSpaceBetween(this, first, second, false);\n    }\n\n    /**\n     * Determines if two nodes or tokens have at least one whitespace character\n     * between them. Order does not matter. Returns false if the given nodes or\n     * tokens overlap.\n     * For backward compatibility, this method returns true if there are\n     * `JSXText` tokens that contain whitespaces between the two.\n     * @param {ASTNode|Token} first The first node or token to check between.\n     * @param {ASTNode|Token} second The second node or token to check between.\n     * @returns {boolean} True if there is a whitespace character between\n     * any of the tokens found between the two given nodes or tokens.\n     * @deprecated in favor of isSpaceBetween().\n     * @public\n     */\n    isSpaceBetweenTokens(first, second) {\n        return isSpaceBetween(this, first, second, true);\n    }\n\n    /**\n     * Converts a source text index into a (line, column) pair.\n     * @param {number} index The index of a character in a file\n     * @returns {Object} A {line, column} location object with a 0-indexed column\n     * @public\n     */\n    getLocFromIndex(index) {\n        if (typeof index !== \"number\") {\n            throw new TypeError(\"Expected `index` to be a number.\");\n        }\n\n        if (index < 0 || index > this.text.length) {\n            throw new RangeError(`Index out of range (requested index ${index}, but source text has length ${this.text.length}).`);\n        }\n\n        /*\n         * For an argument of this.text.length, return the location one \"spot\" past the last character\n         * of the file. If the last character is a linebreak, the location will be column 0 of the next\n         * line; otherwise, the location will be in the next column on the same line.\n         *\n         * See getIndexFromLoc for the motivation for this special case.\n         */\n        if (index === this.text.length) {\n            return { line: this.lines.length, column: this.lines[this.lines.length - 1].length };\n        }\n\n        /*\n         * To figure out which line rangeIndex is on, determine the last index at which rangeIndex could\n         * be inserted into lineIndices to keep the list sorted.\n         */\n        const lineNumber = lodash.sortedLastIndex(this.lineStartIndices, index);\n\n        return { line: lineNumber, column: index - this.lineStartIndices[lineNumber - 1] };\n    }\n\n    /**\n     * Converts a (line, column) pair into a range index.\n     * @param {Object} loc A line/column location\n     * @param {number} loc.line The line number of the location (1-indexed)\n     * @param {number} loc.column The column number of the location (0-indexed)\n     * @returns {number} The range index of the location in the file.\n     * @public\n     */\n    getIndexFromLoc(loc) {\n        if (typeof loc !== \"object\" || typeof loc.line !== \"number\" || typeof loc.column !== \"number\") {\n            throw new TypeError(\"Expected `loc` to be an object with numeric `line` and `column` properties.\");\n        }\n\n        if (loc.line <= 0) {\n            throw new RangeError(`Line number out of range (line ${loc.line} requested). Line numbers should be 1-based.`);\n        }\n\n        if (loc.line > this.lineStartIndices.length) {\n            throw new RangeError(`Line number out of range (line ${loc.line} requested, but only ${this.lineStartIndices.length} lines present).`);\n        }\n\n        const lineStartIndex = this.lineStartIndices[loc.line - 1];\n        const lineEndIndex = loc.line === this.lineStartIndices.length ? this.text.length : this.lineStartIndices[loc.line];\n        const positionIndex = lineStartIndex + loc.column;\n\n        /*\n         * By design, getIndexFromLoc({ line: lineNum, column: 0 }) should return the start index of\n         * the given line, provided that the line number is valid element of this.lines. Since the\n         * last element of this.lines is an empty string for files with trailing newlines, add a\n         * special case where getting the index for the first location after the end of the file\n         * will return the length of the file, rather than throwing an error. This allows rules to\n         * use getIndexFromLoc consistently without worrying about edge cases at the end of a file.\n         */\n        if (\n            loc.line === this.lineStartIndices.length && positionIndex > lineEndIndex ||\n            loc.line < this.lineStartIndices.length && positionIndex >= lineEndIndex\n        ) {\n            throw new RangeError(`Column number out of range (column ${loc.column} requested, but the length of line ${loc.line} is ${lineEndIndex - lineStartIndex}).`);\n        }\n\n        return positionIndex;\n    }\n}\n\nvar sourceCode = SourceCode;\n\nvar sourceCode$1 = {\n    SourceCode: sourceCode\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nconst debug$2 = src(\"eslint:code-path\");\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Gets id of a given segment.\n * @param {CodePathSegment} segment A segment to get.\n * @returns {string} Id of the segment.\n */\n/* istanbul ignore next */\nfunction getId$1(segment) { // eslint-disable-line jsdoc/require-jsdoc\n    return segment.id + (segment.reachable ? \"\" : \"!\");\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nvar debugHelpers = {\n\n    /**\n     * A flag that debug dumping is enabled or not.\n     * @type {boolean}\n     */\n    enabled: debug$2.enabled,\n\n    /**\n     * Dumps given objects.\n     * @param {...any} args objects to dump.\n     * @returns {void}\n     */\n    dump: debug$2,\n\n    /**\n     * Dumps the current analyzing state.\n     * @param {ASTNode} node A node to dump.\n     * @param {CodePathState} state A state to dump.\n     * @param {boolean} leaving A flag whether or not it's leaving\n     * @returns {void}\n     */\n    dumpState: !debug$2.enabled ? debug$2 : /* istanbul ignore next */ function(node, state, leaving) {\n        for (let i = 0; i < state.currentSegments.length; ++i) {\n            const segInternal = state.currentSegments[i].internal;\n\n            if (leaving) {\n                segInternal.exitNodes.push(node);\n            } else {\n                segInternal.nodes.push(node);\n            }\n        }\n\n        debug$2([\n            `${state.currentSegments.map(getId$1).join(\",\")})`,\n            `${node.type}${leaving ? \":exit\" : \"\"}`\n        ].join(\" \"));\n    },\n\n    /**\n     * Dumps a DOT code of a given code path.\n     * The DOT code can be visialized with Graphvis.\n     * @param {CodePath} codePath A code path to dump.\n     * @returns {void}\n     * @see http://www.graphviz.org\n     * @see http://www.webgraphviz.com\n     */\n    dumpDot: !debug$2.enabled ? debug$2 : /* istanbul ignore next */ function(codePath) {\n        let text =\n            \"\\n\" +\n            \"digraph {\\n\" +\n            \"node[shape=box,style=\\\"rounded,filled\\\",fillcolor=white];\\n\" +\n            \"initial[label=\\\"\\\",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];\\n\";\n\n        if (codePath.returnedSegments.length > 0) {\n            text += \"final[label=\\\"\\\",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];\\n\";\n        }\n        if (codePath.thrownSegments.length > 0) {\n            text += \"thrown[label=\\\"✘\\\",shape=circle,width=0.3,height=0.3,fixedsize];\\n\";\n        }\n\n        const traceMap = Object.create(null);\n        const arrows = this.makeDotArrows(codePath, traceMap);\n\n        for (const id in traceMap) { // eslint-disable-line guard-for-in\n            const segment = traceMap[id];\n\n            text += `${id}[`;\n\n            if (segment.reachable) {\n                text += \"label=\\\"\";\n            } else {\n                text += \"style=\\\"rounded,dashed,filled\\\",fillcolor=\\\"#FF9800\\\",label=\\\"<<unreachable>>\\\\n\";\n            }\n\n            if (segment.internal.nodes.length > 0 || segment.internal.exitNodes.length > 0) {\n                text += [].concat(\n                    segment.internal.nodes.map(node => {\n                        switch (node.type) {\n                            case \"Identifier\": return `${node.type} (${node.name})`;\n                            case \"Literal\": return `${node.type} (${node.value})`;\n                            default: return node.type;\n                        }\n                    }),\n                    segment.internal.exitNodes.map(node => {\n                        switch (node.type) {\n                            case \"Identifier\": return `${node.type}:exit (${node.name})`;\n                            case \"Literal\": return `${node.type}:exit (${node.value})`;\n                            default: return `${node.type}:exit`;\n                        }\n                    })\n                ).join(\"\\\\n\");\n            } else {\n                text += \"????\";\n            }\n\n            text += \"\\\"];\\n\";\n        }\n\n        text += `${arrows}\\n`;\n        text += \"}\";\n        debug$2(\"DOT\", text);\n    },\n\n    /**\n     * Makes a DOT code of a given code path.\n     * The DOT code can be visialized with Graphvis.\n     * @param {CodePath} codePath A code path to make DOT.\n     * @param {Object} traceMap Optional. A map to check whether or not segments had been done.\n     * @returns {string} A DOT code of the code path.\n     */\n    makeDotArrows(codePath, traceMap) {\n        const stack = [[codePath.initialSegment, 0]];\n        const done = traceMap || Object.create(null);\n        let lastId = codePath.initialSegment.id;\n        let text = `initial->${codePath.initialSegment.id}`;\n\n        while (stack.length > 0) {\n            const item = stack.pop();\n            const segment = item[0];\n            const index = item[1];\n\n            if (done[segment.id] && index === 0) {\n                continue;\n            }\n            done[segment.id] = segment;\n\n            const nextSegment = segment.allNextSegments[index];\n\n            if (!nextSegment) {\n                continue;\n            }\n\n            if (lastId === segment.id) {\n                text += `->${nextSegment.id}`;\n            } else {\n                text += `;\\n${segment.id}->${nextSegment.id}`;\n            }\n            lastId = nextSegment.id;\n\n            stack.unshift([segment, 1 + index]);\n            stack.push([nextSegment, 0]);\n        }\n\n        codePath.returnedSegments.forEach(finalSegment => {\n            if (lastId === finalSegment.id) {\n                text += \"->final\";\n            } else {\n                text += `;\\n${finalSegment.id}->final`;\n            }\n            lastId = null;\n        });\n\n        codePath.thrownSegments.forEach(finalSegment => {\n            if (lastId === finalSegment.id) {\n                text += \"->thrown\";\n            } else {\n                text += `;\\n${finalSegment.id}->thrown`;\n            }\n            lastId = null;\n        });\n\n        return `${text};`;\n    }\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not a given segment is reachable.\n * @param {CodePathSegment} segment A segment to check.\n * @returns {boolean} `true` if the segment is reachable.\n */\nfunction isReachable$4(segment) {\n    return segment.reachable;\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * A code path segment.\n */\nclass CodePathSegment {\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @param {string} id An identifier.\n     * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.\n     *   This array includes unreachable segments.\n     * @param {boolean} reachable A flag which shows this is reachable.\n     */\n    constructor(id, allPrevSegments, reachable) {\n\n        /**\n         * The identifier of this code path.\n         * Rules use it to store additional information of each rule.\n         * @type {string}\n         */\n        this.id = id;\n\n        /**\n         * An array of the next segments.\n         * @type {CodePathSegment[]}\n         */\n        this.nextSegments = [];\n\n        /**\n         * An array of the previous segments.\n         * @type {CodePathSegment[]}\n         */\n        this.prevSegments = allPrevSegments.filter(isReachable$4);\n\n        /**\n         * An array of the next segments.\n         * This array includes unreachable segments.\n         * @type {CodePathSegment[]}\n         */\n        this.allNextSegments = [];\n\n        /**\n         * An array of the previous segments.\n         * This array includes unreachable segments.\n         * @type {CodePathSegment[]}\n         */\n        this.allPrevSegments = allPrevSegments;\n\n        /**\n         * A flag which shows this is reachable.\n         * @type {boolean}\n         */\n        this.reachable = reachable;\n\n        // Internal data.\n        Object.defineProperty(this, \"internal\", {\n            value: {\n                used: false,\n                loopedPrevSegments: []\n            }\n        });\n\n        /* istanbul ignore if */\n        if (debugHelpers.enabled) {\n            this.internal.nodes = [];\n            this.internal.exitNodes = [];\n        }\n    }\n\n    /**\n     * Checks a given previous segment is coming from the end of a loop.\n     * @param {CodePathSegment} segment A previous segment to check.\n     * @returns {boolean} `true` if the segment is coming from the end of a loop.\n     */\n    isLoopedPrevSegment(segment) {\n        return this.internal.loopedPrevSegments.indexOf(segment) !== -1;\n    }\n\n    /**\n     * Creates the root segment.\n     * @param {string} id An identifier.\n     * @returns {CodePathSegment} The created segment.\n     */\n    static newRoot(id) {\n        return new CodePathSegment(id, [], true);\n    }\n\n    /**\n     * Creates a segment that follows given segments.\n     * @param {string} id An identifier.\n     * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.\n     * @returns {CodePathSegment} The created segment.\n     */\n    static newNext(id, allPrevSegments) {\n        return new CodePathSegment(\n            id,\n            CodePathSegment.flattenUnusedSegments(allPrevSegments),\n            allPrevSegments.some(isReachable$4)\n        );\n    }\n\n    /**\n     * Creates an unreachable segment that follows given segments.\n     * @param {string} id An identifier.\n     * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.\n     * @returns {CodePathSegment} The created segment.\n     */\n    static newUnreachable(id, allPrevSegments) {\n        const segment = new CodePathSegment(id, CodePathSegment.flattenUnusedSegments(allPrevSegments), false);\n\n        /*\n         * In `if (a) return a; foo();` case, the unreachable segment preceded by\n         * the return statement is not used but must not be remove.\n         */\n        CodePathSegment.markUsed(segment);\n\n        return segment;\n    }\n\n    /**\n     * Creates a segment that follows given segments.\n     * This factory method does not connect with `allPrevSegments`.\n     * But this inherits `reachable` flag.\n     * @param {string} id An identifier.\n     * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.\n     * @returns {CodePathSegment} The created segment.\n     */\n    static newDisconnected(id, allPrevSegments) {\n        return new CodePathSegment(id, [], allPrevSegments.some(isReachable$4));\n    }\n\n    /**\n     * Makes a given segment being used.\n     *\n     * And this function registers the segment into the previous segments as a next.\n     * @param {CodePathSegment} segment A segment to mark.\n     * @returns {void}\n     */\n    static markUsed(segment) {\n        if (segment.internal.used) {\n            return;\n        }\n        segment.internal.used = true;\n\n        let i;\n\n        if (segment.reachable) {\n            for (i = 0; i < segment.allPrevSegments.length; ++i) {\n                const prevSegment = segment.allPrevSegments[i];\n\n                prevSegment.allNextSegments.push(segment);\n                prevSegment.nextSegments.push(segment);\n            }\n        } else {\n            for (i = 0; i < segment.allPrevSegments.length; ++i) {\n                segment.allPrevSegments[i].allNextSegments.push(segment);\n            }\n        }\n    }\n\n    /**\n     * Marks a previous segment as looped.\n     * @param {CodePathSegment} segment A segment.\n     * @param {CodePathSegment} prevSegment A previous segment to mark.\n     * @returns {void}\n     */\n    static markPrevSegmentAsLooped(segment, prevSegment) {\n        segment.internal.loopedPrevSegments.push(prevSegment);\n    }\n\n    /**\n     * Replaces unused segments with the previous segments of each unused segment.\n     * @param {CodePathSegment[]} segments An array of segments to replace.\n     * @returns {CodePathSegment[]} The replaced array.\n     */\n    static flattenUnusedSegments(segments) {\n        const done = Object.create(null);\n        const retv = [];\n\n        for (let i = 0; i < segments.length; ++i) {\n            const segment = segments[i];\n\n            // Ignores duplicated.\n            if (done[segment.id]) {\n                continue;\n            }\n\n            // Use previous segments if unused.\n            if (!segment.internal.used) {\n                for (let j = 0; j < segment.allPrevSegments.length; ++j) {\n                    const prevSegment = segment.allPrevSegments[j];\n\n                    if (!done[prevSegment.id]) {\n                        done[prevSegment.id] = true;\n                        retv.push(prevSegment);\n                    }\n                }\n            } else {\n                done[segment.id] = true;\n                retv.push(segment);\n            }\n        }\n\n        return retv;\n    }\n}\n\nvar codePathSegment = CodePathSegment;\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Gets whether or not a given segment is reachable.\n * @param {CodePathSegment} segment A segment to get.\n * @returns {boolean} `true` if the segment is reachable.\n */\nfunction isReachable$5(segment) {\n    return segment.reachable;\n}\n\n/**\n * Creates new segments from the specific range of `context.segmentsList`.\n *\n * When `context.segmentsList` is `[[a, b], [c, d], [e, f]]`, `begin` is `0`, and\n * `end` is `-1`, this creates `[g, h]`. This `g` is from `a`, `c`, and `e`.\n * This `h` is from `b`, `d`, and `f`.\n * @param {ForkContext} context An instance.\n * @param {number} begin The first index of the previous segments.\n * @param {number} end The last index of the previous segments.\n * @param {Function} create A factory function of new segments.\n * @returns {CodePathSegment[]} New segments.\n */\nfunction makeSegments(context, begin, end, create) {\n    const list = context.segmentsList;\n\n    const normalizedBegin = begin >= 0 ? begin : list.length + begin;\n    const normalizedEnd = end >= 0 ? end : list.length + end;\n\n    const segments = [];\n\n    for (let i = 0; i < context.count; ++i) {\n        const allPrevSegments = [];\n\n        for (let j = normalizedBegin; j <= normalizedEnd; ++j) {\n            allPrevSegments.push(list[j][i]);\n        }\n\n        segments.push(create(context.idGenerator.next(), allPrevSegments));\n    }\n\n    return segments;\n}\n\n/**\n * `segments` becomes doubly in a `finally` block. Then if a code path exits by a\n * control statement (such as `break`, `continue`) from the `finally` block, the\n * destination's segments may be half of the source segments. In that case, this\n * merges segments.\n * @param {ForkContext} context An instance.\n * @param {CodePathSegment[]} segments Segments to merge.\n * @returns {CodePathSegment[]} The merged segments.\n */\nfunction mergeExtraSegments(context, segments) {\n    let currentSegments = segments;\n\n    while (currentSegments.length > context.count) {\n        const merged = [];\n\n        for (let i = 0, length = currentSegments.length / 2 | 0; i < length; ++i) {\n            merged.push(codePathSegment.newNext(\n                context.idGenerator.next(),\n                [currentSegments[i], currentSegments[i + length]]\n            ));\n        }\n        currentSegments = merged;\n    }\n    return currentSegments;\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * A class to manage forking.\n */\nclass ForkContext {\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @param {IdGenerator} idGenerator An identifier generator for segments.\n     * @param {ForkContext|null} upper An upper fork context.\n     * @param {number} count A number of parallel segments.\n     */\n    constructor(idGenerator, upper, count) {\n        this.idGenerator = idGenerator;\n        this.upper = upper;\n        this.count = count;\n        this.segmentsList = [];\n    }\n\n    /**\n     * The head segments.\n     * @type {CodePathSegment[]}\n     */\n    get head() {\n        const list = this.segmentsList;\n\n        return list.length === 0 ? [] : list[list.length - 1];\n    }\n\n    /**\n     * A flag which shows empty.\n     * @type {boolean}\n     */\n    get empty() {\n        return this.segmentsList.length === 0;\n    }\n\n    /**\n     * A flag which shows reachable.\n     * @type {boolean}\n     */\n    get reachable() {\n        const segments = this.head;\n\n        return segments.length > 0 && segments.some(isReachable$5);\n    }\n\n    /**\n     * Creates new segments from this context.\n     * @param {number} begin The first index of previous segments.\n     * @param {number} end The last index of previous segments.\n     * @returns {CodePathSegment[]} New segments.\n     */\n    makeNext(begin, end) {\n        return makeSegments(this, begin, end, codePathSegment.newNext);\n    }\n\n    /**\n     * Creates new segments from this context.\n     * The new segments is always unreachable.\n     * @param {number} begin The first index of previous segments.\n     * @param {number} end The last index of previous segments.\n     * @returns {CodePathSegment[]} New segments.\n     */\n    makeUnreachable(begin, end) {\n        return makeSegments(this, begin, end, codePathSegment.newUnreachable);\n    }\n\n    /**\n     * Creates new segments from this context.\n     * The new segments don't have connections for previous segments.\n     * But these inherit the reachable flag from this context.\n     * @param {number} begin The first index of previous segments.\n     * @param {number} end The last index of previous segments.\n     * @returns {CodePathSegment[]} New segments.\n     */\n    makeDisconnected(begin, end) {\n        return makeSegments(this, begin, end, codePathSegment.newDisconnected);\n    }\n\n    /**\n     * Adds segments into this context.\n     * The added segments become the head.\n     * @param {CodePathSegment[]} segments Segments to add.\n     * @returns {void}\n     */\n    add(segments) {\n        assert(segments.length >= this.count, `${segments.length} >= ${this.count}`);\n\n        this.segmentsList.push(mergeExtraSegments(this, segments));\n    }\n\n    /**\n     * Replaces the head segments with given segments.\n     * The current head segments are removed.\n     * @param {CodePathSegment[]} segments Segments to add.\n     * @returns {void}\n     */\n    replaceHead(segments) {\n        assert(segments.length >= this.count, `${segments.length} >= ${this.count}`);\n\n        this.segmentsList.splice(-1, 1, mergeExtraSegments(this, segments));\n    }\n\n    /**\n     * Adds all segments of a given fork context into this context.\n     * @param {ForkContext} context A fork context to add.\n     * @returns {void}\n     */\n    addAll(context) {\n        assert(context.count === this.count);\n\n        const source = context.segmentsList;\n\n        for (let i = 0; i < source.length; ++i) {\n            this.segmentsList.push(source[i]);\n        }\n    }\n\n    /**\n     * Clears all secments in this context.\n     * @returns {void}\n     */\n    clear() {\n        this.segmentsList = [];\n    }\n\n    /**\n     * Creates the root fork context.\n     * @param {IdGenerator} idGenerator An identifier generator for segments.\n     * @returns {ForkContext} New fork context.\n     */\n    static newRoot(idGenerator) {\n        const context = new ForkContext(idGenerator, null, 1);\n\n        context.add([codePathSegment.newRoot(idGenerator.next())]);\n\n        return context;\n    }\n\n    /**\n     * Creates an empty fork context preceded by a given context.\n     * @param {ForkContext} parentContext The parent fork context.\n     * @param {boolean} forkLeavingPath A flag which shows inside of `finally` block.\n     * @returns {ForkContext} New fork context.\n     */\n    static newEmpty(parentContext, forkLeavingPath) {\n        return new ForkContext(\n            parentContext.idGenerator,\n            parentContext,\n            (forkLeavingPath ? 2 : 1) * parentContext.count\n        );\n    }\n}\n\nvar forkContext = ForkContext;\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Adds given segments into the `dest` array.\n * If the `others` array does not includes the given segments, adds to the `all`\n * array as well.\n *\n * This adds only reachable and used segments.\n * @param {CodePathSegment[]} dest A destination array (`returnedSegments` or `thrownSegments`).\n * @param {CodePathSegment[]} others Another destination array (`returnedSegments` or `thrownSegments`).\n * @param {CodePathSegment[]} all The unified destination array (`finalSegments`).\n * @param {CodePathSegment[]} segments Segments to add.\n * @returns {void}\n */\nfunction addToReturnedOrThrown(dest, others, all, segments) {\n    for (let i = 0; i < segments.length; ++i) {\n        const segment = segments[i];\n\n        dest.push(segment);\n        if (others.indexOf(segment) === -1) {\n            all.push(segment);\n        }\n    }\n}\n\n/**\n * Gets a loop-context for a `continue` statement.\n * @param {CodePathState} state A state to get.\n * @param {string} label The label of a `continue` statement.\n * @returns {LoopContext} A loop-context for a `continue` statement.\n */\nfunction getContinueContext(state, label) {\n    if (!label) {\n        return state.loopContext;\n    }\n\n    let context = state.loopContext;\n\n    while (context) {\n        if (context.label === label) {\n            return context;\n        }\n        context = context.upper;\n    }\n\n    /* istanbul ignore next: foolproof (syntax error) */\n    return null;\n}\n\n/**\n * Gets a context for a `break` statement.\n * @param {CodePathState} state A state to get.\n * @param {string} label The label of a `break` statement.\n * @returns {LoopContext|SwitchContext} A context for a `break` statement.\n */\nfunction getBreakContext(state, label) {\n    let context = state.breakContext;\n\n    while (context) {\n        if (label ? context.label === label : context.breakable) {\n            return context;\n        }\n        context = context.upper;\n    }\n\n    /* istanbul ignore next: foolproof (syntax error) */\n    return null;\n}\n\n/**\n * Gets a context for a `return` statement.\n * @param {CodePathState} state A state to get.\n * @returns {TryContext|CodePathState} A context for a `return` statement.\n */\nfunction getReturnContext(state) {\n    let context = state.tryContext;\n\n    while (context) {\n        if (context.hasFinalizer && context.position !== \"finally\") {\n            return context;\n        }\n        context = context.upper;\n    }\n\n    return state;\n}\n\n/**\n * Gets a context for a `throw` statement.\n * @param {CodePathState} state A state to get.\n * @returns {TryContext|CodePathState} A context for a `throw` statement.\n */\nfunction getThrowContext(state) {\n    let context = state.tryContext;\n\n    while (context) {\n        if (context.position === \"try\" ||\n            (context.hasFinalizer && context.position === \"catch\")\n        ) {\n            return context;\n        }\n        context = context.upper;\n    }\n\n    return state;\n}\n\n/**\n * Removes a given element from a given array.\n * @param {any[]} xs An array to remove the specific element.\n * @param {any} x An element to be removed.\n * @returns {void}\n */\nfunction remove$1(xs, x) {\n    xs.splice(xs.indexOf(x), 1);\n}\n\n/**\n * Disconnect given segments.\n *\n * This is used in a process for switch statements.\n * If there is the \"default\" chunk before other cases, the order is different\n * between node's and running's.\n * @param {CodePathSegment[]} prevSegments Forward segments to disconnect.\n * @param {CodePathSegment[]} nextSegments Backward segments to disconnect.\n * @returns {void}\n */\nfunction removeConnection(prevSegments, nextSegments) {\n    for (let i = 0; i < prevSegments.length; ++i) {\n        const prevSegment = prevSegments[i];\n        const nextSegment = nextSegments[i];\n\n        remove$1(prevSegment.nextSegments, nextSegment);\n        remove$1(prevSegment.allNextSegments, nextSegment);\n        remove$1(nextSegment.prevSegments, prevSegment);\n        remove$1(nextSegment.allPrevSegments, prevSegment);\n    }\n}\n\n/**\n * Creates looping path.\n * @param {CodePathState} state The instance.\n * @param {CodePathSegment[]} unflattenedFromSegments Segments which are source.\n * @param {CodePathSegment[]} unflattenedToSegments Segments which are destination.\n * @returns {void}\n */\nfunction makeLooped(state, unflattenedFromSegments, unflattenedToSegments) {\n    const fromSegments = codePathSegment.flattenUnusedSegments(unflattenedFromSegments);\n    const toSegments = codePathSegment.flattenUnusedSegments(unflattenedToSegments);\n\n    const end = Math.min(fromSegments.length, toSegments.length);\n\n    for (let i = 0; i < end; ++i) {\n        const fromSegment = fromSegments[i];\n        const toSegment = toSegments[i];\n\n        if (toSegment.reachable) {\n            fromSegment.nextSegments.push(toSegment);\n        }\n        if (fromSegment.reachable) {\n            toSegment.prevSegments.push(fromSegment);\n        }\n        fromSegment.allNextSegments.push(toSegment);\n        toSegment.allPrevSegments.push(fromSegment);\n\n        if (toSegment.allPrevSegments.length >= 2) {\n            codePathSegment.markPrevSegmentAsLooped(toSegment, fromSegment);\n        }\n\n        state.notifyLooped(fromSegment, toSegment);\n    }\n}\n\n/**\n * Finalizes segments of `test` chunk of a ForStatement.\n *\n * - Adds `false` paths to paths which are leaving from the loop.\n * - Sets `true` paths to paths which go to the body.\n * @param {LoopContext} context A loop context to modify.\n * @param {ChoiceContext} choiceContext A choice context of this loop.\n * @param {CodePathSegment[]} head The current head paths.\n * @returns {void}\n */\nfunction finalizeTestSegmentsOfFor(context, choiceContext, head) {\n    if (!choiceContext.processed) {\n        choiceContext.trueForkContext.add(head);\n        choiceContext.falseForkContext.add(head);\n    }\n\n    if (context.test !== true) {\n        context.brokenForkContext.addAll(choiceContext.falseForkContext);\n    }\n    context.endOfTestSegments = choiceContext.trueForkContext.makeNext(0, -1);\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * A class which manages state to analyze code paths.\n */\nclass CodePathState {\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @param {IdGenerator} idGenerator An id generator to generate id for code\n     *   path segments.\n     * @param {Function} onLooped A callback function to notify looping.\n     */\n    constructor(idGenerator, onLooped) {\n        this.idGenerator = idGenerator;\n        this.notifyLooped = onLooped;\n        this.forkContext = forkContext.newRoot(idGenerator);\n        this.choiceContext = null;\n        this.switchContext = null;\n        this.tryContext = null;\n        this.loopContext = null;\n        this.breakContext = null;\n\n        this.currentSegments = [];\n        this.initialSegment = this.forkContext.head[0];\n\n        // returnedSegments and thrownSegments push elements into finalSegments also.\n        const final = this.finalSegments = [];\n        const returned = this.returnedForkContext = [];\n        const thrown = this.thrownForkContext = [];\n\n        returned.add = addToReturnedOrThrown.bind(null, returned, thrown, final);\n        thrown.add = addToReturnedOrThrown.bind(null, thrown, returned, final);\n    }\n\n    /**\n     * The head segments.\n     * @type {CodePathSegment[]}\n     */\n    get headSegments() {\n        return this.forkContext.head;\n    }\n\n    /**\n     * The parent forking context.\n     * This is used for the root of new forks.\n     * @type {ForkContext}\n     */\n    get parentForkContext() {\n        const current = this.forkContext;\n\n        return current && current.upper;\n    }\n\n    /**\n     * Creates and stacks new forking context.\n     * @param {boolean} forkLeavingPath A flag which shows being in a\n     *   \"finally\" block.\n     * @returns {ForkContext} The created context.\n     */\n    pushForkContext(forkLeavingPath) {\n        this.forkContext = forkContext.newEmpty(\n            this.forkContext,\n            forkLeavingPath\n        );\n\n        return this.forkContext;\n    }\n\n    /**\n     * Pops and merges the last forking context.\n     * @returns {ForkContext} The last context.\n     */\n    popForkContext() {\n        const lastContext = this.forkContext;\n\n        this.forkContext = lastContext.upper;\n        this.forkContext.replaceHead(lastContext.makeNext(0, -1));\n\n        return lastContext;\n    }\n\n    /**\n     * Creates a new path.\n     * @returns {void}\n     */\n    forkPath() {\n        this.forkContext.add(this.parentForkContext.makeNext(-1, -1));\n    }\n\n    /**\n     * Creates a bypass path.\n     * This is used for such as IfStatement which does not have \"else\" chunk.\n     * @returns {void}\n     */\n    forkBypassPath() {\n        this.forkContext.add(this.parentForkContext.head);\n    }\n\n    //--------------------------------------------------------------------------\n    // ConditionalExpression, LogicalExpression, IfStatement\n    //--------------------------------------------------------------------------\n\n    /**\n     * Creates a context for ConditionalExpression, LogicalExpression,\n     * IfStatement, WhileStatement, DoWhileStatement, or ForStatement.\n     *\n     * LogicalExpressions have cases that it goes different paths between the\n     * `true` case and the `false` case.\n     *\n     * For Example:\n     *\n     *     if (a || b) {\n     *         foo();\n     *     } else {\n     *         bar();\n     *     }\n     *\n     * In this case, `b` is evaluated always in the code path of the `else`\n     * block, but it's not so in the code path of the `if` block.\n     * So there are 3 paths.\n     *\n     *     a -> foo();\n     *     a -> b -> foo();\n     *     a -> b -> bar();\n     * @param {string} kind A kind string.\n     *   If the new context is LogicalExpression's, this is `\"&&\"` or `\"||\"`.\n     *   If it's IfStatement's or ConditionalExpression's, this is `\"test\"`.\n     *   Otherwise, this is `\"loop\"`.\n     * @param {boolean} isForkingAsResult A flag that shows that goes different\n     *   paths between `true` and `false`.\n     * @returns {void}\n     */\n    pushChoiceContext(kind, isForkingAsResult) {\n        this.choiceContext = {\n            upper: this.choiceContext,\n            kind,\n            isForkingAsResult,\n            trueForkContext: forkContext.newEmpty(this.forkContext),\n            falseForkContext: forkContext.newEmpty(this.forkContext),\n            processed: false\n        };\n    }\n\n    /**\n     * Pops the last choice context and finalizes it.\n     * @returns {ChoiceContext} The popped context.\n     */\n    popChoiceContext() {\n        const context = this.choiceContext;\n\n        this.choiceContext = context.upper;\n\n        const forkContext = this.forkContext;\n        const headSegments = forkContext.head;\n\n        switch (context.kind) {\n            case \"&&\":\n            case \"||\":\n\n                /*\n                 * If any result were not transferred from child contexts,\n                 * this sets the head segments to both cases.\n                 * The head segments are the path of the right-hand operand.\n                 */\n                if (!context.processed) {\n                    context.trueForkContext.add(headSegments);\n                    context.falseForkContext.add(headSegments);\n                }\n\n                /*\n                 * Transfers results to upper context if this context is in\n                 * test chunk.\n                 */\n                if (context.isForkingAsResult) {\n                    const parentContext = this.choiceContext;\n\n                    parentContext.trueForkContext.addAll(context.trueForkContext);\n                    parentContext.falseForkContext.addAll(context.falseForkContext);\n                    parentContext.processed = true;\n\n                    return context;\n                }\n\n                break;\n\n            case \"test\":\n                if (!context.processed) {\n\n                    /*\n                     * The head segments are the path of the `if` block here.\n                     * Updates the `true` path with the end of the `if` block.\n                     */\n                    context.trueForkContext.clear();\n                    context.trueForkContext.add(headSegments);\n                } else {\n\n                    /*\n                     * The head segments are the path of the `else` block here.\n                     * Updates the `false` path with the end of the `else`\n                     * block.\n                     */\n                    context.falseForkContext.clear();\n                    context.falseForkContext.add(headSegments);\n                }\n\n                break;\n\n            case \"loop\":\n\n                /*\n                 * Loops are addressed in popLoopContext().\n                 * This is called from popLoopContext().\n                 */\n                return context;\n\n            /* istanbul ignore next */\n            default:\n                throw new Error(\"unreachable\");\n        }\n\n        // Merges all paths.\n        const prevForkContext = context.trueForkContext;\n\n        prevForkContext.addAll(context.falseForkContext);\n        forkContext.replaceHead(prevForkContext.makeNext(0, -1));\n\n        return context;\n    }\n\n    /**\n     * Makes a code path segment of the right-hand operand of a logical\n     * expression.\n     * @returns {void}\n     */\n    makeLogicalRight() {\n        const context = this.choiceContext;\n        const forkContext = this.forkContext;\n\n        if (context.processed) {\n\n            /*\n             * This got segments already from the child choice context.\n             * Creates the next path from own true/false fork context.\n             */\n            const prevForkContext =\n                context.kind === \"&&\" ? context.trueForkContext\n                /* kind === \"||\" */ : context.falseForkContext;\n\n            forkContext.replaceHead(prevForkContext.makeNext(0, -1));\n            prevForkContext.clear();\n\n            context.processed = false;\n        } else {\n\n            /*\n             * This did not get segments from the child choice context.\n             * So addresses the head segments.\n             * The head segments are the path of the left-hand operand.\n             */\n            if (context.kind === \"&&\") {\n\n                // The path does short-circuit if false.\n                context.falseForkContext.add(forkContext.head);\n            } else {\n\n                // The path does short-circuit if true.\n                context.trueForkContext.add(forkContext.head);\n            }\n\n            forkContext.replaceHead(forkContext.makeNext(-1, -1));\n        }\n    }\n\n    /**\n     * Makes a code path segment of the `if` block.\n     * @returns {void}\n     */\n    makeIfConsequent() {\n        const context = this.choiceContext;\n        const forkContext = this.forkContext;\n\n        /*\n         * If any result were not transferred from child contexts,\n         * this sets the head segments to both cases.\n         * The head segments are the path of the test expression.\n         */\n        if (!context.processed) {\n            context.trueForkContext.add(forkContext.head);\n            context.falseForkContext.add(forkContext.head);\n        }\n\n        context.processed = false;\n\n        // Creates new path from the `true` case.\n        forkContext.replaceHead(\n            context.trueForkContext.makeNext(0, -1)\n        );\n    }\n\n    /**\n     * Makes a code path segment of the `else` block.\n     * @returns {void}\n     */\n    makeIfAlternate() {\n        const context = this.choiceContext;\n        const forkContext = this.forkContext;\n\n        /*\n         * The head segments are the path of the `if` block.\n         * Updates the `true` path with the end of the `if` block.\n         */\n        context.trueForkContext.clear();\n        context.trueForkContext.add(forkContext.head);\n        context.processed = true;\n\n        // Creates new path from the `false` case.\n        forkContext.replaceHead(\n            context.falseForkContext.makeNext(0, -1)\n        );\n    }\n\n    //--------------------------------------------------------------------------\n    // SwitchStatement\n    //--------------------------------------------------------------------------\n\n    /**\n     * Creates a context object of SwitchStatement and stacks it.\n     * @param {boolean} hasCase `true` if the switch statement has one or more\n     *   case parts.\n     * @param {string|null} label The label text.\n     * @returns {void}\n     */\n    pushSwitchContext(hasCase, label) {\n        this.switchContext = {\n            upper: this.switchContext,\n            hasCase,\n            defaultSegments: null,\n            defaultBodySegments: null,\n            foundDefault: false,\n            lastIsDefault: false,\n            countForks: 0\n        };\n\n        this.pushBreakContext(true, label);\n    }\n\n    /**\n     * Pops the last context of SwitchStatement and finalizes it.\n     *\n     * - Disposes all forking stack for `case` and `default`.\n     * - Creates the next code path segment from `context.brokenForkContext`.\n     * - If the last `SwitchCase` node is not a `default` part, creates a path\n     *   to the `default` body.\n     * @returns {void}\n     */\n    popSwitchContext() {\n        const context = this.switchContext;\n\n        this.switchContext = context.upper;\n\n        const forkContext = this.forkContext;\n        const brokenForkContext = this.popBreakContext().brokenForkContext;\n\n        if (context.countForks === 0) {\n\n            /*\n             * When there is only one `default` chunk and there is one or more\n             * `break` statements, even if forks are nothing, it needs to merge\n             * those.\n             */\n            if (!brokenForkContext.empty) {\n                brokenForkContext.add(forkContext.makeNext(-1, -1));\n                forkContext.replaceHead(brokenForkContext.makeNext(0, -1));\n            }\n\n            return;\n        }\n\n        const lastSegments = forkContext.head;\n\n        this.forkBypassPath();\n        const lastCaseSegments = forkContext.head;\n\n        /*\n         * `brokenForkContext` is used to make the next segment.\n         * It must add the last segment into `brokenForkContext`.\n         */\n        brokenForkContext.add(lastSegments);\n\n        /*\n         * A path which is failed in all case test should be connected to path\n         * of `default` chunk.\n         */\n        if (!context.lastIsDefault) {\n            if (context.defaultBodySegments) {\n\n                /*\n                 * Remove a link from `default` label to its chunk.\n                 * It's false route.\n                 */\n                removeConnection(context.defaultSegments, context.defaultBodySegments);\n                makeLooped(this, lastCaseSegments, context.defaultBodySegments);\n            } else {\n\n                /*\n                 * It handles the last case body as broken if `default` chunk\n                 * does not exist.\n                 */\n                brokenForkContext.add(lastCaseSegments);\n            }\n        }\n\n        // Pops the segment context stack until the entry segment.\n        for (let i = 0; i < context.countForks; ++i) {\n            this.forkContext = this.forkContext.upper;\n        }\n\n        /*\n         * Creates a path from all brokenForkContext paths.\n         * This is a path after switch statement.\n         */\n        this.forkContext.replaceHead(brokenForkContext.makeNext(0, -1));\n    }\n\n    /**\n     * Makes a code path segment for a `SwitchCase` node.\n     * @param {boolean} isEmpty `true` if the body is empty.\n     * @param {boolean} isDefault `true` if the body is the default case.\n     * @returns {void}\n     */\n    makeSwitchCaseBody(isEmpty, isDefault) {\n        const context = this.switchContext;\n\n        if (!context.hasCase) {\n            return;\n        }\n\n        /*\n         * Merge forks.\n         * The parent fork context has two segments.\n         * Those are from the current case and the body of the previous case.\n         */\n        const parentForkContext = this.forkContext;\n        const forkContext = this.pushForkContext();\n\n        forkContext.add(parentForkContext.makeNext(0, -1));\n\n        /*\n         * Save `default` chunk info.\n         * If the `default` label is not at the last, we must make a path from\n         * the last `case` to the `default` chunk.\n         */\n        if (isDefault) {\n            context.defaultSegments = parentForkContext.head;\n            if (isEmpty) {\n                context.foundDefault = true;\n            } else {\n                context.defaultBodySegments = forkContext.head;\n            }\n        } else {\n            if (!isEmpty && context.foundDefault) {\n                context.foundDefault = false;\n                context.defaultBodySegments = forkContext.head;\n            }\n        }\n\n        context.lastIsDefault = isDefault;\n        context.countForks += 1;\n    }\n\n    //--------------------------------------------------------------------------\n    // TryStatement\n    //--------------------------------------------------------------------------\n\n    /**\n     * Creates a context object of TryStatement and stacks it.\n     * @param {boolean} hasFinalizer `true` if the try statement has a\n     *   `finally` block.\n     * @returns {void}\n     */\n    pushTryContext(hasFinalizer) {\n        this.tryContext = {\n            upper: this.tryContext,\n            position: \"try\",\n            hasFinalizer,\n\n            returnedForkContext: hasFinalizer\n                ? forkContext.newEmpty(this.forkContext)\n                : null,\n\n            thrownForkContext: forkContext.newEmpty(this.forkContext),\n            lastOfTryIsReachable: false,\n            lastOfCatchIsReachable: false\n        };\n    }\n\n    /**\n     * Pops the last context of TryStatement and finalizes it.\n     * @returns {void}\n     */\n    popTryContext() {\n        const context = this.tryContext;\n\n        this.tryContext = context.upper;\n\n        if (context.position === \"catch\") {\n\n            // Merges two paths from the `try` block and `catch` block merely.\n            this.popForkContext();\n            return;\n        }\n\n        /*\n         * The following process is executed only when there is the `finally`\n         * block.\n         */\n\n        const returned = context.returnedForkContext;\n        const thrown = context.thrownForkContext;\n\n        if (returned.empty && thrown.empty) {\n            return;\n        }\n\n        // Separate head to normal paths and leaving paths.\n        const headSegments = this.forkContext.head;\n\n        this.forkContext = this.forkContext.upper;\n        const normalSegments = headSegments.slice(0, headSegments.length / 2 | 0);\n        const leavingSegments = headSegments.slice(headSegments.length / 2 | 0);\n\n        // Forwards the leaving path to upper contexts.\n        if (!returned.empty) {\n            getReturnContext(this).returnedForkContext.add(leavingSegments);\n        }\n        if (!thrown.empty) {\n            getThrowContext(this).thrownForkContext.add(leavingSegments);\n        }\n\n        // Sets the normal path as the next.\n        this.forkContext.replaceHead(normalSegments);\n\n        /*\n         * If both paths of the `try` block and the `catch` block are\n         * unreachable, the next path becomes unreachable as well.\n         */\n        if (!context.lastOfTryIsReachable && !context.lastOfCatchIsReachable) {\n            this.forkContext.makeUnreachable();\n        }\n    }\n\n    /**\n     * Makes a code path segment for a `catch` block.\n     * @returns {void}\n     */\n    makeCatchBlock() {\n        const context = this.tryContext;\n        const forkContext$1 = this.forkContext;\n        const thrown = context.thrownForkContext;\n\n        // Update state.\n        context.position = \"catch\";\n        context.thrownForkContext = forkContext.newEmpty(forkContext$1);\n        context.lastOfTryIsReachable = forkContext$1.reachable;\n\n        // Merge thrown paths.\n        thrown.add(forkContext$1.head);\n        const thrownSegments = thrown.makeNext(0, -1);\n\n        // Fork to a bypass and the merged thrown path.\n        this.pushForkContext();\n        this.forkBypassPath();\n        this.forkContext.add(thrownSegments);\n    }\n\n    /**\n     * Makes a code path segment for a `finally` block.\n     *\n     * In the `finally` block, parallel paths are created. The parallel paths\n     * are used as leaving-paths. The leaving-paths are paths from `return`\n     * statements and `throw` statements in a `try` block or a `catch` block.\n     * @returns {void}\n     */\n    makeFinallyBlock() {\n        const context = this.tryContext;\n        let forkContext = this.forkContext;\n        const returned = context.returnedForkContext;\n        const thrown = context.thrownForkContext;\n        const headOfLeavingSegments = forkContext.head;\n\n        // Update state.\n        if (context.position === \"catch\") {\n\n            // Merges two paths from the `try` block and `catch` block.\n            this.popForkContext();\n            forkContext = this.forkContext;\n\n            context.lastOfCatchIsReachable = forkContext.reachable;\n        } else {\n            context.lastOfTryIsReachable = forkContext.reachable;\n        }\n        context.position = \"finally\";\n\n        if (returned.empty && thrown.empty) {\n\n            // This path does not leave.\n            return;\n        }\n\n        /*\n         * Create a parallel segment from merging returned and thrown.\n         * This segment will leave at the end of this finally block.\n         */\n        const segments = forkContext.makeNext(-1, -1);\n\n        for (let i = 0; i < forkContext.count; ++i) {\n            const prevSegsOfLeavingSegment = [headOfLeavingSegments[i]];\n\n            for (let j = 0; j < returned.segmentsList.length; ++j) {\n                prevSegsOfLeavingSegment.push(returned.segmentsList[j][i]);\n            }\n            for (let j = 0; j < thrown.segmentsList.length; ++j) {\n                prevSegsOfLeavingSegment.push(thrown.segmentsList[j][i]);\n            }\n\n            segments.push(\n                codePathSegment.newNext(\n                    this.idGenerator.next(),\n                    prevSegsOfLeavingSegment\n                )\n            );\n        }\n\n        this.pushForkContext(true);\n        this.forkContext.add(segments);\n    }\n\n    /**\n     * Makes a code path segment from the first throwable node to the `catch`\n     * block or the `finally` block.\n     * @returns {void}\n     */\n    makeFirstThrowablePathInTryBlock() {\n        const forkContext = this.forkContext;\n\n        if (!forkContext.reachable) {\n            return;\n        }\n\n        const context = getThrowContext(this);\n\n        if (context === this ||\n            context.position !== \"try\" ||\n            !context.thrownForkContext.empty\n        ) {\n            return;\n        }\n\n        context.thrownForkContext.add(forkContext.head);\n        forkContext.replaceHead(forkContext.makeNext(-1, -1));\n    }\n\n    //--------------------------------------------------------------------------\n    // Loop Statements\n    //--------------------------------------------------------------------------\n\n    /**\n     * Creates a context object of a loop statement and stacks it.\n     * @param {string} type The type of the node which was triggered. One of\n     *   `WhileStatement`, `DoWhileStatement`, `ForStatement`, `ForInStatement`,\n     *   and `ForStatement`.\n     * @param {string|null} label A label of the node which was triggered.\n     * @returns {void}\n     */\n    pushLoopContext(type, label) {\n        const forkContext$1 = this.forkContext;\n        const breakContext = this.pushBreakContext(true, label);\n\n        switch (type) {\n            case \"WhileStatement\":\n                this.pushChoiceContext(\"loop\", false);\n                this.loopContext = {\n                    upper: this.loopContext,\n                    type,\n                    label,\n                    test: void 0,\n                    continueDestSegments: null,\n                    brokenForkContext: breakContext.brokenForkContext\n                };\n                break;\n\n            case \"DoWhileStatement\":\n                this.pushChoiceContext(\"loop\", false);\n                this.loopContext = {\n                    upper: this.loopContext,\n                    type,\n                    label,\n                    test: void 0,\n                    entrySegments: null,\n                    continueForkContext: forkContext.newEmpty(forkContext$1),\n                    brokenForkContext: breakContext.brokenForkContext\n                };\n                break;\n\n            case \"ForStatement\":\n                this.pushChoiceContext(\"loop\", false);\n                this.loopContext = {\n                    upper: this.loopContext,\n                    type,\n                    label,\n                    test: void 0,\n                    endOfInitSegments: null,\n                    testSegments: null,\n                    endOfTestSegments: null,\n                    updateSegments: null,\n                    endOfUpdateSegments: null,\n                    continueDestSegments: null,\n                    brokenForkContext: breakContext.brokenForkContext\n                };\n                break;\n\n            case \"ForInStatement\":\n            case \"ForOfStatement\":\n                this.loopContext = {\n                    upper: this.loopContext,\n                    type,\n                    label,\n                    prevSegments: null,\n                    leftSegments: null,\n                    endOfLeftSegments: null,\n                    continueDestSegments: null,\n                    brokenForkContext: breakContext.brokenForkContext\n                };\n                break;\n\n            /* istanbul ignore next */\n            default:\n                throw new Error(`unknown type: \"${type}\"`);\n        }\n    }\n\n    /**\n     * Pops the last context of a loop statement and finalizes it.\n     * @returns {void}\n     */\n    popLoopContext() {\n        const context = this.loopContext;\n\n        this.loopContext = context.upper;\n\n        const forkContext = this.forkContext;\n        const brokenForkContext = this.popBreakContext().brokenForkContext;\n\n        // Creates a looped path.\n        switch (context.type) {\n            case \"WhileStatement\":\n            case \"ForStatement\":\n                this.popChoiceContext();\n                makeLooped(\n                    this,\n                    forkContext.head,\n                    context.continueDestSegments\n                );\n                break;\n\n            case \"DoWhileStatement\": {\n                const choiceContext = this.popChoiceContext();\n\n                if (!choiceContext.processed) {\n                    choiceContext.trueForkContext.add(forkContext.head);\n                    choiceContext.falseForkContext.add(forkContext.head);\n                }\n                if (context.test !== true) {\n                    brokenForkContext.addAll(choiceContext.falseForkContext);\n                }\n\n                // `true` paths go to looping.\n                const segmentsList = choiceContext.trueForkContext.segmentsList;\n\n                for (let i = 0; i < segmentsList.length; ++i) {\n                    makeLooped(\n                        this,\n                        segmentsList[i],\n                        context.entrySegments\n                    );\n                }\n                break;\n            }\n\n            case \"ForInStatement\":\n            case \"ForOfStatement\":\n                brokenForkContext.add(forkContext.head);\n                makeLooped(\n                    this,\n                    forkContext.head,\n                    context.leftSegments\n                );\n                break;\n\n            /* istanbul ignore next */\n            default:\n                throw new Error(\"unreachable\");\n        }\n\n        // Go next.\n        if (brokenForkContext.empty) {\n            forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));\n        } else {\n            forkContext.replaceHead(brokenForkContext.makeNext(0, -1));\n        }\n    }\n\n    /**\n     * Makes a code path segment for the test part of a WhileStatement.\n     * @param {boolean|undefined} test The test value (only when constant).\n     * @returns {void}\n     */\n    makeWhileTest(test) {\n        const context = this.loopContext;\n        const forkContext = this.forkContext;\n        const testSegments = forkContext.makeNext(0, -1);\n\n        // Update state.\n        context.test = test;\n        context.continueDestSegments = testSegments;\n        forkContext.replaceHead(testSegments);\n    }\n\n    /**\n     * Makes a code path segment for the body part of a WhileStatement.\n     * @returns {void}\n     */\n    makeWhileBody() {\n        const context = this.loopContext;\n        const choiceContext = this.choiceContext;\n        const forkContext = this.forkContext;\n\n        if (!choiceContext.processed) {\n            choiceContext.trueForkContext.add(forkContext.head);\n            choiceContext.falseForkContext.add(forkContext.head);\n        }\n\n        // Update state.\n        if (context.test !== true) {\n            context.brokenForkContext.addAll(choiceContext.falseForkContext);\n        }\n        forkContext.replaceHead(choiceContext.trueForkContext.makeNext(0, -1));\n    }\n\n    /**\n     * Makes a code path segment for the body part of a DoWhileStatement.\n     * @returns {void}\n     */\n    makeDoWhileBody() {\n        const context = this.loopContext;\n        const forkContext = this.forkContext;\n        const bodySegments = forkContext.makeNext(-1, -1);\n\n        // Update state.\n        context.entrySegments = bodySegments;\n        forkContext.replaceHead(bodySegments);\n    }\n\n    /**\n     * Makes a code path segment for the test part of a DoWhileStatement.\n     * @param {boolean|undefined} test The test value (only when constant).\n     * @returns {void}\n     */\n    makeDoWhileTest(test) {\n        const context = this.loopContext;\n        const forkContext = this.forkContext;\n\n        context.test = test;\n\n        // Creates paths of `continue` statements.\n        if (!context.continueForkContext.empty) {\n            context.continueForkContext.add(forkContext.head);\n            const testSegments = context.continueForkContext.makeNext(0, -1);\n\n            forkContext.replaceHead(testSegments);\n        }\n    }\n\n    /**\n     * Makes a code path segment for the test part of a ForStatement.\n     * @param {boolean|undefined} test The test value (only when constant).\n     * @returns {void}\n     */\n    makeForTest(test) {\n        const context = this.loopContext;\n        const forkContext = this.forkContext;\n        const endOfInitSegments = forkContext.head;\n        const testSegments = forkContext.makeNext(-1, -1);\n\n        // Update state.\n        context.test = test;\n        context.endOfInitSegments = endOfInitSegments;\n        context.continueDestSegments = context.testSegments = testSegments;\n        forkContext.replaceHead(testSegments);\n    }\n\n    /**\n     * Makes a code path segment for the update part of a ForStatement.\n     * @returns {void}\n     */\n    makeForUpdate() {\n        const context = this.loopContext;\n        const choiceContext = this.choiceContext;\n        const forkContext = this.forkContext;\n\n        // Make the next paths of the test.\n        if (context.testSegments) {\n            finalizeTestSegmentsOfFor(\n                context,\n                choiceContext,\n                forkContext.head\n            );\n        } else {\n            context.endOfInitSegments = forkContext.head;\n        }\n\n        // Update state.\n        const updateSegments = forkContext.makeDisconnected(-1, -1);\n\n        context.continueDestSegments = context.updateSegments = updateSegments;\n        forkContext.replaceHead(updateSegments);\n    }\n\n    /**\n     * Makes a code path segment for the body part of a ForStatement.\n     * @returns {void}\n     */\n    makeForBody() {\n        const context = this.loopContext;\n        const choiceContext = this.choiceContext;\n        const forkContext$1 = this.forkContext;\n\n        // Update state.\n        if (context.updateSegments) {\n            context.endOfUpdateSegments = forkContext$1.head;\n\n            // `update` -> `test`\n            if (context.testSegments) {\n                makeLooped(\n                    this,\n                    context.endOfUpdateSegments,\n                    context.testSegments\n                );\n            }\n        } else if (context.testSegments) {\n            finalizeTestSegmentsOfFor(\n                context,\n                choiceContext,\n                forkContext$1.head\n            );\n        } else {\n            context.endOfInitSegments = forkContext$1.head;\n        }\n\n        let bodySegments = context.endOfTestSegments;\n\n        if (!bodySegments) {\n\n            /*\n             * If there is not the `test` part, the `body` path comes from the\n             * `init` part and the `update` part.\n             */\n            const prevForkContext = forkContext.newEmpty(forkContext$1);\n\n            prevForkContext.add(context.endOfInitSegments);\n            if (context.endOfUpdateSegments) {\n                prevForkContext.add(context.endOfUpdateSegments);\n            }\n\n            bodySegments = prevForkContext.makeNext(0, -1);\n        }\n        context.continueDestSegments = context.continueDestSegments || bodySegments;\n        forkContext$1.replaceHead(bodySegments);\n    }\n\n    /**\n     * Makes a code path segment for the left part of a ForInStatement and a\n     * ForOfStatement.\n     * @returns {void}\n     */\n    makeForInOfLeft() {\n        const context = this.loopContext;\n        const forkContext = this.forkContext;\n        const leftSegments = forkContext.makeDisconnected(-1, -1);\n\n        // Update state.\n        context.prevSegments = forkContext.head;\n        context.leftSegments = context.continueDestSegments = leftSegments;\n        forkContext.replaceHead(leftSegments);\n    }\n\n    /**\n     * Makes a code path segment for the right part of a ForInStatement and a\n     * ForOfStatement.\n     * @returns {void}\n     */\n    makeForInOfRight() {\n        const context = this.loopContext;\n        const forkContext$1 = this.forkContext;\n        const temp = forkContext.newEmpty(forkContext$1);\n\n        temp.add(context.prevSegments);\n        const rightSegments = temp.makeNext(-1, -1);\n\n        // Update state.\n        context.endOfLeftSegments = forkContext$1.head;\n        forkContext$1.replaceHead(rightSegments);\n    }\n\n    /**\n     * Makes a code path segment for the body part of a ForInStatement and a\n     * ForOfStatement.\n     * @returns {void}\n     */\n    makeForInOfBody() {\n        const context = this.loopContext;\n        const forkContext$1 = this.forkContext;\n        const temp = forkContext.newEmpty(forkContext$1);\n\n        temp.add(context.endOfLeftSegments);\n        const bodySegments = temp.makeNext(-1, -1);\n\n        // Make a path: `right` -> `left`.\n        makeLooped(this, forkContext$1.head, context.leftSegments);\n\n        // Update state.\n        context.brokenForkContext.add(forkContext$1.head);\n        forkContext$1.replaceHead(bodySegments);\n    }\n\n    //--------------------------------------------------------------------------\n    // Control Statements\n    //--------------------------------------------------------------------------\n\n    /**\n     * Creates new context for BreakStatement.\n     * @param {boolean} breakable The flag to indicate it can break by\n     *      an unlabeled BreakStatement.\n     * @param {string|null} label The label of this context.\n     * @returns {Object} The new context.\n     */\n    pushBreakContext(breakable, label) {\n        this.breakContext = {\n            upper: this.breakContext,\n            breakable,\n            label,\n            brokenForkContext: forkContext.newEmpty(this.forkContext)\n        };\n        return this.breakContext;\n    }\n\n    /**\n     * Removes the top item of the break context stack.\n     * @returns {Object} The removed context.\n     */\n    popBreakContext() {\n        const context = this.breakContext;\n        const forkContext = this.forkContext;\n\n        this.breakContext = context.upper;\n\n        // Process this context here for other than switches and loops.\n        if (!context.breakable) {\n            const brokenForkContext = context.brokenForkContext;\n\n            if (!brokenForkContext.empty) {\n                brokenForkContext.add(forkContext.head);\n                forkContext.replaceHead(brokenForkContext.makeNext(0, -1));\n            }\n        }\n\n        return context;\n    }\n\n    /**\n     * Makes a path for a `break` statement.\n     *\n     * It registers the head segment to a context of `break`.\n     * It makes new unreachable segment, then it set the head with the segment.\n     * @param {string} label A label of the break statement.\n     * @returns {void}\n     */\n    makeBreak(label) {\n        const forkContext = this.forkContext;\n\n        if (!forkContext.reachable) {\n            return;\n        }\n\n        const context = getBreakContext(this, label);\n\n        /* istanbul ignore else: foolproof (syntax error) */\n        if (context) {\n            context.brokenForkContext.add(forkContext.head);\n        }\n\n        forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));\n    }\n\n    /**\n     * Makes a path for a `continue` statement.\n     *\n     * It makes a looping path.\n     * It makes new unreachable segment, then it set the head with the segment.\n     * @param {string} label A label of the continue statement.\n     * @returns {void}\n     */\n    makeContinue(label) {\n        const forkContext = this.forkContext;\n\n        if (!forkContext.reachable) {\n            return;\n        }\n\n        const context = getContinueContext(this, label);\n\n        /* istanbul ignore else: foolproof (syntax error) */\n        if (context) {\n            if (context.continueDestSegments) {\n                makeLooped(this, forkContext.head, context.continueDestSegments);\n\n                // If the context is a for-in/of loop, this effects a break also.\n                if (context.type === \"ForInStatement\" ||\n                    context.type === \"ForOfStatement\"\n                ) {\n                    context.brokenForkContext.add(forkContext.head);\n                }\n            } else {\n                context.continueForkContext.add(forkContext.head);\n            }\n        }\n        forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));\n    }\n\n    /**\n     * Makes a path for a `return` statement.\n     *\n     * It registers the head segment to a context of `return`.\n     * It makes new unreachable segment, then it set the head with the segment.\n     * @returns {void}\n     */\n    makeReturn() {\n        const forkContext = this.forkContext;\n\n        if (forkContext.reachable) {\n            getReturnContext(this).returnedForkContext.add(forkContext.head);\n            forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));\n        }\n    }\n\n    /**\n     * Makes a path for a `throw` statement.\n     *\n     * It registers the head segment to a context of `throw`.\n     * It makes new unreachable segment, then it set the head with the segment.\n     * @returns {void}\n     */\n    makeThrow() {\n        const forkContext = this.forkContext;\n\n        if (forkContext.reachable) {\n            getThrowContext(this).thrownForkContext.add(forkContext.head);\n            forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));\n        }\n    }\n\n    /**\n     * Makes the final path.\n     * @returns {void}\n     */\n    makeFinal() {\n        const segments = this.currentSegments;\n\n        if (segments.length > 0 && segments[0].reachable) {\n            this.returnedForkContext.add(segments);\n        }\n    }\n}\n\nvar codePathState = CodePathState;\n\n/**\n * @fileoverview A class of identifiers generator for code path segments.\n *\n * Each rule uses the identifier of code path segments to store additional\n * information of the code path.\n *\n * @author Toru Nagashima\n */\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * A generator for unique ids.\n */\nclass IdGenerator {\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @param {string} prefix Optional. A prefix of generated ids.\n     */\n    constructor(prefix) {\n        this.prefix = String(prefix);\n        this.n = 0;\n    }\n\n    /**\n     * Generates id.\n     * @returns {string} A generated id.\n     */\n    next() {\n        this.n = 1 + this.n | 0;\n\n        /* istanbul ignore if */\n        if (this.n < 0) {\n            this.n = 1;\n        }\n\n        return this.prefix + this.n;\n    }\n}\n\nvar idGenerator = IdGenerator;\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * A code path.\n */\nclass CodePath {\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @param {string} id An identifier.\n     * @param {CodePath|null} upper The code path of the upper function scope.\n     * @param {Function} onLooped A callback function to notify looping.\n     */\n    constructor(id, upper, onLooped) {\n\n        /**\n         * The identifier of this code path.\n         * Rules use it to store additional information of each rule.\n         * @type {string}\n         */\n        this.id = id;\n\n        /**\n         * The code path of the upper function scope.\n         * @type {CodePath|null}\n         */\n        this.upper = upper;\n\n        /**\n         * The code paths of nested function scopes.\n         * @type {CodePath[]}\n         */\n        this.childCodePaths = [];\n\n        // Initializes internal state.\n        Object.defineProperty(\n            this,\n            \"internal\",\n            { value: new codePathState(new idGenerator(`${id}_`), onLooped) }\n        );\n\n        // Adds this into `childCodePaths` of `upper`.\n        if (upper) {\n            upper.childCodePaths.push(this);\n        }\n    }\n\n    /**\n     * Gets the state of a given code path.\n     * @param {CodePath} codePath A code path to get.\n     * @returns {CodePathState} The state of the code path.\n     */\n    static getState(codePath) {\n        return codePath.internal;\n    }\n\n    /**\n     * The initial code path segment.\n     * @type {CodePathSegment}\n     */\n    get initialSegment() {\n        return this.internal.initialSegment;\n    }\n\n    /**\n     * Final code path segments.\n     * This array is a mix of `returnedSegments` and `thrownSegments`.\n     * @type {CodePathSegment[]}\n     */\n    get finalSegments() {\n        return this.internal.finalSegments;\n    }\n\n    /**\n     * Final code path segments which is with `return` statements.\n     * This array contains the last path segment if it's reachable.\n     * Since the reachable last path returns `undefined`.\n     * @type {CodePathSegment[]}\n     */\n    get returnedSegments() {\n        return this.internal.returnedForkContext;\n    }\n\n    /**\n     * Final code path segments which is with `throw` statements.\n     * @type {CodePathSegment[]}\n     */\n    get thrownSegments() {\n        return this.internal.thrownForkContext;\n    }\n\n    /**\n     * Current code path segments.\n     * @type {CodePathSegment[]}\n     */\n    get currentSegments() {\n        return this.internal.currentSegments;\n    }\n\n    /**\n     * Traverses all segments in this code path.\n     *\n     *     codePath.traverseSegments(function(segment, controller) {\n     *         // do something.\n     *     });\n     *\n     * This method enumerates segments in order from the head.\n     *\n     * The `controller` object has two methods.\n     *\n     * - `controller.skip()` - Skip the following segments in this branch.\n     * - `controller.break()` - Skip all following segments.\n     * @param {Object} [options] Omittable.\n     * @param {CodePathSegment} [options.first] The first segment to traverse.\n     * @param {CodePathSegment} [options.last] The last segment to traverse.\n     * @param {Function} callback A callback function.\n     * @returns {void}\n     */\n    traverseSegments(options, callback) {\n        let resolvedOptions;\n        let resolvedCallback;\n\n        if (typeof options === \"function\") {\n            resolvedCallback = options;\n            resolvedOptions = {};\n        } else {\n            resolvedOptions = options || {};\n            resolvedCallback = callback;\n        }\n\n        const startSegment = resolvedOptions.first || this.internal.initialSegment;\n        const lastSegment = resolvedOptions.last;\n\n        let item = null;\n        let index = 0;\n        let end = 0;\n        let segment = null;\n        const visited = Object.create(null);\n        const stack = [[startSegment, 0]];\n        let skippedSegment = null;\n        let broken = false;\n        const controller = {\n            skip() {\n                if (stack.length <= 1) {\n                    broken = true;\n                } else {\n                    skippedSegment = stack[stack.length - 2][0];\n                }\n            },\n            break() {\n                broken = true;\n            }\n        };\n\n        /**\n         * Checks a given previous segment has been visited.\n         * @param {CodePathSegment} prevSegment A previous segment to check.\n         * @returns {boolean} `true` if the segment has been visited.\n         */\n        function isVisited(prevSegment) {\n            return (\n                visited[prevSegment.id] ||\n                segment.isLoopedPrevSegment(prevSegment)\n            );\n        }\n\n        while (stack.length > 0) {\n            item = stack[stack.length - 1];\n            segment = item[0];\n            index = item[1];\n\n            if (index === 0) {\n\n                // Skip if this segment has been visited already.\n                if (visited[segment.id]) {\n                    stack.pop();\n                    continue;\n                }\n\n                // Skip if all previous segments have not been visited.\n                if (segment !== startSegment &&\n                    segment.prevSegments.length > 0 &&\n                    !segment.prevSegments.every(isVisited)\n                ) {\n                    stack.pop();\n                    continue;\n                }\n\n                // Reset the flag of skipping if all branches have been skipped.\n                if (skippedSegment && segment.prevSegments.indexOf(skippedSegment) !== -1) {\n                    skippedSegment = null;\n                }\n                visited[segment.id] = true;\n\n                // Call the callback when the first time.\n                if (!skippedSegment) {\n                    resolvedCallback.call(this, segment, controller);\n                    if (segment === lastSegment) {\n                        controller.skip();\n                    }\n                    if (broken) {\n                        break;\n                    }\n                }\n            }\n\n            // Update the stack.\n            end = segment.nextSegments.length - 1;\n            if (index < end) {\n                item[1] += 1;\n                stack.push([segment.nextSegments[index], 0]);\n            } else if (index === end) {\n                item[0] = segment.nextSegments[index];\n                item[1] = 0;\n            } else {\n                stack.pop();\n            }\n        }\n    }\n}\n\nvar codePath = CodePath;\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nconst { breakableTypePattern: breakableTypePattern$1 } = astUtils;\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Checks whether or not a given node is a `case` node (not `default` node).\n * @param {ASTNode} node A `SwitchCase` node to check.\n * @returns {boolean} `true` if the node is a `case` node (not `default` node).\n */\nfunction isCaseNode(node) {\n    return Boolean(node.test);\n}\n\n/**\n * Checks whether the given logical operator is taken into account for the code\n * path analysis.\n * @param {string} operator The operator found in the LogicalExpression node\n * @returns {boolean} `true` if the operator is \"&&\" or \"||\"\n */\nfunction isHandledLogicalOperator(operator) {\n    return operator === \"&&\" || operator === \"||\";\n}\n\n/**\n * Gets the label if the parent node of a given node is a LabeledStatement.\n * @param {ASTNode} node A node to get.\n * @returns {string|null} The label or `null`.\n */\nfunction getLabel(node) {\n    if (node.parent.type === \"LabeledStatement\") {\n        return node.parent.label.name;\n    }\n    return null;\n}\n\n/**\n * Checks whether or not a given logical expression node goes different path\n * between the `true` case and the `false` case.\n * @param {ASTNode} node A node to check.\n * @returns {boolean} `true` if the node is a test of a choice statement.\n */\nfunction isForkingByTrueOrFalse(node) {\n    const parent = node.parent;\n\n    switch (parent.type) {\n        case \"ConditionalExpression\":\n        case \"IfStatement\":\n        case \"WhileStatement\":\n        case \"DoWhileStatement\":\n        case \"ForStatement\":\n            return parent.test === node;\n\n        case \"LogicalExpression\":\n            return isHandledLogicalOperator(parent.operator);\n\n        default:\n            return false;\n    }\n}\n\n/**\n * Gets the boolean value of a given literal node.\n *\n * This is used to detect infinity loops (e.g. `while (true) {}`).\n * Statements preceded by an infinity loop are unreachable if the loop didn't\n * have any `break` statement.\n * @param {ASTNode} node A node to get.\n * @returns {boolean|undefined} a boolean value if the node is a Literal node,\n *   otherwise `undefined`.\n */\nfunction getBooleanValueIfSimpleConstant(node) {\n    if (node.type === \"Literal\") {\n        return Boolean(node.value);\n    }\n    return void 0;\n}\n\n/**\n * Checks that a given identifier node is a reference or not.\n *\n * This is used to detect the first throwable node in a `try` block.\n * @param {ASTNode} node An Identifier node to check.\n * @returns {boolean} `true` if the node is a reference.\n */\nfunction isIdentifierReference(node) {\n    const parent = node.parent;\n\n    switch (parent.type) {\n        case \"LabeledStatement\":\n        case \"BreakStatement\":\n        case \"ContinueStatement\":\n        case \"ArrayPattern\":\n        case \"RestElement\":\n        case \"ImportSpecifier\":\n        case \"ImportDefaultSpecifier\":\n        case \"ImportNamespaceSpecifier\":\n        case \"CatchClause\":\n            return false;\n\n        case \"FunctionDeclaration\":\n        case \"FunctionExpression\":\n        case \"ArrowFunctionExpression\":\n        case \"ClassDeclaration\":\n        case \"ClassExpression\":\n        case \"VariableDeclarator\":\n            return parent.id !== node;\n\n        case \"Property\":\n        case \"MethodDefinition\":\n            return (\n                parent.key !== node ||\n                parent.computed ||\n                parent.shorthand\n            );\n\n        case \"AssignmentPattern\":\n            return parent.key !== node;\n\n        default:\n            return true;\n    }\n}\n\n/**\n * Updates the current segment with the head segment.\n * This is similar to local branches and tracking branches of git.\n *\n * To separate the current and the head is in order to not make useless segments.\n *\n * In this process, both \"onCodePathSegmentStart\" and \"onCodePathSegmentEnd\"\n * events are fired.\n * @param {CodePathAnalyzer} analyzer The instance.\n * @param {ASTNode} node The current AST node.\n * @returns {void}\n */\nfunction forwardCurrentToHead(analyzer, node) {\n    const codePath$1 = analyzer.codePath;\n    const state = codePath.getState(codePath$1);\n    const currentSegments = state.currentSegments;\n    const headSegments = state.headSegments;\n    const end = Math.max(currentSegments.length, headSegments.length);\n    let i, currentSegment, headSegment;\n\n    // Fires leaving events.\n    for (i = 0; i < end; ++i) {\n        currentSegment = currentSegments[i];\n        headSegment = headSegments[i];\n\n        if (currentSegment !== headSegment && currentSegment) {\n            debugHelpers.dump(`onCodePathSegmentEnd ${currentSegment.id}`);\n\n            if (currentSegment.reachable) {\n                analyzer.emitter.emit(\n                    \"onCodePathSegmentEnd\",\n                    currentSegment,\n                    node\n                );\n            }\n        }\n    }\n\n    // Update state.\n    state.currentSegments = headSegments;\n\n    // Fires entering events.\n    for (i = 0; i < end; ++i) {\n        currentSegment = currentSegments[i];\n        headSegment = headSegments[i];\n\n        if (currentSegment !== headSegment && headSegment) {\n            debugHelpers.dump(`onCodePathSegmentStart ${headSegment.id}`);\n\n            codePathSegment.markUsed(headSegment);\n            if (headSegment.reachable) {\n                analyzer.emitter.emit(\n                    \"onCodePathSegmentStart\",\n                    headSegment,\n                    node\n                );\n            }\n        }\n    }\n\n}\n\n/**\n * Updates the current segment with empty.\n * This is called at the last of functions or the program.\n * @param {CodePathAnalyzer} analyzer The instance.\n * @param {ASTNode} node The current AST node.\n * @returns {void}\n */\nfunction leaveFromCurrentSegment(analyzer, node) {\n    const state = codePath.getState(analyzer.codePath);\n    const currentSegments = state.currentSegments;\n\n    for (let i = 0; i < currentSegments.length; ++i) {\n        const currentSegment = currentSegments[i];\n\n        debugHelpers.dump(`onCodePathSegmentEnd ${currentSegment.id}`);\n        if (currentSegment.reachable) {\n            analyzer.emitter.emit(\n                \"onCodePathSegmentEnd\",\n                currentSegment,\n                node\n            );\n        }\n    }\n\n    state.currentSegments = [];\n}\n\n/**\n * Updates the code path due to the position of a given node in the parent node\n * thereof.\n *\n * For example, if the node is `parent.consequent`, this creates a fork from the\n * current path.\n * @param {CodePathAnalyzer} analyzer The instance.\n * @param {ASTNode} node The current AST node.\n * @returns {void}\n */\nfunction preprocess(analyzer, node) {\n    const codePath$1 = analyzer.codePath;\n    const state = codePath.getState(codePath$1);\n    const parent = node.parent;\n\n    switch (parent.type) {\n        case \"LogicalExpression\":\n            if (\n                parent.right === node &&\n                isHandledLogicalOperator(parent.operator)\n            ) {\n                state.makeLogicalRight();\n            }\n            break;\n\n        case \"ConditionalExpression\":\n        case \"IfStatement\":\n\n            /*\n             * Fork if this node is at `consequent`/`alternate`.\n             * `popForkContext()` exists at `IfStatement:exit` and\n             * `ConditionalExpression:exit`.\n             */\n            if (parent.consequent === node) {\n                state.makeIfConsequent();\n            } else if (parent.alternate === node) {\n                state.makeIfAlternate();\n            }\n            break;\n\n        case \"SwitchCase\":\n            if (parent.consequent[0] === node) {\n                state.makeSwitchCaseBody(false, !parent.test);\n            }\n            break;\n\n        case \"TryStatement\":\n            if (parent.handler === node) {\n                state.makeCatchBlock();\n            } else if (parent.finalizer === node) {\n                state.makeFinallyBlock();\n            }\n            break;\n\n        case \"WhileStatement\":\n            if (parent.test === node) {\n                state.makeWhileTest(getBooleanValueIfSimpleConstant(node));\n            } else {\n                assert(parent.body === node);\n                state.makeWhileBody();\n            }\n            break;\n\n        case \"DoWhileStatement\":\n            if (parent.body === node) {\n                state.makeDoWhileBody();\n            } else {\n                assert(parent.test === node);\n                state.makeDoWhileTest(getBooleanValueIfSimpleConstant(node));\n            }\n            break;\n\n        case \"ForStatement\":\n            if (parent.test === node) {\n                state.makeForTest(getBooleanValueIfSimpleConstant(node));\n            } else if (parent.update === node) {\n                state.makeForUpdate();\n            } else if (parent.body === node) {\n                state.makeForBody();\n            }\n            break;\n\n        case \"ForInStatement\":\n        case \"ForOfStatement\":\n            if (parent.left === node) {\n                state.makeForInOfLeft();\n            } else if (parent.right === node) {\n                state.makeForInOfRight();\n            } else {\n                assert(parent.body === node);\n                state.makeForInOfBody();\n            }\n            break;\n\n        case \"AssignmentPattern\":\n\n            /*\n             * Fork if this node is at `right`.\n             * `left` is executed always, so it uses the current path.\n             * `popForkContext()` exists at `AssignmentPattern:exit`.\n             */\n            if (parent.right === node) {\n                state.pushForkContext();\n                state.forkBypassPath();\n                state.forkPath();\n            }\n            break;\n    }\n}\n\n/**\n * Updates the code path due to the type of a given node in entering.\n * @param {CodePathAnalyzer} analyzer The instance.\n * @param {ASTNode} node The current AST node.\n * @returns {void}\n */\nfunction processCodePathToEnter(analyzer, node) {\n    let codePath$1 = analyzer.codePath;\n    let state = codePath$1 && codePath.getState(codePath$1);\n    const parent = node.parent;\n\n    switch (node.type) {\n        case \"Program\":\n        case \"FunctionDeclaration\":\n        case \"FunctionExpression\":\n        case \"ArrowFunctionExpression\":\n            if (codePath$1) {\n\n                // Emits onCodePathSegmentStart events if updated.\n                forwardCurrentToHead(analyzer, node);\n                debugHelpers.dumpState(node, state, false);\n            }\n\n            // Create the code path of this scope.\n            codePath$1 = analyzer.codePath = new codePath(\n                analyzer.idGenerator.next(),\n                codePath$1,\n                analyzer.onLooped\n            );\n            state = codePath.getState(codePath$1);\n\n            // Emits onCodePathStart events.\n            debugHelpers.dump(`onCodePathStart ${codePath$1.id}`);\n            analyzer.emitter.emit(\"onCodePathStart\", codePath$1, node);\n            break;\n\n        case \"LogicalExpression\":\n            if (isHandledLogicalOperator(node.operator)) {\n                state.pushChoiceContext(\n                    node.operator,\n                    isForkingByTrueOrFalse(node)\n                );\n            }\n            break;\n\n        case \"ConditionalExpression\":\n        case \"IfStatement\":\n            state.pushChoiceContext(\"test\", false);\n            break;\n\n        case \"SwitchStatement\":\n            state.pushSwitchContext(\n                node.cases.some(isCaseNode),\n                getLabel(node)\n            );\n            break;\n\n        case \"TryStatement\":\n            state.pushTryContext(Boolean(node.finalizer));\n            break;\n\n        case \"SwitchCase\":\n\n            /*\n             * Fork if this node is after the 2st node in `cases`.\n             * It's similar to `else` blocks.\n             * The next `test` node is processed in this path.\n             */\n            if (parent.discriminant !== node && parent.cases[0] !== node) {\n                state.forkPath();\n            }\n            break;\n\n        case \"WhileStatement\":\n        case \"DoWhileStatement\":\n        case \"ForStatement\":\n        case \"ForInStatement\":\n        case \"ForOfStatement\":\n            state.pushLoopContext(node.type, getLabel(node));\n            break;\n\n        case \"LabeledStatement\":\n            if (!breakableTypePattern$1.test(node.body.type)) {\n                state.pushBreakContext(false, node.label.name);\n            }\n            break;\n    }\n\n    // Emits onCodePathSegmentStart events if updated.\n    forwardCurrentToHead(analyzer, node);\n    debugHelpers.dumpState(node, state, false);\n}\n\n/**\n * Updates the code path due to the type of a given node in leaving.\n * @param {CodePathAnalyzer} analyzer The instance.\n * @param {ASTNode} node The current AST node.\n * @returns {void}\n */\nfunction processCodePathToExit(analyzer, node) {\n    const codePath$1 = analyzer.codePath;\n    const state = codePath.getState(codePath$1);\n    let dontForward = false;\n\n    switch (node.type) {\n        case \"IfStatement\":\n        case \"ConditionalExpression\":\n            state.popChoiceContext();\n            break;\n\n        case \"LogicalExpression\":\n            if (isHandledLogicalOperator(node.operator)) {\n                state.popChoiceContext();\n            }\n            break;\n\n        case \"SwitchStatement\":\n            state.popSwitchContext();\n            break;\n\n        case \"SwitchCase\":\n\n            /*\n             * This is the same as the process at the 1st `consequent` node in\n             * `preprocess` function.\n             * Must do if this `consequent` is empty.\n             */\n            if (node.consequent.length === 0) {\n                state.makeSwitchCaseBody(true, !node.test);\n            }\n            if (state.forkContext.reachable) {\n                dontForward = true;\n            }\n            break;\n\n        case \"TryStatement\":\n            state.popTryContext();\n            break;\n\n        case \"BreakStatement\":\n            forwardCurrentToHead(analyzer, node);\n            state.makeBreak(node.label && node.label.name);\n            dontForward = true;\n            break;\n\n        case \"ContinueStatement\":\n            forwardCurrentToHead(analyzer, node);\n            state.makeContinue(node.label && node.label.name);\n            dontForward = true;\n            break;\n\n        case \"ReturnStatement\":\n            forwardCurrentToHead(analyzer, node);\n            state.makeReturn();\n            dontForward = true;\n            break;\n\n        case \"ThrowStatement\":\n            forwardCurrentToHead(analyzer, node);\n            state.makeThrow();\n            dontForward = true;\n            break;\n\n        case \"Identifier\":\n            if (isIdentifierReference(node)) {\n                state.makeFirstThrowablePathInTryBlock();\n                dontForward = true;\n            }\n            break;\n\n        case \"CallExpression\":\n        case \"ImportExpression\":\n        case \"MemberExpression\":\n        case \"NewExpression\":\n            state.makeFirstThrowablePathInTryBlock();\n            break;\n\n        case \"WhileStatement\":\n        case \"DoWhileStatement\":\n        case \"ForStatement\":\n        case \"ForInStatement\":\n        case \"ForOfStatement\":\n            state.popLoopContext();\n            break;\n\n        case \"AssignmentPattern\":\n            state.popForkContext();\n            break;\n\n        case \"LabeledStatement\":\n            if (!breakableTypePattern$1.test(node.body.type)) {\n                state.popBreakContext();\n            }\n            break;\n    }\n\n    // Emits onCodePathSegmentStart events if updated.\n    if (!dontForward) {\n        forwardCurrentToHead(analyzer, node);\n    }\n    debugHelpers.dumpState(node, state, true);\n}\n\n/**\n * Updates the code path to finalize the current code path.\n * @param {CodePathAnalyzer} analyzer The instance.\n * @param {ASTNode} node The current AST node.\n * @returns {void}\n */\nfunction postprocess(analyzer, node) {\n    switch (node.type) {\n        case \"Program\":\n        case \"FunctionDeclaration\":\n        case \"FunctionExpression\":\n        case \"ArrowFunctionExpression\": {\n            let codePath$1 = analyzer.codePath;\n\n            // Mark the current path as the final node.\n            codePath.getState(codePath$1).makeFinal();\n\n            // Emits onCodePathSegmentEnd event of the current segments.\n            leaveFromCurrentSegment(analyzer, node);\n\n            // Emits onCodePathEnd event of this code path.\n            debugHelpers.dump(`onCodePathEnd ${codePath$1.id}`);\n            analyzer.emitter.emit(\"onCodePathEnd\", codePath$1, node);\n            debugHelpers.dumpDot(codePath$1);\n\n            codePath$1 = analyzer.codePath = analyzer.codePath.upper;\n            if (codePath$1) {\n                debugHelpers.dumpState(node, codePath.getState(codePath$1), true);\n            }\n            break;\n        }\n    }\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * The class to analyze code paths.\n * This class implements the EventGenerator interface.\n */\nclass CodePathAnalyzer {\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @param {EventGenerator} eventGenerator An event generator to wrap.\n     */\n    constructor(eventGenerator) {\n        this.original = eventGenerator;\n        this.emitter = eventGenerator.emitter;\n        this.codePath = null;\n        this.idGenerator = new idGenerator(\"s\");\n        this.currentNode = null;\n        this.onLooped = this.onLooped.bind(this);\n    }\n\n    /**\n     * Does the process to enter a given AST node.\n     * This updates state of analysis and calls `enterNode` of the wrapped.\n     * @param {ASTNode} node A node which is entering.\n     * @returns {void}\n     */\n    enterNode(node) {\n        this.currentNode = node;\n\n        // Updates the code path due to node's position in its parent node.\n        if (node.parent) {\n            preprocess(this, node);\n        }\n\n        /*\n         * Updates the code path.\n         * And emits onCodePathStart/onCodePathSegmentStart events.\n         */\n        processCodePathToEnter(this, node);\n\n        // Emits node events.\n        this.original.enterNode(node);\n\n        this.currentNode = null;\n    }\n\n    /**\n     * Does the process to leave a given AST node.\n     * This updates state of analysis and calls `leaveNode` of the wrapped.\n     * @param {ASTNode} node A node which is leaving.\n     * @returns {void}\n     */\n    leaveNode(node) {\n        this.currentNode = node;\n\n        /*\n         * Updates the code path.\n         * And emits onCodePathStart/onCodePathSegmentStart events.\n         */\n        processCodePathToExit(this, node);\n\n        // Emits node events.\n        this.original.leaveNode(node);\n\n        // Emits the last onCodePathStart/onCodePathSegmentStart events.\n        postprocess(this, node);\n\n        this.currentNode = null;\n    }\n\n    /**\n     * This is called on a code path looped.\n     * Then this raises a looped event.\n     * @param {CodePathSegment} fromSegment A segment of prev.\n     * @param {CodePathSegment} toSegment A segment of next.\n     * @returns {void}\n     */\n    onLooped(fromSegment, toSegment) {\n        if (fromSegment.reachable && toSegment.reachable) {\n            debugHelpers.dump(`onCodePathSegmentLoop ${fromSegment.id} -> ${toSegment.id}`);\n            this.emitter.emit(\n                \"onCodePathSegmentLoop\",\n                fromSegment,\n                toSegment,\n                this.currentNode\n            );\n        }\n    }\n}\n\nvar codePathAnalyzer = CodePathAnalyzer;\n\n/**\n * Compares the locations of two objects in a source file\n * @param {{line: number, column: number}} itemA The first object\n * @param {{line: number, column: number}} itemB The second object\n * @returns {number} A value less than 1 if itemA appears before itemB in the source file, greater than 1 if\n * itemA appears after itemB in the source file, or 0 if itemA and itemB have the same location.\n */\nfunction compareLocations(itemA, itemB) {\n    return itemA.line - itemB.line || itemA.column - itemB.column;\n}\n\n/**\n * This is the same as the exported function, except that it\n * doesn't handle disable-line and disable-next-line directives, and it always reports unused\n * disable directives.\n * @param {Object} options options for applying directives. This is the same as the options\n * for the exported function, except that `reportUnusedDisableDirectives` is not supported\n * (this function always reports unused disable directives).\n * @returns {{problems: Problem[], unusedDisableDirectives: Problem[]}} An object with a list\n * of filtered problems and unused eslint-disable directives\n */\nfunction applyDirectives(options) {\n    const problems = [];\n    let nextDirectiveIndex = 0;\n    let currentGlobalDisableDirective = null;\n    const disabledRuleMap = new Map();\n\n    // enabledRules is only used when there is a current global disable directive.\n    const enabledRules = new Set();\n    const usedDisableDirectives = new Set();\n\n    for (const problem of options.problems) {\n        while (\n            nextDirectiveIndex < options.directives.length &&\n            compareLocations(options.directives[nextDirectiveIndex], problem) <= 0\n        ) {\n            const directive = options.directives[nextDirectiveIndex++];\n\n            switch (directive.type) {\n                case \"disable\":\n                    if (directive.ruleId === null) {\n                        currentGlobalDisableDirective = directive;\n                        disabledRuleMap.clear();\n                        enabledRules.clear();\n                    } else if (currentGlobalDisableDirective) {\n                        enabledRules.delete(directive.ruleId);\n                        disabledRuleMap.set(directive.ruleId, directive);\n                    } else {\n                        disabledRuleMap.set(directive.ruleId, directive);\n                    }\n                    break;\n\n                case \"enable\":\n                    if (directive.ruleId === null) {\n                        currentGlobalDisableDirective = null;\n                        disabledRuleMap.clear();\n                    } else if (currentGlobalDisableDirective) {\n                        enabledRules.add(directive.ruleId);\n                        disabledRuleMap.delete(directive.ruleId);\n                    } else {\n                        disabledRuleMap.delete(directive.ruleId);\n                    }\n                    break;\n\n                // no default\n            }\n        }\n\n        if (disabledRuleMap.has(problem.ruleId)) {\n            usedDisableDirectives.add(disabledRuleMap.get(problem.ruleId));\n        } else if (currentGlobalDisableDirective && !enabledRules.has(problem.ruleId)) {\n            usedDisableDirectives.add(currentGlobalDisableDirective);\n        } else {\n            problems.push(problem);\n        }\n    }\n\n    const unusedDisableDirectives = options.directives\n        .filter(directive => directive.type === \"disable\" && !usedDisableDirectives.has(directive))\n        .map(directive => ({\n            ruleId: null,\n            message: directive.ruleId\n                ? `Unused eslint-disable directive (no problems were reported from '${directive.ruleId}').`\n                : \"Unused eslint-disable directive (no problems were reported).\",\n            line: directive.unprocessedDirective.line,\n            column: directive.unprocessedDirective.column,\n            severity: options.reportUnusedDisableDirectives === \"warn\" ? 1 : 2,\n            nodeType: null\n        }));\n\n    return { problems, unusedDisableDirectives };\n}\n\n/**\n * Given a list of directive comments (i.e. metadata about eslint-disable and eslint-enable comments) and a list\n * of reported problems, determines which problems should be reported.\n * @param {Object} options Information about directives and problems\n * @param {{\n *      type: (\"disable\"|\"enable\"|\"disable-line\"|\"disable-next-line\"),\n *      ruleId: (string|null),\n *      line: number,\n *      column: number\n * }} options.directives Directive comments found in the file, with one-based columns.\n * Two directive comments can only have the same location if they also have the same type (e.g. a single eslint-disable\n * comment for two different rules is represented as two directives).\n * @param {{ruleId: (string|null), line: number, column: number}[]} options.problems\n * A list of problems reported by rules, sorted by increasing location in the file, with one-based columns.\n * @param {\"off\" | \"warn\" | \"error\"} options.reportUnusedDisableDirectives If `\"warn\"` or `\"error\"`, adds additional problems for unused directives\n * @returns {{ruleId: (string|null), line: number, column: number}[]}\n * A list of reported problems that were not disabled by the directive comments.\n */\nvar applyDisableDirectives = ({ directives, problems, reportUnusedDisableDirectives = \"off\" }) => {\n    const blockDirectives = directives\n        .filter(directive => directive.type === \"disable\" || directive.type === \"enable\")\n        .map(directive => Object.assign({}, directive, { unprocessedDirective: directive }))\n        .sort(compareLocations);\n\n    const lineDirectives = lodash.flatMap(directives, directive => {\n        switch (directive.type) {\n            case \"disable\":\n            case \"enable\":\n                return [];\n\n            case \"disable-line\":\n                return [\n                    { type: \"disable\", line: directive.line, column: 1, ruleId: directive.ruleId, unprocessedDirective: directive },\n                    { type: \"enable\", line: directive.line + 1, column: 0, ruleId: directive.ruleId, unprocessedDirective: directive }\n                ];\n\n            case \"disable-next-line\":\n                return [\n                    { type: \"disable\", line: directive.line + 1, column: 1, ruleId: directive.ruleId, unprocessedDirective: directive },\n                    { type: \"enable\", line: directive.line + 2, column: 0, ruleId: directive.ruleId, unprocessedDirective: directive }\n                ];\n\n            default:\n                throw new TypeError(`Unrecognized directive type '${directive.type}'`);\n        }\n    }).sort(compareLocations);\n\n    const blockDirectivesResult = applyDirectives({\n        problems,\n        directives: blockDirectives,\n        reportUnusedDisableDirectives\n    });\n    const lineDirectivesResult = applyDirectives({\n        problems: blockDirectivesResult.problems,\n        directives: lineDirectives,\n        reportUnusedDisableDirectives\n    });\n\n    return reportUnusedDisableDirectives !== \"off\"\n        ? lineDirectivesResult.problems\n            .concat(blockDirectivesResult.unusedDisableDirectives)\n            .concat(lineDirectivesResult.unusedDisableDirectives)\n            .sort(compareLocations)\n        : lineDirectivesResult.problems;\n};\n\n// Generated by LiveScript 1.4.0\nvar apply, curry, flip, fix, over, memoize, slice$ = [].slice, toString$ = {}.toString;\napply = curry$(function(f, list){\n  return f.apply(null, list);\n});\ncurry = function(f){\n  return curry$(f);\n};\nflip = curry$(function(f, x, y){\n  return f(y, x);\n});\nfix = function(f){\n  return function(g){\n    return function(){\n      return f(g(g)).apply(null, arguments);\n    };\n  }(function(g){\n    return function(){\n      return f(g(g)).apply(null, arguments);\n    };\n  });\n};\nover = curry$(function(f, g, x, y){\n  return f(g(x), g(y));\n});\nmemoize = function(f){\n  var memo;\n  memo = {};\n  return function(){\n    var args, key, arg;\n    args = slice$.call(arguments);\n    key = (function(){\n      var i$, ref$, len$, results$ = [];\n      for (i$ = 0, len$ = (ref$ = args).length; i$ < len$; ++i$) {\n        arg = ref$[i$];\n        results$.push(arg + toString$.call(arg).slice(8, -1));\n      }\n      return results$;\n    }()).join('');\n    return memo[key] = key in memo\n      ? memo[key]\n      : f.apply(null, args);\n  };\n};\nvar Func = {\n  curry: curry,\n  flip: flip,\n  fix: fix,\n  apply: apply,\n  over: over,\n  memoize: memoize\n};\nfunction curry$(f, bound){\n  var context,\n  _curry = function(args) {\n    return f.length > 1 ? function(){\n      var params = args ? args.concat() : [];\n      context = bound ? context || this : this;\n      return params.push.apply(params, arguments) <\n          f.length && arguments.length ?\n        _curry.call(context, params) : f.apply(context, params);\n    } : f;\n  };\n  return _curry();\n}\n\n// Generated by LiveScript 1.4.0\nvar each, map$1, compact, filter, reject, partition, find, head, first, tail, last$1, initial, empty$2, reverse, unique, uniqueBy, fold, foldl, fold1, foldl1, foldr, foldr1, unfoldr, concat, concatMap, flatten, difference, intersection, union$1, countBy, groupBy, andList, orList, any, all, sort, sortWith, sortBy, sum, product, mean, average, maximum, minimum, maximumBy, minimumBy, scan$1, scanl, scan1, scanl1, scanr, scanr1, slice, take, drop, splitAt, takeWhile, dropWhile, span, breakList, zip, zipWith, zipAll, zipAllWith, at, elemIndex, elemIndices, findIndex, findIndices, toString$$1 = {}.toString, slice$$1 = [].slice;\neach = curry$$1(function(f, xs){\n  var i$, len$, x;\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    f(x);\n  }\n  return xs;\n});\nmap$1 = curry$$1(function(f, xs){\n  var i$, len$, x, results$ = [];\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    results$.push(f(x));\n  }\n  return results$;\n});\ncompact = function(xs){\n  var i$, len$, x, results$ = [];\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    if (x) {\n      results$.push(x);\n    }\n  }\n  return results$;\n};\nfilter = curry$$1(function(f, xs){\n  var i$, len$, x, results$ = [];\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    if (f(x)) {\n      results$.push(x);\n    }\n  }\n  return results$;\n});\nreject = curry$$1(function(f, xs){\n  var i$, len$, x, results$ = [];\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    if (!f(x)) {\n      results$.push(x);\n    }\n  }\n  return results$;\n});\npartition = curry$$1(function(f, xs){\n  var passed, failed, i$, len$, x;\n  passed = [];\n  failed = [];\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    (f(x) ? passed : failed).push(x);\n  }\n  return [passed, failed];\n});\nfind = curry$$1(function(f, xs){\n  var i$, len$, x;\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    if (f(x)) {\n      return x;\n    }\n  }\n});\nhead = first = function(xs){\n  return xs[0];\n};\ntail = function(xs){\n  if (!xs.length) {\n    return;\n  }\n  return xs.slice(1);\n};\nlast$1 = function(xs){\n  return xs[xs.length - 1];\n};\ninitial = function(xs){\n  if (!xs.length) {\n    return;\n  }\n  return xs.slice(0, -1);\n};\nempty$2 = function(xs){\n  return !xs.length;\n};\nreverse = function(xs){\n  return xs.concat().reverse();\n};\nunique = function(xs){\n  var result, i$, len$, x;\n  result = [];\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    if (!in$(x, result)) {\n      result.push(x);\n    }\n  }\n  return result;\n};\nuniqueBy = curry$$1(function(f, xs){\n  var seen, i$, len$, x, val, results$ = [];\n  seen = [];\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    val = f(x);\n    if (in$(val, seen)) {\n      continue;\n    }\n    seen.push(val);\n    results$.push(x);\n  }\n  return results$;\n});\nfold = foldl = curry$$1(function(f, memo, xs){\n  var i$, len$, x;\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    memo = f(memo, x);\n  }\n  return memo;\n});\nfold1 = foldl1 = curry$$1(function(f, xs){\n  return fold(f, xs[0], xs.slice(1));\n});\nfoldr = curry$$1(function(f, memo, xs){\n  var i$, x;\n  for (i$ = xs.length - 1; i$ >= 0; --i$) {\n    x = xs[i$];\n    memo = f(x, memo);\n  }\n  return memo;\n});\nfoldr1 = curry$$1(function(f, xs){\n  return foldr(f, xs[xs.length - 1], xs.slice(0, -1));\n});\nunfoldr = curry$$1(function(f, b){\n  var result, x, that;\n  result = [];\n  x = b;\n  while ((that = f(x)) != null) {\n    result.push(that[0]);\n    x = that[1];\n  }\n  return result;\n});\nconcat = function(xss){\n  return [].concat.apply([], xss);\n};\nconcatMap = curry$$1(function(f, xs){\n  var x;\n  return [].concat.apply([], (function(){\n    var i$, ref$, len$, results$ = [];\n    for (i$ = 0, len$ = (ref$ = xs).length; i$ < len$; ++i$) {\n      x = ref$[i$];\n      results$.push(f(x));\n    }\n    return results$;\n  }()));\n});\nflatten = function(xs){\n  var x;\n  return [].concat.apply([], (function(){\n    var i$, ref$, len$, results$ = [];\n    for (i$ = 0, len$ = (ref$ = xs).length; i$ < len$; ++i$) {\n      x = ref$[i$];\n      if (toString$$1.call(x).slice(8, -1) === 'Array') {\n        results$.push(flatten(x));\n      } else {\n        results$.push(x);\n      }\n    }\n    return results$;\n  }()));\n};\ndifference = function(xs){\n  var yss, results, i$, len$, x, j$, len1$, ys;\n  yss = slice$$1.call(arguments, 1);\n  results = [];\n  outer: for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    for (j$ = 0, len1$ = yss.length; j$ < len1$; ++j$) {\n      ys = yss[j$];\n      if (in$(x, ys)) {\n        continue outer;\n      }\n    }\n    results.push(x);\n  }\n  return results;\n};\nintersection = function(xs){\n  var yss, results, i$, len$, x, j$, len1$, ys;\n  yss = slice$$1.call(arguments, 1);\n  results = [];\n  outer: for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    for (j$ = 0, len1$ = yss.length; j$ < len1$; ++j$) {\n      ys = yss[j$];\n      if (!in$(x, ys)) {\n        continue outer;\n      }\n    }\n    results.push(x);\n  }\n  return results;\n};\nunion$1 = function(){\n  var xss, results, i$, len$, xs, j$, len1$, x;\n  xss = slice$$1.call(arguments);\n  results = [];\n  for (i$ = 0, len$ = xss.length; i$ < len$; ++i$) {\n    xs = xss[i$];\n    for (j$ = 0, len1$ = xs.length; j$ < len1$; ++j$) {\n      x = xs[j$];\n      if (!in$(x, results)) {\n        results.push(x);\n      }\n    }\n  }\n  return results;\n};\ncountBy = curry$$1(function(f, xs){\n  var results, i$, len$, x, key;\n  results = {};\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    key = f(x);\n    if (key in results) {\n      results[key] += 1;\n    } else {\n      results[key] = 1;\n    }\n  }\n  return results;\n});\ngroupBy = curry$$1(function(f, xs){\n  var results, i$, len$, x, key;\n  results = {};\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    key = f(x);\n    if (key in results) {\n      results[key].push(x);\n    } else {\n      results[key] = [x];\n    }\n  }\n  return results;\n});\nandList = function(xs){\n  var i$, len$, x;\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    if (!x) {\n      return false;\n    }\n  }\n  return true;\n};\norList = function(xs){\n  var i$, len$, x;\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    if (x) {\n      return true;\n    }\n  }\n  return false;\n};\nany = curry$$1(function(f, xs){\n  var i$, len$, x;\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    if (f(x)) {\n      return true;\n    }\n  }\n  return false;\n});\nall = curry$$1(function(f, xs){\n  var i$, len$, x;\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    if (!f(x)) {\n      return false;\n    }\n  }\n  return true;\n});\nsort = function(xs){\n  return xs.concat().sort(function(x, y){\n    if (x > y) {\n      return 1;\n    } else if (x < y) {\n      return -1;\n    } else {\n      return 0;\n    }\n  });\n};\nsortWith = curry$$1(function(f, xs){\n  return xs.concat().sort(f);\n});\nsortBy = curry$$1(function(f, xs){\n  return xs.concat().sort(function(x, y){\n    if (f(x) > f(y)) {\n      return 1;\n    } else if (f(x) < f(y)) {\n      return -1;\n    } else {\n      return 0;\n    }\n  });\n});\nsum = function(xs){\n  var result, i$, len$, x;\n  result = 0;\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    result += x;\n  }\n  return result;\n};\nproduct = function(xs){\n  var result, i$, len$, x;\n  result = 1;\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    result *= x;\n  }\n  return result;\n};\nmean = average = function(xs){\n  var sum, i$, len$, x;\n  sum = 0;\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    x = xs[i$];\n    sum += x;\n  }\n  return sum / xs.length;\n};\nmaximum = function(xs){\n  var max, i$, ref$, len$, x;\n  max = xs[0];\n  for (i$ = 0, len$ = (ref$ = xs.slice(1)).length; i$ < len$; ++i$) {\n    x = ref$[i$];\n    if (x > max) {\n      max = x;\n    }\n  }\n  return max;\n};\nminimum = function(xs){\n  var min, i$, ref$, len$, x;\n  min = xs[0];\n  for (i$ = 0, len$ = (ref$ = xs.slice(1)).length; i$ < len$; ++i$) {\n    x = ref$[i$];\n    if (x < min) {\n      min = x;\n    }\n  }\n  return min;\n};\nmaximumBy = curry$$1(function(f, xs){\n  var max, i$, ref$, len$, x;\n  max = xs[0];\n  for (i$ = 0, len$ = (ref$ = xs.slice(1)).length; i$ < len$; ++i$) {\n    x = ref$[i$];\n    if (f(x) > f(max)) {\n      max = x;\n    }\n  }\n  return max;\n});\nminimumBy = curry$$1(function(f, xs){\n  var min, i$, ref$, len$, x;\n  min = xs[0];\n  for (i$ = 0, len$ = (ref$ = xs.slice(1)).length; i$ < len$; ++i$) {\n    x = ref$[i$];\n    if (f(x) < f(min)) {\n      min = x;\n    }\n  }\n  return min;\n});\nscan$1 = scanl = curry$$1(function(f, memo, xs){\n  var last, x;\n  last = memo;\n  return [memo].concat((function(){\n    var i$, ref$, len$, results$ = [];\n    for (i$ = 0, len$ = (ref$ = xs).length; i$ < len$; ++i$) {\n      x = ref$[i$];\n      results$.push(last = f(last, x));\n    }\n    return results$;\n  }()));\n});\nscan1 = scanl1 = curry$$1(function(f, xs){\n  if (!xs.length) {\n    return;\n  }\n  return scan$1(f, xs[0], xs.slice(1));\n});\nscanr = curry$$1(function(f, memo, xs){\n  xs = xs.concat().reverse();\n  return scan$1(f, memo, xs).reverse();\n});\nscanr1 = curry$$1(function(f, xs){\n  if (!xs.length) {\n    return;\n  }\n  xs = xs.concat().reverse();\n  return scan$1(f, xs[0], xs.slice(1)).reverse();\n});\nslice = curry$$1(function(x, y, xs){\n  return xs.slice(x, y);\n});\ntake = curry$$1(function(n, xs){\n  if (n <= 0) {\n    return xs.slice(0, 0);\n  } else {\n    return xs.slice(0, n);\n  }\n});\ndrop = curry$$1(function(n, xs){\n  if (n <= 0) {\n    return xs;\n  } else {\n    return xs.slice(n);\n  }\n});\nsplitAt = curry$$1(function(n, xs){\n  return [take(n, xs), drop(n, xs)];\n});\ntakeWhile = curry$$1(function(p, xs){\n  var len, i;\n  len = xs.length;\n  if (!len) {\n    return xs;\n  }\n  i = 0;\n  while (i < len && p(xs[i])) {\n    i += 1;\n  }\n  return xs.slice(0, i);\n});\ndropWhile = curry$$1(function(p, xs){\n  var len, i;\n  len = xs.length;\n  if (!len) {\n    return xs;\n  }\n  i = 0;\n  while (i < len && p(xs[i])) {\n    i += 1;\n  }\n  return xs.slice(i);\n});\nspan = curry$$1(function(p, xs){\n  return [takeWhile(p, xs), dropWhile(p, xs)];\n});\nbreakList = curry$$1(function(p, xs){\n  return span(compose$(p, not$), xs);\n});\nzip = curry$$1(function(xs, ys){\n  var result, len, i$, len$, i, x;\n  result = [];\n  len = ys.length;\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    i = i$;\n    x = xs[i$];\n    if (i === len) {\n      break;\n    }\n    result.push([x, ys[i]]);\n  }\n  return result;\n});\nzipWith = curry$$1(function(f, xs, ys){\n  var result, len, i$, len$, i, x;\n  result = [];\n  len = ys.length;\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    i = i$;\n    x = xs[i$];\n    if (i === len) {\n      break;\n    }\n    result.push(f(x, ys[i]));\n  }\n  return result;\n});\nzipAll = function(){\n  var xss, minLength, i$, len$, xs, ref$, i, lresult$, j$, results$ = [];\n  xss = slice$$1.call(arguments);\n  minLength = undefined;\n  for (i$ = 0, len$ = xss.length; i$ < len$; ++i$) {\n    xs = xss[i$];\n    minLength <= (ref$ = xs.length) || (minLength = ref$);\n  }\n  for (i$ = 0; i$ < minLength; ++i$) {\n    i = i$;\n    lresult$ = [];\n    for (j$ = 0, len$ = xss.length; j$ < len$; ++j$) {\n      xs = xss[j$];\n      lresult$.push(xs[i]);\n    }\n    results$.push(lresult$);\n  }\n  return results$;\n};\nzipAllWith = function(f){\n  var xss, minLength, i$, len$, xs, ref$, i, results$ = [];\n  xss = slice$$1.call(arguments, 1);\n  minLength = undefined;\n  for (i$ = 0, len$ = xss.length; i$ < len$; ++i$) {\n    xs = xss[i$];\n    minLength <= (ref$ = xs.length) || (minLength = ref$);\n  }\n  for (i$ = 0; i$ < minLength; ++i$) {\n    i = i$;\n    results$.push(f.apply(null, (fn$())));\n  }\n  return results$;\n  function fn$(){\n    var i$, ref$, len$, results$ = [];\n    for (i$ = 0, len$ = (ref$ = xss).length; i$ < len$; ++i$) {\n      xs = ref$[i$];\n      results$.push(xs[i]);\n    }\n    return results$;\n  }\n};\nat = curry$$1(function(n, xs){\n  if (n < 0) {\n    return xs[xs.length + n];\n  } else {\n    return xs[n];\n  }\n});\nelemIndex = curry$$1(function(el, xs){\n  var i$, len$, i, x;\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    i = i$;\n    x = xs[i$];\n    if (x === el) {\n      return i;\n    }\n  }\n});\nelemIndices = curry$$1(function(el, xs){\n  var i$, len$, i, x, results$ = [];\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    i = i$;\n    x = xs[i$];\n    if (x === el) {\n      results$.push(i);\n    }\n  }\n  return results$;\n});\nfindIndex = curry$$1(function(f, xs){\n  var i$, len$, i, x;\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    i = i$;\n    x = xs[i$];\n    if (f(x)) {\n      return i;\n    }\n  }\n});\nfindIndices = curry$$1(function(f, xs){\n  var i$, len$, i, x, results$ = [];\n  for (i$ = 0, len$ = xs.length; i$ < len$; ++i$) {\n    i = i$;\n    x = xs[i$];\n    if (f(x)) {\n      results$.push(i);\n    }\n  }\n  return results$;\n});\nvar List = {\n  each: each,\n  map: map$1,\n  filter: filter,\n  compact: compact,\n  reject: reject,\n  partition: partition,\n  find: find,\n  head: head,\n  first: first,\n  tail: tail,\n  last: last$1,\n  initial: initial,\n  empty: empty$2,\n  reverse: reverse,\n  difference: difference,\n  intersection: intersection,\n  union: union$1,\n  countBy: countBy,\n  groupBy: groupBy,\n  fold: fold,\n  fold1: fold1,\n  foldl: foldl,\n  foldl1: foldl1,\n  foldr: foldr,\n  foldr1: foldr1,\n  unfoldr: unfoldr,\n  andList: andList,\n  orList: orList,\n  any: any,\n  all: all,\n  unique: unique,\n  uniqueBy: uniqueBy,\n  sort: sort,\n  sortWith: sortWith,\n  sortBy: sortBy,\n  sum: sum,\n  product: product,\n  mean: mean,\n  average: average,\n  concat: concat,\n  concatMap: concatMap,\n  flatten: flatten,\n  maximum: maximum,\n  minimum: minimum,\n  maximumBy: maximumBy,\n  minimumBy: minimumBy,\n  scan: scan$1,\n  scan1: scan1,\n  scanl: scanl,\n  scanl1: scanl1,\n  scanr: scanr,\n  scanr1: scanr1,\n  slice: slice,\n  take: take,\n  drop: drop,\n  splitAt: splitAt,\n  takeWhile: takeWhile,\n  dropWhile: dropWhile,\n  span: span,\n  breakList: breakList,\n  zip: zip,\n  zipWith: zipWith,\n  zipAll: zipAll,\n  zipAllWith: zipAllWith,\n  at: at,\n  elemIndex: elemIndex,\n  elemIndices: elemIndices,\n  findIndex: findIndex,\n  findIndices: findIndices\n};\nfunction curry$$1(f, bound){\n  var context,\n  _curry = function(args) {\n    return f.length > 1 ? function(){\n      var params = args ? args.concat() : [];\n      context = bound ? context || this : this;\n      return params.push.apply(params, arguments) <\n          f.length && arguments.length ?\n        _curry.call(context, params) : f.apply(context, params);\n    } : f;\n  };\n  return _curry();\n}\nfunction in$(x, xs){\n  var i = -1, l = xs.length >>> 0;\n  while (++i < l) if (x === xs[i]) return true;\n  return false;\n}\nfunction compose$() {\n  var functions = arguments;\n  return function() {\n    var i, result;\n    result = functions[0].apply(this, arguments);\n    for (i = 1; i < functions.length; ++i) {\n      result = functions[i](result);\n    }\n    return result;\n  };\n}\nfunction not$(x){ return !x; }\n\n// Generated by LiveScript 1.4.0\nvar values, keys, pairsToObj, objToPairs, listsToObj, objToLists, empty$3, each$1, map$2, compact$1, filter$1, reject$1, partition$1, find$1;\nvalues = function(object){\n  var i$, x, results$ = [];\n  for (i$ in object) {\n    x = object[i$];\n    results$.push(x);\n  }\n  return results$;\n};\nkeys = function(object){\n  var x, results$ = [];\n  for (x in object) {\n    results$.push(x);\n  }\n  return results$;\n};\npairsToObj = function(object){\n  var i$, len$, x, resultObj$ = {};\n  for (i$ = 0, len$ = object.length; i$ < len$; ++i$) {\n    x = object[i$];\n    resultObj$[x[0]] = x[1];\n  }\n  return resultObj$;\n};\nobjToPairs = function(object){\n  var key, value, results$ = [];\n  for (key in object) {\n    value = object[key];\n    results$.push([key, value]);\n  }\n  return results$;\n};\nlistsToObj = curry$$2(function(keys, values){\n  var i$, len$, i, key, resultObj$ = {};\n  for (i$ = 0, len$ = keys.length; i$ < len$; ++i$) {\n    i = i$;\n    key = keys[i$];\n    resultObj$[key] = values[i];\n  }\n  return resultObj$;\n});\nobjToLists = function(object){\n  var keys, values, key, value;\n  keys = [];\n  values = [];\n  for (key in object) {\n    value = object[key];\n    keys.push(key);\n    values.push(value);\n  }\n  return [keys, values];\n};\nempty$3 = function(object){\n  var x;\n  for (x in object) {\n    return false;\n  }\n  return true;\n};\neach$1 = curry$$2(function(f, object){\n  var i$, x;\n  for (i$ in object) {\n    x = object[i$];\n    f(x);\n  }\n  return object;\n});\nmap$2 = curry$$2(function(f, object){\n  var k, x, resultObj$ = {};\n  for (k in object) {\n    x = object[k];\n    resultObj$[k] = f(x);\n  }\n  return resultObj$;\n});\ncompact$1 = function(object){\n  var k, x, resultObj$ = {};\n  for (k in object) {\n    x = object[k];\n    if (x) {\n      resultObj$[k] = x;\n    }\n  }\n  return resultObj$;\n};\nfilter$1 = curry$$2(function(f, object){\n  var k, x, resultObj$ = {};\n  for (k in object) {\n    x = object[k];\n    if (f(x)) {\n      resultObj$[k] = x;\n    }\n  }\n  return resultObj$;\n});\nreject$1 = curry$$2(function(f, object){\n  var k, x, resultObj$ = {};\n  for (k in object) {\n    x = object[k];\n    if (!f(x)) {\n      resultObj$[k] = x;\n    }\n  }\n  return resultObj$;\n});\npartition$1 = curry$$2(function(f, object){\n  var passed, failed, k, x;\n  passed = {};\n  failed = {};\n  for (k in object) {\n    x = object[k];\n    (f(x) ? passed : failed)[k] = x;\n  }\n  return [passed, failed];\n});\nfind$1 = curry$$2(function(f, object){\n  var i$, x;\n  for (i$ in object) {\n    x = object[i$];\n    if (f(x)) {\n      return x;\n    }\n  }\n});\nvar Obj = {\n  values: values,\n  keys: keys,\n  pairsToObj: pairsToObj,\n  objToPairs: objToPairs,\n  listsToObj: listsToObj,\n  objToLists: objToLists,\n  empty: empty$3,\n  each: each$1,\n  map: map$2,\n  filter: filter$1,\n  compact: compact$1,\n  reject: reject$1,\n  partition: partition$1,\n  find: find$1\n};\nfunction curry$$2(f, bound){\n  var context,\n  _curry = function(args) {\n    return f.length > 1 ? function(){\n      var params = args ? args.concat() : [];\n      context = bound ? context || this : this;\n      return params.push.apply(params, arguments) <\n          f.length && arguments.length ?\n        _curry.call(context, params) : f.apply(context, params);\n    } : f;\n  };\n  return _curry();\n}\n\n// Generated by LiveScript 1.4.0\nvar split, join, lines, unlines, words, unwords, chars, unchars, reverse$1, repeat$1, capitalize, camelize, dasherize;\nsplit = curry$$3(function(sep, str){\n  return str.split(sep);\n});\njoin = curry$$3(function(sep, xs){\n  return xs.join(sep);\n});\nlines = function(str){\n  if (!str.length) {\n    return [];\n  }\n  return str.split('\\n');\n};\nunlines = function(it){\n  return it.join('\\n');\n};\nwords = function(str){\n  if (!str.length) {\n    return [];\n  }\n  return str.split(/[ ]+/);\n};\nunwords = function(it){\n  return it.join(' ');\n};\nchars = function(it){\n  return it.split('');\n};\nunchars = function(it){\n  return it.join('');\n};\nreverse$1 = function(str){\n  return str.split('').reverse().join('');\n};\nrepeat$1 = curry$$3(function(n, str){\n  var result, i$;\n  result = '';\n  for (i$ = 0; i$ < n; ++i$) {\n    result += str;\n  }\n  return result;\n});\ncapitalize = function(str){\n  return str.charAt(0).toUpperCase() + str.slice(1);\n};\ncamelize = function(it){\n  return it.replace(/[-_]+(.)?/g, function(arg$, c){\n    return (c != null ? c : '').toUpperCase();\n  });\n};\ndasherize = function(str){\n  return str.replace(/([^-A-Z])([A-Z]+)/g, function(arg$, lower, upper){\n    return lower + \"-\" + (upper.length > 1\n      ? upper\n      : upper.toLowerCase());\n  }).replace(/^([A-Z]+)/, function(arg$, upper){\n    if (upper.length > 1) {\n      return upper + \"-\";\n    } else {\n      return upper.toLowerCase();\n    }\n  });\n};\nvar Str = {\n  split: split,\n  join: join,\n  lines: lines,\n  unlines: unlines,\n  words: words,\n  unwords: unwords,\n  chars: chars,\n  unchars: unchars,\n  reverse: reverse$1,\n  repeat: repeat$1,\n  capitalize: capitalize,\n  camelize: camelize,\n  dasherize: dasherize\n};\nfunction curry$$3(f, bound){\n  var context,\n  _curry = function(args) {\n    return f.length > 1 ? function(){\n      var params = args ? args.concat() : [];\n      context = bound ? context || this : this;\n      return params.push.apply(params, arguments) <\n          f.length && arguments.length ?\n        _curry.call(context, params) : f.apply(context, params);\n    } : f;\n  };\n  return _curry();\n}\n\n// Generated by LiveScript 1.4.0\nvar max, min, negate$1, abs, signum, quot, rem, div, mod, recip, pi, tau, exp, sqrt, ln, pow, sin, tan, cos, asin, acos, atan, atan2, truncate, round, ceiling, floor, isItNaN, even, odd, gcd, lcm;\nmax = curry$$4(function(x$, y$){\n  return x$ > y$ ? x$ : y$;\n});\nmin = curry$$4(function(x$, y$){\n  return x$ < y$ ? x$ : y$;\n});\nnegate$1 = function(x){\n  return -x;\n};\nabs = Math.abs;\nsignum = function(x){\n  if (x < 0) {\n    return -1;\n  } else if (x > 0) {\n    return 1;\n  } else {\n    return 0;\n  }\n};\nquot = curry$$4(function(x, y){\n  return ~~(x / y);\n});\nrem = curry$$4(function(x$, y$){\n  return x$ % y$;\n});\ndiv = curry$$4(function(x, y){\n  return Math.floor(x / y);\n});\nmod = curry$$4(function(x$, y$){\n  var ref$;\n  return (((x$) % (ref$ = y$) + ref$) % ref$);\n});\nrecip = (function(it){\n  return 1 / it;\n});\npi = Math.PI;\ntau = pi * 2;\nexp = Math.exp;\nsqrt = Math.sqrt;\nln = Math.log;\npow = curry$$4(function(x$, y$){\n  return Math.pow(x$, y$);\n});\nsin = Math.sin;\ntan = Math.tan;\ncos = Math.cos;\nasin = Math.asin;\nacos = Math.acos;\natan = Math.atan;\natan2 = curry$$4(function(x, y){\n  return Math.atan2(x, y);\n});\ntruncate = function(x){\n  return ~~x;\n};\nround = Math.round;\nceiling = Math.ceil;\nfloor = Math.floor;\nisItNaN = function(x){\n  return x !== x;\n};\neven = function(x){\n  return x % 2 === 0;\n};\nodd = function(x){\n  return x % 2 !== 0;\n};\ngcd = curry$$4(function(x, y){\n  var z;\n  x = Math.abs(x);\n  y = Math.abs(y);\n  while (y !== 0) {\n    z = x % y;\n    x = y;\n    y = z;\n  }\n  return x;\n});\nlcm = curry$$4(function(x, y){\n  return Math.abs(Math.floor(x / gcd(x, y) * y));\n});\nvar Num = {\n  max: max,\n  min: min,\n  negate: negate$1,\n  abs: abs,\n  signum: signum,\n  quot: quot,\n  rem: rem,\n  div: div,\n  mod: mod,\n  recip: recip,\n  pi: pi,\n  tau: tau,\n  exp: exp,\n  sqrt: sqrt,\n  ln: ln,\n  pow: pow,\n  sin: sin,\n  tan: tan,\n  cos: cos,\n  acos: acos,\n  asin: asin,\n  atan: atan,\n  atan2: atan2,\n  truncate: truncate,\n  round: round,\n  ceiling: ceiling,\n  floor: floor,\n  isItNaN: isItNaN,\n  even: even,\n  odd: odd,\n  gcd: gcd,\n  lcm: lcm\n};\nfunction curry$$4(f, bound){\n  var context,\n  _curry = function(args) {\n    return f.length > 1 ? function(){\n      var params = args ? args.concat() : [];\n      context = bound ? context || this : this;\n      return params.push.apply(params, arguments) <\n          f.length && arguments.length ?\n        _curry.call(context, params) : f.apply(context, params);\n    } : f;\n  };\n  return _curry();\n}\n\n// Generated by LiveScript 1.4.0\nvar Func$1, List$1, Obj$1, Str$1, Num$1, id$1, isType, replicate, prelude, toString$$2 = {}.toString;\nFunc$1 = Func;\nList$1 = List;\nObj$1 = Obj;\nStr$1 = Str;\nNum$1 = Num;\nid$1 = function(x){\n  return x;\n};\nisType = curry$$5(function(type, x){\n  return toString$$2.call(x).slice(8, -1) === type;\n});\nreplicate = curry$$5(function(n, x){\n  var i$, results$ = [];\n  for (i$ = 0; i$ < n; ++i$) {\n    results$.push(x);\n  }\n  return results$;\n});\nStr$1.empty = List$1.empty;\nStr$1.slice = List$1.slice;\nStr$1.take = List$1.take;\nStr$1.drop = List$1.drop;\nStr$1.splitAt = List$1.splitAt;\nStr$1.takeWhile = List$1.takeWhile;\nStr$1.dropWhile = List$1.dropWhile;\nStr$1.span = List$1.span;\nStr$1.breakStr = List$1.breakList;\nprelude = {\n  Func: Func$1,\n  List: List$1,\n  Obj: Obj$1,\n  Str: Str$1,\n  Num: Num$1,\n  id: id$1,\n  isType: isType,\n  replicate: replicate\n};\nprelude.each = List$1.each;\nprelude.map = List$1.map;\nprelude.filter = List$1.filter;\nprelude.compact = List$1.compact;\nprelude.reject = List$1.reject;\nprelude.partition = List$1.partition;\nprelude.find = List$1.find;\nprelude.head = List$1.head;\nprelude.first = List$1.first;\nprelude.tail = List$1.tail;\nprelude.last = List$1.last;\nprelude.initial = List$1.initial;\nprelude.empty = List$1.empty;\nprelude.reverse = List$1.reverse;\nprelude.difference = List$1.difference;\nprelude.intersection = List$1.intersection;\nprelude.union = List$1.union;\nprelude.countBy = List$1.countBy;\nprelude.groupBy = List$1.groupBy;\nprelude.fold = List$1.fold;\nprelude.foldl = List$1.foldl;\nprelude.fold1 = List$1.fold1;\nprelude.foldl1 = List$1.foldl1;\nprelude.foldr = List$1.foldr;\nprelude.foldr1 = List$1.foldr1;\nprelude.unfoldr = List$1.unfoldr;\nprelude.andList = List$1.andList;\nprelude.orList = List$1.orList;\nprelude.any = List$1.any;\nprelude.all = List$1.all;\nprelude.unique = List$1.unique;\nprelude.uniqueBy = List$1.uniqueBy;\nprelude.sort = List$1.sort;\nprelude.sortWith = List$1.sortWith;\nprelude.sortBy = List$1.sortBy;\nprelude.sum = List$1.sum;\nprelude.product = List$1.product;\nprelude.mean = List$1.mean;\nprelude.average = List$1.average;\nprelude.concat = List$1.concat;\nprelude.concatMap = List$1.concatMap;\nprelude.flatten = List$1.flatten;\nprelude.maximum = List$1.maximum;\nprelude.minimum = List$1.minimum;\nprelude.maximumBy = List$1.maximumBy;\nprelude.minimumBy = List$1.minimumBy;\nprelude.scan = List$1.scan;\nprelude.scanl = List$1.scanl;\nprelude.scan1 = List$1.scan1;\nprelude.scanl1 = List$1.scanl1;\nprelude.scanr = List$1.scanr;\nprelude.scanr1 = List$1.scanr1;\nprelude.slice = List$1.slice;\nprelude.take = List$1.take;\nprelude.drop = List$1.drop;\nprelude.splitAt = List$1.splitAt;\nprelude.takeWhile = List$1.takeWhile;\nprelude.dropWhile = List$1.dropWhile;\nprelude.span = List$1.span;\nprelude.breakList = List$1.breakList;\nprelude.zip = List$1.zip;\nprelude.zipWith = List$1.zipWith;\nprelude.zipAll = List$1.zipAll;\nprelude.zipAllWith = List$1.zipAllWith;\nprelude.at = List$1.at;\nprelude.elemIndex = List$1.elemIndex;\nprelude.elemIndices = List$1.elemIndices;\nprelude.findIndex = List$1.findIndex;\nprelude.findIndices = List$1.findIndices;\nprelude.apply = Func$1.apply;\nprelude.curry = Func$1.curry;\nprelude.flip = Func$1.flip;\nprelude.fix = Func$1.fix;\nprelude.over = Func$1.over;\nprelude.split = Str$1.split;\nprelude.join = Str$1.join;\nprelude.lines = Str$1.lines;\nprelude.unlines = Str$1.unlines;\nprelude.words = Str$1.words;\nprelude.unwords = Str$1.unwords;\nprelude.chars = Str$1.chars;\nprelude.unchars = Str$1.unchars;\nprelude.repeat = Str$1.repeat;\nprelude.capitalize = Str$1.capitalize;\nprelude.camelize = Str$1.camelize;\nprelude.dasherize = Str$1.dasherize;\nprelude.values = Obj$1.values;\nprelude.keys = Obj$1.keys;\nprelude.pairsToObj = Obj$1.pairsToObj;\nprelude.objToPairs = Obj$1.objToPairs;\nprelude.listsToObj = Obj$1.listsToObj;\nprelude.objToLists = Obj$1.objToLists;\nprelude.max = Num$1.max;\nprelude.min = Num$1.min;\nprelude.negate = Num$1.negate;\nprelude.abs = Num$1.abs;\nprelude.signum = Num$1.signum;\nprelude.quot = Num$1.quot;\nprelude.rem = Num$1.rem;\nprelude.div = Num$1.div;\nprelude.mod = Num$1.mod;\nprelude.recip = Num$1.recip;\nprelude.pi = Num$1.pi;\nprelude.tau = Num$1.tau;\nprelude.exp = Num$1.exp;\nprelude.sqrt = Num$1.sqrt;\nprelude.ln = Num$1.ln;\nprelude.pow = Num$1.pow;\nprelude.sin = Num$1.sin;\nprelude.tan = Num$1.tan;\nprelude.cos = Num$1.cos;\nprelude.acos = Num$1.acos;\nprelude.asin = Num$1.asin;\nprelude.atan = Num$1.atan;\nprelude.atan2 = Num$1.atan2;\nprelude.truncate = Num$1.truncate;\nprelude.round = Num$1.round;\nprelude.ceiling = Num$1.ceiling;\nprelude.floor = Num$1.floor;\nprelude.isItNaN = Num$1.isItNaN;\nprelude.even = Num$1.even;\nprelude.odd = Num$1.odd;\nprelude.gcd = Num$1.gcd;\nprelude.lcm = Num$1.lcm;\nprelude.VERSION = '1.1.2';\nvar lib$2 = prelude;\nfunction curry$$5(f, bound){\n  var context,\n  _curry = function(args) {\n    return f.length > 1 ? function(){\n      var params = args ? args.concat() : [];\n      context = bound ? context || this : this;\n      return params.push.apply(params, arguments) <\n          f.length && arguments.length ?\n        _curry.call(context, params) : f.apply(context, params);\n    } : f;\n  };\n  return _curry();\n}\n\nvar parseString = createCommonjsModule(function (module) {\n// Generated by LiveScript 1.4.0\n(function(){\n  var reject, special, tokenRegex;\n  reject = lib$2.reject;\n  function consumeOp(tokens, op){\n    if (tokens[0] === op) {\n      return tokens.shift();\n    } else {\n      throw new Error(\"Expected '\" + op + \"', but got '\" + tokens[0] + \"' instead in \" + JSON.stringify(tokens) + \".\");\n    }\n  }\n  function maybeConsumeOp(tokens, op){\n    if (tokens[0] === op) {\n      return tokens.shift();\n    }\n  }\n  function consumeList(tokens, arg$, hasDelimiters){\n    var open, close, result, untilTest;\n    open = arg$[0], close = arg$[1];\n    if (hasDelimiters) {\n      consumeOp(tokens, open);\n    }\n    result = [];\n    untilTest = \",\" + (hasDelimiters ? close : '');\n    while (tokens.length && (hasDelimiters && tokens[0] !== close)) {\n      result.push(consumeElement(tokens, untilTest));\n      maybeConsumeOp(tokens, ',');\n    }\n    if (hasDelimiters) {\n      consumeOp(tokens, close);\n    }\n    return result;\n  }\n  function consumeArray(tokens, hasDelimiters){\n    return consumeList(tokens, ['[', ']'], hasDelimiters);\n  }\n  function consumeTuple(tokens, hasDelimiters){\n    return consumeList(tokens, ['(', ')'], hasDelimiters);\n  }\n  function consumeFields(tokens, hasDelimiters){\n    var result, untilTest, key;\n    if (hasDelimiters) {\n      consumeOp(tokens, '{');\n    }\n    result = {};\n    untilTest = \",\" + (hasDelimiters ? '}' : '');\n    while (tokens.length && (!hasDelimiters || tokens[0] !== '}')) {\n      key = consumeValue(tokens, ':');\n      consumeOp(tokens, ':');\n      result[key] = consumeElement(tokens, untilTest);\n      maybeConsumeOp(tokens, ',');\n    }\n    if (hasDelimiters) {\n      consumeOp(tokens, '}');\n    }\n    return result;\n  }\n  function consumeValue(tokens, untilTest){\n    var out;\n    untilTest == null && (untilTest = '');\n    out = '';\n    while (tokens.length && -1 === untilTest.indexOf(tokens[0])) {\n      out += tokens.shift();\n    }\n    return out;\n  }\n  function consumeElement(tokens, untilTest){\n    switch (tokens[0]) {\n    case '[':\n      return consumeArray(tokens, true);\n    case '(':\n      return consumeTuple(tokens, true);\n    case '{':\n      return consumeFields(tokens, true);\n    default:\n      return consumeValue(tokens, untilTest);\n    }\n  }\n  function consumeTopLevel(tokens, types, options){\n    var ref$, type, structure, origTokens, result, finalResult, x$, y$;\n    ref$ = types[0], type = ref$.type, structure = ref$.structure;\n    origTokens = tokens.concat();\n    if (!options.explicit && types.length === 1 && ((!type && structure) || (type === 'Array' || type === 'Object'))) {\n      result = structure === 'array' || type === 'Array'\n        ? consumeArray(tokens, tokens[0] === '[')\n        : structure === 'tuple'\n          ? consumeTuple(tokens, tokens[0] === '(')\n          : consumeFields(tokens, tokens[0] === '{');\n      finalResult = tokens.length ? consumeElement(structure === 'array' || type === 'Array'\n        ? (x$ = origTokens, x$.unshift('['), x$.push(']'), x$)\n        : (y$ = origTokens, y$.unshift('('), y$.push(')'), y$)) : result;\n    } else {\n      finalResult = consumeElement(tokens);\n    }\n    return finalResult;\n  }\n  special = /\\[\\]\\(\\)}{:,/.source;\n  tokenRegex = RegExp('(\"(?:\\\\\\\\\"|[^\"])*\")|(\\'(?:\\\\\\\\\\'|[^\\'])*\\')|(/(?:\\\\\\\\/|[^/])*/[a-zA-Z]*)|(#.*#)|([' + special + '])|([^\\\\s' + special + '](?:\\\\s*[^\\\\s' + special + ']+)*)|\\\\s*');\n  module.exports = function(types, string, options){\n    var tokens, node;\n    options == null && (options = {});\n    if (!options.explicit && types.length === 1 && types[0].type === 'String') {\n      return \"'\" + string.replace(/\\\\'/g, \"\\\\\\\\'\") + \"'\";\n    }\n    tokens = reject(not$, string.split(tokenRegex));\n    node = consumeTopLevel(tokens, types, options);\n    if (!node) {\n      throw new Error(\"Error parsing '\" + string + \"'.\");\n    }\n    return node;\n  };\n  function not$(x){ return !x; }\n}).call(this);\n});\n\nvar parseType = createCommonjsModule(function (module) {\n// Generated by LiveScript 1.4.0\n(function(){\n  var identifierRegex, tokenRegex;\n  identifierRegex = /[\\$\\w]+/;\n  function peek(tokens){\n    var token;\n    token = tokens[0];\n    if (token == null) {\n      throw new Error('Unexpected end of input.');\n    }\n    return token;\n  }\n  function consumeIdent(tokens){\n    var token;\n    token = peek(tokens);\n    if (!identifierRegex.test(token)) {\n      throw new Error(\"Expected text, got '\" + token + \"' instead.\");\n    }\n    return tokens.shift();\n  }\n  function consumeOp(tokens, op){\n    var token;\n    token = peek(tokens);\n    if (token !== op) {\n      throw new Error(\"Expected '\" + op + \"', got '\" + token + \"' instead.\");\n    }\n    return tokens.shift();\n  }\n  function maybeConsumeOp(tokens, op){\n    var token;\n    token = tokens[0];\n    if (token === op) {\n      return tokens.shift();\n    } else {\n      return null;\n    }\n  }\n  function consumeArray(tokens){\n    var types;\n    consumeOp(tokens, '[');\n    if (peek(tokens) === ']') {\n      throw new Error(\"Must specify type of Array - eg. [Type], got [] instead.\");\n    }\n    types = consumeTypes(tokens);\n    consumeOp(tokens, ']');\n    return {\n      structure: 'array',\n      of: types\n    };\n  }\n  function consumeTuple(tokens){\n    var components;\n    components = [];\n    consumeOp(tokens, '(');\n    if (peek(tokens) === ')') {\n      throw new Error(\"Tuple must be of at least length 1 - eg. (Type), got () instead.\");\n    }\n    for (;;) {\n      components.push(consumeTypes(tokens));\n      maybeConsumeOp(tokens, ',');\n      if (')' === peek(tokens)) {\n        break;\n      }\n    }\n    consumeOp(tokens, ')');\n    return {\n      structure: 'tuple',\n      of: components\n    };\n  }\n  function consumeFields(tokens){\n    var fields, subset, ref$, key, types;\n    fields = {};\n    consumeOp(tokens, '{');\n    subset = false;\n    for (;;) {\n      if (maybeConsumeOp(tokens, '...')) {\n        subset = true;\n        break;\n      }\n      ref$ = consumeField(tokens), key = ref$[0], types = ref$[1];\n      fields[key] = types;\n      maybeConsumeOp(tokens, ',');\n      if ('}' === peek(tokens)) {\n        break;\n      }\n    }\n    consumeOp(tokens, '}');\n    return {\n      structure: 'fields',\n      of: fields,\n      subset: subset\n    };\n  }\n  function consumeField(tokens){\n    var key, types;\n    key = consumeIdent(tokens);\n    consumeOp(tokens, ':');\n    types = consumeTypes(tokens);\n    return [key, types];\n  }\n  function maybeConsumeStructure(tokens){\n    switch (tokens[0]) {\n    case '[':\n      return consumeArray(tokens);\n    case '(':\n      return consumeTuple(tokens);\n    case '{':\n      return consumeFields(tokens);\n    }\n  }\n  function consumeType(tokens){\n    var token, wildcard, type, structure;\n    token = peek(tokens);\n    wildcard = token === '*';\n    if (wildcard || identifierRegex.test(token)) {\n      type = wildcard\n        ? consumeOp(tokens, '*')\n        : consumeIdent(tokens);\n      structure = maybeConsumeStructure(tokens);\n      if (structure) {\n        return structure.type = type, structure;\n      } else {\n        return {\n          type: type\n        };\n      }\n    } else {\n      structure = maybeConsumeStructure(tokens);\n      if (!structure) {\n        throw new Error(\"Unexpected character: \" + token);\n      }\n      return structure;\n    }\n  }\n  function consumeTypes(tokens){\n    var lookahead, types, typesSoFar, typeObj, type;\n    if ('::' === peek(tokens)) {\n      throw new Error(\"No comment before comment separator '::' found.\");\n    }\n    lookahead = tokens[1];\n    if (lookahead != null && lookahead === '::') {\n      tokens.shift();\n      tokens.shift();\n    }\n    types = [];\n    typesSoFar = {};\n    if ('Maybe' === peek(tokens)) {\n      tokens.shift();\n      types = [\n        {\n          type: 'Undefined'\n        }, {\n          type: 'Null'\n        }\n      ];\n      typesSoFar = {\n        Undefined: true,\n        Null: true\n      };\n    }\n    for (;;) {\n      typeObj = consumeType(tokens), type = typeObj.type;\n      if (!typesSoFar[type]) {\n        types.push(typeObj);\n      }\n      typesSoFar[type] = true;\n      if (!maybeConsumeOp(tokens, '|')) {\n        break;\n      }\n    }\n    return types;\n  }\n  tokenRegex = RegExp('\\\\.\\\\.\\\\.|::|->|' + identifierRegex.source + '|\\\\S', 'g');\n  module.exports = function(input){\n    var tokens, e;\n    if (!input.length) {\n      throw new Error('No type specified.');\n    }\n    tokens = input.match(tokenRegex) || [];\n    if (in$('->', tokens)) {\n      throw new Error(\"Function types are not supported.\\ To validate that something is a function, you may use 'Function'.\");\n    }\n    try {\n      return consumeTypes(tokens);\n    } catch (e$) {\n      e = e$;\n      throw new Error(e.message + \" - Remaining tokens: \" + JSON.stringify(tokens) + \" - Initial input: '\" + input + \"'\");\n    }\n  };\n  function in$(x, xs){\n    var i = -1, l = xs.length >>> 0;\n    while (++i < l) if (x === xs[i]) return true;\n    return false;\n  }\n}).call(this);\n});\n\nvar check = createCommonjsModule(function (module) {\n// Generated by LiveScript 1.4.0\n(function(){\n  var ref$, any, all, isItNaN, types, defaultType, customTypes, toString$ = {}.toString;\n  ref$ = lib$2, any = ref$.any, all = ref$.all, isItNaN = ref$.isItNaN;\n  types = {\n    Number: {\n      typeOf: 'Number',\n      validate: function(it){\n        return !isItNaN(it);\n      }\n    },\n    NaN: {\n      typeOf: 'Number',\n      validate: isItNaN\n    },\n    Int: {\n      typeOf: 'Number',\n      validate: function(it){\n        return !isItNaN(it) && it % 1 === 0;\n      }\n    },\n    Float: {\n      typeOf: 'Number',\n      validate: function(it){\n        return !isItNaN(it);\n      }\n    },\n    Date: {\n      typeOf: 'Date',\n      validate: function(it){\n        return !isItNaN(it.getTime());\n      }\n    }\n  };\n  defaultType = {\n    array: 'Array',\n    tuple: 'Array'\n  };\n  function checkArray(input, type){\n    return all(function(it){\n      return checkMultiple(it, type.of);\n    }, input);\n  }\n  function checkTuple(input, type){\n    var i, i$, ref$, len$, types;\n    i = 0;\n    for (i$ = 0, len$ = (ref$ = type.of).length; i$ < len$; ++i$) {\n      types = ref$[i$];\n      if (!checkMultiple(input[i], types)) {\n        return false;\n      }\n      i++;\n    }\n    return input.length <= i;\n  }\n  function checkFields(input, type){\n    var inputKeys, numInputKeys, k, numOfKeys, key, ref$, types;\n    inputKeys = {};\n    numInputKeys = 0;\n    for (k in input) {\n      inputKeys[k] = true;\n      numInputKeys++;\n    }\n    numOfKeys = 0;\n    for (key in ref$ = type.of) {\n      types = ref$[key];\n      if (!checkMultiple(input[key], types)) {\n        return false;\n      }\n      if (inputKeys[key]) {\n        numOfKeys++;\n      }\n    }\n    return type.subset || numInputKeys === numOfKeys;\n  }\n  function checkStructure(input, type){\n    if (!(input instanceof Object)) {\n      return false;\n    }\n    switch (type.structure) {\n    case 'fields':\n      return checkFields(input, type);\n    case 'array':\n      return checkArray(input, type);\n    case 'tuple':\n      return checkTuple(input, type);\n    }\n  }\n  function check(input, typeObj){\n    var type, structure, setting, that;\n    type = typeObj.type, structure = typeObj.structure;\n    if (type) {\n      if (type === '*') {\n        return true;\n      }\n      setting = customTypes[type] || types[type];\n      if (setting) {\n        return setting.typeOf === toString$.call(input).slice(8, -1) && setting.validate(input);\n      } else {\n        return type === toString$.call(input).slice(8, -1) && (!structure || checkStructure(input, typeObj));\n      }\n    } else if (structure) {\n      if (that = defaultType[structure]) {\n        if (that !== toString$.call(input).slice(8, -1)) {\n          return false;\n        }\n      }\n      return checkStructure(input, typeObj);\n    } else {\n      throw new Error(\"No type defined. Input: \" + input + \".\");\n    }\n  }\n  function checkMultiple(input, types){\n    if (toString$.call(types).slice(8, -1) !== 'Array') {\n      throw new Error(\"Types must be in an array. Input: \" + input + \".\");\n    }\n    return any(function(it){\n      return check(input, it);\n    }, types);\n  }\n  module.exports = function(parsedType, input, options){\n    options == null && (options = {});\n    customTypes = options.customTypes || {};\n    return checkMultiple(input, parsedType);\n  };\n}).call(this);\n});\n\nvar lib$3 = createCommonjsModule(function (module) {\n// Generated by LiveScript 1.4.0\n(function(){\n  var VERSION, parseType$1, parsedTypeCheck, typeCheck;\n  VERSION = '0.3.2';\n  parseType$1 = parseType;\n  parsedTypeCheck = check;\n  typeCheck = function(type, input, options){\n    return parsedTypeCheck(parseType$1(type), input, options);\n  };\n  module.exports = {\n    VERSION: VERSION,\n    typeCheck: typeCheck,\n    parsedTypeCheck: parsedTypeCheck,\n    parseType: parseType$1\n  };\n}).call(this);\n});\nvar lib_1 = lib$3.VERSION;\nvar lib_2 = lib$3.typeCheck;\nvar lib_3 = lib$3.parsedTypeCheck;\nvar lib_4 = lib$3.parseType;\n\nvar cast = createCommonjsModule(function (module) {\n// Generated by LiveScript 1.4.0\n(function(){\n  var parsedTypeCheck, types, toString$ = {}.toString;\n  parsedTypeCheck = lib$3.parsedTypeCheck;\n  types = {\n    '*': function(value, options){\n      switch (toString$.call(value).slice(8, -1)) {\n      case 'Array':\n        return typeCast(value, {\n          type: 'Array'\n        }, options);\n      case 'Object':\n        return typeCast(value, {\n          type: 'Object'\n        }, options);\n      default:\n        return {\n          type: 'Just',\n          value: typesCast(value, [\n            {\n              type: 'Undefined'\n            }, {\n              type: 'Null'\n            }, {\n              type: 'NaN'\n            }, {\n              type: 'Boolean'\n            }, {\n              type: 'Number'\n            }, {\n              type: 'Date'\n            }, {\n              type: 'RegExp'\n            }, {\n              type: 'Array'\n            }, {\n              type: 'Object'\n            }, {\n              type: 'String'\n            }\n          ], (options.explicit = true, options))\n        };\n      }\n    },\n    Undefined: function(it){\n      if (it === 'undefined' || it === void 8) {\n        return {\n          type: 'Just',\n          value: void 8\n        };\n      } else {\n        return {\n          type: 'Nothing'\n        };\n      }\n    },\n    Null: function(it){\n      if (it === 'null') {\n        return {\n          type: 'Just',\n          value: null\n        };\n      } else {\n        return {\n          type: 'Nothing'\n        };\n      }\n    },\n    NaN: function(it){\n      if (it === 'NaN') {\n        return {\n          type: 'Just',\n          value: NaN\n        };\n      } else {\n        return {\n          type: 'Nothing'\n        };\n      }\n    },\n    Boolean: function(it){\n      if (it === 'true') {\n        return {\n          type: 'Just',\n          value: true\n        };\n      } else if (it === 'false') {\n        return {\n          type: 'Just',\n          value: false\n        };\n      } else {\n        return {\n          type: 'Nothing'\n        };\n      }\n    },\n    Number: function(it){\n      return {\n        type: 'Just',\n        value: +it\n      };\n    },\n    Int: function(it){\n      return {\n        type: 'Just',\n        value: +it\n      };\n    },\n    Float: function(it){\n      return {\n        type: 'Just',\n        value: +it\n      };\n    },\n    Date: function(value, options){\n      var that;\n      if (that = /^\\#([\\s\\S]*)\\#$/.exec(value)) {\n        return {\n          type: 'Just',\n          value: new Date(+that[1] || that[1])\n        };\n      } else if (options.explicit) {\n        return {\n          type: 'Nothing'\n        };\n      } else {\n        return {\n          type: 'Just',\n          value: new Date(+value || value)\n        };\n      }\n    },\n    RegExp: function(value, options){\n      var that;\n      if (that = /^\\/([\\s\\S]*)\\/([gimy]*)$/.exec(value)) {\n        return {\n          type: 'Just',\n          value: new RegExp(that[1], that[2])\n        };\n      } else if (options.explicit) {\n        return {\n          type: 'Nothing'\n        };\n      } else {\n        return {\n          type: 'Just',\n          value: new RegExp(value)\n        };\n      }\n    },\n    Array: function(value, options){\n      return castArray(value, {\n        of: [{\n          type: '*'\n        }]\n      }, options);\n    },\n    Object: function(value, options){\n      return castFields(value, {\n        of: {}\n      }, options);\n    },\n    String: function(it){\n      var that;\n      if (toString$.call(it).slice(8, -1) !== 'String') {\n        return {\n          type: 'Nothing'\n        };\n      }\n      if (that = it.match(/^'([\\s\\S]*)'$/)) {\n        return {\n          type: 'Just',\n          value: that[1].replace(/\\\\'/g, \"'\")\n        };\n      } else if (that = it.match(/^\"([\\s\\S]*)\"$/)) {\n        return {\n          type: 'Just',\n          value: that[1].replace(/\\\\\"/g, '\"')\n        };\n      } else {\n        return {\n          type: 'Just',\n          value: it\n        };\n      }\n    }\n  };\n  function castArray(node, type, options){\n    var typeOf, element;\n    if (toString$.call(node).slice(8, -1) !== 'Array') {\n      return {\n        type: 'Nothing'\n      };\n    }\n    typeOf = type.of;\n    return {\n      type: 'Just',\n      value: (function(){\n        var i$, ref$, len$, results$ = [];\n        for (i$ = 0, len$ = (ref$ = node).length; i$ < len$; ++i$) {\n          element = ref$[i$];\n          results$.push(typesCast(element, typeOf, options));\n        }\n        return results$;\n      }())\n    };\n  }\n  function castTuple(node, type, options){\n    var result, i, i$, ref$, len$, types, cast;\n    if (toString$.call(node).slice(8, -1) !== 'Array') {\n      return {\n        type: 'Nothing'\n      };\n    }\n    result = [];\n    i = 0;\n    for (i$ = 0, len$ = (ref$ = type.of).length; i$ < len$; ++i$) {\n      types = ref$[i$];\n      cast = typesCast(node[i], types, options);\n      if (toString$.call(cast).slice(8, -1) !== 'Undefined') {\n        result.push(cast);\n      }\n      i++;\n    }\n    if (node.length <= i) {\n      return {\n        type: 'Just',\n        value: result\n      };\n    } else {\n      return {\n        type: 'Nothing'\n      };\n    }\n  }\n  function castFields(node, type, options){\n    var typeOf, key, value;\n    if (toString$.call(node).slice(8, -1) !== 'Object') {\n      return {\n        type: 'Nothing'\n      };\n    }\n    typeOf = type.of;\n    return {\n      type: 'Just',\n      value: (function(){\n        var ref$, resultObj$ = {};\n        for (key in ref$ = node) {\n          value = ref$[key];\n          resultObj$[typesCast(key, [{\n            type: 'String'\n          }], options)] = typesCast(value, typeOf[key] || [{\n            type: '*'\n          }], options);\n        }\n        return resultObj$;\n      }())\n    };\n  }\n  function typeCast(node, typeObj, options){\n    var type, structure, castFunc, ref$;\n    type = typeObj.type, structure = typeObj.structure;\n    if (type) {\n      castFunc = ((ref$ = options.customTypes[type]) != null ? ref$.cast : void 8) || types[type];\n      if (!castFunc) {\n        throw new Error(\"Type not defined: \" + type + \".\");\n      }\n      return castFunc(node, options, typesCast);\n    } else {\n      switch (structure) {\n      case 'array':\n        return castArray(node, typeObj, options);\n      case 'tuple':\n        return castTuple(node, typeObj, options);\n      case 'fields':\n        return castFields(node, typeObj, options);\n      }\n    }\n  }\n  function typesCast(node, types, options){\n    var i$, len$, type, ref$, valueType, value;\n    for (i$ = 0, len$ = types.length; i$ < len$; ++i$) {\n      type = types[i$];\n      ref$ = typeCast(node, type, options), valueType = ref$.type, value = ref$.value;\n      if (valueType === 'Nothing') {\n        continue;\n      }\n      if (parsedTypeCheck([type], value, {\n        customTypes: options.customTypes\n      })) {\n        return value;\n      }\n    }\n    throw new Error(\"Value \" + JSON.stringify(node) + \" does not type check against \" + JSON.stringify(types) + \".\");\n  }\n  module.exports = typesCast;\n}).call(this);\n});\n\nvar lib$4 = createCommonjsModule(function (module) {\n// Generated by LiveScript 1.4.0\n(function(){\n  var parseString$1, cast$1, parseType, VERSION, parsedTypeParse, parse;\n  parseString$1 = parseString;\n  cast$1 = cast;\n  parseType = lib$3.parseType;\n  VERSION = '0.3.0';\n  parsedTypeParse = function(parsedType, string, options){\n    options == null && (options = {});\n    options.explicit == null && (options.explicit = false);\n    options.customTypes == null && (options.customTypes = {});\n    return cast$1(parseString$1(parsedType, string, options), parsedType, options);\n  };\n  parse = function(type, string, options){\n    return parsedTypeParse(parseType(type), string, options);\n  };\n  module.exports = {\n    VERSION: VERSION,\n    parse: parse,\n    parsedTypeParse: parsedTypeParse\n  };\n}).call(this);\n});\nvar lib_1$1 = lib$4.VERSION;\nvar lib_2$1 = lib$4.parse;\nvar lib_3$1 = lib$4.parsedTypeParse;\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\nconst debug$3 = src(\"eslint:config-comment-parser\");\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * Object to parse ESLint configuration comments inside JavaScript files.\n * @name ConfigCommentParser\n */\nvar configCommentParser = class ConfigCommentParser {\n\n    /**\n     * Parses a list of \"name:string_value\" or/and \"name\" options divided by comma or\n     * whitespace. Used for \"global\" and \"exported\" comments.\n     * @param {string} string The string to parse.\n     * @param {Comment} comment The comment node which has the string.\n     * @returns {Object} Result map object of names and string values, or null values if no value was provided\n     */\n    parseStringConfig(string, comment) {\n        debug$3(\"Parsing String config\");\n\n        const items = {};\n\n        // Collapse whitespace around `:` and `,` to make parsing easier\n        const trimmedString = string.replace(/\\s*([:,])\\s*/gu, \"$1\");\n\n        trimmedString.split(/\\s|,+/u).forEach(name => {\n            if (!name) {\n                return;\n            }\n\n            // value defaults to null (if not provided), e.g: \"foo\" => [\"foo\", null]\n            const [key, value = null] = name.split(\":\");\n\n            items[key] = { value, comment };\n        });\n        return items;\n    }\n\n    /**\n     * Parses a JSON-like config.\n     * @param {string} string The string to parse.\n     * @param {Object} location Start line and column of comments for potential error message.\n     * @returns {({success: true, config: Object}|{success: false, error: Problem})} Result map object\n     */\n    parseJsonConfig(string, location) {\n        debug$3(\"Parsing JSON config\");\n\n        let items = {};\n\n        // Parses a JSON-like comment by the same way as parsing CLI option.\n        try {\n            items = lib$4.parse(\"Object\", string) || {};\n\n            // Some tests say that it should ignore invalid comments such as `/*eslint no-alert:abc*/`.\n            // Also, commaless notations have invalid severity:\n            //     \"no-alert: 2 no-console: 2\" --> {\"no-alert\": \"2 no-console: 2\"}\n            // Should ignore that case as well.\n            if (configOps.isEverySeverityValid(items)) {\n                return {\n                    success: true,\n                    config: items\n                };\n            }\n        } catch (ex) {\n\n            debug$3(\"Levn parsing failed; falling back to manual parsing.\");\n\n            // ignore to parse the string by a fallback.\n        }\n\n        /*\n         * Optionator cannot parse commaless notations.\n         * But we are supporting that. So this is a fallback for that.\n         */\n        items = {};\n        const normalizedString = string.replace(/([-a-zA-Z0-9/]+):/gu, \"\\\"$1\\\":\").replace(/(\\]|[0-9])\\s+(?=\")/u, \"$1,\");\n\n        try {\n            items = JSON.parse(`{${normalizedString}}`);\n        } catch (ex) {\n            debug$3(\"Manual parsing failed.\");\n\n            return {\n                success: false,\n                error: {\n                    ruleId: null,\n                    fatal: true,\n                    severity: 2,\n                    message: `Failed to parse JSON from '${normalizedString}': ${ex.message}`,\n                    line: location.start.line,\n                    column: location.start.column + 1\n                }\n            };\n\n        }\n\n        return {\n            success: true,\n            config: items\n        };\n    }\n\n    /**\n     * Parses a config of values separated by comma.\n     * @param {string} string The string to parse.\n     * @returns {Object} Result map of values and true values\n     */\n    parseListConfig(string) {\n        debug$3(\"Parsing list config\");\n\n        const items = {};\n\n        // Collapse whitespace around commas\n        string.replace(/\\s*,\\s*/gu, \",\").split(/,+/u).forEach(name => {\n            const trimmedName = name.trim();\n\n            if (trimmedName) {\n                items[trimmedName] = true;\n            }\n        });\n        return items;\n    }\n\n};\n\nfunction e(t){return (e=\"function\"==typeof Symbol&&\"symbol\"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&\"function\"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?\"symbol\":typeof e})(t)}function t(e,t){return function(e){if(Array.isArray(e))return e}(e)||function(e,t){if(\"undefined\"==typeof Symbol||!(Symbol.iterator in Object(e)))return;var r=[],n=!0,o=!1,a=void 0;try{for(var s,i=e[Symbol.iterator]();!(n=(s=i.next()).done)&&(r.push(s.value),!t||r.length!==t);n=!0);}catch(e){o=!0,a=e;}finally{try{n||null==i.return||i.return();}finally{if(o)throw a}}return r}(e,t)||n(e,t)||function(){throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\")}()}function r(e){return function(e){if(Array.isArray(e))return o(e)}(e)||function(e){if(\"undefined\"!=typeof Symbol&&Symbol.iterator in Object(e))return Array.from(e)}(e)||n(e)||function(){throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\")}()}function n(e,t){if(e){if(\"string\"==typeof e)return o(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);return \"Object\"===r&&e.constructor&&(r=e.constructor.name),\"Map\"===r||\"Set\"===r?Array.from(r):\"Arguments\"===r||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r)?o(e,t):void 0}}function o(e,t){(null==t||t>e.length)&&(t=e.length);for(var r=0,n=new Array(t);r<t;r++)n[r]=e[r];return n}function a(e,t){return e(t={exports:{}},t.exports),t.exports}var s$1=a((function(e,t){!function e(t){var r,n,o,a,s,i;function l(e){var t,r,n={};for(t in e)e.hasOwnProperty(t)&&(r=e[t],n[t]=\"object\"==typeof r&&null!==r?l(r):r);return n}function u(e,t){this.parent=e,this.key=t;}function c(e,t,r,n){this.node=e,this.path=t,this.wrap=r,this.ref=n;}function p(){}function f(e){return null!=e&&(\"object\"==typeof e&&\"string\"==typeof e.type)}function h(e,t){return (e===r.ObjectExpression||e===r.ObjectPattern)&&\"properties\"===t}function d(e,t){for(var r=e.length-1;r>=0;--r)if(e[r].node===t)return !0;return !1}function y(e,t){return (new p).traverse(e,t)}function m(e,t){var r;return r=function(e,t){var r,n,o,a;for(n=e.length,o=0;n;)t(e[a=o+(r=n>>>1)])?n=r:(o=a+1,n-=r+1);return o}(t,(function(t){return t.range[0]>e.range[0]})),e.extendedRange=[e.range[0],e.range[1]],r!==t.length&&(e.extendedRange[1]=t[r].range[0]),(r-=1)>=0&&(e.extendedRange[0]=t[r].range[1]),e}return r={AssignmentExpression:\"AssignmentExpression\",AssignmentPattern:\"AssignmentPattern\",ArrayExpression:\"ArrayExpression\",ArrayPattern:\"ArrayPattern\",ArrowFunctionExpression:\"ArrowFunctionExpression\",AwaitExpression:\"AwaitExpression\",BlockStatement:\"BlockStatement\",BinaryExpression:\"BinaryExpression\",BreakStatement:\"BreakStatement\",CallExpression:\"CallExpression\",CatchClause:\"CatchClause\",ClassBody:\"ClassBody\",ClassDeclaration:\"ClassDeclaration\",ClassExpression:\"ClassExpression\",ComprehensionBlock:\"ComprehensionBlock\",ComprehensionExpression:\"ComprehensionExpression\",ConditionalExpression:\"ConditionalExpression\",ContinueStatement:\"ContinueStatement\",DebuggerStatement:\"DebuggerStatement\",DirectiveStatement:\"DirectiveStatement\",DoWhileStatement:\"DoWhileStatement\",EmptyStatement:\"EmptyStatement\",ExportAllDeclaration:\"ExportAllDeclaration\",ExportDefaultDeclaration:\"ExportDefaultDeclaration\",ExportNamedDeclaration:\"ExportNamedDeclaration\",ExportSpecifier:\"ExportSpecifier\",ExpressionStatement:\"ExpressionStatement\",ForStatement:\"ForStatement\",ForInStatement:\"ForInStatement\",ForOfStatement:\"ForOfStatement\",FunctionDeclaration:\"FunctionDeclaration\",FunctionExpression:\"FunctionExpression\",GeneratorExpression:\"GeneratorExpression\",Identifier:\"Identifier\",IfStatement:\"IfStatement\",ImportExpression:\"ImportExpression\",ImportDeclaration:\"ImportDeclaration\",ImportDefaultSpecifier:\"ImportDefaultSpecifier\",ImportNamespaceSpecifier:\"ImportNamespaceSpecifier\",ImportSpecifier:\"ImportSpecifier\",Literal:\"Literal\",LabeledStatement:\"LabeledStatement\",LogicalExpression:\"LogicalExpression\",MemberExpression:\"MemberExpression\",MetaProperty:\"MetaProperty\",MethodDefinition:\"MethodDefinition\",ModuleSpecifier:\"ModuleSpecifier\",NewExpression:\"NewExpression\",ObjectExpression:\"ObjectExpression\",ObjectPattern:\"ObjectPattern\",Program:\"Program\",Property:\"Property\",RestElement:\"RestElement\",ReturnStatement:\"ReturnStatement\",SequenceExpression:\"SequenceExpression\",SpreadElement:\"SpreadElement\",Super:\"Super\",SwitchStatement:\"SwitchStatement\",SwitchCase:\"SwitchCase\",TaggedTemplateExpression:\"TaggedTemplateExpression\",TemplateElement:\"TemplateElement\",TemplateLiteral:\"TemplateLiteral\",ThisExpression:\"ThisExpression\",ThrowStatement:\"ThrowStatement\",TryStatement:\"TryStatement\",UnaryExpression:\"UnaryExpression\",UpdateExpression:\"UpdateExpression\",VariableDeclaration:\"VariableDeclaration\",VariableDeclarator:\"VariableDeclarator\",WhileStatement:\"WhileStatement\",WithStatement:\"WithStatement\",YieldExpression:\"YieldExpression\"},o={AssignmentExpression:[\"left\",\"right\"],AssignmentPattern:[\"left\",\"right\"],ArrayExpression:[\"elements\"],ArrayPattern:[\"elements\"],ArrowFunctionExpression:[\"params\",\"body\"],AwaitExpression:[\"argument\"],BlockStatement:[\"body\"],BinaryExpression:[\"left\",\"right\"],BreakStatement:[\"label\"],CallExpression:[\"callee\",\"arguments\"],CatchClause:[\"param\",\"body\"],ClassBody:[\"body\"],ClassDeclaration:[\"id\",\"superClass\",\"body\"],ClassExpression:[\"id\",\"superClass\",\"body\"],ComprehensionBlock:[\"left\",\"right\"],ComprehensionExpression:[\"blocks\",\"filter\",\"body\"],ConditionalExpression:[\"test\",\"consequent\",\"alternate\"],ContinueStatement:[\"label\"],DebuggerStatement:[],DirectiveStatement:[],DoWhileStatement:[\"body\",\"test\"],EmptyStatement:[],ExportAllDeclaration:[\"source\"],ExportDefaultDeclaration:[\"declaration\"],ExportNamedDeclaration:[\"declaration\",\"specifiers\",\"source\"],ExportSpecifier:[\"exported\",\"local\"],ExpressionStatement:[\"expression\"],ForStatement:[\"init\",\"test\",\"update\",\"body\"],ForInStatement:[\"left\",\"right\",\"body\"],ForOfStatement:[\"left\",\"right\",\"body\"],FunctionDeclaration:[\"id\",\"params\",\"body\"],FunctionExpression:[\"id\",\"params\",\"body\"],GeneratorExpression:[\"blocks\",\"filter\",\"body\"],Identifier:[],IfStatement:[\"test\",\"consequent\",\"alternate\"],ImportExpression:[\"source\"],ImportDeclaration:[\"specifiers\",\"source\"],ImportDefaultSpecifier:[\"local\"],ImportNamespaceSpecifier:[\"local\"],ImportSpecifier:[\"imported\",\"local\"],Literal:[],LabeledStatement:[\"label\",\"body\"],LogicalExpression:[\"left\",\"right\"],MemberExpression:[\"object\",\"property\"],MetaProperty:[\"meta\",\"property\"],MethodDefinition:[\"key\",\"value\"],ModuleSpecifier:[],NewExpression:[\"callee\",\"arguments\"],ObjectExpression:[\"properties\"],ObjectPattern:[\"properties\"],Program:[\"body\"],Property:[\"key\",\"value\"],RestElement:[\"argument\"],ReturnStatement:[\"argument\"],SequenceExpression:[\"expressions\"],SpreadElement:[\"argument\"],Super:[],SwitchStatement:[\"discriminant\",\"cases\"],SwitchCase:[\"test\",\"consequent\"],TaggedTemplateExpression:[\"tag\",\"quasi\"],TemplateElement:[],TemplateLiteral:[\"quasis\",\"expressions\"],ThisExpression:[],ThrowStatement:[\"argument\"],TryStatement:[\"block\",\"handler\",\"finalizer\"],UnaryExpression:[\"argument\"],UpdateExpression:[\"argument\"],VariableDeclaration:[\"declarations\"],VariableDeclarator:[\"id\",\"init\"],WhileStatement:[\"test\",\"body\"],WithStatement:[\"object\",\"body\"],YieldExpression:[\"argument\"]},n={Break:a={},Skip:s={},Remove:i={}},u.prototype.replace=function(e){this.parent[this.key]=e;},u.prototype.remove=function(){return Array.isArray(this.parent)?(this.parent.splice(this.key,1),!0):(this.replace(null),!1)},p.prototype.path=function(){var e,t,r,n,o;function a(e,t){if(Array.isArray(t))for(r=0,n=t.length;r<n;++r)e.push(t[r]);else e.push(t);}if(!this.__current.path)return null;for(o=[],e=2,t=this.__leavelist.length;e<t;++e)a(o,this.__leavelist[e].path);return a(o,this.__current.path),o},p.prototype.type=function(){return this.current().type||this.__current.wrap},p.prototype.parents=function(){var e,t,r;for(r=[],e=1,t=this.__leavelist.length;e<t;++e)r.push(this.__leavelist[e].node);return r},p.prototype.current=function(){return this.__current.node},p.prototype.__execute=function(e,t){var r,n;return n=void 0,r=this.__current,this.__current=t,this.__state=null,e&&(n=e.call(this,t.node,this.__leavelist[this.__leavelist.length-1].node)),this.__current=r,n},p.prototype.notify=function(e){this.__state=e;},p.prototype.skip=function(){this.notify(s);},p.prototype.break=function(){this.notify(a);},p.prototype.remove=function(){this.notify(i);},p.prototype.__initialize=function(e,t){this.visitor=t,this.root=e,this.__worklist=[],this.__leavelist=[],this.__current=null,this.__state=null,this.__fallback=null,\"iteration\"===t.fallback?this.__fallback=Object.keys:\"function\"==typeof t.fallback&&(this.__fallback=t.fallback),this.__keys=o,t.keys&&(this.__keys=Object.assign(Object.create(this.__keys),t.keys));},p.prototype.traverse=function(e,t){var r,n,o,i,l,u,p,y,m,x,g,v;for(this.__initialize(e,t),v={},r=this.__worklist,n=this.__leavelist,r.push(new c(e,null,null,null)),n.push(new c(null,null,null,null));r.length;)if((o=r.pop())!==v){if(o.node){if(u=this.__execute(t.enter,o),this.__state===a||u===a)return;if(r.push(v),n.push(o),this.__state===s||u===s)continue;if(l=(i=o.node).type||o.wrap,!(x=this.__keys[l])){if(!this.__fallback)throw new Error(\"Unknown node type \"+l+\".\");x=this.__fallback(i);}for(y=x.length;(y-=1)>=0;)if(g=i[p=x[y]])if(Array.isArray(g)){for(m=g.length;(m-=1)>=0;)if(g[m]&&!d(n,g[m])){if(h(l,x[y]))o=new c(g[m],[p,m],\"Property\",null);else {if(!f(g[m]))continue;o=new c(g[m],[p,m],null,null);}r.push(o);}}else if(f(g)){if(d(n,g))continue;r.push(new c(g,p,null,null));}}}else if(o=n.pop(),u=this.__execute(t.leave,o),this.__state===a||u===a)return},p.prototype.replace=function(e,t){var r,n,o,l,p,d,y,m,x,g,v,A,b;function E(e){var t,n,o,a;if(e.ref.remove())for(n=e.ref.key,a=e.ref.parent,t=r.length;t--;)if((o=r[t]).ref&&o.ref.parent===a){if(o.ref.key<n)break;--o.ref.key;}}for(this.__initialize(e,t),v={},r=this.__worklist,n=this.__leavelist,d=new c(e,null,null,new u(A={root:e},\"root\")),r.push(d),n.push(d);r.length;)if((d=r.pop())!==v){if(void 0!==(p=this.__execute(t.enter,d))&&p!==a&&p!==s&&p!==i&&(d.ref.replace(p),d.node=p),this.__state!==i&&p!==i||(E(d),d.node=null),this.__state===a||p===a)return A.root;if((o=d.node)&&(r.push(v),n.push(d),this.__state!==s&&p!==s)){if(l=o.type||d.wrap,!(x=this.__keys[l])){if(!this.__fallback)throw new Error(\"Unknown node type \"+l+\".\");x=this.__fallback(o);}for(y=x.length;(y-=1)>=0;)if(g=o[b=x[y]])if(Array.isArray(g)){for(m=g.length;(m-=1)>=0;)if(g[m]){if(h(l,x[y]))d=new c(g[m],[b,m],\"Property\",new u(g,m));else {if(!f(g[m]))continue;d=new c(g[m],[b,m],null,new u(g,m));}r.push(d);}}else f(g)&&r.push(new c(g,b,null,new u(o,b)));}}else if(d=n.pop(),void 0!==(p=this.__execute(t.leave,d))&&p!==a&&p!==s&&p!==i&&d.ref.replace(p),this.__state!==i&&p!==i||E(d),this.__state===a||p===a)return A.root;return A.root},t.Syntax=r,t.traverse=y,t.replace=function(e,t){return (new p).replace(e,t)},t.attachComments=function(e,t,r){var o,a,s,i,u=[];if(!e.range)throw new Error(\"attachComments needs range information\");if(!r.length){if(t.length){for(s=0,a=t.length;s<a;s+=1)(o=l(t[s])).extendedRange=[0,e.range[0]],u.push(o);e.leadingComments=u;}return e}for(s=0,a=t.length;s<a;s+=1)u.push(m(l(t[s]),r));return i=0,y(e,{enter:function(e){for(var t;i<u.length&&!((t=u[i]).extendedRange[1]>e.range[0]);)t.extendedRange[1]===e.range[0]?(e.leadingComments||(e.leadingComments=[]),e.leadingComments.push(t),u.splice(i,1)):i+=1;return i===u.length?n.Break:u[i].extendedRange[0]>e.range[1]?n.Skip:void 0}}),i=0,y(e,{leave:function(e){for(var t;i<u.length&&(t=u[i],!(e.range[1]<t.extendedRange[0]));)e.range[1]===t.extendedRange[0]?(e.trailingComments||(e.trailingComments=[]),e.trailingComments.push(t),u.splice(i,1)):i+=1;return i===u.length?n.Break:u[i].extendedRange[0]>e.range[1]?n.Skip:void 0}}),e},t.VisitorKeys=o,t.VisitorOption=n,t.Controller=p,t.cloneEnvironment=function(){return e({})},t}(t);})),i$1=a((function(e){e.exports&&(e.exports=function(){function e(t,r,n,o){this.message=t,this.expected=r,this.found=n,this.location=o,this.name=\"SyntaxError\",\"function\"==typeof Error.captureStackTrace&&Error.captureStackTrace(this,e);}return function(e,t){function r(){this.constructor=e;}r.prototype=t.prototype,e.prototype=new r;}(e,Error),e.buildMessage=function(e,t){var r={literal:function(e){return '\"'+o(e.text)+'\"'},class:function(e){var t,r=\"\";for(t=0;t<e.parts.length;t++)r+=e.parts[t]instanceof Array?a(e.parts[t][0])+\"-\"+a(e.parts[t][1]):a(e.parts[t]);return \"[\"+(e.inverted?\"^\":\"\")+r+\"]\"},any:function(e){return \"any character\"},end:function(e){return \"end of input\"},other:function(e){return e.description}};function n(e){return e.charCodeAt(0).toString(16).toUpperCase()}function o(e){return e.replace(/\\\\/g,\"\\\\\\\\\").replace(/\"/g,'\\\\\"').replace(/\\0/g,\"\\\\0\").replace(/\\t/g,\"\\\\t\").replace(/\\n/g,\"\\\\n\").replace(/\\r/g,\"\\\\r\").replace(/[\\x00-\\x0F]/g,(function(e){return \"\\\\x0\"+n(e)})).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g,(function(e){return \"\\\\x\"+n(e)}))}function a(e){return e.replace(/\\\\/g,\"\\\\\\\\\").replace(/\\]/g,\"\\\\]\").replace(/\\^/g,\"\\\\^\").replace(/-/g,\"\\\\-\").replace(/\\0/g,\"\\\\0\").replace(/\\t/g,\"\\\\t\").replace(/\\n/g,\"\\\\n\").replace(/\\r/g,\"\\\\r\").replace(/[\\x00-\\x0F]/g,(function(e){return \"\\\\x0\"+n(e)})).replace(/[\\x10-\\x1F\\x7F-\\x9F]/g,(function(e){return \"\\\\x\"+n(e)}))}return \"Expected \"+function(e){var t,n,o,a=new Array(e.length);for(t=0;t<e.length;t++)a[t]=(o=e[t],r[o.type](o));if(a.sort(),a.length>0){for(t=1,n=1;t<a.length;t++)a[t-1]!==a[t]&&(a[n]=a[t],n++);a.length=n;}switch(a.length){case 1:return a[0];case 2:return a[0]+\" or \"+a[1];default:return a.slice(0,-1).join(\", \")+\", or \"+a[a.length-1]}}(e)+\" but \"+function(e){return e?'\"'+o(e)+'\"':\"end of input\"}(t)+\" found.\"},{SyntaxError:e,parse:function(t,r){r=void 0!==r?r:{};var n,o,a,s,i={},l={start:be},u=be,c=me(\" \",!1),p=/^[^ [\\],():#!=><~+.]/,f=xe([\" \",\"[\",\"]\",\",\",\"(\",\")\",\":\",\"#\",\"!\",\"=\",\">\",\"<\",\"~\",\"+\",\".\"],!0,!1),h=function(e){return e.join(\"\")},d=me(\">\",!1),y=me(\"~\",!1),m=me(\"+\",!1),x=me(\",\",!1),g=me(\"!\",!1),v=me(\"*\",!1),A=me(\"#\",!1),b=me(\"[\",!1),E=me(\"]\",!1),S=/^[><!]/,_=xe([\">\",\"<\",\"!\"],!1,!1),w=me(\"=\",!1),C=function(e){return (e||\"\")+\"=\"},P=/^[><]/,k=xe([\">\",\"<\"],!1,!1),D=me(\".\",!1),I=function(e,t,r){return {type:\"attribute\",name:e,operator:t,value:r}},j=me('\"',!1),F=/^[^\\\\\"]/,T=xe([\"\\\\\",'\"'],!0,!1),L=me(\"\\\\\",!1),R={type:\"any\"},O=function(e,t){return e+t},B=function(e){return {type:\"literal\",value:(t=e.join(\"\"),t.replace(/\\\\(.)/g,(function(e,t){switch(t){case\"b\":return \"\\b\";case\"f\":return \"\\f\";case\"n\":return \"\\n\";case\"r\":return \"\\r\";case\"t\":return \"\\t\";case\"v\":return \"\\v\";default:return t}})))};var t;},M=me(\"'\",!1),U=/^[^\\\\']/,V=xe([\"\\\\\",\"'\"],!0,!1),q=/^[0-9]/,N=xe([[\"0\",\"9\"]],!1,!1),W=me(\"type(\",!1),G=/^[^ )]/,z=xe([\" \",\")\"],!0,!1),K=me(\")\",!1),H=/^[imsu]/,Y=xe([\"i\",\"m\",\"s\",\"u\"],!1,!1),$=me(\"/\",!1),J=/^[^\\/]/,Q=xe([\"/\"],!0,!1),X=me(\":not(\",!1),Z=me(\":matches(\",!1),ee=me(\":has(\",!1),te=me(\":first-child\",!1),re=me(\":last-child\",!1),ne=me(\":nth-child(\",!1),oe=me(\":nth-last-child(\",!1),ae=me(\":\",!1),se=me(\"statement\",!0),ie=me(\"expression\",!0),le=me(\"declaration\",!0),ue=me(\"function\",!0),ce=me(\"pattern\",!0),pe=0,fe=[{line:1,column:1}],he=0,de=[],ye={};if(\"startRule\"in r){if(!(r.startRule in l))throw new Error(\"Can't start parsing from rule \\\"\"+r.startRule+'\".');u=l[r.startRule];}function me(e,t){return {type:\"literal\",text:e,ignoreCase:t}}function xe(e,t,r){return {type:\"class\",parts:e,inverted:t,ignoreCase:r}}function ge(e){var r,n=fe[e];if(n)return n;for(r=e-1;!fe[r];)r--;for(n={line:(n=fe[r]).line,column:n.column};r<e;)10===t.charCodeAt(r)?(n.line++,n.column=1):n.column++,r++;return fe[e]=n,n}function ve(e,t){var r=ge(e),n=ge(t);return {start:{offset:e,line:r.line,column:r.column},end:{offset:t,line:n.line,column:n.column}}}function Ae(e){pe<he||(pe>he&&(he=pe,de=[]),de.push(e));}function be(){var e,t,r,n,o=30*pe+0,a=ye[o];return a?(pe=a.nextPos,a.result):(e=pe,(t=Ee())!==i&&(r=we())!==i&&Ee()!==i?e=t=1===(n=r).length?n[0]:{type:\"matches\",selectors:n}:(pe=e,e=i),e===i&&(e=pe,(t=Ee())!==i&&(t=void 0),e=t),ye[o]={nextPos:pe,result:e},e)}function Ee(){var e,r,n=30*pe+1,o=ye[n];if(o)return pe=o.nextPos,o.result;for(e=[],32===t.charCodeAt(pe)?(r=\" \",pe++):(r=i,Ae(c));r!==i;)e.push(r),32===t.charCodeAt(pe)?(r=\" \",pe++):(r=i,Ae(c));return ye[n]={nextPos:pe,result:e},e}function Se(){var e,r,n,o=30*pe+2,a=ye[o];if(a)return pe=a.nextPos,a.result;if(r=[],p.test(t.charAt(pe))?(n=t.charAt(pe),pe++):(n=i,Ae(f)),n!==i)for(;n!==i;)r.push(n),p.test(t.charAt(pe))?(n=t.charAt(pe),pe++):(n=i,Ae(f));else r=i;return r!==i&&(r=h(r)),e=r,ye[o]={nextPos:pe,result:e},e}function _e(){var e,r,n,o=30*pe+3,a=ye[o];return a?(pe=a.nextPos,a.result):(e=pe,(r=Ee())!==i?(62===t.charCodeAt(pe)?(n=\">\",pe++):(n=i,Ae(d)),n!==i&&Ee()!==i?e=r=\"child\":(pe=e,e=i)):(pe=e,e=i),e===i&&(e=pe,(r=Ee())!==i?(126===t.charCodeAt(pe)?(n=\"~\",pe++):(n=i,Ae(y)),n!==i&&Ee()!==i?e=r=\"sibling\":(pe=e,e=i)):(pe=e,e=i),e===i&&(e=pe,(r=Ee())!==i?(43===t.charCodeAt(pe)?(n=\"+\",pe++):(n=i,Ae(m)),n!==i&&Ee()!==i?e=r=\"adjacent\":(pe=e,e=i)):(pe=e,e=i),e===i&&(e=pe,32===t.charCodeAt(pe)?(r=\" \",pe++):(r=i,Ae(c)),r!==i&&(n=Ee())!==i?e=r=\"descendant\":(pe=e,e=i)))),ye[o]={nextPos:pe,result:e},e)}function we(){var e,r,n,o,a,s,l,u,c=30*pe+4,p=ye[c];if(p)return pe=p.nextPos,p.result;if(e=pe,(r=Ce())!==i){for(n=[],o=pe,(a=Ee())!==i?(44===t.charCodeAt(pe)?(s=\",\",pe++):(s=i,Ae(x)),s!==i&&(l=Ee())!==i&&(u=Ce())!==i?o=a=[a,s,l,u]:(pe=o,o=i)):(pe=o,o=i);o!==i;)n.push(o),o=pe,(a=Ee())!==i?(44===t.charCodeAt(pe)?(s=\",\",pe++):(s=i,Ae(x)),s!==i&&(l=Ee())!==i&&(u=Ce())!==i?o=a=[a,s,l,u]:(pe=o,o=i)):(pe=o,o=i);n!==i?e=r=[r].concat(n.map((function(e){return e[3]}))):(pe=e,e=i);}else pe=e,e=i;return ye[c]={nextPos:pe,result:e},e}function Ce(){var e,t,r,n,o,a,s,l=30*pe+5,u=ye[l];if(u)return pe=u.nextPos,u.result;if(e=pe,(t=Pe())!==i){for(r=[],n=pe,(o=_e())!==i&&(a=Pe())!==i?n=o=[o,a]:(pe=n,n=i);n!==i;)r.push(n),n=pe,(o=_e())!==i&&(a=Pe())!==i?n=o=[o,a]:(pe=n,n=i);r!==i?(s=t,e=t=r.reduce((function(e,t){return {type:t[0],left:e,right:t[1]}}),s)):(pe=e,e=i);}else pe=e,e=i;return ye[l]={nextPos:pe,result:e},e}function Pe(){var e,r,n,o,a,s,l,u=30*pe+6,c=ye[u];if(c)return pe=c.nextPos,c.result;if(e=pe,33===t.charCodeAt(pe)?(r=\"!\",pe++):(r=i,Ae(g)),r===i&&(r=null),r!==i){if(n=[],(o=ke())!==i)for(;o!==i;)n.push(o),o=ke();else n=i;n!==i?(a=r,l=1===(s=n).length?s[0]:{type:\"compound\",selectors:s},a&&(l.subject=!0),e=r=l):(pe=e,e=i);}else pe=e,e=i;return ye[u]={nextPos:pe,result:e},e}function ke(){var e,r=30*pe+7,n=ye[r];return n?(pe=n.nextPos,n.result):((e=function(){var e,r,n=30*pe+8,o=ye[n];return o?(pe=o.nextPos,o.result):(42===t.charCodeAt(pe)?(r=\"*\",pe++):(r=i,Ae(v)),r!==i&&(r={type:\"wildcard\",value:r}),e=r,ye[n]={nextPos:pe,result:e},e)}())===i&&(e=function(){var e,r,n,o=30*pe+9,a=ye[o];return a?(pe=a.nextPos,a.result):(e=pe,35===t.charCodeAt(pe)?(r=\"#\",pe++):(r=i,Ae(A)),r===i&&(r=null),r!==i&&(n=Se())!==i?e=r={type:\"identifier\",value:n}:(pe=e,e=i),ye[o]={nextPos:pe,result:e},e)}())===i&&(e=function(){var e,r,n,o,a=30*pe+10,s=ye[a];return s?(pe=s.nextPos,s.result):(e=pe,91===t.charCodeAt(pe)?(r=\"[\",pe++):(r=i,Ae(b)),r!==i&&Ee()!==i&&(n=function(){var e,r,n,o,a=30*pe+14,s=ye[a];return s?(pe=s.nextPos,s.result):(e=pe,(r=De())!==i&&Ee()!==i&&(n=function(){var e,r,n,o=30*pe+12,a=ye[o];return a?(pe=a.nextPos,a.result):(e=pe,33===t.charCodeAt(pe)?(r=\"!\",pe++):(r=i,Ae(g)),r===i&&(r=null),r!==i?(61===t.charCodeAt(pe)?(n=\"=\",pe++):(n=i,Ae(w)),n!==i?(r=C(r),e=r):(pe=e,e=i)):(pe=e,e=i),ye[o]={nextPos:pe,result:e},e)}())!==i&&Ee()!==i?((o=function(){var e,r,n,o,a,s=30*pe+18,l=ye[s];if(l)return pe=l.nextPos,l.result;if(e=pe,\"type(\"===t.substr(pe,5)?(r=\"type(\",pe+=5):(r=i,Ae(W)),r!==i)if(Ee()!==i){if(n=[],G.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(z)),o!==i)for(;o!==i;)n.push(o),G.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(z));else n=i;n!==i&&(o=Ee())!==i?(41===t.charCodeAt(pe)?(a=\")\",pe++):(a=i,Ae(K)),a!==i?(r={type:\"type\",value:n.join(\"\")},e=r):(pe=e,e=i)):(pe=e,e=i);}else pe=e,e=i;else pe=e,e=i;return ye[s]={nextPos:pe,result:e},e}())===i&&(o=function(){var e,r,n,o,a,s,l=30*pe+20,u=ye[l];if(u)return pe=u.nextPos,u.result;if(e=pe,47===t.charCodeAt(pe)?(r=\"/\",pe++):(r=i,Ae($)),r!==i){if(n=[],J.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(Q)),o!==i)for(;o!==i;)n.push(o),J.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(Q));else n=i;n!==i?(47===t.charCodeAt(pe)?(o=\"/\",pe++):(o=i,Ae($)),o!==i?((a=function(){var e,r,n=30*pe+19,o=ye[n];if(o)return pe=o.nextPos,o.result;if(e=[],H.test(t.charAt(pe))?(r=t.charAt(pe),pe++):(r=i,Ae(Y)),r!==i)for(;r!==i;)e.push(r),H.test(t.charAt(pe))?(r=t.charAt(pe),pe++):(r=i,Ae(Y));else e=i;return ye[n]={nextPos:pe,result:e},e}())===i&&(a=null),a!==i?(s=a,r={type:\"regexp\",value:new RegExp(n.join(\"\"),s?s.join(\"\"):\"\")},e=r):(pe=e,e=i)):(pe=e,e=i)):(pe=e,e=i);}else pe=e,e=i;return ye[l]={nextPos:pe,result:e},e}()),o!==i?(r=I(r,n,o),e=r):(pe=e,e=i)):(pe=e,e=i),e===i&&(e=pe,(r=De())!==i&&Ee()!==i&&(n=function(){var e,r,n,o=30*pe+11,a=ye[o];return a?(pe=a.nextPos,a.result):(e=pe,S.test(t.charAt(pe))?(r=t.charAt(pe),pe++):(r=i,Ae(_)),r===i&&(r=null),r!==i?(61===t.charCodeAt(pe)?(n=\"=\",pe++):(n=i,Ae(w)),n!==i?(r=C(r),e=r):(pe=e,e=i)):(pe=e,e=i),e===i&&(P.test(t.charAt(pe))?(e=t.charAt(pe),pe++):(e=i,Ae(k))),ye[o]={nextPos:pe,result:e},e)}())!==i&&Ee()!==i?((o=function(){var e,r,n,o,a,s,l=30*pe+15,u=ye[l];if(u)return pe=u.nextPos,u.result;if(e=pe,34===t.charCodeAt(pe)?(r='\"',pe++):(r=i,Ae(j)),r!==i){for(n=[],F.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(T)),o===i&&(o=pe,92===t.charCodeAt(pe)?(a=\"\\\\\",pe++):(a=i,Ae(L)),a!==i?(t.length>pe?(s=t.charAt(pe),pe++):(s=i,Ae(R)),s!==i?(a=O(a,s),o=a):(pe=o,o=i)):(pe=o,o=i));o!==i;)n.push(o),F.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(T)),o===i&&(o=pe,92===t.charCodeAt(pe)?(a=\"\\\\\",pe++):(a=i,Ae(L)),a!==i?(t.length>pe?(s=t.charAt(pe),pe++):(s=i,Ae(R)),s!==i?(a=O(a,s),o=a):(pe=o,o=i)):(pe=o,o=i));n!==i?(34===t.charCodeAt(pe)?(o='\"',pe++):(o=i,Ae(j)),o!==i?(r=B(n),e=r):(pe=e,e=i)):(pe=e,e=i);}else pe=e,e=i;if(e===i)if(e=pe,39===t.charCodeAt(pe)?(r=\"'\",pe++):(r=i,Ae(M)),r!==i){for(n=[],U.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(V)),o===i&&(o=pe,92===t.charCodeAt(pe)?(a=\"\\\\\",pe++):(a=i,Ae(L)),a!==i?(t.length>pe?(s=t.charAt(pe),pe++):(s=i,Ae(R)),s!==i?(a=O(a,s),o=a):(pe=o,o=i)):(pe=o,o=i));o!==i;)n.push(o),U.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(V)),o===i&&(o=pe,92===t.charCodeAt(pe)?(a=\"\\\\\",pe++):(a=i,Ae(L)),a!==i?(t.length>pe?(s=t.charAt(pe),pe++):(s=i,Ae(R)),s!==i?(a=O(a,s),o=a):(pe=o,o=i)):(pe=o,o=i));n!==i?(39===t.charCodeAt(pe)?(o=\"'\",pe++):(o=i,Ae(M)),o!==i?(r=B(n),e=r):(pe=e,e=i)):(pe=e,e=i);}else pe=e,e=i;return ye[l]={nextPos:pe,result:e},e}())===i&&(o=function(){var e,r,n,o,a,s,l,u=30*pe+16,c=ye[u];if(c)return pe=c.nextPos,c.result;for(e=pe,r=pe,n=[],q.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(N));o!==i;)n.push(o),q.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(N));if(n!==i?(46===t.charCodeAt(pe)?(o=\".\",pe++):(o=i,Ae(D)),o!==i?r=n=[n,o]:(pe=r,r=i)):(pe=r,r=i),r===i&&(r=null),r!==i){if(n=[],q.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(N)),o!==i)for(;o!==i;)n.push(o),q.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(N));else n=i;n!==i?(s=n,l=(a=r)?[].concat.apply([],a).join(\"\"):\"\",r={type:\"literal\",value:parseFloat(l+s.join(\"\"))},e=r):(pe=e,e=i);}else pe=e,e=i;return ye[u]={nextPos:pe,result:e},e}())===i&&(o=function(){var e,t,r=30*pe+17,n=ye[r];return n?(pe=n.nextPos,n.result):((t=Se())!==i&&(t={type:\"literal\",value:t}),e=t,ye[r]={nextPos:pe,result:e},e)}()),o!==i?(r=I(r,n,o),e=r):(pe=e,e=i)):(pe=e,e=i),e===i&&(e=pe,(r=De())!==i&&(r={type:\"attribute\",name:r}),e=r)),ye[a]={nextPos:pe,result:e},e)}())!==i&&Ee()!==i?(93===t.charCodeAt(pe)?(o=\"]\",pe++):(o=i,Ae(E)),o!==i?e=r=n:(pe=e,e=i)):(pe=e,e=i),ye[a]={nextPos:pe,result:e},e)}())===i&&(e=function(){var e,r,n,o,a,s,l,u,c=30*pe+21,p=ye[c];if(p)return pe=p.nextPos,p.result;if(e=pe,46===t.charCodeAt(pe)?(r=\".\",pe++):(r=i,Ae(D)),r!==i)if((n=Se())!==i){for(o=[],a=pe,46===t.charCodeAt(pe)?(s=\".\",pe++):(s=i,Ae(D)),s!==i&&(l=Se())!==i?a=s=[s,l]:(pe=a,a=i);a!==i;)o.push(a),a=pe,46===t.charCodeAt(pe)?(s=\".\",pe++):(s=i,Ae(D)),s!==i&&(l=Se())!==i?a=s=[s,l]:(pe=a,a=i);o!==i?(u=n,r={type:\"field\",name:o.reduce((function(e,t){return e+t[0]+t[1]}),u)},e=r):(pe=e,e=i);}else pe=e,e=i;else pe=e,e=i;return ye[c]={nextPos:pe,result:e},e}())===i&&(e=function(){var e,r,n,o,a=30*pe+22,s=ye[a];return s?(pe=s.nextPos,s.result):(e=pe,\":not(\"===t.substr(pe,5)?(r=\":not(\",pe+=5):(r=i,Ae(X)),r!==i&&Ee()!==i&&(n=we())!==i&&Ee()!==i?(41===t.charCodeAt(pe)?(o=\")\",pe++):(o=i,Ae(K)),o!==i?e=r={type:\"not\",selectors:n}:(pe=e,e=i)):(pe=e,e=i),ye[a]={nextPos:pe,result:e},e)}())===i&&(e=function(){var e,r,n,o,a=30*pe+23,s=ye[a];return s?(pe=s.nextPos,s.result):(e=pe,\":matches(\"===t.substr(pe,9)?(r=\":matches(\",pe+=9):(r=i,Ae(Z)),r!==i&&Ee()!==i&&(n=we())!==i&&Ee()!==i?(41===t.charCodeAt(pe)?(o=\")\",pe++):(o=i,Ae(K)),o!==i?e=r={type:\"matches\",selectors:n}:(pe=e,e=i)):(pe=e,e=i),ye[a]={nextPos:pe,result:e},e)}())===i&&(e=function(){var e,r,n,o,a=30*pe+24,s=ye[a];return s?(pe=s.nextPos,s.result):(e=pe,\":has(\"===t.substr(pe,5)?(r=\":has(\",pe+=5):(r=i,Ae(ee)),r!==i&&Ee()!==i&&(n=we())!==i&&Ee()!==i?(41===t.charCodeAt(pe)?(o=\")\",pe++):(o=i,Ae(K)),o!==i?e=r={type:\"has\",selectors:n}:(pe=e,e=i)):(pe=e,e=i),ye[a]={nextPos:pe,result:e},e)}())===i&&(e=function(){var e,r,n=30*pe+25,o=ye[n];return o?(pe=o.nextPos,o.result):(\":first-child\"===t.substr(pe,12)?(r=\":first-child\",pe+=12):(r=i,Ae(te)),r!==i&&(r=Ie(1)),e=r,ye[n]={nextPos:pe,result:e},e)}())===i&&(e=function(){var e,r,n=30*pe+26,o=ye[n];return o?(pe=o.nextPos,o.result):(\":last-child\"===t.substr(pe,11)?(r=\":last-child\",pe+=11):(r=i,Ae(re)),r!==i&&(r=je(1)),e=r,ye[n]={nextPos:pe,result:e},e)}())===i&&(e=function(){var e,r,n,o,a,s=30*pe+27,l=ye[s];if(l)return pe=l.nextPos,l.result;if(e=pe,\":nth-child(\"===t.substr(pe,11)?(r=\":nth-child(\",pe+=11):(r=i,Ae(ne)),r!==i)if(Ee()!==i){if(n=[],q.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(N)),o!==i)for(;o!==i;)n.push(o),q.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(N));else n=i;n!==i&&(o=Ee())!==i?(41===t.charCodeAt(pe)?(a=\")\",pe++):(a=i,Ae(K)),a!==i?(r=Ie(parseInt(n.join(\"\"),10)),e=r):(pe=e,e=i)):(pe=e,e=i);}else pe=e,e=i;else pe=e,e=i;return ye[s]={nextPos:pe,result:e},e}())===i&&(e=function(){var e,r,n,o,a,s=30*pe+28,l=ye[s];if(l)return pe=l.nextPos,l.result;if(e=pe,\":nth-last-child(\"===t.substr(pe,16)?(r=\":nth-last-child(\",pe+=16):(r=i,Ae(oe)),r!==i)if(Ee()!==i){if(n=[],q.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(N)),o!==i)for(;o!==i;)n.push(o),q.test(t.charAt(pe))?(o=t.charAt(pe),pe++):(o=i,Ae(N));else n=i;n!==i&&(o=Ee())!==i?(41===t.charCodeAt(pe)?(a=\")\",pe++):(a=i,Ae(K)),a!==i?(r=je(parseInt(n.join(\"\"),10)),e=r):(pe=e,e=i)):(pe=e,e=i);}else pe=e,e=i;else pe=e,e=i;return ye[s]={nextPos:pe,result:e},e}())===i&&(e=function(){var e,r,n,o=30*pe+29,a=ye[o];return a?(pe=a.nextPos,a.result):(e=pe,58===t.charCodeAt(pe)?(r=\":\",pe++):(r=i,Ae(ae)),r!==i?(\"statement\"===t.substr(pe,9).toLowerCase()?(n=t.substr(pe,9),pe+=9):(n=i,Ae(se)),n===i&&(\"expression\"===t.substr(pe,10).toLowerCase()?(n=t.substr(pe,10),pe+=10):(n=i,Ae(ie)),n===i&&(\"declaration\"===t.substr(pe,11).toLowerCase()?(n=t.substr(pe,11),pe+=11):(n=i,Ae(le)),n===i&&(\"function\"===t.substr(pe,8).toLowerCase()?(n=t.substr(pe,8),pe+=8):(n=i,Ae(ue)),n===i&&(\"pattern\"===t.substr(pe,7).toLowerCase()?(n=t.substr(pe,7),pe+=7):(n=i,Ae(ce)))))),n!==i?e=r={type:\"class\",name:n}:(pe=e,e=i)):(pe=e,e=i),ye[o]={nextPos:pe,result:e},e)}()),ye[r]={nextPos:pe,result:e},e)}function De(){var e,r,n,o=30*pe+13,a=ye[o];if(a)return pe=a.nextPos,a.result;if(r=[],(n=Se())===i&&(46===t.charCodeAt(pe)?(n=\".\",pe++):(n=i,Ae(D))),n!==i)for(;n!==i;)r.push(n),(n=Se())===i&&(46===t.charCodeAt(pe)?(n=\".\",pe++):(n=i,Ae(D)));else r=i;return r!==i&&(r=h(r)),e=r,ye[o]={nextPos:pe,result:e},e}function Ie(e){return {type:\"nth-child\",index:{type:\"literal\",value:e}}}function je(e){return {type:\"nth-last-child\",index:{type:\"literal\",value:e}}}if((n=u())!==i&&pe===t.length)return n;throw n!==i&&pe<t.length&&Ae({type:\"end\"}),o=de,a=he<t.length?t.charAt(he):null,s=he<t.length?ve(he,he+1):ve(he,he),new e(e.buildMessage(o,a),o,a,s)}}}());}));function l(t,r,n){if(!r)return !0;if(!t)return !1;switch(n||(n=[]),r.type){case\"wildcard\":return !0;case\"identifier\":return r.value.toLowerCase()===t.type.toLowerCase();case\"field\":var o=r.name.split(\".\"),a=n[o.length-1];return function e(t,r,n){if(0===n.length)return t===r;if(null==r)return !1;var o=r[n[0]],a=n.slice(1);if(Array.isArray(o)){for(var s=0,i=o.length;s<i;++s)if(e(t,o[s],a))return !0;return !1}return e(t,o,a)}(t,a,o);case\"matches\":for(var i=0,f=r.selectors.length;i<f;++i)if(l(t,r.selectors[i],n))return !0;return !1;case\"compound\":for(var h=0,d=r.selectors.length;h<d;++h)if(!l(t,r.selectors[h],n))return !1;return !0;case\"not\":for(var y=0,m=r.selectors.length;y<m;++y)if(l(t,r.selectors[y],n))return !1;return !0;case\"has\":var x=function(){for(var e=[],n=function(n,o){var a=[];s$1.traverse(t,{enter:function(t,o){null!=o&&a.unshift(o),l(t,r.selectors[n],a)&&e.push(t);},leave:function(){a.shift();},fallback:\"iteration\"});},o=0,a=r.selectors.length;o<a;++o)n(o);return {v:0!==e.length}}();if(\"object\"===e(x))return x.v;case\"child\":return !!l(t,r.right,n)&&l(n[0],r.left,n.slice(1));case\"descendant\":if(l(t,r.right,n))for(var g=0,v=n.length;g<v;++g)if(l(n[g],r.left,n.slice(g+1)))return !0;return !1;case\"attribute\":var A=function(e,t){for(var r=t.split(\".\"),n=0;n<r.length;n++){if(null==e)return e;e=e[r[n]];}return e}(t,r.name);switch(r.operator){case void 0:return null!=A;case\"=\":switch(r.value.type){case\"regexp\":return \"string\"==typeof A&&r.value.value.test(A);case\"literal\":return \"\".concat(r.value.value)===\"\".concat(A);case\"type\":return r.value.value===e(A)}throw new Error(\"Unknown selector value type: \".concat(r.value.type));case\"!=\":switch(r.value.type){case\"regexp\":return !r.value.value.test(A);case\"literal\":return \"\".concat(r.value.value)!==\"\".concat(A);case\"type\":return r.value.value!==e(A)}throw new Error(\"Unknown selector value type: \".concat(r.value.type));case\"<=\":return A<=r.value.value;case\"<\":return A<r.value.value;case\">\":return A>r.value.value;case\">=\":return A>=r.value.value}throw new Error(\"Unknown operator: \".concat(r.operator));case\"sibling\":return l(t,r.right,n)&&u(t,r.left,n,\"LEFT_SIDE\")||r.left.subject&&l(t,r.left,n)&&u(t,r.right,n,\"RIGHT_SIDE\");case\"adjacent\":return l(t,r.right,n)&&c(t,r.left,n,\"LEFT_SIDE\")||r.right.subject&&l(t,r.left,n)&&c(t,r.right,n,\"RIGHT_SIDE\");case\"nth-child\":return l(t,r.right,n)&&p(t,n,(function(){return r.index.value-1}));case\"nth-last-child\":return l(t,r.right,n)&&p(t,n,(function(e){return e-r.index.value}));case\"class\":switch(r.name.toLowerCase()){case\"statement\":if(\"Statement\"===t.type.slice(-9))return !0;case\"declaration\":return \"Declaration\"===t.type.slice(-11);case\"pattern\":if(\"Pattern\"===t.type.slice(-7))return !0;case\"expression\":return \"Expression\"===t.type.slice(-10)||\"Literal\"===t.type.slice(-7)||\"Identifier\"===t.type&&(0===n.length||\"MetaProperty\"!==n[0].type)||\"MetaProperty\"===t.type;case\"function\":return \"FunctionDeclaration\"===t.type||\"FunctionExpression\"===t.type||\"ArrowFunctionExpression\"===t.type}throw new Error(\"Unknown class name: \".concat(r.name))}throw new Error(\"Unknown selector type: \".concat(r.type))}function u(e,r,n,o){var a=t(n,1)[0];if(!a)return !1;for(var i=s$1.VisitorKeys[a.type],u=0,c=i.length;u<c;++u){var p=a[i[u]];if(Array.isArray(p)){var f=p.indexOf(e);if(f<0)continue;var h=void 0,d=void 0;\"LEFT_SIDE\"===o?(h=0,d=f):(h=f+1,d=p.length);for(var y=h;y<d;++y)if(l(p[y],r,n))return !0}}return !1}function c(e,r,n,o){var a=t(n,1)[0];if(!a)return !1;for(var i=s$1.VisitorKeys[a.type],u=0,c=i.length;u<c;++u){var p=a[i[u]];if(Array.isArray(p)){var f=p.indexOf(e);if(f<0)continue;if(\"LEFT_SIDE\"===o&&f>0&&l(p[f-1],r,n))return !0;if(\"RIGHT_SIDE\"===o&&f<p.length-1&&l(p[f+1],r,n))return !0}}return !1}function p(e,r,n){var o=t(r,1)[0];if(!o)return !1;for(var a=s$1.VisitorKeys[o.type],i=0,l=a.length;i<l;++i){var u=o[a[i]];if(Array.isArray(u)){var c=u.indexOf(e);if(c>=0&&c===n(u.length))return !0}}return !1}function f(n,o){if(null==n||\"object\"!=e(n))return [];null==o&&(o=n);for(var a=n.subject?[o]:[],s=0,i=function(e){for(var t=[],r=Object.keys(e),n=0;n<r.length;n++)t.push([r[n],e[r[n]]]);return t}(n);s<i.length;s++){var l=t(i[s],2),u=l[0],c=l[1];a.push.apply(a,r(f(c,\"left\"===u?c:o)));}return a}function h$1(e,t,r){if(t){var n=[],o=f(t);s$1.traverse(e,{enter:function(e,a){if(null!=a&&n.unshift(a),l(e,t,n))if(o.length)for(var s=0,i=o.length;s<i;++s){l(e,o[s],n)&&r(e,a,n);for(var u=0,c=n.length;u<c;++u){var p=n.slice(u+1);l(n[u],o[s],p)&&r(n[u],a,p);}}else r(e,a,n);},leave:function(){n.shift();},fallback:\"iteration\"});}}function d$1(e,t){var r=[];return h$1(e,t,(function(e){r.push(e);})),r}function y$1(e){return i$1.parse(e)}function m$1(e,t){return d$1(e,y$1(t))}m$1.parse=y$1,m$1.match=d$1,m$1.traverse=h$1,m$1.matches=l,m$1.query=m$1;\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n//------------------------------------------------------------------------------\n// Typedefs\n//------------------------------------------------------------------------------\n\n/**\n * An object describing an AST selector\n * @typedef {Object} ASTSelector\n * @property {string} rawSelector The string that was parsed into this selector\n * @property {boolean} isExit `true` if this should be emitted when exiting the node rather than when entering\n * @property {Object} parsedSelector An object (from esquery) describing the matching behavior of the selector\n * @property {string[]|null} listenerTypes A list of node types that could possibly cause the selector to match,\n * or `null` if all node types could cause a match\n * @property {number} attributeCount The total number of classes, pseudo-classes, and attribute queries in this selector\n * @property {number} identifierCount The total number of identifier queries in this selector\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Gets the possible types of a selector\n * @param {Object} parsedSelector An object (from esquery) describing the matching behavior of the selector\n * @returns {string[]|null} The node types that could possibly trigger this selector, or `null` if all node types could trigger it\n */\nfunction getPossibleTypes(parsedSelector) {\n    switch (parsedSelector.type) {\n        case \"identifier\":\n            return [parsedSelector.value];\n\n        case \"matches\": {\n            const typesForComponents = parsedSelector.selectors.map(getPossibleTypes);\n\n            if (typesForComponents.every(Boolean)) {\n                return lodash.union(...typesForComponents);\n            }\n            return null;\n        }\n\n        case \"compound\": {\n            const typesForComponents = parsedSelector.selectors.map(getPossibleTypes).filter(typesForComponent => typesForComponent);\n\n            // If all of the components could match any type, then the compound could also match any type.\n            if (!typesForComponents.length) {\n                return null;\n            }\n\n            /*\n             * If at least one of the components could only match a particular type, the compound could only match\n             * the intersection of those types.\n             */\n            return lodash.intersection(...typesForComponents);\n        }\n\n        case \"child\":\n        case \"descendant\":\n        case \"sibling\":\n        case \"adjacent\":\n            return getPossibleTypes(parsedSelector.right);\n\n        default:\n            return null;\n\n    }\n}\n\n/**\n * Counts the number of class, pseudo-class, and attribute queries in this selector\n * @param {Object} parsedSelector An object (from esquery) describing the selector's matching behavior\n * @returns {number} The number of class, pseudo-class, and attribute queries in this selector\n */\nfunction countClassAttributes(parsedSelector) {\n    switch (parsedSelector.type) {\n        case \"child\":\n        case \"descendant\":\n        case \"sibling\":\n        case \"adjacent\":\n            return countClassAttributes(parsedSelector.left) + countClassAttributes(parsedSelector.right);\n\n        case \"compound\":\n        case \"not\":\n        case \"matches\":\n            return parsedSelector.selectors.reduce((sum, childSelector) => sum + countClassAttributes(childSelector), 0);\n\n        case \"attribute\":\n        case \"field\":\n        case \"nth-child\":\n        case \"nth-last-child\":\n            return 1;\n\n        default:\n            return 0;\n    }\n}\n\n/**\n * Counts the number of identifier queries in this selector\n * @param {Object} parsedSelector An object (from esquery) describing the selector's matching behavior\n * @returns {number} The number of identifier queries\n */\nfunction countIdentifiers(parsedSelector) {\n    switch (parsedSelector.type) {\n        case \"child\":\n        case \"descendant\":\n        case \"sibling\":\n        case \"adjacent\":\n            return countIdentifiers(parsedSelector.left) + countIdentifiers(parsedSelector.right);\n\n        case \"compound\":\n        case \"not\":\n        case \"matches\":\n            return parsedSelector.selectors.reduce((sum, childSelector) => sum + countIdentifiers(childSelector), 0);\n\n        case \"identifier\":\n            return 1;\n\n        default:\n            return 0;\n    }\n}\n\n/**\n * Compares the specificity of two selector objects, with CSS-like rules.\n * @param {ASTSelector} selectorA An AST selector descriptor\n * @param {ASTSelector} selectorB Another AST selector descriptor\n * @returns {number}\n * a value less than 0 if selectorA is less specific than selectorB\n * a value greater than 0 if selectorA is more specific than selectorB\n * a value less than 0 if selectorA and selectorB have the same specificity, and selectorA <= selectorB alphabetically\n * a value greater than 0 if selectorA and selectorB have the same specificity, and selectorA > selectorB alphabetically\n */\nfunction compareSpecificity(selectorA, selectorB) {\n    return selectorA.attributeCount - selectorB.attributeCount ||\n        selectorA.identifierCount - selectorB.identifierCount ||\n        (selectorA.rawSelector <= selectorB.rawSelector ? -1 : 1);\n}\n\n/**\n * Parses a raw selector string, and throws a useful error if parsing fails.\n * @param {string} rawSelector A raw AST selector\n * @returns {Object} An object (from esquery) describing the matching behavior of this selector\n * @throws {Error} An error if the selector is invalid\n */\nfunction tryParseSelector(rawSelector) {\n    try {\n        return m$1.parse(rawSelector.replace(/:exit$/u, \"\"));\n    } catch (err) {\n        if (typeof err.offset === \"number\") {\n            throw new SyntaxError(`Syntax error in selector \"${rawSelector}\" at position ${err.offset}: ${err.message}`);\n        }\n        throw err;\n    }\n}\n\n/**\n * Parses a raw selector string, and returns the parsed selector along with specificity and type information.\n * @param {string} rawSelector A raw AST selector\n * @returns {ASTSelector} A selector descriptor\n */\nconst parseSelector = lodash.memoize(rawSelector => {\n    const parsedSelector = tryParseSelector(rawSelector);\n\n    return {\n        rawSelector,\n        isExit: rawSelector.endsWith(\":exit\"),\n        parsedSelector,\n        listenerTypes: getPossibleTypes(parsedSelector),\n        attributeCount: countClassAttributes(parsedSelector),\n        identifierCount: countIdentifiers(parsedSelector)\n    };\n});\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * The event generator for AST nodes.\n * This implements below interface.\n *\n * ```ts\n * interface EventGenerator {\n *     emitter: SafeEmitter;\n *     enterNode(node: ASTNode): void;\n *     leaveNode(node: ASTNode): void;\n * }\n * ```\n */\nclass NodeEventGenerator {\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @param {SafeEmitter} emitter\n     * An SafeEmitter which is the destination of events. This emitter must already\n     * have registered listeners for all of the events that it needs to listen for.\n     * (See lib/linter/safe-emitter.js for more details on `SafeEmitter`.)\n     * @returns {NodeEventGenerator} new instance\n     */\n    constructor(emitter) {\n        this.emitter = emitter;\n        this.currentAncestry = [];\n        this.enterSelectorsByNodeType = new Map();\n        this.exitSelectorsByNodeType = new Map();\n        this.anyTypeEnterSelectors = [];\n        this.anyTypeExitSelectors = [];\n\n        emitter.eventNames().forEach(rawSelector => {\n            const selector = parseSelector(rawSelector);\n\n            if (selector.listenerTypes) {\n                const typeMap = selector.isExit ? this.exitSelectorsByNodeType : this.enterSelectorsByNodeType;\n\n                selector.listenerTypes.forEach(nodeType => {\n                    if (!typeMap.has(nodeType)) {\n                        typeMap.set(nodeType, []);\n                    }\n                    typeMap.get(nodeType).push(selector);\n                });\n                return;\n            }\n            const selectors = selector.isExit ? this.anyTypeExitSelectors : this.anyTypeEnterSelectors;\n\n            selectors.push(selector);\n        });\n\n        this.anyTypeEnterSelectors.sort(compareSpecificity);\n        this.anyTypeExitSelectors.sort(compareSpecificity);\n        this.enterSelectorsByNodeType.forEach(selectorList => selectorList.sort(compareSpecificity));\n        this.exitSelectorsByNodeType.forEach(selectorList => selectorList.sort(compareSpecificity));\n    }\n\n    /**\n     * Checks a selector against a node, and emits it if it matches\n     * @param {ASTNode} node The node to check\n     * @param {ASTSelector} selector An AST selector descriptor\n     * @returns {void}\n     */\n    applySelector(node, selector) {\n        if (m$1.matches(node, selector.parsedSelector, this.currentAncestry)) {\n            this.emitter.emit(selector.rawSelector, node);\n        }\n    }\n\n    /**\n     * Applies all appropriate selectors to a node, in specificity order\n     * @param {ASTNode} node The node to check\n     * @param {boolean} isExit `false` if the node is currently being entered, `true` if it's currently being exited\n     * @returns {void}\n     */\n    applySelectors(node, isExit) {\n        const selectorsByNodeType = (isExit ? this.exitSelectorsByNodeType : this.enterSelectorsByNodeType).get(node.type) || [];\n        const anyTypeSelectors = isExit ? this.anyTypeExitSelectors : this.anyTypeEnterSelectors;\n\n        /*\n         * selectorsByNodeType and anyTypeSelectors were already sorted by specificity in the constructor.\n         * Iterate through each of them, applying selectors in the right order.\n         */\n        let selectorsByTypeIndex = 0;\n        let anyTypeSelectorsIndex = 0;\n\n        while (selectorsByTypeIndex < selectorsByNodeType.length || anyTypeSelectorsIndex < anyTypeSelectors.length) {\n            if (\n                selectorsByTypeIndex >= selectorsByNodeType.length ||\n                anyTypeSelectorsIndex < anyTypeSelectors.length &&\n                compareSpecificity(anyTypeSelectors[anyTypeSelectorsIndex], selectorsByNodeType[selectorsByTypeIndex]) < 0\n            ) {\n                this.applySelector(node, anyTypeSelectors[anyTypeSelectorsIndex++]);\n            } else {\n                this.applySelector(node, selectorsByNodeType[selectorsByTypeIndex++]);\n            }\n        }\n    }\n\n    /**\n     * Emits an event of entering AST node.\n     * @param {ASTNode} node A node which was entered.\n     * @returns {void}\n     */\n    enterNode(node) {\n        if (node.parent) {\n            this.currentAncestry.unshift(node.parent);\n        }\n        this.applySelectors(node, false);\n    }\n\n    /**\n     * Emits an event of leaving AST node.\n     * @param {ASTNode} node A node which was left.\n     * @returns {void}\n     */\n    leaveNode(node) {\n        this.applySelectors(node, true);\n        this.currentAncestry.shift();\n    }\n}\n\nvar nodeEventGenerator = NodeEventGenerator;\n\n/**\n * @fileoverview An object that creates fix commands for rules.\n * @author Nicholas C. Zakas\n */\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n// none!\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Creates a fix command that inserts text at the specified index in the source text.\n * @param {int} index The 0-based index at which to insert the new text.\n * @param {string} text The text to insert.\n * @returns {Object} The fix command.\n * @private\n */\nfunction insertTextAt(index, text) {\n    return {\n        range: [index, index],\n        text\n    };\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * Creates code fixing commands for rules.\n */\n\nconst ruleFixer = Object.freeze({\n\n    /**\n     * Creates a fix command that inserts text after the given node or token.\n     * The fix is not applied until applyFixes() is called.\n     * @param {ASTNode|Token} nodeOrToken The node or token to insert after.\n     * @param {string} text The text to insert.\n     * @returns {Object} The fix command.\n     */\n    insertTextAfter(nodeOrToken, text) {\n        return this.insertTextAfterRange(nodeOrToken.range, text);\n    },\n\n    /**\n     * Creates a fix command that inserts text after the specified range in the source text.\n     * The fix is not applied until applyFixes() is called.\n     * @param {int[]} range The range to replace, first item is start of range, second\n     *      is end of range.\n     * @param {string} text The text to insert.\n     * @returns {Object} The fix command.\n     */\n    insertTextAfterRange(range, text) {\n        return insertTextAt(range[1], text);\n    },\n\n    /**\n     * Creates a fix command that inserts text before the given node or token.\n     * The fix is not applied until applyFixes() is called.\n     * @param {ASTNode|Token} nodeOrToken The node or token to insert before.\n     * @param {string} text The text to insert.\n     * @returns {Object} The fix command.\n     */\n    insertTextBefore(nodeOrToken, text) {\n        return this.insertTextBeforeRange(nodeOrToken.range, text);\n    },\n\n    /**\n     * Creates a fix command that inserts text before the specified range in the source text.\n     * The fix is not applied until applyFixes() is called.\n     * @param {int[]} range The range to replace, first item is start of range, second\n     *      is end of range.\n     * @param {string} text The text to insert.\n     * @returns {Object} The fix command.\n     */\n    insertTextBeforeRange(range, text) {\n        return insertTextAt(range[0], text);\n    },\n\n    /**\n     * Creates a fix command that replaces text at the node or token.\n     * The fix is not applied until applyFixes() is called.\n     * @param {ASTNode|Token} nodeOrToken The node or token to remove.\n     * @param {string} text The text to insert.\n     * @returns {Object} The fix command.\n     */\n    replaceText(nodeOrToken, text) {\n        return this.replaceTextRange(nodeOrToken.range, text);\n    },\n\n    /**\n     * Creates a fix command that replaces text at the specified range in the source text.\n     * The fix is not applied until applyFixes() is called.\n     * @param {int[]} range The range to replace, first item is start of range, second\n     *      is end of range.\n     * @param {string} text The text to insert.\n     * @returns {Object} The fix command.\n     */\n    replaceTextRange(range, text) {\n        return {\n            range,\n            text\n        };\n    },\n\n    /**\n     * Creates a fix command that removes the node or token from the source.\n     * The fix is not applied until applyFixes() is called.\n     * @param {ASTNode|Token} nodeOrToken The node or token to remove.\n     * @returns {Object} The fix command.\n     */\n    remove(nodeOrToken) {\n        return this.removeRange(nodeOrToken.range);\n    },\n\n    /**\n     * Creates a fix command that removes the specified range of text from the source.\n     * The fix is not applied until applyFixes() is called.\n     * @param {int[]} range The range to remove, first item is start of range, second\n     *      is end of range.\n     * @returns {Object} The fix command.\n     */\n    removeRange(range) {\n        return {\n            range,\n            text: \"\"\n        };\n    }\n\n});\n\n\nvar ruleFixer_1 = ruleFixer;\n\n/**\n * @fileoverview Interpolate keys from an object into a string with {{ }} markers.\n * @author Jed Fox\n */\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nvar interpolate = (text, data) => {\n    if (!data) {\n        return text;\n    }\n\n    // Substitution content for any {{ }} markers.\n    return text.replace(/\\{\\{([^{}]+?)\\}\\}/gu, (fullMatch, termWithWhitespace) => {\n        const term = termWithWhitespace.trim();\n\n        if (term in data) {\n            return data[term];\n        }\n\n        // Preserve old behavior: If parameter name not provided, don't replace it.\n        return fullMatch;\n    });\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n\n//------------------------------------------------------------------------------\n// Typedefs\n//------------------------------------------------------------------------------\n\n/**\n * An error message description\n * @typedef {Object} MessageDescriptor\n * @property {ASTNode} [node] The reported node\n * @property {Location} loc The location of the problem.\n * @property {string} message The problem message.\n * @property {Object} [data] Optional data to use to fill in placeholders in the\n *      message.\n * @property {Function} [fix] The function to call that creates a fix command.\n * @property {Array<{desc?: string, messageId?: string, fix: Function}>} suggest Suggestion descriptions and functions to create a the associated fixes.\n */\n\n/**\n * Information about the report\n * @typedef {Object} ReportInfo\n * @property {string} ruleId\n * @property {(0|1|2)} severity\n * @property {(string|undefined)} message\n * @property {(string|undefined)} [messageId]\n * @property {number} line\n * @property {number} column\n * @property {(number|undefined)} [endLine]\n * @property {(number|undefined)} [endColumn]\n * @property {(string|null)} nodeType\n * @property {string} source\n * @property {({text: string, range: (number[]|null)}|null)} [fix]\n * @property {Array<{text: string, range: (number[]|null)}|null>} [suggestions]\n */\n\n//------------------------------------------------------------------------------\n// Module Definition\n//------------------------------------------------------------------------------\n\n\n/**\n * Translates a multi-argument context.report() call into a single object argument call\n * @param {...*} args A list of arguments passed to `context.report`\n * @returns {MessageDescriptor} A normalized object containing report information\n */\nfunction normalizeMultiArgReportCall(...args) {\n\n    // If there is one argument, it is considered to be a new-style call already.\n    if (args.length === 1) {\n\n        // Shallow clone the object to avoid surprises if reusing the descriptor\n        return Object.assign({}, args[0]);\n    }\n\n    // If the second argument is a string, the arguments are interpreted as [node, message, data, fix].\n    if (typeof args[1] === \"string\") {\n        return {\n            node: args[0],\n            message: args[1],\n            data: args[2],\n            fix: args[3]\n        };\n    }\n\n    // Otherwise, the arguments are interpreted as [node, loc, message, data, fix].\n    return {\n        node: args[0],\n        loc: args[1],\n        message: args[2],\n        data: args[3],\n        fix: args[4]\n    };\n}\n\n/**\n * Asserts that either a loc or a node was provided, and the node is valid if it was provided.\n * @param {MessageDescriptor} descriptor A descriptor to validate\n * @returns {void}\n * @throws AssertionError if neither a node nor a loc was provided, or if the node is not an object\n */\nfunction assertValidNodeInfo(descriptor) {\n    if (descriptor.node) {\n        assert(typeof descriptor.node === \"object\", \"Node must be an object\");\n    } else {\n        assert(descriptor.loc, \"Node must be provided when reporting error if location is not provided\");\n    }\n}\n\n/**\n * Normalizes a MessageDescriptor to always have a `loc` with `start` and `end` properties\n * @param {MessageDescriptor} descriptor A descriptor for the report from a rule.\n * @returns {{start: Location, end: (Location|null)}} An updated location that infers the `start` and `end` properties\n * from the `node` of the original descriptor, or infers the `start` from the `loc` of the original descriptor.\n */\nfunction normalizeReportLoc(descriptor) {\n    if (descriptor.loc) {\n        if (descriptor.loc.start) {\n            return descriptor.loc;\n        }\n        return { start: descriptor.loc, end: null };\n    }\n    return descriptor.node.loc;\n}\n\n/**\n * Compares items in a fixes array by range.\n * @param {Fix} a The first message.\n * @param {Fix} b The second message.\n * @returns {int} -1 if a comes before b, 1 if a comes after b, 0 if equal.\n * @private\n */\nfunction compareFixesByRange(a, b) {\n    return a.range[0] - b.range[0] || a.range[1] - b.range[1];\n}\n\n/**\n * Merges the given fixes array into one.\n * @param {Fix[]} fixes The fixes to merge.\n * @param {SourceCode} sourceCode The source code object to get the text between fixes.\n * @returns {{text: string, range: number[]}} The merged fixes\n */\nfunction mergeFixes(fixes, sourceCode) {\n    if (fixes.length === 0) {\n        return null;\n    }\n    if (fixes.length === 1) {\n        return fixes[0];\n    }\n\n    fixes.sort(compareFixesByRange);\n\n    const originalText = sourceCode.text;\n    const start = fixes[0].range[0];\n    const end = fixes[fixes.length - 1].range[1];\n    let text = \"\";\n    let lastPos = Number.MIN_SAFE_INTEGER;\n\n    for (const fix of fixes) {\n        assert(fix.range[0] >= lastPos, \"Fix objects must not be overlapped in a report.\");\n\n        if (fix.range[0] >= 0) {\n            text += originalText.slice(Math.max(0, start, lastPos), fix.range[0]);\n        }\n        text += fix.text;\n        lastPos = fix.range[1];\n    }\n    text += originalText.slice(Math.max(0, start, lastPos), end);\n\n    return { range: [start, end], text };\n}\n\n/**\n * Gets one fix object from the given descriptor.\n * If the descriptor retrieves multiple fixes, this merges those to one.\n * @param {MessageDescriptor} descriptor The report descriptor.\n * @param {SourceCode} sourceCode The source code object to get text between fixes.\n * @returns {({text: string, range: number[]}|null)} The fix for the descriptor\n */\nfunction normalizeFixes(descriptor, sourceCode) {\n    if (typeof descriptor.fix !== \"function\") {\n        return null;\n    }\n\n    // @type {null | Fix | Fix[] | IterableIterator<Fix>}\n    const fix = descriptor.fix(ruleFixer_1);\n\n    // Merge to one.\n    if (fix && Symbol.iterator in fix) {\n        return mergeFixes(Array.from(fix), sourceCode);\n    }\n    return fix;\n}\n\n/**\n * Gets an array of suggestion objects from the given descriptor.\n * @param {MessageDescriptor} descriptor The report descriptor.\n * @param {SourceCode} sourceCode The source code object to get text between fixes.\n * @param {Object} messages Object of meta messages for the rule.\n * @returns {Array<SuggestionResult>} The suggestions for the descriptor\n */\nfunction mapSuggestions(descriptor, sourceCode, messages) {\n    if (!descriptor.suggest || !Array.isArray(descriptor.suggest)) {\n        return [];\n    }\n\n    return descriptor.suggest.map(suggestInfo => {\n        const computedDesc = suggestInfo.desc || messages[suggestInfo.messageId];\n\n        return {\n            ...suggestInfo,\n            desc: interpolate(computedDesc, suggestInfo.data),\n            fix: normalizeFixes(suggestInfo, sourceCode)\n        };\n    });\n}\n\n/**\n * Creates information about the report from a descriptor\n * @param {Object} options Information about the problem\n * @param {string} options.ruleId Rule ID\n * @param {(0|1|2)} options.severity Rule severity\n * @param {(ASTNode|null)} options.node Node\n * @param {string} options.message Error message\n * @param {string} [options.messageId] The error message ID.\n * @param {{start: SourceLocation, end: (SourceLocation|null)}} options.loc Start and end location\n * @param {{text: string, range: (number[]|null)}} options.fix The fix object\n * @param {Array<{text: string, range: (number[]|null)}>} options.suggestions The array of suggestions objects\n * @returns {function(...args): ReportInfo} Function that returns information about the report\n */\nfunction createProblem(options) {\n    const problem = {\n        ruleId: options.ruleId,\n        severity: options.severity,\n        message: options.message,\n        line: options.loc.start.line,\n        column: options.loc.start.column + 1,\n        nodeType: options.node && options.node.type || null\n    };\n\n    /*\n     * If this isn’t in the conditional, some of the tests fail\n     * because `messageId` is present in the problem object\n     */\n    if (options.messageId) {\n        problem.messageId = options.messageId;\n    }\n\n    if (options.loc.end) {\n        problem.endLine = options.loc.end.line;\n        problem.endColumn = options.loc.end.column + 1;\n    }\n\n    if (options.fix) {\n        problem.fix = options.fix;\n    }\n\n    if (options.suggestions && options.suggestions.length > 0) {\n        problem.suggestions = options.suggestions;\n    }\n\n    return problem;\n}\n\n/**\n * Validates that suggestions are properly defined. Throws if an error is detected.\n * @param {Array<{ desc?: string, messageId?: string }>} suggest The incoming suggest data.\n * @param {Object} messages Object of meta messages for the rule.\n * @returns {void}\n */\nfunction validateSuggestions(suggest, messages) {\n    if (suggest && Array.isArray(suggest)) {\n        suggest.forEach(suggestion => {\n            if (suggestion.messageId) {\n                const { messageId } = suggestion;\n\n                if (!messages) {\n                    throw new TypeError(`context.report() called with a suggest option with a messageId '${messageId}', but no messages were present in the rule metadata.`);\n                }\n\n                if (!messages[messageId]) {\n                    throw new TypeError(`context.report() called with a suggest option with a messageId '${messageId}' which is not present in the 'messages' config: ${JSON.stringify(messages, null, 2)}`);\n                }\n\n                if (suggestion.desc) {\n                    throw new TypeError(\"context.report() called with a suggest option that defines both a 'messageId' and an 'desc'. Please only pass one.\");\n                }\n            } else if (!suggestion.desc) {\n                throw new TypeError(\"context.report() called with a suggest option that doesn't have either a `desc` or `messageId`\");\n            }\n\n            if (typeof suggestion.fix !== \"function\") {\n                throw new TypeError(`context.report() called with a suggest option without a fix function. See: ${suggestion}`);\n            }\n        });\n    }\n}\n\n/**\n * Returns a function that converts the arguments of a `context.report` call from a rule into a reported\n * problem for the Node.js API.\n * @param {{ruleId: string, severity: number, sourceCode: SourceCode, messageIds: Object, disableFixes: boolean}} metadata Metadata for the reported problem\n * @param {SourceCode} sourceCode The `SourceCode` instance for the text being linted\n * @returns {function(...args): ReportInfo} Function that returns information about the report\n */\n\nvar reportTranslator = function createReportTranslator(metadata) {\n\n    /*\n     * `createReportTranslator` gets called once per enabled rule per file. It needs to be very performant.\n     * The report translator itself (i.e. the function that `createReportTranslator` returns) gets\n     * called every time a rule reports a problem, which happens much less frequently (usually, the vast\n     * majority of rules don't report any problems for a given file).\n     */\n    return (...args) => {\n        const descriptor = normalizeMultiArgReportCall(...args);\n        const messages = metadata.messageIds;\n\n        assertValidNodeInfo(descriptor);\n\n        let computedMessage;\n\n        if (descriptor.messageId) {\n            if (!messages) {\n                throw new TypeError(\"context.report() called with a messageId, but no messages were present in the rule metadata.\");\n            }\n            const id = descriptor.messageId;\n\n            if (descriptor.message) {\n                throw new TypeError(\"context.report() called with a message and a messageId. Please only pass one.\");\n            }\n            if (!messages || !Object.prototype.hasOwnProperty.call(messages, id)) {\n                throw new TypeError(`context.report() called with a messageId of '${id}' which is not present in the 'messages' config: ${JSON.stringify(messages, null, 2)}`);\n            }\n            computedMessage = messages[id];\n        } else if (descriptor.message) {\n            computedMessage = descriptor.message;\n        } else {\n            throw new TypeError(\"Missing `message` property in report() call; add a message that describes the linting problem.\");\n        }\n\n        validateSuggestions(descriptor.suggest, messages);\n\n        return createProblem({\n            ruleId: metadata.ruleId,\n            severity: metadata.severity,\n            node: descriptor.node,\n            message: interpolate(computedMessage, descriptor.data),\n            messageId: descriptor.messageId,\n            loc: normalizeReportLoc(descriptor),\n            fix: metadata.disableFixes ? null : normalizeFixes(descriptor, metadata.sourceCode),\n            suggestions: metadata.disableFixes ? [] : mapSuggestions(descriptor, metadata.sourceCode, messages)\n        });\n    };\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Normalizes a rule module to the new-style API\n * @param {(Function|{create: Function})} rule A rule object, which can either be a function\n * (\"old-style\") or an object with a `create` method (\"new-style\")\n * @returns {{create: Function}} A new-style rule.\n */\nfunction normalizeRule(rule) {\n    return typeof rule === \"function\" ? Object.assign({ create: rule }, rule) : rule;\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nclass Rules {\n    constructor() {\n        this._rules = Object.create(null);\n    }\n\n    /**\n     * Registers a rule module for rule id in storage.\n     * @param {string} ruleId Rule id (file name).\n     * @param {Function} ruleModule Rule handler.\n     * @returns {void}\n     */\n    define(ruleId, ruleModule) {\n        this._rules[ruleId] = normalizeRule(ruleModule);\n    }\n\n    /**\n     * Access rule handler by id (file name).\n     * @param {string} ruleId Rule id (file name).\n     * @returns {{create: Function, schema: JsonSchema[]}}\n     * A rule. This is normalized to always have the new-style shape with a `create` method.\n     */\n    get(ruleId) {\n        if (typeof this._rules[ruleId] === \"string\") {\n            this.define(ruleId, commonjsRequire(this._rules[ruleId]));\n        }\n        if (this._rules[ruleId]) {\n            return this._rules[ruleId];\n        }\n        if (rules.has(ruleId)) {\n            return rules.get(ruleId);\n        }\n\n        return null;\n    }\n\n    *[Symbol.iterator]() {\n        yield* rules;\n\n        for (const ruleId of Object.keys(this._rules)) {\n            yield [ruleId, this.get(ruleId)];\n        }\n    }\n}\n\nvar rules$2 = Rules;\n\n/**\n * @fileoverview A variant of EventEmitter which does not give listeners information about each other\n * @author Teddy Katz\n */\n\n//------------------------------------------------------------------------------\n// Typedefs\n//------------------------------------------------------------------------------\n\n/**\n * An event emitter\n * @typedef {Object} SafeEmitter\n * @property {function(eventName: string, listenerFunc: Function): void} on Adds a listener for a given event name\n * @property {function(eventName: string, arg1?: any, arg2?: any, arg3?: any)} emit Emits an event with a given name.\n * This calls all the listeners that were listening for that name, with `arg1`, `arg2`, and `arg3` as arguments.\n * @property {function(): string[]} eventNames Gets the list of event names that have registered listeners.\n */\n\n/**\n * Creates an object which can listen for and emit events.\n * This is similar to the EventEmitter API in Node's standard library, but it has a few differences.\n * The goal is to allow multiple modules to attach arbitrary listeners to the same emitter, without\n * letting the modules know about each other at all.\n * 1. It has no special keys like `error` and `newListener`, which would allow modules to detect when\n * another module throws an error or registers a listener.\n * 2. It calls listener functions without any `this` value. (`EventEmitter` calls listeners with a\n * `this` value of the emitter instance, which would give listeners access to other listeners.)\n * @returns {SafeEmitter} An emitter\n */\nvar safeEmitter = () => {\n    const listeners = Object.create(null);\n\n    return Object.freeze({\n        on(eventName, listener) {\n            if (eventName in listeners) {\n                listeners[eventName].push(listener);\n            } else {\n                listeners[eventName] = [listener];\n            }\n        },\n        emit(eventName, ...args) {\n            if (eventName in listeners) {\n                listeners[eventName].forEach(listener => listener(...args));\n            }\n        },\n        eventNames() {\n            return Object.keys(listeners);\n        }\n    });\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nconst debug$4 = src(\"eslint:source-code-fixer\");\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst BOM = \"\\uFEFF\";\n\n/**\n * Compares items in a messages array by range.\n * @param {Message} a The first message.\n * @param {Message} b The second message.\n * @returns {int} -1 if a comes before b, 1 if a comes after b, 0 if equal.\n * @private\n */\nfunction compareMessagesByFixRange(a, b) {\n    return a.fix.range[0] - b.fix.range[0] || a.fix.range[1] - b.fix.range[1];\n}\n\n/**\n * Compares items in a messages array by line and column.\n * @param {Message} a The first message.\n * @param {Message} b The second message.\n * @returns {int} -1 if a comes before b, 1 if a comes after b, 0 if equal.\n * @private\n */\nfunction compareMessagesByLocation(a, b) {\n    return a.line - b.line || a.column - b.column;\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * Utility for apply fixes to source code.\n * @constructor\n */\nfunction SourceCodeFixer() {\n    Object.freeze(this);\n}\n\n/**\n * Applies the fixes specified by the messages to the given text. Tries to be\n * smart about the fixes and won't apply fixes over the same area in the text.\n * @param {string} sourceText The text to apply the changes to.\n * @param {Message[]} messages The array of messages reported by ESLint.\n * @param {boolean|Function} [shouldFix=true] Determines whether each message should be fixed\n * @returns {Object} An object containing the fixed text and any unfixed messages.\n */\nSourceCodeFixer.applyFixes = function(sourceText, messages, shouldFix) {\n    debug$4(\"Applying fixes\");\n\n    if (shouldFix === false) {\n        debug$4(\"shouldFix parameter was false, not attempting fixes\");\n        return {\n            fixed: false,\n            messages,\n            output: sourceText\n        };\n    }\n\n    // clone the array\n    const remainingMessages = [],\n        fixes = [],\n        bom = sourceText.startsWith(BOM) ? BOM : \"\",\n        text = bom ? sourceText.slice(1) : sourceText;\n    let lastPos = Number.NEGATIVE_INFINITY,\n        output = bom;\n\n    /**\n     * Try to use the 'fix' from a problem.\n     * @param   {Message} problem The message object to apply fixes from\n     * @returns {boolean}         Whether fix was successfully applied\n     */\n    function attemptFix(problem) {\n        const fix = problem.fix;\n        const start = fix.range[0];\n        const end = fix.range[1];\n\n        // Remain it as a problem if it's overlapped or it's a negative range\n        if (lastPos >= start || start > end) {\n            remainingMessages.push(problem);\n            return false;\n        }\n\n        // Remove BOM.\n        if ((start < 0 && end >= 0) || (start === 0 && fix.text.startsWith(BOM))) {\n            output = \"\";\n        }\n\n        // Make output to this fix.\n        output += text.slice(Math.max(0, lastPos), Math.max(0, start));\n        output += fix.text;\n        lastPos = end;\n        return true;\n    }\n\n    messages.forEach(problem => {\n        if (Object.prototype.hasOwnProperty.call(problem, \"fix\")) {\n            fixes.push(problem);\n        } else {\n            remainingMessages.push(problem);\n        }\n    });\n\n    if (fixes.length) {\n        debug$4(\"Found fixes to apply\");\n        let fixesWereApplied = false;\n\n        for (const problem of fixes.sort(compareMessagesByFixRange)) {\n            if (typeof shouldFix !== \"function\" || shouldFix(problem)) {\n                attemptFix(problem);\n\n                /*\n                 * The only time attemptFix will fail is if a previous fix was\n                 * applied which conflicts with it.  So we can mark this as true.\n                 */\n                fixesWereApplied = true;\n            } else {\n                remainingMessages.push(problem);\n            }\n        }\n        output += text.slice(Math.max(0, lastPos));\n\n        return {\n            fixed: fixesWereApplied,\n            messages: remainingMessages.sort(compareMessagesByLocation),\n            output\n        };\n    }\n\n    debug$4(\"No fixes to apply\");\n    return {\n        fixed: false,\n        messages,\n        output: bom + text\n    };\n\n};\n\nvar sourceCodeFixer = SourceCodeFixer;\n\n/**\n * @fileoverview Tracks performance of individual rules.\n * @author Brandon Mills\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/* istanbul ignore next */\n/**\n * Align the string to left\n * @param {string} str string to evaluate\n * @param {int} len length of the string\n * @param {string} ch delimiter character\n * @returns {string} modified string\n * @private\n */\nfunction alignLeft(str, len, ch) {\n    return str + new Array(len - str.length + 1).join(ch || \" \");\n}\n\n/* istanbul ignore next */\n/**\n * Align the string to right\n * @param {string} str string to evaluate\n * @param {int} len length of the string\n * @param {string} ch delimiter character\n * @returns {string} modified string\n * @private\n */\nfunction alignRight(str, len, ch) {\n    return new Array(len - str.length + 1).join(ch || \" \") + str;\n}\n\n//------------------------------------------------------------------------------\n// Module definition\n//------------------------------------------------------------------------------\n\nconst enabled = !!process.env.TIMING;\n\nconst HEADERS = [\"Rule\", \"Time (ms)\", \"Relative\"];\nconst ALIGN = [alignLeft, alignRight, alignRight];\n\n/* istanbul ignore next */\n/**\n * display the data\n * @param {Object} data Data object to be displayed\n * @returns {void} prints modified string with console.log\n * @private\n */\nfunction display(data) {\n    let total = 0;\n    const rows = Object.keys(data)\n        .map(key => {\n            const time = data[key];\n\n            total += time;\n            return [key, time];\n        })\n        .sort((a, b) => b[1] - a[1])\n        .slice(0, 10);\n\n    rows.forEach(row => {\n        row.push(`${(row[1] * 100 / total).toFixed(1)}%`);\n        row[1] = row[1].toFixed(3);\n    });\n\n    rows.unshift(HEADERS);\n\n    const widths = [];\n\n    rows.forEach(row => {\n        const len = row.length;\n\n        for (let i = 0; i < len; i++) {\n            const n = row[i].length;\n\n            if (!widths[i] || n > widths[i]) {\n                widths[i] = n;\n            }\n        }\n    });\n\n    const table = rows.map(row => (\n        row\n            .map((cell, index) => ALIGN[index](cell, widths[index]))\n            .join(\" | \")\n    ));\n\n    table.splice(1, 0, widths.map((width, index) => {\n        const extraAlignment = index !== 0 && index !== widths.length - 1 ? 2 : 1;\n\n        return ALIGN[index](\":\", width + extraAlignment, \"-\");\n    }).join(\"|\"));\n\n    console.log(table.join(\"\\n\")); // eslint-disable-line no-console\n}\n\n/* istanbul ignore next */\nvar timing = (function() {\n\n    const data = Object.create(null);\n\n    /**\n     * Time the run\n     * @param {*} key key from the data object\n     * @param {Function} fn function to be called\n     * @returns {Function} function to be executed\n     * @private\n     */\n    function time(key, fn) {\n        if (typeof data[key] === \"undefined\") {\n            data[key] = 0;\n        }\n\n        return function(...args) {\n            let t = process.hrtime();\n\n            fn(...args);\n            t = process.hrtime(t);\n            data[key] += t[0] * 1e3 + t[1] / 1e6;\n        };\n    }\n\n    if (enabled) {\n        process.on(\"exit\", () => {\n            display(data);\n        });\n    }\n\n    return {\n        time,\n        enabled\n    };\n\n}());\n\nvar rules$3 = {\n\t\"generator-star\": [\n\t\t\"generator-star-spacing\"\n\t],\n\t\"global-strict\": [\n\t\t\"strict\"\n\t],\n\t\"no-arrow-condition\": [\n\t\t\"no-confusing-arrow\",\n\t\t\"no-constant-condition\"\n\t],\n\t\"no-comma-dangle\": [\n\t\t\"comma-dangle\"\n\t],\n\t\"no-empty-class\": [\n\t\t\"no-empty-character-class\"\n\t],\n\t\"no-empty-label\": [\n\t\t\"no-labels\"\n\t],\n\t\"no-extra-strict\": [\n\t\t\"strict\"\n\t],\n\t\"no-reserved-keys\": [\n\t\t\"quote-props\"\n\t],\n\t\"no-space-before-semi\": [\n\t\t\"semi-spacing\"\n\t],\n\t\"no-wrap-func\": [\n\t\t\"no-extra-parens\"\n\t],\n\t\"space-after-function-name\": [\n\t\t\"space-before-function-paren\"\n\t],\n\t\"space-after-keywords\": [\n\t\t\"keyword-spacing\"\n\t],\n\t\"space-before-function-parentheses\": [\n\t\t\"space-before-function-paren\"\n\t],\n\t\"space-before-keywords\": [\n\t\t\"keyword-spacing\"\n\t],\n\t\"space-in-brackets\": [\n\t\t\"object-curly-spacing\",\n\t\t\"array-bracket-spacing\",\n\t\t\"computed-property-spacing\"\n\t],\n\t\"space-return-throw-case\": [\n\t\t\"keyword-spacing\"\n\t],\n\t\"space-unary-word-ops\": [\n\t\t\"space-unary-ops\"\n\t],\n\t\"spaced-line-comment\": [\n\t\t\"spaced-comment\"\n\t]\n};\nvar replacements = {\n\trules: rules$3\n};\n\nvar replacements$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  rules: rules$3,\n  'default': replacements\n});\n\nvar pkg = getCjsExportFromNamespace(_package$1);\n\nvar ruleReplacements = getCjsExportFromNamespace(replacements$1);\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nconst\n    { SourceCode: SourceCode$1 } = sourceCode$1;\n\nconst debug$5 = src(\"eslint:linter\");\nconst MAX_AUTOFIX_PASSES = 10;\nconst DEFAULT_PARSER_NAME = \"espree\";\nconst commentParser = new configCommentParser();\nconst DEFAULT_ERROR_LOC = { start: { line: 1, column: 0 }, end: { line: 1, column: 1 } };\n\n//------------------------------------------------------------------------------\n// Typedefs\n//------------------------------------------------------------------------------\n\n/** @typedef {InstanceType<import(\"../cli-engine/config-array\")[\"ConfigArray\"]>} ConfigArray */\n/** @typedef {InstanceType<import(\"../cli-engine/config-array\")[\"ExtractedConfig\"]>} ExtractedConfig */\n/** @typedef {import(\"../shared/types\").ConfigData} ConfigData */\n/** @typedef {import(\"../shared/types\").Environment} Environment */\n/** @typedef {import(\"../shared/types\").GlobalConf} GlobalConf */\n/** @typedef {import(\"../shared/types\").LintMessage} LintMessage */\n/** @typedef {import(\"../shared/types\").ParserOptions} ParserOptions */\n/** @typedef {import(\"../shared/types\").Processor} Processor */\n/** @typedef {import(\"../shared/types\").Rule} Rule */\n\n/**\n * @template T\n * @typedef {{ [P in keyof T]-?: T[P] }} Required\n */\n\n/**\n * @typedef {Object} DisableDirective\n * @property {(\"disable\"|\"enable\"|\"disable-line\"|\"disable-next-line\")} type\n * @property {number} line\n * @property {number} column\n * @property {(string|null)} ruleId\n */\n\n/**\n * The private data for `Linter` instance.\n * @typedef {Object} LinterInternalSlots\n * @property {ConfigArray|null} lastConfigArray The `ConfigArray` instance that the last `verify()` call used.\n * @property {SourceCode|null} lastSourceCode The `SourceCode` instance that the last `verify()` call used.\n * @property {Map<string, Parser>} parserMap The loaded parsers.\n * @property {Rules} ruleMap The loaded rules.\n */\n\n/**\n * @typedef {Object} VerifyOptions\n * @property {boolean} [allowInlineConfig] Allow/disallow inline comments' ability\n *      to change config once it is set. Defaults to true if not supplied.\n *      Useful if you want to validate JS without comments overriding rules.\n * @property {boolean} [disableFixes] if `true` then the linter doesn't make `fix`\n *      properties into the lint result.\n * @property {string} [filename] the filename of the source code.\n * @property {boolean | \"off\" | \"warn\" | \"error\"} [reportUnusedDisableDirectives] Adds reported errors for\n *      unused `eslint-disable` directives.\n */\n\n/**\n * @typedef {Object} ProcessorOptions\n * @property {(filename:string, text:string) => boolean} [filterCodeBlock] the\n *      predicate function that selects adopt code blocks.\n * @property {Processor[\"postprocess\"]} [postprocess] postprocessor for report\n *      messages. If provided, this should accept an array of the message lists\n *      for each code block returned from the preprocessor, apply a mapping to\n *      the messages as appropriate, and return a one-dimensional array of\n *      messages.\n * @property {Processor[\"preprocess\"]} [preprocess] preprocessor for source text.\n *      If provided, this should accept a string of source text, and return an\n *      array of code blocks to lint.\n */\n\n/**\n * @typedef {Object} FixOptions\n * @property {boolean | ((message: LintMessage) => boolean)} [fix] Determines\n *      whether fixes should be applied.\n */\n\n/**\n * @typedef {Object} InternalOptions\n * @property {string | null} warnInlineConfig The config name what `noInlineConfig` setting came from. If `noInlineConfig` setting didn't exist, this is null. If this is a config name, then the linter warns directive comments.\n * @property {\"off\" | \"warn\" | \"error\"} reportUnusedDisableDirectives (boolean values were normalized)\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Ensures that variables representing built-in properties of the Global Object,\n * and any globals declared by special block comments, are present in the global\n * scope.\n * @param {Scope} globalScope The global scope.\n * @param {Object} configGlobals The globals declared in configuration\n * @param {{exportedVariables: Object, enabledGlobals: Object}} commentDirectives Directives from comment configuration\n * @returns {void}\n */\nfunction addDeclaredGlobals(globalScope, configGlobals, { exportedVariables, enabledGlobals }) {\n\n    // Define configured global variables.\n    for (const id of new Set([...Object.keys(configGlobals), ...Object.keys(enabledGlobals)])) {\n\n        /*\n         * `ConfigOps.normalizeConfigGlobal` will throw an error if a configured global value is invalid. However, these errors would\n         * typically be caught when validating a config anyway (validity for inline global comments is checked separately).\n         */\n        const configValue = configGlobals[id] === void 0 ? void 0 : configOps.normalizeConfigGlobal(configGlobals[id]);\n        const commentValue = enabledGlobals[id] && enabledGlobals[id].value;\n        const value = commentValue || configValue;\n        const sourceComments = enabledGlobals[id] && enabledGlobals[id].comments;\n\n        if (value === \"off\") {\n            continue;\n        }\n\n        let variable = globalScope.set.get(id);\n\n        if (!variable) {\n            variable = new lib.Variable(id, globalScope);\n\n            globalScope.variables.push(variable);\n            globalScope.set.set(id, variable);\n        }\n\n        variable.eslintImplicitGlobalSetting = configValue;\n        variable.eslintExplicitGlobal = sourceComments !== void 0;\n        variable.eslintExplicitGlobalComments = sourceComments;\n        variable.writeable = (value === \"writable\");\n    }\n\n    // mark all exported variables as such\n    Object.keys(exportedVariables).forEach(name => {\n        const variable = globalScope.set.get(name);\n\n        if (variable) {\n            variable.eslintUsed = true;\n        }\n    });\n\n    /*\n     * \"through\" contains all references which definitions cannot be found.\n     * Since we augment the global scope using configuration, we need to update\n     * references and remove the ones that were added by configuration.\n     */\n    globalScope.through = globalScope.through.filter(reference => {\n        const name = reference.identifier.name;\n        const variable = globalScope.set.get(name);\n\n        if (variable) {\n\n            /*\n             * Links the variable and the reference.\n             * And this reference is removed from `Scope#through`.\n             */\n            reference.resolved = variable;\n            variable.references.push(reference);\n\n            return false;\n        }\n\n        return true;\n    });\n}\n\n/**\n * creates a missing-rule message.\n * @param {string} ruleId the ruleId to create\n * @returns {string} created error message\n * @private\n */\nfunction createMissingRuleMessage(ruleId) {\n    return Object.prototype.hasOwnProperty.call(ruleReplacements.rules, ruleId)\n        ? `Rule '${ruleId}' was removed and replaced by: ${ruleReplacements.rules[ruleId].join(\", \")}`\n        : `Definition for rule '${ruleId}' was not found.`;\n}\n\n/**\n * creates a linting problem\n * @param {Object} options to create linting error\n * @param {string} [options.ruleId] the ruleId to report\n * @param {Object} [options.loc] the loc to report\n * @param {string} [options.message] the error message to report\n * @param {string} [options.severity] the error message to report\n * @returns {LintMessage} created problem, returns a missing-rule problem if only provided ruleId.\n * @private\n */\nfunction createLintingProblem(options) {\n    const {\n        ruleId = null,\n        loc = DEFAULT_ERROR_LOC,\n        message = createMissingRuleMessage(options.ruleId),\n        severity = 2\n    } = options;\n\n    return {\n        ruleId,\n        message,\n        line: loc.start.line,\n        column: loc.start.column + 1,\n        endLine: loc.end.line,\n        endColumn: loc.end.column + 1,\n        severity,\n        nodeType: null\n    };\n}\n\n/**\n * Creates a collection of disable directives from a comment\n * @param {Object} options to create disable directives\n * @param {(\"disable\"|\"enable\"|\"disable-line\"|\"disable-next-line\")} options.type The type of directive comment\n * @param {{line: number, column: number}} options.loc The 0-based location of the comment token\n * @param {string} options.value The value after the directive in the comment\n * comment specified no specific rules, so it applies to all rules (e.g. `eslint-disable`)\n * @param {function(string): {create: Function}} options.ruleMapper A map from rule IDs to defined rules\n * @returns {Object} Directives and problems from the comment\n */\nfunction createDisableDirectives(options) {\n    const { type, loc, value, ruleMapper } = options;\n    const ruleIds = Object.keys(commentParser.parseListConfig(value));\n    const directiveRules = ruleIds.length ? ruleIds : [null];\n    const result = {\n        directives: [], // valid disable directives\n        directiveProblems: [] // problems in directives\n    };\n\n    for (const ruleId of directiveRules) {\n\n        // push to directives, if the rule is defined(including null, e.g. /*eslint enable*/)\n        if (ruleId === null || ruleMapper(ruleId) !== null) {\n            result.directives.push({ type, line: loc.start.line, column: loc.start.column + 1, ruleId });\n        } else {\n            result.directiveProblems.push(createLintingProblem({ ruleId, loc }));\n        }\n    }\n    return result;\n}\n\n/**\n * Parses comments in file to extract file-specific config of rules, globals\n * and environments and merges them with global config; also code blocks\n * where reporting is disabled or enabled and merges them with reporting config.\n * @param {string} filename The file being checked.\n * @param {ASTNode} ast The top node of the AST.\n * @param {function(string): {create: Function}} ruleMapper A map from rule IDs to defined rules\n * @param {string|null} warnInlineConfig If a string then it should warn directive comments as disabled. The string value is the config name what the setting came from.\n * @returns {{configuredRules: Object, enabledGlobals: {value:string,comment:Token}[], exportedVariables: Object, problems: Problem[], disableDirectives: DisableDirective[]}}\n * A collection of the directive comments that were found, along with any problems that occurred when parsing\n */\nfunction getDirectiveComments(filename, ast, ruleMapper, warnInlineConfig) {\n    const configuredRules = {};\n    const enabledGlobals = Object.create(null);\n    const exportedVariables = {};\n    const problems = [];\n    const disableDirectives = [];\n\n    ast.comments.filter(token => token.type !== \"Shebang\").forEach(comment => {\n        const trimmedCommentText = comment.value.trim();\n        const match = /^(eslint(?:-env|-enable|-disable(?:(?:-next)?-line)?)?|exported|globals?)(?:\\s|$)/u.exec(trimmedCommentText);\n\n        if (!match) {\n            return;\n        }\n        const directiveText = match[1];\n        const lineCommentSupported = /^eslint-disable-(next-)?line$/u.test(directiveText);\n\n        if (comment.type === \"Line\" && !lineCommentSupported) {\n            return;\n        }\n\n        if (warnInlineConfig) {\n            const kind = comment.type === \"Block\" ? `/*${directiveText}*/` : `//${directiveText}`;\n\n            problems.push(createLintingProblem({\n                ruleId: null,\n                message: `'${kind}' has no effect because you have 'noInlineConfig' setting in ${warnInlineConfig}.`,\n                loc: comment.loc,\n                severity: 1\n            }));\n            return;\n        }\n\n        if (lineCommentSupported && comment.loc.start.line !== comment.loc.end.line) {\n            const message = `${directiveText} comment should not span multiple lines.`;\n\n            problems.push(createLintingProblem({\n                ruleId: null,\n                message,\n                loc: comment.loc\n            }));\n            return;\n        }\n\n        const directiveValue = trimmedCommentText.slice(match.index + directiveText.length);\n\n        switch (directiveText) {\n            case \"eslint-disable\":\n            case \"eslint-enable\":\n            case \"eslint-disable-next-line\":\n            case \"eslint-disable-line\": {\n                const directiveType = directiveText.slice(\"eslint-\".length);\n                const options = { type: directiveType, loc: comment.loc, value: directiveValue, ruleMapper };\n                const { directives, directiveProblems } = createDisableDirectives(options);\n\n                disableDirectives.push(...directives);\n                problems.push(...directiveProblems);\n                break;\n            }\n\n            case \"exported\":\n                Object.assign(exportedVariables, commentParser.parseStringConfig(directiveValue, comment));\n                break;\n\n            case \"globals\":\n            case \"global\":\n                for (const [id, { value }] of Object.entries(commentParser.parseStringConfig(directiveValue, comment))) {\n                    let normalizedValue;\n\n                    try {\n                        normalizedValue = configOps.normalizeConfigGlobal(value);\n                    } catch (err) {\n                        problems.push(createLintingProblem({\n                            ruleId: null,\n                            loc: comment.loc,\n                            message: err.message\n                        }));\n                        continue;\n                    }\n\n                    if (enabledGlobals[id]) {\n                        enabledGlobals[id].comments.push(comment);\n                        enabledGlobals[id].value = normalizedValue;\n                    } else {\n                        enabledGlobals[id] = {\n                            comments: [comment],\n                            value: normalizedValue\n                        };\n                    }\n                }\n                break;\n\n            case \"eslint\": {\n                const parseResult = commentParser.parseJsonConfig(directiveValue, comment.loc);\n\n                if (parseResult.success) {\n                    Object.keys(parseResult.config).forEach(name => {\n                        const rule = ruleMapper(name);\n                        const ruleValue = parseResult.config[name];\n\n                        if (rule === null) {\n                            problems.push(createLintingProblem({ ruleId: name, loc: comment.loc }));\n                            return;\n                        }\n\n                        try {\n                            configValidator.validateRuleOptions(rule, name, ruleValue);\n                        } catch (err) {\n                            problems.push(createLintingProblem({\n                                ruleId: name,\n                                message: err.message,\n                                loc: comment.loc\n                            }));\n\n                            // do not apply the config, if found invalid options.\n                            return;\n                        }\n\n                        configuredRules[name] = ruleValue;\n                    });\n                } else {\n                    problems.push(parseResult.error);\n                }\n\n                break;\n            }\n\n            // no default\n        }\n    });\n\n    return {\n        configuredRules,\n        enabledGlobals,\n        exportedVariables,\n        problems,\n        disableDirectives\n    };\n}\n\n/**\n * Normalize ECMAScript version from the initial config\n * @param  {number} ecmaVersion ECMAScript version from the initial config\n * @returns {number} normalized ECMAScript version\n */\nfunction normalizeEcmaVersion$1(ecmaVersion) {\n\n    /*\n     * Calculate ECMAScript edition number from official year version starting with\n     * ES2015, which corresponds with ES6 (or a difference of 2009).\n     */\n    return ecmaVersion >= 2015 ? ecmaVersion - 2009 : ecmaVersion;\n}\n\nconst eslintEnvPattern = /\\/\\*\\s*eslint-env\\s(.+?)\\*\\//gu;\n\n/**\n * Checks whether or not there is a comment which has \"eslint-env *\" in a given text.\n * @param {string} text A source code text to check.\n * @returns {Object|null} A result of parseListConfig() with \"eslint-env *\" comment.\n */\nfunction findEslintEnv(text) {\n    let match, retv;\n\n    eslintEnvPattern.lastIndex = 0;\n\n    while ((match = eslintEnvPattern.exec(text))) {\n        retv = Object.assign(retv || {}, commentParser.parseListConfig(match[1]));\n    }\n\n    return retv;\n}\n\n/**\n * Convert \"/path/to/<text>\" to \"<text>\".\n * `CLIEngine#executeOnText()` method gives \"/path/to/<text>\" if the filename\n * was omitted because `configArray.extractConfig()` requires an absolute path.\n * But the linter should pass `<text>` to `RuleContext#getFilename()` in that\n * case.\n * Also, code blocks can have their virtual filename. If the parent filename was\n * `<text>`, the virtual filename is `<text>/0_foo.js` or something like (i.e.,\n * it's not an absolute path).\n * @param {string} filename The filename to normalize.\n * @returns {string} The normalized filename.\n */\nfunction normalizeFilename(filename) {\n    const parts = filename.split(path$1.sep);\n    const index = parts.lastIndexOf(\"<text>\");\n\n    return index === -1 ? filename : parts.slice(index).join(path$1.sep);\n}\n\n/**\n * Normalizes the possible options for `linter.verify` and `linter.verifyAndFix` to a\n * consistent shape.\n * @param {VerifyOptions} providedOptions Options\n * @param {ConfigData} config Config.\n * @returns {Required<VerifyOptions> & InternalOptions} Normalized options\n */\nfunction normalizeVerifyOptions(providedOptions, config) {\n    const disableInlineConfig = config.noInlineConfig === true;\n    const ignoreInlineConfig = providedOptions.allowInlineConfig === false;\n    const configNameOfNoInlineConfig = config.configNameOfNoInlineConfig\n        ? ` (${config.configNameOfNoInlineConfig})`\n        : \"\";\n\n    let reportUnusedDisableDirectives = providedOptions.reportUnusedDisableDirectives;\n\n    if (typeof reportUnusedDisableDirectives === \"boolean\") {\n        reportUnusedDisableDirectives = reportUnusedDisableDirectives ? \"error\" : \"off\";\n    }\n    if (typeof reportUnusedDisableDirectives !== \"string\") {\n        reportUnusedDisableDirectives = config.reportUnusedDisableDirectives ? \"warn\" : \"off\";\n    }\n\n    return {\n        filename: normalizeFilename(providedOptions.filename || \"<input>\"),\n        allowInlineConfig: !ignoreInlineConfig,\n        warnInlineConfig: disableInlineConfig && !ignoreInlineConfig\n            ? `your config${configNameOfNoInlineConfig}`\n            : null,\n        reportUnusedDisableDirectives,\n        disableFixes: Boolean(providedOptions.disableFixes)\n    };\n}\n\n/**\n * Combines the provided parserOptions with the options from environments\n * @param {string} parserName The parser name which uses this options.\n * @param {ParserOptions} providedOptions The provided 'parserOptions' key in a config\n * @param {Environment[]} enabledEnvironments The environments enabled in configuration and with inline comments\n * @returns {ParserOptions} Resulting parser options after merge\n */\nfunction resolveParserOptions(parserName, providedOptions, enabledEnvironments) {\n    const parserOptionsFromEnv = enabledEnvironments\n        .filter(env => env.parserOptions)\n        .reduce((parserOptions, env) => lodash.merge(parserOptions, env.parserOptions), {});\n    const mergedParserOptions = lodash.merge(parserOptionsFromEnv, providedOptions || {});\n    const isModule = mergedParserOptions.sourceType === \"module\";\n\n    if (isModule) {\n\n        /*\n         * can't have global return inside of modules\n         * TODO: espree validate parserOptions.globalReturn when sourceType is setting to module.(@aladdin-add)\n         */\n        mergedParserOptions.ecmaFeatures = Object.assign({}, mergedParserOptions.ecmaFeatures, { globalReturn: false });\n    }\n\n    /*\n     * TODO: @aladdin-add\n     * 1. for a 3rd-party parser, do not normalize parserOptions\n     * 2. for espree, no need to do this (espree will do it)\n     */\n    mergedParserOptions.ecmaVersion = normalizeEcmaVersion$1(mergedParserOptions.ecmaVersion);\n\n    return mergedParserOptions;\n}\n\n/**\n * Combines the provided globals object with the globals from environments\n * @param {Record<string, GlobalConf>} providedGlobals The 'globals' key in a config\n * @param {Environment[]} enabledEnvironments The environments enabled in configuration and with inline comments\n * @returns {Record<string, GlobalConf>} The resolved globals object\n */\nfunction resolveGlobals(providedGlobals, enabledEnvironments) {\n    return Object.assign(\n        {},\n        ...enabledEnvironments.filter(env => env.globals).map(env => env.globals),\n        providedGlobals\n    );\n}\n\n/**\n * Strips Unicode BOM from a given text.\n * @param {string} text A text to strip.\n * @returns {string} The stripped text.\n */\nfunction stripUnicodeBOM(text) {\n\n    /*\n     * Check Unicode BOM.\n     * In JavaScript, string data is stored as UTF-16, so BOM is 0xFEFF.\n     * http://www.ecma-international.org/ecma-262/6.0/#sec-unicode-format-control-characters\n     */\n    if (text.charCodeAt(0) === 0xFEFF) {\n        return text.slice(1);\n    }\n    return text;\n}\n\n/**\n * Get the options for a rule (not including severity), if any\n * @param {Array|number} ruleConfig rule configuration\n * @returns {Array} of rule options, empty Array if none\n */\nfunction getRuleOptions(ruleConfig) {\n    if (Array.isArray(ruleConfig)) {\n        return ruleConfig.slice(1);\n    }\n    return [];\n\n}\n\n/**\n * Analyze scope of the given AST.\n * @param {ASTNode} ast The `Program` node to analyze.\n * @param {ParserOptions} parserOptions The parser options.\n * @param {Record<string, string[]>} visitorKeys The visitor keys.\n * @returns {ScopeManager} The analysis result.\n */\nfunction analyzeScope(ast, parserOptions, visitorKeys) {\n    const ecmaFeatures = parserOptions.ecmaFeatures || {};\n    const ecmaVersion = parserOptions.ecmaVersion || 5;\n\n    return lib.analyze(ast, {\n        ignoreEval: true,\n        nodejsScope: ecmaFeatures.globalReturn,\n        impliedStrict: ecmaFeatures.impliedStrict,\n        ecmaVersion,\n        sourceType: parserOptions.sourceType || \"script\",\n        childVisitorKeys: visitorKeys || lib$1.KEYS,\n        fallback: traverser.getKeys\n    });\n}\n\n/**\n * Parses text into an AST. Moved out here because the try-catch prevents\n * optimization of functions, so it's best to keep the try-catch as isolated\n * as possible\n * @param {string} text The text to parse.\n * @param {Parser} parser The parser to parse.\n * @param {ParserOptions} providedParserOptions Options to pass to the parser\n * @param {string} filePath The path to the file being parsed.\n * @returns {{success: false, error: Problem}|{success: true, sourceCode: SourceCode}}\n * An object containing the AST and parser services if parsing was successful, or the error if parsing failed\n * @private\n */\nfunction parse$4(text, parser, providedParserOptions, filePath) {\n    const textToParse = stripUnicodeBOM(text).replace(astUtils.shebangPattern, (match, captured) => `//${captured}`);\n    const parserOptions = Object.assign({}, providedParserOptions, {\n        loc: true,\n        range: true,\n        raw: true,\n        tokens: true,\n        comment: true,\n        eslintVisitorKeys: true,\n        eslintScopeManager: true,\n        filePath\n    });\n\n    /*\n     * Check for parsing errors first. If there's a parsing error, nothing\n     * else can happen. However, a parsing error does not throw an error\n     * from this method - it's just considered a fatal error message, a\n     * problem that ESLint identified just like any other.\n     */\n    try {\n        const parseResult = (typeof parser.parseForESLint === \"function\")\n            ? parser.parseForESLint(textToParse, parserOptions)\n            : { ast: parser.parse(textToParse, parserOptions) };\n        const ast = parseResult.ast;\n        const parserServices = parseResult.services || {};\n        const visitorKeys = parseResult.visitorKeys || lib$1.KEYS;\n        const scopeManager = parseResult.scopeManager || analyzeScope(ast, parserOptions, visitorKeys);\n\n        return {\n            success: true,\n\n            /*\n             * Save all values that `parseForESLint()` returned.\n             * If a `SourceCode` object is given as the first parameter instead of source code text,\n             * linter skips the parsing process and reuses the source code object.\n             * In that case, linter needs all the values that `parseForESLint()` returned.\n             */\n            sourceCode: new SourceCode$1({\n                text,\n                ast,\n                parserServices,\n                scopeManager,\n                visitorKeys\n            })\n        };\n    } catch (ex) {\n\n        // If the message includes a leading line number, strip it:\n        const message = `Parsing error: ${ex.message.replace(/^line \\d+:/iu, \"\").trim()}`;\n\n        debug$5(\"%s\\n%s\", message, ex.stack);\n\n        return {\n            success: false,\n            error: {\n                ruleId: null,\n                fatal: true,\n                severity: 2,\n                message,\n                line: ex.lineNumber,\n                column: ex.column\n            }\n        };\n    }\n}\n\n/**\n * Gets the scope for the current node\n * @param {ScopeManager} scopeManager The scope manager for this AST\n * @param {ASTNode} currentNode The node to get the scope of\n * @returns {eslint-scope.Scope} The scope information for this node\n */\nfunction getScope(scopeManager, currentNode) {\n\n    // On Program node, get the outermost scope to avoid return Node.js special function scope or ES modules scope.\n    const inner = currentNode.type !== \"Program\";\n\n    for (let node = currentNode; node; node = node.parent) {\n        const scope = scopeManager.acquire(node, inner);\n\n        if (scope) {\n            if (scope.type === \"function-expression-name\") {\n                return scope.childScopes[0];\n            }\n            return scope;\n        }\n    }\n\n    return scopeManager.scopes[0];\n}\n\n/**\n * Marks a variable as used in the current scope\n * @param {ScopeManager} scopeManager The scope manager for this AST. The scope may be mutated by this function.\n * @param {ASTNode} currentNode The node currently being traversed\n * @param {Object} parserOptions The options used to parse this text\n * @param {string} name The name of the variable that should be marked as used.\n * @returns {boolean} True if the variable was found and marked as used, false if not.\n */\nfunction markVariableAsUsed(scopeManager, currentNode, parserOptions, name) {\n    const hasGlobalReturn = parserOptions.ecmaFeatures && parserOptions.ecmaFeatures.globalReturn;\n    const specialScope = hasGlobalReturn || parserOptions.sourceType === \"module\";\n    const currentScope = getScope(scopeManager, currentNode);\n\n    // Special Node.js scope means we need to start one level deeper\n    const initialScope = currentScope.type === \"global\" && specialScope ? currentScope.childScopes[0] : currentScope;\n\n    for (let scope = initialScope; scope; scope = scope.upper) {\n        const variable = scope.variables.find(scopeVar => scopeVar.name === name);\n\n        if (variable) {\n            variable.eslintUsed = true;\n            return true;\n        }\n    }\n\n    return false;\n}\n\n/**\n * Runs a rule, and gets its listeners\n * @param {Rule} rule A normalized rule with a `create` method\n * @param {Context} ruleContext The context that should be passed to the rule\n * @returns {Object} A map of selector listeners provided by the rule\n */\nfunction createRuleListeners(rule, ruleContext) {\n    try {\n        return rule.create(ruleContext);\n    } catch (ex) {\n        ex.message = `Error while loading rule '${ruleContext.id}': ${ex.message}`;\n        throw ex;\n    }\n}\n\n/**\n * Gets all the ancestors of a given node\n * @param {ASTNode} node The node\n * @returns {ASTNode[]} All the ancestor nodes in the AST, not including the provided node, starting\n * from the root node and going inwards to the parent node.\n */\nfunction getAncestors(node) {\n    const ancestorsStartingAtParent = [];\n\n    for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {\n        ancestorsStartingAtParent.push(ancestor);\n    }\n\n    return ancestorsStartingAtParent.reverse();\n}\n\n// methods that exist on SourceCode object\nconst DEPRECATED_SOURCECODE_PASSTHROUGHS = {\n    getSource: \"getText\",\n    getSourceLines: \"getLines\",\n    getAllComments: \"getAllComments\",\n    getNodeByRangeIndex: \"getNodeByRangeIndex\",\n    getComments: \"getComments\",\n    getCommentsBefore: \"getCommentsBefore\",\n    getCommentsAfter: \"getCommentsAfter\",\n    getCommentsInside: \"getCommentsInside\",\n    getJSDocComment: \"getJSDocComment\",\n    getFirstToken: \"getFirstToken\",\n    getFirstTokens: \"getFirstTokens\",\n    getLastToken: \"getLastToken\",\n    getLastTokens: \"getLastTokens\",\n    getTokenAfter: \"getTokenAfter\",\n    getTokenBefore: \"getTokenBefore\",\n    getTokenByRangeStart: \"getTokenByRangeStart\",\n    getTokens: \"getTokens\",\n    getTokensAfter: \"getTokensAfter\",\n    getTokensBefore: \"getTokensBefore\",\n    getTokensBetween: \"getTokensBetween\"\n};\n\nconst BASE_TRAVERSAL_CONTEXT = Object.freeze(\n    Object.keys(DEPRECATED_SOURCECODE_PASSTHROUGHS).reduce(\n        (contextInfo, methodName) =>\n            Object.assign(contextInfo, {\n                [methodName](...args) {\n                    return this.getSourceCode()[DEPRECATED_SOURCECODE_PASSTHROUGHS[methodName]](...args);\n                }\n            }),\n        {}\n    )\n);\n\n/**\n * Runs the given rules on the given SourceCode object\n * @param {SourceCode} sourceCode A SourceCode object for the given text\n * @param {Object} configuredRules The rules configuration\n * @param {function(string): Rule} ruleMapper A mapper function from rule names to rules\n * @param {Object} parserOptions The options that were passed to the parser\n * @param {string} parserName The name of the parser in the config\n * @param {Object} settings The settings that were enabled in the config\n * @param {string} filename The reported filename of the code\n * @param {boolean} disableFixes If true, it doesn't make `fix` properties.\n * @param {string | undefined} cwd cwd of the cli\n * @returns {Problem[]} An array of reported problems\n */\nfunction runRules(sourceCode, configuredRules, ruleMapper, parserOptions, parserName, settings, filename, disableFixes, cwd) {\n    const emitter = safeEmitter();\n    const nodeQueue = [];\n    let currentNode = sourceCode.ast;\n\n    traverser.traverse(sourceCode.ast, {\n        enter(node, parent) {\n            node.parent = parent;\n            nodeQueue.push({ isEntering: true, node });\n        },\n        leave(node) {\n            nodeQueue.push({ isEntering: false, node });\n        },\n        visitorKeys: sourceCode.visitorKeys\n    });\n\n    /*\n     * Create a frozen object with the ruleContext properties and methods that are shared by all rules.\n     * All rule contexts will inherit from this object. This avoids the performance penalty of copying all the\n     * properties once for each rule.\n     */\n    const sharedTraversalContext = Object.freeze(\n        Object.assign(\n            Object.create(BASE_TRAVERSAL_CONTEXT),\n            {\n                getAncestors: () => getAncestors(currentNode),\n                getDeclaredVariables: sourceCode.scopeManager.getDeclaredVariables.bind(sourceCode.scopeManager),\n                getCwd: () => cwd,\n                getFilename: () => filename,\n                getScope: () => getScope(sourceCode.scopeManager, currentNode),\n                getSourceCode: () => sourceCode,\n                markVariableAsUsed: name => markVariableAsUsed(sourceCode.scopeManager, currentNode, parserOptions, name),\n                parserOptions,\n                parserPath: parserName,\n                parserServices: sourceCode.parserServices,\n                settings\n            }\n        )\n    );\n\n\n    const lintingProblems = [];\n\n    Object.keys(configuredRules).forEach(ruleId => {\n        const severity = configOps.getRuleSeverity(configuredRules[ruleId]);\n\n        // not load disabled rules\n        if (severity === 0) {\n            return;\n        }\n\n        const rule = ruleMapper(ruleId);\n\n        if (rule === null) {\n            lintingProblems.push(createLintingProblem({ ruleId }));\n            return;\n        }\n\n        const messageIds = rule.meta && rule.meta.messages;\n        let reportTranslator$1 = null;\n        const ruleContext = Object.freeze(\n            Object.assign(\n                Object.create(sharedTraversalContext),\n                {\n                    id: ruleId,\n                    options: getRuleOptions(configuredRules[ruleId]),\n                    report(...args) {\n\n                        /*\n                         * Create a report translator lazily.\n                         * In a vast majority of cases, any given rule reports zero errors on a given\n                         * piece of code. Creating a translator lazily avoids the performance cost of\n                         * creating a new translator function for each rule that usually doesn't get\n                         * called.\n                         *\n                         * Using lazy report translators improves end-to-end performance by about 3%\n                         * with Node 8.4.0.\n                         */\n                        if (reportTranslator$1 === null) {\n                            reportTranslator$1 = reportTranslator({\n                                ruleId,\n                                severity,\n                                sourceCode,\n                                messageIds,\n                                disableFixes\n                            });\n                        }\n                        const problem = reportTranslator$1(...args);\n\n                        if (problem.fix && rule.meta && !rule.meta.fixable) {\n                            throw new Error(\"Fixable rules should export a `meta.fixable` property.\");\n                        }\n                        lintingProblems.push(problem);\n                    }\n                }\n            )\n        );\n\n        const ruleListeners = createRuleListeners(rule, ruleContext);\n\n        // add all the selectors from the rule as listeners\n        Object.keys(ruleListeners).forEach(selector => {\n            emitter.on(\n                selector,\n                timing.enabled\n                    ? timing.time(ruleId, ruleListeners[selector])\n                    : ruleListeners[selector]\n            );\n        });\n    });\n\n    const eventGenerator = new codePathAnalyzer(new nodeEventGenerator(emitter));\n\n    nodeQueue.forEach(traversalInfo => {\n        currentNode = traversalInfo.node;\n\n        try {\n            if (traversalInfo.isEntering) {\n                eventGenerator.enterNode(currentNode);\n            } else {\n                eventGenerator.leaveNode(currentNode);\n            }\n        } catch (err) {\n            err.currentNode = currentNode;\n            throw err;\n        }\n    });\n\n    return lintingProblems;\n}\n\n/**\n * Ensure the source code to be a string.\n * @param {string|SourceCode} textOrSourceCode The text or source code object.\n * @returns {string} The source code text.\n */\nfunction ensureText(textOrSourceCode) {\n    if (typeof textOrSourceCode === \"object\") {\n        const { hasBOM, text } = textOrSourceCode;\n        const bom = hasBOM ? \"\\uFEFF\" : \"\";\n\n        return bom + text;\n    }\n\n    return String(textOrSourceCode);\n}\n\n/**\n * Get an environment.\n * @param {LinterInternalSlots} slots The internal slots of Linter.\n * @param {string} envId The environment ID to get.\n * @returns {Environment|null} The environment.\n */\nfunction getEnv(slots, envId) {\n    return (\n        (slots.lastConfigArray && slots.lastConfigArray.pluginEnvironments.get(envId)) ||\n        environments.get(envId) ||\n        null\n    );\n}\n\n/**\n * Get a rule.\n * @param {LinterInternalSlots} slots The internal slots of Linter.\n * @param {string} ruleId The rule ID to get.\n * @returns {Rule|null} The rule.\n */\nfunction getRule(slots, ruleId) {\n    return (\n        (slots.lastConfigArray && slots.lastConfigArray.pluginRules.get(ruleId)) ||\n        slots.ruleMap.get(ruleId)\n    );\n}\n\n/**\n * Normalize the value of the cwd\n * @param {string | undefined} cwd raw value of the cwd, path to a directory that should be considered as the current working directory, can be undefined.\n * @returns {string | undefined} normalized cwd\n */\nfunction normalizeCwd(cwd) {\n    if (cwd) {\n        return cwd;\n    }\n    if (typeof process === \"object\") {\n        return process.cwd();\n    }\n\n    // It's more explicit to assign the undefined\n    // eslint-disable-next-line no-undefined\n    return undefined;\n}\n\n/**\n * The map to store private data.\n * @type {WeakMap<Linter, LinterInternalSlots>}\n */\nconst internalSlotsMap = new WeakMap();\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * Object that is responsible for verifying JavaScript text\n * @name eslint\n */\nclass Linter {\n\n    /**\n     * Initialize the Linter.\n     * @param {Object} [config] the config object\n     * @param {string} [config.cwd]  path to a directory that should be considered as the current working directory, can be undefined.\n     */\n    constructor({ cwd } = {}) {\n        internalSlotsMap.set(this, {\n            cwd: normalizeCwd(cwd),\n            lastConfigArray: null,\n            lastSourceCode: null,\n            parserMap: new Map([[\"espree\", espree_1]]),\n            ruleMap: new rules$2()\n        });\n\n        this.version = pkg.version;\n    }\n\n    /**\n     * Getter for package version.\n     * @static\n     * @returns {string} The version from package.json.\n     */\n    static get version() {\n        return pkg.version;\n    }\n\n    /**\n     * Same as linter.verify, except without support for processors.\n     * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object.\n     * @param {ConfigData} providedConfig An ESLintConfig instance to configure everything.\n     * @param {VerifyOptions} [providedOptions] The optional filename of the file being checked.\n     * @returns {LintMessage[]} The results as an array of messages or an empty array if no messages.\n     */\n    _verifyWithoutProcessors(textOrSourceCode, providedConfig, providedOptions) {\n        const slots = internalSlotsMap.get(this);\n        const config = providedConfig || {};\n        const options = normalizeVerifyOptions(providedOptions, config);\n        let text;\n\n        // evaluate arguments\n        if (typeof textOrSourceCode === \"string\") {\n            slots.lastSourceCode = null;\n            text = textOrSourceCode;\n        } else {\n            slots.lastSourceCode = textOrSourceCode;\n            text = textOrSourceCode.text;\n        }\n\n        // Resolve parser.\n        let parserName = DEFAULT_PARSER_NAME;\n        let parser = espree_1;\n\n        if (typeof config.parser === \"object\" && config.parser !== null) {\n            parserName = config.parser.filePath;\n            parser = config.parser.definition;\n        } else if (typeof config.parser === \"string\") {\n            if (!slots.parserMap.has(config.parser)) {\n                return [{\n                    ruleId: null,\n                    fatal: true,\n                    severity: 2,\n                    message: `Configured parser '${config.parser}' was not found.`,\n                    line: 0,\n                    column: 0\n                }];\n            }\n            parserName = config.parser;\n            parser = slots.parserMap.get(config.parser);\n        }\n\n        // search and apply \"eslint-env *\".\n        const envInFile = options.allowInlineConfig && !options.warnInlineConfig\n            ? findEslintEnv(text)\n            : {};\n        const resolvedEnvConfig = Object.assign({ builtin: true }, config.env, envInFile);\n        const enabledEnvs = Object.keys(resolvedEnvConfig)\n            .filter(envName => resolvedEnvConfig[envName])\n            .map(envName => getEnv(slots, envName))\n            .filter(env => env);\n\n        const parserOptions = resolveParserOptions(parserName, config.parserOptions || {}, enabledEnvs);\n        const configuredGlobals = resolveGlobals(config.globals || {}, enabledEnvs);\n        const settings = config.settings || {};\n\n        if (!slots.lastSourceCode) {\n            const parseResult = parse$4(\n                text,\n                parser,\n                parserOptions,\n                options.filename\n            );\n\n            if (!parseResult.success) {\n                return [parseResult.error];\n            }\n\n            slots.lastSourceCode = parseResult.sourceCode;\n        } else {\n\n            /*\n             * If the given source code object as the first argument does not have scopeManager, analyze the scope.\n             * This is for backward compatibility (SourceCode is frozen so it cannot rebind).\n             */\n            if (!slots.lastSourceCode.scopeManager) {\n                slots.lastSourceCode = new SourceCode$1({\n                    text: slots.lastSourceCode.text,\n                    ast: slots.lastSourceCode.ast,\n                    parserServices: slots.lastSourceCode.parserServices,\n                    visitorKeys: slots.lastSourceCode.visitorKeys,\n                    scopeManager: analyzeScope(slots.lastSourceCode.ast, parserOptions)\n                });\n            }\n        }\n\n        const sourceCode = slots.lastSourceCode;\n        const commentDirectives = options.allowInlineConfig\n            ? getDirectiveComments(options.filename, sourceCode.ast, ruleId => getRule(slots, ruleId), options.warnInlineConfig)\n            : { configuredRules: {}, enabledGlobals: {}, exportedVariables: {}, problems: [], disableDirectives: [] };\n\n        // augment global scope with declared global variables\n        addDeclaredGlobals(\n            sourceCode.scopeManager.scopes[0],\n            configuredGlobals,\n            { exportedVariables: commentDirectives.exportedVariables, enabledGlobals: commentDirectives.enabledGlobals }\n        );\n\n        const configuredRules = Object.assign({}, config.rules, commentDirectives.configuredRules);\n\n        let lintingProblems;\n\n        try {\n            lintingProblems = runRules(\n                sourceCode,\n                configuredRules,\n                ruleId => getRule(slots, ruleId),\n                parserOptions,\n                parserName,\n                settings,\n                options.filename,\n                options.disableFixes,\n                slots.cwd\n            );\n        } catch (err) {\n            err.message += `\\nOccurred while linting ${options.filename}`;\n            debug$5(\"An error occurred while traversing\");\n            debug$5(\"Filename:\", options.filename);\n            if (err.currentNode) {\n                const { line } = err.currentNode.loc.start;\n\n                debug$5(\"Line:\", line);\n                err.message += `:${line}`;\n            }\n            debug$5(\"Parser Options:\", parserOptions);\n            debug$5(\"Parser Path:\", parserName);\n            debug$5(\"Settings:\", settings);\n            throw err;\n        }\n\n        return applyDisableDirectives({\n            directives: commentDirectives.disableDirectives,\n            problems: lintingProblems\n                .concat(commentDirectives.problems)\n                .sort((problemA, problemB) => problemA.line - problemB.line || problemA.column - problemB.column),\n            reportUnusedDisableDirectives: options.reportUnusedDisableDirectives\n        });\n    }\n\n    /**\n     * Verifies the text against the rules specified by the second argument.\n     * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object.\n     * @param {ConfigData|ConfigArray} config An ESLintConfig instance to configure everything.\n     * @param {(string|(VerifyOptions&ProcessorOptions))} [filenameOrOptions] The optional filename of the file being checked.\n     *      If this is not set, the filename will default to '<input>' in the rule context. If\n     *      an object, then it has \"filename\", \"allowInlineConfig\", and some properties.\n     * @returns {LintMessage[]} The results as an array of messages or an empty array if no messages.\n     */\n    verify(textOrSourceCode, config, filenameOrOptions) {\n        debug$5(\"Verify\");\n        const options = typeof filenameOrOptions === \"string\"\n            ? { filename: filenameOrOptions }\n            : filenameOrOptions || {};\n\n        // CLIEngine passes a `ConfigArray` object.\n        if (config && typeof config.extractConfig === \"function\") {\n            return this._verifyWithConfigArray(textOrSourceCode, config, options);\n        }\n\n        /*\n         * `Linter` doesn't support `overrides` property in configuration.\n         * So we cannot apply multiple processors.\n         */\n        if (options.preprocess || options.postprocess) {\n            return this._verifyWithProcessor(textOrSourceCode, config, options);\n        }\n        return this._verifyWithoutProcessors(textOrSourceCode, config, options);\n    }\n\n    /**\n     * Verify a given code with `ConfigArray`.\n     * @param {string|SourceCode} textOrSourceCode The source code.\n     * @param {ConfigArray} configArray The config array.\n     * @param {VerifyOptions&ProcessorOptions} options The options.\n     * @returns {LintMessage[]} The found problems.\n     */\n    _verifyWithConfigArray(textOrSourceCode, configArray, options) {\n        debug$5(\"With ConfigArray: %s\", options.filename);\n\n        // Store the config array in order to get plugin envs and rules later.\n        internalSlotsMap.get(this).lastConfigArray = configArray;\n\n        // Extract the final config for this file.\n        const config = configArray.extractConfig(options.filename);\n        const processor =\n            config.processor &&\n            configArray.pluginProcessors.get(config.processor);\n\n        // Verify.\n        if (processor) {\n            debug$5(\"Apply the processor: %o\", config.processor);\n            const { preprocess, postprocess, supportsAutofix } = processor;\n            const disableFixes = options.disableFixes || !supportsAutofix;\n\n            return this._verifyWithProcessor(\n                textOrSourceCode,\n                config,\n                { ...options, disableFixes, postprocess, preprocess },\n                configArray\n            );\n        }\n        return this._verifyWithoutProcessors(textOrSourceCode, config, options);\n    }\n\n    /**\n     * Verify with a processor.\n     * @param {string|SourceCode} textOrSourceCode The source code.\n     * @param {ConfigData|ExtractedConfig} config The config array.\n     * @param {VerifyOptions&ProcessorOptions} options The options.\n     * @param {ConfigArray} [configForRecursive] The `CofnigArray` object to apply multiple processors recursively.\n     * @returns {LintMessage[]} The found problems.\n     */\n    _verifyWithProcessor(textOrSourceCode, config, options, configForRecursive) {\n        const filename = options.filename || \"<input>\";\n        const filenameToExpose = normalizeFilename(filename);\n        const text = ensureText(textOrSourceCode);\n        const preprocess = options.preprocess || (rawText => [rawText]);\n        const postprocess = options.postprocess || lodash.flatten;\n        const filterCodeBlock =\n            options.filterCodeBlock ||\n            (blockFilename => blockFilename.endsWith(\".js\"));\n        const originalExtname = path$1.extname(filename);\n        const messageLists = preprocess(text, filenameToExpose).map((block, i) => {\n            debug$5(\"A code block was found: %o\", block.filename || \"(unnamed)\");\n\n            // Keep the legacy behavior.\n            if (typeof block === \"string\") {\n                return this._verifyWithoutProcessors(block, config, options);\n            }\n\n            const blockText = block.text;\n            const blockName = path$1.join(filename, `${i}_${block.filename}`);\n\n            // Skip this block if filtered.\n            if (!filterCodeBlock(blockName, blockText)) {\n                debug$5(\"This code block was skipped.\");\n                return [];\n            }\n\n            // Resolve configuration again if the file extension was changed.\n            if (configForRecursive && path$1.extname(blockName) !== originalExtname) {\n                debug$5(\"Resolving configuration again because the file extension was changed.\");\n                return this._verifyWithConfigArray(\n                    blockText,\n                    configForRecursive,\n                    { ...options, filename: blockName }\n                );\n            }\n\n            // Does lint.\n            return this._verifyWithoutProcessors(\n                blockText,\n                config,\n                { ...options, filename: blockName }\n            );\n        });\n\n        return postprocess(messageLists, filenameToExpose);\n    }\n\n    /**\n     * Gets the SourceCode object representing the parsed source.\n     * @returns {SourceCode} The SourceCode object.\n     */\n    getSourceCode() {\n        return internalSlotsMap.get(this).lastSourceCode;\n    }\n\n    /**\n     * Defines a new linting rule.\n     * @param {string} ruleId A unique rule identifier\n     * @param {Function | Rule} ruleModule Function from context to object mapping AST node types to event handlers\n     * @returns {void}\n     */\n    defineRule(ruleId, ruleModule) {\n        internalSlotsMap.get(this).ruleMap.define(ruleId, ruleModule);\n    }\n\n    /**\n     * Defines many new linting rules.\n     * @param {Record<string, Function | Rule>} rulesToDefine map from unique rule identifier to rule\n     * @returns {void}\n     */\n    defineRules(rulesToDefine) {\n        Object.getOwnPropertyNames(rulesToDefine).forEach(ruleId => {\n            this.defineRule(ruleId, rulesToDefine[ruleId]);\n        });\n    }\n\n    /**\n     * Gets an object with all loaded rules.\n     * @returns {Map<string, Rule>} All loaded rules\n     */\n    getRules() {\n        const { lastConfigArray, ruleMap } = internalSlotsMap.get(this);\n\n        return new Map(function *() {\n            yield* ruleMap;\n\n            if (lastConfigArray) {\n                yield* lastConfigArray.pluginRules;\n            }\n        }());\n    }\n\n    /**\n     * Define a new parser module\n     * @param {string} parserId Name of the parser\n     * @param {Parser} parserModule The parser object\n     * @returns {void}\n     */\n    defineParser(parserId, parserModule) {\n        internalSlotsMap.get(this).parserMap.set(parserId, parserModule);\n    }\n\n    /**\n     * Performs multiple autofix passes over the text until as many fixes as possible\n     * have been applied.\n     * @param {string} text The source text to apply fixes to.\n     * @param {ConfigData|ConfigArray} config The ESLint config object to use.\n     * @param {VerifyOptions&ProcessorOptions&FixOptions} options The ESLint options object to use.\n     * @returns {{fixed:boolean,messages:LintMessage[],output:string}} The result of the fix operation as returned from the\n     *      SourceCodeFixer.\n     */\n    verifyAndFix(text, config, options) {\n        let messages = [],\n            fixedResult,\n            fixed = false,\n            passNumber = 0,\n            currentText = text;\n        const debugTextDescription = options && options.filename || `${text.slice(0, 10)}...`;\n        const shouldFix = options && typeof options.fix !== \"undefined\" ? options.fix : true;\n\n        /**\n         * This loop continues until one of the following is true:\n         *\n         * 1. No more fixes have been applied.\n         * 2. Ten passes have been made.\n         *\n         * That means anytime a fix is successfully applied, there will be another pass.\n         * Essentially, guaranteeing a minimum of two passes.\n         */\n        do {\n            passNumber++;\n\n            debug$5(`Linting code for ${debugTextDescription} (pass ${passNumber})`);\n            messages = this.verify(currentText, config, options);\n\n            debug$5(`Generating fixed text for ${debugTextDescription} (pass ${passNumber})`);\n            fixedResult = sourceCodeFixer.applyFixes(currentText, messages, shouldFix);\n\n            /*\n             * stop if there are any syntax errors.\n             * 'fixedResult.output' is a empty string.\n             */\n            if (messages.length === 1 && messages[0].fatal) {\n                break;\n            }\n\n            // keep track if any fixes were ever applied - important for return value\n            fixed = fixed || fixedResult.fixed;\n\n            // update to use the fixed output instead of the original text\n            currentText = fixedResult.output;\n\n        } while (\n            fixedResult.fixed &&\n            passNumber < MAX_AUTOFIX_PASSES\n        );\n\n        /*\n         * If the last result had fixes, we need to lint again to be sure we have\n         * the most up-to-date information.\n         */\n        if (fixedResult.fixed) {\n            fixedResult.messages = this.verify(currentText, config, options);\n        }\n\n        // ensure the last result properly reflects if fixes were done\n        fixedResult.fixed = fixed;\n        fixedResult.output = currentText;\n\n        return fixedResult;\n    }\n}\n\nvar linter = {\n    Linter,\n\n    /**\n     * Get the internal slots of a given Linter instance for tests.\n     * @param {Linter} instance The Linter instance to get.\n     * @returns {LinterInternalSlots} The internal slots.\n     */\n    getLinterInternalSlots(instance) {\n        return internalSlotsMap.get(instance);\n    }\n};\n\nconst { Linter: Linter$1 } = linter;\n\n\n\nvar linter$1 = {\n    Linter: Linter$1,\n\n    // For testers.\n    SourceCodeFixer: sourceCodeFixer,\n    interpolate\n};\n\nconst resolveFrom = (fromDir, moduleId, silent) => {\n\tif (typeof fromDir !== 'string') {\n\t\tthrow new TypeError(`Expected \\`fromDir\\` to be of type \\`string\\`, got \\`${typeof fromDir}\\``);\n\t}\n\n\tif (typeof moduleId !== 'string') {\n\t\tthrow new TypeError(`Expected \\`moduleId\\` to be of type \\`string\\`, got \\`${typeof moduleId}\\``);\n\t}\n\n\ttry {\n\t\tfromDir = fs$2.realpathSync(fromDir);\n\t} catch (err) {\n\t\tif (err.code === 'ENOENT') {\n\t\t\tfromDir = path$1.resolve(fromDir);\n\t\t} else if (silent) {\n\t\t\treturn null;\n\t\t} else {\n\t\t\tthrow err;\n\t\t}\n\t}\n\n\tconst fromFile = path$1.join(fromDir, 'noop.js');\n\n\tconst resolveFileName = () => module$1._resolveFilename(moduleId, {\n\t\tid: fromFile,\n\t\tfilename: fromFile,\n\t\tpaths: module$1._nodeModulePaths(fromDir)\n\t});\n\n\tif (silent) {\n\t\ttry {\n\t\t\treturn resolveFileName();\n\t\t} catch (err) {\n\t\t\treturn null;\n\t\t}\n\t}\n\n\treturn resolveFileName();\n};\n\nvar resolveFrom_1 = (fromDir, moduleId) => resolveFrom(fromDir, moduleId);\nvar silent = (fromDir, moduleId) => resolveFrom(fromDir, moduleId, true);\nresolveFrom_1.silent = silent;\n\nvar parentModule = filepath => {\n\tconst stacks = callsites_1();\n\n\tif (!filepath) {\n\t\treturn stacks[2].getFileName();\n\t}\n\n\tlet seenVal = false;\n\n\t// Skip the first stack as it's this function\n\tstacks.shift();\n\n\tfor (const stack of stacks) {\n\t\tconst parentFilepath = stack.getFileName();\n\n\t\tif (typeof parentFilepath !== 'string') {\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (parentFilepath === filepath) {\n\t\t\tseenVal = true;\n\t\t\tcontinue;\n\t\t}\n\n\t\t// Skip native modules\n\t\tif (parentFilepath === 'module.js') {\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (seenVal && parentFilepath !== filepath) {\n\t\t\treturn parentFilepath;\n\t\t}\n\t}\n};\n\nvar importFresh = moduleId => {\n\tif (typeof moduleId !== 'string') {\n\t\tthrow new TypeError('Expected a string');\n\t}\n\n\tconst parentPath = parentModule(__filename);\n\n\tconst filePath = resolveFrom_1(path$1.dirname(parentPath), moduleId);\n\n\tconst oldModule = commonjsRequire.cache[filePath];\n\t// Delete itself from module parent\n\tif (oldModule && oldModule.parent) {\n\t\tlet i = oldModule.parent.children.length;\n\n\t\twhile (i--) {\n\t\t\tif (oldModule.parent.children[i].id === filePath) {\n\t\t\t\toldModule.parent.children.splice(i, 1);\n\t\t\t}\n\t\t}\n\t}\n\n\tdelete commonjsRequire.cache[filePath]; // Delete module from cache\n\n\tconst parent = commonjsRequire.cache[parentPath]; // If `filePath` and `parentPath` are the same, cache will already be deleted so we won't get a memory leak in next step\n\n\treturn parent === undefined ? commonjsRequire() : parent.require(filePath); // In case cache doesn't have parent, fall back to normal require\n};\n\nconst singleComment = Symbol('singleComment');\nconst multiComment = Symbol('multiComment');\nconst stripWithoutWhitespace = () => '';\nconst stripWithWhitespace = (string, start, end) => string.slice(start, end).replace(/\\S/g, ' ');\n\nconst isEscaped$1 = (jsonString, quotePosition) => {\n\tlet index = quotePosition - 1;\n\tlet backslashCount = 0;\n\n\twhile (jsonString[index] === '\\\\') {\n\t\tindex -= 1;\n\t\tbackslashCount += 1;\n\t}\n\n\treturn Boolean(backslashCount % 2);\n};\n\nvar stripJsonComments = (jsonString, options = {}) => {\n\tif (typeof jsonString !== 'string') {\n\t\tthrow new TypeError(`Expected argument \\`jsonString\\` to be a \\`string\\`, got \\`${typeof jsonString}\\``);\n\t}\n\n\tconst strip = options.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;\n\n\tlet insideString = false;\n\tlet insideComment = false;\n\tlet offset = 0;\n\tlet result = '';\n\n\tfor (let i = 0; i < jsonString.length; i++) {\n\t\tconst currentCharacter = jsonString[i];\n\t\tconst nextCharacter = jsonString[i + 1];\n\n\t\tif (!insideComment && currentCharacter === '\"') {\n\t\t\tconst escaped = isEscaped$1(jsonString, i);\n\t\t\tif (!escaped) {\n\t\t\t\tinsideString = !insideString;\n\t\t\t}\n\t\t}\n\n\t\tif (insideString) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (!insideComment && currentCharacter + nextCharacter === '//') {\n\t\t\tresult += jsonString.slice(offset, i);\n\t\t\toffset = i;\n\t\t\tinsideComment = singleComment;\n\t\t\ti++;\n\t\t} else if (insideComment === singleComment && currentCharacter + nextCharacter === '\\r\\n') {\n\t\t\ti++;\n\t\t\tinsideComment = false;\n\t\t\tresult += strip(jsonString, offset, i);\n\t\t\toffset = i;\n\t\t\tcontinue;\n\t\t} else if (insideComment === singleComment && currentCharacter === '\\n') {\n\t\t\tinsideComment = false;\n\t\t\tresult += strip(jsonString, offset, i);\n\t\t\toffset = i;\n\t\t} else if (!insideComment && currentCharacter + nextCharacter === '/*') {\n\t\t\tresult += jsonString.slice(offset, i);\n\t\t\toffset = i;\n\t\t\tinsideComment = multiComment;\n\t\t\ti++;\n\t\t\tcontinue;\n\t\t} else if (insideComment === multiComment && currentCharacter + nextCharacter === '*/') {\n\t\t\ti++;\n\t\t\tinsideComment = false;\n\t\t\tresult += strip(jsonString, offset, i + 1);\n\t\t\toffset = i + 1;\n\t\t\tcontinue;\n\t\t}\n\t}\n\n\treturn result + (insideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\nconst debug$6 = src(\"eslint:ignore-pattern\");\n\n/** @typedef {ReturnType<import(\"ignore\").default>} Ignore */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Get the path to the common ancestor directory of given paths.\n * @param {string[]} sourcePaths The paths to calculate the common ancestor.\n * @returns {string} The path to the common ancestor directory.\n */\nfunction getCommonAncestorPath(sourcePaths) {\n    let result = sourcePaths[0];\n\n    for (let i = 1; i < sourcePaths.length; ++i) {\n        const a = result;\n        const b = sourcePaths[i];\n\n        // Set the shorter one (it's the common ancestor if one includes the other).\n        result = a.length < b.length ? a : b;\n\n        // Set the common ancestor.\n        for (let j = 0, lastSepPos = 0; j < a.length && j < b.length; ++j) {\n            if (a[j] !== b[j]) {\n                result = a.slice(0, lastSepPos);\n                break;\n            }\n            if (a[j] === path$1.sep) {\n                lastSepPos = j;\n            }\n        }\n    }\n\n    return result || path$1.sep;\n}\n\n/**\n * Make relative path.\n * @param {string} from The source path to get relative path.\n * @param {string} to The destination path to get relative path.\n * @returns {string} The relative path.\n */\nfunction relative(from, to) {\n    const relPath = path$1.relative(from, to);\n\n    if (path$1.sep === \"/\") {\n        return relPath;\n    }\n    return relPath.split(path$1.sep).join(\"/\");\n}\n\n/**\n * Get the trailing slash if existed.\n * @param {string} filePath The path to check.\n * @returns {string} The trailing slash if existed.\n */\nfunction dirSuffix(filePath) {\n    const isDir = (\n        filePath.endsWith(path$1.sep) ||\n        (process.platform === \"win32\" && filePath.endsWith(\"/\"))\n    );\n\n    return isDir ? \"/\" : \"\";\n}\n\nconst DefaultPatterns = Object.freeze([\"/node_modules/*\", \"/bower_components/*\"]);\nconst DotPatterns = Object.freeze([\".*\", \"!../\"]);\n\n//------------------------------------------------------------------------------\n// Public\n//------------------------------------------------------------------------------\n\nclass IgnorePattern {\n\n    /**\n     * The default patterns.\n     * @type {string[]}\n     */\n    static get DefaultPatterns() {\n        return DefaultPatterns;\n    }\n\n    /**\n     * Create the default predicate function.\n     * @param {string} cwd The current working directory.\n     * @returns {((filePath:string, dot:boolean) => boolean) & {basePath:string; patterns:string[]}}\n     * The preficate function.\n     * The first argument is an absolute path that is checked.\n     * The second argument is the flag to not ignore dotfiles.\n     * If the predicate function returned `true`, it means the path should be ignored.\n     */\n    static createDefaultIgnore(cwd) {\n        return this.createIgnore([new IgnorePattern(DefaultPatterns, cwd)]);\n    }\n\n    /**\n     * Create the predicate function from multiple `IgnorePattern` objects.\n     * @param {IgnorePattern[]} ignorePatterns The list of ignore patterns.\n     * @returns {((filePath:string, dot?:boolean) => boolean) & {basePath:string; patterns:string[]}}\n     * The preficate function.\n     * The first argument is an absolute path that is checked.\n     * The second argument is the flag to not ignore dotfiles.\n     * If the predicate function returned `true`, it means the path should be ignored.\n     */\n    static createIgnore(ignorePatterns) {\n        debug$6(\"Create with: %o\", ignorePatterns);\n\n        const basePath = getCommonAncestorPath(ignorePatterns.map(p => p.basePath));\n        const patterns = [].concat(\n            ...ignorePatterns.map(p => p.getPatternsRelativeTo(basePath))\n        );\n        const ig = ignore().add([...DotPatterns, ...patterns]);\n        const dotIg = ignore().add(patterns);\n\n        debug$6(\"  processed: %o\", { basePath, patterns });\n\n        return Object.assign(\n            (filePath, dot = false) => {\n                assert(path$1.isAbsolute(filePath), \"'filePath' should be an absolute path.\");\n                const relPathRaw = relative(basePath, filePath);\n                const relPath = relPathRaw && (relPathRaw + dirSuffix(filePath));\n                const adoptedIg = dot ? dotIg : ig;\n                const result = relPath !== \"\" && adoptedIg.ignores(relPath);\n\n                debug$6(\"Check\", { filePath, dot, relativePath: relPath, result });\n                return result;\n            },\n            { basePath, patterns }\n        );\n    }\n\n    /**\n     * Initialize a new `IgnorePattern` instance.\n     * @param {string[]} patterns The glob patterns that ignore to lint.\n     * @param {string} basePath The base path of `patterns`.\n     */\n    constructor(patterns, basePath) {\n        assert(path$1.isAbsolute(basePath), \"'basePath' should be an absolute path.\");\n\n        /**\n         * The glob patterns that ignore to lint.\n         * @type {string[]}\n         */\n        this.patterns = patterns;\n\n        /**\n         * The base path of `patterns`.\n         * @type {string}\n         */\n        this.basePath = basePath;\n\n        /**\n         * If `true` then patterns which don't start with `/` will match the paths to the outside of `basePath`. Defaults to `false`.\n         *\n         * It's set `true` for `.eslintignore`, `package.json`, and `--ignore-path` for backward compatibility.\n         * It's `false` as-is for `ignorePatterns` property in config files.\n         * @type {boolean}\n         */\n        this.loose = false;\n    }\n\n    /**\n     * Get `patterns` as modified for a given base path. It modifies the\n     * absolute paths in the patterns as prepending the difference of two base\n     * paths.\n     * @param {string} newBasePath The base path.\n     * @returns {string[]} Modifired patterns.\n     */\n    getPatternsRelativeTo(newBasePath) {\n        assert(path$1.isAbsolute(newBasePath), \"'newBasePath' should be an absolute path.\");\n        const { basePath, loose, patterns } = this;\n\n        if (newBasePath === basePath) {\n            return patterns;\n        }\n        const prefix = `/${relative(newBasePath, basePath)}`;\n\n        return patterns.map(pattern => {\n            const negative = pattern.startsWith(\"!\");\n            const head = negative ? \"!\" : \"\";\n            const body = negative ? pattern.slice(1) : pattern;\n\n            if (body.startsWith(\"/\") || body.startsWith(\"../\")) {\n                return `${head}${prefix}${body}`;\n            }\n            return loose ? pattern : `${head}${prefix}/**/${body}`;\n        });\n    }\n}\n\nvar ignorePattern = { IgnorePattern };\n\nconst { IgnorePattern: IgnorePattern$1 } = ignorePattern;\n\n// For VSCode intellisense\n/** @typedef {import(\"../../shared/types\").ConfigData} ConfigData */\n/** @typedef {import(\"../../shared/types\").GlobalConf} GlobalConf */\n/** @typedef {import(\"../../shared/types\").SeverityConf} SeverityConf */\n/** @typedef {import(\"./config-dependency\").DependentParser} DependentParser */\n/** @typedef {import(\"./config-dependency\").DependentPlugin} DependentPlugin */\n\n/**\n * Check if `xs` starts with `ys`.\n * @template T\n * @param {T[]} xs The array to check.\n * @param {T[]} ys The array that may be the first part of `xs`.\n * @returns {boolean} `true` if `xs` starts with `ys`.\n */\nfunction startsWith(xs, ys) {\n    return xs.length >= ys.length && ys.every((y, i) => y === xs[i]);\n}\n\n/**\n * The class for extracted config data.\n */\nclass ExtractedConfig {\n    constructor() {\n\n        /**\n         * The config name what `noInlineConfig` setting came from.\n         * @type {string}\n         */\n        this.configNameOfNoInlineConfig = \"\";\n\n        /**\n         * Environments.\n         * @type {Record<string, boolean>}\n         */\n        this.env = {};\n\n        /**\n         * Global variables.\n         * @type {Record<string, GlobalConf>}\n         */\n        this.globals = {};\n\n        /**\n         * The glob patterns that ignore to lint.\n         * @type {(((filePath:string, dot?:boolean) => boolean) & { basePath:string; patterns:string[] }) | undefined}\n         */\n        this.ignores = void 0;\n\n        /**\n         * The flag that disables directive comments.\n         * @type {boolean|undefined}\n         */\n        this.noInlineConfig = void 0;\n\n        /**\n         * Parser definition.\n         * @type {DependentParser|null}\n         */\n        this.parser = null;\n\n        /**\n         * Options for the parser.\n         * @type {Object}\n         */\n        this.parserOptions = {};\n\n        /**\n         * Plugin definitions.\n         * @type {Record<string, DependentPlugin>}\n         */\n        this.plugins = {};\n\n        /**\n         * Processor ID.\n         * @type {string|null}\n         */\n        this.processor = null;\n\n        /**\n         * The flag that reports unused `eslint-disable` directive comments.\n         * @type {boolean|undefined}\n         */\n        this.reportUnusedDisableDirectives = void 0;\n\n        /**\n         * Rule settings.\n         * @type {Record<string, [SeverityConf, ...any[]]>}\n         */\n        this.rules = {};\n\n        /**\n         * Shared settings.\n         * @type {Object}\n         */\n        this.settings = {};\n    }\n\n    /**\n     * Convert this config to the compatible object as a config file content.\n     * @returns {ConfigData} The converted object.\n     */\n    toCompatibleObjectAsConfigFileContent() {\n        const {\n            /* eslint-disable no-unused-vars */\n            configNameOfNoInlineConfig: _ignore1,\n            processor: _ignore2,\n            /* eslint-enable no-unused-vars */\n            ignores,\n            ...config\n        } = this;\n\n        config.parser = config.parser && config.parser.filePath;\n        config.plugins = Object.keys(config.plugins).filter(Boolean).reverse();\n        config.ignorePatterns = ignores ? ignores.patterns : [];\n\n        // Strip the default patterns from `ignorePatterns`.\n        if (startsWith(config.ignorePatterns, IgnorePattern$1.DefaultPatterns)) {\n            config.ignorePatterns =\n                config.ignorePatterns.slice(IgnorePattern$1.DefaultPatterns.length);\n        }\n\n        return config;\n    }\n}\n\nvar extractedConfig = { ExtractedConfig };\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nconst { ExtractedConfig: ExtractedConfig$1 } = extractedConfig;\nconst { IgnorePattern: IgnorePattern$2 } = ignorePattern;\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n// Define types for VSCode IntelliSense.\n/** @typedef {import(\"../../shared/types\").Environment} Environment */\n/** @typedef {import(\"../../shared/types\").GlobalConf} GlobalConf */\n/** @typedef {import(\"../../shared/types\").RuleConf} RuleConf */\n/** @typedef {import(\"../../shared/types\").Rule} Rule */\n/** @typedef {import(\"../../shared/types\").Plugin} Plugin */\n/** @typedef {import(\"../../shared/types\").Processor} Processor */\n/** @typedef {import(\"./config-dependency\").DependentParser} DependentParser */\n/** @typedef {import(\"./config-dependency\").DependentPlugin} DependentPlugin */\n/** @typedef {import(\"./override-tester\")[\"OverrideTester\"]} OverrideTester */\n\n/**\n * @typedef {Object} ConfigArrayElement\n * @property {string} name The name of this config element.\n * @property {string} filePath The path to the source file of this config element.\n * @property {InstanceType<OverrideTester>|null} criteria The tester for the `files` and `excludedFiles` of this config element.\n * @property {Record<string, boolean>|undefined} env The environment settings.\n * @property {Record<string, GlobalConf>|undefined} globals The global variable settings.\n * @property {IgnorePattern|undefined} ignorePattern The ignore patterns.\n * @property {boolean|undefined} noInlineConfig The flag that disables directive comments.\n * @property {DependentParser|undefined} parser The parser loader.\n * @property {Object|undefined} parserOptions The parser options.\n * @property {Record<string, DependentPlugin>|undefined} plugins The plugin loaders.\n * @property {string|undefined} processor The processor name to refer plugin's processor.\n * @property {boolean|undefined} reportUnusedDisableDirectives The flag to report unused `eslint-disable` comments.\n * @property {boolean|undefined} root The flag to express root.\n * @property {Record<string, RuleConf>|undefined} rules The rule settings\n * @property {Object|undefined} settings The shared settings.\n */\n\n/**\n * @typedef {Object} ConfigArrayInternalSlots\n * @property {Map<string, ExtractedConfig>} cache The cache to extract configs.\n * @property {ReadonlyMap<string, Environment>|null} envMap The map from environment ID to environment definition.\n * @property {ReadonlyMap<string, Processor>|null} processorMap The map from processor ID to environment definition.\n * @property {ReadonlyMap<string, Rule>|null} ruleMap The map from rule ID to rule definition.\n */\n\n/** @type {WeakMap<ConfigArray, ConfigArrayInternalSlots>} */\nconst internalSlotsMap$1 = new class extends WeakMap {\n    get(key) {\n        let value = super.get(key);\n\n        if (!value) {\n            value = {\n                cache: new Map(),\n                envMap: null,\n                processorMap: null,\n                ruleMap: null\n            };\n            super.set(key, value);\n        }\n\n        return value;\n    }\n}();\n\n/**\n * Get the indices which are matched to a given file.\n * @param {ConfigArrayElement[]} elements The elements.\n * @param {string} filePath The path to a target file.\n * @returns {number[]} The indices.\n */\nfunction getMatchedIndices(elements, filePath) {\n    const indices = [];\n\n    for (let i = elements.length - 1; i >= 0; --i) {\n        const element = elements[i];\n\n        if (!element.criteria || element.criteria.test(filePath)) {\n            indices.push(i);\n        }\n    }\n\n    return indices;\n}\n\n/**\n * Check if a value is a non-null object.\n * @param {any} x The value to check.\n * @returns {boolean} `true` if the value is a non-null object.\n */\nfunction isNonNullObject(x) {\n    return typeof x === \"object\" && x !== null;\n}\n\n/**\n * Merge two objects.\n *\n * Assign every property values of `y` to `x` if `x` doesn't have the property.\n * If `x`'s property value is an object, it does recursive.\n * @param {Object} target The destination to merge\n * @param {Object|undefined} source The source to merge.\n * @returns {void}\n */\nfunction mergeWithoutOverwrite(target, source) {\n    if (!isNonNullObject(source)) {\n        return;\n    }\n\n    for (const key of Object.keys(source)) {\n        if (key === \"__proto__\") {\n            continue;\n        }\n\n        if (isNonNullObject(target[key])) {\n            mergeWithoutOverwrite(target[key], source[key]);\n        } else if (target[key] === void 0) {\n            if (isNonNullObject(source[key])) {\n                target[key] = Array.isArray(source[key]) ? [] : {};\n                mergeWithoutOverwrite(target[key], source[key]);\n            } else if (source[key] !== void 0) {\n                target[key] = source[key];\n            }\n        }\n    }\n}\n\n/**\n * Merge plugins.\n * `target`'s definition is prior to `source`'s.\n * @param {Record<string, DependentPlugin>} target The destination to merge\n * @param {Record<string, DependentPlugin>|undefined} source The source to merge.\n * @returns {void}\n */\nfunction mergePlugins(target, source) {\n    if (!isNonNullObject(source)) {\n        return;\n    }\n\n    for (const key of Object.keys(source)) {\n        if (key === \"__proto__\") {\n            continue;\n        }\n        const targetValue = target[key];\n        const sourceValue = source[key];\n\n        // Adopt the plugin which was found at first.\n        if (targetValue === void 0) {\n            if (sourceValue.error) {\n                throw sourceValue.error;\n            }\n            target[key] = sourceValue;\n        }\n    }\n}\n\n/**\n * Merge rule configs.\n * `target`'s definition is prior to `source`'s.\n * @param {Record<string, Array>} target The destination to merge\n * @param {Record<string, RuleConf>|undefined} source The source to merge.\n * @returns {void}\n */\nfunction mergeRuleConfigs(target, source) {\n    if (!isNonNullObject(source)) {\n        return;\n    }\n\n    for (const key of Object.keys(source)) {\n        if (key === \"__proto__\") {\n            continue;\n        }\n        const targetDef = target[key];\n        const sourceDef = source[key];\n\n        // Adopt the rule config which was found at first.\n        if (targetDef === void 0) {\n            if (Array.isArray(sourceDef)) {\n                target[key] = [...sourceDef];\n            } else {\n                target[key] = [sourceDef];\n            }\n\n        /*\n         * If the first found rule config is severity only and the current rule\n         * config has options, merge the severity and the options.\n         */\n        } else if (\n            targetDef.length === 1 &&\n            Array.isArray(sourceDef) &&\n            sourceDef.length >= 2\n        ) {\n            targetDef.push(...sourceDef.slice(1));\n        }\n    }\n}\n\n/**\n * Create the extracted config.\n * @param {ConfigArray} instance The config elements.\n * @param {number[]} indices The indices to use.\n * @returns {ExtractedConfig} The extracted config.\n */\nfunction createConfig(instance, indices) {\n    const config = new ExtractedConfig$1();\n    const ignorePatterns = [];\n\n    // Merge elements.\n    for (const index of indices) {\n        const element = instance[index];\n\n        // Adopt the parser which was found at first.\n        if (!config.parser && element.parser) {\n            if (element.parser.error) {\n                throw element.parser.error;\n            }\n            config.parser = element.parser;\n        }\n\n        // Adopt the processor which was found at first.\n        if (!config.processor && element.processor) {\n            config.processor = element.processor;\n        }\n\n        // Adopt the noInlineConfig which was found at first.\n        if (config.noInlineConfig === void 0 && element.noInlineConfig !== void 0) {\n            config.noInlineConfig = element.noInlineConfig;\n            config.configNameOfNoInlineConfig = element.name;\n        }\n\n        // Adopt the reportUnusedDisableDirectives which was found at first.\n        if (config.reportUnusedDisableDirectives === void 0 && element.reportUnusedDisableDirectives !== void 0) {\n            config.reportUnusedDisableDirectives = element.reportUnusedDisableDirectives;\n        }\n\n        // Collect ignorePatterns\n        if (element.ignorePattern) {\n            ignorePatterns.push(element.ignorePattern);\n        }\n\n        // Merge others.\n        mergeWithoutOverwrite(config.env, element.env);\n        mergeWithoutOverwrite(config.globals, element.globals);\n        mergeWithoutOverwrite(config.parserOptions, element.parserOptions);\n        mergeWithoutOverwrite(config.settings, element.settings);\n        mergePlugins(config.plugins, element.plugins);\n        mergeRuleConfigs(config.rules, element.rules);\n    }\n\n    // Create the predicate function for ignore patterns.\n    if (ignorePatterns.length > 0) {\n        config.ignores = IgnorePattern$2.createIgnore(ignorePatterns.reverse());\n    }\n\n    return config;\n}\n\n/**\n * Collect definitions.\n * @template T, U\n * @param {string} pluginId The plugin ID for prefix.\n * @param {Record<string,T>} defs The definitions to collect.\n * @param {Map<string, U>} map The map to output.\n * @param {function(T): U} [normalize] The normalize function for each value.\n * @returns {void}\n */\nfunction collect(pluginId, defs, map, normalize) {\n    if (defs) {\n        const prefix = pluginId && `${pluginId}/`;\n\n        for (const [key, value] of Object.entries(defs)) {\n            map.set(\n                `${prefix}${key}`,\n                normalize ? normalize(value) : value\n            );\n        }\n    }\n}\n\n/**\n * Normalize a rule definition.\n * @param {Function|Rule} rule The rule definition to normalize.\n * @returns {Rule} The normalized rule definition.\n */\nfunction normalizePluginRule(rule) {\n    return typeof rule === \"function\" ? { create: rule } : rule;\n}\n\n/**\n * Delete the mutation methods from a given map.\n * @param {Map<any, any>} map The map object to delete.\n * @returns {void}\n */\nfunction deleteMutationMethods(map) {\n    Object.defineProperties(map, {\n        clear: { configurable: true, value: void 0 },\n        delete: { configurable: true, value: void 0 },\n        set: { configurable: true, value: void 0 }\n    });\n}\n\n/**\n * Create `envMap`, `processorMap`, `ruleMap` with the plugins in the config array.\n * @param {ConfigArrayElement[]} elements The config elements.\n * @param {ConfigArrayInternalSlots} slots The internal slots.\n * @returns {void}\n */\nfunction initPluginMemberMaps(elements, slots) {\n    const processed = new Set();\n\n    slots.envMap = new Map();\n    slots.processorMap = new Map();\n    slots.ruleMap = new Map();\n\n    for (const element of elements) {\n        if (!element.plugins) {\n            continue;\n        }\n\n        for (const [pluginId, value] of Object.entries(element.plugins)) {\n            const plugin = value.definition;\n\n            if (!plugin || processed.has(pluginId)) {\n                continue;\n            }\n            processed.add(pluginId);\n\n            collect(pluginId, plugin.environments, slots.envMap);\n            collect(pluginId, plugin.processors, slots.processorMap);\n            collect(pluginId, plugin.rules, slots.ruleMap, normalizePluginRule);\n        }\n    }\n\n    deleteMutationMethods(slots.envMap);\n    deleteMutationMethods(slots.processorMap);\n    deleteMutationMethods(slots.ruleMap);\n}\n\n/**\n * Create `envMap`, `processorMap`, `ruleMap` with the plugins in the config array.\n * @param {ConfigArray} instance The config elements.\n * @returns {ConfigArrayInternalSlots} The extracted config.\n */\nfunction ensurePluginMemberMaps(instance) {\n    const slots = internalSlotsMap$1.get(instance);\n\n    if (!slots.ruleMap) {\n        initPluginMemberMaps(instance, slots);\n    }\n\n    return slots;\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * The Config Array.\n *\n * `ConfigArray` instance contains all settings, parsers, and plugins.\n * You need to call `ConfigArray#extractConfig(filePath)` method in order to\n * extract, merge and get only the config data which is related to an arbitrary\n * file.\n * @extends {Array<ConfigArrayElement>}\n */\nclass ConfigArray extends Array {\n\n    /**\n     * Get the plugin environments.\n     * The returned map cannot be mutated.\n     * @type {ReadonlyMap<string, Environment>} The plugin environments.\n     */\n    get pluginEnvironments() {\n        return ensurePluginMemberMaps(this).envMap;\n    }\n\n    /**\n     * Get the plugin processors.\n     * The returned map cannot be mutated.\n     * @type {ReadonlyMap<string, Processor>} The plugin processors.\n     */\n    get pluginProcessors() {\n        return ensurePluginMemberMaps(this).processorMap;\n    }\n\n    /**\n     * Get the plugin rules.\n     * The returned map cannot be mutated.\n     * @returns {ReadonlyMap<string, Rule>} The plugin rules.\n     */\n    get pluginRules() {\n        return ensurePluginMemberMaps(this).ruleMap;\n    }\n\n    /**\n     * Check if this config has `root` flag.\n     * @returns {boolean} `true` if this config array is root.\n     */\n    isRoot() {\n        for (let i = this.length - 1; i >= 0; --i) {\n            const root = this[i].root;\n\n            if (typeof root === \"boolean\") {\n                return root;\n            }\n        }\n        return false;\n    }\n\n    /**\n     * Extract the config data which is related to a given file.\n     * @param {string} filePath The absolute path to the target file.\n     * @returns {ExtractedConfig} The extracted config data.\n     */\n    extractConfig(filePath) {\n        const { cache } = internalSlotsMap$1.get(this);\n        const indices = getMatchedIndices(this, filePath);\n        const cacheKey = indices.join(\",\");\n\n        if (!cache.has(cacheKey)) {\n            cache.set(cacheKey, createConfig(this, indices));\n        }\n\n        return cache.get(cacheKey);\n    }\n}\n\nconst exportObject = {\n    ConfigArray,\n\n    /**\n     * Get the used extracted configs.\n     * CLIEngine will use this method to collect used deprecated rules.\n     * @param {ConfigArray} instance The config array object to get.\n     * @returns {ExtractedConfig[]} The used extracted configs.\n     * @private\n     */\n    getUsedExtractedConfigs(instance) {\n        const { cache } = internalSlotsMap$1.get(instance);\n\n        return Array.from(cache.values());\n    }\n};\n\nvar configArray = exportObject;\n\n/**\n * The class is to store parsers or plugins.\n * This class hides the loaded object from `JSON.stringify()` and `console.log`.\n * @template T\n */\nclass ConfigDependency {\n\n    /**\n     * Initialize this instance.\n     * @param {Object} data The dependency data.\n     * @param {T} [data.definition] The dependency if the loading succeeded.\n     * @param {Error} [data.error] The error object if the loading failed.\n     * @param {string} [data.filePath] The actual path to the dependency if the loading succeeded.\n     * @param {string} data.id The ID of this dependency.\n     * @param {string} data.importerName The name of the config file which loads this dependency.\n     * @param {string} data.importerPath The path to the config file which loads this dependency.\n     */\n    constructor({\n        definition = null,\n        error = null,\n        filePath = null,\n        id,\n        importerName,\n        importerPath\n    }) {\n\n        /**\n         * The loaded dependency if the loading succeeded.\n         * @type {T|null}\n         */\n        this.definition = definition;\n\n        /**\n         * The error object if the loading failed.\n         * @type {Error|null}\n         */\n        this.error = error;\n\n        /**\n         * The loaded dependency if the loading succeeded.\n         * @type {string|null}\n         */\n        this.filePath = filePath;\n\n        /**\n         * The ID of this dependency.\n         * @type {string}\n         */\n        this.id = id;\n\n        /**\n         * The name of the config file which loads this dependency.\n         * @type {string}\n         */\n        this.importerName = importerName;\n\n        /**\n         * The path to the config file which loads this dependency.\n         * @type {string}\n         */\n        this.importerPath = importerPath;\n    }\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @returns {Object} a JSON compatible object.\n     */\n    toJSON() {\n        const obj = this[util$2.inspect.custom]();\n\n        // Display `error.message` (`Error#message` is unenumerable).\n        if (obj.error instanceof Error) {\n            obj.error = { ...obj.error, message: obj.error.message };\n        }\n\n        return obj;\n    }\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @returns {Object} an object to display by `console.log()`.\n     */\n    [util$2.inspect.custom]() {\n        const {\n            definition: _ignore, // eslint-disable-line no-unused-vars\n            ...obj\n        } = this;\n\n        return obj;\n    }\n}\n\n/** @typedef {ConfigDependency<import(\"../../shared/types\").Parser>} DependentParser */\n/** @typedef {ConfigDependency<import(\"../../shared/types\").Plugin>} DependentPlugin */\n\nvar configDependency = { ConfigDependency };\n\nvar concatMap$1 = function (xs, fn) {\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        var x = fn(xs[i], i);\n        if (isArray$1(x)) res.push.apply(res, x);\n        else res.push(x);\n    }\n    return res;\n};\n\nvar isArray$1 = Array.isArray || function (xs) {\n    return Object.prototype.toString.call(xs) === '[object Array]';\n};\n\nvar balancedMatch = balanced;\nfunction balanced(a, b, str) {\n  if (a instanceof RegExp) a = maybeMatch(a, str);\n  if (b instanceof RegExp) b = maybeMatch(b, str);\n\n  var r = range(a, b, str);\n\n  return r && {\n    start: r[0],\n    end: r[1],\n    pre: str.slice(0, r[0]),\n    body: str.slice(r[0] + a.length, r[1]),\n    post: str.slice(r[1] + b.length)\n  };\n}\n\nfunction maybeMatch(reg, str) {\n  var m = str.match(reg);\n  return m ? m[0] : null;\n}\n\nbalanced.range = range;\nfunction range(a, b, str) {\n  var begs, beg, left, right, result;\n  var ai = str.indexOf(a);\n  var bi = str.indexOf(b, ai + 1);\n  var i = ai;\n\n  if (ai >= 0 && bi > 0) {\n    begs = [];\n    left = str.length;\n\n    while (i >= 0 && !result) {\n      if (i == ai) {\n        begs.push(i);\n        ai = str.indexOf(a, i + 1);\n      } else if (begs.length == 1) {\n        result = [ begs.pop(), bi ];\n      } else {\n        beg = begs.pop();\n        if (beg < left) {\n          left = beg;\n          right = bi;\n        }\n\n        bi = str.indexOf(b, i + 1);\n      }\n\n      i = ai < bi && ai >= 0 ? ai : bi;\n    }\n\n    if (begs.length) {\n      result = [ left, right ];\n    }\n  }\n\n  return result;\n}\n\nvar braceExpansion = expandTop;\n\nvar escSlash = '\\0SLASH'+Math.random()+'\\0';\nvar escOpen = '\\0OPEN'+Math.random()+'\\0';\nvar escClose = '\\0CLOSE'+Math.random()+'\\0';\nvar escComma = '\\0COMMA'+Math.random()+'\\0';\nvar escPeriod = '\\0PERIOD'+Math.random()+'\\0';\n\nfunction numeric(str) {\n  return parseInt(str, 10) == str\n    ? parseInt(str, 10)\n    : str.charCodeAt(0);\n}\n\nfunction escapeBraces(str) {\n  return str.split('\\\\\\\\').join(escSlash)\n            .split('\\\\{').join(escOpen)\n            .split('\\\\}').join(escClose)\n            .split('\\\\,').join(escComma)\n            .split('\\\\.').join(escPeriod);\n}\n\nfunction unescapeBraces(str) {\n  return str.split(escSlash).join('\\\\')\n            .split(escOpen).join('{')\n            .split(escClose).join('}')\n            .split(escComma).join(',')\n            .split(escPeriod).join('.');\n}\n\n\n// Basically just str.split(\",\"), but handling cases\n// where we have nested braced sections, which should be\n// treated as individual members, like {a,{b,c},d}\nfunction parseCommaParts(str) {\n  if (!str)\n    return [''];\n\n  var parts = [];\n  var m = balancedMatch('{', '}', str);\n\n  if (!m)\n    return str.split(',');\n\n  var pre = m.pre;\n  var body = m.body;\n  var post = m.post;\n  var p = pre.split(',');\n\n  p[p.length-1] += '{' + body + '}';\n  var postParts = parseCommaParts(post);\n  if (post.length) {\n    p[p.length-1] += postParts.shift();\n    p.push.apply(p, postParts);\n  }\n\n  parts.push.apply(parts, p);\n\n  return parts;\n}\n\nfunction expandTop(str) {\n  if (!str)\n    return [];\n\n  // I don't know why Bash 4.3 does this, but it does.\n  // Anything starting with {} will have the first two bytes preserved\n  // but *only* at the top level, so {},a}b will not expand to anything,\n  // but a{},b}c will be expanded to [a}c,abc].\n  // One could argue that this is a bug in Bash, but since the goal of\n  // this module is to match Bash's rules, we escape a leading {}\n  if (str.substr(0, 2) === '{}') {\n    str = '\\\\{\\\\}' + str.substr(2);\n  }\n\n  return expand(escapeBraces(str), true).map(unescapeBraces);\n}\n\nfunction embrace(str) {\n  return '{' + str + '}';\n}\nfunction isPadded(el) {\n  return /^-?0\\d/.test(el);\n}\n\nfunction lte(i, y) {\n  return i <= y;\n}\nfunction gte(i, y) {\n  return i >= y;\n}\n\nfunction expand(str, isTop) {\n  var expansions = [];\n\n  var m = balancedMatch('{', '}', str);\n  if (!m || /\\$$/.test(m.pre)) return [str];\n\n  var isNumericSequence = /^-?\\d+\\.\\.-?\\d+(?:\\.\\.-?\\d+)?$/.test(m.body);\n  var isAlphaSequence = /^[a-zA-Z]\\.\\.[a-zA-Z](?:\\.\\.-?\\d+)?$/.test(m.body);\n  var isSequence = isNumericSequence || isAlphaSequence;\n  var isOptions = m.body.indexOf(',') >= 0;\n  if (!isSequence && !isOptions) {\n    // {a},b}\n    if (m.post.match(/,.*\\}/)) {\n      str = m.pre + '{' + m.body + escClose + m.post;\n      return expand(str);\n    }\n    return [str];\n  }\n\n  var n;\n  if (isSequence) {\n    n = m.body.split(/\\.\\./);\n  } else {\n    n = parseCommaParts(m.body);\n    if (n.length === 1) {\n      // x{{a,b}}y ==> x{a}y x{b}y\n      n = expand(n[0], false).map(embrace);\n      if (n.length === 1) {\n        var post = m.post.length\n          ? expand(m.post, false)\n          : [''];\n        return post.map(function(p) {\n          return m.pre + n[0] + p;\n        });\n      }\n    }\n  }\n\n  // at this point, n is the parts, and we know it's not a comma set\n  // with a single entry.\n\n  // no need to expand pre, since it is guaranteed to be free of brace-sets\n  var pre = m.pre;\n  var post = m.post.length\n    ? expand(m.post, false)\n    : [''];\n\n  var N;\n\n  if (isSequence) {\n    var x = numeric(n[0]);\n    var y = numeric(n[1]);\n    var width = Math.max(n[0].length, n[1].length);\n    var incr = n.length == 3\n      ? Math.abs(numeric(n[2]))\n      : 1;\n    var test = lte;\n    var reverse = y < x;\n    if (reverse) {\n      incr *= -1;\n      test = gte;\n    }\n    var pad = n.some(isPadded);\n\n    N = [];\n\n    for (var i = x; test(i, y); i += incr) {\n      var c;\n      if (isAlphaSequence) {\n        c = String.fromCharCode(i);\n        if (c === '\\\\')\n          c = '';\n      } else {\n        c = String(i);\n        if (pad) {\n          var need = width - c.length;\n          if (need > 0) {\n            var z = new Array(need + 1).join('0');\n            if (i < 0)\n              c = '-' + z + c.slice(1);\n            else\n              c = z + c;\n          }\n        }\n      }\n      N.push(c);\n    }\n  } else {\n    N = concatMap$1(n, function(el) { return expand(el, false) });\n  }\n\n  for (var j = 0; j < N.length; j++) {\n    for (var k = 0; k < post.length; k++) {\n      var expansion = pre + N[j] + post[k];\n      if (!isTop || isSequence || expansion)\n        expansions.push(expansion);\n    }\n  }\n\n  return expansions;\n}\n\nvar minimatch_1 = minimatch;\nminimatch.Minimatch = Minimatch;\n\nvar path = { sep: '/' };\ntry {\n  path = path$1;\n} catch (er) {}\n\nvar GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};\n\n\nvar plTypes = {\n  '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},\n  '?': { open: '(?:', close: ')?' },\n  '+': { open: '(?:', close: ')+' },\n  '*': { open: '(?:', close: ')*' },\n  '@': { open: '(?:', close: ')' }\n};\n\n// any single thing other than /\n// don't need to escape / when using new RegExp()\nvar qmark = '[^/]';\n\n// * => any number of characters\nvar star = qmark + '*?';\n\n// ** when dots are allowed.  Anything goes, except .. and .\n// not (^ or / followed by one or two dots followed by $ or /),\n// followed by anything, any number of times.\nvar twoStarDot = '(?:(?!(?:\\\\\\/|^)(?:\\\\.{1,2})($|\\\\\\/)).)*?';\n\n// not a ^ or / followed by a dot,\n// followed by anything, any number of times.\nvar twoStarNoDot = '(?:(?!(?:\\\\\\/|^)\\\\.).)*?';\n\n// characters that need to be escaped in RegExp.\nvar reSpecials = charSet('().*{}+?[]^$\\\\!');\n\n// \"abc\" -> { a:true, b:true, c:true }\nfunction charSet (s) {\n  return s.split('').reduce(function (set, c) {\n    set[c] = true;\n    return set\n  }, {})\n}\n\n// normalizes slashes.\nvar slashSplit = /\\/+/;\n\nminimatch.filter = filter$2;\nfunction filter$2 (pattern, options) {\n  options = options || {};\n  return function (p, i, list) {\n    return minimatch(p, pattern, options)\n  }\n}\n\nfunction ext (a, b) {\n  a = a || {};\n  b = b || {};\n  var t = {};\n  Object.keys(b).forEach(function (k) {\n    t[k] = b[k];\n  });\n  Object.keys(a).forEach(function (k) {\n    t[k] = a[k];\n  });\n  return t\n}\n\nminimatch.defaults = function (def) {\n  if (!def || !Object.keys(def).length) return minimatch\n\n  var orig = minimatch;\n\n  var m = function minimatch (p, pattern, options) {\n    return orig.minimatch(p, pattern, ext(def, options))\n  };\n\n  m.Minimatch = function Minimatch (pattern, options) {\n    return new orig.Minimatch(pattern, ext(def, options))\n  };\n\n  return m\n};\n\nMinimatch.defaults = function (def) {\n  if (!def || !Object.keys(def).length) return Minimatch\n  return minimatch.defaults(def).Minimatch\n};\n\nfunction minimatch (p, pattern, options) {\n  if (typeof pattern !== 'string') {\n    throw new TypeError('glob pattern string required')\n  }\n\n  if (!options) options = {};\n\n  // shortcut: comments match nothing.\n  if (!options.nocomment && pattern.charAt(0) === '#') {\n    return false\n  }\n\n  // \"\" only matches \"\"\n  if (pattern.trim() === '') return p === ''\n\n  return new Minimatch(pattern, options).match(p)\n}\n\nfunction Minimatch (pattern, options) {\n  if (!(this instanceof Minimatch)) {\n    return new Minimatch(pattern, options)\n  }\n\n  if (typeof pattern !== 'string') {\n    throw new TypeError('glob pattern string required')\n  }\n\n  if (!options) options = {};\n  pattern = pattern.trim();\n\n  // windows support: need to use /, not \\\n  if (path.sep !== '/') {\n    pattern = pattern.split(path.sep).join('/');\n  }\n\n  this.options = options;\n  this.set = [];\n  this.pattern = pattern;\n  this.regexp = null;\n  this.negate = false;\n  this.comment = false;\n  this.empty = false;\n\n  // make the set of regexps etc.\n  this.make();\n}\n\nMinimatch.prototype.debug = function () {};\n\nMinimatch.prototype.make = make;\nfunction make () {\n  // don't do it more than once.\n  if (this._made) return\n\n  var pattern = this.pattern;\n  var options = this.options;\n\n  // empty patterns and comments match nothing.\n  if (!options.nocomment && pattern.charAt(0) === '#') {\n    this.comment = true;\n    return\n  }\n  if (!pattern) {\n    this.empty = true;\n    return\n  }\n\n  // step 1: figure out negation, etc.\n  this.parseNegate();\n\n  // step 2: expand braces\n  var set = this.globSet = this.braceExpand();\n\n  if (options.debug) this.debug = console.error;\n\n  this.debug(this.pattern, set);\n\n  // step 3: now we have a set, so turn each one into a series of path-portion\n  // matching patterns.\n  // These will be regexps, except in the case of \"**\", which is\n  // set to the GLOBSTAR object for globstar behavior,\n  // and will not contain any / characters\n  set = this.globParts = set.map(function (s) {\n    return s.split(slashSplit)\n  });\n\n  this.debug(this.pattern, set);\n\n  // glob --> regexps\n  set = set.map(function (s, si, set) {\n    return s.map(this.parse, this)\n  }, this);\n\n  this.debug(this.pattern, set);\n\n  // filter out everything that didn't compile properly.\n  set = set.filter(function (s) {\n    return s.indexOf(false) === -1\n  });\n\n  this.debug(this.pattern, set);\n\n  this.set = set;\n}\n\nMinimatch.prototype.parseNegate = parseNegate;\nfunction parseNegate () {\n  var pattern = this.pattern;\n  var negate = false;\n  var options = this.options;\n  var negateOffset = 0;\n\n  if (options.nonegate) return\n\n  for (var i = 0, l = pattern.length\n    ; i < l && pattern.charAt(i) === '!'\n    ; i++) {\n    negate = !negate;\n    negateOffset++;\n  }\n\n  if (negateOffset) this.pattern = pattern.substr(negateOffset);\n  this.negate = negate;\n}\n\n// Brace expansion:\n// a{b,c}d -> abd acd\n// a{b,}c -> abc ac\n// a{0..3}d -> a0d a1d a2d a3d\n// a{b,c{d,e}f}g -> abg acdfg acefg\n// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg\n//\n// Invalid sets are not expanded.\n// a{2..}b -> a{2..}b\n// a{b}c -> a{b}c\nminimatch.braceExpand = function (pattern, options) {\n  return braceExpand(pattern, options)\n};\n\nMinimatch.prototype.braceExpand = braceExpand;\n\nfunction braceExpand (pattern, options) {\n  if (!options) {\n    if (this instanceof Minimatch) {\n      options = this.options;\n    } else {\n      options = {};\n    }\n  }\n\n  pattern = typeof pattern === 'undefined'\n    ? this.pattern : pattern;\n\n  if (typeof pattern === 'undefined') {\n    throw new TypeError('undefined pattern')\n  }\n\n  if (options.nobrace ||\n    !pattern.match(/\\{.*\\}/)) {\n    // shortcut. no need to expand.\n    return [pattern]\n  }\n\n  return braceExpansion(pattern)\n}\n\n// parse a component of the expanded set.\n// At this point, no pattern may contain \"/\" in it\n// so we're going to return a 2d array, where each entry is the full\n// pattern, split on '/', and then turned into a regular expression.\n// A regexp is made at the end which joins each array with an\n// escaped /, and another full one which joins each regexp with |.\n//\n// Following the lead of Bash 4.1, note that \"**\" only has special meaning\n// when it is the *only* thing in a path portion.  Otherwise, any series\n// of * is equivalent to a single *.  Globstar behavior is enabled by\n// default, and can be disabled by setting options.noglobstar.\nMinimatch.prototype.parse = parse$5;\nvar SUBPARSE = {};\nfunction parse$5 (pattern, isSub) {\n  if (pattern.length > 1024 * 64) {\n    throw new TypeError('pattern is too long')\n  }\n\n  var options = this.options;\n\n  // shortcuts\n  if (!options.noglobstar && pattern === '**') return GLOBSTAR\n  if (pattern === '') return ''\n\n  var re = '';\n  var hasMagic = !!options.nocase;\n  var escaping = false;\n  // ? => one single character\n  var patternListStack = [];\n  var negativeLists = [];\n  var stateChar;\n  var inClass = false;\n  var reClassStart = -1;\n  var classStart = -1;\n  // . and .. never match anything that doesn't start with .,\n  // even when options.dot is set.\n  var patternStart = pattern.charAt(0) === '.' ? '' // anything\n  // not (start or / followed by . or .. followed by / or end)\n  : options.dot ? '(?!(?:^|\\\\\\/)\\\\.{1,2}(?:$|\\\\\\/))'\n  : '(?!\\\\.)';\n  var self = this;\n\n  function clearStateChar () {\n    if (stateChar) {\n      // we had some state-tracking character\n      // that wasn't consumed by this pass.\n      switch (stateChar) {\n        case '*':\n          re += star;\n          hasMagic = true;\n        break\n        case '?':\n          re += qmark;\n          hasMagic = true;\n        break\n        default:\n          re += '\\\\' + stateChar;\n        break\n      }\n      self.debug('clearStateChar %j %j', stateChar, re);\n      stateChar = false;\n    }\n  }\n\n  for (var i = 0, len = pattern.length, c\n    ; (i < len) && (c = pattern.charAt(i))\n    ; i++) {\n    this.debug('%s\\t%s %s %j', pattern, i, re, c);\n\n    // skip over any that are escaped.\n    if (escaping && reSpecials[c]) {\n      re += '\\\\' + c;\n      escaping = false;\n      continue\n    }\n\n    switch (c) {\n      case '/':\n        // completely not allowed, even escaped.\n        // Should already be path-split by now.\n        return false\n\n      case '\\\\':\n        clearStateChar();\n        escaping = true;\n      continue\n\n      // the various stateChar values\n      // for the \"extglob\" stuff.\n      case '?':\n      case '*':\n      case '+':\n      case '@':\n      case '!':\n        this.debug('%s\\t%s %s %j <-- stateChar', pattern, i, re, c);\n\n        // all of those are literals inside a class, except that\n        // the glob [!a] means [^a] in regexp\n        if (inClass) {\n          this.debug('  in class');\n          if (c === '!' && i === classStart + 1) c = '^';\n          re += c;\n          continue\n        }\n\n        // if we already have a stateChar, then it means\n        // that there was something like ** or +? in there.\n        // Handle the stateChar, then proceed with this one.\n        self.debug('call clearStateChar %j', stateChar);\n        clearStateChar();\n        stateChar = c;\n        // if extglob is disabled, then +(asdf|foo) isn't a thing.\n        // just clear the statechar *now*, rather than even diving into\n        // the patternList stuff.\n        if (options.noext) clearStateChar();\n      continue\n\n      case '(':\n        if (inClass) {\n          re += '(';\n          continue\n        }\n\n        if (!stateChar) {\n          re += '\\\\(';\n          continue\n        }\n\n        patternListStack.push({\n          type: stateChar,\n          start: i - 1,\n          reStart: re.length,\n          open: plTypes[stateChar].open,\n          close: plTypes[stateChar].close\n        });\n        // negation is (?:(?!js)[^/]*)\n        re += stateChar === '!' ? '(?:(?!(?:' : '(?:';\n        this.debug('plType %j %j', stateChar, re);\n        stateChar = false;\n      continue\n\n      case ')':\n        if (inClass || !patternListStack.length) {\n          re += '\\\\)';\n          continue\n        }\n\n        clearStateChar();\n        hasMagic = true;\n        var pl = patternListStack.pop();\n        // negation is (?:(?!js)[^/]*)\n        // The others are (?:<pattern>)<type>\n        re += pl.close;\n        if (pl.type === '!') {\n          negativeLists.push(pl);\n        }\n        pl.reEnd = re.length;\n      continue\n\n      case '|':\n        if (inClass || !patternListStack.length || escaping) {\n          re += '\\\\|';\n          escaping = false;\n          continue\n        }\n\n        clearStateChar();\n        re += '|';\n      continue\n\n      // these are mostly the same in regexp and glob\n      case '[':\n        // swallow any state-tracking char before the [\n        clearStateChar();\n\n        if (inClass) {\n          re += '\\\\' + c;\n          continue\n        }\n\n        inClass = true;\n        classStart = i;\n        reClassStart = re.length;\n        re += c;\n      continue\n\n      case ']':\n        //  a right bracket shall lose its special\n        //  meaning and represent itself in\n        //  a bracket expression if it occurs\n        //  first in the list.  -- POSIX.2 2.8.3.2\n        if (i === classStart + 1 || !inClass) {\n          re += '\\\\' + c;\n          escaping = false;\n          continue\n        }\n\n        // handle the case where we left a class open.\n        // \"[z-a]\" is valid, equivalent to \"\\[z-a\\]\"\n        if (inClass) {\n          // split where the last [ was, make sure we don't have\n          // an invalid re. if so, re-walk the contents of the\n          // would-be class to re-translate any characters that\n          // were passed through as-is\n          // TODO: It would probably be faster to determine this\n          // without a try/catch and a new RegExp, but it's tricky\n          // to do safely.  For now, this is safe and works.\n          var cs = pattern.substring(classStart + 1, i);\n          try {\n            RegExp('[' + cs + ']');\n          } catch (er) {\n            // not a valid class!\n            var sp = this.parse(cs, SUBPARSE);\n            re = re.substr(0, reClassStart) + '\\\\[' + sp[0] + '\\\\]';\n            hasMagic = hasMagic || sp[1];\n            inClass = false;\n            continue\n          }\n        }\n\n        // finish up the class.\n        hasMagic = true;\n        inClass = false;\n        re += c;\n      continue\n\n      default:\n        // swallow any state char that wasn't consumed\n        clearStateChar();\n\n        if (escaping) {\n          // no need\n          escaping = false;\n        } else if (reSpecials[c]\n          && !(c === '^' && inClass)) {\n          re += '\\\\';\n        }\n\n        re += c;\n\n    } // switch\n  } // for\n\n  // handle the case where we left a class open.\n  // \"[abc\" is valid, equivalent to \"\\[abc\"\n  if (inClass) {\n    // split where the last [ was, and escape it\n    // this is a huge pita.  We now have to re-walk\n    // the contents of the would-be class to re-translate\n    // any characters that were passed through as-is\n    cs = pattern.substr(classStart + 1);\n    sp = this.parse(cs, SUBPARSE);\n    re = re.substr(0, reClassStart) + '\\\\[' + sp[0];\n    hasMagic = hasMagic || sp[1];\n  }\n\n  // handle the case where we had a +( thing at the *end*\n  // of the pattern.\n  // each pattern list stack adds 3 chars, and we need to go through\n  // and escape any | chars that were passed through as-is for the regexp.\n  // Go through and escape them, taking care not to double-escape any\n  // | chars that were already escaped.\n  for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {\n    var tail = re.slice(pl.reStart + pl.open.length);\n    this.debug('setting tail', re, pl);\n    // maybe some even number of \\, then maybe 1 \\, followed by a |\n    tail = tail.replace(/((?:\\\\{2}){0,64})(\\\\?)\\|/g, function (_, $1, $2) {\n      if (!$2) {\n        // the | isn't already escaped, so escape it.\n        $2 = '\\\\';\n      }\n\n      // need to escape all those slashes *again*, without escaping the\n      // one that we need for escaping the | character.  As it works out,\n      // escaping an even number of slashes can be done by simply repeating\n      // it exactly after itself.  That's why this trick works.\n      //\n      // I am sorry that you have to see this.\n      return $1 + $1 + $2 + '|'\n    });\n\n    this.debug('tail=%j\\n   %s', tail, tail, pl, re);\n    var t = pl.type === '*' ? star\n      : pl.type === '?' ? qmark\n      : '\\\\' + pl.type;\n\n    hasMagic = true;\n    re = re.slice(0, pl.reStart) + t + '\\\\(' + tail;\n  }\n\n  // handle trailing things that only matter at the very end.\n  clearStateChar();\n  if (escaping) {\n    // trailing \\\\\n    re += '\\\\\\\\';\n  }\n\n  // only need to apply the nodot start if the re starts with\n  // something that could conceivably capture a dot\n  var addPatternStart = false;\n  switch (re.charAt(0)) {\n    case '.':\n    case '[':\n    case '(': addPatternStart = true;\n  }\n\n  // Hack to work around lack of negative lookbehind in JS\n  // A pattern like: *.!(x).!(y|z) needs to ensure that a name\n  // like 'a.xyz.yz' doesn't match.  So, the first negative\n  // lookahead, has to look ALL the way ahead, to the end of\n  // the pattern.\n  for (var n = negativeLists.length - 1; n > -1; n--) {\n    var nl = negativeLists[n];\n\n    var nlBefore = re.slice(0, nl.reStart);\n    var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);\n    var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);\n    var nlAfter = re.slice(nl.reEnd);\n\n    nlLast += nlAfter;\n\n    // Handle nested stuff like *(*.js|!(*.json)), where open parens\n    // mean that we should *not* include the ) in the bit that is considered\n    // \"after\" the negated section.\n    var openParensBefore = nlBefore.split('(').length - 1;\n    var cleanAfter = nlAfter;\n    for (i = 0; i < openParensBefore; i++) {\n      cleanAfter = cleanAfter.replace(/\\)[+*?]?/, '');\n    }\n    nlAfter = cleanAfter;\n\n    var dollar = '';\n    if (nlAfter === '' && isSub !== SUBPARSE) {\n      dollar = '$';\n    }\n    var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast;\n    re = newRe;\n  }\n\n  // if the re is not \"\" at this point, then we need to make sure\n  // it doesn't match against an empty path part.\n  // Otherwise a/* will match a/, which it should not.\n  if (re !== '' && hasMagic) {\n    re = '(?=.)' + re;\n  }\n\n  if (addPatternStart) {\n    re = patternStart + re;\n  }\n\n  // parsing just a piece of a larger pattern.\n  if (isSub === SUBPARSE) {\n    return [re, hasMagic]\n  }\n\n  // skip the regexp for non-magical patterns\n  // unescape anything in it, though, so that it'll be\n  // an exact match against a file etc.\n  if (!hasMagic) {\n    return globUnescape(pattern)\n  }\n\n  var flags = options.nocase ? 'i' : '';\n  try {\n    var regExp = new RegExp('^' + re + '$', flags);\n  } catch (er) {\n    // If it was an invalid regular expression, then it can't match\n    // anything.  This trick looks for a character after the end of\n    // the string, which is of course impossible, except in multi-line\n    // mode, but it's not a /m regex.\n    return new RegExp('$.')\n  }\n\n  regExp._glob = pattern;\n  regExp._src = re;\n\n  return regExp\n}\n\nminimatch.makeRe = function (pattern, options) {\n  return new Minimatch(pattern, options || {}).makeRe()\n};\n\nMinimatch.prototype.makeRe = makeRe;\nfunction makeRe () {\n  if (this.regexp || this.regexp === false) return this.regexp\n\n  // at this point, this.set is a 2d array of partial\n  // pattern strings, or \"**\".\n  //\n  // It's better to use .match().  This function shouldn't\n  // be used, really, but it's pretty convenient sometimes,\n  // when you just want to work with a regex.\n  var set = this.set;\n\n  if (!set.length) {\n    this.regexp = false;\n    return this.regexp\n  }\n  var options = this.options;\n\n  var twoStar = options.noglobstar ? star\n    : options.dot ? twoStarDot\n    : twoStarNoDot;\n  var flags = options.nocase ? 'i' : '';\n\n  var re = set.map(function (pattern) {\n    return pattern.map(function (p) {\n      return (p === GLOBSTAR) ? twoStar\n      : (typeof p === 'string') ? regExpEscape(p)\n      : p._src\n    }).join('\\\\\\/')\n  }).join('|');\n\n  // must match entire pattern\n  // ending in a * or ** will make it less strict.\n  re = '^(?:' + re + ')$';\n\n  // can match anything, as long as it's not this.\n  if (this.negate) re = '^(?!' + re + ').*$';\n\n  try {\n    this.regexp = new RegExp(re, flags);\n  } catch (ex) {\n    this.regexp = false;\n  }\n  return this.regexp\n}\n\nminimatch.match = function (list, pattern, options) {\n  options = options || {};\n  var mm = new Minimatch(pattern, options);\n  list = list.filter(function (f) {\n    return mm.match(f)\n  });\n  if (mm.options.nonull && !list.length) {\n    list.push(pattern);\n  }\n  return list\n};\n\nMinimatch.prototype.match = match;\nfunction match (f, partial) {\n  this.debug('match', f, this.pattern);\n  // short-circuit in the case of busted things.\n  // comments, etc.\n  if (this.comment) return false\n  if (this.empty) return f === ''\n\n  if (f === '/' && partial) return true\n\n  var options = this.options;\n\n  // windows: need to use /, not \\\n  if (path.sep !== '/') {\n    f = f.split(path.sep).join('/');\n  }\n\n  // treat the test path as a set of pathparts.\n  f = f.split(slashSplit);\n  this.debug(this.pattern, 'split', f);\n\n  // just ONE of the pattern sets in this.set needs to match\n  // in order for it to be valid.  If negating, then just one\n  // match means that we have failed.\n  // Either way, return on the first hit.\n\n  var set = this.set;\n  this.debug(this.pattern, 'set', set);\n\n  // Find the basename of the path by looking for the last non-empty segment\n  var filename;\n  var i;\n  for (i = f.length - 1; i >= 0; i--) {\n    filename = f[i];\n    if (filename) break\n  }\n\n  for (i = 0; i < set.length; i++) {\n    var pattern = set[i];\n    var file = f;\n    if (options.matchBase && pattern.length === 1) {\n      file = [filename];\n    }\n    var hit = this.matchOne(file, pattern, partial);\n    if (hit) {\n      if (options.flipNegate) return true\n      return !this.negate\n    }\n  }\n\n  // didn't get any hits.  this is success if it's a negative\n  // pattern, failure otherwise.\n  if (options.flipNegate) return false\n  return this.negate\n}\n\n// set partial to true to test if, for example,\n// \"/a/b\" matches the start of \"/*/b/*/d\"\n// Partial means, if you run out of file before you run\n// out of pattern, then that's fine, as long as all\n// the parts match.\nMinimatch.prototype.matchOne = function (file, pattern, partial) {\n  var options = this.options;\n\n  this.debug('matchOne',\n    { 'this': this, file: file, pattern: pattern });\n\n  this.debug('matchOne', file.length, pattern.length);\n\n  for (var fi = 0,\n      pi = 0,\n      fl = file.length,\n      pl = pattern.length\n      ; (fi < fl) && (pi < pl)\n      ; fi++, pi++) {\n    this.debug('matchOne loop');\n    var p = pattern[pi];\n    var f = file[fi];\n\n    this.debug(pattern, p, f);\n\n    // should be impossible.\n    // some invalid regexp stuff in the set.\n    if (p === false) return false\n\n    if (p === GLOBSTAR) {\n      this.debug('GLOBSTAR', [pattern, p, f]);\n\n      // \"**\"\n      // a/**/b/**/c would match the following:\n      // a/b/x/y/z/c\n      // a/x/y/z/b/c\n      // a/b/x/b/x/c\n      // a/b/c\n      // To do this, take the rest of the pattern after\n      // the **, and see if it would match the file remainder.\n      // If so, return success.\n      // If not, the ** \"swallows\" a segment, and try again.\n      // This is recursively awful.\n      //\n      // a/**/b/**/c matching a/b/x/y/z/c\n      // - a matches a\n      // - doublestar\n      //   - matchOne(b/x/y/z/c, b/**/c)\n      //     - b matches b\n      //     - doublestar\n      //       - matchOne(x/y/z/c, c) -> no\n      //       - matchOne(y/z/c, c) -> no\n      //       - matchOne(z/c, c) -> no\n      //       - matchOne(c, c) yes, hit\n      var fr = fi;\n      var pr = pi + 1;\n      if (pr === pl) {\n        this.debug('** at the end');\n        // a ** at the end will just swallow the rest.\n        // We have found a match.\n        // however, it will not swallow /.x, unless\n        // options.dot is set.\n        // . and .. are *never* matched by **, for explosively\n        // exponential reasons.\n        for (; fi < fl; fi++) {\n          if (file[fi] === '.' || file[fi] === '..' ||\n            (!options.dot && file[fi].charAt(0) === '.')) return false\n        }\n        return true\n      }\n\n      // ok, let's see if we can swallow whatever we can.\n      while (fr < fl) {\n        var swallowee = file[fr];\n\n        this.debug('\\nglobstar while', file, fr, pattern, pr, swallowee);\n\n        // XXX remove this slice.  Just pass the start index.\n        if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {\n          this.debug('globstar found match!', fr, fl, swallowee);\n          // found a match.\n          return true\n        } else {\n          // can't swallow \".\" or \"..\" ever.\n          // can only swallow \".foo\" when explicitly asked.\n          if (swallowee === '.' || swallowee === '..' ||\n            (!options.dot && swallowee.charAt(0) === '.')) {\n            this.debug('dot detected!', file, fr, pattern, pr);\n            break\n          }\n\n          // ** swallows a segment, and continue.\n          this.debug('globstar swallow a segment, and continue');\n          fr++;\n        }\n      }\n\n      // no match was found.\n      // However, in partial mode, we can't say this is necessarily over.\n      // If there's more *pattern* left, then\n      if (partial) {\n        // ran out of file\n        this.debug('\\n>>> no match, partial?', file, fr, pattern, pr);\n        if (fr === fl) return true\n      }\n      return false\n    }\n\n    // something other than **\n    // non-magic patterns just have to match exactly\n    // patterns with magic have been turned into regexps.\n    var hit;\n    if (typeof p === 'string') {\n      if (options.nocase) {\n        hit = f.toLowerCase() === p.toLowerCase();\n      } else {\n        hit = f === p;\n      }\n      this.debug('string match', p, f, hit);\n    } else {\n      hit = f.match(p);\n      this.debug('pattern match', p, f, hit);\n    }\n\n    if (!hit) return false\n  }\n\n  // Note: ending in / means that we'll get a final \"\"\n  // at the end of the pattern.  This can only match a\n  // corresponding \"\" at the end of the file.\n  // If the file ends in /, then it can only match a\n  // a pattern that ends in /, unless the pattern just\n  // doesn't have any more for it. But, a/b/ should *not*\n  // match \"a/b/*\", even though \"\" matches against the\n  // [^/]*? pattern, except in partial mode, where it might\n  // simply not be reached yet.\n  // However, a/b/ should still satisfy a/*\n\n  // now either we fell off the end of the pattern, or we're done.\n  if (fi === fl && pi === pl) {\n    // ran out of pattern and filename at the same time.\n    // an exact hit!\n    return true\n  } else if (fi === fl) {\n    // ran out of file, but still had pattern left.\n    // this is ok if we're doing the match as part of\n    // a glob fs traversal.\n    return partial\n  } else if (pi === pl) {\n    // ran out of pattern, still have file left.\n    // this is only acceptable if we're on the very last\n    // empty segment of a file with a trailing slash.\n    // a/* should match a/b/\n    var emptyFileEnd = (fi === fl - 1) && (file[fi] === '');\n    return emptyFileEnd\n  }\n\n  // should be unreachable.\n  throw new Error('wtf?')\n};\n\n// replace stuff like \\* with *\nfunction globUnescape (s) {\n  return s.replace(/\\\\(.)/g, '$1')\n}\n\nfunction regExpEscape (s) {\n  return s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&')\n}\n\nconst { Minimatch: Minimatch$1 } = minimatch_1;\nconst minimatchOpts = { dot: true, matchBase: true };\n\n/**\n * @typedef {Object} Pattern\n * @property {InstanceType<Minimatch>[] | null} includes The positive matchers.\n * @property {InstanceType<Minimatch>[] | null} excludes The negative matchers.\n */\n\n/**\n * Normalize a given pattern to an array.\n * @param {string|string[]|undefined} patterns A glob pattern or an array of glob patterns.\n * @returns {string[]|null} Normalized patterns.\n * @private\n */\nfunction normalizePatterns(patterns) {\n    if (Array.isArray(patterns)) {\n        return patterns.filter(Boolean);\n    }\n    if (typeof patterns === \"string\" && patterns) {\n        return [patterns];\n    }\n    return [];\n}\n\n/**\n * Create the matchers of given patterns.\n * @param {string[]} patterns The patterns.\n * @returns {InstanceType<Minimatch>[] | null} The matchers.\n */\nfunction toMatcher(patterns) {\n    if (patterns.length === 0) {\n        return null;\n    }\n    return patterns.map(pattern => {\n        if (/^\\.[/\\\\]/u.test(pattern)) {\n            return new Minimatch$1(\n                pattern.slice(2),\n\n                // `./*.js` should not match with `subdir/foo.js`\n                { ...minimatchOpts, matchBase: false }\n            );\n        }\n        return new Minimatch$1(pattern, minimatchOpts);\n    });\n}\n\n/**\n * Convert a given matcher to string.\n * @param {Pattern} matchers The matchers.\n * @returns {string} The string expression of the matcher.\n */\nfunction patternToJson({ includes, excludes }) {\n    return {\n        includes: includes && includes.map(m => m.pattern),\n        excludes: excludes && excludes.map(m => m.pattern)\n    };\n}\n\n/**\n * The class to test given paths are matched by the patterns.\n */\nclass OverrideTester {\n\n    /**\n     * Create a tester with given criteria.\n     * If there are no criteria, returns `null`.\n     * @param {string|string[]} files The glob patterns for included files.\n     * @param {string|string[]} excludedFiles The glob patterns for excluded files.\n     * @param {string} basePath The path to the base directory to test paths.\n     * @returns {OverrideTester|null} The created instance or `null`.\n     */\n    static create(files, excludedFiles, basePath) {\n        const includePatterns = normalizePatterns(files);\n        const excludePatterns = normalizePatterns(excludedFiles);\n        const allPatterns = includePatterns.concat(excludePatterns);\n\n        if (allPatterns.length === 0) {\n            return null;\n        }\n\n        // Rejects absolute paths or relative paths to parents.\n        for (const pattern of allPatterns) {\n            if (path$1.isAbsolute(pattern) || pattern.includes(\"..\")) {\n                throw new Error(`Invalid override pattern (expected relative path not containing '..'): ${pattern}`);\n            }\n        }\n\n        const includes = toMatcher(includePatterns);\n        const excludes = toMatcher(excludePatterns);\n\n        return new OverrideTester([{ includes, excludes }], basePath);\n    }\n\n    /**\n     * Combine two testers by logical and.\n     * If either of the testers was `null`, returns the other tester.\n     * The `basePath` property of the two must be the same value.\n     * @param {OverrideTester|null} a A tester.\n     * @param {OverrideTester|null} b Another tester.\n     * @returns {OverrideTester|null} Combined tester.\n     */\n    static and(a, b) {\n        if (!b) {\n            return a && new OverrideTester(a.patterns, a.basePath);\n        }\n        if (!a) {\n            return new OverrideTester(b.patterns, b.basePath);\n        }\n\n        assert.strictEqual(a.basePath, b.basePath);\n        return new OverrideTester(a.patterns.concat(b.patterns), a.basePath);\n    }\n\n    /**\n     * Initialize this instance.\n     * @param {Pattern[]} patterns The matchers.\n     * @param {string} basePath The base path.\n     */\n    constructor(patterns, basePath) {\n\n        /** @type {Pattern[]} */\n        this.patterns = patterns;\n\n        /** @type {string} */\n        this.basePath = basePath;\n    }\n\n    /**\n     * Test if a given path is matched or not.\n     * @param {string} filePath The absolute path to the target file.\n     * @returns {boolean} `true` if the path was matched.\n     */\n    test(filePath) {\n        if (typeof filePath !== \"string\" || !path$1.isAbsolute(filePath)) {\n            throw new Error(`'filePath' should be an absolute path, but got ${filePath}.`);\n        }\n        const relativePath = path$1.relative(this.basePath, filePath);\n\n        return this.patterns.every(({ includes, excludes }) => (\n            (!includes || includes.some(m => m.match(relativePath))) &&\n            (!excludes || !excludes.some(m => m.match(relativePath)))\n        ));\n    }\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @returns {Object} a JSON compatible object.\n     */\n    toJSON() {\n        if (this.patterns.length === 1) {\n            return {\n                ...patternToJson(this.patterns[0]),\n                basePath: this.basePath\n            };\n        }\n        return {\n            AND: this.patterns.map(patternToJson),\n            basePath: this.basePath\n        };\n    }\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @returns {Object} an object to display by `console.log()`.\n     */\n    [util$2.inspect.custom]() {\n        return this.toJSON();\n    }\n}\n\nvar overrideTester = { OverrideTester };\n\nconst { ConfigArray: ConfigArray$1, getUsedExtractedConfigs } = configArray;\nconst { ConfigDependency: ConfigDependency$1 } = configDependency;\nconst { ExtractedConfig: ExtractedConfig$2 } = extractedConfig;\nconst { IgnorePattern: IgnorePattern$3 } = ignorePattern;\nconst { OverrideTester: OverrideTester$1 } = overrideTester;\n\nvar configArray$1 = {\n    ConfigArray: ConfigArray$1,\n    ConfigDependency: ConfigDependency$1,\n    ExtractedConfig: ExtractedConfig$2,\n    IgnorePattern: IgnorePattern$3,\n    OverrideTester: OverrideTester$1,\n    getUsedExtractedConfigs\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n\nconst { validateConfigSchema: validateConfigSchema$1 } = configValidator;\n\n\nconst {\n    ConfigArray: ConfigArray$2,\n    ConfigDependency: ConfigDependency$2,\n    IgnorePattern: IgnorePattern$4,\n    OverrideTester: OverrideTester$2\n} = configArray$1;\nconst debug$7 = src(\"eslint:config-array-factory\");\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst eslintRecommendedPath = path$1.resolve(__dirname, \"../../conf/eslint-recommended.js\");\nconst eslintAllPath = path$1.resolve(__dirname, \"../../conf/eslint-all.js\");\nconst configFilenames = [\n    \".eslintrc.js\",\n    \".eslintrc.cjs\",\n    \".eslintrc.yaml\",\n    \".eslintrc.yml\",\n    \".eslintrc.json\",\n    \".eslintrc\",\n    \"package.json\"\n];\n\n// Define types for VSCode IntelliSense.\n/** @typedef {import(\"../shared/types\").ConfigData} ConfigData */\n/** @typedef {import(\"../shared/types\").OverrideConfigData} OverrideConfigData */\n/** @typedef {import(\"../shared/types\").Parser} Parser */\n/** @typedef {import(\"../shared/types\").Plugin} Plugin */\n/** @typedef {import(\"./config-array/config-dependency\").DependentParser} DependentParser */\n/** @typedef {import(\"./config-array/config-dependency\").DependentPlugin} DependentPlugin */\n/** @typedef {ConfigArray[0]} ConfigArrayElement */\n\n/**\n * @typedef {Object} ConfigArrayFactoryOptions\n * @property {Map<string,Plugin>} [additionalPluginPool] The map for additional plugins.\n * @property {string} [cwd] The path to the current working directory.\n * @property {string} [resolvePluginsRelativeTo] A path to the directory that plugins should be resolved from. Defaults to `cwd`.\n */\n\n/**\n * @typedef {Object} ConfigArrayFactoryInternalSlots\n * @property {Map<string,Plugin>} additionalPluginPool The map for additional plugins.\n * @property {string} cwd The path to the current working directory.\n * @property {string} resolvePluginsRelativeTo An absolute path the the directory that plugins should be resolved from.\n */\n\n/** @type {WeakMap<ConfigArrayFactory, ConfigArrayFactoryInternalSlots>} */\nconst internalSlotsMap$2 = new WeakMap();\n\n/**\n * Check if a given string is a file path.\n * @param {string} nameOrPath A module name or file path.\n * @returns {boolean} `true` if the `nameOrPath` is a file path.\n */\nfunction isFilePath(nameOrPath) {\n    return (\n        /^\\.{1,2}[/\\\\]/u.test(nameOrPath) ||\n        path$1.isAbsolute(nameOrPath)\n    );\n}\n\n/**\n * Convenience wrapper for synchronously reading file contents.\n * @param {string} filePath The filename to read.\n * @returns {string} The file contents, with the BOM removed.\n * @private\n */\nfunction readFile(filePath) {\n    return fs$2.readFileSync(filePath, \"utf8\").replace(/^\\ufeff/u, \"\");\n}\n\n/**\n * Loads a YAML configuration from a file.\n * @param {string} filePath The filename to load.\n * @returns {ConfigData} The configuration object from the file.\n * @throws {Error} If the file cannot be read.\n * @private\n */\nfunction loadYAMLConfigFile(filePath) {\n    debug$7(`Loading YAML config file: ${filePath}`);\n\n    // lazy load YAML to improve performance when not used\n    const yaml = jsYaml$1;\n\n    try {\n\n        // empty YAML file can be null, so always use\n        return yaml.safeLoad(readFile(filePath)) || {};\n    } catch (e) {\n        debug$7(`Error reading YAML file: ${filePath}`);\n        e.message = `Cannot read config file: ${filePath}\\nError: ${e.message}`;\n        throw e;\n    }\n}\n\n/**\n * Loads a JSON configuration from a file.\n * @param {string} filePath The filename to load.\n * @returns {ConfigData} The configuration object from the file.\n * @throws {Error} If the file cannot be read.\n * @private\n */\nfunction loadJSONConfigFile(filePath) {\n    debug$7(`Loading JSON config file: ${filePath}`);\n\n    try {\n        return JSON.parse(stripJsonComments(readFile(filePath)));\n    } catch (e) {\n        debug$7(`Error reading JSON file: ${filePath}`);\n        e.message = `Cannot read config file: ${filePath}\\nError: ${e.message}`;\n        e.messageTemplate = \"failed-to-read-json\";\n        e.messageData = {\n            path: filePath,\n            message: e.message\n        };\n        throw e;\n    }\n}\n\n/**\n * Loads a legacy (.eslintrc) configuration from a file.\n * @param {string} filePath The filename to load.\n * @returns {ConfigData} The configuration object from the file.\n * @throws {Error} If the file cannot be read.\n * @private\n */\nfunction loadLegacyConfigFile(filePath) {\n    debug$7(`Loading legacy config file: ${filePath}`);\n\n    // lazy load YAML to improve performance when not used\n    const yaml = jsYaml$1;\n\n    try {\n        return yaml.safeLoad(stripJsonComments(readFile(filePath))) || /* istanbul ignore next */ {};\n    } catch (e) {\n        debug$7(\"Error reading YAML file: %s\\n%o\", filePath, e);\n        e.message = `Cannot read config file: ${filePath}\\nError: ${e.message}`;\n        throw e;\n    }\n}\n\n/**\n * Loads a JavaScript configuration from a file.\n * @param {string} filePath The filename to load.\n * @returns {ConfigData} The configuration object from the file.\n * @throws {Error} If the file cannot be read.\n * @private\n */\nfunction loadJSConfigFile(filePath) {\n    debug$7(`Loading JS config file: ${filePath}`);\n    try {\n        return importFresh(filePath);\n    } catch (e) {\n        debug$7(`Error reading JavaScript file: ${filePath}`);\n        e.message = `Cannot read config file: ${filePath}\\nError: ${e.message}`;\n        throw e;\n    }\n}\n\n/**\n * Loads a configuration from a package.json file.\n * @param {string} filePath The filename to load.\n * @returns {ConfigData} The configuration object from the file.\n * @throws {Error} If the file cannot be read.\n * @private\n */\nfunction loadPackageJSONConfigFile(filePath) {\n    debug$7(`Loading package.json config file: ${filePath}`);\n    try {\n        const packageData = loadJSONConfigFile(filePath);\n\n        if (!Object.hasOwnProperty.call(packageData, \"eslintConfig\")) {\n            throw Object.assign(\n                new Error(\"package.json file doesn't have 'eslintConfig' field.\"),\n                { code: \"ESLINT_CONFIG_FIELD_NOT_FOUND\" }\n            );\n        }\n\n        return packageData.eslintConfig;\n    } catch (e) {\n        debug$7(`Error reading package.json file: ${filePath}`);\n        e.message = `Cannot read config file: ${filePath}\\nError: ${e.message}`;\n        throw e;\n    }\n}\n\n/**\n * Loads a `.eslintignore` from a file.\n * @param {string} filePath The filename to load.\n * @returns {string[]} The ignore patterns from the file.\n * @private\n */\nfunction loadESLintIgnoreFile(filePath) {\n    debug$7(`Loading .eslintignore file: ${filePath}`);\n\n    try {\n        return readFile(filePath)\n            .split(/\\r?\\n/gu)\n            .filter(line => line.trim() !== \"\" && !line.startsWith(\"#\"));\n    } catch (e) {\n        debug$7(`Error reading .eslintignore file: ${filePath}`);\n        e.message = `Cannot read .eslintignore file: ${filePath}\\nError: ${e.message}`;\n        throw e;\n    }\n}\n\n/**\n * Creates an error to notify about a missing config to extend from.\n * @param {string} configName The name of the missing config.\n * @param {string} importerName The name of the config that imported the missing config\n * @returns {Error} The error object to throw\n * @private\n */\nfunction configMissingError(configName, importerName) {\n    return Object.assign(\n        new Error(`Failed to load config \"${configName}\" to extend from.`),\n        {\n            messageTemplate: \"extend-config-missing\",\n            messageData: { configName, importerName }\n        }\n    );\n}\n\n/**\n * Loads a configuration file regardless of the source. Inspects the file path\n * to determine the correctly way to load the config file.\n * @param {string} filePath The path to the configuration.\n * @returns {ConfigData|null} The configuration information.\n * @private\n */\nfunction loadConfigFile(filePath) {\n    switch (path$1.extname(filePath)) {\n        case \".js\":\n        case \".cjs\":\n            return loadJSConfigFile(filePath);\n\n        case \".json\":\n            if (path$1.basename(filePath) === \"package.json\") {\n                return loadPackageJSONConfigFile(filePath);\n            }\n            return loadJSONConfigFile(filePath);\n\n        case \".yaml\":\n        case \".yml\":\n            return loadYAMLConfigFile(filePath);\n\n        default:\n            return loadLegacyConfigFile(filePath);\n    }\n}\n\n/**\n * Write debug log.\n * @param {string} request The requested module name.\n * @param {string} relativeTo The file path to resolve the request relative to.\n * @param {string} filePath The resolved file path.\n * @returns {void}\n */\nfunction writeDebugLogForLoading(request, relativeTo, filePath) {\n    /* istanbul ignore next */\n    if (debug$7.enabled) {\n        let nameAndVersion = null;\n\n        try {\n            const packageJsonPath = relativeModuleResolver.resolve(\n                `${request}/package.json`,\n                relativeTo\n            );\n            const { version = \"unknown\" } = commonjsRequire(packageJsonPath);\n\n            nameAndVersion = `${request}@${version}`;\n        } catch (error) {\n            debug$7(\"package.json was not found:\", error.message);\n            nameAndVersion = request;\n        }\n\n        debug$7(\"Loaded: %s (%s)\", nameAndVersion, filePath);\n    }\n}\n\n/**\n * Concatenate two config data.\n * @param {IterableIterator<ConfigArrayElement>|null} elements The config elements.\n * @param {ConfigArray|null} parentConfigArray The parent config array.\n * @returns {ConfigArray} The concatenated config array.\n */\nfunction createConfigArray(elements, parentConfigArray) {\n    if (!elements) {\n        return parentConfigArray || new ConfigArray$2();\n    }\n    const configArray = new ConfigArray$2(...elements);\n\n    if (parentConfigArray && !configArray.isRoot()) {\n        configArray.unshift(...parentConfigArray);\n    }\n    return configArray;\n}\n\n/**\n * Normalize a given plugin.\n * - Ensure the object to have four properties: configs, environments, processors, and rules.\n * - Ensure the object to not have other properties.\n * @param {Plugin} plugin The plugin to normalize.\n * @returns {Plugin} The normalized plugin.\n */\nfunction normalizePlugin(plugin) {\n    return {\n        configs: plugin.configs || {},\n        environments: plugin.environments || {},\n        processors: plugin.processors || {},\n        rules: plugin.rules || {}\n    };\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * The factory of `ConfigArray` objects.\n */\nclass ConfigArrayFactory {\n\n    /**\n     * Initialize this instance.\n     * @param {ConfigArrayFactoryOptions} [options] The map for additional plugins.\n     */\n    constructor({\n        additionalPluginPool = new Map(),\n        cwd = process.cwd(),\n        resolvePluginsRelativeTo = cwd\n    } = {}) {\n        internalSlotsMap$2.set(this, { additionalPluginPool, cwd, resolvePluginsRelativeTo: path$1.resolve(cwd, resolvePluginsRelativeTo) });\n    }\n\n    /**\n     * Create `ConfigArray` instance from a config data.\n     * @param {ConfigData|null} configData The config data to create.\n     * @param {Object} [options] The options.\n     * @param {string} [options.filePath] The path to this config data.\n     * @param {string} [options.name] The config name.\n     * @param {ConfigArray} [options.parent] The parent config array.\n     * @returns {ConfigArray} Loaded config.\n     */\n    create(configData, { filePath, name, parent } = {}) {\n        return createConfigArray(\n            configData\n                ? this._normalizeConfigData(configData, filePath, name)\n                : null,\n            parent\n        );\n    }\n\n    /**\n     * Load a config file.\n     * @param {string} filePath The path to a config file.\n     * @param {Object} [options] The options.\n     * @param {string} [options.name] The config name.\n     * @param {ConfigArray} [options.parent] The parent config array.\n     * @returns {ConfigArray} Loaded config.\n     */\n    loadFile(filePath, { name, parent } = {}) {\n        const { cwd } = internalSlotsMap$2.get(this);\n        const absolutePath = path$1.resolve(cwd, filePath);\n\n        return createConfigArray(\n            this._loadConfigData(absolutePath, name),\n            parent\n        );\n    }\n\n    /**\n     * Load the config file on a given directory if exists.\n     * @param {string} directoryPath The path to a directory.\n     * @param {Object} [options] The options.\n     * @param {string} [options.name] The config name.\n     * @param {ConfigArray} [options.parent] The parent config array.\n     * @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.\n     */\n    loadInDirectory(directoryPath, { name, parent } = {}) {\n        const { cwd } = internalSlotsMap$2.get(this);\n        const absolutePath = path$1.resolve(cwd, directoryPath);\n\n        return createConfigArray(\n            this._loadConfigDataInDirectory(absolutePath, name),\n            parent\n        );\n    }\n\n    /**\n     * Load `.eslintignore` file.\n     * @param {string} filePath The path to a `.eslintignore` file to load.\n     * @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.\n     */\n    loadESLintIgnore(filePath) {\n        const { cwd } = internalSlotsMap$2.get(this);\n        const absolutePath = path$1.resolve(cwd, filePath);\n        const name = path$1.relative(cwd, absolutePath);\n        const ignorePatterns = loadESLintIgnoreFile(absolutePath);\n\n        return createConfigArray(\n            this._normalizeESLintIgnoreData(ignorePatterns, absolutePath, name)\n        );\n    }\n\n    /**\n     * Load `.eslintignore` file in the current working directory.\n     * @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.\n     */\n    loadDefaultESLintIgnore() {\n        const { cwd } = internalSlotsMap$2.get(this);\n        const eslintIgnorePath = path$1.resolve(cwd, \".eslintignore\");\n        const packageJsonPath = path$1.resolve(cwd, \"package.json\");\n\n        if (fs$2.existsSync(eslintIgnorePath)) {\n            return this.loadESLintIgnore(eslintIgnorePath);\n        }\n        if (fs$2.existsSync(packageJsonPath)) {\n            const data = loadJSONConfigFile(packageJsonPath);\n\n            if (Object.hasOwnProperty.call(data, \"eslintIgnore\")) {\n                if (!Array.isArray(data.eslintIgnore)) {\n                    throw new Error(\"Package.json eslintIgnore property requires an array of paths\");\n                }\n                return createConfigArray(\n                    this._normalizeESLintIgnoreData(\n                        data.eslintIgnore,\n                        packageJsonPath,\n                        \"eslintIgnore in package.json\"\n                    )\n                );\n            }\n        }\n\n        return new ConfigArray$2();\n    }\n\n    /**\n     * Load a given config file.\n     * @param {string} filePath The path to a config file.\n     * @param {string} name The config name.\n     * @returns {IterableIterator<ConfigArrayElement>} Loaded config.\n     * @private\n     */\n    _loadConfigData(filePath, name) {\n        return this._normalizeConfigData(\n            loadConfigFile(filePath),\n            filePath,\n            name\n        );\n    }\n\n    /**\n     * Load the config file in a given directory if exists.\n     * @param {string} directoryPath The path to a directory.\n     * @param {string} name The config name.\n     * @returns {IterableIterator<ConfigArrayElement> | null} Loaded config. `null` if any config doesn't exist.\n     * @private\n     */\n    _loadConfigDataInDirectory(directoryPath, name) {\n        for (const filename of configFilenames) {\n            const filePath = path$1.join(directoryPath, filename);\n\n            if (fs$2.existsSync(filePath)) {\n                let configData;\n\n                try {\n                    configData = loadConfigFile(filePath);\n                } catch (error) {\n                    if (!error || error.code !== \"ESLINT_CONFIG_FIELD_NOT_FOUND\") {\n                        throw error;\n                    }\n                }\n\n                if (configData) {\n                    debug$7(`Config file found: ${filePath}`);\n                    return this._normalizeConfigData(configData, filePath, name);\n                }\n            }\n        }\n\n        debug$7(`Config file not found on ${directoryPath}`);\n        return null;\n    }\n\n    /**\n     * Normalize a given `.eslintignore` data to config array elements.\n     * @param {string[]} ignorePatterns The patterns to ignore files.\n     * @param {string|undefined} filePath The file path of this config.\n     * @param {string|undefined} name The name of this config.\n     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.\n     * @private\n     */\n    *_normalizeESLintIgnoreData(ignorePatterns, filePath, name) {\n        const elements = this._normalizeObjectConfigData(\n            { ignorePatterns },\n            filePath,\n            name\n        );\n\n        // Set `ignorePattern.loose` flag for backward compatibility.\n        for (const element of elements) {\n            if (element.ignorePattern) {\n                element.ignorePattern.loose = true;\n            }\n            yield element;\n        }\n    }\n\n    /**\n     * Normalize a given config to an array.\n     * @param {ConfigData} configData The config data to normalize.\n     * @param {string|undefined} providedFilePath The file path of this config.\n     * @param {string|undefined} providedName The name of this config.\n     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.\n     * @private\n     */\n    _normalizeConfigData(configData, providedFilePath, providedName) {\n        const { cwd } = internalSlotsMap$2.get(this);\n        const filePath = providedFilePath\n            ? path$1.resolve(cwd, providedFilePath)\n            : \"\";\n        const name = providedName || (filePath && path$1.relative(cwd, filePath));\n\n        validateConfigSchema$1(configData, name || filePath);\n\n        return this._normalizeObjectConfigData(configData, filePath, name);\n    }\n\n    /**\n     * Normalize a given config to an array.\n     * @param {ConfigData|OverrideConfigData} configData The config data to normalize.\n     * @param {string} filePath The file path of this config.\n     * @param {string} name The name of this config.\n     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.\n     * @private\n     */\n    *_normalizeObjectConfigData(configData, filePath, name) {\n        const { cwd } = internalSlotsMap$2.get(this);\n        const { files, excludedFiles, ...configBody } = configData;\n        const basePath = filePath ? path$1.dirname(filePath) : cwd;\n        const criteria = OverrideTester$2.create(files, excludedFiles, basePath);\n        const elements =\n            this._normalizeObjectConfigDataBody(configBody, filePath, name);\n\n        // Apply the criteria to every element.\n        for (const element of elements) {\n\n            // Adopt the base path of the entry file (the outermost base path).\n            if (element.criteria) {\n                element.criteria.basePath = basePath;\n            }\n            if (element.ignorePattern) {\n                element.ignorePattern.basePath = basePath;\n            }\n\n            /*\n             * Merge the criteria; this is for only file extension processors in\n             * `overrides` section for now.\n             */\n            element.criteria = OverrideTester$2.and(criteria, element.criteria);\n\n            /*\n             * Remove `root` property to ignore `root` settings which came from\n             * `extends` in `overrides`.\n             */\n            if (element.criteria) {\n                element.root = void 0;\n            }\n\n            yield element;\n        }\n    }\n\n    /**\n     * Normalize a given config to an array.\n     * @param {ConfigData} configData The config data to normalize.\n     * @param {string} filePath The file path of this config.\n     * @param {string} name The name of this config.\n     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.\n     * @private\n     */\n    *_normalizeObjectConfigDataBody(\n        {\n            env,\n            extends: extend,\n            globals,\n            ignorePatterns,\n            noInlineConfig,\n            parser: parserName,\n            parserOptions,\n            plugins: pluginList,\n            processor,\n            reportUnusedDisableDirectives,\n            root,\n            rules,\n            settings,\n            overrides: overrideList = []\n        },\n        filePath,\n        name\n    ) {\n        const extendList = Array.isArray(extend) ? extend : [extend];\n        const ignorePattern = ignorePatterns && new IgnorePattern$4(\n            Array.isArray(ignorePatterns) ? ignorePatterns : [ignorePatterns],\n            filePath ? path$1.dirname(filePath) : internalSlotsMap$2.get(this).cwd\n        );\n\n        // Flatten `extends`.\n        for (const extendName of extendList.filter(Boolean)) {\n            yield* this._loadExtends(extendName, filePath, name);\n        }\n\n        // Load parser & plugins.\n        const parser =\n            parserName && this._loadParser(parserName, filePath, name);\n        const plugins =\n            pluginList && this._loadPlugins(pluginList, filePath, name);\n\n        // Yield pseudo config data for file extension processors.\n        if (plugins) {\n            yield* this._takeFileExtensionProcessors(plugins, filePath, name);\n        }\n\n        // Yield the config data except `extends` and `overrides`.\n        yield {\n\n            // Debug information.\n            name,\n            filePath,\n\n            // Config data.\n            criteria: null,\n            env,\n            globals,\n            ignorePattern,\n            noInlineConfig,\n            parser,\n            parserOptions,\n            plugins,\n            processor,\n            reportUnusedDisableDirectives,\n            root,\n            rules,\n            settings\n        };\n\n        // Flatten `overries`.\n        for (let i = 0; i < overrideList.length; ++i) {\n            yield* this._normalizeObjectConfigData(\n                overrideList[i],\n                filePath,\n                `${name}#overrides[${i}]`\n            );\n        }\n    }\n\n    /**\n     * Load configs of an element in `extends`.\n     * @param {string} extendName The name of a base config.\n     * @param {string} importerPath The file path which has the `extends` property.\n     * @param {string} importerName The name of the config which has the `extends` property.\n     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.\n     * @private\n     */\n    _loadExtends(extendName, importerPath, importerName) {\n        debug$7(\"Loading {extends:%j} relative to %s\", extendName, importerPath);\n        try {\n            if (extendName.startsWith(\"eslint:\")) {\n                return this._loadExtendedBuiltInConfig(\n                    extendName,\n                    importerName\n                );\n            }\n            if (extendName.startsWith(\"plugin:\")) {\n                return this._loadExtendedPluginConfig(\n                    extendName,\n                    importerPath,\n                    importerName\n                );\n            }\n            return this._loadExtendedShareableConfig(\n                extendName,\n                importerPath,\n                importerName\n            );\n        } catch (error) {\n            error.message += `\\nReferenced from: ${importerPath || importerName}`;\n            throw error;\n        }\n    }\n\n    /**\n     * Load configs of an element in `extends`.\n     * @param {string} extendName The name of a base config.\n     * @param {string} importerName The name of the config which has the `extends` property.\n     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.\n     * @private\n     */\n    _loadExtendedBuiltInConfig(extendName, importerName) {\n        const name = `${importerName} » ${extendName}`;\n\n        if (extendName === \"eslint:recommended\") {\n            return this._loadConfigData(eslintRecommendedPath, name);\n        }\n        if (extendName === \"eslint:all\") {\n            return this._loadConfigData(eslintAllPath, name);\n        }\n\n        throw configMissingError(extendName, importerName);\n    }\n\n    /**\n     * Load configs of an element in `extends`.\n     * @param {string} extendName The name of a base config.\n     * @param {string} importerPath The file path which has the `extends` property.\n     * @param {string} importerName The name of the config which has the `extends` property.\n     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.\n     * @private\n     */\n    _loadExtendedPluginConfig(extendName, importerPath, importerName) {\n        const slashIndex = extendName.lastIndexOf(\"/\");\n        const pluginName = extendName.slice(\"plugin:\".length, slashIndex);\n        const configName = extendName.slice(slashIndex + 1);\n\n        if (isFilePath(pluginName)) {\n            throw new Error(\"'extends' cannot use a file path for plugins.\");\n        }\n\n        const plugin = this._loadPlugin(pluginName, importerPath, importerName);\n        const configData =\n            plugin.definition &&\n            plugin.definition.configs[configName];\n\n        if (configData) {\n            return this._normalizeConfigData(\n                configData,\n                plugin.filePath,\n                `${importerName} » plugin:${plugin.id}/${configName}`\n            );\n        }\n\n        throw plugin.error || configMissingError(extendName, importerPath);\n    }\n\n    /**\n     * Load configs of an element in `extends`.\n     * @param {string} extendName The name of a base config.\n     * @param {string} importerPath The file path which has the `extends` property.\n     * @param {string} importerName The name of the config which has the `extends` property.\n     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.\n     * @private\n     */\n    _loadExtendedShareableConfig(extendName, importerPath, importerName) {\n        const { cwd } = internalSlotsMap$2.get(this);\n        const relativeTo = importerPath || path$1.join(cwd, \"__placeholder__.js\");\n        let request;\n\n        if (isFilePath(extendName)) {\n            request = extendName;\n        } else if (extendName.startsWith(\".\")) {\n            request = `./${extendName}`; // For backward compatibility. A ton of tests depended on this behavior.\n        } else {\n            request = naming.normalizePackageName(\n                extendName,\n                \"eslint-config\"\n            );\n        }\n\n        let filePath;\n\n        try {\n            filePath = relativeModuleResolver.resolve(request, relativeTo);\n        } catch (error) {\n            /* istanbul ignore else */\n            if (error && error.code === \"MODULE_NOT_FOUND\") {\n                throw configMissingError(extendName, importerPath);\n            }\n            throw error;\n        }\n\n        writeDebugLogForLoading(request, relativeTo, filePath);\n        return this._loadConfigData(filePath, `${importerName} » ${request}`);\n    }\n\n    /**\n     * Load given plugins.\n     * @param {string[]} names The plugin names to load.\n     * @param {string} importerPath The path to a config file that imports it. This is just a debug info.\n     * @param {string} importerName The name of a config file that imports it. This is just a debug info.\n     * @returns {Record<string,DependentPlugin>} The loaded parser.\n     * @private\n     */\n    _loadPlugins(names, importerPath, importerName) {\n        return names.reduce((map, name) => {\n            if (isFilePath(name)) {\n                throw new Error(\"Plugins array cannot includes file paths.\");\n            }\n            const plugin = this._loadPlugin(name, importerPath, importerName);\n\n            map[plugin.id] = plugin;\n\n            return map;\n        }, {});\n    }\n\n    /**\n     * Load a given parser.\n     * @param {string} nameOrPath The package name or the path to a parser file.\n     * @param {string} importerPath The path to a config file that imports it.\n     * @param {string} importerName The name of a config file that imports it. This is just a debug info.\n     * @returns {DependentParser} The loaded parser.\n     */\n    _loadParser(nameOrPath, importerPath, importerName) {\n        debug$7(\"Loading parser %j from %s\", nameOrPath, importerPath);\n\n        const { cwd } = internalSlotsMap$2.get(this);\n        const relativeTo = importerPath || path$1.join(cwd, \"__placeholder__.js\");\n\n        try {\n            const filePath = relativeModuleResolver.resolve(nameOrPath, relativeTo);\n\n            writeDebugLogForLoading(nameOrPath, relativeTo, filePath);\n\n            return new ConfigDependency$2({\n                definition: commonjsRequire(filePath),\n                filePath,\n                id: nameOrPath,\n                importerName,\n                importerPath\n            });\n        } catch (error) {\n\n            // If the parser name is \"espree\", load the espree of ESLint.\n            if (nameOrPath === \"espree\") {\n                debug$7(\"Fallback espree.\");\n                return new ConfigDependency$2({\n                    definition: espree_1,\n                    filePath: commonjsRequire.resolve(\"espree\"),\n                    id: nameOrPath,\n                    importerName,\n                    importerPath\n                });\n            }\n\n            debug$7(\"Failed to load parser '%s' declared in '%s'.\", nameOrPath, importerName);\n            error.message = `Failed to load parser '${nameOrPath}' declared in '${importerName}': ${error.message}`;\n\n            return new ConfigDependency$2({\n                error,\n                id: nameOrPath,\n                importerName,\n                importerPath\n            });\n        }\n    }\n\n    /**\n     * Load a given plugin.\n     * @param {string} name The plugin name to load.\n     * @param {string} importerPath The path to a config file that imports it. This is just a debug info.\n     * @param {string} importerName The name of a config file that imports it. This is just a debug info.\n     * @returns {DependentPlugin} The loaded plugin.\n     * @private\n     */\n    _loadPlugin(name, importerPath, importerName) {\n        debug$7(\"Loading plugin %j from %s\", name, importerPath);\n\n        const { additionalPluginPool, resolvePluginsRelativeTo } = internalSlotsMap$2.get(this);\n        const request = naming.normalizePackageName(name, \"eslint-plugin\");\n        const id = naming.getShorthandName(request, \"eslint-plugin\");\n        const relativeTo = path$1.join(resolvePluginsRelativeTo, \"__placeholder__.js\");\n\n        if (name.match(/\\s+/u)) {\n            const error = Object.assign(\n                new Error(`Whitespace found in plugin name '${name}'`),\n                {\n                    messageTemplate: \"whitespace-found\",\n                    messageData: { pluginName: request }\n                }\n            );\n\n            return new ConfigDependency$2({\n                error,\n                id,\n                importerName,\n                importerPath\n            });\n        }\n\n        // Check for additional pool.\n        const plugin =\n            additionalPluginPool.get(request) ||\n            additionalPluginPool.get(id);\n\n        if (plugin) {\n            return new ConfigDependency$2({\n                definition: normalizePlugin(plugin),\n                filePath: importerPath,\n                id,\n                importerName,\n                importerPath\n            });\n        }\n\n        let filePath;\n        let error;\n\n        try {\n            filePath = relativeModuleResolver.resolve(request, relativeTo);\n        } catch (resolveError) {\n            error = resolveError;\n            /* istanbul ignore else */\n            if (error && error.code === \"MODULE_NOT_FOUND\") {\n                error.messageTemplate = \"plugin-missing\";\n                error.messageData = {\n                    pluginName: request,\n                    resolvePluginsRelativeTo,\n                    importerName\n                };\n            }\n        }\n\n        if (filePath) {\n            try {\n                writeDebugLogForLoading(request, relativeTo, filePath);\n\n                const startTime = Date.now();\n                const pluginDefinition = commonjsRequire(filePath);\n\n                debug$7(`Plugin ${filePath} loaded in: ${Date.now() - startTime}ms`);\n\n                return new ConfigDependency$2({\n                    definition: normalizePlugin(pluginDefinition),\n                    filePath,\n                    id,\n                    importerName,\n                    importerPath\n                });\n            } catch (loadError) {\n                error = loadError;\n            }\n        }\n\n        debug$7(\"Failed to load plugin '%s' declared in '%s'.\", name, importerName);\n        error.message = `Failed to load plugin '${name}' declared in '${importerName}': ${error.message}`;\n        return new ConfigDependency$2({\n            error,\n            id,\n            importerName,\n            importerPath\n        });\n    }\n\n    /**\n     * Take file expression processors as config array elements.\n     * @param {Record<string,DependentPlugin>} plugins The plugin definitions.\n     * @param {string} filePath The file path of this config.\n     * @param {string} name The name of this config.\n     * @returns {IterableIterator<ConfigArrayElement>} The config array elements of file expression processors.\n     * @private\n     */\n    *_takeFileExtensionProcessors(plugins, filePath, name) {\n        for (const pluginId of Object.keys(plugins)) {\n            const processors =\n                plugins[pluginId] &&\n                plugins[pluginId].definition &&\n                plugins[pluginId].definition.processors;\n\n            if (!processors) {\n                continue;\n            }\n\n            for (const processorId of Object.keys(processors)) {\n                if (processorId.startsWith(\".\")) {\n                    yield* this._normalizeObjectConfigData(\n                        {\n                            files: [`*${processorId}`],\n                            processor: `${pluginId}/${processorId}`\n                        },\n                        filePath,\n                        `${name}#processors[\"${pluginId}/${processorId}\"]`\n                    );\n                }\n            }\n        }\n    }\n}\n\nvar configArrayFactory = { ConfigArrayFactory };\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\nconst rulesDirCache = {};\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * Load all rule modules from specified directory.\n * @param {string} relativeRulesDir Path to rules directory, may be relative.\n * @param {string} cwd Current working directory\n * @returns {Object} Loaded rule modules.\n */\nvar loadRules = function(relativeRulesDir, cwd) {\n    const rulesDir = path$1.resolve(cwd, relativeRulesDir);\n\n    // cache will help performance as IO operation are expensive\n    if (rulesDirCache[rulesDir]) {\n        return rulesDirCache[rulesDir];\n    }\n\n    const rules = Object.create(null);\n\n    fs$2.readdirSync(rulesDir).forEach(file => {\n        if (path$1.extname(file) !== \".js\") {\n            return;\n        }\n        rules[file.slice(0, -3)] = commonjsRequire(path$1.join(rulesDir, file));\n    });\n    rulesDirCache[rulesDir] = rules;\n\n    return rules;\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\nconst { validateConfigArray: validateConfigArray$1 } = configValidator;\nconst { ConfigArrayFactory: ConfigArrayFactory$1 } = configArrayFactory;\nconst { ConfigArray: ConfigArray$3, ConfigDependency: ConfigDependency$3, IgnorePattern: IgnorePattern$5 } = configArray$1;\n\nconst debug$8 = src(\"eslint:cascading-config-array-factory\");\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n// Define types for VSCode IntelliSense.\n/** @typedef {import(\"../shared/types\").ConfigData} ConfigData */\n/** @typedef {import(\"../shared/types\").Parser} Parser */\n/** @typedef {import(\"../shared/types\").Plugin} Plugin */\n/** @typedef {ReturnType<ConfigArrayFactory[\"create\"]>} ConfigArray */\n\n/**\n * @typedef {Object} CascadingConfigArrayFactoryOptions\n * @property {Map<string,Plugin>} [additionalPluginPool] The map for additional plugins.\n * @property {ConfigData} [baseConfig] The config by `baseConfig` option.\n * @property {ConfigData} [cliConfig] The config by CLI options (`--env`, `--global`, `--ignore-pattern`, `--parser`, `--parser-options`, `--plugin`, and `--rule`). CLI options overwrite the setting in config files.\n * @property {string} [cwd] The base directory to start lookup.\n * @property {string} [ignorePath] The path to the alternative file of `.eslintignore`.\n * @property {string[]} [rulePaths] The value of `--rulesdir` option.\n * @property {string} [specificConfigPath] The value of `--config` option.\n * @property {boolean} [useEslintrc] if `false` then it doesn't load config files.\n */\n\n/**\n * @typedef {Object} CascadingConfigArrayFactoryInternalSlots\n * @property {ConfigArray} baseConfigArray The config array of `baseConfig` option.\n * @property {ConfigData} baseConfigData The config data of `baseConfig` option. This is used to reset `baseConfigArray`.\n * @property {ConfigArray} cliConfigArray The config array of CLI options.\n * @property {ConfigData} cliConfigData The config data of CLI options. This is used to reset `cliConfigArray`.\n * @property {ConfigArrayFactory} configArrayFactory The factory for config arrays.\n * @property {Map<string, ConfigArray>} configCache The cache from directory paths to config arrays.\n * @property {string} cwd The base directory to start lookup.\n * @property {WeakMap<ConfigArray, ConfigArray>} finalizeCache The cache from config arrays to finalized config arrays.\n * @property {string} [ignorePath] The path to the alternative file of `.eslintignore`.\n * @property {string[]|null} rulePaths The value of `--rulesdir` option. This is used to reset `baseConfigArray`.\n * @property {string|null} specificConfigPath The value of `--config` option. This is used to reset `cliConfigArray`.\n * @property {boolean} useEslintrc if `false` then it doesn't load config files.\n */\n\n/** @type {WeakMap<CascadingConfigArrayFactory, CascadingConfigArrayFactoryInternalSlots>} */\nconst internalSlotsMap$3 = new WeakMap();\n\n/**\n * Create the config array from `baseConfig` and `rulePaths`.\n * @param {CascadingConfigArrayFactoryInternalSlots} slots The slots.\n * @returns {ConfigArray} The config array of the base configs.\n */\nfunction createBaseConfigArray({\n    configArrayFactory,\n    baseConfigData,\n    rulePaths,\n    cwd\n}) {\n    const baseConfigArray = configArrayFactory.create(\n        baseConfigData,\n        { name: \"BaseConfig\" }\n    );\n\n    /*\n     * Create the config array element for the default ignore patterns.\n     * This element has `ignorePattern` property that ignores the default\n     * patterns in the current working directory.\n     */\n    baseConfigArray.unshift(configArrayFactory.create(\n        { ignorePatterns: IgnorePattern$5.DefaultPatterns },\n        { name: \"DefaultIgnorePattern\" }\n    )[0]);\n\n    /*\n     * Load rules `--rulesdir` option as a pseudo plugin.\n     * Use a pseudo plugin to define rules of `--rulesdir`, so we can validate\n     * the rule's options with only information in the config array.\n     */\n    if (rulePaths && rulePaths.length > 0) {\n        baseConfigArray.push({\n            name: \"--rulesdir\",\n            filePath: \"\",\n            plugins: {\n                \"\": new ConfigDependency$3({\n                    definition: {\n                        rules: rulePaths.reduce(\n                            (map, rulesPath) => Object.assign(\n                                map,\n                                loadRules(rulesPath, cwd)\n                            ),\n                            {}\n                        )\n                    },\n                    filePath: \"\",\n                    id: \"\",\n                    importerName: \"--rulesdir\",\n                    importerPath: \"\"\n                })\n            }\n        });\n    }\n\n    return baseConfigArray;\n}\n\n/**\n * Create the config array from CLI options.\n * @param {CascadingConfigArrayFactoryInternalSlots} slots The slots.\n * @returns {ConfigArray} The config array of the base configs.\n */\nfunction createCLIConfigArray({\n    cliConfigData,\n    configArrayFactory,\n    ignorePath,\n    specificConfigPath\n}) {\n    const cliConfigArray = configArrayFactory.create(\n        cliConfigData,\n        { name: \"CLIOptions\" }\n    );\n\n    cliConfigArray.unshift(\n        ...(ignorePath\n            ? configArrayFactory.loadESLintIgnore(ignorePath)\n            : configArrayFactory.loadDefaultESLintIgnore())\n    );\n\n    if (specificConfigPath) {\n        cliConfigArray.unshift(\n            ...configArrayFactory.loadFile(\n                specificConfigPath,\n                { name: \"--config\" }\n            )\n        );\n    }\n\n    return cliConfigArray;\n}\n\n/**\n * The error type when there are files matched by a glob, but all of them have been ignored.\n */\nclass ConfigurationNotFoundError extends Error {\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @param {string} directoryPath The directory path.\n     */\n    constructor(directoryPath) {\n        super(`No ESLint configuration found in ${directoryPath}.`);\n        this.messageTemplate = \"no-config-found\";\n        this.messageData = { directoryPath };\n    }\n}\n\n/**\n * This class provides the functionality that enumerates every file which is\n * matched by given glob patterns and that configuration.\n */\nclass CascadingConfigArrayFactory {\n\n    /**\n     * Initialize this enumerator.\n     * @param {CascadingConfigArrayFactoryOptions} options The options.\n     */\n    constructor({\n        additionalPluginPool = new Map(),\n        baseConfig: baseConfigData = null,\n        cliConfig: cliConfigData = null,\n        cwd = process.cwd(),\n        ignorePath,\n        resolvePluginsRelativeTo = cwd,\n        rulePaths = [],\n        specificConfigPath = null,\n        useEslintrc = true\n    } = {}) {\n        const configArrayFactory = new ConfigArrayFactory$1({\n            additionalPluginPool,\n            cwd,\n            resolvePluginsRelativeTo\n        });\n\n        internalSlotsMap$3.set(this, {\n            baseConfigArray: createBaseConfigArray({\n                baseConfigData,\n                configArrayFactory,\n                cwd,\n                rulePaths\n            }),\n            baseConfigData,\n            cliConfigArray: createCLIConfigArray({\n                cliConfigData,\n                configArrayFactory,\n                ignorePath,\n                specificConfigPath\n            }),\n            cliConfigData,\n            configArrayFactory,\n            configCache: new Map(),\n            cwd,\n            finalizeCache: new WeakMap(),\n            ignorePath,\n            rulePaths,\n            specificConfigPath,\n            useEslintrc\n        });\n    }\n\n    /**\n     * The path to the current working directory.\n     * This is used by tests.\n     * @type {string}\n     */\n    get cwd() {\n        const { cwd } = internalSlotsMap$3.get(this);\n\n        return cwd;\n    }\n\n    /**\n     * Get the config array of a given file.\n     * If `filePath` was not given, it returns the config which contains only\n     * `baseConfigData` and `cliConfigData`.\n     * @param {string} [filePath] The file path to a file.\n     * @param {Object} [options] The options.\n     * @param {boolean} [options.ignoreNotFoundError] If `true` then it doesn't throw `ConfigurationNotFoundError`.\n     * @returns {ConfigArray} The config array of the file.\n     */\n    getConfigArrayForFile(filePath, { ignoreNotFoundError = false } = {}) {\n        const {\n            baseConfigArray,\n            cliConfigArray,\n            cwd\n        } = internalSlotsMap$3.get(this);\n\n        if (!filePath) {\n            return new ConfigArray$3(...baseConfigArray, ...cliConfigArray);\n        }\n\n        const directoryPath = path$1.dirname(path$1.resolve(cwd, filePath));\n\n        debug$8(`Load config files for ${directoryPath}.`);\n\n        return this._finalizeConfigArray(\n            this._loadConfigInAncestors(directoryPath),\n            directoryPath,\n            ignoreNotFoundError\n        );\n    }\n\n    /**\n     * Clear config cache.\n     * @returns {void}\n     */\n    clearCache() {\n        const slots = internalSlotsMap$3.get(this);\n\n        slots.baseConfigArray = createBaseConfigArray(slots);\n        slots.cliConfigArray = createCLIConfigArray(slots);\n        slots.configCache.clear();\n    }\n\n    /**\n     * Load and normalize config files from the ancestor directories.\n     * @param {string} directoryPath The path to a leaf directory.\n     * @returns {ConfigArray} The loaded config.\n     * @private\n     */\n    _loadConfigInAncestors(directoryPath) {\n        const {\n            baseConfigArray,\n            configArrayFactory,\n            configCache,\n            cwd,\n            useEslintrc\n        } = internalSlotsMap$3.get(this);\n\n        if (!useEslintrc) {\n            return baseConfigArray;\n        }\n\n        let configArray = configCache.get(directoryPath);\n\n        // Hit cache.\n        if (configArray) {\n            debug$8(`Cache hit: ${directoryPath}.`);\n            return configArray;\n        }\n        debug$8(`No cache found: ${directoryPath}.`);\n\n        const homePath = os.homedir();\n\n        // Consider this is root.\n        if (directoryPath === homePath && cwd !== homePath) {\n            debug$8(\"Stop traversing because of considered root.\");\n            return this._cacheConfig(directoryPath, baseConfigArray);\n        }\n\n        // Load the config on this directory.\n        try {\n            configArray = configArrayFactory.loadInDirectory(directoryPath);\n        } catch (error) {\n            /* istanbul ignore next */\n            if (error.code === \"EACCES\") {\n                debug$8(\"Stop traversing because of 'EACCES' error.\");\n                return this._cacheConfig(directoryPath, baseConfigArray);\n            }\n            throw error;\n        }\n\n        if (configArray.length > 0 && configArray.isRoot()) {\n            debug$8(\"Stop traversing because of 'root:true'.\");\n            configArray.unshift(...baseConfigArray);\n            return this._cacheConfig(directoryPath, configArray);\n        }\n\n        // Load from the ancestors and merge it.\n        const parentPath = path$1.dirname(directoryPath);\n        const parentConfigArray = parentPath && parentPath !== directoryPath\n            ? this._loadConfigInAncestors(parentPath)\n            : baseConfigArray;\n\n        if (configArray.length > 0) {\n            configArray.unshift(...parentConfigArray);\n        } else {\n            configArray = parentConfigArray;\n        }\n\n        // Cache and return.\n        return this._cacheConfig(directoryPath, configArray);\n    }\n\n    /**\n     * Freeze and cache a given config.\n     * @param {string} directoryPath The path to a directory as a cache key.\n     * @param {ConfigArray} configArray The config array as a cache value.\n     * @returns {ConfigArray} The `configArray` (frozen).\n     */\n    _cacheConfig(directoryPath, configArray) {\n        const { configCache } = internalSlotsMap$3.get(this);\n\n        Object.freeze(configArray);\n        configCache.set(directoryPath, configArray);\n\n        return configArray;\n    }\n\n    /**\n     * Finalize a given config array.\n     * Concatenate `--config` and other CLI options.\n     * @param {ConfigArray} configArray The parent config array.\n     * @param {string} directoryPath The path to the leaf directory to find config files.\n     * @param {boolean} ignoreNotFoundError If `true` then it doesn't throw `ConfigurationNotFoundError`.\n     * @returns {ConfigArray} The loaded config.\n     * @private\n     */\n    _finalizeConfigArray(configArray, directoryPath, ignoreNotFoundError) {\n        const {\n            cliConfigArray,\n            configArrayFactory,\n            finalizeCache,\n            useEslintrc\n        } = internalSlotsMap$3.get(this);\n\n        let finalConfigArray = finalizeCache.get(configArray);\n\n        if (!finalConfigArray) {\n            finalConfigArray = configArray;\n\n            // Load the personal config if there are no regular config files.\n            if (\n                useEslintrc &&\n                configArray.every(c => !c.filePath) &&\n                cliConfigArray.every(c => !c.filePath) // `--config` option can be a file.\n            ) {\n                debug$8(\"Loading the config file of the home directory.\");\n\n                finalConfigArray = configArrayFactory.loadInDirectory(\n                    os.homedir(),\n                    { name: \"PersonalConfig\", parent: finalConfigArray }\n                );\n            }\n\n            // Apply CLI options.\n            if (cliConfigArray.length > 0) {\n                finalConfigArray = finalConfigArray.concat(cliConfigArray);\n            }\n\n            // Validate rule settings and environments.\n            validateConfigArray$1(finalConfigArray);\n\n            // Cache it.\n            Object.freeze(finalConfigArray);\n            finalizeCache.set(configArray, finalConfigArray);\n\n            debug$8(\n                \"Configuration was determined: %o on %s\",\n                finalConfigArray,\n                directoryPath\n            );\n        }\n\n        // At least one element (the default ignore patterns) exists.\n        if (!ignoreNotFoundError && useEslintrc && finalConfigArray.length <= 1) {\n            throw new ConfigurationNotFoundError(directoryPath);\n        }\n\n        return finalConfigArray;\n    }\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nvar cascadingConfigArrayFactory = { CascadingConfigArrayFactory };\n\n/*!\n * is-extglob <https://github.com/jonschlinkert/is-extglob>\n *\n * Copyright (c) 2014-2016, Jon Schlinkert.\n * Licensed under the MIT License.\n */\n\nvar isExtglob = function isExtglob(str) {\n  if (typeof str !== 'string' || str === '') {\n    return false;\n  }\n\n  var match;\n  while ((match = /(\\\\).|([@?!+*]\\(.*\\))/g.exec(str))) {\n    if (match[2]) return true;\n    str = str.slice(match.index + match[0].length);\n  }\n\n  return false;\n};\n\n/*!\n * is-glob <https://github.com/jonschlinkert/is-glob>\n *\n * Copyright (c) 2014-2017, Jon Schlinkert.\n * Released under the MIT License.\n */\n\n\nvar chars$1 = { '{': '}', '(': ')', '[': ']'};\nvar strictRegex = /\\\\(.)|(^!|\\*|[\\].+)]\\?|\\[[^\\\\\\]]+\\]|\\{[^\\\\}]+\\}|\\(\\?[:!=][^\\\\)]+\\)|\\([^|]+\\|[^\\\\)]+\\))/;\nvar relaxedRegex = /\\\\(.)|(^!|[*?{}()[\\]]|\\(\\?)/;\n\nvar isGlob = function isGlob(str, options) {\n  if (typeof str !== 'string' || str === '') {\n    return false;\n  }\n\n  if (isExtglob(str)) {\n    return true;\n  }\n\n  var regex = strictRegex;\n  var match;\n\n  // optionally relax regex\n  if (options && options.strict === false) {\n    regex = relaxedRegex;\n  }\n\n  while ((match = regex.exec(str))) {\n    if (match[2]) return true;\n    var idx = match.index + match[0].length;\n\n    // if an open bracket/brace/paren is escaped,\n    // set the index to the next closing character\n    var open = match[1];\n    var close = open ? chars$1[open] : null;\n    if (open && close) {\n      var n = str.indexOf(close, idx);\n      if (n !== -1) {\n        idx = n + 1;\n      }\n    }\n\n    str = str.slice(idx);\n  }\n  return false;\n};\n\nvar pathPosixDirname = path$1.posix.dirname;\nvar isWin32 = os.platform() === 'win32';\n\nvar slash = '/';\nvar backslash = /\\\\/g;\nvar enclosure = /[\\{\\[].*[\\/]*.*[\\}\\]]$/;\nvar globby = /(^|[^\\\\])([\\{\\[]|\\([^\\)]+$)/;\nvar escaped = /\\\\([\\!\\*\\?\\|\\[\\]\\(\\)\\{\\}])/g;\n\n/**\n * @param {string} str\n * @param {Object} opts\n * @param {boolean} [opts.flipBackslashes=true]\n */\nvar globParent = function globParent(str, opts) {\n  var options = Object.assign({ flipBackslashes: true }, opts);\n\n  // flip windows path separators\n  if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {\n    str = str.replace(backslash, slash);\n  }\n\n  // special case for strings ending in enclosure containing path separator\n  if (enclosure.test(str)) {\n    str += slash;\n  }\n\n  // preserves full path in case of trailing path separator\n  str += 'a';\n\n  // remove path parts that are globby\n  do {\n    str = pathPosixDirname(str);\n  } while (isGlob(str) || globby.test(str));\n\n  // remove escape chars and return result\n  return str.replace(escaped, '$1');\n};\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n\nconst { escapeRegExp: escapeRegExp$1 } = lodash;\nconst { Minimatch: Minimatch$2 } = minimatch_1;\nconst { IgnorePattern: IgnorePattern$6 } = configArray$1;\nconst { CascadingConfigArrayFactory: CascadingConfigArrayFactory$1 } = cascadingConfigArrayFactory;\nconst debug$9 = src(\"eslint:file-enumerator\");\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\nconst minimatchOpts$1 = { dot: true, matchBase: true };\nconst dotfilesPattern = /(?:(?:^\\.)|(?:[/\\\\]\\.))[^/\\\\.].*/u;\nconst NONE = 0;\nconst IGNORED_SILENTLY = 1;\nconst IGNORED = 2;\n\n// For VSCode intellisense\n/** @typedef {ReturnType<CascadingConfigArrayFactory[\"getConfigArrayForFile\"]>} ConfigArray */\n\n/**\n * @typedef {Object} FileEnumeratorOptions\n * @property {CascadingConfigArrayFactory} [configArrayFactory] The factory for config arrays.\n * @property {string} [cwd] The base directory to start lookup.\n * @property {string[]} [extensions] The extensions to match files for directory patterns.\n * @property {boolean} [globInputPaths] Set to false to skip glob resolution of input file paths to lint (default: true). If false, each input file paths is assumed to be a non-glob path to an existing file.\n * @property {boolean} [ignore] The flag to check ignored files.\n * @property {string[]} [rulePaths] The value of `--rulesdir` option.\n */\n\n/**\n * @typedef {Object} FileAndConfig\n * @property {string} filePath The path to a target file.\n * @property {ConfigArray} config The config entries of that file.\n * @property {boolean} ignored If `true` then this file should be ignored and warned because it was directly specified.\n */\n\n/**\n * @typedef {Object} FileEntry\n * @property {string} filePath The path to a target file.\n * @property {ConfigArray} config The config entries of that file.\n * @property {NONE|IGNORED_SILENTLY|IGNORED} flag The flag.\n * - `NONE` means the file is a target file.\n * - `IGNORED_SILENTLY` means the file should be ignored silently.\n * - `IGNORED` means the file should be ignored and warned because it was directly specified.\n */\n\n/**\n * @typedef {Object} FileEnumeratorInternalSlots\n * @property {CascadingConfigArrayFactory} configArrayFactory The factory for config arrays.\n * @property {string} cwd The base directory to start lookup.\n * @property {RegExp} extensionRegExp The RegExp to test if a string ends with specific file extensions.\n * @property {boolean} globInputPaths Set to false to skip glob resolution of input file paths to lint (default: true). If false, each input file paths is assumed to be a non-glob path to an existing file.\n * @property {boolean} ignoreFlag The flag to check ignored files.\n * @property {(filePath:string, dot:boolean) => boolean} defaultIgnores The default predicate function to ignore files.\n */\n\n/** @type {WeakMap<FileEnumerator, FileEnumeratorInternalSlots>} */\nconst internalSlotsMap$4 = new WeakMap();\n\n/**\n * Check if a string is a glob pattern or not.\n * @param {string} pattern A glob pattern.\n * @returns {boolean} `true` if the string is a glob pattern.\n */\nfunction isGlobPattern(pattern) {\n    return isGlob(path$1.sep === \"\\\\\" ? pattern.replace(/\\\\/gu, \"/\") : pattern);\n}\n\n/**\n * Get stats of a given path.\n * @param {string} filePath The path to target file.\n * @returns {fs.Stats|null} The stats.\n * @private\n */\nfunction statSafeSync(filePath) {\n    try {\n        return fs$2.statSync(filePath);\n    } catch (error) {\n        /* istanbul ignore next */\n        if (error.code !== \"ENOENT\") {\n            throw error;\n        }\n        return null;\n    }\n}\n\n/**\n * Get filenames in a given path to a directory.\n * @param {string} directoryPath The path to target directory.\n * @returns {string[]} The filenames.\n * @private\n */\nfunction readdirSafeSync(directoryPath) {\n    try {\n        return fs$2.readdirSync(directoryPath);\n    } catch (error) {\n        /* istanbul ignore next */\n        if (error.code !== \"ENOENT\") {\n            throw error;\n        }\n        return [];\n    }\n}\n\n/**\n * The error type when no files match a glob.\n */\nclass NoFilesFoundError extends Error {\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @param {string} pattern The glob pattern which was not found.\n     * @param {boolean} globDisabled If `true` then the pattern was a glob pattern, but glob was disabled.\n     */\n    constructor(pattern, globDisabled) {\n        super(`No files matching '${pattern}' were found${globDisabled ? \" (glob was disabled)\" : \"\"}.`);\n        this.messageTemplate = \"file-not-found\";\n        this.messageData = { pattern, globDisabled };\n    }\n}\n\n/**\n * The error type when there are files matched by a glob, but all of them have been ignored.\n */\nclass AllFilesIgnoredError extends Error {\n\n    // eslint-disable-next-line jsdoc/require-description\n    /**\n     * @param {string} pattern The glob pattern which was not found.\n     */\n    constructor(pattern) {\n        super(`All files matched by '${pattern}' are ignored.`);\n        this.messageTemplate = \"all-files-ignored\";\n        this.messageData = { pattern };\n    }\n}\n\n/**\n * This class provides the functionality that enumerates every file which is\n * matched by given glob patterns and that configuration.\n */\nclass FileEnumerator {\n\n    /**\n     * Initialize this enumerator.\n     * @param {FileEnumeratorOptions} options The options.\n     */\n    constructor({\n        cwd = process.cwd(),\n        configArrayFactory = new CascadingConfigArrayFactory$1({ cwd }),\n        extensions = [\".js\"],\n        globInputPaths = true,\n        errorOnUnmatchedPattern = true,\n        ignore = true\n    } = {}) {\n        internalSlotsMap$4.set(this, {\n            configArrayFactory,\n            cwd,\n            defaultIgnores: IgnorePattern$6.createDefaultIgnore(cwd),\n            extensionRegExp: new RegExp(\n                `.\\\\.(?:${extensions\n                    .map(ext => escapeRegExp$1(\n                        ext.startsWith(\".\")\n                            ? ext.slice(1)\n                            : ext\n                    ))\n                    .join(\"|\")\n                })$`,\n                \"u\"\n            ),\n            globInputPaths,\n            errorOnUnmatchedPattern,\n            ignoreFlag: ignore\n        });\n    }\n\n    /**\n     * The `RegExp` object that tests if a file path has the allowed file extensions.\n     * @type {RegExp}\n     */\n    get extensionRegExp() {\n        return internalSlotsMap$4.get(this).extensionRegExp;\n    }\n\n    /**\n     * Iterate files which are matched by given glob patterns.\n     * @param {string|string[]} patternOrPatterns The glob patterns to iterate files.\n     * @returns {IterableIterator<FileAndConfig>} The found files.\n     */\n    *iterateFiles(patternOrPatterns) {\n        const { globInputPaths, errorOnUnmatchedPattern } = internalSlotsMap$4.get(this);\n        const patterns = Array.isArray(patternOrPatterns)\n            ? patternOrPatterns\n            : [patternOrPatterns];\n\n        debug$9(\"Start to iterate files: %o\", patterns);\n\n        // The set of paths to remove duplicate.\n        const set = new Set();\n\n        for (const pattern of patterns) {\n            let foundRegardlessOfIgnored = false;\n            let found = false;\n\n            // Skip empty string.\n            if (!pattern) {\n                continue;\n            }\n\n            // Iterate files of this pttern.\n            for (const { config, filePath, flag } of this._iterateFiles(pattern)) {\n                foundRegardlessOfIgnored = true;\n                if (flag === IGNORED_SILENTLY) {\n                    continue;\n                }\n                found = true;\n\n                // Remove duplicate paths while yielding paths.\n                if (!set.has(filePath)) {\n                    set.add(filePath);\n                    yield {\n                        config,\n                        filePath,\n                        ignored: flag === IGNORED\n                    };\n                }\n            }\n\n            // Raise an error if any files were not found.\n            if (errorOnUnmatchedPattern) {\n                if (!foundRegardlessOfIgnored) {\n                    throw new NoFilesFoundError(\n                        pattern,\n                        !globInputPaths && isGlob(pattern)\n                    );\n                }\n                if (!found) {\n                    throw new AllFilesIgnoredError(pattern);\n                }\n            }\n        }\n\n        debug$9(`Complete iterating files: ${JSON.stringify(patterns)}`);\n    }\n\n    /**\n     * Iterate files which are matched by a given glob pattern.\n     * @param {string} pattern The glob pattern to iterate files.\n     * @returns {IterableIterator<FileEntry>} The found files.\n     */\n    _iterateFiles(pattern) {\n        const { cwd, globInputPaths } = internalSlotsMap$4.get(this);\n        const absolutePath = path$1.resolve(cwd, pattern);\n        const isDot = dotfilesPattern.test(pattern);\n        const stat = statSafeSync(absolutePath);\n\n        if (stat && stat.isDirectory()) {\n            return this._iterateFilesWithDirectory(absolutePath, isDot);\n        }\n        if (stat && stat.isFile()) {\n            return this._iterateFilesWithFile(absolutePath);\n        }\n        if (globInputPaths && isGlobPattern(pattern)) {\n            return this._iterateFilesWithGlob(absolutePath, isDot);\n        }\n\n        return [];\n    }\n\n    /**\n     * Iterate a file which is matched by a given path.\n     * @param {string} filePath The path to the target file.\n     * @returns {IterableIterator<FileEntry>} The found files.\n     * @private\n     */\n    _iterateFilesWithFile(filePath) {\n        debug$9(`File: ${filePath}`);\n\n        const { configArrayFactory } = internalSlotsMap$4.get(this);\n        const config = configArrayFactory.getConfigArrayForFile(filePath);\n        const ignored = this._isIgnoredFile(filePath, { config, direct: true });\n        const flag = ignored ? IGNORED : NONE;\n\n        return [{ config, filePath, flag }];\n    }\n\n    /**\n     * Iterate files in a given path.\n     * @param {string} directoryPath The path to the target directory.\n     * @param {boolean} dotfiles If `true` then it doesn't skip dot files by default.\n     * @returns {IterableIterator<FileEntry>} The found files.\n     * @private\n     */\n    _iterateFilesWithDirectory(directoryPath, dotfiles) {\n        debug$9(`Directory: ${directoryPath}`);\n\n        return this._iterateFilesRecursive(\n            directoryPath,\n            { dotfiles, recursive: true, selector: null }\n        );\n    }\n\n    /**\n     * Iterate files which are matched by a given glob pattern.\n     * @param {string} pattern The glob pattern to iterate files.\n     * @param {boolean} dotfiles If `true` then it doesn't skip dot files by default.\n     * @returns {IterableIterator<FileEntry>} The found files.\n     * @private\n     */\n    _iterateFilesWithGlob(pattern, dotfiles) {\n        debug$9(`Glob: ${pattern}`);\n\n        const directoryPath = path$1.resolve(globParent(pattern));\n        const globPart = pattern.slice(directoryPath.length + 1);\n\n        /*\n         * recursive if there are `**` or path separators in the glob part.\n         * Otherwise, patterns such as `src/*.js`, it doesn't need recursive.\n         */\n        const recursive = /\\*\\*|\\/|\\\\/u.test(globPart);\n        const selector = new Minimatch$2(pattern, minimatchOpts$1);\n\n        debug$9(`recursive? ${recursive}`);\n\n        return this._iterateFilesRecursive(\n            directoryPath,\n            { dotfiles, recursive, selector }\n        );\n    }\n\n    /**\n     * Iterate files in a given path.\n     * @param {string} directoryPath The path to the target directory.\n     * @param {Object} options The options to iterate files.\n     * @param {boolean} [options.dotfiles] If `true` then it doesn't skip dot files by default.\n     * @param {boolean} [options.recursive] If `true` then it dives into sub directories.\n     * @param {InstanceType<Minimatch>} [options.selector] The matcher to choose files.\n     * @returns {IterableIterator<FileEntry>} The found files.\n     * @private\n     */\n    *_iterateFilesRecursive(directoryPath, options) {\n        debug$9(`Enter the directory: ${directoryPath}`);\n        const { configArrayFactory, extensionRegExp } = internalSlotsMap$4.get(this);\n\n        /** @type {ConfigArray|null} */\n        let config = null;\n\n        // Enumerate the files of this directory.\n        for (const filename of readdirSafeSync(directoryPath)) {\n            const filePath = path$1.join(directoryPath, filename);\n            const stat = statSafeSync(filePath); // TODO: Use `withFileTypes` in the future.\n\n            // Check if the file is matched.\n            if (stat && stat.isFile()) {\n                if (!config) {\n                    config = configArrayFactory.getConfigArrayForFile(\n                        filePath,\n\n                        /*\n                         * We must ignore `ConfigurationNotFoundError` at this\n                         * point because we don't know if target files exist in\n                         * this directory.\n                         */\n                        { ignoreNotFoundError: true }\n                    );\n                }\n                const ignored = this._isIgnoredFile(filePath, { ...options, config });\n                const flag = ignored ? IGNORED_SILENTLY : NONE;\n                const matched = options.selector\n\n                    // Started with a glob pattern; choose by the pattern.\n                    ? options.selector.match(filePath)\n\n                    // Started with a directory path; choose by file extensions.\n                    : extensionRegExp.test(filePath);\n\n                if (matched) {\n                    debug$9(`Yield: ${filename}${ignored ? \" but ignored\" : \"\"}`);\n                    yield {\n                        config: configArrayFactory.getConfigArrayForFile(filePath),\n                        filePath,\n                        flag\n                    };\n                } else {\n                    debug$9(`Didn't match: ${filename}`);\n                }\n\n            // Dive into the sub directory.\n            } else if (options.recursive && stat && stat.isDirectory()) {\n                if (!config) {\n                    config = configArrayFactory.getConfigArrayForFile(\n                        filePath,\n                        { ignoreNotFoundError: true }\n                    );\n                }\n                const ignored = this._isIgnoredFile(\n                    filePath + path$1.sep,\n                    { ...options, config }\n                );\n\n                if (!ignored) {\n                    yield* this._iterateFilesRecursive(filePath, options);\n                }\n            }\n        }\n\n        debug$9(`Leave the directory: ${directoryPath}`);\n    }\n\n    /**\n     * Check if a given file should be ignored.\n     * @param {string} filePath The path to a file to check.\n     * @param {Object} options Options\n     * @param {ConfigArray} [options.config] The config for this file.\n     * @param {boolean} [options.dotfiles] If `true` then this is not ignore dot files by default.\n     * @param {boolean} [options.direct] If `true` then this is a direct specified file.\n     * @returns {boolean} `true` if the file should be ignored.\n     * @private\n     */\n    _isIgnoredFile(filePath, {\n        config: providedConfig,\n        dotfiles = false,\n        direct = false\n    }) {\n        const {\n            configArrayFactory,\n            defaultIgnores,\n            ignoreFlag\n        } = internalSlotsMap$4.get(this);\n\n        if (ignoreFlag) {\n            const config =\n                providedConfig ||\n                configArrayFactory.getConfigArrayForFile(\n                    filePath,\n                    { ignoreNotFoundError: true }\n                );\n            const ignores =\n                config.extractConfig(filePath).ignores || defaultIgnores;\n\n            return ignores(filePath, dotfiles);\n        }\n\n        return !direct && defaultIgnores(filePath, dotfiles);\n    }\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nvar fileEnumerator = { FileEnumerator };\n\nvar imurmurhash = createCommonjsModule(function (module) {\n/**\n * @preserve\n * JS Implementation of incremental MurmurHash3 (r150) (as of May 10, 2013)\n *\n * @author <a href=\"mailto:jensyt@gmail.com\">Jens Taylor</a>\n * @see http://github.com/homebrewing/brauhaus-diff\n * @author <a href=\"mailto:gary.court@gmail.com\">Gary Court</a>\n * @see http://github.com/garycourt/murmurhash-js\n * @author <a href=\"mailto:aappleby@gmail.com\">Austin Appleby</a>\n * @see http://sites.google.com/site/murmurhash/\n */\n(function(){\n    var cache;\n\n    // Call this function without `new` to use the cached object (good for\n    // single-threaded environments), or with `new` to create a new object.\n    //\n    // @param {string} key A UTF-16 or ASCII string\n    // @param {number} seed An optional positive integer\n    // @return {object} A MurmurHash3 object for incremental hashing\n    function MurmurHash3(key, seed) {\n        var m = this instanceof MurmurHash3 ? this : cache;\n        m.reset(seed);\n        if (typeof key === 'string' && key.length > 0) {\n            m.hash(key);\n        }\n\n        if (m !== this) {\n            return m;\n        }\n    }\n    // Incrementally add a string to this hash\n    //\n    // @param {string} key A UTF-16 or ASCII string\n    // @return {object} this\n    MurmurHash3.prototype.hash = function(key) {\n        var h1, k1, i, top, len;\n\n        len = key.length;\n        this.len += len;\n\n        k1 = this.k1;\n        i = 0;\n        switch (this.rem) {\n            case 0: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) : 0;\n            case 1: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) << 8 : 0;\n            case 2: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) << 16 : 0;\n            case 3:\n                k1 ^= len > i ? (key.charCodeAt(i) & 0xff) << 24 : 0;\n                k1 ^= len > i ? (key.charCodeAt(i++) & 0xff00) >> 8 : 0;\n        }\n\n        this.rem = (len + this.rem) & 3; // & 3 is same as % 4\n        len -= this.rem;\n        if (len > 0) {\n            h1 = this.h1;\n            while (1) {\n                k1 = (k1 * 0x2d51 + (k1 & 0xffff) * 0xcc9e0000) & 0xffffffff;\n                k1 = (k1 << 15) | (k1 >>> 17);\n                k1 = (k1 * 0x3593 + (k1 & 0xffff) * 0x1b870000) & 0xffffffff;\n\n                h1 ^= k1;\n                h1 = (h1 << 13) | (h1 >>> 19);\n                h1 = (h1 * 5 + 0xe6546b64) & 0xffffffff;\n\n                if (i >= len) {\n                    break;\n                }\n\n                k1 = ((key.charCodeAt(i++) & 0xffff)) ^\n                     ((key.charCodeAt(i++) & 0xffff) << 8) ^\n                     ((key.charCodeAt(i++) & 0xffff) << 16);\n                top = key.charCodeAt(i++);\n                k1 ^= ((top & 0xff) << 24) ^\n                      ((top & 0xff00) >> 8);\n            }\n\n            k1 = 0;\n            switch (this.rem) {\n                case 3: k1 ^= (key.charCodeAt(i + 2) & 0xffff) << 16;\n                case 2: k1 ^= (key.charCodeAt(i + 1) & 0xffff) << 8;\n                case 1: k1 ^= (key.charCodeAt(i) & 0xffff);\n            }\n\n            this.h1 = h1;\n        }\n\n        this.k1 = k1;\n        return this;\n    };\n\n    // Get the result of this hash\n    //\n    // @return {number} The 32-bit hash\n    MurmurHash3.prototype.result = function() {\n        var k1, h1;\n        \n        k1 = this.k1;\n        h1 = this.h1;\n\n        if (k1 > 0) {\n            k1 = (k1 * 0x2d51 + (k1 & 0xffff) * 0xcc9e0000) & 0xffffffff;\n            k1 = (k1 << 15) | (k1 >>> 17);\n            k1 = (k1 * 0x3593 + (k1 & 0xffff) * 0x1b870000) & 0xffffffff;\n            h1 ^= k1;\n        }\n\n        h1 ^= this.len;\n\n        h1 ^= h1 >>> 16;\n        h1 = (h1 * 0xca6b + (h1 & 0xffff) * 0x85eb0000) & 0xffffffff;\n        h1 ^= h1 >>> 13;\n        h1 = (h1 * 0xae35 + (h1 & 0xffff) * 0xc2b20000) & 0xffffffff;\n        h1 ^= h1 >>> 16;\n\n        return h1 >>> 0;\n    };\n\n    // Reset the hash object for reuse\n    //\n    // @param {number} seed An optional positive integer\n    MurmurHash3.prototype.reset = function(seed) {\n        this.h1 = typeof seed === 'number' ? seed : 0;\n        this.rem = this.k1 = this.len = 0;\n        return this;\n    };\n\n    // A cached object to use. This can be safely used if you're in a single-\n    // threaded environment, otherwise you need to create new hashes to use.\n    cache = new MurmurHash3();\n\n    {\n        module.exports = MurmurHash3;\n    }\n}());\n});\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n//------------------------------------------------------------------------------\n// Private\n//------------------------------------------------------------------------------\n\n/**\n * hash the given string\n * @param  {string} str the string to hash\n * @returns {string}    the hash\n */\nfunction hash(str) {\n    return imurmurhash(str).result().toString(36);\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nvar hash_1 = hash;\n\nvar _0777 = parseInt('0777', 8);\n\nvar mkdirp = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;\n\nfunction mkdirP (p, opts, f, made) {\n    if (typeof opts === 'function') {\n        f = opts;\n        opts = {};\n    }\n    else if (!opts || typeof opts !== 'object') {\n        opts = { mode: opts };\n    }\n    \n    var mode = opts.mode;\n    var xfs = opts.fs || fs$2;\n    \n    if (mode === undefined) {\n        mode = _0777;\n    }\n    if (!made) made = null;\n    \n    var cb = f || function () {};\n    p = path$1.resolve(p);\n    \n    xfs.mkdir(p, mode, function (er) {\n        if (!er) {\n            made = made || p;\n            return cb(null, made);\n        }\n        switch (er.code) {\n            case 'ENOENT':\n                if (path$1.dirname(p) === p) return cb(er);\n                mkdirP(path$1.dirname(p), opts, function (er, made) {\n                    if (er) cb(er, made);\n                    else mkdirP(p, opts, cb, made);\n                });\n                break;\n\n            // In the case of any other error, just see if there's a dir\n            // there already.  If so, then hooray!  If not, then something\n            // is borked.\n            default:\n                xfs.stat(p, function (er2, stat) {\n                    // if the stat fails, then that's super weird.\n                    // let the original error be the failure reason.\n                    if (er2 || !stat.isDirectory()) cb(er, made);\n                    else cb(null, made);\n                });\n                break;\n        }\n    });\n}\n\nmkdirP.sync = function sync (p, opts, made) {\n    if (!opts || typeof opts !== 'object') {\n        opts = { mode: opts };\n    }\n    \n    var mode = opts.mode;\n    var xfs = opts.fs || fs$2;\n    \n    if (mode === undefined) {\n        mode = _0777;\n    }\n    if (!made) made = null;\n\n    p = path$1.resolve(p);\n\n    try {\n        xfs.mkdirSync(p, mode);\n        made = made || p;\n    }\n    catch (err0) {\n        switch (err0.code) {\n            case 'ENOENT' :\n                made = sync(path$1.dirname(p), opts, made);\n                sync(p, opts, made);\n                break;\n\n            // In the case of any other error, just see if there's a dir\n            // there already.  If so, then hooray!  If not, then something\n            // is borked.\n            default:\n                var stat;\n                try {\n                    stat = xfs.statSync(p);\n                }\n                catch (err1) {\n                    throw err0;\n                }\n                if (!stat.isDirectory()) throw err0;\n                break;\n        }\n    }\n\n    return made;\n};\n\n/**\n * Asynchronously writes data to a file, replacing the file if it already\n * exists and creating any intermediate directories if they don't already\n * exist. Data can be a string or a buffer. Returns a promise if a callback\n * function is not passed.\n *\n * ```js\n * var writeFile = require('write');\n * writeFile('foo.txt', 'This is content...', function(err) {\n *   if (err) console.log(err);\n * });\n *\n * // promise\n * writeFile('foo.txt', 'This is content...')\n *   .then(function() {\n *     // do stuff\n *   });\n * ```\n * @name writeFile\n * @param {string|Buffer|integer} `filepath` filepath or file descriptor.\n * @param {string|Buffer|Uint8Array} `data` String to write to disk.\n * @param {object} `options` Options to pass to [fs.writeFile][fs]{#fs_fs_writefile_file_data_options_callback} and/or [mkdirp][]\n * @param {Function} `callback` (optional) If no callback is provided, a promise is returned.\n * @api public\n */\n\nfunction writeFile(filepath, data, options, cb) {\n  if (typeof options === 'function') {\n    cb = options;\n    options = {};\n  }\n\n  if (typeof cb !== 'function') {\n    return writeFile.promise.apply(null, arguments);\n  }\n\n  if (typeof filepath !== 'string') {\n    cb(new TypeError('expected filepath to be a string'));\n    return;\n  }\n\n  mkdirp(path$1.dirname(filepath), options, function(err) {\n    if (err) {\n      cb(err);\n      return;\n    }\n    fs$2.writeFile(filepath, data, options, cb);\n  });\n}\n/**\n * The promise version of [writeFile](#writefile). Returns a promise.\n *\n * ```js\n * var writeFile = require('write');\n * writeFile.promise('foo.txt', 'This is content...')\n *   .then(function() {\n *     // do stuff\n *   });\n * ```\n * @name .promise\n * @param {string|Buffer|integer} `filepath` filepath or file descriptor.\n * @param {string|Buffer|Uint8Array} `val` String or buffer to write to disk.\n * @param {object} `options` Options to pass to [fs.writeFile][fs]{#fs_fs_writefile_file_data_options_callback} and/or [mkdirp][]\n * @return {Promise}\n * @api public\n */\n\nwriteFile.promise = function(filepath, val, options) {\n  if (typeof filepath !== 'string') {\n    return Promise.reject(new TypeError('expected filepath to be a string'));\n  }\n\n  return new Promise(function(resolve, reject) {\n    mkdirp(path$1.dirname(filepath), options, function(err) {\n      if (err) {\n        reject(err);\n        return;\n      }\n\n      fs$2.writeFile(filepath, val, options, function(err) {\n        if (err) {\n          reject(err);\n          return;\n        }\n        resolve(val);\n      });\n    });\n  });\n};\n\n/**\n * The synchronous version of [writeFile](#writefile). Returns undefined.\n *\n * ```js\n * var writeFile = require('write');\n * writeFile.sync('foo.txt', 'This is content...');\n * ```\n * @name .sync\n * @param {string|Buffer|integer} `filepath` filepath or file descriptor.\n * @param {string|Buffer|Uint8Array} `data` String or buffer to write to disk.\n * @param {object} `options` Options to pass to [fs.writeFileSync][fs]{#fs_fs_writefilesync_file_data_options} and/or [mkdirp][]\n * @return {undefined}\n * @api public\n */\n\nwriteFile.sync = function(filepath, data, options) {\n  if (typeof filepath !== 'string') {\n    throw new TypeError('expected filepath to be a string');\n  }\n  mkdirp.sync(path$1.dirname(filepath), options);\n  fs$2.writeFileSync(filepath, data, options);\n};\n\n/**\n * Uses `fs.createWriteStream` to write data to a file, replacing the\n * file if it already exists and creating any intermediate directories\n * if they don't already exist. Data can be a string or a buffer. Returns\n * a new [WriteStream](https://nodejs.org/api/fs.html#fs_class_fs_writestream)\n * object.\n *\n * ```js\n * var fs = require('fs');\n * var writeFile = require('write');\n * fs.createReadStream('README.md')\n *   .pipe(writeFile.stream('a/b/c/other-file.md'))\n *   .on('close', function() {\n *     // do stuff\n *   });\n * ```\n * @name .stream\n * @param {string|Buffer|integer} `filepath` filepath or file descriptor.\n * @param {object} `options` Options to pass to [mkdirp][] and [fs.createWriteStream][fs]{#fs_fs_createwritestream_path_options}\n * @return {Stream} Returns a new [WriteStream](https://nodejs.org/api/fs.html#fs_class_fs_writestream) object. (See [Writable Stream](https://nodejs.org/api/stream.html#stream_class_stream_writable)).\n * @api public\n */\n\nwriteFile.stream = function(filepath, options) {\n  mkdirp.sync(path$1.dirname(filepath), options);\n  return fs$2.createWriteStream(filepath, options);\n};\n\n/**\n * Expose `writeFile`\n */\n\nvar write = writeFile;\n\nvar Flatted = (function (Primitive, primitive) {\n\n  /*!\n   * ISC License\n   *\n   * Copyright (c) 2018, Andrea Giammarchi, @WebReflection\n   *\n   * Permission to use, copy, modify, and/or distribute this software for any\n   * purpose with or without fee is hereby granted, provided that the above\n   * copyright notice and this permission notice appear in all copies.\n   *\n   * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n   * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\n   * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n   * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n   * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE\n   * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n   * PERFORMANCE OF THIS SOFTWARE.\n   */\n\n  var Flatted = {\n\n    parse: function parse(text, reviver) {\n      var input = JSON.parse(text, Primitives).map(primitives);\n      var value = input[0];\n      var $ = reviver || noop;\n      var tmp = typeof value === 'object' && value ?\n                  revive(input, new Set, value, $) :\n                  value;\n      return $.call({'': tmp}, '', tmp);\n    },\n\n    stringify: function stringify(value, replacer, space) {\n      for (var\n        firstRun,\n        known = new Map,\n        input = [],\n        output = [],\n        $ = replacer && typeof replacer === typeof input ?\n              function (k, v) {\n                if (k === '' || -1 < replacer.indexOf(k)) return v;\n              } :\n              (replacer || noop),\n        i = +set(known, input, $.call({'': value}, '', value)),\n        replace = function (key, value) {\n          if (firstRun) {\n            firstRun = !firstRun;\n            return value;\n          }\n          var after = $.call(this, key, value);\n          switch (typeof after) {\n            case 'object':\n              if (after === null) return after;\n            case primitive:\n              return known.get(after) || set(known, input, after);\n          }\n          return after;\n        };\n        i < input.length; i++\n      ) {\n        firstRun = true;\n        output[i] = JSON.stringify(input[i], replace, space);\n      }\n      return '[' + output.join(',') + ']';\n    }\n\n  };\n\n  return Flatted;\n\n  function noop(key, value) {\n    return value;\n  }\n\n  function revive(input, parsed, output, $) {\n    return Object.keys(output).reduce(\n      function (output, key) {\n        var value = output[key];\n        if (value instanceof Primitive) {\n          var tmp = input[value];\n          if (typeof tmp === 'object' && !parsed.has(tmp)) {\n            parsed.add(tmp);\n            output[key] = $.call(output, key, revive(input, parsed, tmp, $));\n          } else {\n            output[key] = $.call(output, key, tmp);\n          }\n        } else\n          output[key] = $.call(output, key, value);\n        return output;\n      },\n      output\n    );\n  }\n\n  function set(known, input, value) {\n    var index = Primitive(input.push(value) - 1);\n    known.set(value, index);\n    return index;\n  }\n\n  // the two kinds of primitives\n  //  1. the real one\n  //  2. the wrapped one\n\n  function primitives(value) {\n    return value instanceof Primitive ? Primitive(value) : value;\n  }\n\n  function Primitives(key, value) {\n    return typeof value === primitive ? new Primitive(value) : value;\n  }\n\n}(String, 'string'));\nvar parse$6 = Flatted.parse;\nvar stringify = Flatted.stringify;\n\nvar utils$2 = {\n  tryParse: function ( filePath, defaultValue ) {\n    var result;\n    try {\n      result = this.readJSON( filePath );\n    } catch (ex) {\n      result = defaultValue;\n    }\n    return result;\n  },\n\n  /**\n   * Read json file synchronously using flatted\n   *\n   * @method readJSON\n   * @param  {String} filePath Json filepath\n   * @returns {*} parse result\n   */\n  readJSON: function ( filePath ) {\n    return Flatted.parse( fs$2.readFileSync( filePath, {\n      encoding: 'utf8'\n    } ) );\n  },\n\n  /**\n   * Write json file synchronously using circular-json\n   *\n   * @method writeJSON\n   * @param  {String} filePath Json filepath\n   * @param  {*} data Object to serialize\n   */\n  writeJSON: function ( filePath, data ) {\n    write.sync( filePath, Flatted.stringify( data ) );\n  }\n};\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\nvar isWindows = process.platform === 'win32';\n\n\n// JavaScript implementation of realpath, ported from node pre-v6\n\nvar DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);\n\nfunction rethrow() {\n  // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and\n  // is fairly slow to generate.\n  var callback;\n  if (DEBUG) {\n    var backtrace = new Error;\n    callback = debugCallback;\n  } else\n    callback = missingCallback;\n\n  return callback;\n\n  function debugCallback(err) {\n    if (err) {\n      backtrace.message = err.message;\n      err = backtrace;\n      missingCallback(err);\n    }\n  }\n\n  function missingCallback(err) {\n    if (err) {\n      if (process.throwDeprecation)\n        throw err;  // Forgot a callback but don't know where? Use NODE_DEBUG=fs\n      else if (!process.noDeprecation) {\n        var msg = 'fs: missing callback ' + (err.stack || err.message);\n        if (process.traceDeprecation)\n          console.trace(msg);\n        else\n          console.error(msg);\n      }\n    }\n  }\n}\n\nfunction maybeCallback(cb) {\n  return typeof cb === 'function' ? cb : rethrow();\n}\n\nvar normalize = path$1.normalize;\n\n// Regexp that finds the next partion of a (partial) path\n// result is [base_with_slash, base], e.g. ['somedir/', 'somedir']\nif (isWindows) {\n  var nextPartRe = /(.*?)(?:[\\/\\\\]+|$)/g;\n} else {\n  var nextPartRe = /(.*?)(?:[\\/]+|$)/g;\n}\n\n// Regex to find the device root, including trailing slash. E.g. 'c:\\\\'.\nif (isWindows) {\n  var splitRootRe = /^(?:[a-zA-Z]:|[\\\\\\/]{2}[^\\\\\\/]+[\\\\\\/][^\\\\\\/]+)?[\\\\\\/]*/;\n} else {\n  var splitRootRe = /^[\\/]*/;\n}\n\nvar realpathSync = function realpathSync(p, cache) {\n  // make p is absolute\n  p = path$1.resolve(p);\n\n  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {\n    return cache[p];\n  }\n\n  var original = p,\n      seenLinks = {},\n      knownHard = {};\n\n  // current character position in p\n  var pos;\n  // the partial path so far, including a trailing slash if any\n  var current;\n  // the partial path without a trailing slash (except when pointing at a root)\n  var base;\n  // the partial path scanned in the previous round, with slash\n  var previous;\n\n  start();\n\n  function start() {\n    // Skip over roots\n    var m = splitRootRe.exec(p);\n    pos = m[0].length;\n    current = m[0];\n    base = m[0];\n    previous = '';\n\n    // On windows, check that the root exists. On unix there is no need.\n    if (isWindows && !knownHard[base]) {\n      fs$2.lstatSync(base);\n      knownHard[base] = true;\n    }\n  }\n\n  // walk down the path, swapping out linked pathparts for their real\n  // values\n  // NB: p.length changes.\n  while (pos < p.length) {\n    // find the next part\n    nextPartRe.lastIndex = pos;\n    var result = nextPartRe.exec(p);\n    previous = current;\n    current += result[0];\n    base = previous + result[1];\n    pos = nextPartRe.lastIndex;\n\n    // continue if not a symlink\n    if (knownHard[base] || (cache && cache[base] === base)) {\n      continue;\n    }\n\n    var resolvedLink;\n    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {\n      // some known symbolic link.  no need to stat again.\n      resolvedLink = cache[base];\n    } else {\n      var stat = fs$2.lstatSync(base);\n      if (!stat.isSymbolicLink()) {\n        knownHard[base] = true;\n        if (cache) cache[base] = base;\n        continue;\n      }\n\n      // read the link if it wasn't read before\n      // dev/ino always return 0 on windows, so skip the check.\n      var linkTarget = null;\n      if (!isWindows) {\n        var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);\n        if (seenLinks.hasOwnProperty(id)) {\n          linkTarget = seenLinks[id];\n        }\n      }\n      if (linkTarget === null) {\n        fs$2.statSync(base);\n        linkTarget = fs$2.readlinkSync(base);\n      }\n      resolvedLink = path$1.resolve(previous, linkTarget);\n      // track this, if given a cache.\n      if (cache) cache[base] = resolvedLink;\n      if (!isWindows) seenLinks[id] = linkTarget;\n    }\n\n    // resolve the link, then start over\n    p = path$1.resolve(resolvedLink, p.slice(pos));\n    start();\n  }\n\n  if (cache) cache[original] = p;\n\n  return p;\n};\n\n\nvar realpath = function realpath(p, cache, cb) {\n  if (typeof cb !== 'function') {\n    cb = maybeCallback(cache);\n    cache = null;\n  }\n\n  // make p is absolute\n  p = path$1.resolve(p);\n\n  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {\n    return process.nextTick(cb.bind(null, null, cache[p]));\n  }\n\n  var original = p,\n      seenLinks = {},\n      knownHard = {};\n\n  // current character position in p\n  var pos;\n  // the partial path so far, including a trailing slash if any\n  var current;\n  // the partial path without a trailing slash (except when pointing at a root)\n  var base;\n  // the partial path scanned in the previous round, with slash\n  var previous;\n\n  start();\n\n  function start() {\n    // Skip over roots\n    var m = splitRootRe.exec(p);\n    pos = m[0].length;\n    current = m[0];\n    base = m[0];\n    previous = '';\n\n    // On windows, check that the root exists. On unix there is no need.\n    if (isWindows && !knownHard[base]) {\n      fs$2.lstat(base, function(err) {\n        if (err) return cb(err);\n        knownHard[base] = true;\n        LOOP();\n      });\n    } else {\n      process.nextTick(LOOP);\n    }\n  }\n\n  // walk down the path, swapping out linked pathparts for their real\n  // values\n  function LOOP() {\n    // stop if scanned past end of path\n    if (pos >= p.length) {\n      if (cache) cache[original] = p;\n      return cb(null, p);\n    }\n\n    // find the next part\n    nextPartRe.lastIndex = pos;\n    var result = nextPartRe.exec(p);\n    previous = current;\n    current += result[0];\n    base = previous + result[1];\n    pos = nextPartRe.lastIndex;\n\n    // continue if not a symlink\n    if (knownHard[base] || (cache && cache[base] === base)) {\n      return process.nextTick(LOOP);\n    }\n\n    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {\n      // known symbolic link.  no need to stat again.\n      return gotResolvedLink(cache[base]);\n    }\n\n    return fs$2.lstat(base, gotStat);\n  }\n\n  function gotStat(err, stat) {\n    if (err) return cb(err);\n\n    // if not a symlink, skip to the next path part\n    if (!stat.isSymbolicLink()) {\n      knownHard[base] = true;\n      if (cache) cache[base] = base;\n      return process.nextTick(LOOP);\n    }\n\n    // stat & read the link if not read before\n    // call gotTarget as soon as the link target is known\n    // dev/ino always return 0 on windows, so skip the check.\n    if (!isWindows) {\n      var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);\n      if (seenLinks.hasOwnProperty(id)) {\n        return gotTarget(null, seenLinks[id], base);\n      }\n    }\n    fs$2.stat(base, function(err) {\n      if (err) return cb(err);\n\n      fs$2.readlink(base, function(err, target) {\n        if (!isWindows) seenLinks[id] = target;\n        gotTarget(err, target);\n      });\n    });\n  }\n\n  function gotTarget(err, target, base) {\n    if (err) return cb(err);\n\n    var resolvedLink = path$1.resolve(previous, target);\n    if (cache) cache[base] = resolvedLink;\n    gotResolvedLink(resolvedLink);\n  }\n\n  function gotResolvedLink(resolvedLink) {\n    // resolve the link, then start over\n    p = path$1.resolve(resolvedLink, p.slice(pos));\n    start();\n  }\n};\n\nvar old = {\n\trealpathSync: realpathSync,\n\trealpath: realpath\n};\n\nvar fs_realpath = realpath$1;\nrealpath$1.realpath = realpath$1;\nrealpath$1.sync = realpathSync$1;\nrealpath$1.realpathSync = realpathSync$1;\nrealpath$1.monkeypatch = monkeypatch;\nrealpath$1.unmonkeypatch = unmonkeypatch;\n\n\nvar origRealpath = fs$2.realpath;\nvar origRealpathSync = fs$2.realpathSync;\n\nvar version$9 = process.version;\nvar ok = /^v[0-5]\\./.test(version$9);\n\n\nfunction newError (er) {\n  return er && er.syscall === 'realpath' && (\n    er.code === 'ELOOP' ||\n    er.code === 'ENOMEM' ||\n    er.code === 'ENAMETOOLONG'\n  )\n}\n\nfunction realpath$1 (p, cache, cb) {\n  if (ok) {\n    return origRealpath(p, cache, cb)\n  }\n\n  if (typeof cache === 'function') {\n    cb = cache;\n    cache = null;\n  }\n  origRealpath(p, cache, function (er, result) {\n    if (newError(er)) {\n      old.realpath(p, cache, cb);\n    } else {\n      cb(er, result);\n    }\n  });\n}\n\nfunction realpathSync$1 (p, cache) {\n  if (ok) {\n    return origRealpathSync(p, cache)\n  }\n\n  try {\n    return origRealpathSync(p, cache)\n  } catch (er) {\n    if (newError(er)) {\n      return old.realpathSync(p, cache)\n    } else {\n      throw er\n    }\n  }\n}\n\nfunction monkeypatch () {\n  fs$2.realpath = realpath$1;\n  fs$2.realpathSync = realpathSync$1;\n}\n\nfunction unmonkeypatch () {\n  fs$2.realpath = origRealpath;\n  fs$2.realpathSync = origRealpathSync;\n}\n\nvar inherits_browser = createCommonjsModule(function (module) {\nif (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor;\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      });\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor;\n      var TempCtor = function () {};\n      TempCtor.prototype = superCtor.prototype;\n      ctor.prototype = new TempCtor();\n      ctor.prototype.constructor = ctor;\n    }\n  };\n}\n});\n\nvar inherits = createCommonjsModule(function (module) {\ntry {\n  var util = util$2;\n  /* istanbul ignore next */\n  if (typeof util.inherits !== 'function') throw '';\n  module.exports = util.inherits;\n} catch (e) {\n  /* istanbul ignore next */\n  module.exports = inherits_browser;\n}\n});\n\nfunction posix(path) {\n\treturn path.charAt(0) === '/';\n}\n\nfunction win32(path) {\n\t// https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56\n\tvar splitDeviceRe = /^([a-zA-Z]:|[\\\\\\/]{2}[^\\\\\\/]+[\\\\\\/]+[^\\\\\\/]+)?([\\\\\\/])?([\\s\\S]*?)$/;\n\tvar result = splitDeviceRe.exec(path);\n\tvar device = result[1] || '';\n\tvar isUnc = Boolean(device && device.charAt(1) !== ':');\n\n\t// UNC paths are always absolute\n\treturn Boolean(result[2] || isUnc);\n}\n\nvar pathIsAbsolute = process.platform === 'win32' ? win32 : posix;\nvar posix_1 = posix;\nvar win32_1 = win32;\npathIsAbsolute.posix = posix_1;\npathIsAbsolute.win32 = win32_1;\n\nvar alphasort_1 = alphasort;\nvar alphasorti_1 = alphasorti;\nvar setopts_1 = setopts;\nvar ownProp_1 = ownProp;\nvar makeAbs_1 = makeAbs;\nvar finish_1 = finish;\nvar mark_1 = mark$1;\nvar isIgnored_1 = isIgnored;\nvar childrenIgnored_1 = childrenIgnored;\n\nfunction ownProp (obj, field) {\n  return Object.prototype.hasOwnProperty.call(obj, field)\n}\n\n\n\n\nvar Minimatch$3 = minimatch_1.Minimatch;\n\nfunction alphasorti (a, b) {\n  return a.toLowerCase().localeCompare(b.toLowerCase())\n}\n\nfunction alphasort (a, b) {\n  return a.localeCompare(b)\n}\n\nfunction setupIgnores (self, options) {\n  self.ignore = options.ignore || [];\n\n  if (!Array.isArray(self.ignore))\n    self.ignore = [self.ignore];\n\n  if (self.ignore.length) {\n    self.ignore = self.ignore.map(ignoreMap);\n  }\n}\n\n// ignore patterns are always in dot:true mode.\nfunction ignoreMap (pattern) {\n  var gmatcher = null;\n  if (pattern.slice(-3) === '/**') {\n    var gpattern = pattern.replace(/(\\/\\*\\*)+$/, '');\n    gmatcher = new Minimatch$3(gpattern, { dot: true });\n  }\n\n  return {\n    matcher: new Minimatch$3(pattern, { dot: true }),\n    gmatcher: gmatcher\n  }\n}\n\nfunction setopts (self, pattern, options) {\n  if (!options)\n    options = {};\n\n  // base-matching: just use globstar for that.\n  if (options.matchBase && -1 === pattern.indexOf(\"/\")) {\n    if (options.noglobstar) {\n      throw new Error(\"base matching requires globstar\")\n    }\n    pattern = \"**/\" + pattern;\n  }\n\n  self.silent = !!options.silent;\n  self.pattern = pattern;\n  self.strict = options.strict !== false;\n  self.realpath = !!options.realpath;\n  self.realpathCache = options.realpathCache || Object.create(null);\n  self.follow = !!options.follow;\n  self.dot = !!options.dot;\n  self.mark = !!options.mark;\n  self.nodir = !!options.nodir;\n  if (self.nodir)\n    self.mark = true;\n  self.sync = !!options.sync;\n  self.nounique = !!options.nounique;\n  self.nonull = !!options.nonull;\n  self.nosort = !!options.nosort;\n  self.nocase = !!options.nocase;\n  self.stat = !!options.stat;\n  self.noprocess = !!options.noprocess;\n  self.absolute = !!options.absolute;\n\n  self.maxLength = options.maxLength || Infinity;\n  self.cache = options.cache || Object.create(null);\n  self.statCache = options.statCache || Object.create(null);\n  self.symlinks = options.symlinks || Object.create(null);\n\n  setupIgnores(self, options);\n\n  self.changedCwd = false;\n  var cwd = process.cwd();\n  if (!ownProp(options, \"cwd\"))\n    self.cwd = cwd;\n  else {\n    self.cwd = path$1.resolve(options.cwd);\n    self.changedCwd = self.cwd !== cwd;\n  }\n\n  self.root = options.root || path$1.resolve(self.cwd, \"/\");\n  self.root = path$1.resolve(self.root);\n  if (process.platform === \"win32\")\n    self.root = self.root.replace(/\\\\/g, \"/\");\n\n  // TODO: is an absolute `cwd` supposed to be resolved against `root`?\n  // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')\n  self.cwdAbs = pathIsAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);\n  if (process.platform === \"win32\")\n    self.cwdAbs = self.cwdAbs.replace(/\\\\/g, \"/\");\n  self.nomount = !!options.nomount;\n\n  // disable comments and negation in Minimatch.\n  // Note that they are not supported in Glob itself anyway.\n  options.nonegate = true;\n  options.nocomment = true;\n\n  self.minimatch = new Minimatch$3(pattern, options);\n  self.options = self.minimatch.options;\n}\n\nfunction finish (self) {\n  var nou = self.nounique;\n  var all = nou ? [] : Object.create(null);\n\n  for (var i = 0, l = self.matches.length; i < l; i ++) {\n    var matches = self.matches[i];\n    if (!matches || Object.keys(matches).length === 0) {\n      if (self.nonull) {\n        // do like the shell, and spit out the literal glob\n        var literal = self.minimatch.globSet[i];\n        if (nou)\n          all.push(literal);\n        else\n          all[literal] = true;\n      }\n    } else {\n      // had matches\n      var m = Object.keys(matches);\n      if (nou)\n        all.push.apply(all, m);\n      else\n        m.forEach(function (m) {\n          all[m] = true;\n        });\n    }\n  }\n\n  if (!nou)\n    all = Object.keys(all);\n\n  if (!self.nosort)\n    all = all.sort(self.nocase ? alphasorti : alphasort);\n\n  // at *some* point we statted all of these\n  if (self.mark) {\n    for (var i = 0; i < all.length; i++) {\n      all[i] = self._mark(all[i]);\n    }\n    if (self.nodir) {\n      all = all.filter(function (e) {\n        var notDir = !(/\\/$/.test(e));\n        var c = self.cache[e] || self.cache[makeAbs(self, e)];\n        if (notDir && c)\n          notDir = c !== 'DIR' && !Array.isArray(c);\n        return notDir\n      });\n    }\n  }\n\n  if (self.ignore.length)\n    all = all.filter(function(m) {\n      return !isIgnored(self, m)\n    });\n\n  self.found = all;\n}\n\nfunction mark$1 (self, p) {\n  var abs = makeAbs(self, p);\n  var c = self.cache[abs];\n  var m = p;\n  if (c) {\n    var isDir = c === 'DIR' || Array.isArray(c);\n    var slash = p.slice(-1) === '/';\n\n    if (isDir && !slash)\n      m += '/';\n    else if (!isDir && slash)\n      m = m.slice(0, -1);\n\n    if (m !== p) {\n      var mabs = makeAbs(self, m);\n      self.statCache[mabs] = self.statCache[abs];\n      self.cache[mabs] = self.cache[abs];\n    }\n  }\n\n  return m\n}\n\n// lotta situps...\nfunction makeAbs (self, f) {\n  var abs = f;\n  if (f.charAt(0) === '/') {\n    abs = path$1.join(self.root, f);\n  } else if (pathIsAbsolute(f) || f === '') {\n    abs = f;\n  } else if (self.changedCwd) {\n    abs = path$1.resolve(self.cwd, f);\n  } else {\n    abs = path$1.resolve(f);\n  }\n\n  if (process.platform === 'win32')\n    abs = abs.replace(/\\\\/g, '/');\n\n  return abs\n}\n\n\n// Return true, if pattern ends with globstar '**', for the accompanying parent directory.\n// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents\nfunction isIgnored (self, path) {\n  if (!self.ignore.length)\n    return false\n\n  return self.ignore.some(function(item) {\n    return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path))\n  })\n}\n\nfunction childrenIgnored (self, path) {\n  if (!self.ignore.length)\n    return false\n\n  return self.ignore.some(function(item) {\n    return !!(item.gmatcher && item.gmatcher.match(path))\n  })\n}\n\nvar common$2 = {\n\talphasort: alphasort_1,\n\talphasorti: alphasorti_1,\n\tsetopts: setopts_1,\n\townProp: ownProp_1,\n\tmakeAbs: makeAbs_1,\n\tfinish: finish_1,\n\tmark: mark_1,\n\tisIgnored: isIgnored_1,\n\tchildrenIgnored: childrenIgnored_1\n};\n\nvar sync = globSync;\nglobSync.GlobSync = GlobSync;\nvar setopts$1 = common$2.setopts;\nvar ownProp$1 = common$2.ownProp;\nvar childrenIgnored$1 = common$2.childrenIgnored;\nvar isIgnored$1 = common$2.isIgnored;\n\nfunction globSync (pattern, options) {\n  if (typeof options === 'function' || arguments.length === 3)\n    throw new TypeError('callback provided to sync glob\\n'+\n                        'See: https://github.com/isaacs/node-glob/issues/167')\n\n  return new GlobSync(pattern, options).found\n}\n\nfunction GlobSync (pattern, options) {\n  if (!pattern)\n    throw new Error('must provide pattern')\n\n  if (typeof options === 'function' || arguments.length === 3)\n    throw new TypeError('callback provided to sync glob\\n'+\n                        'See: https://github.com/isaacs/node-glob/issues/167')\n\n  if (!(this instanceof GlobSync))\n    return new GlobSync(pattern, options)\n\n  setopts$1(this, pattern, options);\n\n  if (this.noprocess)\n    return this\n\n  var n = this.minimatch.set.length;\n  this.matches = new Array(n);\n  for (var i = 0; i < n; i ++) {\n    this._process(this.minimatch.set[i], i, false);\n  }\n  this._finish();\n}\n\nGlobSync.prototype._finish = function () {\n  assert(this instanceof GlobSync);\n  if (this.realpath) {\n    var self = this;\n    this.matches.forEach(function (matchset, index) {\n      var set = self.matches[index] = Object.create(null);\n      for (var p in matchset) {\n        try {\n          p = self._makeAbs(p);\n          var real = fs_realpath.realpathSync(p, self.realpathCache);\n          set[real] = true;\n        } catch (er) {\n          if (er.syscall === 'stat')\n            set[self._makeAbs(p)] = true;\n          else\n            throw er\n        }\n      }\n    });\n  }\n  common$2.finish(this);\n};\n\n\nGlobSync.prototype._process = function (pattern, index, inGlobStar) {\n  assert(this instanceof GlobSync);\n\n  // Get the first [n] parts of pattern that are all strings.\n  var n = 0;\n  while (typeof pattern[n] === 'string') {\n    n ++;\n  }\n  // now n is the index of the first one that is *not* a string.\n\n  // See if there's anything else\n  var prefix;\n  switch (n) {\n    // if not, then this is rather simple\n    case pattern.length:\n      this._processSimple(pattern.join('/'), index);\n      return\n\n    case 0:\n      // pattern *starts* with some non-trivial item.\n      // going to readdir(cwd), but not include the prefix in matches.\n      prefix = null;\n      break\n\n    default:\n      // pattern has some string bits in the front.\n      // whatever it starts with, whether that's 'absolute' like /foo/bar,\n      // or 'relative' like '../baz'\n      prefix = pattern.slice(0, n).join('/');\n      break\n  }\n\n  var remain = pattern.slice(n);\n\n  // get the list of entries.\n  var read;\n  if (prefix === null)\n    read = '.';\n  else if (pathIsAbsolute(prefix) || pathIsAbsolute(pattern.join('/'))) {\n    if (!prefix || !pathIsAbsolute(prefix))\n      prefix = '/' + prefix;\n    read = prefix;\n  } else\n    read = prefix;\n\n  var abs = this._makeAbs(read);\n\n  //if ignored, skip processing\n  if (childrenIgnored$1(this, read))\n    return\n\n  var isGlobStar = remain[0] === minimatch_1.GLOBSTAR;\n  if (isGlobStar)\n    this._processGlobStar(prefix, read, abs, remain, index, inGlobStar);\n  else\n    this._processReaddir(prefix, read, abs, remain, index, inGlobStar);\n};\n\n\nGlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) {\n  var entries = this._readdir(abs, inGlobStar);\n\n  // if the abs isn't a dir, then nothing can match!\n  if (!entries)\n    return\n\n  // It will only match dot entries if it starts with a dot, or if\n  // dot is set.  Stuff like @(.foo|.bar) isn't allowed.\n  var pn = remain[0];\n  var negate = !!this.minimatch.negate;\n  var rawGlob = pn._glob;\n  var dotOk = this.dot || rawGlob.charAt(0) === '.';\n\n  var matchedEntries = [];\n  for (var i = 0; i < entries.length; i++) {\n    var e = entries[i];\n    if (e.charAt(0) !== '.' || dotOk) {\n      var m;\n      if (negate && !prefix) {\n        m = !e.match(pn);\n      } else {\n        m = e.match(pn);\n      }\n      if (m)\n        matchedEntries.push(e);\n    }\n  }\n\n  var len = matchedEntries.length;\n  // If there are no matched entries, then nothing matches.\n  if (len === 0)\n    return\n\n  // if this is the last remaining pattern bit, then no need for\n  // an additional stat *unless* the user has specified mark or\n  // stat explicitly.  We know they exist, since readdir returned\n  // them.\n\n  if (remain.length === 1 && !this.mark && !this.stat) {\n    if (!this.matches[index])\n      this.matches[index] = Object.create(null);\n\n    for (var i = 0; i < len; i ++) {\n      var e = matchedEntries[i];\n      if (prefix) {\n        if (prefix.slice(-1) !== '/')\n          e = prefix + '/' + e;\n        else\n          e = prefix + e;\n      }\n\n      if (e.charAt(0) === '/' && !this.nomount) {\n        e = path$1.join(this.root, e);\n      }\n      this._emitMatch(index, e);\n    }\n    // This was the last one, and no stats were needed\n    return\n  }\n\n  // now test all matched entries as stand-ins for that part\n  // of the pattern.\n  remain.shift();\n  for (var i = 0; i < len; i ++) {\n    var e = matchedEntries[i];\n    var newPattern;\n    if (prefix)\n      newPattern = [prefix, e];\n    else\n      newPattern = [e];\n    this._process(newPattern.concat(remain), index, inGlobStar);\n  }\n};\n\n\nGlobSync.prototype._emitMatch = function (index, e) {\n  if (isIgnored$1(this, e))\n    return\n\n  var abs = this._makeAbs(e);\n\n  if (this.mark)\n    e = this._mark(e);\n\n  if (this.absolute) {\n    e = abs;\n  }\n\n  if (this.matches[index][e])\n    return\n\n  if (this.nodir) {\n    var c = this.cache[abs];\n    if (c === 'DIR' || Array.isArray(c))\n      return\n  }\n\n  this.matches[index][e] = true;\n\n  if (this.stat)\n    this._stat(e);\n};\n\n\nGlobSync.prototype._readdirInGlobStar = function (abs) {\n  // follow all symlinked directories forever\n  // just proceed as if this is a non-globstar situation\n  if (this.follow)\n    return this._readdir(abs, false)\n\n  var entries;\n  var lstat;\n  try {\n    lstat = fs$2.lstatSync(abs);\n  } catch (er) {\n    if (er.code === 'ENOENT') {\n      // lstat failed, doesn't exist\n      return null\n    }\n  }\n\n  var isSym = lstat && lstat.isSymbolicLink();\n  this.symlinks[abs] = isSym;\n\n  // If it's not a symlink or a dir, then it's definitely a regular file.\n  // don't bother doing a readdir in that case.\n  if (!isSym && lstat && !lstat.isDirectory())\n    this.cache[abs] = 'FILE';\n  else\n    entries = this._readdir(abs, false);\n\n  return entries\n};\n\nGlobSync.prototype._readdir = function (abs, inGlobStar) {\n\n  if (inGlobStar && !ownProp$1(this.symlinks, abs))\n    return this._readdirInGlobStar(abs)\n\n  if (ownProp$1(this.cache, abs)) {\n    var c = this.cache[abs];\n    if (!c || c === 'FILE')\n      return null\n\n    if (Array.isArray(c))\n      return c\n  }\n\n  try {\n    return this._readdirEntries(abs, fs$2.readdirSync(abs))\n  } catch (er) {\n    this._readdirError(abs, er);\n    return null\n  }\n};\n\nGlobSync.prototype._readdirEntries = function (abs, entries) {\n  // if we haven't asked to stat everything, then just\n  // assume that everything in there exists, so we can avoid\n  // having to stat it a second time.\n  if (!this.mark && !this.stat) {\n    for (var i = 0; i < entries.length; i ++) {\n      var e = entries[i];\n      if (abs === '/')\n        e = abs + e;\n      else\n        e = abs + '/' + e;\n      this.cache[e] = true;\n    }\n  }\n\n  this.cache[abs] = entries;\n\n  // mark and cache dir-ness\n  return entries\n};\n\nGlobSync.prototype._readdirError = function (f, er) {\n  // handle errors, and cache the information\n  switch (er.code) {\n    case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205\n    case 'ENOTDIR': // totally normal. means it *does* exist.\n      var abs = this._makeAbs(f);\n      this.cache[abs] = 'FILE';\n      if (abs === this.cwdAbs) {\n        var error = new Error(er.code + ' invalid cwd ' + this.cwd);\n        error.path = this.cwd;\n        error.code = er.code;\n        throw error\n      }\n      break\n\n    case 'ENOENT': // not terribly unusual\n    case 'ELOOP':\n    case 'ENAMETOOLONG':\n    case 'UNKNOWN':\n      this.cache[this._makeAbs(f)] = false;\n      break\n\n    default: // some unusual error.  Treat as failure.\n      this.cache[this._makeAbs(f)] = false;\n      if (this.strict)\n        throw er\n      if (!this.silent)\n        console.error('glob error', er);\n      break\n  }\n};\n\nGlobSync.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) {\n\n  var entries = this._readdir(abs, inGlobStar);\n\n  // no entries means not a dir, so it can never have matches\n  // foo.txt/** doesn't match foo.txt\n  if (!entries)\n    return\n\n  // test without the globstar, and with every child both below\n  // and replacing the globstar.\n  var remainWithoutGlobStar = remain.slice(1);\n  var gspref = prefix ? [ prefix ] : [];\n  var noGlobStar = gspref.concat(remainWithoutGlobStar);\n\n  // the noGlobStar pattern exits the inGlobStar state\n  this._process(noGlobStar, index, false);\n\n  var len = entries.length;\n  var isSym = this.symlinks[abs];\n\n  // If it's a symlink, and we're in a globstar, then stop\n  if (isSym && inGlobStar)\n    return\n\n  for (var i = 0; i < len; i++) {\n    var e = entries[i];\n    if (e.charAt(0) === '.' && !this.dot)\n      continue\n\n    // these two cases enter the inGlobStar state\n    var instead = gspref.concat(entries[i], remainWithoutGlobStar);\n    this._process(instead, index, true);\n\n    var below = gspref.concat(entries[i], remain);\n    this._process(below, index, true);\n  }\n};\n\nGlobSync.prototype._processSimple = function (prefix, index) {\n  // XXX review this.  Shouldn't it be doing the mounting etc\n  // before doing stat?  kinda weird?\n  var exists = this._stat(prefix);\n\n  if (!this.matches[index])\n    this.matches[index] = Object.create(null);\n\n  // If it doesn't exist, then just mark the lack of results\n  if (!exists)\n    return\n\n  if (prefix && pathIsAbsolute(prefix) && !this.nomount) {\n    var trail = /[\\/\\\\]$/.test(prefix);\n    if (prefix.charAt(0) === '/') {\n      prefix = path$1.join(this.root, prefix);\n    } else {\n      prefix = path$1.resolve(this.root, prefix);\n      if (trail)\n        prefix += '/';\n    }\n  }\n\n  if (process.platform === 'win32')\n    prefix = prefix.replace(/\\\\/g, '/');\n\n  // Mark this as a match\n  this._emitMatch(index, prefix);\n};\n\n// Returns either 'DIR', 'FILE', or false\nGlobSync.prototype._stat = function (f) {\n  var abs = this._makeAbs(f);\n  var needDir = f.slice(-1) === '/';\n\n  if (f.length > this.maxLength)\n    return false\n\n  if (!this.stat && ownProp$1(this.cache, abs)) {\n    var c = this.cache[abs];\n\n    if (Array.isArray(c))\n      c = 'DIR';\n\n    // It exists, but maybe not how we need it\n    if (!needDir || c === 'DIR')\n      return c\n\n    if (needDir && c === 'FILE')\n      return false\n\n    // otherwise we have to stat, because maybe c=true\n    // if we know it exists, but not what it is.\n  }\n  var stat = this.statCache[abs];\n  if (!stat) {\n    var lstat;\n    try {\n      lstat = fs$2.lstatSync(abs);\n    } catch (er) {\n      if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {\n        this.statCache[abs] = false;\n        return false\n      }\n    }\n\n    if (lstat && lstat.isSymbolicLink()) {\n      try {\n        stat = fs$2.statSync(abs);\n      } catch (er) {\n        stat = lstat;\n      }\n    } else {\n      stat = lstat;\n    }\n  }\n\n  this.statCache[abs] = stat;\n\n  var c = true;\n  if (stat)\n    c = stat.isDirectory() ? 'DIR' : 'FILE';\n\n  this.cache[abs] = this.cache[abs] || c;\n\n  if (needDir && c === 'FILE')\n    return false\n\n  return c\n};\n\nGlobSync.prototype._mark = function (p) {\n  return common$2.mark(this, p)\n};\n\nGlobSync.prototype._makeAbs = function (f) {\n  return common$2.makeAbs(this, f)\n};\n\n// Returns a wrapper function that returns a wrapped callback\n// The wrapper function should do some stuff, and return a\n// presumably different callback function.\n// This makes sure that own properties are retained, so that\n// decorations and such are not lost along the way.\nvar wrappy_1 = wrappy;\nfunction wrappy (fn, cb) {\n  if (fn && cb) return wrappy(fn)(cb)\n\n  if (typeof fn !== 'function')\n    throw new TypeError('need wrapper function')\n\n  Object.keys(fn).forEach(function (k) {\n    wrapper[k] = fn[k];\n  });\n\n  return wrapper\n\n  function wrapper() {\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n    var ret = fn.apply(this, args);\n    var cb = args[args.length-1];\n    if (typeof ret === 'function' && ret !== cb) {\n      Object.keys(cb).forEach(function (k) {\n        ret[k] = cb[k];\n      });\n    }\n    return ret\n  }\n}\n\nvar once_1 = wrappy_1(once);\nvar strict$1 = wrappy_1(onceStrict);\n\nonce.proto = once(function () {\n  Object.defineProperty(Function.prototype, 'once', {\n    value: function () {\n      return once(this)\n    },\n    configurable: true\n  });\n\n  Object.defineProperty(Function.prototype, 'onceStrict', {\n    value: function () {\n      return onceStrict(this)\n    },\n    configurable: true\n  });\n});\n\nfunction once (fn) {\n  var f = function () {\n    if (f.called) return f.value\n    f.called = true;\n    return f.value = fn.apply(this, arguments)\n  };\n  f.called = false;\n  return f\n}\n\nfunction onceStrict (fn) {\n  var f = function () {\n    if (f.called)\n      throw new Error(f.onceError)\n    f.called = true;\n    return f.value = fn.apply(this, arguments)\n  };\n  var name = fn.name || 'Function wrapped with `once`';\n  f.onceError = name + \" shouldn't be called more than once\";\n  f.called = false;\n  return f\n}\nonce_1.strict = strict$1;\n\nvar reqs = Object.create(null);\n\n\nvar inflight_1 = wrappy_1(inflight);\n\nfunction inflight (key, cb) {\n  if (reqs[key]) {\n    reqs[key].push(cb);\n    return null\n  } else {\n    reqs[key] = [cb];\n    return makeres(key)\n  }\n}\n\nfunction makeres (key) {\n  return once_1(function RES () {\n    var cbs = reqs[key];\n    var len = cbs.length;\n    var args = slice$1(arguments);\n\n    // XXX It's somewhat ambiguous whether a new callback added in this\n    // pass should be queued for later execution if something in the\n    // list of callbacks throws, or if it should just be discarded.\n    // However, it's such an edge case that it hardly matters, and either\n    // choice is likely as surprising as the other.\n    // As it happens, we do go ahead and schedule it for later execution.\n    try {\n      for (var i = 0; i < len; i++) {\n        cbs[i].apply(null, args);\n      }\n    } finally {\n      if (cbs.length > len) {\n        // added more in the interim.\n        // de-zalgo, just in case, but don't call again.\n        cbs.splice(0, len);\n        process.nextTick(function () {\n          RES.apply(null, args);\n        });\n      } else {\n        delete reqs[key];\n      }\n    }\n  })\n}\n\nfunction slice$1 (args) {\n  var length = args.length;\n  var array = [];\n\n  for (var i = 0; i < length; i++) array[i] = args[i];\n  return array\n}\n\n// Approach:\n//\n// 1. Get the minimatch set\n// 2. For each pattern in the set, PROCESS(pattern, false)\n// 3. Store matches per-set, then uniq them\n//\n// PROCESS(pattern, inGlobStar)\n// Get the first [n] items from pattern that are all strings\n// Join these together.  This is PREFIX.\n//   If there is no more remaining, then stat(PREFIX) and\n//   add to matches if it succeeds.  END.\n//\n// If inGlobStar and PREFIX is symlink and points to dir\n//   set ENTRIES = []\n// else readdir(PREFIX) as ENTRIES\n//   If fail, END\n//\n// with ENTRIES\n//   If pattern[n] is GLOBSTAR\n//     // handle the case where the globstar match is empty\n//     // by pruning it out, and testing the resulting pattern\n//     PROCESS(pattern[0..n] + pattern[n+1 .. $], false)\n//     // handle other cases.\n//     for ENTRY in ENTRIES (not dotfiles)\n//       // attach globstar + tail onto the entry\n//       // Mark that this entry is a globstar match\n//       PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)\n//\n//   else // not globstar\n//     for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)\n//       Test ENTRY against pattern[n]\n//       If fails, continue\n//       If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $])\n//\n// Caveat:\n//   Cache all stats and readdirs results to minimize syscall.  Since all\n//   we ever care about is existence and directory-ness, we can just keep\n//   `true` for files, and [children,...] for directories, or `false` for\n//   things that don't exist.\n\nvar glob_1 = glob;\n\nvar EE = events.EventEmitter;\nvar setopts$2 = common$2.setopts;\nvar ownProp$2 = common$2.ownProp;\n\n\nvar childrenIgnored$2 = common$2.childrenIgnored;\nvar isIgnored$2 = common$2.isIgnored;\n\n\n\nfunction glob (pattern, options, cb) {\n  if (typeof options === 'function') cb = options, options = {};\n  if (!options) options = {};\n\n  if (options.sync) {\n    if (cb)\n      throw new TypeError('callback provided to sync glob')\n    return sync(pattern, options)\n  }\n\n  return new Glob(pattern, options, cb)\n}\n\nglob.sync = sync;\nvar GlobSync$1 = glob.GlobSync = sync.GlobSync;\n\n// old api surface\nglob.glob = glob;\n\nfunction extend$1 (origin, add) {\n  if (add === null || typeof add !== 'object') {\n    return origin\n  }\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin\n}\n\nglob.hasMagic = function (pattern, options_) {\n  var options = extend$1({}, options_);\n  options.noprocess = true;\n\n  var g = new Glob(pattern, options);\n  var set = g.minimatch.set;\n\n  if (!pattern)\n    return false\n\n  if (set.length > 1)\n    return true\n\n  for (var j = 0; j < set[0].length; j++) {\n    if (typeof set[0][j] !== 'string')\n      return true\n  }\n\n  return false\n};\n\nglob.Glob = Glob;\ninherits(Glob, EE);\nfunction Glob (pattern, options, cb) {\n  if (typeof options === 'function') {\n    cb = options;\n    options = null;\n  }\n\n  if (options && options.sync) {\n    if (cb)\n      throw new TypeError('callback provided to sync glob')\n    return new GlobSync$1(pattern, options)\n  }\n\n  if (!(this instanceof Glob))\n    return new Glob(pattern, options, cb)\n\n  setopts$2(this, pattern, options);\n  this._didRealPath = false;\n\n  // process each pattern in the minimatch set\n  var n = this.minimatch.set.length;\n\n  // The matches are stored as {<filename>: true,...} so that\n  // duplicates are automagically pruned.\n  // Later, we do an Object.keys() on these.\n  // Keep them as a list so we can fill in when nonull is set.\n  this.matches = new Array(n);\n\n  if (typeof cb === 'function') {\n    cb = once_1(cb);\n    this.on('error', cb);\n    this.on('end', function (matches) {\n      cb(null, matches);\n    });\n  }\n\n  var self = this;\n  this._processing = 0;\n\n  this._emitQueue = [];\n  this._processQueue = [];\n  this.paused = false;\n\n  if (this.noprocess)\n    return this\n\n  if (n === 0)\n    return done()\n\n  var sync = true;\n  for (var i = 0; i < n; i ++) {\n    this._process(this.minimatch.set[i], i, false, done);\n  }\n  sync = false;\n\n  function done () {\n    --self._processing;\n    if (self._processing <= 0) {\n      if (sync) {\n        process.nextTick(function () {\n          self._finish();\n        });\n      } else {\n        self._finish();\n      }\n    }\n  }\n}\n\nGlob.prototype._finish = function () {\n  assert(this instanceof Glob);\n  if (this.aborted)\n    return\n\n  if (this.realpath && !this._didRealpath)\n    return this._realpath()\n\n  common$2.finish(this);\n  this.emit('end', this.found);\n};\n\nGlob.prototype._realpath = function () {\n  if (this._didRealpath)\n    return\n\n  this._didRealpath = true;\n\n  var n = this.matches.length;\n  if (n === 0)\n    return this._finish()\n\n  var self = this;\n  for (var i = 0; i < this.matches.length; i++)\n    this._realpathSet(i, next);\n\n  function next () {\n    if (--n === 0)\n      self._finish();\n  }\n};\n\nGlob.prototype._realpathSet = function (index, cb) {\n  var matchset = this.matches[index];\n  if (!matchset)\n    return cb()\n\n  var found = Object.keys(matchset);\n  var self = this;\n  var n = found.length;\n\n  if (n === 0)\n    return cb()\n\n  var set = this.matches[index] = Object.create(null);\n  found.forEach(function (p, i) {\n    // If there's a problem with the stat, then it means that\n    // one or more of the links in the realpath couldn't be\n    // resolved.  just return the abs value in that case.\n    p = self._makeAbs(p);\n    fs_realpath.realpath(p, self.realpathCache, function (er, real) {\n      if (!er)\n        set[real] = true;\n      else if (er.syscall === 'stat')\n        set[p] = true;\n      else\n        self.emit('error', er); // srsly wtf right here\n\n      if (--n === 0) {\n        self.matches[index] = set;\n        cb();\n      }\n    });\n  });\n};\n\nGlob.prototype._mark = function (p) {\n  return common$2.mark(this, p)\n};\n\nGlob.prototype._makeAbs = function (f) {\n  return common$2.makeAbs(this, f)\n};\n\nGlob.prototype.abort = function () {\n  this.aborted = true;\n  this.emit('abort');\n};\n\nGlob.prototype.pause = function () {\n  if (!this.paused) {\n    this.paused = true;\n    this.emit('pause');\n  }\n};\n\nGlob.prototype.resume = function () {\n  if (this.paused) {\n    this.emit('resume');\n    this.paused = false;\n    if (this._emitQueue.length) {\n      var eq = this._emitQueue.slice(0);\n      this._emitQueue.length = 0;\n      for (var i = 0; i < eq.length; i ++) {\n        var e = eq[i];\n        this._emitMatch(e[0], e[1]);\n      }\n    }\n    if (this._processQueue.length) {\n      var pq = this._processQueue.slice(0);\n      this._processQueue.length = 0;\n      for (var i = 0; i < pq.length; i ++) {\n        var p = pq[i];\n        this._processing--;\n        this._process(p[0], p[1], p[2], p[3]);\n      }\n    }\n  }\n};\n\nGlob.prototype._process = function (pattern, index, inGlobStar, cb) {\n  assert(this instanceof Glob);\n  assert(typeof cb === 'function');\n\n  if (this.aborted)\n    return\n\n  this._processing++;\n  if (this.paused) {\n    this._processQueue.push([pattern, index, inGlobStar, cb]);\n    return\n  }\n\n  //console.error('PROCESS %d', this._processing, pattern)\n\n  // Get the first [n] parts of pattern that are all strings.\n  var n = 0;\n  while (typeof pattern[n] === 'string') {\n    n ++;\n  }\n  // now n is the index of the first one that is *not* a string.\n\n  // see if there's anything else\n  var prefix;\n  switch (n) {\n    // if not, then this is rather simple\n    case pattern.length:\n      this._processSimple(pattern.join('/'), index, cb);\n      return\n\n    case 0:\n      // pattern *starts* with some non-trivial item.\n      // going to readdir(cwd), but not include the prefix in matches.\n      prefix = null;\n      break\n\n    default:\n      // pattern has some string bits in the front.\n      // whatever it starts with, whether that's 'absolute' like /foo/bar,\n      // or 'relative' like '../baz'\n      prefix = pattern.slice(0, n).join('/');\n      break\n  }\n\n  var remain = pattern.slice(n);\n\n  // get the list of entries.\n  var read;\n  if (prefix === null)\n    read = '.';\n  else if (pathIsAbsolute(prefix) || pathIsAbsolute(pattern.join('/'))) {\n    if (!prefix || !pathIsAbsolute(prefix))\n      prefix = '/' + prefix;\n    read = prefix;\n  } else\n    read = prefix;\n\n  var abs = this._makeAbs(read);\n\n  //if ignored, skip _processing\n  if (childrenIgnored$2(this, read))\n    return cb()\n\n  var isGlobStar = remain[0] === minimatch_1.GLOBSTAR;\n  if (isGlobStar)\n    this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);\n  else\n    this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);\n};\n\nGlob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) {\n  var self = this;\n  this._readdir(abs, inGlobStar, function (er, entries) {\n    return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb)\n  });\n};\n\nGlob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {\n\n  // if the abs isn't a dir, then nothing can match!\n  if (!entries)\n    return cb()\n\n  // It will only match dot entries if it starts with a dot, or if\n  // dot is set.  Stuff like @(.foo|.bar) isn't allowed.\n  var pn = remain[0];\n  var negate = !!this.minimatch.negate;\n  var rawGlob = pn._glob;\n  var dotOk = this.dot || rawGlob.charAt(0) === '.';\n\n  var matchedEntries = [];\n  for (var i = 0; i < entries.length; i++) {\n    var e = entries[i];\n    if (e.charAt(0) !== '.' || dotOk) {\n      var m;\n      if (negate && !prefix) {\n        m = !e.match(pn);\n      } else {\n        m = e.match(pn);\n      }\n      if (m)\n        matchedEntries.push(e);\n    }\n  }\n\n  //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)\n\n  var len = matchedEntries.length;\n  // If there are no matched entries, then nothing matches.\n  if (len === 0)\n    return cb()\n\n  // if this is the last remaining pattern bit, then no need for\n  // an additional stat *unless* the user has specified mark or\n  // stat explicitly.  We know they exist, since readdir returned\n  // them.\n\n  if (remain.length === 1 && !this.mark && !this.stat) {\n    if (!this.matches[index])\n      this.matches[index] = Object.create(null);\n\n    for (var i = 0; i < len; i ++) {\n      var e = matchedEntries[i];\n      if (prefix) {\n        if (prefix !== '/')\n          e = prefix + '/' + e;\n        else\n          e = prefix + e;\n      }\n\n      if (e.charAt(0) === '/' && !this.nomount) {\n        e = path$1.join(this.root, e);\n      }\n      this._emitMatch(index, e);\n    }\n    // This was the last one, and no stats were needed\n    return cb()\n  }\n\n  // now test all matched entries as stand-ins for that part\n  // of the pattern.\n  remain.shift();\n  for (var i = 0; i < len; i ++) {\n    var e = matchedEntries[i];\n    if (prefix) {\n      if (prefix !== '/')\n        e = prefix + '/' + e;\n      else\n        e = prefix + e;\n    }\n    this._process([e].concat(remain), index, inGlobStar, cb);\n  }\n  cb();\n};\n\nGlob.prototype._emitMatch = function (index, e) {\n  if (this.aborted)\n    return\n\n  if (isIgnored$2(this, e))\n    return\n\n  if (this.paused) {\n    this._emitQueue.push([index, e]);\n    return\n  }\n\n  var abs = pathIsAbsolute(e) ? e : this._makeAbs(e);\n\n  if (this.mark)\n    e = this._mark(e);\n\n  if (this.absolute)\n    e = abs;\n\n  if (this.matches[index][e])\n    return\n\n  if (this.nodir) {\n    var c = this.cache[abs];\n    if (c === 'DIR' || Array.isArray(c))\n      return\n  }\n\n  this.matches[index][e] = true;\n\n  var st = this.statCache[abs];\n  if (st)\n    this.emit('stat', e, st);\n\n  this.emit('match', e);\n};\n\nGlob.prototype._readdirInGlobStar = function (abs, cb) {\n  if (this.aborted)\n    return\n\n  // follow all symlinked directories forever\n  // just proceed as if this is a non-globstar situation\n  if (this.follow)\n    return this._readdir(abs, false, cb)\n\n  var lstatkey = 'lstat\\0' + abs;\n  var self = this;\n  var lstatcb = inflight_1(lstatkey, lstatcb_);\n\n  if (lstatcb)\n    fs$2.lstat(abs, lstatcb);\n\n  function lstatcb_ (er, lstat) {\n    if (er && er.code === 'ENOENT')\n      return cb()\n\n    var isSym = lstat && lstat.isSymbolicLink();\n    self.symlinks[abs] = isSym;\n\n    // If it's not a symlink or a dir, then it's definitely a regular file.\n    // don't bother doing a readdir in that case.\n    if (!isSym && lstat && !lstat.isDirectory()) {\n      self.cache[abs] = 'FILE';\n      cb();\n    } else\n      self._readdir(abs, false, cb);\n  }\n};\n\nGlob.prototype._readdir = function (abs, inGlobStar, cb) {\n  if (this.aborted)\n    return\n\n  cb = inflight_1('readdir\\0'+abs+'\\0'+inGlobStar, cb);\n  if (!cb)\n    return\n\n  //console.error('RD %j %j', +inGlobStar, abs)\n  if (inGlobStar && !ownProp$2(this.symlinks, abs))\n    return this._readdirInGlobStar(abs, cb)\n\n  if (ownProp$2(this.cache, abs)) {\n    var c = this.cache[abs];\n    if (!c || c === 'FILE')\n      return cb()\n\n    if (Array.isArray(c))\n      return cb(null, c)\n  }\n  fs$2.readdir(abs, readdirCb(this, abs, cb));\n};\n\nfunction readdirCb (self, abs, cb) {\n  return function (er, entries) {\n    if (er)\n      self._readdirError(abs, er, cb);\n    else\n      self._readdirEntries(abs, entries, cb);\n  }\n}\n\nGlob.prototype._readdirEntries = function (abs, entries, cb) {\n  if (this.aborted)\n    return\n\n  // if we haven't asked to stat everything, then just\n  // assume that everything in there exists, so we can avoid\n  // having to stat it a second time.\n  if (!this.mark && !this.stat) {\n    for (var i = 0; i < entries.length; i ++) {\n      var e = entries[i];\n      if (abs === '/')\n        e = abs + e;\n      else\n        e = abs + '/' + e;\n      this.cache[e] = true;\n    }\n  }\n\n  this.cache[abs] = entries;\n  return cb(null, entries)\n};\n\nGlob.prototype._readdirError = function (f, er, cb) {\n  if (this.aborted)\n    return\n\n  // handle errors, and cache the information\n  switch (er.code) {\n    case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205\n    case 'ENOTDIR': // totally normal. means it *does* exist.\n      var abs = this._makeAbs(f);\n      this.cache[abs] = 'FILE';\n      if (abs === this.cwdAbs) {\n        var error = new Error(er.code + ' invalid cwd ' + this.cwd);\n        error.path = this.cwd;\n        error.code = er.code;\n        this.emit('error', error);\n        this.abort();\n      }\n      break\n\n    case 'ENOENT': // not terribly unusual\n    case 'ELOOP':\n    case 'ENAMETOOLONG':\n    case 'UNKNOWN':\n      this.cache[this._makeAbs(f)] = false;\n      break\n\n    default: // some unusual error.  Treat as failure.\n      this.cache[this._makeAbs(f)] = false;\n      if (this.strict) {\n        this.emit('error', er);\n        // If the error is handled, then we abort\n        // if not, we threw out of here\n        this.abort();\n      }\n      if (!this.silent)\n        console.error('glob error', er);\n      break\n  }\n\n  return cb()\n};\n\nGlob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) {\n  var self = this;\n  this._readdir(abs, inGlobStar, function (er, entries) {\n    self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);\n  });\n};\n\n\nGlob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {\n  //console.error('pgs2', prefix, remain[0], entries)\n\n  // no entries means not a dir, so it can never have matches\n  // foo.txt/** doesn't match foo.txt\n  if (!entries)\n    return cb()\n\n  // test without the globstar, and with every child both below\n  // and replacing the globstar.\n  var remainWithoutGlobStar = remain.slice(1);\n  var gspref = prefix ? [ prefix ] : [];\n  var noGlobStar = gspref.concat(remainWithoutGlobStar);\n\n  // the noGlobStar pattern exits the inGlobStar state\n  this._process(noGlobStar, index, false, cb);\n\n  var isSym = this.symlinks[abs];\n  var len = entries.length;\n\n  // If it's a symlink, and we're in a globstar, then stop\n  if (isSym && inGlobStar)\n    return cb()\n\n  for (var i = 0; i < len; i++) {\n    var e = entries[i];\n    if (e.charAt(0) === '.' && !this.dot)\n      continue\n\n    // these two cases enter the inGlobStar state\n    var instead = gspref.concat(entries[i], remainWithoutGlobStar);\n    this._process(instead, index, true, cb);\n\n    var below = gspref.concat(entries[i], remain);\n    this._process(below, index, true, cb);\n  }\n\n  cb();\n};\n\nGlob.prototype._processSimple = function (prefix, index, cb) {\n  // XXX review this.  Shouldn't it be doing the mounting etc\n  // before doing stat?  kinda weird?\n  var self = this;\n  this._stat(prefix, function (er, exists) {\n    self._processSimple2(prefix, index, er, exists, cb);\n  });\n};\nGlob.prototype._processSimple2 = function (prefix, index, er, exists, cb) {\n\n  //console.error('ps2', prefix, exists)\n\n  if (!this.matches[index])\n    this.matches[index] = Object.create(null);\n\n  // If it doesn't exist, then just mark the lack of results\n  if (!exists)\n    return cb()\n\n  if (prefix && pathIsAbsolute(prefix) && !this.nomount) {\n    var trail = /[\\/\\\\]$/.test(prefix);\n    if (prefix.charAt(0) === '/') {\n      prefix = path$1.join(this.root, prefix);\n    } else {\n      prefix = path$1.resolve(this.root, prefix);\n      if (trail)\n        prefix += '/';\n    }\n  }\n\n  if (process.platform === 'win32')\n    prefix = prefix.replace(/\\\\/g, '/');\n\n  // Mark this as a match\n  this._emitMatch(index, prefix);\n  cb();\n};\n\n// Returns either 'DIR', 'FILE', or false\nGlob.prototype._stat = function (f, cb) {\n  var abs = this._makeAbs(f);\n  var needDir = f.slice(-1) === '/';\n\n  if (f.length > this.maxLength)\n    return cb()\n\n  if (!this.stat && ownProp$2(this.cache, abs)) {\n    var c = this.cache[abs];\n\n    if (Array.isArray(c))\n      c = 'DIR';\n\n    // It exists, but maybe not how we need it\n    if (!needDir || c === 'DIR')\n      return cb(null, c)\n\n    if (needDir && c === 'FILE')\n      return cb()\n\n    // otherwise we have to stat, because maybe c=true\n    // if we know it exists, but not what it is.\n  }\n  var stat = this.statCache[abs];\n  if (stat !== undefined) {\n    if (stat === false)\n      return cb(null, stat)\n    else {\n      var type = stat.isDirectory() ? 'DIR' : 'FILE';\n      if (needDir && type === 'FILE')\n        return cb()\n      else\n        return cb(null, type, stat)\n    }\n  }\n\n  var self = this;\n  var statcb = inflight_1('stat\\0' + abs, lstatcb_);\n  if (statcb)\n    fs$2.lstat(abs, statcb);\n\n  function lstatcb_ (er, lstat) {\n    if (lstat && lstat.isSymbolicLink()) {\n      // If it's a symlink, then treat it as the target, unless\n      // the target does not exist, then treat it as a file.\n      return fs$2.stat(abs, function (er, stat) {\n        if (er)\n          self._stat2(f, abs, null, lstat, cb);\n        else\n          self._stat2(f, abs, er, stat, cb);\n      })\n    } else {\n      self._stat2(f, abs, er, lstat, cb);\n    }\n  }\n};\n\nGlob.prototype._stat2 = function (f, abs, er, stat, cb) {\n  if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {\n    this.statCache[abs] = false;\n    return cb()\n  }\n\n  var needDir = f.slice(-1) === '/';\n  this.statCache[abs] = stat;\n\n  if (abs.slice(-1) === '/' && stat && !stat.isDirectory())\n    return cb(null, false, stat)\n\n  var c = true;\n  if (stat)\n    c = stat.isDirectory() ? 'DIR' : 'FILE';\n  this.cache[abs] = this.cache[abs] || c;\n\n  if (needDir && c === 'FILE')\n    return cb()\n\n  return cb(null, c, stat)\n};\n\nvar rimraf_1 = rimraf;\nrimraf.sync = rimrafSync;\n\n\n\n\n\nvar _0666 = parseInt('666', 8);\n\nvar defaultGlobOpts = {\n  nosort: true,\n  silent: true\n};\n\n// for EMFILE handling\nvar timeout = 0;\n\nvar isWindows$1 = (process.platform === \"win32\");\n\nfunction defaults (options) {\n  var methods = [\n    'unlink',\n    'chmod',\n    'stat',\n    'lstat',\n    'rmdir',\n    'readdir'\n  ];\n  methods.forEach(function(m) {\n    options[m] = options[m] || fs$2[m];\n    m = m + 'Sync';\n    options[m] = options[m] || fs$2[m];\n  });\n\n  options.maxBusyTries = options.maxBusyTries || 3;\n  options.emfileWait = options.emfileWait || 1000;\n  if (options.glob === false) {\n    options.disableGlob = true;\n  }\n  options.disableGlob = options.disableGlob || false;\n  options.glob = options.glob || defaultGlobOpts;\n}\n\nfunction rimraf (p, options, cb) {\n  if (typeof options === 'function') {\n    cb = options;\n    options = {};\n  }\n\n  assert(p, 'rimraf: missing path');\n  assert.equal(typeof p, 'string', 'rimraf: path should be a string');\n  assert.equal(typeof cb, 'function', 'rimraf: callback function required');\n  assert(options, 'rimraf: invalid options argument provided');\n  assert.equal(typeof options, 'object', 'rimraf: options should be object');\n\n  defaults(options);\n\n  var busyTries = 0;\n  var errState = null;\n  var n = 0;\n\n  if (options.disableGlob || !glob_1.hasMagic(p))\n    return afterGlob(null, [p])\n\n  options.lstat(p, function (er, stat) {\n    if (!er)\n      return afterGlob(null, [p])\n\n    glob_1(p, options.glob, afterGlob);\n  });\n\n  function next (er) {\n    errState = errState || er;\n    if (--n === 0)\n      cb(errState);\n  }\n\n  function afterGlob (er, results) {\n    if (er)\n      return cb(er)\n\n    n = results.length;\n    if (n === 0)\n      return cb()\n\n    results.forEach(function (p) {\n      rimraf_(p, options, function CB (er) {\n        if (er) {\n          if ((er.code === \"EBUSY\" || er.code === \"ENOTEMPTY\" || er.code === \"EPERM\") &&\n              busyTries < options.maxBusyTries) {\n            busyTries ++;\n            var time = busyTries * 100;\n            // try again, with the same exact callback as this one.\n            return setTimeout(function () {\n              rimraf_(p, options, CB);\n            }, time)\n          }\n\n          // this one won't happen if graceful-fs is used.\n          if (er.code === \"EMFILE\" && timeout < options.emfileWait) {\n            return setTimeout(function () {\n              rimraf_(p, options, CB);\n            }, timeout ++)\n          }\n\n          // already gone\n          if (er.code === \"ENOENT\") er = null;\n        }\n\n        timeout = 0;\n        next(er);\n      });\n    });\n  }\n}\n\n// Two possible strategies.\n// 1. Assume it's a file.  unlink it, then do the dir stuff on EPERM or EISDIR\n// 2. Assume it's a directory.  readdir, then do the file stuff on ENOTDIR\n//\n// Both result in an extra syscall when you guess wrong.  However, there\n// are likely far more normal files in the world than directories.  This\n// is based on the assumption that a the average number of files per\n// directory is >= 1.\n//\n// If anyone ever complains about this, then I guess the strategy could\n// be made configurable somehow.  But until then, YAGNI.\nfunction rimraf_ (p, options, cb) {\n  assert(p);\n  assert(options);\n  assert(typeof cb === 'function');\n\n  // sunos lets the root user unlink directories, which is... weird.\n  // so we have to lstat here and make sure it's not a dir.\n  options.lstat(p, function (er, st) {\n    if (er && er.code === \"ENOENT\")\n      return cb(null)\n\n    // Windows can EPERM on stat.  Life is suffering.\n    if (er && er.code === \"EPERM\" && isWindows$1)\n      fixWinEPERM(p, options, er, cb);\n\n    if (st && st.isDirectory())\n      return rmdir(p, options, er, cb)\n\n    options.unlink(p, function (er) {\n      if (er) {\n        if (er.code === \"ENOENT\")\n          return cb(null)\n        if (er.code === \"EPERM\")\n          return (isWindows$1)\n            ? fixWinEPERM(p, options, er, cb)\n            : rmdir(p, options, er, cb)\n        if (er.code === \"EISDIR\")\n          return rmdir(p, options, er, cb)\n      }\n      return cb(er)\n    });\n  });\n}\n\nfunction fixWinEPERM (p, options, er, cb) {\n  assert(p);\n  assert(options);\n  assert(typeof cb === 'function');\n  if (er)\n    assert(er instanceof Error);\n\n  options.chmod(p, _0666, function (er2) {\n    if (er2)\n      cb(er2.code === \"ENOENT\" ? null : er);\n    else\n      options.stat(p, function(er3, stats) {\n        if (er3)\n          cb(er3.code === \"ENOENT\" ? null : er);\n        else if (stats.isDirectory())\n          rmdir(p, options, er, cb);\n        else\n          options.unlink(p, cb);\n      });\n  });\n}\n\nfunction fixWinEPERMSync (p, options, er) {\n  assert(p);\n  assert(options);\n  if (er)\n    assert(er instanceof Error);\n\n  try {\n    options.chmodSync(p, _0666);\n  } catch (er2) {\n    if (er2.code === \"ENOENT\")\n      return\n    else\n      throw er\n  }\n\n  try {\n    var stats = options.statSync(p);\n  } catch (er3) {\n    if (er3.code === \"ENOENT\")\n      return\n    else\n      throw er\n  }\n\n  if (stats.isDirectory())\n    rmdirSync(p, options, er);\n  else\n    options.unlinkSync(p);\n}\n\nfunction rmdir (p, options, originalEr, cb) {\n  assert(p);\n  assert(options);\n  if (originalEr)\n    assert(originalEr instanceof Error);\n  assert(typeof cb === 'function');\n\n  // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)\n  // if we guessed wrong, and it's not a directory, then\n  // raise the original error.\n  options.rmdir(p, function (er) {\n    if (er && (er.code === \"ENOTEMPTY\" || er.code === \"EEXIST\" || er.code === \"EPERM\"))\n      rmkids(p, options, cb);\n    else if (er && er.code === \"ENOTDIR\")\n      cb(originalEr);\n    else\n      cb(er);\n  });\n}\n\nfunction rmkids(p, options, cb) {\n  assert(p);\n  assert(options);\n  assert(typeof cb === 'function');\n\n  options.readdir(p, function (er, files) {\n    if (er)\n      return cb(er)\n    var n = files.length;\n    if (n === 0)\n      return options.rmdir(p, cb)\n    var errState;\n    files.forEach(function (f) {\n      rimraf(path$1.join(p, f), options, function (er) {\n        if (errState)\n          return\n        if (er)\n          return cb(errState = er)\n        if (--n === 0)\n          options.rmdir(p, cb);\n      });\n    });\n  });\n}\n\n// this looks simpler, and is strictly *faster*, but will\n// tie up the JavaScript thread and fail on excessively\n// deep directory trees.\nfunction rimrafSync (p, options) {\n  options = options || {};\n  defaults(options);\n\n  assert(p, 'rimraf: missing path');\n  assert.equal(typeof p, 'string', 'rimraf: path should be a string');\n  assert(options, 'rimraf: missing options');\n  assert.equal(typeof options, 'object', 'rimraf: options should be object');\n\n  var results;\n\n  if (options.disableGlob || !glob_1.hasMagic(p)) {\n    results = [p];\n  } else {\n    try {\n      options.lstatSync(p);\n      results = [p];\n    } catch (er) {\n      results = glob_1.sync(p, options.glob);\n    }\n  }\n\n  if (!results.length)\n    return\n\n  for (var i = 0; i < results.length; i++) {\n    var p = results[i];\n\n    try {\n      var st = options.lstatSync(p);\n    } catch (er) {\n      if (er.code === \"ENOENT\")\n        return\n\n      // Windows can EPERM on stat.  Life is suffering.\n      if (er.code === \"EPERM\" && isWindows$1)\n        fixWinEPERMSync(p, options, er);\n    }\n\n    try {\n      // sunos lets the root user unlink directories, which is... weird.\n      if (st && st.isDirectory())\n        rmdirSync(p, options, null);\n      else\n        options.unlinkSync(p);\n    } catch (er) {\n      if (er.code === \"ENOENT\")\n        return\n      if (er.code === \"EPERM\")\n        return isWindows$1 ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)\n      if (er.code !== \"EISDIR\")\n        throw er\n\n      rmdirSync(p, options, er);\n    }\n  }\n}\n\nfunction rmdirSync (p, options, originalEr) {\n  assert(p);\n  assert(options);\n  if (originalEr)\n    assert(originalEr instanceof Error);\n\n  try {\n    options.rmdirSync(p);\n  } catch (er) {\n    if (er.code === \"ENOENT\")\n      return\n    if (er.code === \"ENOTDIR\")\n      throw originalEr\n    if (er.code === \"ENOTEMPTY\" || er.code === \"EEXIST\" || er.code === \"EPERM\")\n      rmkidsSync(p, options);\n  }\n}\n\nfunction rmkidsSync (p, options) {\n  assert(p);\n  assert(options);\n  options.readdirSync(p).forEach(function (f) {\n    rimrafSync(path$1.join(p, f), options);\n  });\n\n  // We only end up here once we got ENOTEMPTY at least once, and\n  // at this point, we are guaranteed to have removed all the kids.\n  // So, we know that it won't be ENOENT or ENOTDIR or anything else.\n  // try really hard to delete stuff on windows, because it has a\n  // PROFOUNDLY annoying habit of not closing handles promptly when\n  // files are deleted, resulting in spurious ENOTEMPTY errors.\n  var retries = isWindows$1 ? 100 : 1;\n  var i = 0;\n  do {\n    var threw = true;\n    try {\n      var ret = options.rmdirSync(p, options);\n      threw = false;\n      return ret\n    } finally {\n      if (++i < retries && threw)\n        continue\n    }\n  } while (true)\n}\n\nvar rimraf$1 = rimraf_1.sync;\n\n\nvar del = function del( file ) {\n  if ( fs$2.existsSync( file ) ) {\n    //if rimraf doesn't throw then the file has been deleted or didn't exist\n    rimraf$1( file, {\n      glob: false\n    } );\n    return true;\n  }\n  return false;\n};\n\nvar writeJSON = utils$2.writeJSON;\n\nvar cache$2 = {\n  /**\n   * Load a cache identified by the given Id. If the element does not exists, then initialize an empty\n   * cache storage. If specified `cacheDir` will be used as the directory to persist the data to. If omitted\n   * then the cache module directory `./cache` will be used instead\n   *\n   * @method load\n   * @param docId {String} the id of the cache, would also be used as the name of the file cache\n   * @param [cacheDir] {String} directory for the cache entry\n   */\n  load: function ( docId, cacheDir ) {\n    var me = this;\n\n    me._visited = { };\n    me._persisted = { };\n    me._pathToFile = cacheDir ? path$1.resolve( cacheDir, docId ) : path$1.resolve( __dirname, './.cache/', docId );\n\n    if ( fs$2.existsSync( me._pathToFile ) ) {\n      me._persisted = utils$2.tryParse( me._pathToFile, { } );\n    }\n  },\n\n  /**\n   * Load the cache from the provided file\n   * @method loadFile\n   * @param  {String} pathToFile the path to the file containing the info for the cache\n   */\n  loadFile: function ( pathToFile ) {\n    var me = this;\n    var dir = path$1.dirname( pathToFile );\n    var fName = path$1.basename( pathToFile );\n\n    me.load( fName, dir );\n  },\n\n  /**\n   * Returns the entire persisted object\n   * @method all\n   * @returns {*}\n   */\n  all: function () {\n    return this._persisted;\n  },\n\n  keys: function () {\n    return Object.keys( this._persisted );\n  },\n  /**\n   * sets a key to a given value\n   * @method setKey\n   * @param key {string} the key to set\n   * @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify\n   */\n  setKey: function ( key, value ) {\n    this._visited[ key ] = true;\n    this._persisted[ key ] = value;\n  },\n  /**\n   * remove a given key from the cache\n   * @method removeKey\n   * @param key {String} the key to remove from the object\n   */\n  removeKey: function ( key ) {\n    delete this._visited[ key ]; // esfmt-ignore-line\n    delete this._persisted[ key ]; // esfmt-ignore-line\n  },\n  /**\n   * Return the value of the provided key\n   * @method getKey\n   * @param key {String} the name of the key to retrieve\n   * @returns {*} the value from the key\n   */\n  getKey: function ( key ) {\n    this._visited[ key ] = true;\n    return this._persisted[ key ];\n  },\n\n  /**\n   * Remove keys that were not accessed/set since the\n   * last time the `prune` method was called.\n   * @method _prune\n   * @private\n   */\n  _prune: function () {\n    var me = this;\n    var obj = { };\n\n    var keys = Object.keys( me._visited );\n\n    // no keys visited for either get or set value\n    if ( keys.length === 0 ) {\n      return;\n    }\n\n    keys.forEach( function ( key ) {\n      obj[ key ] = me._persisted[ key ];\n    } );\n\n    me._visited = { };\n    me._persisted = obj;\n  },\n\n  /**\n   * Save the state of the cache identified by the docId to disk\n   * as a JSON structure\n   * @param [noPrune=false] {Boolean} whether to remove from cache the non visited files\n   * @method save\n   */\n  save: function ( noPrune ) {\n    var me = this;\n\n    (!noPrune) && me._prune();\n    writeJSON( me._pathToFile, me._persisted );\n  },\n\n  /**\n   * remove the file where the cache is persisted\n   * @method removeCacheFile\n   * @return {Boolean} true or false if the file was successfully deleted\n   */\n  removeCacheFile: function () {\n    return del( this._pathToFile );\n  },\n  /**\n   * Destroy the file cache and cache content.\n   * @method destroy\n   */\n  destroy: function () {\n    var me = this;\n    me._visited = { };\n    me._persisted = { };\n\n    me.removeCacheFile();\n  }\n};\n\nvar cache_1 = {\n  /**\n   * Alias for create. Should be considered depreacted. Will be removed in next releases\n   *\n   * @method load\n   * @param docId {String} the id of the cache, would also be used as the name of the file cache\n   * @param [cacheDir] {String} directory for the cache entry\n   * @returns {cache} cache instance\n   */\n  load: function ( docId, cacheDir ) {\n    return this.create( docId, cacheDir );\n  },\n\n  /**\n  * Load a cache identified by the given Id. If the element does not exists, then initialize an empty\n  * cache storage.\n  *\n  * @method create\n  * @param docId {String} the id of the cache, would also be used as the name of the file cache\n  * @param [cacheDir] {String} directory for the cache entry\n  * @returns {cache} cache instance\n  */\n  create: function ( docId, cacheDir ) {\n    var obj = Object.create( cache$2 );\n    obj.load( docId, cacheDir );\n    return obj;\n  },\n\n  createFromFile: function ( filePath ) {\n    var obj = Object.create( cache$2 );\n    obj.loadFile( filePath );\n    return obj;\n  },\n  /**\n   * Clear the cache identified by the given id. Caches stored in a different cache directory can be deleted directly\n   *\n   * @method clearCache\n   * @param docId {String} the id of the cache, would also be used as the name of the file cache\n   * @param cacheDir {String} the directory where the cache file was written\n   * @returns {Boolean} true if the cache folder was deleted. False otherwise\n   */\n  clearCacheById: function ( docId, cacheDir ) {\n    var filePath = cacheDir ? path$1.resolve( cacheDir, docId ) : path$1.resolve( __dirname, './.cache/', docId );\n    return del( filePath );\n  },\n  /**\n   * Remove all cache stored in the cache directory\n   * @method clearAll\n   * @returns {Boolean} true if the cache folder was deleted. False otherwise\n   */\n  clearAll: function ( cacheDir ) {\n    var filePath = cacheDir ? path$1.resolve( cacheDir ) : path$1.resolve( __dirname, './.cache/' );\n    return del( filePath );\n  }\n};\n\nvar cache$3 = {\n  createFromFile: function ( filePath, useChecksum ) {\n    var fname = path$1.basename( filePath );\n    var dir = path$1.dirname( filePath );\n    return this.create( fname, dir, useChecksum );\n  },\n\n  create: function ( cacheId, _path, useChecksum ) {\n    var fs = fs$2;\n    var flatCache = cache_1;\n    var cache = flatCache.load( cacheId, _path );\n    var normalizedEntries = { };\n\n    var removeNotFoundFiles = function removeNotFoundFiles() {\n      const cachedEntries = cache.keys();\n      // remove not found entries\n      cachedEntries.forEach( function remover( fPath ) {\n        try {\n          fs.statSync( fPath );\n        } catch (err) {\n          if ( err.code === 'ENOENT' ) {\n            cache.removeKey( fPath );\n          }\n        }\n      } );\n    };\n\n    removeNotFoundFiles();\n\n    return {\n      /**\n       * the flat cache storage used to persist the metadata of the `files\n       * @type {Object}\n       */\n      cache: cache,\n\n      /**\n       * Given a buffer, calculate md5 hash of its content.\n       * @method getHash\n       * @param  {Buffer} buffer   buffer to calculate hash on\n       * @return {String}          content hash digest\n       */\n      getHash: function ( buffer ) {\n        return crypto\n          .createHash( 'md5' )\n          .update( buffer )\n          .digest( 'hex' );\n      },\n\n      /**\n       * Return whether or not a file has changed since last time reconcile was called.\n       * @method hasFileChanged\n       * @param  {String}  file  the filepath to check\n       * @return {Boolean}       wheter or not the file has changed\n       */\n      hasFileChanged: function ( file ) {\n        return this.getFileDescriptor( file ).changed;\n      },\n\n      /**\n       * given an array of file paths it return and object with three arrays:\n       *  - changedFiles: Files that changed since previous run\n       *  - notChangedFiles: Files that haven't change\n       *  - notFoundFiles: Files that were not found, probably deleted\n       *\n       * @param  {Array} files the files to analyze and compare to the previous seen files\n       * @return {[type]}       [description]\n       */\n      analyzeFiles: function ( files ) {\n        var me = this;\n        files = files || [ ];\n\n        var res = {\n          changedFiles: [],\n          notFoundFiles: [],\n          notChangedFiles: []\n        };\n\n        me.normalizeEntries( files ).forEach( function ( entry ) {\n          if ( entry.changed ) {\n            res.changedFiles.push( entry.key );\n            return;\n          }\n          if ( entry.notFound ) {\n            res.notFoundFiles.push( entry.key );\n            return;\n          }\n          res.notChangedFiles.push( entry.key );\n        } );\n        return res;\n      },\n\n      getFileDescriptor: function ( file ) {\n        var fstat;\n\n        try {\n          fstat = fs.statSync( file );\n        } catch (ex) {\n          this.removeEntry( file );\n          return { key: file, notFound: true, err: ex };\n        }\n\n        if ( useChecksum ) {\n          return this._getFileDescriptorUsingChecksum( file );\n        }\n\n        return this._getFileDescriptorUsingMtimeAndSize( file, fstat );\n      },\n\n      _getFileDescriptorUsingMtimeAndSize: function ( file, fstat ) {\n        var meta = cache.getKey( file );\n        var cacheExists = !!meta;\n\n        var cSize = fstat.size;\n        var cTime = fstat.mtime.getTime();\n\n        var isDifferentDate;\n        var isDifferentSize;\n\n        if ( !meta ) {\n          meta = { size: cSize, mtime: cTime };\n        } else {\n          isDifferentDate = cTime !== meta.mtime;\n          isDifferentSize = cSize !== meta.size;\n        }\n\n        var nEntry = normalizedEntries[ file ] = {\n          key: file,\n          changed: !cacheExists || isDifferentDate || isDifferentSize,\n          meta: meta\n        };\n\n        return nEntry;\n      },\n\n      _getFileDescriptorUsingChecksum: function ( file ) {\n        var meta = cache.getKey( file );\n        var cacheExists = !!meta;\n\n        var contentBuffer;\n        try {\n          contentBuffer = fs.readFileSync( file );\n        } catch (ex) {\n          contentBuffer = '';\n        }\n\n        var isDifferent = true;\n        var hash = this.getHash( contentBuffer );\n\n        if ( !meta ) {\n          meta = { hash: hash };\n        } else {\n          isDifferent = hash !== meta.hash;\n        }\n\n        var nEntry = normalizedEntries[ file ] = {\n          key: file,\n          changed: !cacheExists || isDifferent,\n          meta: meta\n        };\n\n        return nEntry;\n      },\n\n      /**\n       * Return the list o the files that changed compared\n       * against the ones stored in the cache\n       *\n       * @method getUpdated\n       * @param files {Array} the array of files to compare against the ones in the cache\n       * @returns {Array}\n       */\n      getUpdatedFiles: function ( files ) {\n        var me = this;\n        files = files || [ ];\n\n        return me.normalizeEntries( files ).filter( function ( entry ) {\n          return entry.changed;\n        } ).map( function ( entry ) {\n          return entry.key;\n        } );\n      },\n\n      /**\n       * return the list of files\n       * @method normalizeEntries\n       * @param files\n       * @returns {*}\n       */\n      normalizeEntries: function ( files ) {\n        files = files || [ ];\n\n        var me = this;\n        var nEntries = files.map( function ( file ) {\n          return me.getFileDescriptor( file );\n        } );\n\n        //normalizeEntries = nEntries;\n        return nEntries;\n      },\n\n      /**\n       * Remove an entry from the file-entry-cache. Useful to force the file to still be considered\n       * modified the next time the process is run\n       *\n       * @method removeEntry\n       * @param entryName\n       */\n      removeEntry: function ( entryName ) {\n        delete normalizedEntries[ entryName ];\n        cache.removeKey( entryName );\n      },\n\n      /**\n       * Delete the cache file from the disk\n       * @method deleteCacheFile\n       */\n      deleteCacheFile: function () {\n        cache.removeCacheFile();\n      },\n\n      /**\n       * remove the cache from the file and clear the memory cache\n       */\n      destroy: function () {\n        normalizedEntries = { };\n        cache.destroy();\n      },\n\n      _getMetaForFileUsingCheckSum: function ( cacheEntry ) {\n        var contentBuffer = fs.readFileSync( cacheEntry.key );\n        var hash = this.getHash( contentBuffer );\n        var meta = Object.assign( cacheEntry.meta, { hash: hash } );\n        return meta;\n      },\n\n      _getMetaForFileUsingMtimeAndSize: function ( cacheEntry ) {\n        var stat = fs.statSync( cacheEntry.key );\n        var meta = Object.assign( cacheEntry.meta, {\n          size: stat.size,\n          mtime: stat.mtime.getTime()\n        } );\n        return meta;\n      },\n\n      /**\n       * Sync the files and persist them to the cache\n       * @method reconcile\n       */\n      reconcile: function ( noPrune ) {\n        removeNotFoundFiles();\n\n        noPrune = typeof noPrune === 'undefined' ? true : noPrune;\n\n        var entries = normalizedEntries;\n        var keys = Object.keys( entries );\n\n        if ( keys.length === 0 ) {\n          return;\n        }\n\n        var me = this;\n\n        keys.forEach( function ( entryName ) {\n          var cacheEntry = entries[ entryName ];\n\n          try {\n            var meta = useChecksum ? me._getMetaForFileUsingCheckSum( cacheEntry ) : me._getMetaForFileUsingMtimeAndSize( cacheEntry );\n            cache.setKey( entryName, meta );\n          } catch (err) {\n            // if the file does not exists we don't save it\n            // other errors are just thrown\n            if ( err.code !== 'ENOENT' ) {\n              throw err;\n            }\n          }\n        } );\n\n        cache.save( noPrune );\n      }\n    };\n  }\n};\n\nvar jsonStableStringifyWithoutJsonify = function (obj, opts) {\n    if (!opts) opts = {};\n    if (typeof opts === 'function') opts = { cmp: opts };\n    var space = opts.space || '';\n    if (typeof space === 'number') space = Array(space+1).join(' ');\n    var cycles = (typeof opts.cycles === 'boolean') ? opts.cycles : false;\n    var replacer = opts.replacer || function(key, value) { return value; };\n\n    var cmp = opts.cmp && (function (f) {\n        return function (node) {\n            return function (a, b) {\n                var aobj = { key: a, value: node[a] };\n                var bobj = { key: b, value: node[b] };\n                return f(aobj, bobj);\n            };\n        };\n    })(opts.cmp);\n\n    var seen = [];\n    return (function stringify (parent, key, node, level) {\n        var indent = space ? ('\\n' + new Array(level + 1).join(space)) : '';\n        var colonSeparator = space ? ': ' : ':';\n\n        if (node && node.toJSON && typeof node.toJSON === 'function') {\n            node = node.toJSON();\n        }\n\n        node = replacer.call(parent, key, node);\n\n        if (node === undefined) {\n            return;\n        }\n        if (typeof node !== 'object' || node === null) {\n            return JSON.stringify(node);\n        }\n        if (isArray$2(node)) {\n            var out = [];\n            for (var i = 0; i < node.length; i++) {\n                var item = stringify(node, i, node[i], level+1) || JSON.stringify(null);\n                out.push(indent + space + item);\n            }\n            return '[' + out.join(',') + indent + ']';\n        }\n        else {\n            if (seen.indexOf(node) !== -1) {\n                if (cycles) return JSON.stringify('__cycle__');\n                throw new TypeError('Converting circular structure to JSON');\n            }\n            else seen.push(node);\n\n            var keys = objectKeys(node).sort(cmp && cmp(node));\n            var out = [];\n            for (var i = 0; i < keys.length; i++) {\n                var key = keys[i];\n                var value = stringify(node, key, node[key], level+1);\n\n                if(!value) continue;\n\n                var keyValue = JSON.stringify(key)\n                    + colonSeparator\n                    + value;\n                out.push(indent + space + keyValue);\n            }\n            seen.splice(seen.indexOf(node), 1);\n            return '{' + out.join(',') + indent + '}';\n        }\n    })({ '': obj }, '', obj, 0);\n};\n\nvar isArray$2 = Array.isArray || function (x) {\n    return {}.toString.call(x) === '[object Array]';\n};\n\nvar objectKeys = Object.keys || function (obj) {\n    var has = Object.prototype.hasOwnProperty || function () { return true };\n    var keys = [];\n    for (var key in obj) {\n        if (has.call(obj, key)) keys.push(key);\n    }\n    return keys;\n};\n\n//-----------------------------------------------------------------------------\n// Requirements\n//-----------------------------------------------------------------------------\n\n\n\n\n\n\n\n\n//-----------------------------------------------------------------------------\n// Helpers\n//-----------------------------------------------------------------------------\n\nconst configHashCache = new WeakMap();\nconst nodeVersion = process && process.version;\n\n/**\n * Calculates the hash of the config\n * @param {ConfigArray} config The config.\n * @returns {string} The hash of the config\n */\nfunction hashOfConfigFor(config) {\n    if (!configHashCache.has(config)) {\n        configHashCache.set(config, hash_1(`${pkg.version}_${nodeVersion}_${jsonStableStringifyWithoutJsonify(config)}`));\n    }\n\n    return configHashCache.get(config);\n}\n\n//-----------------------------------------------------------------------------\n// Public Interface\n//-----------------------------------------------------------------------------\n\n/**\n * Lint result cache. This wraps around the file-entry-cache module,\n * transparently removing properties that are difficult or expensive to\n * serialize and adding them back in on retrieval.\n */\nclass LintResultCache {\n\n    /**\n     * Creates a new LintResultCache instance.\n     * @param {string} cacheFileLocation The cache file location.\n     *   configuration lookup by file path).\n     */\n    constructor(cacheFileLocation) {\n        assert(cacheFileLocation, \"Cache file location is required\");\n\n        this.fileEntryCache = cache$3.create(cacheFileLocation);\n    }\n\n    /**\n     * Retrieve cached lint results for a given file path, if present in the\n     * cache. If the file is present and has not been changed, rebuild any\n     * missing result information.\n     * @param {string} filePath The file for which to retrieve lint results.\n     * @param {ConfigArray} config The config of the file.\n     * @returns {Object|null} The rebuilt lint results, or null if the file is\n     *   changed or not in the filesystem.\n     */\n    getCachedLintResults(filePath, config) {\n\n        /*\n         * Cached lint results are valid if and only if:\n         * 1. The file is present in the filesystem\n         * 2. The file has not changed since the time it was previously linted\n         * 3. The ESLint configuration has not changed since the time the file\n         *    was previously linted\n         * If any of these are not true, we will not reuse the lint results.\n         */\n\n        const fileDescriptor = this.fileEntryCache.getFileDescriptor(filePath);\n        const hashOfConfig = hashOfConfigFor(config);\n        const changed = fileDescriptor.changed || fileDescriptor.meta.hashOfConfig !== hashOfConfig;\n\n        if (fileDescriptor.notFound || changed) {\n            return null;\n        }\n\n        // If source is present but null, need to reread the file from the filesystem.\n        if (fileDescriptor.meta.results && fileDescriptor.meta.results.source === null) {\n            fileDescriptor.meta.results.source = fs$2.readFileSync(filePath, \"utf-8\");\n        }\n\n        return fileDescriptor.meta.results;\n    }\n\n    /**\n     * Set the cached lint results for a given file path, after removing any\n     * information that will be both unnecessary and difficult to serialize.\n     * Avoids caching results with an \"output\" property (meaning fixes were\n     * applied), to prevent potentially incorrect results if fixes are not\n     * written to disk.\n     * @param {string} filePath The file for which to set lint results.\n     * @param {ConfigArray} config The config of the file.\n     * @param {Object} result The lint result to be set for the file.\n     * @returns {void}\n     */\n    setCachedLintResults(filePath, config, result) {\n        if (result && Object.prototype.hasOwnProperty.call(result, \"output\")) {\n            return;\n        }\n\n        const fileDescriptor = this.fileEntryCache.getFileDescriptor(filePath);\n\n        if (fileDescriptor && !fileDescriptor.notFound) {\n\n            // Serialize the result, except that we want to remove the file source if present.\n            const resultToSerialize = Object.assign({}, result);\n\n            /*\n             * Set result.source to null.\n             * In `getCachedLintResults`, if source is explicitly null, we will\n             * read the file from the filesystem to set the value again.\n             */\n            if (Object.prototype.hasOwnProperty.call(resultToSerialize, \"source\")) {\n                resultToSerialize.source = null;\n            }\n\n            fileDescriptor.meta.results = resultToSerialize;\n            fileDescriptor.meta.hashOfConfig = hashOfConfigFor(config);\n        }\n    }\n\n    /**\n     * Persists the in-memory cache to disk.\n     * @returns {void}\n     */\n    reconcile() {\n        this.fileEntryCache.reconcile();\n    }\n}\n\nvar lintResultCache = LintResultCache;\n\n/*\n * The CLI object should *not* call process.exit() directly. It should only return\n * exit codes. This allows other programs to use the CLI object and still control\n * when the program exits.\n */\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\n\n\n\n\n\n\n\nconst { Linter: Linter$2 } = linter$1;\n\nconst { CascadingConfigArrayFactory: CascadingConfigArrayFactory$2 } = cascadingConfigArrayFactory;\nconst { IgnorePattern: IgnorePattern$7, getUsedExtractedConfigs: getUsedExtractedConfigs$1 } = configArray$1;\nconst { FileEnumerator: FileEnumerator$1 } = fileEnumerator;\n\n\n\nconst debug$a = src(\"eslint:cli-engine\");\nconst validFixTypes = new Set([\"problem\", \"suggestion\", \"layout\"]);\n\n//------------------------------------------------------------------------------\n// Typedefs\n//------------------------------------------------------------------------------\n\n// For VSCode IntelliSense\n/** @typedef {import(\"../shared/types\").ConfigData} ConfigData */\n/** @typedef {import(\"../shared/types\").LintMessage} LintMessage */\n/** @typedef {import(\"../shared/types\").ParserOptions} ParserOptions */\n/** @typedef {import(\"../shared/types\").Plugin} Plugin */\n/** @typedef {import(\"../shared/types\").RuleConf} RuleConf */\n/** @typedef {import(\"../shared/types\").Rule} Rule */\n/** @typedef {ReturnType<CascadingConfigArrayFactory[\"getConfigArrayForFile\"]>} ConfigArray */\n/** @typedef {ReturnType<ConfigArray[\"extractConfig\"]>} ExtractedConfig */\n\n/**\n * The options to configure a CLI engine with.\n * @typedef {Object} CLIEngineOptions\n * @property {boolean} allowInlineConfig Enable or disable inline configuration comments.\n * @property {ConfigData} baseConfig Base config object, extended by all configs used with this CLIEngine instance\n * @property {boolean} cache Enable result caching.\n * @property {string} cacheLocation The cache file to use instead of .eslintcache.\n * @property {string} configFile The configuration file to use.\n * @property {string} cwd The value to use for the current working directory.\n * @property {string[]} envs An array of environments to load.\n * @property {string[]} extensions An array of file extensions to check.\n * @property {boolean|Function} fix Execute in autofix mode. If a function, should return a boolean.\n * @property {string[]} fixTypes Array of rule types to apply fixes for.\n * @property {string[]} globals An array of global variables to declare.\n * @property {boolean} ignore False disables use of .eslintignore.\n * @property {string} ignorePath The ignore file to use instead of .eslintignore.\n * @property {string|string[]} ignorePattern One or more glob patterns to ignore.\n * @property {boolean} useEslintrc False disables looking for .eslintrc\n * @property {string} parser The name of the parser to use.\n * @property {ParserOptions} parserOptions An object of parserOption settings to use.\n * @property {string[]} plugins An array of plugins to load.\n * @property {Record<string,RuleConf>} rules An object of rules to use.\n * @property {string[]} rulePaths An array of directories to load custom rules from.\n * @property {boolean} reportUnusedDisableDirectives `true` adds reports for unused eslint-disable directives\n * @property {boolean} globInputPaths Set to false to skip glob resolution of input file paths to lint (default: true). If false, each input file paths is assumed to be a non-glob path to an existing file.\n * @property {string} resolvePluginsRelativeTo The folder where plugins should be resolved from, defaulting to the CWD\n */\n\n/**\n * A linting result.\n * @typedef {Object} LintResult\n * @property {string} filePath The path to the file that was linted.\n * @property {LintMessage[]} messages All of the messages for the result.\n * @property {number} errorCount Number of errors for the result.\n * @property {number} warningCount Number of warnings for the result.\n * @property {number} fixableErrorCount Number of fixable errors for the result.\n * @property {number} fixableWarningCount Number of fixable warnings for the result.\n * @property {string} [source] The source code of the file that was linted.\n * @property {string} [output] The source code of the file that was linted, with as many fixes applied as possible.\n */\n\n/**\n * Information of deprecated rules.\n * @typedef {Object} DeprecatedRuleInfo\n * @property {string} ruleId The rule ID.\n * @property {string[]} replacedBy The rule IDs that replace this deprecated rule.\n */\n\n/**\n * Linting results.\n * @typedef {Object} LintReport\n * @property {LintResult[]} results All of the result.\n * @property {number} errorCount Number of errors for the result.\n * @property {number} warningCount Number of warnings for the result.\n * @property {number} fixableErrorCount Number of fixable errors for the result.\n * @property {number} fixableWarningCount Number of fixable warnings for the result.\n * @property {DeprecatedRuleInfo[]} usedDeprecatedRules The list of used deprecated rules.\n */\n\n/**\n * Private data for CLIEngine.\n * @typedef {Object} CLIEngineInternalSlots\n * @property {Map<string, Plugin>} additionalPluginPool The map for additional plugins.\n * @property {string} cacheFilePath The path to the cache of lint results.\n * @property {CascadingConfigArrayFactory} configArrayFactory The factory of configs.\n * @property {(filePath: string) => boolean} defaultIgnores The default predicate function to check if a file ignored or not.\n * @property {FileEnumerator} fileEnumerator The file enumerator.\n * @property {ConfigArray[]} lastConfigArrays The list of config arrays that the last `executeOnFiles` or `executeOnText` used.\n * @property {LintResultCache|null} lintResultCache The cache of lint results.\n * @property {Linter} linter The linter instance which has loaded rules.\n * @property {CLIEngineOptions} options The normalized options of this instance.\n */\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/** @type {WeakMap<CLIEngine, CLIEngineInternalSlots>} */\nconst internalSlotsMap$5 = new WeakMap();\n\n/**\n * Determines if each fix type in an array is supported by ESLint and throws\n * an error if not.\n * @param {string[]} fixTypes An array of fix types to check.\n * @returns {void}\n * @throws {Error} If an invalid fix type is found.\n */\nfunction validateFixTypes(fixTypes) {\n    for (const fixType of fixTypes) {\n        if (!validFixTypes.has(fixType)) {\n            throw new Error(`Invalid fix type \"${fixType}\" found.`);\n        }\n    }\n}\n\n/**\n * It will calculate the error and warning count for collection of messages per file\n * @param {LintMessage[]} messages Collection of messages\n * @returns {Object} Contains the stats\n * @private\n */\nfunction calculateStatsPerFile(messages) {\n    return messages.reduce((stat, message) => {\n        if (message.fatal || message.severity === 2) {\n            stat.errorCount++;\n            if (message.fix) {\n                stat.fixableErrorCount++;\n            }\n        } else {\n            stat.warningCount++;\n            if (message.fix) {\n                stat.fixableWarningCount++;\n            }\n        }\n        return stat;\n    }, {\n        errorCount: 0,\n        warningCount: 0,\n        fixableErrorCount: 0,\n        fixableWarningCount: 0\n    });\n}\n\n/**\n * It will calculate the error and warning count for collection of results from all files\n * @param {LintResult[]} results Collection of messages from all the files\n * @returns {Object} Contains the stats\n * @private\n */\nfunction calculateStatsPerRun(results) {\n    return results.reduce((stat, result) => {\n        stat.errorCount += result.errorCount;\n        stat.warningCount += result.warningCount;\n        stat.fixableErrorCount += result.fixableErrorCount;\n        stat.fixableWarningCount += result.fixableWarningCount;\n        return stat;\n    }, {\n        errorCount: 0,\n        warningCount: 0,\n        fixableErrorCount: 0,\n        fixableWarningCount: 0\n    });\n}\n\n/**\n * Processes an source code using ESLint.\n * @param {Object} config The config object.\n * @param {string} config.text The source code to verify.\n * @param {string} config.cwd The path to the current working directory.\n * @param {string|undefined} config.filePath The path to the file of `text`. If this is undefined, it uses `<text>`.\n * @param {ConfigArray} config.config The config.\n * @param {boolean} config.fix If `true` then it does fix.\n * @param {boolean} config.allowInlineConfig If `true` then it uses directive comments.\n * @param {boolean} config.reportUnusedDisableDirectives If `true` then it reports unused `eslint-disable` comments.\n * @param {RegExp} config.extensionRegExp The `RegExp` object that tests if a file path has the allowed file extensions.\n * @param {Linter} config.linter The linter instance to verify.\n * @returns {LintResult} The result of linting.\n * @private\n */\nfunction verifyText({\n    text,\n    cwd,\n    filePath: providedFilePath,\n    config,\n    fix,\n    allowInlineConfig,\n    reportUnusedDisableDirectives,\n    extensionRegExp,\n    linter\n}) {\n    const filePath = providedFilePath || \"<text>\";\n\n    debug$a(`Lint ${filePath}`);\n\n    /*\n     * Verify.\n     * `config.extractConfig(filePath)` requires an absolute path, but `linter`\n     * doesn't know CWD, so it gives `linter` an absolute path always.\n     */\n    const filePathToVerify = filePath === \"<text>\" ? path$1.join(cwd, filePath) : filePath;\n    const { fixed, messages, output } = linter.verifyAndFix(\n        text,\n        config,\n        {\n            allowInlineConfig,\n            filename: filePathToVerify,\n            fix,\n            reportUnusedDisableDirectives,\n\n            /**\n             * Check if the linter should adopt a given code block or not.\n             * Currently, the linter adopts code blocks if the name matches `--ext` option.\n             * In the future, `overrides` in the configuration would affect the adoption (https://github.com/eslint/rfcs/pull/20).\n             * @param {string} blockFilename The virtual filename of a code block.\n             * @returns {boolean} `true` if the linter should adopt the code block.\n             */\n            filterCodeBlock(blockFilename) {\n                return extensionRegExp.test(blockFilename);\n            }\n        }\n    );\n\n    // Tweak and return.\n    const result = {\n        filePath,\n        messages,\n        ...calculateStatsPerFile(messages)\n    };\n\n    if (fixed) {\n        result.output = output;\n    }\n    if (\n        result.errorCount + result.warningCount > 0 &&\n        typeof result.output === \"undefined\"\n    ) {\n        result.source = text;\n    }\n\n    return result;\n}\n\n/**\n * Returns result with warning by ignore settings\n * @param {string} filePath File path of checked code\n * @param {string} baseDir  Absolute path of base directory\n * @returns {LintResult} Result with single warning\n * @private\n */\nfunction createIgnoreResult(filePath, baseDir) {\n    let message;\n    const isHidden = /^\\./u.test(path$1.basename(filePath));\n    const isInNodeModules = baseDir && path$1.relative(baseDir, filePath).startsWith(\"node_modules\");\n    const isInBowerComponents = baseDir && path$1.relative(baseDir, filePath).startsWith(\"bower_components\");\n\n    if (isHidden) {\n        message = \"File ignored by default.  Use a negated ignore pattern (like \\\"--ignore-pattern '!<relative/path/to/filename>'\\\") to override.\";\n    } else if (isInNodeModules) {\n        message = \"File ignored by default. Use \\\"--ignore-pattern '!node_modules/*'\\\" to override.\";\n    } else if (isInBowerComponents) {\n        message = \"File ignored by default. Use \\\"--ignore-pattern '!bower_components/*'\\\" to override.\";\n    } else {\n        message = \"File ignored because of a matching ignore pattern. Use \\\"--no-ignore\\\" to override.\";\n    }\n\n    return {\n        filePath: path$1.resolve(filePath),\n        messages: [\n            {\n                fatal: false,\n                severity: 1,\n                message\n            }\n        ],\n        errorCount: 0,\n        warningCount: 1,\n        fixableErrorCount: 0,\n        fixableWarningCount: 0\n    };\n}\n\n/**\n * Get a rule.\n * @param {string} ruleId The rule ID to get.\n * @param {ConfigArray[]} configArrays The config arrays that have plugin rules.\n * @returns {Rule|null} The rule or null.\n */\nfunction getRule$1(ruleId, configArrays) {\n    for (const configArray of configArrays) {\n        const rule = configArray.pluginRules.get(ruleId);\n\n        if (rule) {\n            return rule;\n        }\n    }\n    return rules.get(ruleId) || null;\n}\n\n/**\n * Collect used deprecated rules.\n * @param {ConfigArray[]} usedConfigArrays The config arrays which were used.\n * @returns {IterableIterator<DeprecatedRuleInfo>} Used deprecated rules.\n */\nfunction *iterateRuleDeprecationWarnings(usedConfigArrays) {\n    const processedRuleIds = new Set();\n\n    // Flatten used configs.\n    /** @type {ExtractedConfig[]} */\n    const configs = [].concat(\n        ...usedConfigArrays.map(getUsedExtractedConfigs$1)\n    );\n\n    // Traverse rule configs.\n    for (const config of configs) {\n        for (const [ruleId, ruleConfig] of Object.entries(config.rules)) {\n\n            // Skip if it was processed.\n            if (processedRuleIds.has(ruleId)) {\n                continue;\n            }\n            processedRuleIds.add(ruleId);\n\n            // Skip if it's not used.\n            if (!configOps.getRuleSeverity(ruleConfig)) {\n                continue;\n            }\n            const rule = getRule$1(ruleId, usedConfigArrays);\n\n            // Skip if it's not deprecated.\n            if (!(rule && rule.meta && rule.meta.deprecated)) {\n                continue;\n            }\n\n            // This rule was used and deprecated.\n            yield {\n                ruleId,\n                replacedBy: rule.meta.replacedBy || []\n            };\n        }\n    }\n}\n\n/**\n * Checks if the given message is an error message.\n * @param {LintMessage} message The message to check.\n * @returns {boolean} Whether or not the message is an error message.\n * @private\n */\nfunction isErrorMessage(message) {\n    return message.severity === 2;\n}\n\n\n/**\n * return the cacheFile to be used by eslint, based on whether the provided parameter is\n * a directory or looks like a directory (ends in `path.sep`), in which case the file\n * name will be the `cacheFile/.cache_hashOfCWD`\n *\n * if cacheFile points to a file or looks like a file then in will just use that file\n * @param {string} cacheFile The name of file to be used to store the cache\n * @param {string} cwd Current working directory\n * @returns {string} the resolved path to the cache file\n */\nfunction getCacheFile(cacheFile, cwd) {\n\n    /*\n     * make sure the path separators are normalized for the environment/os\n     * keeping the trailing path separator if present\n     */\n    const normalizedCacheFile = path$1.normalize(cacheFile);\n\n    const resolvedCacheFile = path$1.resolve(cwd, normalizedCacheFile);\n    const looksLikeADirectory = normalizedCacheFile.slice(-1) === path$1.sep;\n\n    /**\n     * return the name for the cache file in case the provided parameter is a directory\n     * @returns {string} the resolved path to the cacheFile\n     */\n    function getCacheFileForDirectory() {\n        return path$1.join(resolvedCacheFile, `.cache_${hash_1(cwd)}`);\n    }\n\n    let fileStats;\n\n    try {\n        fileStats = fs$2.lstatSync(resolvedCacheFile);\n    } catch (ex) {\n        fileStats = null;\n    }\n\n\n    /*\n     * in case the file exists we need to verify if the provided path\n     * is a directory or a file. If it is a directory we want to create a file\n     * inside that directory\n     */\n    if (fileStats) {\n\n        /*\n         * is a directory or is a file, but the original file the user provided\n         * looks like a directory but `path.resolve` removed the `last path.sep`\n         * so we need to still treat this like a directory\n         */\n        if (fileStats.isDirectory() || looksLikeADirectory) {\n            return getCacheFileForDirectory();\n        }\n\n        // is file so just use that file\n        return resolvedCacheFile;\n    }\n\n    /*\n     * here we known the file or directory doesn't exist,\n     * so we will try to infer if its a directory if it looks like a directory\n     * for the current operating system.\n     */\n\n    // if the last character passed is a path separator we assume is a directory\n    if (looksLikeADirectory) {\n        return getCacheFileForDirectory();\n    }\n\n    return resolvedCacheFile;\n}\n\n/**\n * Convert a string array to a boolean map.\n * @param {string[]|null} keys The keys to assign true.\n * @param {boolean} defaultValue The default value for each property.\n * @param {string} displayName The property name which is used in error message.\n * @returns {Record<string,boolean>} The boolean map.\n */\nfunction toBooleanMap(keys, defaultValue, displayName) {\n    if (keys && !Array.isArray(keys)) {\n        throw new Error(`${displayName} must be an array.`);\n    }\n    if (keys && keys.length > 0) {\n        return keys.reduce((map, def) => {\n            const [key, value] = def.split(\":\");\n\n            if (key !== \"__proto__\") {\n                map[key] = value === void 0\n                    ? defaultValue\n                    : value === \"true\";\n            }\n\n            return map;\n        }, {});\n    }\n    return void 0;\n}\n\n/**\n * Create a config data from CLI options.\n * @param {CLIEngineOptions} options The options\n * @returns {ConfigData|null} The created config data.\n */\nfunction createConfigDataFromOptions(options) {\n    const {\n        ignorePattern,\n        parser,\n        parserOptions,\n        plugins,\n        rules\n    } = options;\n    const env = toBooleanMap(options.envs, true, \"envs\");\n    const globals = toBooleanMap(options.globals, false, \"globals\");\n\n    if (\n        env === void 0 &&\n        globals === void 0 &&\n        (ignorePattern === void 0 || ignorePattern.length === 0) &&\n        parser === void 0 &&\n        parserOptions === void 0 &&\n        plugins === void 0 &&\n        rules === void 0\n    ) {\n        return null;\n    }\n    return {\n        env,\n        globals,\n        ignorePatterns: ignorePattern,\n        parser,\n        parserOptions,\n        plugins,\n        rules\n    };\n}\n\n/**\n * Checks whether a directory exists at the given location\n * @param {string} resolvedPath A path from the CWD\n * @returns {boolean} `true` if a directory exists\n */\nfunction directoryExists(resolvedPath) {\n    try {\n        return fs$2.statSync(resolvedPath).isDirectory();\n    } catch (error) {\n        if (error && error.code === \"ENOENT\") {\n            return false;\n        }\n        throw error;\n    }\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\nclass CLIEngine {\n\n    /**\n     * Creates a new instance of the core CLI engine.\n     * @param {CLIEngineOptions} providedOptions The options for this instance.\n     */\n    constructor(providedOptions) {\n        const options = Object.assign(\n            Object.create(null),\n            defaultCliOptions,\n            { cwd: process.cwd() },\n            providedOptions\n        );\n\n        if (options.fix === void 0) {\n            options.fix = false;\n        }\n\n        const additionalPluginPool = new Map();\n        const cacheFilePath = getCacheFile(\n            options.cacheLocation || options.cacheFile,\n            options.cwd\n        );\n        const configArrayFactory = new CascadingConfigArrayFactory$2({\n            additionalPluginPool,\n            baseConfig: options.baseConfig || null,\n            cliConfig: createConfigDataFromOptions(options),\n            cwd: options.cwd,\n            ignorePath: options.ignorePath,\n            resolvePluginsRelativeTo: options.resolvePluginsRelativeTo,\n            rulePaths: options.rulePaths,\n            specificConfigPath: options.configFile,\n            useEslintrc: options.useEslintrc\n        });\n        const fileEnumerator = new FileEnumerator$1({\n            configArrayFactory,\n            cwd: options.cwd,\n            extensions: options.extensions,\n            globInputPaths: options.globInputPaths,\n            errorOnUnmatchedPattern: options.errorOnUnmatchedPattern,\n            ignore: options.ignore\n        });\n        const lintResultCache$1 =\n            options.cache ? new lintResultCache(cacheFilePath) : null;\n        const linter = new Linter$2({ cwd: options.cwd });\n\n        /** @type {ConfigArray[]} */\n        const lastConfigArrays = [configArrayFactory.getConfigArrayForFile()];\n\n        // Store private data.\n        internalSlotsMap$5.set(this, {\n            additionalPluginPool,\n            cacheFilePath,\n            configArrayFactory,\n            defaultIgnores: IgnorePattern$7.createDefaultIgnore(options.cwd),\n            fileEnumerator,\n            lastConfigArrays,\n            lintResultCache: lintResultCache$1,\n            linter,\n            options\n        });\n\n        // setup special filter for fixes\n        if (options.fix && options.fixTypes && options.fixTypes.length > 0) {\n            debug$a(`Using fix types ${options.fixTypes}`);\n\n            // throw an error if any invalid fix types are found\n            validateFixTypes(options.fixTypes);\n\n            // convert to Set for faster lookup\n            const fixTypes = new Set(options.fixTypes);\n\n            // save original value of options.fix in case it's a function\n            const originalFix = (typeof options.fix === \"function\")\n                ? options.fix : () => true;\n\n            options.fix = message => {\n                const rule = message.ruleId && getRule$1(message.ruleId, lastConfigArrays);\n                const matches = rule && rule.meta && fixTypes.has(rule.meta.type);\n\n                return matches && originalFix(message);\n            };\n        }\n    }\n\n    getRules() {\n        const { lastConfigArrays } = internalSlotsMap$5.get(this);\n\n        return new Map(function *() {\n            yield* rules;\n\n            for (const configArray of lastConfigArrays) {\n                yield* configArray.pluginRules;\n            }\n        }());\n    }\n\n    /**\n     * Returns results that only contains errors.\n     * @param {LintResult[]} results The results to filter.\n     * @returns {LintResult[]} The filtered results.\n     */\n    static getErrorResults(results) {\n        const filtered = [];\n\n        results.forEach(result => {\n            const filteredMessages = result.messages.filter(isErrorMessage);\n\n            if (filteredMessages.length > 0) {\n                filtered.push({\n                    ...result,\n                    messages: filteredMessages,\n                    errorCount: filteredMessages.length,\n                    warningCount: 0,\n                    fixableErrorCount: result.fixableErrorCount,\n                    fixableWarningCount: 0\n                });\n            }\n        });\n\n        return filtered;\n    }\n\n    /**\n     * Outputs fixes from the given results to files.\n     * @param {LintReport} report The report object created by CLIEngine.\n     * @returns {void}\n     */\n    static outputFixes(report) {\n        report.results.filter(result => Object.prototype.hasOwnProperty.call(result, \"output\")).forEach(result => {\n            fs$2.writeFileSync(result.filePath, result.output);\n        });\n    }\n\n\n    /**\n     * Add a plugin by passing its configuration\n     * @param {string} name Name of the plugin.\n     * @param {Plugin} pluginObject Plugin configuration object.\n     * @returns {void}\n     */\n    addPlugin(name, pluginObject) {\n        const {\n            additionalPluginPool,\n            configArrayFactory,\n            lastConfigArrays\n        } = internalSlotsMap$5.get(this);\n\n        additionalPluginPool.set(name, pluginObject);\n        configArrayFactory.clearCache();\n        lastConfigArrays.length = 1;\n        lastConfigArrays[0] = configArrayFactory.getConfigArrayForFile();\n    }\n\n    /**\n     * Resolves the patterns passed into executeOnFiles() into glob-based patterns\n     * for easier handling.\n     * @param {string[]} patterns The file patterns passed on the command line.\n     * @returns {string[]} The equivalent glob patterns.\n     */\n    resolveFileGlobPatterns(patterns) {\n        const { options } = internalSlotsMap$5.get(this);\n\n        if (options.globInputPaths === false) {\n            return patterns.filter(Boolean);\n        }\n\n        const extensions = options.extensions.map(ext => ext.replace(/^\\./u, \"\"));\n        const dirSuffix = `/**/*.{${extensions.join(\",\")}}`;\n\n        return patterns.filter(Boolean).map(pathname => {\n            const resolvedPath = path$1.resolve(options.cwd, pathname);\n            const newPath = directoryExists(resolvedPath)\n                ? pathname.replace(/[/\\\\]$/u, \"\") + dirSuffix\n                : pathname;\n\n            return path$1.normalize(newPath).replace(/\\\\/gu, \"/\");\n        });\n    }\n\n    /**\n     * Executes the current configuration on an array of file and directory names.\n     * @param {string[]} patterns An array of file and directory names.\n     * @returns {LintReport} The results for all files that were linted.\n     */\n    executeOnFiles(patterns) {\n        const {\n            cacheFilePath,\n            fileEnumerator,\n            lastConfigArrays,\n            lintResultCache,\n            linter,\n            options: {\n                allowInlineConfig,\n                cache,\n                cwd,\n                fix,\n                reportUnusedDisableDirectives\n            }\n        } = internalSlotsMap$5.get(this);\n        const results = [];\n        const startTime = Date.now();\n\n        // Clear the last used config arrays.\n        lastConfigArrays.length = 0;\n\n        // Delete cache file; should this do here?\n        if (!cache) {\n            try {\n                fs$2.unlinkSync(cacheFilePath);\n            } catch (error) {\n                const errorCode = error && error.code;\n\n                // Ignore errors when no such file exists or file system is read only (and cache file does not exist)\n                if (errorCode !== \"ENOENT\" && !(errorCode === \"EROFS\" && !fs$2.existsSync(cacheFilePath))) {\n                    throw error;\n                }\n            }\n        }\n\n        // Iterate source code files.\n        for (const { config, filePath, ignored } of fileEnumerator.iterateFiles(patterns)) {\n            if (ignored) {\n                results.push(createIgnoreResult(filePath, cwd));\n                continue;\n            }\n\n            /*\n             * Store used configs for:\n             * - this method uses to collect used deprecated rules.\n             * - `getRules()` method uses to collect all loaded rules.\n             * - `--fix-type` option uses to get the loaded rule's meta data.\n             */\n            if (!lastConfigArrays.includes(config)) {\n                lastConfigArrays.push(config);\n            }\n\n            // Skip if there is cached result.\n            if (lintResultCache) {\n                const cachedResult =\n                    lintResultCache.getCachedLintResults(filePath, config);\n\n                if (cachedResult) {\n                    const hadMessages =\n                        cachedResult.messages &&\n                        cachedResult.messages.length > 0;\n\n                    if (hadMessages && fix) {\n                        debug$a(`Reprocessing cached file to allow autofix: ${filePath}`);\n                    } else {\n                        debug$a(`Skipping file since it hasn't changed: ${filePath}`);\n                        results.push(cachedResult);\n                        continue;\n                    }\n                }\n            }\n\n            // Do lint.\n            const result = verifyText({\n                text: fs$2.readFileSync(filePath, \"utf8\"),\n                filePath,\n                config,\n                cwd,\n                fix,\n                allowInlineConfig,\n                reportUnusedDisableDirectives,\n                extensionRegExp: fileEnumerator.extensionRegExp,\n                linter\n            });\n\n            results.push(result);\n\n            /*\n             * Store the lint result in the LintResultCache.\n             * NOTE: The LintResultCache will remove the file source and any\n             * other properties that are difficult to serialize, and will\n             * hydrate those properties back in on future lint runs.\n             */\n            if (lintResultCache) {\n                lintResultCache.setCachedLintResults(filePath, config, result);\n            }\n        }\n\n        // Persist the cache to disk.\n        if (lintResultCache) {\n            lintResultCache.reconcile();\n        }\n\n        // Collect used deprecated rules.\n        const usedDeprecatedRules = Array.from(\n            iterateRuleDeprecationWarnings(lastConfigArrays)\n        );\n\n        debug$a(`Linting complete in: ${Date.now() - startTime}ms`);\n        return {\n            results,\n            ...calculateStatsPerRun(results),\n            usedDeprecatedRules\n        };\n    }\n\n    /**\n     * Executes the current configuration on text.\n     * @param {string} text A string of JavaScript code to lint.\n     * @param {string} [filename] An optional string representing the texts filename.\n     * @param {boolean} [warnIgnored] Always warn when a file is ignored\n     * @returns {LintReport} The results for the linting.\n     */\n    executeOnText(text, filename, warnIgnored) {\n        const {\n            configArrayFactory,\n            fileEnumerator,\n            lastConfigArrays,\n            linter,\n            options: {\n                allowInlineConfig,\n                cwd,\n                fix,\n                reportUnusedDisableDirectives\n            }\n        } = internalSlotsMap$5.get(this);\n        const results = [];\n        const startTime = Date.now();\n        const resolvedFilename = filename && path$1.resolve(cwd, filename);\n\n        // Clear the last used config arrays.\n        lastConfigArrays.length = 0;\n\n        if (resolvedFilename && this.isPathIgnored(resolvedFilename)) {\n            if (warnIgnored) {\n                results.push(createIgnoreResult(resolvedFilename, cwd));\n            }\n        } else {\n            const config = configArrayFactory.getConfigArrayForFile(\n                resolvedFilename || \"__placeholder__.js\"\n            );\n\n            /*\n             * Store used configs for:\n             * - this method uses to collect used deprecated rules.\n             * - `getRules()` method uses to collect all loaded rules.\n             * - `--fix-type` option uses to get the loaded rule's meta data.\n             */\n            lastConfigArrays.push(config);\n\n            // Do lint.\n            results.push(verifyText({\n                text,\n                filePath: resolvedFilename,\n                config,\n                cwd,\n                fix,\n                allowInlineConfig,\n                reportUnusedDisableDirectives,\n                extensionRegExp: fileEnumerator.extensionRegExp,\n                linter\n            }));\n        }\n\n        // Collect used deprecated rules.\n        const usedDeprecatedRules = Array.from(\n            iterateRuleDeprecationWarnings(lastConfigArrays)\n        );\n\n        debug$a(`Linting complete in: ${Date.now() - startTime}ms`);\n        return {\n            results,\n            ...calculateStatsPerRun(results),\n            usedDeprecatedRules\n        };\n    }\n\n    /**\n     * Returns a configuration object for the given file based on the CLI options.\n     * This is the same logic used by the ESLint CLI executable to determine\n     * configuration for each file it processes.\n     * @param {string} filePath The path of the file to retrieve a config object for.\n     * @returns {ConfigData} A configuration object for the file.\n     */\n    getConfigForFile(filePath) {\n        const { configArrayFactory, options } = internalSlotsMap$5.get(this);\n        const absolutePath = path$1.resolve(options.cwd, filePath);\n\n        if (directoryExists(absolutePath)) {\n            throw Object.assign(\n                new Error(\"'filePath' should not be a directory path.\"),\n                { messageTemplate: \"print-config-with-directory-path\" }\n            );\n        }\n\n        return configArrayFactory\n            .getConfigArrayForFile(absolutePath)\n            .extractConfig(absolutePath)\n            .toCompatibleObjectAsConfigFileContent();\n    }\n\n    /**\n     * Checks if a given path is ignored by ESLint.\n     * @param {string} filePath The path of the file to check.\n     * @returns {boolean} Whether or not the given path is ignored.\n     */\n    isPathIgnored(filePath) {\n        const {\n            configArrayFactory,\n            defaultIgnores,\n            options: { cwd, ignore }\n        } = internalSlotsMap$5.get(this);\n        const absolutePath = path$1.resolve(cwd, filePath);\n\n        if (ignore) {\n            const config = configArrayFactory\n                .getConfigArrayForFile(absolutePath)\n                .extractConfig(absolutePath);\n            const ignores = config.ignores || defaultIgnores;\n\n            return ignores(absolutePath);\n        }\n\n        return defaultIgnores(absolutePath);\n    }\n\n    /**\n     * Returns the formatter representing the given format or null if no formatter\n     * with the given name can be found.\n     * @param {string} [format] The name of the format to load or the path to a\n     *      custom formatter.\n     * @returns {Function} The formatter function or null if not found.\n     */\n    getFormatter(format) {\n\n        // default is stylish\n        const resolvedFormatName = format || \"stylish\";\n\n        // only strings are valid formatters\n        if (typeof resolvedFormatName === \"string\") {\n\n            // replace \\ with / for Windows compatibility\n            const normalizedFormatName = resolvedFormatName.replace(/\\\\/gu, \"/\");\n\n            const slots = internalSlotsMap$5.get(this);\n            const cwd = slots ? slots.options.cwd : process.cwd();\n            const namespace = naming.getNamespaceFromTerm(normalizedFormatName);\n\n            let formatterPath;\n\n            // if there's a slash, then it's a file (TODO: this check seems dubious for scoped npm packages)\n            if (!namespace && normalizedFormatName.indexOf(\"/\") > -1) {\n                formatterPath = path$1.resolve(cwd, normalizedFormatName);\n            } else {\n                try {\n                    const npmFormat = naming.normalizePackageName(normalizedFormatName, \"eslint-formatter\");\n\n                    formatterPath = relativeModuleResolver.resolve(npmFormat, path$1.join(cwd, \"__placeholder__.js\"));\n                } catch (e) {\n                    formatterPath = path$1.resolve(__dirname, \"formatters\", normalizedFormatName);\n                }\n            }\n\n            try {\n                return commonjsRequire(formatterPath);\n            } catch (ex) {\n                ex.message = `There was a problem loading formatter: ${formatterPath}\\nError: ${ex.message}`;\n                throw ex;\n            }\n\n        } else {\n            return null;\n        }\n    }\n}\n\nCLIEngine.version = pkg.version;\nCLIEngine.getFormatter = CLIEngine.prototype.getFormatter;\n\nvar cliEngine = {\n    CLIEngine,\n\n    /**\n     * Get the internal slots of a given CLIEngine instance for tests.\n     * @param {CLIEngine} instance The CLIEngine instance to get.\n     * @returns {CLIEngineInternalSlots} The internal slots.\n     */\n    getCLIEngineInternalSlots(instance) {\n        return internalSlotsMap$5.get(instance);\n    }\n};\n\nconst { CLIEngine: CLIEngine$1 } = cliEngine;\n\nvar cliEngine$1 = {\n    CLIEngine: CLIEngine$1\n};\n\n/* global describe, it */\n\n/*\n * This is a wrapper around mocha to allow for DRY unittests for eslint\n * Format:\n * RuleTester.run(\"{ruleName}\", {\n *      valid: [\n *          \"{code}\",\n *          { code: \"{code}\", options: {options}, globals: {globals}, parser: \"{parser}\", settings: {settings} }\n *      ],\n *      invalid: [\n *          { code: \"{code}\", errors: {numErrors} },\n *          { code: \"{code}\", errors: [\"{errorMessage}\"] },\n *          { code: \"{code}\", options: {options}, globals: {globals}, parser: \"{parser}\", settings: {settings}, errors: [{ message: \"{errorMessage}\", type: \"{errorNodeType}\"}] }\n *      ]\n *  });\n *\n * Variables:\n * {code} - String that represents the code to be tested\n * {options} - Arguments that are passed to the configurable rules.\n * {globals} - An object representing a list of variables that are\n *             registered as globals\n * {parser} - String representing the parser to use\n * {settings} - An object representing global settings for all rules\n * {numErrors} - If failing case doesn't need to check error message,\n *               this integer will specify how many errors should be\n *               received\n * {errorMessage} - Message that is returned by the rule on failure\n * {errorNodeType} - AST node type that is returned by they rule as\n *                   a cause of the failure.\n */\n\n//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nconst\n    { getRuleOptionsSchema: getRuleOptionsSchema$1, validate: validate$4 } = configValidator,\n    { Linter: Linter$3, SourceCodeFixer: SourceCodeFixer$1, interpolate: interpolate$1 } = linter$1;\n\nconst ajv$3 = ajv$1({ strictDefaults: true });\n\n//------------------------------------------------------------------------------\n// Private Members\n//------------------------------------------------------------------------------\n\n/*\n * testerDefaultConfig must not be modified as it allows to reset the tester to\n * the initial default configuration\n */\nconst testerDefaultConfig = { rules: {} };\nlet defaultConfig = { rules: {} };\n\n/*\n * List every parameters possible on a test case that are not related to eslint\n * configuration\n */\nconst RuleTesterParameters = [\n    \"code\",\n    \"filename\",\n    \"options\",\n    \"errors\",\n    \"output\"\n];\n\nconst hasOwnProperty$1 = Function.call.bind(Object.hasOwnProperty);\n\n/**\n * Clones a given value deeply.\n * Note: This ignores `parent` property.\n * @param {any} x A value to clone.\n * @returns {any} A cloned value.\n */\nfunction cloneDeeplyExcludesParent(x) {\n    if (typeof x === \"object\" && x !== null) {\n        if (Array.isArray(x)) {\n            return x.map(cloneDeeplyExcludesParent);\n        }\n\n        const retv = {};\n\n        for (const key in x) {\n            if (key !== \"parent\" && hasOwnProperty$1(x, key)) {\n                retv[key] = cloneDeeplyExcludesParent(x[key]);\n            }\n        }\n\n        return retv;\n    }\n\n    return x;\n}\n\n/**\n * Freezes a given value deeply.\n * @param {any} x A value to freeze.\n * @returns {void}\n */\nfunction freezeDeeply(x) {\n    if (typeof x === \"object\" && x !== null) {\n        if (Array.isArray(x)) {\n            x.forEach(freezeDeeply);\n        } else {\n            for (const key in x) {\n                if (key !== \"parent\" && hasOwnProperty$1(x, key)) {\n                    freezeDeeply(x[key]);\n                }\n            }\n        }\n        Object.freeze(x);\n    }\n}\n\n/**\n * Replace control characters by `\\u00xx` form.\n * @param {string} text The text to sanitize.\n * @returns {string} The sanitized text.\n */\nfunction sanitize(text) {\n    return text.replace(\n        /[\\u0000-\\u0009|\\u000b-\\u001a]/gu, // eslint-disable-line no-control-regex\n        c => `\\\\u${c.codePointAt(0).toString(16).padStart(4, \"0\")}`\n    );\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n// default separators for testing\nconst DESCRIBE = Symbol(\"describe\");\nconst IT = Symbol(\"it\");\n\n/**\n * This is `it` default handler if `it` don't exist.\n * @this {Mocha}\n * @param {string} text The description of the test case.\n * @param {Function} method The logic of the test case.\n * @returns {any} Returned value of `method`.\n */\nfunction itDefaultHandler(text, method) {\n    try {\n        return method.call(this);\n    } catch (err) {\n        if (err instanceof assert.AssertionError) {\n            err.message += ` (${util$2.inspect(err.actual)} ${err.operator} ${util$2.inspect(err.expected)})`;\n        }\n        throw err;\n    }\n}\n\n/**\n * This is `describe` default handler if `describe` don't exist.\n * @this {Mocha}\n * @param {string} text The description of the test case.\n * @param {Function} method The logic of the test case.\n * @returns {any} Returned value of `method`.\n */\nfunction describeDefaultHandler(text, method) {\n    return method.call(this);\n}\n\nclass RuleTester {\n\n    /**\n     * Creates a new instance of RuleTester.\n     * @param {Object} [testerConfig] Optional, extra configuration for the tester\n     */\n    constructor(testerConfig) {\n\n        /**\n         * The configuration to use for this tester. Combination of the tester\n         * configuration and the default configuration.\n         * @type {Object}\n         */\n        this.testerConfig = lodash.merge(\n\n            // we have to clone because merge uses the first argument for recipient\n            lodash.cloneDeep(defaultConfig),\n            testerConfig,\n            { rules: { \"rule-tester/validate-ast\": \"error\" } }\n        );\n\n        /**\n         * Rule definitions to define before tests.\n         * @type {Object}\n         */\n        this.rules = {};\n        this.linter = new Linter$3();\n    }\n\n    /**\n     * Set the configuration to use for all future tests\n     * @param {Object} config the configuration to use.\n     * @returns {void}\n     */\n    static setDefaultConfig(config) {\n        if (typeof config !== \"object\") {\n            throw new TypeError(\"RuleTester.setDefaultConfig: config must be an object\");\n        }\n        defaultConfig = config;\n\n        // Make sure the rules object exists since it is assumed to exist later\n        defaultConfig.rules = defaultConfig.rules || {};\n    }\n\n    /**\n     * Get the current configuration used for all tests\n     * @returns {Object} the current configuration\n     */\n    static getDefaultConfig() {\n        return defaultConfig;\n    }\n\n    /**\n     * Reset the configuration to the initial configuration of the tester removing\n     * any changes made until now.\n     * @returns {void}\n     */\n    static resetDefaultConfig() {\n        defaultConfig = lodash.cloneDeep(testerDefaultConfig);\n    }\n\n\n    /*\n     * If people use `mocha test.js --watch` command, `describe` and `it` function\n     * instances are different for each execution. So `describe` and `it` should get fresh instance\n     * always.\n     */\n    static get describe() {\n        return (\n            this[DESCRIBE] ||\n            (typeof describe === \"function\" ? describe : describeDefaultHandler)\n        );\n    }\n\n    static set describe(value) {\n        this[DESCRIBE] = value;\n    }\n\n    static get it() {\n        return (\n            this[IT] ||\n            (typeof it === \"function\" ? it : itDefaultHandler)\n        );\n    }\n\n    static set it(value) {\n        this[IT] = value;\n    }\n\n    /**\n     * Define a rule for one particular run of tests.\n     * @param {string} name The name of the rule to define.\n     * @param {Function} rule The rule definition.\n     * @returns {void}\n     */\n    defineRule(name, rule) {\n        this.rules[name] = rule;\n    }\n\n    /**\n     * Adds a new rule test to execute.\n     * @param {string} ruleName The name of the rule to run.\n     * @param {Function} rule The rule to test.\n     * @param {Object} test The collection of tests to run.\n     * @returns {void}\n     */\n    run(ruleName, rule, test) {\n\n        const testerConfig = this.testerConfig,\n            requiredScenarios = [\"valid\", \"invalid\"],\n            scenarioErrors = [],\n            linter = this.linter;\n\n        if (lodash.isNil(test) || typeof test !== \"object\") {\n            throw new TypeError(`Test Scenarios for rule ${ruleName} : Could not find test scenario object`);\n        }\n\n        requiredScenarios.forEach(scenarioType => {\n            if (lodash.isNil(test[scenarioType])) {\n                scenarioErrors.push(`Could not find any ${scenarioType} test scenarios`);\n            }\n        });\n\n        if (scenarioErrors.length > 0) {\n            throw new Error([\n                `Test Scenarios for rule ${ruleName} is invalid:`\n            ].concat(scenarioErrors).join(\"\\n\"));\n        }\n\n\n        linter.defineRule(ruleName, Object.assign({}, rule, {\n\n            // Create a wrapper rule that freezes the `context` properties.\n            create(context) {\n                freezeDeeply(context.options);\n                freezeDeeply(context.settings);\n                freezeDeeply(context.parserOptions);\n\n                return (typeof rule === \"function\" ? rule : rule.create)(context);\n            }\n        }));\n\n        linter.defineRules(this.rules);\n\n        /**\n         * Run the rule for the given item\n         * @param {string|Object} item Item to run the rule against\n         * @returns {Object} Eslint run result\n         * @private\n         */\n        function runRuleForItem(item) {\n            let config = lodash.cloneDeep(testerConfig),\n                code, filename, output, beforeAST, afterAST;\n\n            if (typeof item === \"string\") {\n                code = item;\n            } else {\n                code = item.code;\n\n                /*\n                 * Assumes everything on the item is a config except for the\n                 * parameters used by this tester\n                 */\n                const itemConfig = lodash.omit(item, RuleTesterParameters);\n\n                /*\n                 * Create the config object from the tester config and this item\n                 * specific configurations.\n                 */\n                config = lodash.merge(\n                    config,\n                    itemConfig\n                );\n            }\n\n            if (item.filename) {\n                filename = item.filename;\n            }\n\n            if (hasOwnProperty$1(item, \"options\")) {\n                assert(Array.isArray(item.options), \"options must be an array\");\n                config.rules[ruleName] = [1].concat(item.options);\n            } else {\n                config.rules[ruleName] = 1;\n            }\n\n            const schema = getRuleOptionsSchema$1(rule);\n\n            /*\n             * Setup AST getters.\n             * The goal is to check whether or not AST was modified when\n             * running the rule under test.\n             */\n            linter.defineRule(\"rule-tester/validate-ast\", () => ({\n                Program(node) {\n                    beforeAST = cloneDeeplyExcludesParent(node);\n                },\n                \"Program:exit\"(node) {\n                    afterAST = node;\n                }\n            }));\n\n            if (typeof config.parser === \"string\") {\n                assert(path$1.isAbsolute(config.parser), \"Parsers provided as strings to RuleTester must be absolute paths\");\n                linter.defineParser(config.parser, commonjsRequire(config.parser));\n            }\n\n            if (schema) {\n                ajv$3.validateSchema(schema);\n\n                if (ajv$3.errors) {\n                    const errors = ajv$3.errors.map(error => {\n                        const field = error.dataPath[0] === \".\" ? error.dataPath.slice(1) : error.dataPath;\n\n                        return `\\t${field}: ${error.message}`;\n                    }).join(\"\\n\");\n\n                    throw new Error([`Schema for rule ${ruleName} is invalid:`, errors]);\n                }\n\n                /*\n                 * `ajv.validateSchema` checks for errors in the structure of the schema (by comparing the schema against a \"meta-schema\"),\n                 * and it reports those errors individually. However, there are other types of schema errors that only occur when compiling\n                 * the schema (e.g. using invalid defaults in a schema), and only one of these errors can be reported at a time. As a result,\n                 * the schema is compiled here separately from checking for `validateSchema` errors.\n                 */\n                try {\n                    ajv$3.compile(schema);\n                } catch (err) {\n                    throw new Error(`Schema for rule ${ruleName} is invalid: ${err.message}`);\n                }\n            }\n\n            validate$4(config, \"rule-tester\", id => (id === ruleName ? rule : null));\n\n            // Verify the code.\n            const messages = linter.verify(code, config, filename);\n\n            // Ignore syntax errors for backward compatibility if `errors` is a number.\n            if (typeof item.errors !== \"number\") {\n                const errorMessage = messages.find(m => m.fatal);\n\n                assert(!errorMessage, `A fatal parsing error occurred: ${errorMessage && errorMessage.message}`);\n            }\n\n            // Verify if autofix makes a syntax error or not.\n            if (messages.some(m => m.fix)) {\n                output = SourceCodeFixer$1.applyFixes(code, messages).output;\n                const errorMessageInFix = linter.verify(output, config, filename).find(m => m.fatal);\n\n                assert(!errorMessageInFix, `A fatal parsing error occurred in autofix: ${errorMessageInFix && errorMessageInFix.message}`);\n            } else {\n                output = code;\n            }\n\n            return {\n                messages,\n                output,\n                beforeAST,\n                afterAST: cloneDeeplyExcludesParent(afterAST)\n            };\n        }\n\n        /**\n         * Check if the AST was changed\n         * @param {ASTNode} beforeAST AST node before running\n         * @param {ASTNode} afterAST AST node after running\n         * @returns {void}\n         * @private\n         */\n        function assertASTDidntChange(beforeAST, afterAST) {\n            if (!lodash.isEqual(beforeAST, afterAST)) {\n                assert.fail(\"Rule should not modify AST.\");\n            }\n        }\n\n        /**\n         * Check if the template is valid or not\n         * all valid cases go through this\n         * @param {string|Object} item Item to run the rule against\n         * @returns {void}\n         * @private\n         */\n        function testValidTemplate(item) {\n            const result = runRuleForItem(item);\n            const messages = result.messages;\n\n            assert.strictEqual(messages.length, 0, util$2.format(\"Should have no errors but had %d: %s\",\n                messages.length, util$2.inspect(messages)));\n\n            assertASTDidntChange(result.beforeAST, result.afterAST);\n        }\n\n        /**\n         * Asserts that the message matches its expected value. If the expected\n         * value is a regular expression, it is checked against the actual\n         * value.\n         * @param {string} actual Actual value\n         * @param {string|RegExp} expected Expected value\n         * @returns {void}\n         * @private\n         */\n        function assertMessageMatches(actual, expected) {\n            if (expected instanceof RegExp) {\n\n                // assert.js doesn't have a built-in RegExp match function\n                assert.ok(\n                    expected.test(actual),\n                    `Expected '${actual}' to match ${expected}`\n                );\n            } else {\n                assert.strictEqual(actual, expected);\n            }\n        }\n\n        /**\n         * Check if the template is invalid or not\n         * all invalid cases go through this.\n         * @param {string|Object} item Item to run the rule against\n         * @returns {void}\n         * @private\n         */\n        function testInvalidTemplate(item) {\n            assert.ok(item.errors || item.errors === 0,\n                `Did not specify errors for an invalid test of ${ruleName}`);\n\n            const result = runRuleForItem(item);\n            const messages = result.messages;\n\n\n            if (typeof item.errors === \"number\") {\n                assert.strictEqual(messages.length, item.errors, util$2.format(\"Should have %d error%s but had %d: %s\",\n                    item.errors, item.errors === 1 ? \"\" : \"s\", messages.length, util$2.inspect(messages)));\n            } else {\n                assert.strictEqual(\n                    messages.length, item.errors.length,\n                    util$2.format(\n                        \"Should have %d error%s but had %d: %s\",\n                        item.errors.length, item.errors.length === 1 ? \"\" : \"s\", messages.length, util$2.inspect(messages)\n                    )\n                );\n\n                const hasMessageOfThisRule = messages.some(m => m.ruleId === ruleName);\n\n                for (let i = 0, l = item.errors.length; i < l; i++) {\n                    const error = item.errors[i];\n                    const message = messages[i];\n\n                    assert(hasMessageOfThisRule, \"Error rule name should be the same as the name of the rule being tested\");\n\n                    if (typeof error === \"string\" || error instanceof RegExp) {\n\n                        // Just an error message.\n                        assertMessageMatches(message.message, error);\n                    } else if (typeof error === \"object\") {\n\n                        /*\n                         * Error object.\n                         * This may have a message, messageId, data, node type, line, and/or\n                         * column.\n                         */\n                        if (hasOwnProperty$1(error, \"message\")) {\n                            assert.ok(!hasOwnProperty$1(error, \"messageId\"), \"Error should not specify both 'message' and a 'messageId'.\");\n                            assert.ok(!hasOwnProperty$1(error, \"data\"), \"Error should not specify both 'data' and 'message'.\");\n                            assertMessageMatches(message.message, error.message);\n                        } else if (hasOwnProperty$1(error, \"messageId\")) {\n                            assert.ok(\n                                hasOwnProperty$1(rule, \"meta\") && hasOwnProperty$1(rule.meta, \"messages\"),\n                                \"Error can not use 'messageId' if rule under test doesn't define 'meta.messages'.\"\n                            );\n                            if (!hasOwnProperty$1(rule.meta.messages, error.messageId)) {\n                                const friendlyIDList = `[${Object.keys(rule.meta.messages).map(key => `'${key}'`).join(\", \")}]`;\n\n                                assert(false, `Invalid messageId '${error.messageId}'. Expected one of ${friendlyIDList}.`);\n                            }\n                            assert.strictEqual(\n                                message.messageId,\n                                error.messageId,\n                                `messageId '${message.messageId}' does not match expected messageId '${error.messageId}'.`\n                            );\n                            if (hasOwnProperty$1(error, \"data\")) {\n\n                                /*\n                                 *  if data was provided, then directly compare the returned message to a synthetic\n                                 *  interpolated message using the same message ID and data provided in the test.\n                                 *  See https://github.com/eslint/eslint/issues/9890 for context.\n                                 */\n                                const unformattedOriginalMessage = rule.meta.messages[error.messageId];\n                                const rehydratedMessage = interpolate$1(unformattedOriginalMessage, error.data);\n\n                                assert.strictEqual(\n                                    message.message,\n                                    rehydratedMessage,\n                                    `Hydrated message \"${rehydratedMessage}\" does not match \"${message.message}\"`\n                                );\n                            }\n                        }\n\n                        assert.ok(\n                            hasOwnProperty$1(error, \"data\") ? hasOwnProperty$1(error, \"messageId\") : true,\n                            \"Error must specify 'messageId' if 'data' is used.\"\n                        );\n\n                        if (error.type) {\n                            assert.strictEqual(message.nodeType, error.type, `Error type should be ${error.type}, found ${message.nodeType}`);\n                        }\n\n                        if (hasOwnProperty$1(error, \"line\")) {\n                            assert.strictEqual(message.line, error.line, `Error line should be ${error.line}`);\n                        }\n\n                        if (hasOwnProperty$1(error, \"column\")) {\n                            assert.strictEqual(message.column, error.column, `Error column should be ${error.column}`);\n                        }\n\n                        if (hasOwnProperty$1(error, \"endLine\")) {\n                            assert.strictEqual(message.endLine, error.endLine, `Error endLine should be ${error.endLine}`);\n                        }\n\n                        if (hasOwnProperty$1(error, \"endColumn\")) {\n                            assert.strictEqual(message.endColumn, error.endColumn, `Error endColumn should be ${error.endColumn}`);\n                        }\n\n                        if (hasOwnProperty$1(error, \"suggestions\")) {\n\n                            // Support asserting there are no suggestions\n                            if (!error.suggestions || (Array.isArray(error.suggestions) && error.suggestions.length === 0)) {\n                                if (Array.isArray(message.suggestions) && message.suggestions.length > 0) {\n                                    assert.fail(`Error should have no suggestions on error with message: \"${message.message}\"`);\n                                }\n                            } else {\n                                assert.strictEqual(Array.isArray(message.suggestions), true, `Error should have an array of suggestions. Instead received \"${message.suggestions}\" on error with message: \"${message.message}\"`);\n                                assert.strictEqual(message.suggestions.length, error.suggestions.length, `Error should have ${error.suggestions.length} suggestions. Instead found ${message.suggestions.length} suggestions`);\n\n                                error.suggestions.forEach((expectedSuggestion, index) => {\n                                    const actualSuggestion = message.suggestions[index];\n\n                                    /**\n                                     * Tests equality of a suggestion key if that key is defined in the expected output.\n                                     * @param {string} key Key to validate from the suggestion object\n                                     * @returns {void}\n                                     */\n                                    function assertSuggestionKeyEquals(key) {\n                                        if (hasOwnProperty$1(expectedSuggestion, key)) {\n                                            assert.deepStrictEqual(actualSuggestion[key], expectedSuggestion[key], `Error suggestion at index: ${index} should have desc of: \"${actualSuggestion[key]}\"`);\n                                        }\n                                    }\n                                    assertSuggestionKeyEquals(\"desc\");\n                                    assertSuggestionKeyEquals(\"messageId\");\n\n                                    if (hasOwnProperty$1(expectedSuggestion, \"output\")) {\n                                        const codeWithAppliedSuggestion = SourceCodeFixer$1.applyFixes(item.code, [actualSuggestion]).output;\n\n                                        assert.strictEqual(codeWithAppliedSuggestion, expectedSuggestion.output, `Expected the applied suggestion fix to match the test suggestion output for suggestion at index: ${index} on error with message: \"${message.message}\"`);\n                                    }\n                                });\n                            }\n                        }\n                    } else {\n\n                        // Message was an unexpected type\n                        assert.fail(`Error should be a string, object, or RegExp, but found (${util$2.inspect(message)})`);\n                    }\n                }\n            }\n\n            if (hasOwnProperty$1(item, \"output\")) {\n                if (item.output === null) {\n                    assert.strictEqual(\n                        result.output,\n                        item.code,\n                        \"Expected no autofixes to be suggested\"\n                    );\n                } else {\n                    assert.strictEqual(result.output, item.output, \"Output is incorrect.\");\n                }\n            }\n\n            assertASTDidntChange(result.beforeAST, result.afterAST);\n        }\n\n        /*\n         * This creates a mocha test suite and pipes all supplied info through\n         * one of the templates above.\n         */\n        RuleTester.describe(ruleName, () => {\n            RuleTester.describe(\"valid\", () => {\n                test.valid.forEach(valid => {\n                    RuleTester.it(sanitize(typeof valid === \"object\" ? valid.code : valid), () => {\n                        testValidTemplate(valid);\n                    });\n                });\n            });\n\n            RuleTester.describe(\"invalid\", () => {\n                test.invalid.forEach(invalid => {\n                    RuleTester.it(sanitize(invalid.code), () => {\n                        testInvalidTemplate(invalid);\n                    });\n                });\n            });\n        });\n    }\n}\n\nRuleTester[DESCRIBE] = RuleTester[IT] = null;\n\nvar ruleTester = RuleTester;\n\nvar ruleTester$1 = {\n    RuleTester: ruleTester\n};\n\nvar api = createCommonjsModule(function (module) {\n\nconst { CLIEngine } = cliEngine$1;\nconst { Linter } = linter$1;\nconst { RuleTester } = ruleTester$1;\nconst { SourceCode } = sourceCode$1;\n\nmodule.exports = {\n    Linter,\n    CLIEngine,\n    RuleTester,\n    SourceCode\n};\n\n// DOTO: remove deprecated API.\nlet deprecatedLinterInstance = null;\n\nObject.defineProperty(module.exports, \"linter\", {\n    enumerable: false,\n    get() {\n        if (!deprecatedLinterInstance) {\n            deprecatedLinterInstance = new Linter();\n        }\n\n        return deprecatedLinterInstance;\n    }\n});\n});\nvar api_1 = api.Linter;\nvar api_2 = api.CLIEngine;\nvar api_3 = api.RuleTester;\nvar api_4 = api.SourceCode;\n\nfunction skipws (str) {\n  let i = 0;\n  do {\n    if (str[i] !== ' ' && str[i] !== '\\t') { return i }\n  } while (++i < str.length)\n  return i\n}\n\n/* ------- default parsers ------- */\n\nconst PARSERS = {};\n\nPARSERS.parse_tag = function parse_tag (str) {\n  const result = str.match(/^\\s*@(\\S+)/);\n  if (!result) { throw new Error('Invalid `@tag`, missing @ symbol') }\n\n  return {\n    source: result[0],\n    data: { tag: result[1] }\n  }\n};\n\nPARSERS.parse_type = function parse_type (str, data) {\n  if (data.errors && data.errors.length) { return null }\n\n  let pos = skipws(str);\n  let res = '';\n  let curlies = 0;\n\n  if (str[pos] !== '{') { return null }\n\n  while (pos < str.length) {\n    curlies += (str[pos] === '{' ? 1 : (str[pos] === '}' ? -1 : 0));\n    res += str[pos];\n    pos++;\n    if (curlies === 0) { break }\n  }\n\n  if (curlies !== 0) { throw new Error('Invalid `{type}`, unpaired curlies') }\n\n  return {\n    source: str.slice(0, pos),\n    data: { type: res.slice(1, -1) }\n  }\n};\n\nPARSERS.parse_name = function parse_name (str, data) {\n  if (data.errors && data.errors.length) { return null }\n\n  let pos = skipws(str);\n  let name = '';\n  let brackets = 0;\n  let res = { optional: false };\n\n  // if it starts with quoted group assume it is a literal\n  const quotedGroups = str.slice(pos).split('\"');\n  if (quotedGroups.length > 1 && quotedGroups[0] === '' && quotedGroups.length % 2 === 1) {\n    name = quotedGroups[1];\n    pos += name.length + 2;\n  // assume name is non-space string or anything wrapped into brackets\n  } else {\n    while (pos < str.length) {\n      brackets += (str[pos] === '[' ? 1 : (str[pos] === ']' ? -1 : 0));\n      name += str[pos];\n      pos++;\n      if (brackets === 0 && /\\s/.test(str[pos])) { break }\n    }\n\n    if (brackets !== 0) { throw new Error('Invalid `name`, unpaired brackets') }\n\n    res = { name, optional: false };\n\n    if (name[0] === '[' && name[name.length - 1] === ']') {\n      res.optional = true;\n      name = name.slice(1, -1);\n\n      if (name.indexOf('=') !== -1) {\n        const parts = name.split('=');\n        name = parts[0];\n        res.default = parts[1].replace(/^([\"'])(.+)(\\1)$/, '$2');\n      }\n    }\n  }\n\n  res.name = name;\n\n  return {\n    source: str.slice(0, pos),\n    data: res\n  }\n};\n\nPARSERS.parse_description = function parse_description (str, data) {\n  if (data.errors && data.errors.length) { return null }\n\n  const result = str.match(/^\\s+((.|\\s)+)?/);\n\n  if (result) {\n    return {\n      source: result[0],\n      data: { description: result[1] === undefined ? '' : result[1] }\n    }\n  }\n\n  return null\n};\n\nvar parsers$1 = PARSERS;\n\nconst MARKER_START = '/**';\nconst MARKER_START_SKIP = '/***';\nconst MARKER_END = '*/';\n\n/* ------- util functions ------- */\n\nfunction find$2 (list, filter) {\n  let i = list.length;\n  let matchs = true;\n\n  while (i--) {\n    for (const k in filter) {\n      if ({}.hasOwnProperty.call(filter, k)) {\n        matchs = (filter[k] === list[i][k]) && matchs;\n      }\n    }\n    if (matchs) { return list[i] }\n  }\n  return null\n}\n\n/* ------- parsing ------- */\n\n/**\n * Parses \"@tag {type} name description\"\n * @param {string} str Raw doc string\n * @param {Array<function>} parsers Array of parsers to be applied to the source\n * @returns {object} parsed tag node\n */\nfunction parse_tag (str, parsers) {\n  const data = parsers.reduce(function (state, parser) {\n    let result;\n\n    try {\n      result = parser(state.source, Object.assign({}, state.data));\n    } catch (err) {\n      state.data.errors = (state.data.errors || [])\n        .concat(parser.name + ': ' + err.message);\n    }\n\n    if (result) {\n      state.source = state.source.slice(result.source.length);\n      state.data = Object.assign(state.data, result.data);\n    }\n\n    return state\n  }, {\n    source: str,\n    data: {}\n  }).data;\n\n  data.optional = !!data.optional;\n  data.type = data.type === undefined ? '' : data.type;\n  data.name = data.name === undefined ? '' : data.name;\n  data.description = data.description === undefined ? '' : data.description;\n\n  return data\n}\n\n/**\n * Parses comment block (array of String lines)\n */\nfunction parse_block (source, opts) {\n  const trim = opts.trim\n    ? s => s.trim()\n    : s => s;\n\n  const toggleFence = (typeof opts.fence === 'function')\n    ? opts.fence\n    : line => line.split(opts.fence).length % 2 === 0;\n\n  let source_str = source\n    .map((line) => { return trim(line.source) })\n    .join('\\n');\n\n  source_str = trim(source_str);\n\n  const start = source[0].number;\n\n  // merge source lines into tags\n  // we assume tag starts with \"@\"\n  source = source\n    .reduce(function (state, line) {\n      line.source = trim(line.source);\n\n      // start of a new tag detected\n      if (line.source.match(/^\\s*@(\\S+)/) && !state.isFenced) {\n        state.tags.push({\n          source: [line.source],\n          line: line.number\n        });\n      // keep appending source to the current tag\n      } else {\n        const tag = state.tags[state.tags.length - 1];\n        if (opts.join !== undefined && opts.join !== false && opts.join !== 0 &&\n            !line.startWithStar && tag.source.length > 0) {\n          let source;\n          if (typeof opts.join === 'string') {\n            source = opts.join + line.source.replace(/^\\s+/, '');\n          } else if (typeof opts.join === 'number') {\n            source = line.source;\n          } else {\n            source = ' ' + line.source.replace(/^\\s+/, '');\n          }\n          tag.source[tag.source.length - 1] += source;\n        } else {\n          tag.source.push(line.source);\n        }\n      }\n\n      if (toggleFence(line.source)) {\n        state.isFenced = !state.isFenced;\n      }\n      return state\n    }, {\n      tags: [{ source: [] }],\n      isFenced: false\n    })\n    .tags\n    .map((tag) => {\n      tag.source = trim(tag.source.join('\\n'));\n      return tag\n    });\n\n  // Block description\n  const description = source.shift();\n\n  // skip if no descriptions and no tags\n  if (description.source === '' && source.length === 0) {\n    return null\n  }\n\n  const tags = source.reduce(function (tags, tag) {\n    const tag_node = parse_tag(tag.source, opts.parsers);\n\n    tag_node.line = tag.line;\n    tag_node.source = tag.source;\n\n    if (opts.dotted_names && tag_node.name.includes('.')) {\n      let parent_name;\n      let parent_tag;\n      let parent_tags = tags;\n      const parts = tag_node.name.split('.');\n\n      while (parts.length > 1) {\n        parent_name = parts.shift();\n        parent_tag = find$2(parent_tags, {\n          tag: tag_node.tag,\n          name: parent_name\n        });\n\n        if (!parent_tag) {\n          parent_tag = {\n            tag: tag_node.tag,\n            line: Number(tag_node.line),\n            name: parent_name,\n            type: '',\n            description: ''\n          };\n          parent_tags.push(parent_tag);\n        }\n\n        parent_tag.tags = parent_tag.tags || [];\n        parent_tags = parent_tag.tags;\n      }\n\n      tag_node.name = parts[0];\n      parent_tags.push(tag_node);\n      return tags\n    }\n\n    return tags.concat(tag_node)\n  }, []);\n\n  return {\n    tags,\n    line: start,\n    description: description.source,\n    source: source_str\n  }\n}\n\n/**\n * Produces `extract` function with internal state initialized\n */\nfunction mkextract (opts) {\n  let chunk = null;\n  let indent = 0;\n  let number = 0;\n\n  opts = Object.assign({}, {\n    trim: true,\n    dotted_names: false,\n    fence: '```',\n    parsers: [\n      parsers$1.parse_tag,\n      parsers$1.parse_type,\n      parsers$1.parse_name,\n      parsers$1.parse_description\n    ]\n  }, opts || {});\n\n  /**\n   * Read lines until they make a block\n   * Return parsed block once fullfilled or null otherwise\n   */\n  return function extract (line) {\n    let result = null;\n    const startPos = line.indexOf(MARKER_START);\n    const endPos = line.indexOf(MARKER_END);\n\n    // if open marker detected and it's not, skip one\n    if (startPos !== -1 && line.indexOf(MARKER_START_SKIP) !== startPos) {\n      chunk = [];\n      indent = startPos + MARKER_START.length;\n    }\n\n    // if we are on middle of comment block\n    if (chunk) {\n      let lineStart = indent;\n      let startWithStar = false;\n\n      // figure out if we slice from opening marker pos\n      // or line start is shifted to the left\n      const nonSpaceChar = line.match(/\\S/);\n\n      // skip for the first line starting with /** (fresh chunk)\n      // it always has the right indentation\n      if (chunk.length > 0 && nonSpaceChar) {\n        if (nonSpaceChar[0] === '*') {\n          const afterNonSpaceCharIdx = nonSpaceChar.index + 1;\n          const extraCharIsSpace = line.charAt(afterNonSpaceCharIdx) === ' ';\n          lineStart = afterNonSpaceCharIdx + (extraCharIsSpace ? 1 : 0);\n          startWithStar = true;\n        } else if (nonSpaceChar.index < indent) {\n          lineStart = nonSpaceChar.index;\n        }\n      }\n\n      // slice the line until end or until closing marker start\n      chunk.push({\n        number,\n        startWithStar,\n        source: line.slice(lineStart, endPos === -1 ? line.length : endPos)\n      });\n\n      // finalize block if end marker detected\n      if (endPos !== -1) {\n        result = parse_block(chunk, opts);\n        chunk = null;\n        indent = 0;\n      }\n    }\n\n    number += 1;\n    return result\n  }\n}\n\n/* ------- Public API ------- */\n\nvar parser$1 = function parse (source, opts) {\n  const blocks = [];\n  const extract = mkextract(opts);\n  const lines = source.split(/\\n/);\n\n  lines.forEach((line) => {\n    const block = extract(line);\n    if (block) {\n      blocks.push(block);\n    }\n  });\n\n  return blocks\n};\n\nvar PARSERS_1 = parsers$1;\nvar mkextract_1 = mkextract;\nparser$1.PARSERS = PARSERS_1;\nparser$1.mkextract = mkextract_1;\n\nvar stringifier = createCommonjsModule(function (module, exports) {\n\nconst getIndent = (indent) => {\n  return typeof indent === 'number' ? ' '.repeat(indent) : indent\n};\n\nmodule.exports = exports = function stringify (arg, opts) {\n  if (Array.isArray(arg)) {\n    return stringifyBlocks(arg, opts)\n  }\n  if (arg && typeof arg === 'object') {\n    if ('tag' in arg) {\n      return stringifyTag(arg, opts)\n    }\n    if ('tags' in arg) {\n      return stringifyBlock(arg, opts)\n    }\n  }\n  throw new TypeError('Unexpected argument passed to `stringify`.')\n};\n\nconst stringifyBlocks = exports.stringifyBlocks = function stringifyBlocks (\n  blocks, { indent = '' } = {}\n) {\n  const indnt = getIndent(indent);\n  return blocks.reduce((s, block) => {\n    return s + stringifyBlock(block, { indent })\n  }, (indnt ? indnt.slice(0, -1) : '') + '/**\\n') + indnt + '*/'\n};\n\nconst stringifyBlock = exports.stringifyBlock = function stringifyBlock (\n  block, { indent = '' } = {}\n) {\n  // block.line\n  const indnt = getIndent(indent);\n\n  return (\n    block.description\n      ? block.description.replace(/^\\n/, '').replace(/^(.*)\\n?/gm, (n0, descLine) => {\n        return `${indnt}*${descLine ? ` ${descLine}` : ''}\\n`\n      })\n      : ''\n  ) + block.tags.reduce((s, tag) => {\n    return s + stringifyTag(tag, { indent })\n  }, '')\n};\n\nconst stringifyTag = exports.stringifyTag = function stringifyTag (\n  tag, { indent = '' } = {}\n) {\n  const indnt = getIndent(indent);\n  const {\n    type, name, optional, description, tag: tagName, default: deflt //, line , source\n  } = tag;\n\n  return indnt + `* @${tagName}` +\n    (type ? ` {${type}}` : '') +\n    (name.trim() ? ` ${\n      optional ? '[' : ''\n    }${name.trimRight()}${deflt ? `=${deflt}` : ''}${\n      optional ? ']' : ''\n    }` : '') +\n    (description ? ` ${description.replace(/\\n/g, '\\n' + indnt + '* ')}` : '') + '\\n'\n};\n});\nvar stringifier_1 = stringifier.stringifyBlocks;\nvar stringifier_2 = stringifier.stringifyBlock;\nvar stringifier_3 = stringifier.stringifyTag;\n\nvar commentParser$1 = parser$1;\n\nvar stringify_1 = stringifier;\n\n/* ------- Transform stream ------- */\n\nclass Parser$1 extends stream$4.Transform {\n  constructor (opts) {\n    opts = opts || {};\n    super({ objectMode: true });\n    this._extract = parser$1.mkextract(opts);\n  }\n\n  _transform (data, encoding, done) {\n    let block;\n    const lines = data.toString().split(/\\n/);\n\n    while (lines.length) {\n      block = this._extract(lines.shift());\n      if (block) {\n        this.push(block);\n      }\n    }\n\n    done();\n  }\n}\n\nvar stream_1 = function stream (opts) {\n  return new Parser$1(opts)\n};\n\n/* ------- File parser ------- */\n\nvar file = function file (file_path, done) {\n  let opts = {};\n  const collected = [];\n\n  if (arguments.length === 3) {\n    opts = done;\n    done = arguments[2];\n  }\n\n  return fs$2.createReadStream(file_path, { encoding: 'utf8' })\n    .on('error', done)\n    .pipe(new Parser$1(opts))\n    .on('error', done)\n    .on('data', function (data) {\n      collected.push(data);\n    })\n    .on('finish', function () {\n      done(null, collected);\n    })\n};\ncommentParser$1.stringify = stringify_1;\ncommentParser$1.stream = stream_1;\ncommentParser$1.file = file;\n\nconst tagToName = {\n  operationId: 'operation id',\n  summary: 'summary',\n  description: 'description',\n  tag: 'tag',\n  bodyDescription: 'body description',\n  externalDocs: 'url',\n  server: 'url',\n  cookieParam: 'parameter name',\n  headerParam: 'parameter name',\n  queryParam: 'parameter name',\n  pathParam: 'parameter name',\n  bodyContent: 'content-type',\n  security: 'security scheme name',\n};\n\nconst openAPIRegex = /^(GET|PUT|POST|DELETE|OPTIONS|HEAD|PATCH|TRACE) \\/.*$/;\n\nconst missing = (context, comment, tag, name) => {\n  const commentLines = comment.value.split(/\\r\\n|\\r|\\n/);\n  const start = commentLines[tag.line].indexOf(`@${tag.tag}`);\n  const endOfLine = commentLines[tag.line].length;\n\n  context.report({\n    loc: {\n      start: {\n        line: comment.loc.start.line + tag.line,\n        column: start,\n      },\n      end: {\n        line: comment.loc.start.line + tag.line,\n        column: endOfLine,\n      },\n    },\n    message: `Missing ${name}`,\n  });\n};\n\nconst statusCodeUndefined = (context, comment, tag, status) => {\n  const commentLines = comment.value.split(/\\r\\n|\\r|\\n/);\n  const start = commentLines[tag.line].indexOf(`@${tag.tag}`);\n  const end = start + tag.tag.length + 1;\n\n  context.report({\n    loc: {\n      start: {\n        line: comment.loc.start.line + tag.line,\n        column: end + 1,\n      },\n      end: {\n        line: comment.loc.start.line + tag.line,\n        column: end + 1 + status.length,\n      },\n    },\n    message: `Status code '${status}' is not defined`,\n  });\n};\n\nfunction parseErrors(comment, jsDocComment, context) {\n  const seenResponses = [];\n\n  if (openAPIRegex.test(jsDocComment.description)) {\n    jsDocComment.tags.forEach((tag) => {\n      // const commentLines = comment.value.split(/\\r\\n|\\r|\\n/);\n      // const start = commentLines[tag.line].indexOf(`@${tag.tag}`);\n      // const end = start + tag.tag.length + 1;\n      // const endOfLine = commentLines[tag.line].length;\n\n      switch (tag.tag) {\n        // required: name\n        case 'operationId':\n        case 'summary':\n        case 'description':\n        case 'tag':\n        case 'bodyDescription':\n        case 'externalDocs':\n        case 'server':\n        case 'cookieParam':\n        case 'headerParam':\n        case 'queryParam':\n        case 'pathParam':\n        case 'bodyContent':\n        case 'security':\n          if (!tag.name) {\n            missing(context, comment, tag, tagToName[tag.tag]);\n          }\n          break;\n\n        // required: name\n        // required: description\n        case 'response':\n          if (!tag.name) {\n            missing(context, comment, tag, 'status code');\n          } else {\n            seenResponses.push(tag.name);\n          }\n          if (!tag.description) {\n            missing(context, comment, tag, 'response description');\n          }\n          break;\n\n        // required: name\n        // required: schema\n        case 'callback':\n          if (!tag.name) {\n            missing(context, comment, tag, 'callback name');\n          }\n          if (!tag.schema) {\n            missing(context, comment, tag, 'callback component');\n          }\n          break;\n\n        // required: name [status.content]\n        case 'responseContent': {\n          const [status, content] = tag.name.split('.');\n          if (!status) {\n            missing(context, comment, tag, 'status code');\n          } else if (!seenResponses.includes(status)) {\n            statusCodeUndefined(context, comment, tag, status);\n          }\n          if (!content) {\n            missing(context, comment, tag, 'content-type');\n          }\n          break;\n        }\n\n        // required: name [status.header]\n        case 'responseHeader': {\n          const [status, header] = tag.name.split('.');\n          if (!status) {\n            missing(context, comment, tag, 'status code');\n          } else if (!seenResponses.includes(status)) {\n            statusCodeUndefined(context, comment, tag, status);\n          }\n          if (!header) {\n            missing(context, comment, tag, 'header name');\n          }\n          break;\n        }\n\n        // required: name [status.header]\n        // required: schema\n        case 'responseHeaderComponent': {\n          const [status, header] = tag.name.split('.');\n          if (!status) {\n            missing(context, comment, tag, 'status code');\n          } else if (!seenResponses.includes(status)) {\n            statusCodeUndefined(context, comment, tag, status);\n          }\n          if (!header) {\n            missing(context, comment, tag, 'header name');\n          }\n          if (!tag.type) {\n            missing(context, comment, tag, 'header component');\n          }\n          break;\n        }\n\n        // required: name [status.contentType.example]\n        // required: schema\n        case 'responseExample': {\n          const [status, contentType, example] = tag.name.split('.');\n          if (!status) {\n            missing(context, comment, tag, 'status code');\n          } else if (!seenResponses.includes(status)) {\n            statusCodeUndefined(context, comment, tag, status);\n          }\n          if (!contentType) {\n            missing(context, comment, tag, 'content-type');\n          }\n          if (!example) {\n            missing(context, comment, tag, 'example name');\n          }\n          if (!tag.type) {\n            missing(context, comment, tag, 'example component');\n          }\n          break;\n        }\n\n        // required: name [status.contentType.example]\n        // required: schema\n        case 'responseLink': {\n          const [status, link] = tag.name.split('.');\n          if (!status) {\n            missing(context, comment, tag, 'status code');\n          } else if (!seenResponses.includes(status)) {\n            statusCodeUndefined(context, comment, tag, status);\n          }\n          if (!link) {\n            missing(context, comment, tag, 'link component');\n          }\n          break;\n        }\n\n        case 'bodyComponent':\n          if (!tag.type) {\n            missing(context, comment, tag, 'body component');\n          }\n          break;\n\n        case 'paramComponent':\n          if (!tag.type) {\n            missing(context, comment, tag, 'parameter component');\n          }\n          break;\n\n        case 'responseComponent':\n          if (!tag.name) {\n            missing(context, comment, tag, 'status code');\n          }\n          if (!tag.type) {\n            missing(context, comment, tag, 'response component');\n          }\n          break;\n      }\n    });\n  }\n}\n\nfunction parse$7(comment, jsDocComment, context) {\n  if (openAPIRegex.test(jsDocComment.description)) {\n    const [method, path] = jsDocComment.description.split(' ');\n\n    if (\n      !jsDocComment.tags.find(\n        (tag) => tag.tag === 'response' || tag.tag === 'responseComponent'\n      )\n    ) {\n      context.report({\n        loc: comment.loc,\n        message: `At least one response is required`,\n      });\n    }\n\n    jsDocComment.tags.forEach((tag) => {\n      const commentLines = comment.value.split(/\\r\\n|\\r|\\n/);\n      const start = commentLines[tag.line].indexOf(`@${tag.tag}`);\n      const end = start + tag.tag.length + 1;\n      const endOfLine = commentLines[tag.line].length;\n\n      if (\n        tag.tag.includes('body') &&\n        (method === 'GET' || method === 'DELETE')\n      ) {\n        context.report({\n          loc: {\n            start: {\n              line: comment.loc.start.line + tag.line,\n              column: start,\n            },\n            end: {\n              line: comment.loc.start.line + tag.line,\n              column: endOfLine,\n            },\n          },\n          message: `${method.toLowerCase()} requests should not have a body`,\n        });\n      }\n\n      switch (tag.tag) {\n        // no: schema\n        case 'operationId':\n        case 'summary':\n        case 'description':\n        case 'tag':\n        case 'bodyDescription':\n        case 'externalDocs':\n        case 'server':\n        case 'response':\n        case 'bodyComponent':\n        case 'paramComponent':\n          if (tag.type) {\n            context.report({\n              loc: {\n                start: {\n                  line: comment.loc.start.line + tag.line,\n                  column: end + 1,\n                },\n                end: {\n                  line: comment.loc.start.line + tag.line,\n                  column: end + 1 + `{${tag.type}}`.length,\n                },\n              },\n              message: `Unnecessary type declaration '{${tag.type}}'`,\n            });\n          }\n          break;\n\n        // no: name\n        // no: description\n        // no: schema\n        case 'deprecated':\n        case 'bodyRequired':\n          if (tag.type || tag.name || tag.description) {\n            context.report({\n              loc: {\n                start: {\n                  line: comment.loc.start.line + tag.line,\n                  column: end + 1,\n                },\n                end: {\n                  line: comment.loc.start.line + tag.line,\n                  column: endOfLine,\n                },\n              },\n              message: `Unnecessary options`,\n            });\n          }\n          break;\n\n        // no: description\n        case 'bodyContent':\n        case 'callback':\n        case 'responseContent':\n        case 'responseHeaderComponent':\n        case 'responseExample':\n        case 'responseLink':\n        case 'responseComponent':\n          if (tag.description) ;\n          break;\n\n        // no:       description\n        // no:       schema\n        case 'security':\n          // TODO: implement.\n          break;\n\n        case 'cookieParam':\n        case 'headerParam':\n        case 'queryParam':\n        case 'pathParam':\n        case 'responseHeader':\n          break;\n\n        default:\n          // warn\n          context.report({\n            loc: {\n              start: {\n                line: comment.loc.start.line + tag.line,\n                column: start,\n              },\n              end: {\n                line: comment.loc.start.line + tag.line,\n                column: endOfLine,\n              },\n            },\n            message: `'@${tag.tag}' is an invalid tag`,\n          });\n          break;\n      }\n    });\n  }\n}\n\nfunction getComments(cb) {\n  return {\n    Program(node) {\n      node.comments\n        .filter((comment) => comment.type === 'Block')\n        .forEach((comment) => {\n          const [jsDocComment] = commentParser$1(`/*${comment.value}*/`);\n          if (jsDocComment) {\n            cb(comment, jsDocComment);\n          }\n        });\n    },\n  };\n}\n\nvar eslintPluginOpenapi = {\n  rules: {\n    errors: {\n      create: function (context) {\n        return getComments((comment, jsDocComment) => {\n          parseErrors(comment, jsDocComment, context);\n        });\n      },\n    },\n    warnings: {\n      create: (context) => {\n        return getComments((comment, jsDocComment) => {\n          parse$7(comment, jsDocComment, context);\n        });\n      },\n    },\n  },\n  configs: {\n    recommended: {\n      plugins: ['openapi'],\n      rules: {\n        'openapi/warnings': 'warn',\n        'openapi/errors': 'error',\n      },\n    },\n  },\n};\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\nvar _listCacheClear = listCacheClear;\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\nvar eq_1 = eq;\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq_1(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\nvar _assocIndexOf = assocIndexOf;\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = _assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\nvar _listCacheDelete = listCacheDelete;\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = _assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\nvar _listCacheGet = listCacheGet;\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return _assocIndexOf(this.__data__, key) > -1;\n}\n\nvar _listCacheHas = listCacheHas;\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = _assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\nvar _listCacheSet = listCacheSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = _listCacheClear;\nListCache.prototype['delete'] = _listCacheDelete;\nListCache.prototype.get = _listCacheGet;\nListCache.prototype.has = _listCacheHas;\nListCache.prototype.set = _listCacheSet;\n\nvar _ListCache = ListCache;\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new _ListCache;\n  this.size = 0;\n}\n\nvar _stackClear = stackClear;\n\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\nvar _stackDelete = stackDelete;\n\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\nvar _stackGet = stackGet;\n\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\nvar _stackHas = stackHas;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nvar _freeGlobal = freeGlobal;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = _freeGlobal || freeSelf || Function('return this')();\n\nvar _root = root;\n\n/** Built-in value references. */\nvar Symbol$1 = _root.Symbol;\n\nvar _Symbol = Symbol$1;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$2 = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty$2.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nvar _getRawTag = getRawTag;\n\n/** Used for built-in method references. */\nvar objectProto$1 = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString$1 = objectProto$1.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString$1.call(value);\n}\n\nvar _objectToString = objectToString;\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag$1 = _Symbol ? _Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag$1 && symToStringTag$1 in Object(value))\n    ? _getRawTag(value)\n    : _objectToString(value);\n}\n\nvar _baseGetTag = baseGetTag;\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject$1(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nvar isObject_1$1 = isObject$1;\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction$2(value) {\n  if (!isObject_1$1(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = _baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nvar isFunction_1 = isFunction$2;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = _root['__core-js_shared__'];\n\nvar _coreJsData = coreJsData;\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(_coreJsData && _coreJsData.keys && _coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\nvar _isMasked = isMasked;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\nvar _toSource = toSource;\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto$1 = Function.prototype,\n    objectProto$2 = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString$1 = funcProto$1.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$3 = objectProto$2.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString$1.call(hasOwnProperty$3).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject_1$1(value) || _isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction_1(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(_toSource(value));\n}\n\nvar _baseIsNative = baseIsNative;\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue$1(object, key) {\n  return object == null ? undefined : object[key];\n}\n\nvar _getValue = getValue$1;\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = _getValue(object, key);\n  return _baseIsNative(value) ? value : undefined;\n}\n\nvar _getNative = getNative;\n\n/* Built-in method references that are verified to be native. */\nvar Map$1 = _getNative(_root, 'Map');\n\nvar _Map = Map$1;\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = _getNative(Object, 'create');\n\nvar _nativeCreate = nativeCreate;\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = _nativeCreate ? _nativeCreate(null) : {};\n  this.size = 0;\n}\n\nvar _hashClear = hashClear;\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nvar _hashDelete = hashDelete;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto$3 = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$4 = objectProto$3.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (_nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty$4.call(data, key) ? data[key] : undefined;\n}\n\nvar _hashGet = hashGet;\n\n/** Used for built-in method references. */\nvar objectProto$4 = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$5 = objectProto$4.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return _nativeCreate ? (data[key] !== undefined) : hasOwnProperty$5.call(data, key);\n}\n\nvar _hashHas = hashHas;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED$1 = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (_nativeCreate && value === undefined) ? HASH_UNDEFINED$1 : value;\n  return this;\n}\n\nvar _hashSet = hashSet;\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = _hashClear;\nHash.prototype['delete'] = _hashDelete;\nHash.prototype.get = _hashGet;\nHash.prototype.has = _hashHas;\nHash.prototype.set = _hashSet;\n\nvar _Hash = Hash;\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new _Hash,\n    'map': new (_Map || _ListCache),\n    'string': new _Hash\n  };\n}\n\nvar _mapCacheClear = mapCacheClear;\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\nvar _isKeyable = isKeyable;\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return _isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\nvar _getMapData = getMapData;\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = _getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nvar _mapCacheDelete = mapCacheDelete;\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return _getMapData(this, key).get(key);\n}\n\nvar _mapCacheGet = mapCacheGet;\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return _getMapData(this, key).has(key);\n}\n\nvar _mapCacheHas = mapCacheHas;\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = _getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\nvar _mapCacheSet = mapCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = _mapCacheClear;\nMapCache.prototype['delete'] = _mapCacheDelete;\nMapCache.prototype.get = _mapCacheGet;\nMapCache.prototype.has = _mapCacheHas;\nMapCache.prototype.set = _mapCacheSet;\n\nvar _MapCache = MapCache;\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof _ListCache) {\n    var pairs = data.__data__;\n    if (!_Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new _MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\nvar _stackSet = stackSet;\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new _ListCache(entries);\n  this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = _stackClear;\nStack.prototype['delete'] = _stackDelete;\nStack.prototype.get = _stackGet;\nStack.prototype.has = _stackHas;\nStack.prototype.set = _stackSet;\n\nvar _Stack = Stack;\n\nvar defineProperty = (function() {\n  try {\n    var func = _getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\nvar _defineProperty = defineProperty;\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && _defineProperty) {\n    _defineProperty(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n\nvar _baseAssignValue = baseAssignValue;\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n  if ((value !== undefined && !eq_1(object[key], value)) ||\n      (value === undefined && !(key in object))) {\n    _baseAssignValue(object, key, value);\n  }\n}\n\nvar _assignMergeValue = assignMergeValue;\n\n/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n  return function(object, iteratee, keysFunc) {\n    var index = -1,\n        iterable = Object(object),\n        props = keysFunc(object),\n        length = props.length;\n\n    while (length--) {\n      var key = props[fromRight ? length : ++index];\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n    return object;\n  };\n}\n\nvar _createBaseFor = createBaseFor;\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = _createBaseFor();\n\nvar _baseFor = baseFor;\n\nvar _cloneBuffer = createCommonjsModule(function (module, exports) {\n/** Detect free variable `exports`. */\nvar freeExports =  exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? _root.Buffer : undefined,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\nmodule.exports = cloneBuffer;\n});\n\n/** Built-in value references. */\nvar Uint8Array = _root.Uint8Array;\n\nvar _Uint8Array = Uint8Array;\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new _Uint8Array(result).set(new _Uint8Array(arrayBuffer));\n  return result;\n}\n\nvar _cloneArrayBuffer = cloneArrayBuffer;\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? _cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\nvar _cloneTypedArray = cloneTypedArray;\n\n/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\nvar _copyArray = copyArray;\n\n/** Built-in value references. */\nvar objectCreate = Object.create;\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(proto) {\n    if (!isObject_1$1(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object;\n    object.prototype = undefined;\n    return result;\n  };\n}());\n\nvar _baseCreate = baseCreate;\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\nvar _overArg = overArg;\n\n/** Built-in value references. */\nvar getPrototype = _overArg(Object.getPrototypeOf, Object);\n\nvar _getPrototype = getPrototype;\n\n/** Used for built-in method references. */\nvar objectProto$5 = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$5;\n\n  return value === proto;\n}\n\nvar _isPrototype = isPrototype;\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !_isPrototype(object))\n    ? _baseCreate(_getPrototype(object))\n    : {};\n}\n\nvar _initCloneObject = initCloneObject;\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nvar isObjectLike_1 = isObjectLike;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike_1(value) && _baseGetTag(value) == argsTag;\n}\n\nvar _baseIsArguments = baseIsArguments;\n\n/** Used for built-in method references. */\nvar objectProto$6 = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$6 = objectProto$6.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto$6.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = _baseIsArguments(function() { return arguments; }()) ? _baseIsArguments : function(value) {\n  return isObjectLike_1(value) && hasOwnProperty$6.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\nvar isArguments_1 = isArguments;\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray$3 = Array.isArray;\n\nvar isArray_1 = isArray$3;\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nvar isLength_1 = isLength;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength_1(value.length) && !isFunction_1(value);\n}\n\nvar isArrayLike_1 = isArrayLike;\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike_1(value) && isArrayLike_1(value);\n}\n\nvar isArrayLikeObject_1 = isArrayLikeObject;\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nvar stubFalse_1 = stubFalse;\n\nvar isBuffer_1 = createCommonjsModule(function (module, exports) {\n/** Detect free variable `exports`. */\nvar freeExports =  exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? _root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse_1;\n\nmodule.exports = isBuffer;\n});\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto$2 = Function.prototype,\n    objectProto$7 = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString$2 = funcProto$2.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$7 = objectProto$7.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString$2.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike_1(value) || _baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = _getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty$7.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString$2.call(Ctor) == objectCtorString;\n}\n\nvar isPlainObject_1 = isPlainObject;\n\n/** `Object#toString` result references. */\nvar argsTag$1 = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag$1 = '[object Function]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag$1 = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag$1] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag$1] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag$1] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike_1(value) &&\n    isLength_1(value.length) && !!typedArrayTags[_baseGetTag(value)];\n}\n\nvar _baseIsTypedArray = baseIsTypedArray;\n\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\nvar _baseUnary = baseUnary;\n\nvar _nodeUtil = createCommonjsModule(function (module, exports) {\n/** Detect free variable `exports`. */\nvar freeExports =  exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && _freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    // Use `util.types` for Node.js 10+.\n    var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n    if (types) {\n      return types;\n    }\n\n    // Legacy `process.binding('util')` for Node.js < 10.\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\nmodule.exports = nodeUtil;\n});\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = _nodeUtil && _nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? _baseUnary(nodeIsTypedArray) : _baseIsTypedArray;\n\nvar isTypedArray_1 = isTypedArray;\n\n/**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction safeGet(object, key) {\n  if (key === 'constructor' && typeof object[key] === 'function') {\n    return;\n  }\n\n  if (key == '__proto__') {\n    return;\n  }\n\n  return object[key];\n}\n\nvar _safeGet = safeGet;\n\n/** Used for built-in method references. */\nvar objectProto$8 = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$8 = objectProto$8.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty$8.call(object, key) && eq_1(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    _baseAssignValue(object, key, value);\n  }\n}\n\nvar _assignValue = assignValue;\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      _baseAssignValue(object, key, newValue);\n    } else {\n      _assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\nvar _copyObject = copyObject;\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\nvar _baseTimes = baseTimes;\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER$1 = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  var type = typeof value;\n  length = length == null ? MAX_SAFE_INTEGER$1 : length;\n\n  return !!length &&\n    (type == 'number' ||\n      (type != 'symbol' && reIsUint.test(value))) &&\n        (value > -1 && value % 1 == 0 && value < length);\n}\n\nvar _isIndex = isIndex;\n\n/** Used for built-in method references. */\nvar objectProto$9 = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$9 = objectProto$9.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray_1(value),\n      isArg = !isArr && isArguments_1(value),\n      isBuff = !isArr && !isArg && isBuffer_1(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray_1(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? _baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty$9.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           _isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nvar _arrayLikeKeys = arrayLikeKeys;\n\n/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nvar _nativeKeysIn = nativeKeysIn;\n\n/** Used for built-in method references. */\nvar objectProto$a = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty$a = objectProto$a.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n  if (!isObject_1$1(object)) {\n    return _nativeKeysIn(object);\n  }\n  var isProto = _isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty$a.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nvar _baseKeysIn = baseKeysIn;\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike_1(object) ? _arrayLikeKeys(object, true) : _baseKeysIn(object);\n}\n\nvar keysIn_1 = keysIn;\n\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n  return _copyObject(value, keysIn_1(value));\n}\n\nvar toPlainObject_1 = toPlainObject;\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n  var objValue = _safeGet(object, key),\n      srcValue = _safeGet(source, key),\n      stacked = stack.get(srcValue);\n\n  if (stacked) {\n    _assignMergeValue(object, key, stacked);\n    return;\n  }\n  var newValue = customizer\n    ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n    : undefined;\n\n  var isCommon = newValue === undefined;\n\n  if (isCommon) {\n    var isArr = isArray_1(srcValue),\n        isBuff = !isArr && isBuffer_1(srcValue),\n        isTyped = !isArr && !isBuff && isTypedArray_1(srcValue);\n\n    newValue = srcValue;\n    if (isArr || isBuff || isTyped) {\n      if (isArray_1(objValue)) {\n        newValue = objValue;\n      }\n      else if (isArrayLikeObject_1(objValue)) {\n        newValue = _copyArray(objValue);\n      }\n      else if (isBuff) {\n        isCommon = false;\n        newValue = _cloneBuffer(srcValue, true);\n      }\n      else if (isTyped) {\n        isCommon = false;\n        newValue = _cloneTypedArray(srcValue, true);\n      }\n      else {\n        newValue = [];\n      }\n    }\n    else if (isPlainObject_1(srcValue) || isArguments_1(srcValue)) {\n      newValue = objValue;\n      if (isArguments_1(objValue)) {\n        newValue = toPlainObject_1(objValue);\n      }\n      else if (!isObject_1$1(objValue) || isFunction_1(objValue)) {\n        newValue = _initCloneObject(srcValue);\n      }\n    }\n    else {\n      isCommon = false;\n    }\n  }\n  if (isCommon) {\n    // Recursively merge objects and arrays (susceptible to call stack limits).\n    stack.set(srcValue, newValue);\n    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n    stack['delete'](srcValue);\n  }\n  _assignMergeValue(object, key, newValue);\n}\n\nvar _baseMergeDeep = baseMergeDeep;\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n  if (object === source) {\n    return;\n  }\n  _baseFor(source, function(srcValue, key) {\n    stack || (stack = new _Stack);\n    if (isObject_1$1(srcValue)) {\n      _baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n    }\n    else {\n      var newValue = customizer\n        ? customizer(_safeGet(object, key), srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      if (newValue === undefined) {\n        newValue = srcValue;\n      }\n      _assignMergeValue(object, key, newValue);\n    }\n  }, keysIn_1);\n}\n\nvar _baseMerge = baseMerge;\n\n/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\nvar identity_1 = identity;\n\n/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply$1(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\nvar _apply = apply$1;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = transform(array);\n    return _apply(func, this, otherArgs);\n  };\n}\n\nvar _overRest = overRest;\n\n/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\nvar constant_1 = constant;\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !_defineProperty ? identity_1 : function(func, string) {\n  return _defineProperty(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant_1(string),\n    'writable': true\n  });\n};\n\nvar _baseSetToString = baseSetToString;\n\n/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n    HOT_SPAN = 16;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeNow = Date.now;\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n  var count = 0,\n      lastCalled = 0;\n\n  return function() {\n    var stamp = nativeNow(),\n        remaining = HOT_SPAN - (stamp - lastCalled);\n\n    lastCalled = stamp;\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n    return func.apply(undefined, arguments);\n  };\n}\n\nvar _shortOut = shortOut;\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = _shortOut(_baseSetToString);\n\nvar _setToString = setToString;\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  return _setToString(_overRest(func, start, identity_1), func + '');\n}\n\nvar _baseRest = baseRest;\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject_1$1(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n        ? (isArrayLike_1(object) && _isIndex(index, object.length))\n        : (type == 'string' && index in object)\n      ) {\n    return eq_1(object[index], value);\n  }\n  return false;\n}\n\nvar _isIterateeCall = isIterateeCall;\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return _baseRest(function(object, sources) {\n    var index = -1,\n        length = sources.length,\n        customizer = length > 1 ? sources[length - 1] : undefined,\n        guard = length > 2 ? sources[2] : undefined;\n\n    customizer = (assigner.length > 3 && typeof customizer == 'function')\n      ? (length--, customizer)\n      : undefined;\n\n    if (guard && _isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    object = Object(object);\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, index, customizer);\n      }\n    }\n    return object;\n  });\n}\n\nvar _createAssigner = createAssigner;\n\n/**\n * This method is like `_.merge` except that it accepts `customizer` which\n * is invoked to produce the merged values of the destination and source\n * properties. If `customizer` returns `undefined`, merging is handled by the\n * method instead. The `customizer` is invoked with six arguments:\n * (objValue, srcValue, key, object, source, stack).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} sources The source objects.\n * @param {Function} customizer The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @example\n *\n * function customizer(objValue, srcValue) {\n *   if (_.isArray(objValue)) {\n *     return objValue.concat(srcValue);\n *   }\n * }\n *\n * var object = { 'a': [1], 'b': [2] };\n * var other = { 'a': [3], 'b': [4] };\n *\n * _.mergeWith(object, other, customizer);\n * // => { 'a': [1, 3], 'b': [2, 4] }\n */\nvar mergeWith = _createAssigner(function(object, source, srcIndex, customizer) {\n  _baseMerge(object, source, srcIndex, customizer);\n});\n\nvar mergeWith_1 = mergeWith;\n\nfunction customizer(objValue, srcValue) {\n\tif (isArray_1(objValue)) {\n\t\treturn objValue.concat(srcValue);\n\t}\n}\n\n// The security object has a bizare setup...\nfunction fixSecurityObject(thing) {\n\tif (thing.security) {\n\t\tconst newSecurity = Object.keys(thing.security).map((s) => ({\n\t\t\t[s]: thing.security[s],\n\t\t}));\n\t\tthing.security = newSecurity;\n\t}\n}\n\nconst primitiveTypes = [\n\t'integer',\n\t'number',\n\t'string',\n\t'boolean',\n\t'object',\n\t'array',\n];\n\nconst formatMap = {\n\tint32: 'integer',\n\tint64: 'integer',\n\tfloat: 'number',\n\tdouble: 'number',\n\tdate: 'string',\n\t'date-time': 'string',\n\tpassword: 'string',\n\tbyte: 'string',\n\tbinary: 'string',\n};\n\nfunction parseDescription(tag) {\n\tconst rawType = tag.type;\n\tconst isArray = rawType && rawType.endsWith('[]');\n\n\tlet parsedType;\n\tif (rawType) {\n\t\tparsedType = rawType.replace(/\\[\\]$/, '');\n\t}\n\n\tconst isPrimitive = primitiveTypes.includes(parsedType);\n\tconst isFormat = Object.keys(formatMap).includes(parsedType);\n\n\tlet defaultValue;\n\tif (tag.default) {\n\t\tswitch (parsedType) {\n\t\t\tcase 'integer':\n\t\t\tcase 'int32':\n\t\t\tcase 'int64':\n\t\t\t\tdefaultValue = parseInt(tag.default, 10);\n\t\t\t\tbreak;\n\t\t\tcase 'number':\n\t\t\tcase 'double':\n\t\t\tcase 'float':\n\t\t\t\tdefaultValue = parseFloat(tag.default);\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tdefaultValue = tag.default;\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\tlet rootType;\n\tif (isPrimitive) {\n\t\trootType = { type: parsedType, default: defaultValue };\n\t} else if (isFormat) {\n\t\trootType = {\n\t\t\ttype: formatMap[parsedType],\n\t\t\tformat: parsedType,\n\t\t\tdefault: defaultValue,\n\t\t};\n\t} else {\n\t\trootType = { $ref: `#/components/schemas/${parsedType}` };\n\t}\n\n\tlet schema;\n\tif (isArray) {\n\t\tschema = {\n\t\t\ttype: 'array',\n\t\t\titems: {\n\t\t\t\t...rootType,\n\t\t\t},\n\t\t};\n\t} else {\n\t\tschema = {\n\t\t\t...rootType,\n\t\t};\n\t}\n\n\tif (parsedType === undefined) {\n\t\tschema = undefined;\n\t}\n\n\t// remove the optional dash from the description.\n\tlet description = tag.description.trim().replace(/^- /, '');\n\tif (description === '') {\n\t\tdescription = undefined;\n\t}\n\n\treturn {\n\t\tname: tag.name,\n\t\tdescription: description,\n\t\trequired: !tag.optional,\n\t\tschema: schema,\n\t\trawType: rawType,\n\t};\n}\n\nfunction tagsToObjects(tags, verbose) {\n\treturn tags.map((tag) => {\n\t\tconst parsedResponse = parseDescription(tag);\n\n\t\t// Some ops only have a `description`, merge `name` and `description`\n\t\t// for these.\n\t\tlet nameAndDescription = '';\n\t\tif (parsedResponse.name) {\n\t\t\tnameAndDescription += parsedResponse.name;\n\t\t}\n\t\tif (parsedResponse.description) {\n\t\t\tnameAndDescription += ` ${parsedResponse.description.trim()}`;\n\t\t}\n\n\t\tswitch (tag.tag) {\n\t\t\tcase 'operationId':\n\t\t\tcase 'summary':\n\t\t\tcase 'description':\n\t\t\t\treturn { [tag.tag]: nameAndDescription };\n\n\t\t\tcase 'deprecated':\n\t\t\t\treturn { deprecated: true };\n\n\t\t\tcase 'externalDocs':\n\t\t\t\treturn {\n\t\t\t\t\texternalDocs: {\n\t\t\t\t\t\turl: parsedResponse.name,\n\t\t\t\t\t\tdescription: parsedResponse.description,\n\t\t\t\t\t},\n\t\t\t\t};\n\n\t\t\tcase 'server':\n\t\t\t\treturn {\n\t\t\t\t\tservers: [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\turl: parsedResponse.name,\n\t\t\t\t\t\t\tdescription: parsedResponse.description,\n\t\t\t\t\t\t},\n\t\t\t\t\t],\n\t\t\t\t};\n\n\t\t\tcase 'tag':\n\t\t\t\treturn { tags: [nameAndDescription] };\n\n\t\t\tcase 'cookieParam':\n\t\t\tcase 'headerParam':\n\t\t\tcase 'queryParam':\n\t\t\tcase 'pathParam':\n\t\t\t\treturn {\n\t\t\t\t\tparameters: [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tname: parsedResponse.name,\n\t\t\t\t\t\t\tin: tag.tag.replace(/Param$/, ''),\n\t\t\t\t\t\t\tdescription: parsedResponse.description,\n\t\t\t\t\t\t\trequired: parsedResponse.required,\n\t\t\t\t\t\t\tschema: parsedResponse.schema,\n\t\t\t\t\t\t},\n\t\t\t\t\t],\n\t\t\t\t};\n\n\t\t\tcase 'bodyContent':\n\t\t\t\treturn {\n\t\t\t\t\trequestBody: {\n\t\t\t\t\t\tcontent: {\n\t\t\t\t\t\t\t[parsedResponse.name.replace('*\\\\/*', '*/*')]: {\n\t\t\t\t\t\t\t\tschema: parsedResponse.schema,\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t};\n\n\t\t\tcase 'bodyDescription':\n\t\t\t\treturn { requestBody: { description: nameAndDescription } };\n\n\t\t\tcase 'bodyRequired':\n\t\t\t\treturn { requestBody: { required: true } };\n\n\t\t\tcase 'response':\n\t\t\t\treturn {\n\t\t\t\t\tresponses: {\n\t\t\t\t\t\t[parsedResponse.name]: {\n\t\t\t\t\t\t\tdescription: parsedResponse.description,\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t};\n\n\t\t\tcase 'callback':\n\t\t\t\treturn {\n\t\t\t\t\tcallbacks: {\n\t\t\t\t\t\t[parsedResponse.name]: {\n\t\t\t\t\t\t\t$ref: `#/components/callbacks/${parsedResponse.rawType}`,\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t};\n\n\t\t\tcase 'responseContent': {\n\t\t\t\tconst [status, contentType] = parsedResponse.name.split('.');\n\n\t\t\t\treturn {\n\t\t\t\t\tresponses: {\n\t\t\t\t\t\t[status]: {\n\t\t\t\t\t\t\tcontent: {\n\t\t\t\t\t\t\t\t[contentType]: {\n\t\t\t\t\t\t\t\t\tschema: parsedResponse.schema,\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tcase 'responseHeaderComponent': {\n\t\t\t\tconst [status, header] = parsedResponse.name.split('.');\n\t\t\t\treturn {\n\t\t\t\t\tresponses: {\n\t\t\t\t\t\t[status]: {\n\t\t\t\t\t\t\theaders: {\n\t\t\t\t\t\t\t\t[header]: {\n\t\t\t\t\t\t\t\t\t$ref: `#/components/headers/${parsedResponse.rawType}`,\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tcase 'responseHeader': {\n\t\t\t\tconst [status, header] = parsedResponse.name.split('.');\n\t\t\t\treturn {\n\t\t\t\t\tresponses: {\n\t\t\t\t\t\t[status]: {\n\t\t\t\t\t\t\theaders: {\n\t\t\t\t\t\t\t\t[header]: {\n\t\t\t\t\t\t\t\t\tdescription: parsedResponse.description,\n\t\t\t\t\t\t\t\t\tschema: parsedResponse.schema,\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tcase 'responseExample': {\n\t\t\t\tconst [status, contentType, example] = parsedResponse.name.split('.');\n\t\t\t\treturn {\n\t\t\t\t\tresponses: {\n\t\t\t\t\t\t[status]: {\n\t\t\t\t\t\t\tcontent: {\n\t\t\t\t\t\t\t\t[contentType]: {\n\t\t\t\t\t\t\t\t\texamples: {\n\t\t\t\t\t\t\t\t\t\t[example]: {\n\t\t\t\t\t\t\t\t\t\t\t$ref: `#/components/examples/${parsedResponse.rawType}`,\n\t\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tcase 'responseLink': {\n\t\t\t\tconst [status, link] = parsedResponse.name.split('.');\n\t\t\t\treturn {\n\t\t\t\t\tresponses: {\n\t\t\t\t\t\t[status]: {\n\t\t\t\t\t\t\tlinks: {\n\t\t\t\t\t\t\t\t[link]: {\n\t\t\t\t\t\t\t\t\t$ref: `#/components/links/${parsedResponse.rawType}`,\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tcase 'bodyComponent':\n\t\t\t\treturn {\n\t\t\t\t\trequestBody: {\n\t\t\t\t\t\t$ref: `#/components/requestBodies/${parsedResponse.rawType}`,\n\t\t\t\t\t},\n\t\t\t\t};\n\n\t\t\tcase 'responseComponent':\n\t\t\t\treturn {\n\t\t\t\t\tresponses: {\n\t\t\t\t\t\t[parsedResponse.name]: {\n\t\t\t\t\t\t\t$ref: `#/components/responses/${parsedResponse.rawType}`,\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t};\n\n\t\t\tcase 'paramComponent':\n\t\t\t\treturn {\n\t\t\t\t\tparameters: [\n\t\t\t\t\t\t{ $ref: `#/components/parameters/${parsedResponse.rawType}` },\n\t\t\t\t\t],\n\t\t\t\t};\n\n\t\t\tcase 'security': {\n\t\t\t\tconst [security, scopeItem] = parsedResponse.name.split('.');\n\t\t\t\tlet scope = [];\n\t\t\t\tif (scopeItem) {\n\t\t\t\t\tscope = [scopeItem];\n\t\t\t\t}\n\t\t\t\treturn {\n\t\t\t\t\tsecurity: { [security]: scope },\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tdefault: {\n\t\t\t\treturn {};\n\t\t\t}\n\t\t}\n\t});\n}\n\nfunction commentsToOpenApi(\n\tfileContents,\n\tverbose\n) {\n\tconst openAPIRegex = /^(GET|PUT|POST|DELETE|OPTIONS|HEAD|PATCH|TRACE) \\/.*$/;\n\n\tconst jsDocComments = commentParser$1(fileContents, { trim: false });\n\n\tconst filteredComments = jsDocComments\n\t\t.filter((comment) => {\n\t\t\tconst validComment = openAPIRegex.test(comment.description.trim());\n\n\t\t\treturn validComment;\n\t\t})\n\t\t.map((comment) => {\n\t\t\t// Line count, number of tags + 1 for description.\n\t\t\t// - Don't count line-breaking due to long descriptions\n\t\t\t// - Don't count empty lines\n\t\t\tconst loc = comment.tags.length + 1;\n\n\t\t\tconst objects = tagsToObjects(comment.tags);\n\n\t\t\tconst res = mergeWith_1({}, ...objects, customizer);\n\n\t\t\tfixSecurityObject(res);\n\n\t\t\tconst [method, path] = comment.description.split(' ');\n\n\t\t\tconst pathsObject = {\n\t\t\t\t[path.trim()]: {\n\t\t\t\t\t[method.toLowerCase().trim()]: {\n\t\t\t\t\t\t...res,\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t};\n\n\t\t\t// Purge all undefined objects/arrays.\n\t\t\tconst spec = JSON.parse(JSON.stringify({ paths: pathsObject }));\n\t\t\treturn {\n\t\t\t\tspec: spec,\n\t\t\t\tloc: loc,\n\t\t\t};\n\t\t});\n\treturn filteredComments;\n}\n\nfunction yamlLOC(string) {\n\t// Break string into lines.\n\tconst split = string.split(/\\r\\n|\\r|\\n/);\n\tconst filtered = split.filter((line) => {\n\t\t// Remove comments.\n\t\tif (/^\\s*([#]\\s*.*)?$/.test(line)) {\n\t\t\treturn false;\n\t\t}\n\t\t// Remove empty lines.\n\t\treturn line.trim().length > 0;\n\t});\n\tconst loc = filtered.length;\n\treturn loc;\n}\n\nconst ALLOWED_KEYS = [\n\t'openapi',\n\t'info',\n\t'servers',\n\t'security',\n\t'tags',\n\t'externalDocs',\n\t'components',\n\t'paths',\n];\n\nfunction parseFile(\n\tfile,\n\tlinter,\n\tverbose\n) {\n\tconst fileContent = fs$2.readFileSync(file, { encoding: 'utf8' });\n\tconst ext = path$1.extname(file);\n\n\tif (ext === '.yaml' || ext === '.yml') {\n\t\ttry {\n\t\t\tconst spec = jsYaml$1.safeLoad(fileContent);\n\t\t\tconst invalidKeys = Object.keys(spec).filter(\n\t\t\t\t(key) => !ALLOWED_KEYS.includes(key)\n\t\t\t);\n\n\t\t\tlet messages = [];\n\t\t\tif (invalidKeys.length > 0) {\n\t\t\t\tinvalidKeys.forEach((key) => {\n\t\t\t\t\tmessages.push({\n\t\t\t\t\t\tseverity: 1,\n\t\t\t\t\t\tmessage: `unexpected key '${key}'`,\n\t\t\t\t\t\tline: 0,\n\t\t\t\t\t\tcolumn: 0,\n\t\t\t\t\t});\n\t\t\t\t\tdelete spec[key];\n\t\t\t\t});\n\t\t\t}\n\n\t\t\tif (Object.keys(spec).find((key) => ALLOWED_KEYS.includes(key))) {\n\t\t\t\tconst loc = yamlLOC(fileContent);\n\t\t\t\treturn {\n\t\t\t\t\tparsedFile: [{ spec: spec, loc: loc }],\n\t\t\t\t\tmessages: messages,\n\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn { parsedFile: [], messages: messages };\n\t\t} catch (e) {\n\t\t\treturn {\n\t\t\t\tparsedFile: [],\n\t\t\t\tmessages: [\n\t\t\t\t\t{\n\t\t\t\t\t\tseverity: 2,\n\t\t\t\t\t\tmessage: e.reason,\n\t\t\t\t\t\tline: e.mark.line + 1, // eslint indexed by 1 for line.\n\t\t\t\t\t\tcolumn: e.mark.column,\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t};\n\t\t}\n\t} else {\n\t\tconst jsDocComments = commentParser$1(fileContent);\n\n\t\tconst rawCommentString = jsDocComments.reduce((acc, c) => {\n\t\t\tacc += '\\n' + stringify_1([c]);\n\t\t\treturn acc;\n\t\t}, '');\n\n\t\tconst messages = linter.verify(rawCommentString, {\n\t\t\trules: {\n\t\t\t\twarnings: 'warn',\n\t\t\t\terrors: 'error',\n\t\t\t},\n\t\t});\n\t\treturn {\n\t\t\tparsedFile: commentsToOpenApi(fileContent),\n\t\t\tmessages: messages,\n\t\t};\n\t}\n}\n\nvar arrayUnion = (...arguments_) => {\n\treturn [...new Set([].concat(...arguments_))];\n};\n\n/*\n * merge2\n * https://github.com/teambition/merge2\n *\n * Copyright (c) 2014-2016 Teambition\n * Licensed under the MIT license.\n */\n\nconst PassThrough = stream$4.PassThrough;\nconst slice$2 = Array.prototype.slice;\n\nvar merge2_1 = merge2;\n\nfunction merge2 () {\n  const streamsQueue = [];\n  let merging = false;\n  const args = slice$2.call(arguments);\n  let options = args[args.length - 1];\n\n  if (options && !Array.isArray(options) && options.pipe == null) args.pop();\n  else options = {};\n\n  const doEnd = options.end !== false;\n  if (options.objectMode == null) options.objectMode = true;\n  if (options.highWaterMark == null) options.highWaterMark = 64 * 1024;\n  const mergedStream = PassThrough(options);\n\n  function addStream () {\n    for (let i = 0, len = arguments.length; i < len; i++) {\n      streamsQueue.push(pauseStreams(arguments[i], options));\n    }\n    mergeStream();\n    return this\n  }\n\n  function mergeStream () {\n    if (merging) return\n    merging = true;\n\n    let streams = streamsQueue.shift();\n    if (!streams) {\n      process.nextTick(endStream);\n      return\n    }\n    if (!Array.isArray(streams)) streams = [streams];\n\n    let pipesCount = streams.length + 1;\n\n    function next () {\n      if (--pipesCount > 0) return\n      merging = false;\n      mergeStream();\n    }\n\n    function pipe (stream) {\n      function onend () {\n        stream.removeListener('merge2UnpipeEnd', onend);\n        stream.removeListener('end', onend);\n        next();\n      }\n      // skip ended stream\n      if (stream._readableState.endEmitted) return next()\n\n      stream.on('merge2UnpipeEnd', onend);\n      stream.on('end', onend);\n      stream.pipe(mergedStream, { end: false });\n      // compatible for old stream\n      stream.resume();\n    }\n\n    for (let i = 0; i < streams.length; i++) pipe(streams[i]);\n\n    next();\n  }\n\n  function endStream () {\n    merging = false;\n    // emit 'queueDrain' when all streams merged.\n    mergedStream.emit('queueDrain');\n    return doEnd && mergedStream.end()\n  }\n\n  mergedStream.setMaxListeners(0);\n  mergedStream.add = addStream;\n  mergedStream.on('unpipe', function (stream) {\n    stream.emit('merge2UnpipeEnd');\n  });\n\n  if (args.length) addStream.apply(null, args);\n  return mergedStream\n}\n\n// check and pause streams for pipe.\nfunction pauseStreams (streams, options) {\n  if (!Array.isArray(streams)) {\n    // Backwards-compat with old-style streams\n    if (!streams._readableState && streams.pipe) streams = streams.pipe(PassThrough(options));\n    if (!streams._readableState || !streams.pause || !streams.pipe) {\n      throw new Error('Only readable stream can be merged.')\n    }\n    streams.pause();\n  } else {\n    for (let i = 0, len = streams.length; i < len; i++) streams[i] = pauseStreams(streams[i], options);\n  }\n  return streams\n}\n\nvar array = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nfunction flatten(items) {\r\n    return items.reduce((collection, item) => [].concat(collection, item), []);\r\n}\r\nexports.flatten = flatten;\r\nfunction splitWhen(items, predicate) {\r\n    const result = [[]];\r\n    let groupIndex = 0;\r\n    for (const item of items) {\r\n        if (predicate(item)) {\r\n            groupIndex++;\r\n            result[groupIndex] = [];\r\n        }\r\n        else {\r\n            result[groupIndex].push(item);\r\n        }\r\n    }\r\n    return result;\r\n}\r\nexports.splitWhen = splitWhen;\n});\n\nunwrapExports(array);\nvar array_1 = array.flatten;\nvar array_2 = array.splitWhen;\n\nvar errno = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nfunction isEnoentCodeError(error) {\r\n    return error.code === 'ENOENT';\r\n}\r\nexports.isEnoentCodeError = isEnoentCodeError;\n});\n\nunwrapExports(errno);\nvar errno_1 = errno.isEnoentCodeError;\n\nvar fs = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nclass DirentFromStats {\r\n    constructor(name, stats) {\r\n        this.name = name;\r\n        this.isBlockDevice = stats.isBlockDevice.bind(stats);\r\n        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);\r\n        this.isDirectory = stats.isDirectory.bind(stats);\r\n        this.isFIFO = stats.isFIFO.bind(stats);\r\n        this.isFile = stats.isFile.bind(stats);\r\n        this.isSocket = stats.isSocket.bind(stats);\r\n        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);\r\n    }\r\n}\r\nfunction createDirentFromStats(name, stats) {\r\n    return new DirentFromStats(name, stats);\r\n}\r\nexports.createDirentFromStats = createDirentFromStats;\n});\n\nunwrapExports(fs);\nvar fs_1 = fs.createDirentFromStats;\n\nvar path_1 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nconst LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\\\\r\nconst UNESCAPED_GLOB_SYMBOLS_RE = /(\\\\?)([()*?[\\]{|}]|^!|[!+@](?=\\())/g;\r\n/**\r\n * Designed to work only with simple paths: `dir\\\\file`.\r\n */\r\nfunction unixify(filepath) {\r\n    return filepath.replace(/\\\\/g, '/');\r\n}\r\nexports.unixify = unixify;\r\nfunction makeAbsolute(cwd, filepath) {\r\n    return path$1.resolve(cwd, filepath);\r\n}\r\nexports.makeAbsolute = makeAbsolute;\r\nfunction escape(pattern) {\r\n    return pattern.replace(UNESCAPED_GLOB_SYMBOLS_RE, '\\\\$2');\r\n}\r\nexports.escape = escape;\r\nfunction removeLeadingDotSegment(entry) {\r\n    // We do not use `startsWith` because this is 10x slower than current implementation for some cases.\r\n    // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with\r\n    if (entry.charAt(0) === '.') {\r\n        const secondCharactery = entry.charAt(1);\r\n        if (secondCharactery === '/' || secondCharactery === '\\\\') {\r\n            return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);\r\n        }\r\n    }\r\n    return entry;\r\n}\r\nexports.removeLeadingDotSegment = removeLeadingDotSegment;\n});\n\nunwrapExports(path_1);\nvar path_2 = path_1.unixify;\nvar path_3 = path_1.makeAbsolute;\nvar path_4 = path_1.escape;\nvar path_5 = path_1.removeLeadingDotSegment;\n\nvar utils$3 = createCommonjsModule(function (module, exports) {\n\nexports.isInteger = num => {\n  if (typeof num === 'number') {\n    return Number.isInteger(num);\n  }\n  if (typeof num === 'string' && num.trim() !== '') {\n    return Number.isInteger(Number(num));\n  }\n  return false;\n};\n\n/**\n * Find a node of the given type\n */\n\nexports.find = (node, type) => node.nodes.find(node => node.type === type);\n\n/**\n * Find a node of the given type\n */\n\nexports.exceedsLimit = (min, max, step = 1, limit) => {\n  if (limit === false) return false;\n  if (!exports.isInteger(min) || !exports.isInteger(max)) return false;\n  return ((Number(max) - Number(min)) / Number(step)) >= limit;\n};\n\n/**\n * Escape the given node with '\\\\' before node.value\n */\n\nexports.escapeNode = (block, n = 0, type) => {\n  let node = block.nodes[n];\n  if (!node) return;\n\n  if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {\n    if (node.escaped !== true) {\n      node.value = '\\\\' + node.value;\n      node.escaped = true;\n    }\n  }\n};\n\n/**\n * Returns true if the given brace node should be enclosed in literal braces\n */\n\nexports.encloseBrace = node => {\n  if (node.type !== 'brace') return false;\n  if ((node.commas >> 0 + node.ranges >> 0) === 0) {\n    node.invalid = true;\n    return true;\n  }\n  return false;\n};\n\n/**\n * Returns true if a brace node is invalid.\n */\n\nexports.isInvalidBrace = block => {\n  if (block.type !== 'brace') return false;\n  if (block.invalid === true || block.dollar) return true;\n  if ((block.commas >> 0 + block.ranges >> 0) === 0) {\n    block.invalid = true;\n    return true;\n  }\n  if (block.open !== true || block.close !== true) {\n    block.invalid = true;\n    return true;\n  }\n  return false;\n};\n\n/**\n * Returns true if a node is an open or close node\n */\n\nexports.isOpenOrClose = node => {\n  if (node.type === 'open' || node.type === 'close') {\n    return true;\n  }\n  return node.open === true || node.close === true;\n};\n\n/**\n * Reduce an array of text nodes.\n */\n\nexports.reduce = nodes => nodes.reduce((acc, node) => {\n  if (node.type === 'text') acc.push(node.value);\n  if (node.type === 'range') node.type = 'text';\n  return acc;\n}, []);\n\n/**\n * Flatten an array\n */\n\nexports.flatten = (...args) => {\n  const result = [];\n  const flat = arr => {\n    for (let i = 0; i < arr.length; i++) {\n      let ele = arr[i];\n      Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele);\n    }\n    return result;\n  };\n  flat(args);\n  return result;\n};\n});\nvar utils_1$1 = utils$3.isInteger;\nvar utils_2$1 = utils$3.find;\nvar utils_3$1 = utils$3.exceedsLimit;\nvar utils_4 = utils$3.escapeNode;\nvar utils_5 = utils$3.encloseBrace;\nvar utils_6 = utils$3.isInvalidBrace;\nvar utils_7 = utils$3.isOpenOrClose;\nvar utils_8 = utils$3.reduce;\nvar utils_9 = utils$3.flatten;\n\nvar stringify$1 = (ast, options = {}) => {\n  let stringify = (node, parent = {}) => {\n    let invalidBlock = options.escapeInvalid && utils$3.isInvalidBrace(parent);\n    let invalidNode = node.invalid === true && options.escapeInvalid === true;\n    let output = '';\n\n    if (node.value) {\n      if ((invalidBlock || invalidNode) && utils$3.isOpenOrClose(node)) {\n        return '\\\\' + node.value;\n      }\n      return node.value;\n    }\n\n    if (node.value) {\n      return node.value;\n    }\n\n    if (node.nodes) {\n      for (let child of node.nodes) {\n        output += stringify(child);\n      }\n    }\n    return output;\n  };\n\n  return stringify(ast);\n};\n\n/*!\n * is-number <https://github.com/jonschlinkert/is-number>\n *\n * Copyright (c) 2014-present, Jon Schlinkert.\n * Released under the MIT License.\n */\n\nvar isNumber = function(num) {\n  if (typeof num === 'number') {\n    return num - num === 0;\n  }\n  if (typeof num === 'string' && num.trim() !== '') {\n    return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);\n  }\n  return false;\n};\n\nconst toRegexRange = (min, max, options) => {\n  if (isNumber(min) === false) {\n    throw new TypeError('toRegexRange: expected the first argument to be a number');\n  }\n\n  if (max === void 0 || min === max) {\n    return String(min);\n  }\n\n  if (isNumber(max) === false) {\n    throw new TypeError('toRegexRange: expected the second argument to be a number.');\n  }\n\n  let opts = { relaxZeros: true, ...options };\n  if (typeof opts.strictZeros === 'boolean') {\n    opts.relaxZeros = opts.strictZeros === false;\n  }\n\n  let relax = String(opts.relaxZeros);\n  let shorthand = String(opts.shorthand);\n  let capture = String(opts.capture);\n  let wrap = String(opts.wrap);\n  let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;\n\n  if (toRegexRange.cache.hasOwnProperty(cacheKey)) {\n    return toRegexRange.cache[cacheKey].result;\n  }\n\n  let a = Math.min(min, max);\n  let b = Math.max(min, max);\n\n  if (Math.abs(a - b) === 1) {\n    let result = min + '|' + max;\n    if (opts.capture) {\n      return `(${result})`;\n    }\n    if (opts.wrap === false) {\n      return result;\n    }\n    return `(?:${result})`;\n  }\n\n  let isPadded = hasPadding(min) || hasPadding(max);\n  let state = { min, max, a, b };\n  let positives = [];\n  let negatives = [];\n\n  if (isPadded) {\n    state.isPadded = isPadded;\n    state.maxLen = String(state.max).length;\n  }\n\n  if (a < 0) {\n    let newMin = b < 0 ? Math.abs(b) : 1;\n    negatives = splitToPatterns(newMin, Math.abs(a), state, opts);\n    a = state.a = 0;\n  }\n\n  if (b >= 0) {\n    positives = splitToPatterns(a, b, state, opts);\n  }\n\n  state.negatives = negatives;\n  state.positives = positives;\n  state.result = collatePatterns(negatives, positives);\n\n  if (opts.capture === true) {\n    state.result = `(${state.result})`;\n  } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {\n    state.result = `(?:${state.result})`;\n  }\n\n  toRegexRange.cache[cacheKey] = state;\n  return state.result;\n};\n\nfunction collatePatterns(neg, pos, options) {\n  let onlyNegative = filterPatterns(neg, pos, '-', false) || [];\n  let onlyPositive = filterPatterns(pos, neg, '', false) || [];\n  let intersected = filterPatterns(neg, pos, '-?', true) || [];\n  let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);\n  return subpatterns.join('|');\n}\n\nfunction splitToRanges(min, max) {\n  let nines = 1;\n  let zeros = 1;\n\n  let stop = countNines(min, nines);\n  let stops = new Set([max]);\n\n  while (min <= stop && stop <= max) {\n    stops.add(stop);\n    nines += 1;\n    stop = countNines(min, nines);\n  }\n\n  stop = countZeros(max + 1, zeros) - 1;\n\n  while (min < stop && stop <= max) {\n    stops.add(stop);\n    zeros += 1;\n    stop = countZeros(max + 1, zeros) - 1;\n  }\n\n  stops = [...stops];\n  stops.sort(compare);\n  return stops;\n}\n\n/**\n * Convert a range to a regex pattern\n * @param {Number} `start`\n * @param {Number} `stop`\n * @return {String}\n */\n\nfunction rangeToPattern(start, stop, options) {\n  if (start === stop) {\n    return { pattern: start, count: [], digits: 0 };\n  }\n\n  let zipped = zip$1(start, stop);\n  let digits = zipped.length;\n  let pattern = '';\n  let count = 0;\n\n  for (let i = 0; i < digits; i++) {\n    let [startDigit, stopDigit] = zipped[i];\n\n    if (startDigit === stopDigit) {\n      pattern += startDigit;\n\n    } else if (startDigit !== '0' || stopDigit !== '9') {\n      pattern += toCharacterClass(startDigit, stopDigit);\n\n    } else {\n      count++;\n    }\n  }\n\n  if (count) {\n    pattern += options.shorthand === true ? '\\\\d' : '[0-9]';\n  }\n\n  return { pattern, count: [count], digits };\n}\n\nfunction splitToPatterns(min, max, tok, options) {\n  let ranges = splitToRanges(min, max);\n  let tokens = [];\n  let start = min;\n  let prev;\n\n  for (let i = 0; i < ranges.length; i++) {\n    let max = ranges[i];\n    let obj = rangeToPattern(String(start), String(max), options);\n    let zeros = '';\n\n    if (!tok.isPadded && prev && prev.pattern === obj.pattern) {\n      if (prev.count.length > 1) {\n        prev.count.pop();\n      }\n\n      prev.count.push(obj.count[0]);\n      prev.string = prev.pattern + toQuantifier(prev.count);\n      start = max + 1;\n      continue;\n    }\n\n    if (tok.isPadded) {\n      zeros = padZeros(max, tok, options);\n    }\n\n    obj.string = zeros + obj.pattern + toQuantifier(obj.count);\n    tokens.push(obj);\n    start = max + 1;\n    prev = obj;\n  }\n\n  return tokens;\n}\n\nfunction filterPatterns(arr, comparison, prefix, intersection, options) {\n  let result = [];\n\n  for (let ele of arr) {\n    let { string } = ele;\n\n    // only push if _both_ are negative...\n    if (!intersection && !contains$1(comparison, 'string', string)) {\n      result.push(prefix + string);\n    }\n\n    // or _both_ are positive\n    if (intersection && contains$1(comparison, 'string', string)) {\n      result.push(prefix + string);\n    }\n  }\n  return result;\n}\n\n/**\n * Zip strings\n */\n\nfunction zip$1(a, b) {\n  let arr = [];\n  for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);\n  return arr;\n}\n\nfunction compare(a, b) {\n  return a > b ? 1 : b > a ? -1 : 0;\n}\n\nfunction contains$1(arr, key, val) {\n  return arr.some(ele => ele[key] === val);\n}\n\nfunction countNines(min, len) {\n  return Number(String(min).slice(0, -len) + '9'.repeat(len));\n}\n\nfunction countZeros(integer, zeros) {\n  return integer - (integer % Math.pow(10, zeros));\n}\n\nfunction toQuantifier(digits) {\n  let [start = 0, stop = ''] = digits;\n  if (stop || start > 1) {\n    return `{${start + (stop ? ',' + stop : '')}}`;\n  }\n  return '';\n}\n\nfunction toCharacterClass(a, b, options) {\n  return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;\n}\n\nfunction hasPadding(str) {\n  return /^-?(0+)\\d/.test(str);\n}\n\nfunction padZeros(value, tok, options) {\n  if (!tok.isPadded) {\n    return value;\n  }\n\n  let diff = Math.abs(tok.maxLen - String(value).length);\n  let relax = options.relaxZeros !== false;\n\n  switch (diff) {\n    case 0:\n      return '';\n    case 1:\n      return relax ? '0?' : '0';\n    case 2:\n      return relax ? '0{0,2}' : '00';\n    default: {\n      return relax ? `0{0,${diff}}` : `0{${diff}}`;\n    }\n  }\n}\n\n/**\n * Cache\n */\n\ntoRegexRange.cache = {};\ntoRegexRange.clearCache = () => (toRegexRange.cache = {});\n\n/**\n * Expose `toRegexRange`\n */\n\nvar toRegexRange_1 = toRegexRange;\n\nconst isObject$2 = val => val !== null && typeof val === 'object' && !Array.isArray(val);\n\nconst transform = toNumber => {\n  return value => toNumber === true ? Number(value) : String(value);\n};\n\nconst isValidValue = value => {\n  return typeof value === 'number' || (typeof value === 'string' && value !== '');\n};\n\nconst isNumber$1 = num => Number.isInteger(+num);\n\nconst zeros = input => {\n  let value = `${input}`;\n  let index = -1;\n  if (value[0] === '-') value = value.slice(1);\n  if (value === '0') return false;\n  while (value[++index] === '0');\n  return index > 0;\n};\n\nconst stringify$2 = (start, end, options) => {\n  if (typeof start === 'string' || typeof end === 'string') {\n    return true;\n  }\n  return options.stringify === true;\n};\n\nconst pad = (input, maxLength, toNumber) => {\n  if (maxLength > 0) {\n    let dash = input[0] === '-' ? '-' : '';\n    if (dash) input = input.slice(1);\n    input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));\n  }\n  if (toNumber === false) {\n    return String(input);\n  }\n  return input;\n};\n\nconst toMaxLen = (input, maxLength) => {\n  let negative = input[0] === '-' ? '-' : '';\n  if (negative) {\n    input = input.slice(1);\n    maxLength--;\n  }\n  while (input.length < maxLength) input = '0' + input;\n  return negative ? ('-' + input) : input;\n};\n\nconst toSequence = (parts, options) => {\n  parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);\n  parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);\n\n  let prefix = options.capture ? '' : '?:';\n  let positives = '';\n  let negatives = '';\n  let result;\n\n  if (parts.positives.length) {\n    positives = parts.positives.join('|');\n  }\n\n  if (parts.negatives.length) {\n    negatives = `-(${prefix}${parts.negatives.join('|')})`;\n  }\n\n  if (positives && negatives) {\n    result = `${positives}|${negatives}`;\n  } else {\n    result = positives || negatives;\n  }\n\n  if (options.wrap) {\n    return `(${prefix}${result})`;\n  }\n\n  return result;\n};\n\nconst toRange = (a, b, isNumbers, options) => {\n  if (isNumbers) {\n    return toRegexRange_1(a, b, { wrap: false, ...options });\n  }\n\n  let start = String.fromCharCode(a);\n  if (a === b) return start;\n\n  let stop = String.fromCharCode(b);\n  return `[${start}-${stop}]`;\n};\n\nconst toRegex = (start, end, options) => {\n  if (Array.isArray(start)) {\n    let wrap = options.wrap === true;\n    let prefix = options.capture ? '' : '?:';\n    return wrap ? `(${prefix}${start.join('|')})` : start.join('|');\n  }\n  return toRegexRange_1(start, end, options);\n};\n\nconst rangeError = (...args) => {\n  return new RangeError('Invalid range arguments: ' + util$2.inspect(...args));\n};\n\nconst invalidRange = (start, end, options) => {\n  if (options.strictRanges === true) throw rangeError([start, end]);\n  return [];\n};\n\nconst invalidStep = (step, options) => {\n  if (options.strictRanges === true) {\n    throw new TypeError(`Expected step \"${step}\" to be a number`);\n  }\n  return [];\n};\n\nconst fillNumbers = (start, end, step = 1, options = {}) => {\n  let a = Number(start);\n  let b = Number(end);\n\n  if (!Number.isInteger(a) || !Number.isInteger(b)) {\n    if (options.strictRanges === true) throw rangeError([start, end]);\n    return [];\n  }\n\n  // fix negative zero\n  if (a === 0) a = 0;\n  if (b === 0) b = 0;\n\n  let descending = a > b;\n  let startString = String(start);\n  let endString = String(end);\n  let stepString = String(step);\n  step = Math.max(Math.abs(step), 1);\n\n  let padded = zeros(startString) || zeros(endString) || zeros(stepString);\n  let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;\n  let toNumber = padded === false && stringify$2(start, end, options) === false;\n  let format = options.transform || transform(toNumber);\n\n  if (options.toRegex && step === 1) {\n    return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);\n  }\n\n  let parts = { negatives: [], positives: [] };\n  let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));\n  let range = [];\n  let index = 0;\n\n  while (descending ? a >= b : a <= b) {\n    if (options.toRegex === true && step > 1) {\n      push(a);\n    } else {\n      range.push(pad(format(a, index), maxLen, toNumber));\n    }\n    a = descending ? a - step : a + step;\n    index++;\n  }\n\n  if (options.toRegex === true) {\n    return step > 1\n      ? toSequence(parts, options)\n      : toRegex(range, null, { wrap: false, ...options });\n  }\n\n  return range;\n};\n\nconst fillLetters = (start, end, step = 1, options = {}) => {\n  if ((!isNumber$1(start) && start.length > 1) || (!isNumber$1(end) && end.length > 1)) {\n    return invalidRange(start, end, options);\n  }\n\n\n  let format = options.transform || (val => String.fromCharCode(val));\n  let a = `${start}`.charCodeAt(0);\n  let b = `${end}`.charCodeAt(0);\n\n  let descending = a > b;\n  let min = Math.min(a, b);\n  let max = Math.max(a, b);\n\n  if (options.toRegex && step === 1) {\n    return toRange(min, max, false, options);\n  }\n\n  let range = [];\n  let index = 0;\n\n  while (descending ? a >= b : a <= b) {\n    range.push(format(a, index));\n    a = descending ? a - step : a + step;\n    index++;\n  }\n\n  if (options.toRegex === true) {\n    return toRegex(range, null, { wrap: false, options });\n  }\n\n  return range;\n};\n\nconst fill = (start, end, step, options = {}) => {\n  if (end == null && isValidValue(start)) {\n    return [start];\n  }\n\n  if (!isValidValue(start) || !isValidValue(end)) {\n    return invalidRange(start, end, options);\n  }\n\n  if (typeof step === 'function') {\n    return fill(start, end, 1, { transform: step });\n  }\n\n  if (isObject$2(step)) {\n    return fill(start, end, 0, step);\n  }\n\n  let opts = { ...options };\n  if (opts.capture === true) opts.wrap = true;\n  step = step || opts.step || 1;\n\n  if (!isNumber$1(step)) {\n    if (step != null && !isObject$2(step)) return invalidStep(step, opts);\n    return fill(start, end, 1, step);\n  }\n\n  if (isNumber$1(start) && isNumber$1(end)) {\n    return fillNumbers(start, end, step, opts);\n  }\n\n  return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);\n};\n\nvar fillRange = fill;\n\nconst compile$2 = (ast, options = {}) => {\n  let walk = (node, parent = {}) => {\n    let invalidBlock = utils$3.isInvalidBrace(parent);\n    let invalidNode = node.invalid === true && options.escapeInvalid === true;\n    let invalid = invalidBlock === true || invalidNode === true;\n    let prefix = options.escapeInvalid === true ? '\\\\' : '';\n    let output = '';\n\n    if (node.isOpen === true) {\n      return prefix + node.value;\n    }\n    if (node.isClose === true) {\n      return prefix + node.value;\n    }\n\n    if (node.type === 'open') {\n      return invalid ? (prefix + node.value) : '(';\n    }\n\n    if (node.type === 'close') {\n      return invalid ? (prefix + node.value) : ')';\n    }\n\n    if (node.type === 'comma') {\n      return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|');\n    }\n\n    if (node.value) {\n      return node.value;\n    }\n\n    if (node.nodes && node.ranges > 0) {\n      let args = utils$3.reduce(node.nodes);\n      let range = fillRange(...args, { ...options, wrap: false, toRegex: true });\n\n      if (range.length !== 0) {\n        return args.length > 1 && range.length > 1 ? `(${range})` : range;\n      }\n    }\n\n    if (node.nodes) {\n      for (let child of node.nodes) {\n        output += walk(child, node);\n      }\n    }\n    return output;\n  };\n\n  return walk(ast);\n};\n\nvar compile_1$1 = compile$2;\n\nconst append = (queue = '', stash = '', enclose = false) => {\n  let result = [];\n\n  queue = [].concat(queue);\n  stash = [].concat(stash);\n\n  if (!stash.length) return queue;\n  if (!queue.length) {\n    return enclose ? utils$3.flatten(stash).map(ele => `{${ele}}`) : stash;\n  }\n\n  for (let item of queue) {\n    if (Array.isArray(item)) {\n      for (let value of item) {\n        result.push(append(value, stash, enclose));\n      }\n    } else {\n      for (let ele of stash) {\n        if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;\n        result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele));\n      }\n    }\n  }\n  return utils$3.flatten(result);\n};\n\nconst expand$1 = (ast, options = {}) => {\n  let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;\n\n  let walk = (node, parent = {}) => {\n    node.queue = [];\n\n    let p = parent;\n    let q = parent.queue;\n\n    while (p.type !== 'brace' && p.type !== 'root' && p.parent) {\n      p = p.parent;\n      q = p.queue;\n    }\n\n    if (node.invalid || node.dollar) {\n      q.push(append(q.pop(), stringify$1(node, options)));\n      return;\n    }\n\n    if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {\n      q.push(append(q.pop(), ['{}']));\n      return;\n    }\n\n    if (node.nodes && node.ranges > 0) {\n      let args = utils$3.reduce(node.nodes);\n\n      if (utils$3.exceedsLimit(...args, options.step, rangeLimit)) {\n        throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');\n      }\n\n      let range = fillRange(...args, options);\n      if (range.length === 0) {\n        range = stringify$1(node, options);\n      }\n\n      q.push(append(q.pop(), range));\n      node.nodes = [];\n      return;\n    }\n\n    let enclose = utils$3.encloseBrace(node);\n    let queue = node.queue;\n    let block = node;\n\n    while (block.type !== 'brace' && block.type !== 'root' && block.parent) {\n      block = block.parent;\n      queue = block.queue;\n    }\n\n    for (let i = 0; i < node.nodes.length; i++) {\n      let child = node.nodes[i];\n\n      if (child.type === 'comma' && node.type === 'brace') {\n        if (i === 1) queue.push('');\n        queue.push('');\n        continue;\n      }\n\n      if (child.type === 'close') {\n        q.push(append(q.pop(), queue, enclose));\n        continue;\n      }\n\n      if (child.value && child.type !== 'open') {\n        queue.push(append(queue.pop(), child.value));\n        continue;\n      }\n\n      if (child.nodes) {\n        walk(child, node);\n      }\n    }\n\n    return queue;\n  };\n\n  return utils$3.flatten(walk(ast));\n};\n\nvar expand_1 = expand$1;\n\nvar constants = {\n  MAX_LENGTH: 1024 * 64,\n\n  // Digits\n  CHAR_0: '0', /* 0 */\n  CHAR_9: '9', /* 9 */\n\n  // Alphabet chars.\n  CHAR_UPPERCASE_A: 'A', /* A */\n  CHAR_LOWERCASE_A: 'a', /* a */\n  CHAR_UPPERCASE_Z: 'Z', /* Z */\n  CHAR_LOWERCASE_Z: 'z', /* z */\n\n  CHAR_LEFT_PARENTHESES: '(', /* ( */\n  CHAR_RIGHT_PARENTHESES: ')', /* ) */\n\n  CHAR_ASTERISK: '*', /* * */\n\n  // Non-alphabetic chars.\n  CHAR_AMPERSAND: '&', /* & */\n  CHAR_AT: '@', /* @ */\n  CHAR_BACKSLASH: '\\\\', /* \\ */\n  CHAR_BACKTICK: '`', /* ` */\n  CHAR_CARRIAGE_RETURN: '\\r', /* \\r */\n  CHAR_CIRCUMFLEX_ACCENT: '^', /* ^ */\n  CHAR_COLON: ':', /* : */\n  CHAR_COMMA: ',', /* , */\n  CHAR_DOLLAR: '$', /* . */\n  CHAR_DOT: '.', /* . */\n  CHAR_DOUBLE_QUOTE: '\"', /* \" */\n  CHAR_EQUAL: '=', /* = */\n  CHAR_EXCLAMATION_MARK: '!', /* ! */\n  CHAR_FORM_FEED: '\\f', /* \\f */\n  CHAR_FORWARD_SLASH: '/', /* / */\n  CHAR_HASH: '#', /* # */\n  CHAR_HYPHEN_MINUS: '-', /* - */\n  CHAR_LEFT_ANGLE_BRACKET: '<', /* < */\n  CHAR_LEFT_CURLY_BRACE: '{', /* { */\n  CHAR_LEFT_SQUARE_BRACKET: '[', /* [ */\n  CHAR_LINE_FEED: '\\n', /* \\n */\n  CHAR_NO_BREAK_SPACE: '\\u00A0', /* \\u00A0 */\n  CHAR_PERCENT: '%', /* % */\n  CHAR_PLUS: '+', /* + */\n  CHAR_QUESTION_MARK: '?', /* ? */\n  CHAR_RIGHT_ANGLE_BRACKET: '>', /* > */\n  CHAR_RIGHT_CURLY_BRACE: '}', /* } */\n  CHAR_RIGHT_SQUARE_BRACKET: ']', /* ] */\n  CHAR_SEMICOLON: ';', /* ; */\n  CHAR_SINGLE_QUOTE: '\\'', /* ' */\n  CHAR_SPACE: ' ', /*   */\n  CHAR_TAB: '\\t', /* \\t */\n  CHAR_UNDERSCORE: '_', /* _ */\n  CHAR_VERTICAL_LINE: '|', /* | */\n  CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\\uFEFF' /* \\uFEFF */\n};\n\n/**\n * Constants\n */\n\nconst {\n  MAX_LENGTH,\n  CHAR_BACKSLASH, /* \\ */\n  CHAR_BACKTICK, /* ` */\n  CHAR_COMMA: CHAR_COMMA$1, /* , */\n  CHAR_DOT, /* . */\n  CHAR_LEFT_PARENTHESES, /* ( */\n  CHAR_RIGHT_PARENTHESES, /* ) */\n  CHAR_LEFT_CURLY_BRACE, /* { */\n  CHAR_RIGHT_CURLY_BRACE, /* } */\n  CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1, /* [ */\n  CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1, /* ] */\n  CHAR_DOUBLE_QUOTE: CHAR_DOUBLE_QUOTE$1, /* \" */\n  CHAR_SINGLE_QUOTE: CHAR_SINGLE_QUOTE$1, /* ' */\n  CHAR_NO_BREAK_SPACE,\n  CHAR_ZERO_WIDTH_NOBREAK_SPACE\n} = constants;\n\n/**\n * parse\n */\n\nconst parse$8 = (input, options = {}) => {\n  if (typeof input !== 'string') {\n    throw new TypeError('Expected a string');\n  }\n\n  let opts = options || {};\n  let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;\n  if (input.length > max) {\n    throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);\n  }\n\n  let ast = { type: 'root', input, nodes: [] };\n  let stack = [ast];\n  let block = ast;\n  let prev = ast;\n  let brackets = 0;\n  let length = input.length;\n  let index = 0;\n  let depth = 0;\n  let value;\n\n  /**\n   * Helpers\n   */\n\n  const advance = () => input[index++];\n  const push = node => {\n    if (node.type === 'text' && prev.type === 'dot') {\n      prev.type = 'text';\n    }\n\n    if (prev && prev.type === 'text' && node.type === 'text') {\n      prev.value += node.value;\n      return;\n    }\n\n    block.nodes.push(node);\n    node.parent = block;\n    node.prev = prev;\n    prev = node;\n    return node;\n  };\n\n  push({ type: 'bos' });\n\n  while (index < length) {\n    block = stack[stack.length - 1];\n    value = advance();\n\n    /**\n     * Invalid chars\n     */\n\n    if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {\n      continue;\n    }\n\n    /**\n     * Escaped chars\n     */\n\n    if (value === CHAR_BACKSLASH) {\n      push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });\n      continue;\n    }\n\n    /**\n     * Right square bracket (literal): ']'\n     */\n\n    if (value === CHAR_RIGHT_SQUARE_BRACKET$1) {\n      push({ type: 'text', value: '\\\\' + value });\n      continue;\n    }\n\n    /**\n     * Left square bracket: '['\n     */\n\n    if (value === CHAR_LEFT_SQUARE_BRACKET$1) {\n      brackets++;\n      let next;\n\n      while (index < length && (next = advance())) {\n        value += next;\n\n        if (next === CHAR_LEFT_SQUARE_BRACKET$1) {\n          brackets++;\n          continue;\n        }\n\n        if (next === CHAR_BACKSLASH) {\n          value += advance();\n          continue;\n        }\n\n        if (next === CHAR_RIGHT_SQUARE_BRACKET$1) {\n          brackets--;\n\n          if (brackets === 0) {\n            break;\n          }\n        }\n      }\n\n      push({ type: 'text', value });\n      continue;\n    }\n\n    /**\n     * Parentheses\n     */\n\n    if (value === CHAR_LEFT_PARENTHESES) {\n      block = push({ type: 'paren', nodes: [] });\n      stack.push(block);\n      push({ type: 'text', value });\n      continue;\n    }\n\n    if (value === CHAR_RIGHT_PARENTHESES) {\n      if (block.type !== 'paren') {\n        push({ type: 'text', value });\n        continue;\n      }\n      block = stack.pop();\n      push({ type: 'text', value });\n      block = stack[stack.length - 1];\n      continue;\n    }\n\n    /**\n     * Quotes: '|\"|`\n     */\n\n    if (value === CHAR_DOUBLE_QUOTE$1 || value === CHAR_SINGLE_QUOTE$1 || value === CHAR_BACKTICK) {\n      let open = value;\n      let next;\n\n      if (options.keepQuotes !== true) {\n        value = '';\n      }\n\n      while (index < length && (next = advance())) {\n        if (next === CHAR_BACKSLASH) {\n          value += next + advance();\n          continue;\n        }\n\n        if (next === open) {\n          if (options.keepQuotes === true) value += next;\n          break;\n        }\n\n        value += next;\n      }\n\n      push({ type: 'text', value });\n      continue;\n    }\n\n    /**\n     * Left curly brace: '{'\n     */\n\n    if (value === CHAR_LEFT_CURLY_BRACE) {\n      depth++;\n\n      let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;\n      let brace = {\n        type: 'brace',\n        open: true,\n        close: false,\n        dollar,\n        depth,\n        commas: 0,\n        ranges: 0,\n        nodes: []\n      };\n\n      block = push(brace);\n      stack.push(block);\n      push({ type: 'open', value });\n      continue;\n    }\n\n    /**\n     * Right curly brace: '}'\n     */\n\n    if (value === CHAR_RIGHT_CURLY_BRACE) {\n      if (block.type !== 'brace') {\n        push({ type: 'text', value });\n        continue;\n      }\n\n      let type = 'close';\n      block = stack.pop();\n      block.close = true;\n\n      push({ type, value });\n      depth--;\n\n      block = stack[stack.length - 1];\n      continue;\n    }\n\n    /**\n     * Comma: ','\n     */\n\n    if (value === CHAR_COMMA$1 && depth > 0) {\n      if (block.ranges > 0) {\n        block.ranges = 0;\n        let open = block.nodes.shift();\n        block.nodes = [open, { type: 'text', value: stringify$1(block) }];\n      }\n\n      push({ type: 'comma', value });\n      block.commas++;\n      continue;\n    }\n\n    /**\n     * Dot: '.'\n     */\n\n    if (value === CHAR_DOT && depth > 0 && block.commas === 0) {\n      let siblings = block.nodes;\n\n      if (depth === 0 || siblings.length === 0) {\n        push({ type: 'text', value });\n        continue;\n      }\n\n      if (prev.type === 'dot') {\n        block.range = [];\n        prev.value += value;\n        prev.type = 'range';\n\n        if (block.nodes.length !== 3 && block.nodes.length !== 5) {\n          block.invalid = true;\n          block.ranges = 0;\n          prev.type = 'text';\n          continue;\n        }\n\n        block.ranges++;\n        block.args = [];\n        continue;\n      }\n\n      if (prev.type === 'range') {\n        siblings.pop();\n\n        let before = siblings[siblings.length - 1];\n        before.value += prev.value + value;\n        prev = before;\n        block.ranges--;\n        continue;\n      }\n\n      push({ type: 'dot', value });\n      continue;\n    }\n\n    /**\n     * Text\n     */\n\n    push({ type: 'text', value });\n  }\n\n  // Mark imbalanced braces and brackets as invalid\n  do {\n    block = stack.pop();\n\n    if (block.type !== 'root') {\n      block.nodes.forEach(node => {\n        if (!node.nodes) {\n          if (node.type === 'open') node.isOpen = true;\n          if (node.type === 'close') node.isClose = true;\n          if (!node.nodes) node.type = 'text';\n          node.invalid = true;\n        }\n      });\n\n      // get the location of the block on parent.nodes (block's siblings)\n      let parent = stack[stack.length - 1];\n      let index = parent.nodes.indexOf(block);\n      // replace the (invalid) block with it's nodes\n      parent.nodes.splice(index, 1, ...block.nodes);\n    }\n  } while (stack.length > 0);\n\n  push({ type: 'eos' });\n  return ast;\n};\n\nvar parse_1$1 = parse$8;\n\n/**\n * Expand the given pattern or create a regex-compatible string.\n *\n * ```js\n * const braces = require('braces');\n * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']\n * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']\n * ```\n * @param {String} `str`\n * @param {Object} `options`\n * @return {String}\n * @api public\n */\n\nconst braces = (input, options = {}) => {\n  let output = [];\n\n  if (Array.isArray(input)) {\n    for (let pattern of input) {\n      let result = braces.create(pattern, options);\n      if (Array.isArray(result)) {\n        output.push(...result);\n      } else {\n        output.push(result);\n      }\n    }\n  } else {\n    output = [].concat(braces.create(input, options));\n  }\n\n  if (options && options.expand === true && options.nodupes === true) {\n    output = [...new Set(output)];\n  }\n  return output;\n};\n\n/**\n * Parse the given `str` with the given `options`.\n *\n * ```js\n * // braces.parse(pattern, [, options]);\n * const ast = braces.parse('a/{b,c}/d');\n * console.log(ast);\n * ```\n * @param {String} pattern Brace pattern to parse\n * @param {Object} options\n * @return {Object} Returns an AST\n * @api public\n */\n\nbraces.parse = (input, options = {}) => parse_1$1(input, options);\n\n/**\n * Creates a braces string from an AST, or an AST node.\n *\n * ```js\n * const braces = require('braces');\n * let ast = braces.parse('foo/{a,b}/bar');\n * console.log(stringify(ast.nodes[2])); //=> '{a,b}'\n * ```\n * @param {String} `input` Brace pattern or AST.\n * @param {Object} `options`\n * @return {Array} Returns an array of expanded values.\n * @api public\n */\n\nbraces.stringify = (input, options = {}) => {\n  if (typeof input === 'string') {\n    return stringify$1(braces.parse(input, options), options);\n  }\n  return stringify$1(input, options);\n};\n\n/**\n * Compiles a brace pattern into a regex-compatible, optimized string.\n * This method is called by the main [braces](#braces) function by default.\n *\n * ```js\n * const braces = require('braces');\n * console.log(braces.compile('a/{b,c}/d'));\n * //=> ['a/(b|c)/d']\n * ```\n * @param {String} `input` Brace pattern or AST.\n * @param {Object} `options`\n * @return {Array} Returns an array of expanded values.\n * @api public\n */\n\nbraces.compile = (input, options = {}) => {\n  if (typeof input === 'string') {\n    input = braces.parse(input, options);\n  }\n  return compile_1$1(input, options);\n};\n\n/**\n * Expands a brace pattern into an array. This method is called by the\n * main [braces](#braces) function when `options.expand` is true. Before\n * using this method it's recommended that you read the [performance notes](#performance))\n * and advantages of using [.compile](#compile) instead.\n *\n * ```js\n * const braces = require('braces');\n * console.log(braces.expand('a/{b,c}/d'));\n * //=> ['a/b/d', 'a/c/d'];\n * ```\n * @param {String} `pattern` Brace pattern\n * @param {Object} `options`\n * @return {Array} Returns an array of expanded values.\n * @api public\n */\n\nbraces.expand = (input, options = {}) => {\n  if (typeof input === 'string') {\n    input = braces.parse(input, options);\n  }\n\n  let result = expand_1(input, options);\n\n  // filter out empty strings if specified\n  if (options.noempty === true) {\n    result = result.filter(Boolean);\n  }\n\n  // filter out duplicates if specified\n  if (options.nodupes === true) {\n    result = [...new Set(result)];\n  }\n\n  return result;\n};\n\n/**\n * Processes a brace pattern and returns either an expanded array\n * (if `options.expand` is true), a highly optimized regex-compatible string.\n * This method is called by the main [braces](#braces) function.\n *\n * ```js\n * const braces = require('braces');\n * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))\n * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'\n * ```\n * @param {String} `pattern` Brace pattern\n * @param {Object} `options`\n * @return {Array} Returns an array of expanded values.\n * @api public\n */\n\nbraces.create = (input, options = {}) => {\n  if (input === '' || input.length < 3) {\n    return [input];\n  }\n\n return options.expand !== true\n    ? braces.compile(input, options)\n    : braces.expand(input, options);\n};\n\n/**\n * Expose \"braces\"\n */\n\nvar braces_1 = braces;\n\nconst WIN_SLASH = '\\\\\\\\/';\nconst WIN_NO_SLASH = `[^${WIN_SLASH}]`;\n\n/**\n * Posix glob regex\n */\n\nconst DOT_LITERAL = '\\\\.';\nconst PLUS_LITERAL = '\\\\+';\nconst QMARK_LITERAL = '\\\\?';\nconst SLASH_LITERAL = '\\\\/';\nconst ONE_CHAR = '(?=.)';\nconst QMARK = '[^/]';\nconst END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;\nconst START_ANCHOR = `(?:^|${SLASH_LITERAL})`;\nconst DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;\nconst NO_DOT = `(?!${DOT_LITERAL})`;\nconst NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;\nconst NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;\nconst NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;\nconst QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;\nconst STAR = `${QMARK}*?`;\n\nconst POSIX_CHARS = {\n  DOT_LITERAL,\n  PLUS_LITERAL,\n  QMARK_LITERAL,\n  SLASH_LITERAL,\n  ONE_CHAR,\n  QMARK,\n  END_ANCHOR,\n  DOTS_SLASH,\n  NO_DOT,\n  NO_DOTS,\n  NO_DOT_SLASH,\n  NO_DOTS_SLASH,\n  QMARK_NO_DOT,\n  STAR,\n  START_ANCHOR\n};\n\n/**\n * Windows glob regex\n */\n\nconst WINDOWS_CHARS = {\n  ...POSIX_CHARS,\n\n  SLASH_LITERAL: `[${WIN_SLASH}]`,\n  QMARK: WIN_NO_SLASH,\n  STAR: `${WIN_NO_SLASH}*?`,\n  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,\n  NO_DOT: `(?!${DOT_LITERAL})`,\n  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,\n  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,\n  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,\n  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,\n  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,\n  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`\n};\n\n/**\n * POSIX Bracket Regex\n */\n\nconst POSIX_REGEX_SOURCE = {\n  alnum: 'a-zA-Z0-9',\n  alpha: 'a-zA-Z',\n  ascii: '\\\\x00-\\\\x7F',\n  blank: ' \\\\t',\n  cntrl: '\\\\x00-\\\\x1F\\\\x7F',\n  digit: '0-9',\n  graph: '\\\\x21-\\\\x7E',\n  lower: 'a-z',\n  print: '\\\\x20-\\\\x7E ',\n  punct: '\\\\-!\"#$%&\\'()\\\\*+,./:;<=>?@[\\\\]^_`{|}~',\n  space: ' \\\\t\\\\r\\\\n\\\\v\\\\f',\n  upper: 'A-Z',\n  word: 'A-Za-z0-9_',\n  xdigit: 'A-Fa-f0-9'\n};\n\nvar constants$1 = {\n  MAX_LENGTH: 1024 * 64,\n  POSIX_REGEX_SOURCE,\n\n  // regular expressions\n  REGEX_BACKSLASH: /\\\\(?![*+?^${}(|)[\\]])/g,\n  REGEX_NON_SPECIAL_CHARS: /^[^@![\\].,$*+?^{}()|\\\\/]+/,\n  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\\]]/,\n  REGEX_SPECIAL_CHARS_BACKREF: /(\\\\?)((\\W)(\\3*))/g,\n  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\\]])/g,\n  REGEX_REMOVE_BACKSLASH: /(?:\\[.*?[^\\\\]\\]|\\\\(?=.))/g,\n\n  // Replace globs with equivalent patterns to reduce parsing time.\n  REPLACEMENTS: {\n    '***': '*',\n    '**/**': '**',\n    '**/**/**': '**'\n  },\n\n  // Digits\n  CHAR_0: 48, /* 0 */\n  CHAR_9: 57, /* 9 */\n\n  // Alphabet chars.\n  CHAR_UPPERCASE_A: 65, /* A */\n  CHAR_LOWERCASE_A: 97, /* a */\n  CHAR_UPPERCASE_Z: 90, /* Z */\n  CHAR_LOWERCASE_Z: 122, /* z */\n\n  CHAR_LEFT_PARENTHESES: 40, /* ( */\n  CHAR_RIGHT_PARENTHESES: 41, /* ) */\n\n  CHAR_ASTERISK: 42, /* * */\n\n  // Non-alphabetic chars.\n  CHAR_AMPERSAND: 38, /* & */\n  CHAR_AT: 64, /* @ */\n  CHAR_BACKWARD_SLASH: 92, /* \\ */\n  CHAR_CARRIAGE_RETURN: 13, /* \\r */\n  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */\n  CHAR_COLON: 58, /* : */\n  CHAR_COMMA: 44, /* , */\n  CHAR_DOT: 46, /* . */\n  CHAR_DOUBLE_QUOTE: 34, /* \" */\n  CHAR_EQUAL: 61, /* = */\n  CHAR_EXCLAMATION_MARK: 33, /* ! */\n  CHAR_FORM_FEED: 12, /* \\f */\n  CHAR_FORWARD_SLASH: 47, /* / */\n  CHAR_GRAVE_ACCENT: 96, /* ` */\n  CHAR_HASH: 35, /* # */\n  CHAR_HYPHEN_MINUS: 45, /* - */\n  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */\n  CHAR_LEFT_CURLY_BRACE: 123, /* { */\n  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */\n  CHAR_LINE_FEED: 10, /* \\n */\n  CHAR_NO_BREAK_SPACE: 160, /* \\u00A0 */\n  CHAR_PERCENT: 37, /* % */\n  CHAR_PLUS: 43, /* + */\n  CHAR_QUESTION_MARK: 63, /* ? */\n  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */\n  CHAR_RIGHT_CURLY_BRACE: 125, /* } */\n  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */\n  CHAR_SEMICOLON: 59, /* ; */\n  CHAR_SINGLE_QUOTE: 39, /* ' */\n  CHAR_SPACE: 32, /*   */\n  CHAR_TAB: 9, /* \\t */\n  CHAR_UNDERSCORE: 95, /* _ */\n  CHAR_VERTICAL_LINE: 124, /* | */\n  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \\uFEFF */\n\n  SEP: path$1.sep,\n\n  /**\n   * Create EXTGLOB_CHARS\n   */\n\n  extglobChars(chars) {\n    return {\n      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },\n      '?': { type: 'qmark', open: '(?:', close: ')?' },\n      '+': { type: 'plus', open: '(?:', close: ')+' },\n      '*': { type: 'star', open: '(?:', close: ')*' },\n      '@': { type: 'at', open: '(?:', close: ')' }\n    };\n  },\n\n  /**\n   * Create GLOB_CHARS\n   */\n\n  globChars(win32) {\n    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;\n  }\n};\n\nvar utils$4 = createCommonjsModule(function (module, exports) {\n\n\nconst win32 = process.platform === 'win32';\nconst {\n  REGEX_BACKSLASH,\n  REGEX_REMOVE_BACKSLASH,\n  REGEX_SPECIAL_CHARS,\n  REGEX_SPECIAL_CHARS_GLOBAL\n} = constants$1;\n\nexports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);\nexports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);\nexports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);\nexports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\\\$1');\nexports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');\n\nexports.removeBackslashes = str => {\n  return str.replace(REGEX_REMOVE_BACKSLASH, match => {\n    return match === '\\\\' ? '' : match;\n  });\n};\n\nexports.supportsLookbehinds = () => {\n  const segs = process.version.slice(1).split('.').map(Number);\n  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {\n    return true;\n  }\n  return false;\n};\n\nexports.isWindows = options => {\n  if (options && typeof options.windows === 'boolean') {\n    return options.windows;\n  }\n  return win32 === true || path$1.sep === '\\\\';\n};\n\nexports.escapeLast = (input, char, lastIdx) => {\n  const idx = input.lastIndexOf(char, lastIdx);\n  if (idx === -1) return input;\n  if (input[idx - 1] === '\\\\') return exports.escapeLast(input, char, idx - 1);\n  return `${input.slice(0, idx)}\\\\${input.slice(idx)}`;\n};\n\nexports.removePrefix = (input, state = {}) => {\n  let output = input;\n  if (output.startsWith('./')) {\n    output = output.slice(2);\n    state.prefix = './';\n  }\n  return output;\n};\n\nexports.wrapOutput = (input, state = {}, options = {}) => {\n  const prepend = options.contains ? '' : '^';\n  const append = options.contains ? '' : '$';\n\n  let output = `${prepend}(?:${input})${append}`;\n  if (state.negated === true) {\n    output = `(?:^(?!${output}).*$)`;\n  }\n  return output;\n};\n});\nvar utils_1$2 = utils$4.isObject;\nvar utils_2$2 = utils$4.hasRegexChars;\nvar utils_3$2 = utils$4.isRegexChar;\nvar utils_4$1 = utils$4.escapeRegex;\nvar utils_5$1 = utils$4.toPosixSlashes;\nvar utils_6$1 = utils$4.removeBackslashes;\nvar utils_7$1 = utils$4.supportsLookbehinds;\nvar utils_8$1 = utils$4.isWindows;\nvar utils_9$1 = utils$4.escapeLast;\nvar utils_10 = utils$4.removePrefix;\nvar utils_11 = utils$4.wrapOutput;\n\nconst {\n  CHAR_ASTERISK: CHAR_ASTERISK$1,             /* * */\n  CHAR_AT,                   /* @ */\n  CHAR_BACKWARD_SLASH,       /* \\ */\n  CHAR_COMMA: CHAR_COMMA$2,                /* , */\n  CHAR_DOT: CHAR_DOT$1,                  /* . */\n  CHAR_EXCLAMATION_MARK,     /* ! */\n  CHAR_FORWARD_SLASH,        /* / */\n  CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1,     /* { */\n  CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1,     /* ( */\n  CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$2,  /* [ */\n  CHAR_PLUS,                 /* + */\n  CHAR_QUESTION_MARK,        /* ? */\n  CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1,    /* } */\n  CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1,    /* ) */\n  CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$2  /* ] */\n} = constants$1;\n\nconst isPathSeparator = code => {\n  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;\n};\n\nconst depth = token => {\n  if (token.isPrefix !== true) {\n    token.depth = token.isGlobstar ? Infinity : 1;\n  }\n};\n\n/**\n * Quickly scans a glob pattern and returns an object with a handful of\n * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),\n * `glob` (the actual pattern), and `negated` (true if the path starts with `!`).\n *\n * ```js\n * const pm = require('picomatch');\n * console.log(pm.scan('foo/bar/*.js'));\n * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }\n * ```\n * @param {String} `str`\n * @param {Object} `options`\n * @return {Object} Returns an object with tokens and regex source string.\n * @api public\n */\n\nconst scan$2 = (input, options) => {\n  const opts = options || {};\n\n  const length = input.length - 1;\n  const scanToEnd = opts.parts === true || opts.scanToEnd === true;\n  const slashes = [];\n  const tokens = [];\n  const parts = [];\n\n  let str = input;\n  let index = -1;\n  let start = 0;\n  let lastIndex = 0;\n  let isBrace = false;\n  let isBracket = false;\n  let isGlob = false;\n  let isExtglob = false;\n  let isGlobstar = false;\n  let braceEscaped = false;\n  let backslashes = false;\n  let negated = false;\n  let finished = false;\n  let braces = 0;\n  let prev;\n  let code;\n  let token = { value: '', depth: 0, isGlob: false };\n\n  const eos = () => index >= length;\n  const peek = () => str.charCodeAt(index + 1);\n  const advance = () => {\n    prev = code;\n    return str.charCodeAt(++index);\n  };\n\n  while (index < length) {\n    code = advance();\n    let next;\n\n    if (code === CHAR_BACKWARD_SLASH) {\n      backslashes = token.backslashes = true;\n      code = advance();\n\n      if (code === CHAR_LEFT_CURLY_BRACE$1) {\n        braceEscaped = true;\n      }\n      continue;\n    }\n\n    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE$1) {\n      braces++;\n\n      while (eos() !== true && (code = advance())) {\n        if (code === CHAR_BACKWARD_SLASH) {\n          backslashes = token.backslashes = true;\n          advance();\n          continue;\n        }\n\n        if (code === CHAR_LEFT_CURLY_BRACE$1) {\n          braces++;\n          continue;\n        }\n\n        if (braceEscaped !== true && code === CHAR_DOT$1 && (code = advance()) === CHAR_DOT$1) {\n          isBrace = token.isBrace = true;\n          isGlob = token.isGlob = true;\n          finished = true;\n\n          if (scanToEnd === true) {\n            continue;\n          }\n\n          break;\n        }\n\n        if (braceEscaped !== true && code === CHAR_COMMA$2) {\n          isBrace = token.isBrace = true;\n          isGlob = token.isGlob = true;\n          finished = true;\n\n          if (scanToEnd === true) {\n            continue;\n          }\n\n          break;\n        }\n\n        if (code === CHAR_RIGHT_CURLY_BRACE$1) {\n          braces--;\n\n          if (braces === 0) {\n            braceEscaped = false;\n            isBrace = token.isBrace = true;\n            finished = true;\n            break;\n          }\n        }\n      }\n\n      if (scanToEnd === true) {\n        continue;\n      }\n\n      break;\n    }\n\n    if (code === CHAR_FORWARD_SLASH) {\n      slashes.push(index);\n      tokens.push(token);\n      token = { value: '', depth: 0, isGlob: false };\n\n      if (finished === true) continue;\n      if (prev === CHAR_DOT$1 && index === (start + 1)) {\n        start += 2;\n        continue;\n      }\n\n      lastIndex = index + 1;\n      continue;\n    }\n\n    if (opts.noext !== true) {\n      const isExtglobChar = code === CHAR_PLUS\n        || code === CHAR_AT\n        || code === CHAR_ASTERISK$1\n        || code === CHAR_QUESTION_MARK\n        || code === CHAR_EXCLAMATION_MARK;\n\n      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES$1) {\n        isGlob = token.isGlob = true;\n        isExtglob = token.isExtglob = true;\n        finished = true;\n\n        if (scanToEnd === true) {\n          while (eos() !== true && (code = advance())) {\n            if (code === CHAR_BACKWARD_SLASH) {\n              backslashes = token.backslashes = true;\n              code = advance();\n              continue;\n            }\n\n            if (code === CHAR_RIGHT_PARENTHESES$1) {\n              isGlob = token.isGlob = true;\n              finished = true;\n              break;\n            }\n          }\n          continue;\n        }\n        break;\n      }\n    }\n\n    if (code === CHAR_ASTERISK$1) {\n      if (prev === CHAR_ASTERISK$1) isGlobstar = token.isGlobstar = true;\n      isGlob = token.isGlob = true;\n      finished = true;\n\n      if (scanToEnd === true) {\n        continue;\n      }\n      break;\n    }\n\n    if (code === CHAR_QUESTION_MARK) {\n      isGlob = token.isGlob = true;\n      finished = true;\n\n      if (scanToEnd === true) {\n        continue;\n      }\n      break;\n    }\n\n    if (code === CHAR_LEFT_SQUARE_BRACKET$2) {\n      while (eos() !== true && (next = advance())) {\n        if (next === CHAR_BACKWARD_SLASH) {\n          backslashes = token.backslashes = true;\n          advance();\n          continue;\n        }\n\n        if (next === CHAR_RIGHT_SQUARE_BRACKET$2) {\n          isBracket = token.isBracket = true;\n          isGlob = token.isGlob = true;\n          finished = true;\n\n          if (scanToEnd === true) {\n            continue;\n          }\n          break;\n        }\n      }\n    }\n\n    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {\n      negated = token.negated = true;\n      start++;\n      continue;\n    }\n\n    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES$1) {\n      isGlob = token.isGlob = true;\n\n      if (scanToEnd === true) {\n        while (eos() !== true && (code = advance())) {\n          if (code === CHAR_LEFT_PARENTHESES$1) {\n            backslashes = token.backslashes = true;\n            code = advance();\n            continue;\n          }\n\n          if (code === CHAR_RIGHT_PARENTHESES$1) {\n            finished = true;\n            break;\n          }\n        }\n        continue;\n      }\n      break;\n    }\n\n    if (isGlob === true) {\n      finished = true;\n\n      if (scanToEnd === true) {\n        continue;\n      }\n\n      break;\n    }\n  }\n\n  if (opts.noext === true) {\n    isExtglob = false;\n    isGlob = false;\n  }\n\n  let base = str;\n  let prefix = '';\n  let glob = '';\n\n  if (start > 0) {\n    prefix = str.slice(0, start);\n    str = str.slice(start);\n    lastIndex -= start;\n  }\n\n  if (base && isGlob === true && lastIndex > 0) {\n    base = str.slice(0, lastIndex);\n    glob = str.slice(lastIndex);\n  } else if (isGlob === true) {\n    base = '';\n    glob = str;\n  } else {\n    base = str;\n  }\n\n  if (base && base !== '' && base !== '/' && base !== str) {\n    if (isPathSeparator(base.charCodeAt(base.length - 1))) {\n      base = base.slice(0, -1);\n    }\n  }\n\n  if (opts.unescape === true) {\n    if (glob) glob = utils$4.removeBackslashes(glob);\n\n    if (base && backslashes === true) {\n      base = utils$4.removeBackslashes(base);\n    }\n  }\n\n  const state = {\n    prefix,\n    input,\n    start,\n    base,\n    glob,\n    isBrace,\n    isBracket,\n    isGlob,\n    isExtglob,\n    isGlobstar,\n    negated\n  };\n\n  if (opts.tokens === true) {\n    state.maxDepth = 0;\n    if (!isPathSeparator(code)) {\n      tokens.push(token);\n    }\n    state.tokens = tokens;\n  }\n\n  if (opts.parts === true || opts.tokens === true) {\n    let prevIndex;\n\n    for (let idx = 0; idx < slashes.length; idx++) {\n      const n = prevIndex ? prevIndex + 1 : start;\n      const i = slashes[idx];\n      const value = input.slice(n, i);\n      if (opts.tokens) {\n        if (idx === 0 && start !== 0) {\n          tokens[idx].isPrefix = true;\n          tokens[idx].value = prefix;\n        } else {\n          tokens[idx].value = value;\n        }\n        depth(tokens[idx]);\n        state.maxDepth += tokens[idx].depth;\n      }\n      if (idx !== 0 || value !== '') {\n        parts.push(value);\n      }\n      prevIndex = i;\n    }\n\n    if (prevIndex && prevIndex + 1 < input.length) {\n      const value = input.slice(prevIndex + 1);\n      parts.push(value);\n\n      if (opts.tokens) {\n        tokens[tokens.length - 1].value = value;\n        depth(tokens[tokens.length - 1]);\n        state.maxDepth += tokens[tokens.length - 1].depth;\n      }\n    }\n\n    state.slashes = slashes;\n    state.parts = parts;\n  }\n\n  return state;\n};\n\nvar scan_1 = scan$2;\n\n/**\n * Constants\n */\n\nconst {\n  MAX_LENGTH: MAX_LENGTH$1,\n  POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,\n  REGEX_NON_SPECIAL_CHARS,\n  REGEX_SPECIAL_CHARS_BACKREF,\n  REPLACEMENTS\n} = constants$1;\n\n/**\n * Helpers\n */\n\nconst expandRange = (args, options) => {\n  if (typeof options.expandRange === 'function') {\n    return options.expandRange(...args, options);\n  }\n\n  args.sort();\n  const value = `[${args.join('-')}]`;\n\n  try {\n    /* eslint-disable-next-line no-new */\n    new RegExp(value);\n  } catch (ex) {\n    return args.map(v => utils$4.escapeRegex(v)).join('..');\n  }\n\n  return value;\n};\n\n/**\n * Create the message for a syntax error\n */\n\nconst syntaxError = (type, char) => {\n  return `Missing ${type}: \"${char}\" - use \"\\\\\\\\${char}\" to match literal characters`;\n};\n\n/**\n * Parse the given input string.\n * @param {String} input\n * @param {Object} options\n * @return {Object}\n */\n\nconst parse$9 = (input, options) => {\n  if (typeof input !== 'string') {\n    throw new TypeError('Expected a string');\n  }\n\n  input = REPLACEMENTS[input] || input;\n\n  const opts = { ...options };\n  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;\n\n  let len = input.length;\n  if (len > max) {\n    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);\n  }\n\n  const bos = { type: 'bos', value: '', output: opts.prepend || '' };\n  const tokens = [bos];\n\n  const capture = opts.capture ? '' : '?:';\n  const win32 = utils$4.isWindows(options);\n\n  // create constants based on platform, for windows or posix\n  const PLATFORM_CHARS = constants$1.globChars(win32);\n  const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);\n\n  const {\n    DOT_LITERAL,\n    PLUS_LITERAL,\n    SLASH_LITERAL,\n    ONE_CHAR,\n    DOTS_SLASH,\n    NO_DOT,\n    NO_DOT_SLASH,\n    NO_DOTS_SLASH,\n    QMARK,\n    QMARK_NO_DOT,\n    STAR,\n    START_ANCHOR\n  } = PLATFORM_CHARS;\n\n  const globstar = (opts) => {\n    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;\n  };\n\n  const nodot = opts.dot ? '' : NO_DOT;\n  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;\n  let star = opts.bash === true ? globstar(opts) : STAR;\n\n  if (opts.capture) {\n    star = `(${star})`;\n  }\n\n  // minimatch options support\n  if (typeof opts.noext === 'boolean') {\n    opts.noextglob = opts.noext;\n  }\n\n  const state = {\n    input,\n    index: -1,\n    start: 0,\n    dot: opts.dot === true,\n    consumed: '',\n    output: '',\n    prefix: '',\n    backtrack: false,\n    negated: false,\n    brackets: 0,\n    braces: 0,\n    parens: 0,\n    quotes: 0,\n    globstar: false,\n    tokens\n  };\n\n  input = utils$4.removePrefix(input, state);\n  len = input.length;\n\n  const extglobs = [];\n  const braces = [];\n  const stack = [];\n  let prev = bos;\n  let value;\n\n  /**\n   * Tokenizing helpers\n   */\n\n  const eos = () => state.index === len - 1;\n  const peek = state.peek = (n = 1) => input[state.index + n];\n  const advance = state.advance = () => input[++state.index];\n  const remaining = () => input.slice(state.index + 1);\n  const consume = (value = '', num = 0) => {\n    state.consumed += value;\n    state.index += num;\n  };\n  const append = token => {\n    state.output += token.output != null ? token.output : token.value;\n    consume(token.value);\n  };\n\n  const negate = () => {\n    let count = 1;\n\n    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {\n      advance();\n      state.start++;\n      count++;\n    }\n\n    if (count % 2 === 0) {\n      return false;\n    }\n\n    state.negated = true;\n    state.start++;\n    return true;\n  };\n\n  const increment = type => {\n    state[type]++;\n    stack.push(type);\n  };\n\n  const decrement = type => {\n    state[type]--;\n    stack.pop();\n  };\n\n  /**\n   * Push tokens onto the tokens array. This helper speeds up\n   * tokenizing by 1) helping us avoid backtracking as much as possible,\n   * and 2) helping us avoid creating extra tokens when consecutive\n   * characters are plain text. This improves performance and simplifies\n   * lookbehinds.\n   */\n\n  const push = tok => {\n    if (prev.type === 'globstar') {\n      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');\n      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));\n\n      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {\n        state.output = state.output.slice(0, -prev.output.length);\n        prev.type = 'star';\n        prev.value = '*';\n        prev.output = star;\n        state.output += prev.output;\n      }\n    }\n\n    if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) {\n      extglobs[extglobs.length - 1].inner += tok.value;\n    }\n\n    if (tok.value || tok.output) append(tok);\n    if (prev && prev.type === 'text' && tok.type === 'text') {\n      prev.value += tok.value;\n      prev.output = (prev.output || '') + tok.value;\n      return;\n    }\n\n    tok.prev = prev;\n    tokens.push(tok);\n    prev = tok;\n  };\n\n  const extglobOpen = (type, value) => {\n    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };\n\n    token.prev = prev;\n    token.parens = state.parens;\n    token.output = state.output;\n    const output = (opts.capture ? '(' : '') + token.open;\n\n    increment('parens');\n    push({ type, value, output: state.output ? '' : ONE_CHAR });\n    push({ type: 'paren', extglob: true, value: advance(), output });\n    extglobs.push(token);\n  };\n\n  const extglobClose = token => {\n    let output = token.close + (opts.capture ? ')' : '');\n\n    if (token.type === 'negate') {\n      let extglobStar = star;\n\n      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {\n        extglobStar = globstar(opts);\n      }\n\n      if (extglobStar !== star || eos() || /^\\)+$/.test(remaining())) {\n        output = token.close = `)$))${extglobStar}`;\n      }\n\n      if (token.prev.type === 'bos' && eos()) {\n        state.negatedExtglob = true;\n      }\n    }\n\n    push({ type: 'paren', extglob: true, value, output });\n    decrement('parens');\n  };\n\n  /**\n   * Fast paths\n   */\n\n  if (opts.fastpaths !== false && !/(^[*!]|[/()[\\]{}\"])/.test(input)) {\n    let backslashes = false;\n\n    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {\n      if (first === '\\\\') {\n        backslashes = true;\n        return m;\n      }\n\n      if (first === '?') {\n        if (esc) {\n          return esc + first + (rest ? QMARK.repeat(rest.length) : '');\n        }\n        if (index === 0) {\n          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');\n        }\n        return QMARK.repeat(chars.length);\n      }\n\n      if (first === '.') {\n        return DOT_LITERAL.repeat(chars.length);\n      }\n\n      if (first === '*') {\n        if (esc) {\n          return esc + first + (rest ? star : '');\n        }\n        return star;\n      }\n      return esc ? m : `\\\\${m}`;\n    });\n\n    if (backslashes === true) {\n      if (opts.unescape === true) {\n        output = output.replace(/\\\\/g, '');\n      } else {\n        output = output.replace(/\\\\+/g, m => {\n          return m.length % 2 === 0 ? '\\\\\\\\' : (m ? '\\\\' : '');\n        });\n      }\n    }\n\n    if (output === input && opts.contains === true) {\n      state.output = input;\n      return state;\n    }\n\n    state.output = utils$4.wrapOutput(output, state, options);\n    return state;\n  }\n\n  /**\n   * Tokenize input until we reach end-of-string\n   */\n\n  while (!eos()) {\n    value = advance();\n\n    if (value === '\\u0000') {\n      continue;\n    }\n\n    /**\n     * Escaped characters\n     */\n\n    if (value === '\\\\') {\n      const next = peek();\n\n      if (next === '/' && opts.bash !== true) {\n        continue;\n      }\n\n      if (next === '.' || next === ';') {\n        continue;\n      }\n\n      if (!next) {\n        value += '\\\\';\n        push({ type: 'text', value });\n        continue;\n      }\n\n      // collapse slashes to reduce potential for exploits\n      const match = /^\\\\+/.exec(remaining());\n      let slashes = 0;\n\n      if (match && match[0].length > 2) {\n        slashes = match[0].length;\n        state.index += slashes;\n        if (slashes % 2 !== 0) {\n          value += '\\\\';\n        }\n      }\n\n      if (opts.unescape === true) {\n        value = advance() || '';\n      } else {\n        value += advance() || '';\n      }\n\n      if (state.brackets === 0) {\n        push({ type: 'text', value });\n        continue;\n      }\n    }\n\n    /**\n     * If we're inside a regex character class, continue\n     * until we reach the closing bracket.\n     */\n\n    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {\n      if (opts.posix !== false && value === ':') {\n        const inner = prev.value.slice(1);\n        if (inner.includes('[')) {\n          prev.posix = true;\n\n          if (inner.includes(':')) {\n            const idx = prev.value.lastIndexOf('[');\n            const pre = prev.value.slice(0, idx);\n            const rest = prev.value.slice(idx + 2);\n            const posix = POSIX_REGEX_SOURCE$1[rest];\n            if (posix) {\n              prev.value = pre + posix;\n              state.backtrack = true;\n              advance();\n\n              if (!bos.output && tokens.indexOf(prev) === 1) {\n                bos.output = ONE_CHAR;\n              }\n              continue;\n            }\n          }\n        }\n      }\n\n      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {\n        value = `\\\\${value}`;\n      }\n\n      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {\n        value = `\\\\${value}`;\n      }\n\n      if (opts.posix === true && value === '!' && prev.value === '[') {\n        value = '^';\n      }\n\n      prev.value += value;\n      append({ value });\n      continue;\n    }\n\n    /**\n     * If we're inside a quoted string, continue\n     * until we reach the closing double quote.\n     */\n\n    if (state.quotes === 1 && value !== '\"') {\n      value = utils$4.escapeRegex(value);\n      prev.value += value;\n      append({ value });\n      continue;\n    }\n\n    /**\n     * Double quotes\n     */\n\n    if (value === '\"') {\n      state.quotes = state.quotes === 1 ? 0 : 1;\n      if (opts.keepQuotes === true) {\n        push({ type: 'text', value });\n      }\n      continue;\n    }\n\n    /**\n     * Parentheses\n     */\n\n    if (value === '(') {\n      increment('parens');\n      push({ type: 'paren', value });\n      continue;\n    }\n\n    if (value === ')') {\n      if (state.parens === 0 && opts.strictBrackets === true) {\n        throw new SyntaxError(syntaxError('opening', '('));\n      }\n\n      const extglob = extglobs[extglobs.length - 1];\n      if (extglob && state.parens === extglob.parens + 1) {\n        extglobClose(extglobs.pop());\n        continue;\n      }\n\n      push({ type: 'paren', value, output: state.parens ? ')' : '\\\\)' });\n      decrement('parens');\n      continue;\n    }\n\n    /**\n     * Square brackets\n     */\n\n    if (value === '[') {\n      if (opts.nobracket === true || !remaining().includes(']')) {\n        if (opts.nobracket !== true && opts.strictBrackets === true) {\n          throw new SyntaxError(syntaxError('closing', ']'));\n        }\n\n        value = `\\\\${value}`;\n      } else {\n        increment('brackets');\n      }\n\n      push({ type: 'bracket', value });\n      continue;\n    }\n\n    if (value === ']') {\n      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {\n        push({ type: 'text', value, output: `\\\\${value}` });\n        continue;\n      }\n\n      if (state.brackets === 0) {\n        if (opts.strictBrackets === true) {\n          throw new SyntaxError(syntaxError('opening', '['));\n        }\n\n        push({ type: 'text', value, output: `\\\\${value}` });\n        continue;\n      }\n\n      decrement('brackets');\n\n      const prevValue = prev.value.slice(1);\n      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {\n        value = `/${value}`;\n      }\n\n      prev.value += value;\n      append({ value });\n\n      // when literal brackets are explicitly disabled\n      // assume we should match with a regex character class\n      if (opts.literalBrackets === false || utils$4.hasRegexChars(prevValue)) {\n        continue;\n      }\n\n      const escaped = utils$4.escapeRegex(prev.value);\n      state.output = state.output.slice(0, -prev.value.length);\n\n      // when literal brackets are explicitly enabled\n      // assume we should escape the brackets to match literal characters\n      if (opts.literalBrackets === true) {\n        state.output += escaped;\n        prev.value = escaped;\n        continue;\n      }\n\n      // when the user specifies nothing, try to match both\n      prev.value = `(${capture}${escaped}|${prev.value})`;\n      state.output += prev.value;\n      continue;\n    }\n\n    /**\n     * Braces\n     */\n\n    if (value === '{' && opts.nobrace !== true) {\n      increment('braces');\n\n      const open = {\n        type: 'brace',\n        value,\n        output: '(',\n        outputIndex: state.output.length,\n        tokensIndex: state.tokens.length\n      };\n\n      braces.push(open);\n      push(open);\n      continue;\n    }\n\n    if (value === '}') {\n      const brace = braces[braces.length - 1];\n\n      if (opts.nobrace === true || !brace) {\n        push({ type: 'text', value, output: value });\n        continue;\n      }\n\n      let output = ')';\n\n      if (brace.dots === true) {\n        const arr = tokens.slice();\n        const range = [];\n\n        for (let i = arr.length - 1; i >= 0; i--) {\n          tokens.pop();\n          if (arr[i].type === 'brace') {\n            break;\n          }\n          if (arr[i].type !== 'dots') {\n            range.unshift(arr[i].value);\n          }\n        }\n\n        output = expandRange(range, opts);\n        state.backtrack = true;\n      }\n\n      if (brace.comma !== true && brace.dots !== true) {\n        const out = state.output.slice(0, brace.outputIndex);\n        const toks = state.tokens.slice(brace.tokensIndex);\n        brace.value = brace.output = '\\\\{';\n        value = output = '\\\\}';\n        state.output = out;\n        for (const t of toks) {\n          state.output += (t.output || t.value);\n        }\n      }\n\n      push({ type: 'brace', value, output });\n      decrement('braces');\n      braces.pop();\n      continue;\n    }\n\n    /**\n     * Pipes\n     */\n\n    if (value === '|') {\n      if (extglobs.length > 0) {\n        extglobs[extglobs.length - 1].conditions++;\n      }\n      push({ type: 'text', value });\n      continue;\n    }\n\n    /**\n     * Commas\n     */\n\n    if (value === ',') {\n      let output = value;\n\n      const brace = braces[braces.length - 1];\n      if (brace && stack[stack.length - 1] === 'braces') {\n        brace.comma = true;\n        output = '|';\n      }\n\n      push({ type: 'comma', value, output });\n      continue;\n    }\n\n    /**\n     * Slashes\n     */\n\n    if (value === '/') {\n      // if the beginning of the glob is \"./\", advance the start\n      // to the current index, and don't add the \"./\" characters\n      // to the state. This greatly simplifies lookbehinds when\n      // checking for BOS characters like \"!\" and \".\" (not \"./\")\n      if (prev.type === 'dot' && state.index === state.start + 1) {\n        state.start = state.index + 1;\n        state.consumed = '';\n        state.output = '';\n        tokens.pop();\n        prev = bos; // reset \"prev\" to the first token\n        continue;\n      }\n\n      push({ type: 'slash', value, output: SLASH_LITERAL });\n      continue;\n    }\n\n    /**\n     * Dots\n     */\n\n    if (value === '.') {\n      if (state.braces > 0 && prev.type === 'dot') {\n        if (prev.value === '.') prev.output = DOT_LITERAL;\n        const brace = braces[braces.length - 1];\n        prev.type = 'dots';\n        prev.output += value;\n        prev.value += value;\n        brace.dots = true;\n        continue;\n      }\n\n      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {\n        push({ type: 'text', value, output: DOT_LITERAL });\n        continue;\n      }\n\n      push({ type: 'dot', value, output: DOT_LITERAL });\n      continue;\n    }\n\n    /**\n     * Question marks\n     */\n\n    if (value === '?') {\n      const isGroup = prev && prev.value === '(';\n      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {\n        extglobOpen('qmark', value);\n        continue;\n      }\n\n      if (prev && prev.type === 'paren') {\n        const next = peek();\n        let output = value;\n\n        if (next === '<' && !utils$4.supportsLookbehinds()) {\n          throw new Error('Node.js v10 or higher is required for regex lookbehinds');\n        }\n\n        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\\w+>)/.test(remaining()))) {\n          output = `\\\\${value}`;\n        }\n\n        push({ type: 'text', value, output });\n        continue;\n      }\n\n      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {\n        push({ type: 'qmark', value, output: QMARK_NO_DOT });\n        continue;\n      }\n\n      push({ type: 'qmark', value, output: QMARK });\n      continue;\n    }\n\n    /**\n     * Exclamation\n     */\n\n    if (value === '!') {\n      if (opts.noextglob !== true && peek() === '(') {\n        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {\n          extglobOpen('negate', value);\n          continue;\n        }\n      }\n\n      if (opts.nonegate !== true && state.index === 0) {\n        negate();\n        continue;\n      }\n    }\n\n    /**\n     * Plus\n     */\n\n    if (value === '+') {\n      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {\n        extglobOpen('plus', value);\n        continue;\n      }\n\n      if ((prev && prev.value === '(') || opts.regex === false) {\n        push({ type: 'plus', value, output: PLUS_LITERAL });\n        continue;\n      }\n\n      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {\n        push({ type: 'plus', value });\n        continue;\n      }\n\n      push({ type: 'plus', value: PLUS_LITERAL });\n      continue;\n    }\n\n    /**\n     * Plain text\n     */\n\n    if (value === '@') {\n      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {\n        push({ type: 'at', extglob: true, value, output: '' });\n        continue;\n      }\n\n      push({ type: 'text', value });\n      continue;\n    }\n\n    /**\n     * Plain text\n     */\n\n    if (value !== '*') {\n      if (value === '$' || value === '^') {\n        value = `\\\\${value}`;\n      }\n\n      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());\n      if (match) {\n        value += match[0];\n        state.index += match[0].length;\n      }\n\n      push({ type: 'text', value });\n      continue;\n    }\n\n    /**\n     * Stars\n     */\n\n    if (prev && (prev.type === 'globstar' || prev.star === true)) {\n      prev.type = 'star';\n      prev.star = true;\n      prev.value += value;\n      prev.output = star;\n      state.backtrack = true;\n      state.globstar = true;\n      consume(value);\n      continue;\n    }\n\n    let rest = remaining();\n    if (opts.noextglob !== true && /^\\([^?]/.test(rest)) {\n      extglobOpen('star', value);\n      continue;\n    }\n\n    if (prev.type === 'star') {\n      if (opts.noglobstar === true) {\n        consume(value);\n        continue;\n      }\n\n      const prior = prev.prev;\n      const before = prior.prev;\n      const isStart = prior.type === 'slash' || prior.type === 'bos';\n      const afterStar = before && (before.type === 'star' || before.type === 'globstar');\n\n      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {\n        push({ type: 'star', value, output: '' });\n        continue;\n      }\n\n      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');\n      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');\n      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {\n        push({ type: 'star', value, output: '' });\n        continue;\n      }\n\n      // strip consecutive `/**/`\n      while (rest.slice(0, 3) === '/**') {\n        const after = input[state.index + 4];\n        if (after && after !== '/') {\n          break;\n        }\n        rest = rest.slice(3);\n        consume('/**', 3);\n      }\n\n      if (prior.type === 'bos' && eos()) {\n        prev.type = 'globstar';\n        prev.value += value;\n        prev.output = globstar(opts);\n        state.output = prev.output;\n        state.globstar = true;\n        consume(value);\n        continue;\n      }\n\n      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {\n        state.output = state.output.slice(0, -(prior.output + prev.output).length);\n        prior.output = `(?:${prior.output}`;\n\n        prev.type = 'globstar';\n        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');\n        prev.value += value;\n        state.globstar = true;\n        state.output += prior.output + prev.output;\n        consume(value);\n        continue;\n      }\n\n      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {\n        const end = rest[1] !== void 0 ? '|$' : '';\n\n        state.output = state.output.slice(0, -(prior.output + prev.output).length);\n        prior.output = `(?:${prior.output}`;\n\n        prev.type = 'globstar';\n        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;\n        prev.value += value;\n\n        state.output += prior.output + prev.output;\n        state.globstar = true;\n\n        consume(value + advance());\n\n        push({ type: 'slash', value: '/', output: '' });\n        continue;\n      }\n\n      if (prior.type === 'bos' && rest[0] === '/') {\n        prev.type = 'globstar';\n        prev.value += value;\n        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;\n        state.output = prev.output;\n        state.globstar = true;\n        consume(value + advance());\n        push({ type: 'slash', value: '/', output: '' });\n        continue;\n      }\n\n      // remove single star from output\n      state.output = state.output.slice(0, -prev.output.length);\n\n      // reset previous token to globstar\n      prev.type = 'globstar';\n      prev.output = globstar(opts);\n      prev.value += value;\n\n      // reset output with globstar\n      state.output += prev.output;\n      state.globstar = true;\n      consume(value);\n      continue;\n    }\n\n    const token = { type: 'star', value, output: star };\n\n    if (opts.bash === true) {\n      token.output = '.*?';\n      if (prev.type === 'bos' || prev.type === 'slash') {\n        token.output = nodot + token.output;\n      }\n      push(token);\n      continue;\n    }\n\n    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {\n      token.output = value;\n      push(token);\n      continue;\n    }\n\n    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {\n      if (prev.type === 'dot') {\n        state.output += NO_DOT_SLASH;\n        prev.output += NO_DOT_SLASH;\n\n      } else if (opts.dot === true) {\n        state.output += NO_DOTS_SLASH;\n        prev.output += NO_DOTS_SLASH;\n\n      } else {\n        state.output += nodot;\n        prev.output += nodot;\n      }\n\n      if (peek() !== '*') {\n        state.output += ONE_CHAR;\n        prev.output += ONE_CHAR;\n      }\n    }\n\n    push(token);\n  }\n\n  while (state.brackets > 0) {\n    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));\n    state.output = utils$4.escapeLast(state.output, '[');\n    decrement('brackets');\n  }\n\n  while (state.parens > 0) {\n    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));\n    state.output = utils$4.escapeLast(state.output, '(');\n    decrement('parens');\n  }\n\n  while (state.braces > 0) {\n    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));\n    state.output = utils$4.escapeLast(state.output, '{');\n    decrement('braces');\n  }\n\n  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {\n    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });\n  }\n\n  // rebuild the output if we had to backtrack at any point\n  if (state.backtrack === true) {\n    state.output = '';\n\n    for (const token of state.tokens) {\n      state.output += token.output != null ? token.output : token.value;\n\n      if (token.suffix) {\n        state.output += token.suffix;\n      }\n    }\n  }\n\n  return state;\n};\n\n/**\n * Fast paths for creating regular expressions for common glob patterns.\n * This can significantly speed up processing and has very little downside\n * impact when none of the fast paths match.\n */\n\nparse$9.fastpaths = (input, options) => {\n  const opts = { ...options };\n  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;\n  const len = input.length;\n  if (len > max) {\n    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);\n  }\n\n  input = REPLACEMENTS[input] || input;\n  const win32 = utils$4.isWindows(options);\n\n  // create constants based on platform, for windows or posix\n  const {\n    DOT_LITERAL,\n    SLASH_LITERAL,\n    ONE_CHAR,\n    DOTS_SLASH,\n    NO_DOT,\n    NO_DOTS,\n    NO_DOTS_SLASH,\n    STAR,\n    START_ANCHOR\n  } = constants$1.globChars(win32);\n\n  const nodot = opts.dot ? NO_DOTS : NO_DOT;\n  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;\n  const capture = opts.capture ? '' : '?:';\n  const state = { negated: false, prefix: '' };\n  let star = opts.bash === true ? '.*?' : STAR;\n\n  if (opts.capture) {\n    star = `(${star})`;\n  }\n\n  const globstar = (opts) => {\n    if (opts.noglobstar === true) return star;\n    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;\n  };\n\n  const create = str => {\n    switch (str) {\n      case '*':\n        return `${nodot}${ONE_CHAR}${star}`;\n\n      case '.*':\n        return `${DOT_LITERAL}${ONE_CHAR}${star}`;\n\n      case '*.*':\n        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;\n\n      case '*/*':\n        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;\n\n      case '**':\n        return nodot + globstar(opts);\n\n      case '**/*':\n        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;\n\n      case '**/*.*':\n        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;\n\n      case '**/.*':\n        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;\n\n      default: {\n        const match = /^(.*?)\\.(\\w+)$/.exec(str);\n        if (!match) return;\n\n        const source = create(match[1]);\n        if (!source) return;\n\n        return source + DOT_LITERAL + match[2];\n      }\n    }\n  };\n\n  const output = utils$4.removePrefix(input, state);\n  let source = create(output);\n\n  if (source && opts.strictSlashes !== true) {\n    source += `${SLASH_LITERAL}?`;\n  }\n\n  return source;\n};\n\nvar parse_1$2 = parse$9;\n\nconst isObject$3 = val => val && typeof val === 'object' && !Array.isArray(val);\n\n/**\n * Creates a matcher function from one or more glob patterns. The\n * returned function takes a string to match as its first argument,\n * and returns true if the string is a match. The returned matcher\n * function also takes a boolean as the second argument that, when true,\n * returns an object with additional information.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch(glob[, options]);\n *\n * const isMatch = picomatch('*.!(*a)');\n * console.log(isMatch('a.a')); //=> false\n * console.log(isMatch('a.b')); //=> true\n * ```\n * @name picomatch\n * @param {String|Array} `globs` One or more glob patterns.\n * @param {Object=} `options`\n * @return {Function=} Returns a matcher function.\n * @api public\n */\n\nconst picomatch = (glob, options, returnState = false) => {\n  if (Array.isArray(glob)) {\n    const fns = glob.map(input => picomatch(input, options, returnState));\n    const arrayMatcher = str => {\n      for (const isMatch of fns) {\n        const state = isMatch(str);\n        if (state) return state;\n      }\n      return false;\n    };\n    return arrayMatcher;\n  }\n\n  const isState = isObject$3(glob) && glob.tokens && glob.input;\n\n  if (glob === '' || (typeof glob !== 'string' && !isState)) {\n    throw new TypeError('Expected pattern to be a non-empty string');\n  }\n\n  const opts = options || {};\n  const posix = utils$4.isWindows(options);\n  const regex = isState\n    ? picomatch.compileRe(glob, options)\n    : picomatch.makeRe(glob, options, false, true);\n\n  const state = regex.state;\n  delete regex.state;\n\n  let isIgnored = () => false;\n  if (opts.ignore) {\n    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };\n    isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);\n  }\n\n  const matcher = (input, returnObject = false) => {\n    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });\n    const result = { glob, state, regex, posix, input, output, match, isMatch };\n\n    if (typeof opts.onResult === 'function') {\n      opts.onResult(result);\n    }\n\n    if (isMatch === false) {\n      result.isMatch = false;\n      return returnObject ? result : false;\n    }\n\n    if (isIgnored(input)) {\n      if (typeof opts.onIgnore === 'function') {\n        opts.onIgnore(result);\n      }\n      result.isMatch = false;\n      return returnObject ? result : false;\n    }\n\n    if (typeof opts.onMatch === 'function') {\n      opts.onMatch(result);\n    }\n    return returnObject ? result : true;\n  };\n\n  if (returnState) {\n    matcher.state = state;\n  }\n\n  return matcher;\n};\n\n/**\n * Test `input` with the given `regex`. This is used by the main\n * `picomatch()` function to test the input string.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.test(input, regex[, options]);\n *\n * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\\/([^/]*?))$/));\n * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }\n * ```\n * @param {String} `input` String to test.\n * @param {RegExp} `regex`\n * @return {Object} Returns an object with matching info.\n * @api public\n */\n\npicomatch.test = (input, regex, options, { glob, posix } = {}) => {\n  if (typeof input !== 'string') {\n    throw new TypeError('Expected input to be a string');\n  }\n\n  if (input === '') {\n    return { isMatch: false, output: '' };\n  }\n\n  const opts = options || {};\n  const format = opts.format || (posix ? utils$4.toPosixSlashes : null);\n  let match = input === glob;\n  let output = (match && format) ? format(input) : input;\n\n  if (match === false) {\n    output = format ? format(input) : input;\n    match = output === glob;\n  }\n\n  if (match === false || opts.capture === true) {\n    if (opts.matchBase === true || opts.basename === true) {\n      match = picomatch.matchBase(input, regex, options, posix);\n    } else {\n      match = regex.exec(output);\n    }\n  }\n\n  return { isMatch: Boolean(match), match, output };\n};\n\n/**\n * Match the basename of a filepath.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.matchBase(input, glob[, options]);\n * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true\n * ```\n * @param {String} `input` String to test.\n * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).\n * @return {Boolean}\n * @api public\n */\n\npicomatch.matchBase = (input, glob, options, posix = utils$4.isWindows(options)) => {\n  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);\n  return regex.test(path$1.basename(input));\n};\n\n/**\n * Returns true if **any** of the given glob `patterns` match the specified `string`.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.isMatch(string, patterns[, options]);\n *\n * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true\n * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false\n * ```\n * @param {String|Array} str The string to test.\n * @param {String|Array} patterns One or more glob patterns to use for matching.\n * @param {Object} [options] See available [options](#options).\n * @return {Boolean} Returns true if any patterns match `str`\n * @api public\n */\n\npicomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);\n\n/**\n * Parse a glob pattern to create the source string for a regular\n * expression.\n *\n * ```js\n * const picomatch = require('picomatch');\n * const result = picomatch.parse(pattern[, options]);\n * ```\n * @param {String} `pattern`\n * @param {Object} `options`\n * @return {Object} Returns an object with useful properties and output to be used as a regex source string.\n * @api public\n */\n\npicomatch.parse = (pattern, options) => {\n  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));\n  return parse_1$2(pattern, { ...options, fastpaths: false });\n};\n\n/**\n * Scan a glob pattern to separate the pattern into segments.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.scan(input[, options]);\n *\n * const result = picomatch.scan('!./foo/*.js');\n * console.log(result);\n * { prefix: '!./',\n *   input: '!./foo/*.js',\n *   start: 3,\n *   base: 'foo',\n *   glob: '*.js',\n *   isBrace: false,\n *   isBracket: false,\n *   isGlob: true,\n *   isExtglob: false,\n *   isGlobstar: false,\n *   negated: true }\n * ```\n * @param {String} `input` Glob pattern to scan.\n * @param {Object} `options`\n * @return {Object} Returns an object with\n * @api public\n */\n\npicomatch.scan = (input, options) => scan_1(input, options);\n\n/**\n * Create a regular expression from a parsed glob pattern.\n *\n * ```js\n * const picomatch = require('picomatch');\n * const state = picomatch.parse('*.js');\n * // picomatch.compileRe(state[, options]);\n *\n * console.log(picomatch.compileRe(state));\n * //=> /^(?:(?!\\.)(?=.)[^/]*?\\.js)$/\n * ```\n * @param {String} `state` The object returned from the `.parse` method.\n * @param {Object} `options`\n * @return {RegExp} Returns a regex created from the given pattern.\n * @api public\n */\n\npicomatch.compileRe = (parsed, options, returnOutput = false, returnState = false) => {\n  if (returnOutput === true) {\n    return parsed.output;\n  }\n\n  const opts = options || {};\n  const prepend = opts.contains ? '' : '^';\n  const append = opts.contains ? '' : '$';\n\n  let source = `${prepend}(?:${parsed.output})${append}`;\n  if (parsed && parsed.negated === true) {\n    source = `^(?!${source}).*$`;\n  }\n\n  const regex = picomatch.toRegex(source, options);\n  if (returnState === true) {\n    regex.state = parsed;\n  }\n\n  return regex;\n};\n\npicomatch.makeRe = (input, options, returnOutput = false, returnState = false) => {\n  if (!input || typeof input !== 'string') {\n    throw new TypeError('Expected a non-empty string');\n  }\n\n  const opts = options || {};\n  let parsed = { negated: false, fastpaths: true };\n  let prefix = '';\n  let output;\n\n  if (input.startsWith('./')) {\n    input = input.slice(2);\n    prefix = parsed.prefix = './';\n  }\n\n  if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {\n    output = parse_1$2.fastpaths(input, options);\n  }\n\n  if (output === undefined) {\n    parsed = parse_1$2(input, options);\n    parsed.prefix = prefix + (parsed.prefix || '');\n  } else {\n    parsed.output = output;\n  }\n\n  return picomatch.compileRe(parsed, options, returnOutput, returnState);\n};\n\n/**\n * Create a regular expression from the given regex source string.\n *\n * ```js\n * const picomatch = require('picomatch');\n * // picomatch.toRegex(source[, options]);\n *\n * const { output } = picomatch.parse('*.js');\n * console.log(picomatch.toRegex(output));\n * //=> /^(?:(?!\\.)(?=.)[^/]*?\\.js)$/\n * ```\n * @param {String} `source` Regular expression source string.\n * @param {Object} `options`\n * @return {RegExp}\n * @api public\n */\n\npicomatch.toRegex = (source, options) => {\n  try {\n    const opts = options || {};\n    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));\n  } catch (err) {\n    if (options && options.debug === true) throw err;\n    return /$^/;\n  }\n};\n\n/**\n * Picomatch constants.\n * @return {Object}\n */\n\npicomatch.constants = constants$1;\n\n/**\n * Expose \"picomatch\"\n */\n\nvar picomatch_1 = picomatch;\n\nvar picomatch$1 = picomatch_1;\n\nconst isEmptyString$1 = val => typeof val === 'string' && (val === '' || val === './');\n\n/**\n * Returns an array of strings that match one or more glob patterns.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm(list, patterns[, options]);\n *\n * console.log(mm(['a.js', 'a.txt'], ['*.js']));\n * //=> [ 'a.js' ]\n * ```\n * @param {String|Array<string>} list List of strings to match.\n * @param {String|Array<string>} patterns One or more glob patterns to use for matching.\n * @param {Object} options See available [options](#options)\n * @return {Array} Returns an array of matches\n * @summary false\n * @api public\n */\n\nconst micromatch = (list, patterns, options) => {\n  patterns = [].concat(patterns);\n  list = [].concat(list);\n\n  let omit = new Set();\n  let keep = new Set();\n  let items = new Set();\n  let negatives = 0;\n\n  let onResult = state => {\n    items.add(state.output);\n    if (options && options.onResult) {\n      options.onResult(state);\n    }\n  };\n\n  for (let i = 0; i < patterns.length; i++) {\n    let isMatch = picomatch$1(String(patterns[i]), { ...options, onResult }, true);\n    let negated = isMatch.state.negated || isMatch.state.negatedExtglob;\n    if (negated) negatives++;\n\n    for (let item of list) {\n      let matched = isMatch(item, true);\n\n      let match = negated ? !matched.isMatch : matched.isMatch;\n      if (!match) continue;\n\n      if (negated) {\n        omit.add(matched.output);\n      } else {\n        omit.delete(matched.output);\n        keep.add(matched.output);\n      }\n    }\n  }\n\n  let result = negatives === patterns.length ? [...items] : [...keep];\n  let matches = result.filter(item => !omit.has(item));\n\n  if (options && matches.length === 0) {\n    if (options.failglob === true) {\n      throw new Error(`No matches found for \"${patterns.join(', ')}\"`);\n    }\n\n    if (options.nonull === true || options.nullglob === true) {\n      return options.unescape ? patterns.map(p => p.replace(/\\\\/g, '')) : patterns;\n    }\n  }\n\n  return matches;\n};\n\n/**\n * Backwards compatibility\n */\n\nmicromatch.match = micromatch;\n\n/**\n * Returns a matcher function from the given glob `pattern` and `options`.\n * The returned function takes a string to match as its only argument and returns\n * true if the string is a match.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.matcher(pattern[, options]);\n *\n * const isMatch = mm.matcher('*.!(*a)');\n * console.log(isMatch('a.a')); //=> false\n * console.log(isMatch('a.b')); //=> true\n * ```\n * @param {String} `pattern` Glob pattern\n * @param {Object} `options`\n * @return {Function} Returns a matcher function.\n * @api public\n */\n\nmicromatch.matcher = (pattern, options) => picomatch$1(pattern, options);\n\n/**\n * Returns true if **any** of the given glob `patterns` match the specified `string`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.isMatch(string, patterns[, options]);\n *\n * console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true\n * console.log(mm.isMatch('a.a', 'b.*')); //=> false\n * ```\n * @param {String} str The string to test.\n * @param {String|Array} patterns One or more glob patterns to use for matching.\n * @param {Object} [options] See available [options](#options).\n * @return {Boolean} Returns true if any patterns match `str`\n * @api public\n */\n\nmicromatch.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str);\n\n/**\n * Backwards compatibility\n */\n\nmicromatch.any = micromatch.isMatch;\n\n/**\n * Returns a list of strings that _**do not match any**_ of the given `patterns`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.not(list, patterns[, options]);\n *\n * console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a'));\n * //=> ['b.b', 'c.c']\n * ```\n * @param {Array} `list` Array of strings to match.\n * @param {String|Array} `patterns` One or more glob pattern to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Array} Returns an array of strings that **do not match** the given patterns.\n * @api public\n */\n\nmicromatch.not = (list, patterns, options = {}) => {\n  patterns = [].concat(patterns).map(String);\n  let result = new Set();\n  let items = [];\n\n  let onResult = state => {\n    if (options.onResult) options.onResult(state);\n    items.push(state.output);\n  };\n\n  let matches = micromatch(list, patterns, { ...options, onResult });\n\n  for (let item of items) {\n    if (!matches.includes(item)) {\n      result.add(item);\n    }\n  }\n  return [...result];\n};\n\n/**\n * Returns true if the given `string` contains the given pattern. Similar\n * to [.isMatch](#isMatch) but the pattern can match any part of the string.\n *\n * ```js\n * var mm = require('micromatch');\n * // mm.contains(string, pattern[, options]);\n *\n * console.log(mm.contains('aa/bb/cc', '*b'));\n * //=> true\n * console.log(mm.contains('aa/bb/cc', '*d'));\n * //=> false\n * ```\n * @param {String} `str` The string to match.\n * @param {String|Array} `patterns` Glob pattern to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if the patter matches any part of `str`.\n * @api public\n */\n\nmicromatch.contains = (str, pattern, options) => {\n  if (typeof str !== 'string') {\n    throw new TypeError(`Expected a string: \"${util$2.inspect(str)}\"`);\n  }\n\n  if (Array.isArray(pattern)) {\n    return pattern.some(p => micromatch.contains(str, p, options));\n  }\n\n  if (typeof pattern === 'string') {\n    if (isEmptyString$1(str) || isEmptyString$1(pattern)) {\n      return false;\n    }\n\n    if (str.includes(pattern) || (str.startsWith('./') && str.slice(2).includes(pattern))) {\n      return true;\n    }\n  }\n\n  return micromatch.isMatch(str, pattern, { ...options, contains: true });\n};\n\n/**\n * Filter the keys of the given object with the given `glob` pattern\n * and `options`. Does not attempt to match nested keys. If you need this feature,\n * use [glob-object][] instead.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.matchKeys(object, patterns[, options]);\n *\n * const obj = { aa: 'a', ab: 'b', ac: 'c' };\n * console.log(mm.matchKeys(obj, '*b'));\n * //=> { ab: 'b' }\n * ```\n * @param {Object} `object` The object with keys to filter.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Object} Returns an object with only keys that match the given patterns.\n * @api public\n */\n\nmicromatch.matchKeys = (obj, patterns, options) => {\n  if (!utils$4.isObject(obj)) {\n    throw new TypeError('Expected the first argument to be an object');\n  }\n  let keys = micromatch(Object.keys(obj), patterns, options);\n  let res = {};\n  for (let key of keys) res[key] = obj[key];\n  return res;\n};\n\n/**\n * Returns true if some of the strings in the given `list` match any of the given glob `patterns`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.some(list, patterns[, options]);\n *\n * console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));\n * // true\n * console.log(mm.some(['foo.js'], ['*.js', '!foo.js']));\n * // false\n * ```\n * @param {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if any patterns match `str`\n * @api public\n */\n\nmicromatch.some = (list, patterns, options) => {\n  let items = [].concat(list);\n\n  for (let pattern of [].concat(patterns)) {\n    let isMatch = picomatch$1(String(pattern), options);\n    if (items.some(item => isMatch(item))) {\n      return true;\n    }\n  }\n  return false;\n};\n\n/**\n * Returns true if every string in the given `list` matches\n * any of the given glob `patterns`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.every(list, patterns[, options]);\n *\n * console.log(mm.every('foo.js', ['foo.js']));\n * // true\n * console.log(mm.every(['foo.js', 'bar.js'], ['*.js']));\n * // true\n * console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));\n * // false\n * console.log(mm.every(['foo.js'], ['*.js', '!foo.js']));\n * // false\n * ```\n * @param {String|Array} `list` The string or array of strings to test.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if any patterns match `str`\n * @api public\n */\n\nmicromatch.every = (list, patterns, options) => {\n  let items = [].concat(list);\n\n  for (let pattern of [].concat(patterns)) {\n    let isMatch = picomatch$1(String(pattern), options);\n    if (!items.every(item => isMatch(item))) {\n      return false;\n    }\n  }\n  return true;\n};\n\n/**\n * Returns true if **all** of the given `patterns` match\n * the specified string.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.all(string, patterns[, options]);\n *\n * console.log(mm.all('foo.js', ['foo.js']));\n * // true\n *\n * console.log(mm.all('foo.js', ['*.js', '!foo.js']));\n * // false\n *\n * console.log(mm.all('foo.js', ['*.js', 'foo.js']));\n * // true\n *\n * console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));\n * // true\n * ```\n * @param {String|Array} `str` The string to test.\n * @param {String|Array} `patterns` One or more glob patterns to use for matching.\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns true if any patterns match `str`\n * @api public\n */\n\nmicromatch.all = (str, patterns, options) => {\n  if (typeof str !== 'string') {\n    throw new TypeError(`Expected a string: \"${util$2.inspect(str)}\"`);\n  }\n\n  return [].concat(patterns).every(p => picomatch$1(p, options)(str));\n};\n\n/**\n * Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.capture(pattern, string[, options]);\n *\n * console.log(mm.capture('test/*.js', 'test/foo.js'));\n * //=> ['foo']\n * console.log(mm.capture('test/*.js', 'foo/bar.css'));\n * //=> null\n * ```\n * @param {String} `glob` Glob pattern to use for matching.\n * @param {String} `input` String to match\n * @param {Object} `options` See available [options](#options) for changing how matches are performed\n * @return {Boolean} Returns an array of captures if the input matches the glob pattern, otherwise `null`.\n * @api public\n */\n\nmicromatch.capture = (glob, input, options) => {\n  let posix = utils$4.isWindows(options);\n  let regex = picomatch$1.makeRe(String(glob), { ...options, capture: true });\n  let match = regex.exec(posix ? utils$4.toPosixSlashes(input) : input);\n\n  if (match) {\n    return match.slice(1).map(v => v === void 0 ? '' : v);\n  }\n};\n\n/**\n * Create a regular expression from the given glob `pattern`.\n *\n * ```js\n * const mm = require('micromatch');\n * // mm.makeRe(pattern[, options]);\n *\n * console.log(mm.makeRe('*.js'));\n * //=> /^(?:(\\.[\\\\\\/])?(?!\\.)(?=.)[^\\/]*?\\.js)$/\n * ```\n * @param {String} `pattern` A glob pattern to convert to regex.\n * @param {Object} `options`\n * @return {RegExp} Returns a regex created from the given pattern.\n * @api public\n */\n\nmicromatch.makeRe = (...args) => picomatch$1.makeRe(...args);\n\n/**\n * Scan a glob pattern to separate the pattern into segments. Used\n * by the [split](#split) method.\n *\n * ```js\n * const mm = require('micromatch');\n * const state = mm.scan(pattern[, options]);\n * ```\n * @param {String} `pattern`\n * @param {Object} `options`\n * @return {Object} Returns an object with\n * @api public\n */\n\nmicromatch.scan = (...args) => picomatch$1.scan(...args);\n\n/**\n * Parse a glob pattern to create the source string for a regular\n * expression.\n *\n * ```js\n * const mm = require('micromatch');\n * const state = mm(pattern[, options]);\n * ```\n * @param {String} `glob`\n * @param {Object} `options`\n * @return {Object} Returns an object with useful properties and output to be used as regex source string.\n * @api public\n */\n\nmicromatch.parse = (patterns, options) => {\n  let res = [];\n  for (let pattern of [].concat(patterns || [])) {\n    for (let str of braces_1(String(pattern), options)) {\n      res.push(picomatch$1.parse(str, options));\n    }\n  }\n  return res;\n};\n\n/**\n * Process the given brace `pattern`.\n *\n * ```js\n * const { braces } = require('micromatch');\n * console.log(braces('foo/{a,b,c}/bar'));\n * //=> [ 'foo/(a|b|c)/bar' ]\n *\n * console.log(braces('foo/{a,b,c}/bar', { expand: true }));\n * //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ]\n * ```\n * @param {String} `pattern` String with brace pattern to process.\n * @param {Object} `options` Any [options](#options) to change how expansion is performed. See the [braces][] library for all available options.\n * @return {Array}\n * @api public\n */\n\nmicromatch.braces = (pattern, options) => {\n  if (typeof pattern !== 'string') throw new TypeError('Expected a string');\n  if ((options && options.nobrace === true) || !/\\{.*\\}/.test(pattern)) {\n    return [pattern];\n  }\n  return braces_1(pattern, options);\n};\n\n/**\n * Expand braces\n */\n\nmicromatch.braceExpand = (pattern, options) => {\n  if (typeof pattern !== 'string') throw new TypeError('Expected a string');\n  return micromatch.braces(pattern, { ...options, expand: true });\n};\n\n/**\n * Expose micromatch\n */\n\nvar micromatch_1 = micromatch;\n\nvar pattern$1 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\n\r\n\r\nconst GLOBSTAR = '**';\r\nconst ESCAPE_SYMBOL = '\\\\';\r\nconst COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;\r\nconst REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\\[.*]/;\r\nconst REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\\(.*\\|.*\\)/;\r\nconst GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\\(.*\\)/;\r\nconst BRACE_EXPANSIONS_SYMBOLS_RE = /{.*(?:,|\\.\\.).*}/;\r\nfunction isStaticPattern(pattern, options = {}) {\r\n    return !isDynamicPattern(pattern, options);\r\n}\r\nexports.isStaticPattern = isStaticPattern;\r\nfunction isDynamicPattern(pattern, options = {}) {\r\n    /**\r\n     * When the `caseSensitiveMatch` option is disabled, all patterns must be marked as dynamic, because we cannot check\r\n     * filepath directly (without read directory).\r\n     */\r\n    if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {\r\n        return true;\r\n    }\r\n    if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {\r\n        return true;\r\n    }\r\n    if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {\r\n        return true;\r\n    }\r\n    if (options.braceExpansion !== false && BRACE_EXPANSIONS_SYMBOLS_RE.test(pattern)) {\r\n        return true;\r\n    }\r\n    return false;\r\n}\r\nexports.isDynamicPattern = isDynamicPattern;\r\nfunction convertToPositivePattern(pattern) {\r\n    return isNegativePattern(pattern) ? pattern.slice(1) : pattern;\r\n}\r\nexports.convertToPositivePattern = convertToPositivePattern;\r\nfunction convertToNegativePattern(pattern) {\r\n    return '!' + pattern;\r\n}\r\nexports.convertToNegativePattern = convertToNegativePattern;\r\nfunction isNegativePattern(pattern) {\r\n    return pattern.startsWith('!') && pattern[1] !== '(';\r\n}\r\nexports.isNegativePattern = isNegativePattern;\r\nfunction isPositivePattern(pattern) {\r\n    return !isNegativePattern(pattern);\r\n}\r\nexports.isPositivePattern = isPositivePattern;\r\nfunction getNegativePatterns(patterns) {\r\n    return patterns.filter(isNegativePattern);\r\n}\r\nexports.getNegativePatterns = getNegativePatterns;\r\nfunction getPositivePatterns(patterns) {\r\n    return patterns.filter(isPositivePattern);\r\n}\r\nexports.getPositivePatterns = getPositivePatterns;\r\nfunction getBaseDirectory(pattern) {\r\n    return globParent(pattern, { flipBackslashes: false });\r\n}\r\nexports.getBaseDirectory = getBaseDirectory;\r\nfunction hasGlobStar(pattern) {\r\n    return pattern.includes(GLOBSTAR);\r\n}\r\nexports.hasGlobStar = hasGlobStar;\r\nfunction endsWithSlashGlobStar(pattern) {\r\n    return pattern.endsWith('/' + GLOBSTAR);\r\n}\r\nexports.endsWithSlashGlobStar = endsWithSlashGlobStar;\r\nfunction isAffectDepthOfReadingPattern(pattern) {\r\n    const basename = path$1.basename(pattern);\r\n    return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);\r\n}\r\nexports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;\r\nfunction expandPatternsWithBraceExpansion(patterns) {\r\n    return patterns.reduce((collection, pattern) => {\r\n        return collection.concat(expandBraceExpansion(pattern));\r\n    }, []);\r\n}\r\nexports.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;\r\nfunction expandBraceExpansion(pattern) {\r\n    return micromatch_1.braces(pattern, {\r\n        expand: true,\r\n        nodupes: true\r\n    });\r\n}\r\nexports.expandBraceExpansion = expandBraceExpansion;\r\nfunction getPatternParts(pattern, options) {\r\n    const info = picomatch$1.scan(pattern, Object.assign(Object.assign({}, options), { parts: true }));\r\n    // See micromatch/picomatch#58 for more details\r\n    if (info.parts.length === 0) {\r\n        return [pattern];\r\n    }\r\n    return info.parts;\r\n}\r\nexports.getPatternParts = getPatternParts;\r\nfunction makeRe(pattern, options) {\r\n    return micromatch_1.makeRe(pattern, options);\r\n}\r\nexports.makeRe = makeRe;\r\nfunction convertPatternsToRe(patterns, options) {\r\n    return patterns.map((pattern) => makeRe(pattern, options));\r\n}\r\nexports.convertPatternsToRe = convertPatternsToRe;\r\nfunction matchAny(entry, patternsRe) {\r\n    return patternsRe.some((patternRe) => patternRe.test(entry));\r\n}\r\nexports.matchAny = matchAny;\n});\n\nunwrapExports(pattern$1);\nvar pattern_1 = pattern$1.isStaticPattern;\nvar pattern_2 = pattern$1.isDynamicPattern;\nvar pattern_3 = pattern$1.convertToPositivePattern;\nvar pattern_4 = pattern$1.convertToNegativePattern;\nvar pattern_5 = pattern$1.isNegativePattern;\nvar pattern_6 = pattern$1.isPositivePattern;\nvar pattern_7 = pattern$1.getNegativePatterns;\nvar pattern_8 = pattern$1.getPositivePatterns;\nvar pattern_9 = pattern$1.getBaseDirectory;\nvar pattern_10 = pattern$1.hasGlobStar;\nvar pattern_11 = pattern$1.endsWithSlashGlobStar;\nvar pattern_12 = pattern$1.isAffectDepthOfReadingPattern;\nvar pattern_13 = pattern$1.expandPatternsWithBraceExpansion;\nvar pattern_14 = pattern$1.expandBraceExpansion;\nvar pattern_15 = pattern$1.getPatternParts;\nvar pattern_16 = pattern$1.makeRe;\nvar pattern_17 = pattern$1.convertPatternsToRe;\nvar pattern_18 = pattern$1.matchAny;\n\nvar stream = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nfunction merge(streams) {\r\n    const mergedStream = merge2_1(streams);\r\n    streams.forEach((stream) => {\r\n        stream.once('error', (error) => mergedStream.emit('error', error));\r\n    });\r\n    mergedStream.once('close', () => propagateCloseEventToSources(streams));\r\n    mergedStream.once('end', () => propagateCloseEventToSources(streams));\r\n    return mergedStream;\r\n}\r\nexports.merge = merge;\r\nfunction propagateCloseEventToSources(streams) {\r\n    streams.forEach((stream) => stream.emit('close'));\r\n}\n});\n\nunwrapExports(stream);\nvar stream_1$1 = stream.merge;\n\nvar string = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nfunction isString(input) {\r\n    return typeof input === 'string';\r\n}\r\nexports.isString = isString;\r\nfunction isEmpty(input) {\r\n    return input === '';\r\n}\r\nexports.isEmpty = isEmpty;\n});\n\nunwrapExports(string);\nvar string_1 = string.isString;\nvar string_2 = string.isEmpty;\n\nvar utils$5 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nexports.array = array;\r\n\r\nexports.errno = errno;\r\n\r\nexports.fs = fs;\r\n\r\nexports.path = path_1;\r\n\r\nexports.pattern = pattern$1;\r\n\r\nexports.stream = stream;\r\n\r\nexports.string = string;\n});\n\nunwrapExports(utils$5);\nvar utils_1$3 = utils$5.array;\nvar utils_2$3 = utils$5.errno;\nvar utils_3$3 = utils$5.fs;\nvar utils_4$2 = utils$5.path;\nvar utils_5$2 = utils$5.pattern;\nvar utils_6$2 = utils$5.stream;\nvar utils_7$2 = utils$5.string;\n\nvar tasks = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nfunction generate(patterns, settings) {\r\n    const positivePatterns = getPositivePatterns(patterns);\r\n    const negativePatterns = getNegativePatternsAsPositive(patterns, settings.ignore);\r\n    const staticPatterns = positivePatterns.filter((pattern) => utils$5.pattern.isStaticPattern(pattern, settings));\r\n    const dynamicPatterns = positivePatterns.filter((pattern) => utils$5.pattern.isDynamicPattern(pattern, settings));\r\n    const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */ false);\r\n    const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */ true);\r\n    return staticTasks.concat(dynamicTasks);\r\n}\r\nexports.generate = generate;\r\nfunction convertPatternsToTasks(positive, negative, dynamic) {\r\n    const positivePatternsGroup = groupPatternsByBaseDirectory(positive);\r\n    // When we have a global group – there is no reason to divide the patterns into independent tasks.\r\n    // In this case, the global task covers the rest.\r\n    if ('.' in positivePatternsGroup) {\r\n        const task = convertPatternGroupToTask('.', positive, negative, dynamic);\r\n        return [task];\r\n    }\r\n    return convertPatternGroupsToTasks(positivePatternsGroup, negative, dynamic);\r\n}\r\nexports.convertPatternsToTasks = convertPatternsToTasks;\r\nfunction getPositivePatterns(patterns) {\r\n    return utils$5.pattern.getPositivePatterns(patterns);\r\n}\r\nexports.getPositivePatterns = getPositivePatterns;\r\nfunction getNegativePatternsAsPositive(patterns, ignore) {\r\n    const negative = utils$5.pattern.getNegativePatterns(patterns).concat(ignore);\r\n    const positive = negative.map(utils$5.pattern.convertToPositivePattern);\r\n    return positive;\r\n}\r\nexports.getNegativePatternsAsPositive = getNegativePatternsAsPositive;\r\nfunction groupPatternsByBaseDirectory(patterns) {\r\n    const group = {};\r\n    return patterns.reduce((collection, pattern) => {\r\n        const base = utils$5.pattern.getBaseDirectory(pattern);\r\n        if (base in collection) {\r\n            collection[base].push(pattern);\r\n        }\r\n        else {\r\n            collection[base] = [pattern];\r\n        }\r\n        return collection;\r\n    }, group);\r\n}\r\nexports.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;\r\nfunction convertPatternGroupsToTasks(positive, negative, dynamic) {\r\n    return Object.keys(positive).map((base) => {\r\n        return convertPatternGroupToTask(base, positive[base], negative, dynamic);\r\n    });\r\n}\r\nexports.convertPatternGroupsToTasks = convertPatternGroupsToTasks;\r\nfunction convertPatternGroupToTask(base, positive, negative, dynamic) {\r\n    return {\r\n        dynamic,\r\n        positive,\r\n        negative,\r\n        base,\r\n        patterns: [].concat(positive, negative.map(utils$5.pattern.convertToNegativePattern))\r\n    };\r\n}\r\nexports.convertPatternGroupToTask = convertPatternGroupToTask;\n});\n\nunwrapExports(tasks);\nvar tasks_1 = tasks.generate;\nvar tasks_2 = tasks.convertPatternsToTasks;\nvar tasks_3 = tasks.getPositivePatterns;\nvar tasks_4 = tasks.getNegativePatternsAsPositive;\nvar tasks_5 = tasks.groupPatternsByBaseDirectory;\nvar tasks_6 = tasks.convertPatternGroupsToTasks;\nvar tasks_7 = tasks.convertPatternGroupToTask;\n\nvar async$1 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nfunction read(path, settings, callback) {\r\n    settings.fs.lstat(path, (lstatError, lstat) => {\r\n        if (lstatError !== null) {\r\n            return callFailureCallback(callback, lstatError);\r\n        }\r\n        if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {\r\n            return callSuccessCallback(callback, lstat);\r\n        }\r\n        settings.fs.stat(path, (statError, stat) => {\r\n            if (statError !== null) {\r\n                if (settings.throwErrorOnBrokenSymbolicLink) {\r\n                    return callFailureCallback(callback, statError);\r\n                }\r\n                return callSuccessCallback(callback, lstat);\r\n            }\r\n            if (settings.markSymbolicLink) {\r\n                stat.isSymbolicLink = () => true;\r\n            }\r\n            callSuccessCallback(callback, stat);\r\n        });\r\n    });\r\n}\r\nexports.read = read;\r\nfunction callFailureCallback(callback, error) {\r\n    callback(error);\r\n}\r\nfunction callSuccessCallback(callback, result) {\r\n    callback(null, result);\r\n}\n});\n\nunwrapExports(async$1);\nvar async_1 = async$1.read;\n\nvar sync$1 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nfunction read(path, settings) {\r\n    const lstat = settings.fs.lstatSync(path);\r\n    if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {\r\n        return lstat;\r\n    }\r\n    try {\r\n        const stat = settings.fs.statSync(path);\r\n        if (settings.markSymbolicLink) {\r\n            stat.isSymbolicLink = () => true;\r\n        }\r\n        return stat;\r\n    }\r\n    catch (error) {\r\n        if (!settings.throwErrorOnBrokenSymbolicLink) {\r\n            return lstat;\r\n        }\r\n        throw error;\r\n    }\r\n}\r\nexports.read = read;\n});\n\nunwrapExports(sync$1);\nvar sync_1 = sync$1.read;\n\nvar fs_1$1 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nexports.FILE_SYSTEM_ADAPTER = {\r\n    lstat: fs$2.lstat,\r\n    stat: fs$2.stat,\r\n    lstatSync: fs$2.lstatSync,\r\n    statSync: fs$2.statSync\r\n};\r\nfunction createFileSystemAdapter(fsMethods) {\r\n    if (fsMethods === undefined) {\r\n        return exports.FILE_SYSTEM_ADAPTER;\r\n    }\r\n    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);\r\n}\r\nexports.createFileSystemAdapter = createFileSystemAdapter;\n});\n\nunwrapExports(fs_1$1);\nvar fs_2 = fs_1$1.FILE_SYSTEM_ADAPTER;\nvar fs_3 = fs_1$1.createFileSystemAdapter;\n\nvar settings = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nclass Settings {\r\n    constructor(_options = {}) {\r\n        this._options = _options;\r\n        this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);\r\n        this.fs = fs_1$1.createFileSystemAdapter(this._options.fs);\r\n        this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);\r\n        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);\r\n    }\r\n    _getValue(option, value) {\r\n        return option === undefined ? value : option;\r\n    }\r\n}\r\nexports.default = Settings;\n});\n\nunwrapExports(settings);\n\nvar out = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\n\r\nexports.Settings = settings.default;\r\nfunction stat(path, optionsOrSettingsOrCallback, callback) {\r\n    if (typeof optionsOrSettingsOrCallback === 'function') {\r\n        return async$1.read(path, getSettings(), optionsOrSettingsOrCallback);\r\n    }\r\n    async$1.read(path, getSettings(optionsOrSettingsOrCallback), callback);\r\n}\r\nexports.stat = stat;\r\nfunction statSync(path, optionsOrSettings) {\r\n    const settings = getSettings(optionsOrSettings);\r\n    return sync$1.read(path, settings);\r\n}\r\nexports.statSync = statSync;\r\nfunction getSettings(settingsOrOptions = {}) {\r\n    if (settingsOrOptions instanceof settings.default) {\r\n        return settingsOrOptions;\r\n    }\r\n    return new settings.default(settingsOrOptions);\r\n}\n});\n\nunwrapExports(out);\nvar out_1 = out.Settings;\nvar out_2 = out.stat;\nvar out_3 = out.statSync;\n\nvar runParallel_1 = runParallel;\n\nfunction runParallel (tasks, cb) {\n  var results, pending, keys;\n  var isSync = true;\n\n  if (Array.isArray(tasks)) {\n    results = [];\n    pending = tasks.length;\n  } else {\n    keys = Object.keys(tasks);\n    results = {};\n    pending = keys.length;\n  }\n\n  function done (err) {\n    function end () {\n      if (cb) cb(err, results);\n      cb = null;\n    }\n    if (isSync) process.nextTick(end);\n    else end();\n  }\n\n  function each (i, err, result) {\n    results[i] = result;\n    if (--pending === 0 || err) {\n      done(err);\n    }\n  }\n\n  if (!pending) {\n    // empty\n    done(null);\n  } else if (keys) {\n    // object\n    keys.forEach(function (key) {\n      tasks[key](function (err, result) { each(key, err, result); });\n    });\n  } else {\n    // array\n    tasks.forEach(function (task, i) {\n      task(function (err, result) { each(i, err, result); });\n    });\n  }\n\n  isSync = false;\n}\n\nvar constants$2 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nconst NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.');\r\nconst MAJOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);\r\nconst MINOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);\r\nconst SUPPORTED_MAJOR_VERSION = 10;\r\nconst SUPPORTED_MINOR_VERSION = 10;\r\nconst IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION;\r\nconst IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION;\r\n/**\r\n * IS `true` for Node.js 10.10 and greater.\r\n */\r\nexports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;\n});\n\nunwrapExports(constants$2);\nvar constants_1 = constants$2.IS_SUPPORT_READDIR_WITH_FILE_TYPES;\n\nvar fs$1 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nclass DirentFromStats {\r\n    constructor(name, stats) {\r\n        this.name = name;\r\n        this.isBlockDevice = stats.isBlockDevice.bind(stats);\r\n        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);\r\n        this.isDirectory = stats.isDirectory.bind(stats);\r\n        this.isFIFO = stats.isFIFO.bind(stats);\r\n        this.isFile = stats.isFile.bind(stats);\r\n        this.isSocket = stats.isSocket.bind(stats);\r\n        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);\r\n    }\r\n}\r\nfunction createDirentFromStats(name, stats) {\r\n    return new DirentFromStats(name, stats);\r\n}\r\nexports.createDirentFromStats = createDirentFromStats;\n});\n\nunwrapExports(fs$1);\nvar fs_1$2 = fs$1.createDirentFromStats;\n\nvar utils$6 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nexports.fs = fs$1;\n});\n\nunwrapExports(utils$6);\nvar utils_1$4 = utils$6.fs;\n\nvar async$2 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\n\r\n\r\nfunction read(directory, settings, callback) {\r\n    if (!settings.stats && constants$2.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {\r\n        return readdirWithFileTypes(directory, settings, callback);\r\n    }\r\n    return readdir(directory, settings, callback);\r\n}\r\nexports.read = read;\r\nfunction readdirWithFileTypes(directory, settings, callback) {\r\n    settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {\r\n        if (readdirError !== null) {\r\n            return callFailureCallback(callback, readdirError);\r\n        }\r\n        const entries = dirents.map((dirent) => ({\r\n            dirent,\r\n            name: dirent.name,\r\n            path: `${directory}${settings.pathSegmentSeparator}${dirent.name}`\r\n        }));\r\n        if (!settings.followSymbolicLinks) {\r\n            return callSuccessCallback(callback, entries);\r\n        }\r\n        const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));\r\n        runParallel_1(tasks, (rplError, rplEntries) => {\r\n            if (rplError !== null) {\r\n                return callFailureCallback(callback, rplError);\r\n            }\r\n            callSuccessCallback(callback, rplEntries);\r\n        });\r\n    });\r\n}\r\nexports.readdirWithFileTypes = readdirWithFileTypes;\r\nfunction makeRplTaskEntry(entry, settings) {\r\n    return (done) => {\r\n        if (!entry.dirent.isSymbolicLink()) {\r\n            return done(null, entry);\r\n        }\r\n        settings.fs.stat(entry.path, (statError, stats) => {\r\n            if (statError !== null) {\r\n                if (settings.throwErrorOnBrokenSymbolicLink) {\r\n                    return done(statError);\r\n                }\r\n                return done(null, entry);\r\n            }\r\n            entry.dirent = utils$6.fs.createDirentFromStats(entry.name, stats);\r\n            return done(null, entry);\r\n        });\r\n    };\r\n}\r\nfunction readdir(directory, settings, callback) {\r\n    settings.fs.readdir(directory, (readdirError, names) => {\r\n        if (readdirError !== null) {\r\n            return callFailureCallback(callback, readdirError);\r\n        }\r\n        const filepaths = names.map((name) => `${directory}${settings.pathSegmentSeparator}${name}`);\r\n        const tasks = filepaths.map((filepath) => {\r\n            return (done) => out.stat(filepath, settings.fsStatSettings, done);\r\n        });\r\n        runParallel_1(tasks, (rplError, results) => {\r\n            if (rplError !== null) {\r\n                return callFailureCallback(callback, rplError);\r\n            }\r\n            const entries = [];\r\n            names.forEach((name, index) => {\r\n                const stats = results[index];\r\n                const entry = {\r\n                    name,\r\n                    path: filepaths[index],\r\n                    dirent: utils$6.fs.createDirentFromStats(name, stats)\r\n                };\r\n                if (settings.stats) {\r\n                    entry.stats = stats;\r\n                }\r\n                entries.push(entry);\r\n            });\r\n            callSuccessCallback(callback, entries);\r\n        });\r\n    });\r\n}\r\nexports.readdir = readdir;\r\nfunction callFailureCallback(callback, error) {\r\n    callback(error);\r\n}\r\nfunction callSuccessCallback(callback, result) {\r\n    callback(null, result);\r\n}\n});\n\nunwrapExports(async$2);\nvar async_1$1 = async$2.read;\nvar async_2 = async$2.readdirWithFileTypes;\nvar async_3 = async$2.readdir;\n\nvar sync$2 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\n\r\nfunction read(directory, settings) {\r\n    if (!settings.stats && constants$2.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {\r\n        return readdirWithFileTypes(directory, settings);\r\n    }\r\n    return readdir(directory, settings);\r\n}\r\nexports.read = read;\r\nfunction readdirWithFileTypes(directory, settings) {\r\n    const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });\r\n    return dirents.map((dirent) => {\r\n        const entry = {\r\n            dirent,\r\n            name: dirent.name,\r\n            path: `${directory}${settings.pathSegmentSeparator}${dirent.name}`\r\n        };\r\n        if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) {\r\n            try {\r\n                const stats = settings.fs.statSync(entry.path);\r\n                entry.dirent = utils$6.fs.createDirentFromStats(entry.name, stats);\r\n            }\r\n            catch (error) {\r\n                if (settings.throwErrorOnBrokenSymbolicLink) {\r\n                    throw error;\r\n                }\r\n            }\r\n        }\r\n        return entry;\r\n    });\r\n}\r\nexports.readdirWithFileTypes = readdirWithFileTypes;\r\nfunction readdir(directory, settings) {\r\n    const names = settings.fs.readdirSync(directory);\r\n    return names.map((name) => {\r\n        const entryPath = `${directory}${settings.pathSegmentSeparator}${name}`;\r\n        const stats = out.statSync(entryPath, settings.fsStatSettings);\r\n        const entry = {\r\n            name,\r\n            path: entryPath,\r\n            dirent: utils$6.fs.createDirentFromStats(name, stats)\r\n        };\r\n        if (settings.stats) {\r\n            entry.stats = stats;\r\n        }\r\n        return entry;\r\n    });\r\n}\r\nexports.readdir = readdir;\n});\n\nunwrapExports(sync$2);\nvar sync_1$1 = sync$2.read;\nvar sync_2 = sync$2.readdirWithFileTypes;\nvar sync_3 = sync$2.readdir;\n\nvar fs_1$3 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nexports.FILE_SYSTEM_ADAPTER = {\r\n    lstat: fs$2.lstat,\r\n    stat: fs$2.stat,\r\n    lstatSync: fs$2.lstatSync,\r\n    statSync: fs$2.statSync,\r\n    readdir: fs$2.readdir,\r\n    readdirSync: fs$2.readdirSync\r\n};\r\nfunction createFileSystemAdapter(fsMethods) {\r\n    if (fsMethods === undefined) {\r\n        return exports.FILE_SYSTEM_ADAPTER;\r\n    }\r\n    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);\r\n}\r\nexports.createFileSystemAdapter = createFileSystemAdapter;\n});\n\nunwrapExports(fs_1$3);\nvar fs_2$1 = fs_1$3.FILE_SYSTEM_ADAPTER;\nvar fs_3$1 = fs_1$3.createFileSystemAdapter;\n\nvar settings$1 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\n\r\nclass Settings {\r\n    constructor(_options = {}) {\r\n        this._options = _options;\r\n        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);\r\n        this.fs = fs_1$3.createFileSystemAdapter(this._options.fs);\r\n        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$1.sep);\r\n        this.stats = this._getValue(this._options.stats, false);\r\n        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);\r\n        this.fsStatSettings = new out.Settings({\r\n            followSymbolicLink: this.followSymbolicLinks,\r\n            fs: this.fs,\r\n            throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink\r\n        });\r\n    }\r\n    _getValue(option, value) {\r\n        return option === undefined ? value : option;\r\n    }\r\n}\r\nexports.default = Settings;\n});\n\nunwrapExports(settings$1);\n\nvar out$1 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\n\r\nexports.Settings = settings$1.default;\r\nfunction scandir(path, optionsOrSettingsOrCallback, callback) {\r\n    if (typeof optionsOrSettingsOrCallback === 'function') {\r\n        return async$2.read(path, getSettings(), optionsOrSettingsOrCallback);\r\n    }\r\n    async$2.read(path, getSettings(optionsOrSettingsOrCallback), callback);\r\n}\r\nexports.scandir = scandir;\r\nfunction scandirSync(path, optionsOrSettings) {\r\n    const settings = getSettings(optionsOrSettings);\r\n    return sync$2.read(path, settings);\r\n}\r\nexports.scandirSync = scandirSync;\r\nfunction getSettings(settingsOrOptions = {}) {\r\n    if (settingsOrOptions instanceof settings$1.default) {\r\n        return settingsOrOptions;\r\n    }\r\n    return new settings$1.default(settingsOrOptions);\r\n}\n});\n\nunwrapExports(out$1);\nvar out_1$1 = out$1.Settings;\nvar out_2$1 = out$1.scandir;\nvar out_3$1 = out$1.scandirSync;\n\nfunction reusify (Constructor) {\n  var head = new Constructor();\n  var tail = head;\n\n  function get () {\n    var current = head;\n\n    if (current.next) {\n      head = current.next;\n    } else {\n      head = new Constructor();\n      tail = head;\n    }\n\n    current.next = null;\n\n    return current\n  }\n\n  function release (obj) {\n    tail.next = obj;\n    tail = obj;\n  }\n\n  return {\n    get: get,\n    release: release\n  }\n}\n\nvar reusify_1 = reusify;\n\nfunction fastqueue (context, worker, concurrency) {\n  if (typeof context === 'function') {\n    concurrency = worker;\n    worker = context;\n    context = null;\n  }\n\n  var cache = reusify_1(Task);\n  var queueHead = null;\n  var queueTail = null;\n  var _running = 0;\n\n  var self = {\n    push: push,\n    drain: noop$3,\n    saturated: noop$3,\n    pause: pause,\n    paused: false,\n    concurrency: concurrency,\n    running: running,\n    resume: resume,\n    idle: idle,\n    length: length,\n    getQueue: getQueue,\n    unshift: unshift,\n    empty: noop$3,\n    kill: kill,\n    killAndDrain: killAndDrain\n  };\n\n  return self\n\n  function running () {\n    return _running\n  }\n\n  function pause () {\n    self.paused = true;\n  }\n\n  function length () {\n    var current = queueHead;\n    var counter = 0;\n\n    while (current) {\n      current = current.next;\n      counter++;\n    }\n\n    return counter\n  }\n\n  function getQueue () {\n    var current = queueHead;\n    var tasks = [];\n\n    while (current) {\n      tasks.push(current.value);\n      current = current.next;\n    }\n\n    return tasks\n  }\n\n  function resume () {\n    if (!self.paused) return\n    self.paused = false;\n    for (var i = 0; i < self.concurrency; i++) {\n      _running++;\n      release();\n    }\n  }\n\n  function idle () {\n    return _running === 0 && self.length() === 0\n  }\n\n  function push (value, done) {\n    var current = cache.get();\n\n    current.context = context;\n    current.release = release;\n    current.value = value;\n    current.callback = done || noop$3;\n\n    if (_running === self.concurrency || self.paused) {\n      if (queueTail) {\n        queueTail.next = current;\n        queueTail = current;\n      } else {\n        queueHead = current;\n        queueTail = current;\n        self.saturated();\n      }\n    } else {\n      _running++;\n      worker.call(context, current.value, current.worked);\n    }\n  }\n\n  function unshift (value, done) {\n    var current = cache.get();\n\n    current.context = context;\n    current.release = release;\n    current.value = value;\n    current.callback = done || noop$3;\n\n    if (_running === self.concurrency || self.paused) {\n      if (queueHead) {\n        current.next = queueHead;\n        queueHead = current;\n      } else {\n        queueHead = current;\n        queueTail = current;\n        self.saturated();\n      }\n    } else {\n      _running++;\n      worker.call(context, current.value, current.worked);\n    }\n  }\n\n  function release (holder) {\n    if (holder) {\n      cache.release(holder);\n    }\n    var next = queueHead;\n    if (next) {\n      if (!self.paused) {\n        if (queueTail === queueHead) {\n          queueTail = null;\n        }\n        queueHead = next.next;\n        next.next = null;\n        worker.call(context, next.value, next.worked);\n        if (queueTail === null) {\n          self.empty();\n        }\n      } else {\n        _running--;\n      }\n    } else if (--_running === 0) {\n      self.drain();\n    }\n  }\n\n  function kill () {\n    queueHead = null;\n    queueTail = null;\n    self.drain = noop$3;\n  }\n\n  function killAndDrain () {\n    queueHead = null;\n    queueTail = null;\n    self.drain();\n    self.drain = noop$3;\n  }\n}\n\nfunction noop$3 () {}\n\nfunction Task () {\n  this.value = null;\n  this.callback = noop$3;\n  this.next = null;\n  this.release = noop$3;\n  this.context = null;\n\n  var self = this;\n\n  this.worked = function worked (err, result) {\n    var callback = self.callback;\n    self.value = null;\n    self.callback = noop$3;\n    callback.call(self.context, err, result);\n    self.release(self);\n  };\n}\n\nvar queue = fastqueue;\n\nvar common$3 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nfunction isFatalError(settings, error) {\r\n    if (settings.errorFilter === null) {\r\n        return true;\r\n    }\r\n    return !settings.errorFilter(error);\r\n}\r\nexports.isFatalError = isFatalError;\r\nfunction isAppliedFilter(filter, value) {\r\n    return filter === null || filter(value);\r\n}\r\nexports.isAppliedFilter = isAppliedFilter;\r\nfunction replacePathSegmentSeparator(filepath, separator) {\r\n    return filepath.split(/[\\\\/]/).join(separator);\r\n}\r\nexports.replacePathSegmentSeparator = replacePathSegmentSeparator;\r\nfunction joinPathSegments(a, b, separator) {\r\n    if (a === '') {\r\n        return b;\r\n    }\r\n    return a + separator + b;\r\n}\r\nexports.joinPathSegments = joinPathSegments;\n});\n\nunwrapExports(common$3);\nvar common_1 = common$3.isFatalError;\nvar common_2 = common$3.isAppliedFilter;\nvar common_3 = common$3.replacePathSegmentSeparator;\nvar common_4 = common$3.joinPathSegments;\n\nvar reader = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nclass Reader {\r\n    constructor(_root, _settings) {\r\n        this._root = _root;\r\n        this._settings = _settings;\r\n        this._root = common$3.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);\r\n    }\r\n}\r\nexports.default = Reader;\n});\n\nunwrapExports(reader);\n\nvar async$3 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\n\r\n\r\n\r\nclass AsyncReader extends reader.default {\r\n    constructor(_root, _settings) {\r\n        super(_root, _settings);\r\n        this._settings = _settings;\r\n        this._scandir = out$1.scandir;\r\n        this._emitter = new events.EventEmitter();\r\n        this._queue = queue(this._worker.bind(this), this._settings.concurrency);\r\n        this._isFatalError = false;\r\n        this._isDestroyed = false;\r\n        this._queue.drain = () => {\r\n            if (!this._isFatalError) {\r\n                this._emitter.emit('end');\r\n            }\r\n        };\r\n    }\r\n    read() {\r\n        this._isFatalError = false;\r\n        this._isDestroyed = false;\r\n        setImmediate(() => {\r\n            this._pushToQueue(this._root, this._settings.basePath);\r\n        });\r\n        return this._emitter;\r\n    }\r\n    destroy() {\r\n        if (this._isDestroyed) {\r\n            throw new Error('The reader is already destroyed');\r\n        }\r\n        this._isDestroyed = true;\r\n        this._queue.killAndDrain();\r\n    }\r\n    onEntry(callback) {\r\n        this._emitter.on('entry', callback);\r\n    }\r\n    onError(callback) {\r\n        this._emitter.once('error', callback);\r\n    }\r\n    onEnd(callback) {\r\n        this._emitter.once('end', callback);\r\n    }\r\n    _pushToQueue(directory, base) {\r\n        const queueItem = { directory, base };\r\n        this._queue.push(queueItem, (error) => {\r\n            if (error !== null) {\r\n                this._handleError(error);\r\n            }\r\n        });\r\n    }\r\n    _worker(item, done) {\r\n        this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => {\r\n            if (error !== null) {\r\n                return done(error, undefined);\r\n            }\r\n            for (const entry of entries) {\r\n                this._handleEntry(entry, item.base);\r\n            }\r\n            done(null, undefined);\r\n        });\r\n    }\r\n    _handleError(error) {\r\n        if (!common$3.isFatalError(this._settings, error)) {\r\n            return;\r\n        }\r\n        this._isFatalError = true;\r\n        this._isDestroyed = true;\r\n        this._emitter.emit('error', error);\r\n    }\r\n    _handleEntry(entry, base) {\r\n        if (this._isDestroyed || this._isFatalError) {\r\n            return;\r\n        }\r\n        const fullpath = entry.path;\r\n        if (base !== undefined) {\r\n            entry.path = common$3.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);\r\n        }\r\n        if (common$3.isAppliedFilter(this._settings.entryFilter, entry)) {\r\n            this._emitEntry(entry);\r\n        }\r\n        if (entry.dirent.isDirectory() && common$3.isAppliedFilter(this._settings.deepFilter, entry)) {\r\n            this._pushToQueue(fullpath, entry.path);\r\n        }\r\n    }\r\n    _emitEntry(entry) {\r\n        this._emitter.emit('entry', entry);\r\n    }\r\n}\r\nexports.default = AsyncReader;\n});\n\nunwrapExports(async$3);\n\nvar async$4 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nclass AsyncProvider {\r\n    constructor(_root, _settings) {\r\n        this._root = _root;\r\n        this._settings = _settings;\r\n        this._reader = new async$3.default(this._root, this._settings);\r\n        this._storage = new Set();\r\n    }\r\n    read(callback) {\r\n        this._reader.onError((error) => {\r\n            callFailureCallback(callback, error);\r\n        });\r\n        this._reader.onEntry((entry) => {\r\n            this._storage.add(entry);\r\n        });\r\n        this._reader.onEnd(() => {\r\n            callSuccessCallback(callback, [...this._storage]);\r\n        });\r\n        this._reader.read();\r\n    }\r\n}\r\nexports.default = AsyncProvider;\r\nfunction callFailureCallback(callback, error) {\r\n    callback(error);\r\n}\r\nfunction callSuccessCallback(callback, entries) {\r\n    callback(null, entries);\r\n}\n});\n\nunwrapExports(async$4);\n\nvar stream$1 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\nclass StreamProvider {\r\n    constructor(_root, _settings) {\r\n        this._root = _root;\r\n        this._settings = _settings;\r\n        this._reader = new async$3.default(this._root, this._settings);\r\n        this._stream = new stream$4.Readable({\r\n            objectMode: true,\r\n            read: () => { },\r\n            destroy: this._reader.destroy.bind(this._reader)\r\n        });\r\n    }\r\n    read() {\r\n        this._reader.onError((error) => {\r\n            this._stream.emit('error', error);\r\n        });\r\n        this._reader.onEntry((entry) => {\r\n            this._stream.push(entry);\r\n        });\r\n        this._reader.onEnd(() => {\r\n            this._stream.push(null);\r\n        });\r\n        this._reader.read();\r\n        return this._stream;\r\n    }\r\n}\r\nexports.default = StreamProvider;\n});\n\nunwrapExports(stream$1);\n\nvar sync$3 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\n\r\nclass SyncReader extends reader.default {\r\n    constructor() {\r\n        super(...arguments);\r\n        this._scandir = out$1.scandirSync;\r\n        this._storage = new Set();\r\n        this._queue = new Set();\r\n    }\r\n    read() {\r\n        this._pushToQueue(this._root, this._settings.basePath);\r\n        this._handleQueue();\r\n        return [...this._storage];\r\n    }\r\n    _pushToQueue(directory, base) {\r\n        this._queue.add({ directory, base });\r\n    }\r\n    _handleQueue() {\r\n        for (const item of this._queue.values()) {\r\n            this._handleDirectory(item.directory, item.base);\r\n        }\r\n    }\r\n    _handleDirectory(directory, base) {\r\n        try {\r\n            const entries = this._scandir(directory, this._settings.fsScandirSettings);\r\n            for (const entry of entries) {\r\n                this._handleEntry(entry, base);\r\n            }\r\n        }\r\n        catch (error) {\r\n            this._handleError(error);\r\n        }\r\n    }\r\n    _handleError(error) {\r\n        if (!common$3.isFatalError(this._settings, error)) {\r\n            return;\r\n        }\r\n        throw error;\r\n    }\r\n    _handleEntry(entry, base) {\r\n        const fullpath = entry.path;\r\n        if (base !== undefined) {\r\n            entry.path = common$3.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);\r\n        }\r\n        if (common$3.isAppliedFilter(this._settings.entryFilter, entry)) {\r\n            this._pushToStorage(entry);\r\n        }\r\n        if (entry.dirent.isDirectory() && common$3.isAppliedFilter(this._settings.deepFilter, entry)) {\r\n            this._pushToQueue(fullpath, entry.path);\r\n        }\r\n    }\r\n    _pushToStorage(entry) {\r\n        this._storage.add(entry);\r\n    }\r\n}\r\nexports.default = SyncReader;\n});\n\nunwrapExports(sync$3);\n\nvar sync$4 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nclass SyncProvider {\r\n    constructor(_root, _settings) {\r\n        this._root = _root;\r\n        this._settings = _settings;\r\n        this._reader = new sync$3.default(this._root, this._settings);\r\n    }\r\n    read() {\r\n        return this._reader.read();\r\n    }\r\n}\r\nexports.default = SyncProvider;\n});\n\nunwrapExports(sync$4);\n\nvar settings$2 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\nclass Settings {\r\n    constructor(_options = {}) {\r\n        this._options = _options;\r\n        this.basePath = this._getValue(this._options.basePath, undefined);\r\n        this.concurrency = this._getValue(this._options.concurrency, Infinity);\r\n        this.deepFilter = this._getValue(this._options.deepFilter, null);\r\n        this.entryFilter = this._getValue(this._options.entryFilter, null);\r\n        this.errorFilter = this._getValue(this._options.errorFilter, null);\r\n        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$1.sep);\r\n        this.fsScandirSettings = new out$1.Settings({\r\n            followSymbolicLinks: this._options.followSymbolicLinks,\r\n            fs: this._options.fs,\r\n            pathSegmentSeparator: this._options.pathSegmentSeparator,\r\n            stats: this._options.stats,\r\n            throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink\r\n        });\r\n    }\r\n    _getValue(option, value) {\r\n        return option === undefined ? value : option;\r\n    }\r\n}\r\nexports.default = Settings;\n});\n\nunwrapExports(settings$2);\n\nvar out$2 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\n\r\n\r\nexports.Settings = settings$2.default;\r\nfunction walk(directory, optionsOrSettingsOrCallback, callback) {\r\n    if (typeof optionsOrSettingsOrCallback === 'function') {\r\n        return new async$4.default(directory, getSettings()).read(optionsOrSettingsOrCallback);\r\n    }\r\n    new async$4.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);\r\n}\r\nexports.walk = walk;\r\nfunction walkSync(directory, optionsOrSettings) {\r\n    const settings = getSettings(optionsOrSettings);\r\n    const provider = new sync$4.default(directory, settings);\r\n    return provider.read();\r\n}\r\nexports.walkSync = walkSync;\r\nfunction walkStream(directory, optionsOrSettings) {\r\n    const settings = getSettings(optionsOrSettings);\r\n    const provider = new stream$1.default(directory, settings);\r\n    return provider.read();\r\n}\r\nexports.walkStream = walkStream;\r\nfunction getSettings(settingsOrOptions = {}) {\r\n    if (settingsOrOptions instanceof settings$2.default) {\r\n        return settingsOrOptions;\r\n    }\r\n    return new settings$2.default(settingsOrOptions);\r\n}\n});\n\nunwrapExports(out$2);\nvar out_1$2 = out$2.Settings;\nvar out_2$2 = out$2.walk;\nvar out_3$2 = out$2.walkSync;\nvar out_4 = out$2.walkStream;\n\nvar reader$1 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\n\r\nclass Reader {\r\n    constructor(_settings) {\r\n        this._settings = _settings;\r\n        this._fsStatSettings = new out.Settings({\r\n            followSymbolicLink: this._settings.followSymbolicLinks,\r\n            fs: this._settings.fs,\r\n            throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks\r\n        });\r\n    }\r\n    _getFullEntryPath(filepath) {\r\n        return path$1.resolve(this._settings.cwd, filepath);\r\n    }\r\n    _makeEntry(stats, pattern) {\r\n        const entry = {\r\n            name: pattern,\r\n            path: pattern,\r\n            dirent: utils$5.fs.createDirentFromStats(pattern, stats)\r\n        };\r\n        if (this._settings.stats) {\r\n            entry.stats = stats;\r\n        }\r\n        return entry;\r\n    }\r\n    _isFatalError(error) {\r\n        return !utils$5.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;\r\n    }\r\n}\r\nexports.default = Reader;\n});\n\nunwrapExports(reader$1);\n\nvar stream$2 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\n\r\n\r\nclass ReaderStream extends reader$1.default {\r\n    constructor() {\r\n        super(...arguments);\r\n        this._walkStream = out$2.walkStream;\r\n        this._stat = out.stat;\r\n    }\r\n    dynamic(root, options) {\r\n        return this._walkStream(root, options);\r\n    }\r\n    static(patterns, options) {\r\n        const filepaths = patterns.map(this._getFullEntryPath, this);\r\n        const stream = new stream$4.PassThrough({ objectMode: true });\r\n        stream._write = (index, _enc, done) => {\r\n            return this._getEntry(filepaths[index], patterns[index], options)\r\n                .then((entry) => {\r\n                if (entry !== null && options.entryFilter(entry)) {\r\n                    stream.push(entry);\r\n                }\r\n                if (index === filepaths.length - 1) {\r\n                    stream.end();\r\n                }\r\n                done();\r\n            })\r\n                .catch(done);\r\n        };\r\n        for (let i = 0; i < filepaths.length; i++) {\r\n            stream.write(i);\r\n        }\r\n        return stream;\r\n    }\r\n    _getEntry(filepath, pattern, options) {\r\n        return this._getStat(filepath)\r\n            .then((stats) => this._makeEntry(stats, pattern))\r\n            .catch((error) => {\r\n            if (options.errorFilter(error)) {\r\n                return null;\r\n            }\r\n            throw error;\r\n        });\r\n    }\r\n    _getStat(filepath) {\r\n        return new Promise((resolve, reject) => {\r\n            this._stat(filepath, this._fsStatSettings, (error, stats) => {\r\n                return error === null ? resolve(stats) : reject(error);\r\n            });\r\n        });\r\n    }\r\n}\r\nexports.default = ReaderStream;\n});\n\nunwrapExports(stream$2);\n\nvar matcher = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nclass Matcher {\r\n    constructor(_patterns, _settings, _micromatchOptions) {\r\n        this._patterns = _patterns;\r\n        this._settings = _settings;\r\n        this._micromatchOptions = _micromatchOptions;\r\n        this._storage = [];\r\n        this._fillStorage();\r\n    }\r\n    _fillStorage() {\r\n        /**\r\n         * The original pattern may include `{,*,**,a/*}`, which will lead to problems with matching (unresolved level).\r\n         * So, before expand patterns with brace expansion into separated patterns.\r\n         */\r\n        const patterns = utils$5.pattern.expandPatternsWithBraceExpansion(this._patterns);\r\n        for (const pattern of patterns) {\r\n            const segments = this._getPatternSegments(pattern);\r\n            const sections = this._splitSegmentsIntoSections(segments);\r\n            this._storage.push({\r\n                complete: sections.length <= 1,\r\n                pattern,\r\n                segments,\r\n                sections\r\n            });\r\n        }\r\n    }\r\n    _getPatternSegments(pattern) {\r\n        const parts = utils$5.pattern.getPatternParts(pattern, this._micromatchOptions);\r\n        return parts.map((part) => {\r\n            const dynamic = utils$5.pattern.isDynamicPattern(part, this._settings);\r\n            if (!dynamic) {\r\n                return {\r\n                    dynamic: false,\r\n                    pattern: part\r\n                };\r\n            }\r\n            return {\r\n                dynamic: true,\r\n                pattern: part,\r\n                patternRe: utils$5.pattern.makeRe(part, this._micromatchOptions)\r\n            };\r\n        });\r\n    }\r\n    _splitSegmentsIntoSections(segments) {\r\n        return utils$5.array.splitWhen(segments, (segment) => segment.dynamic && utils$5.pattern.hasGlobStar(segment.pattern));\r\n    }\r\n}\r\nexports.default = Matcher;\n});\n\nunwrapExports(matcher);\n\nvar partial = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nclass PartialMatcher extends matcher.default {\r\n    match(filepath) {\r\n        const parts = filepath.split('/');\r\n        const levels = parts.length;\r\n        const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);\r\n        for (const pattern of patterns) {\r\n            const section = pattern.sections[0];\r\n            /**\r\n             * In this case, the pattern has a globstar and we must read all directories unconditionally,\r\n             * but only if the level has reached the end of the first group.\r\n             *\r\n             * fixtures/{a,b}/**\r\n             *  ^ true/false  ^ always true\r\n            */\r\n            if (!pattern.complete && levels > section.length) {\r\n                return true;\r\n            }\r\n            const match = parts.every((part, index) => {\r\n                const segment = pattern.segments[index];\r\n                if (segment.dynamic && segment.patternRe.test(part)) {\r\n                    return true;\r\n                }\r\n                if (!segment.dynamic && segment.pattern === part) {\r\n                    return true;\r\n                }\r\n                return false;\r\n            });\r\n            if (match) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n}\r\nexports.default = PartialMatcher;\n});\n\nunwrapExports(partial);\n\nvar deep = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\nclass DeepFilter {\r\n    constructor(_settings, _micromatchOptions) {\r\n        this._settings = _settings;\r\n        this._micromatchOptions = _micromatchOptions;\r\n    }\r\n    getFilter(basePath, positive, negative) {\r\n        const matcher = this._getMatcher(positive);\r\n        const negativeRe = this._getNegativePatternsRe(negative);\r\n        return (entry) => this._filter(basePath, entry, matcher, negativeRe);\r\n    }\r\n    _getMatcher(patterns) {\r\n        return new partial.default(patterns, this._settings, this._micromatchOptions);\r\n    }\r\n    _getNegativePatternsRe(patterns) {\r\n        const affectDepthOfReadingPatterns = patterns.filter(utils$5.pattern.isAffectDepthOfReadingPattern);\r\n        return utils$5.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);\r\n    }\r\n    _filter(basePath, entry, matcher, negativeRe) {\r\n        const depth = this._getEntryLevel(basePath, entry.path);\r\n        if (this._isSkippedByDeep(depth)) {\r\n            return false;\r\n        }\r\n        if (this._isSkippedSymbolicLink(entry)) {\r\n            return false;\r\n        }\r\n        const filepath = utils$5.path.removeLeadingDotSegment(entry.path);\r\n        if (this._isSkippedByPositivePatterns(filepath, matcher)) {\r\n            return false;\r\n        }\r\n        return this._isSkippedByNegativePatterns(filepath, negativeRe);\r\n    }\r\n    _isSkippedByDeep(entryDepth) {\r\n        return entryDepth >= this._settings.deep;\r\n    }\r\n    _isSkippedSymbolicLink(entry) {\r\n        return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();\r\n    }\r\n    _getEntryLevel(basePath, entryPath) {\r\n        const basePathDepth = basePath.split('/').length;\r\n        const entryPathDepth = entryPath.split('/').length;\r\n        return entryPathDepth - (basePath === '' ? 0 : basePathDepth);\r\n    }\r\n    _isSkippedByPositivePatterns(entryPath, matcher) {\r\n        return !this._settings.baseNameMatch && !matcher.match(entryPath);\r\n    }\r\n    _isSkippedByNegativePatterns(entryPath, negativeRe) {\r\n        return !utils$5.pattern.matchAny(entryPath, negativeRe);\r\n    }\r\n}\r\nexports.default = DeepFilter;\n});\n\nunwrapExports(deep);\n\nvar entry = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nclass EntryFilter {\r\n    constructor(_settings, _micromatchOptions) {\r\n        this._settings = _settings;\r\n        this._micromatchOptions = _micromatchOptions;\r\n        this.index = new Map();\r\n    }\r\n    getFilter(positive, negative) {\r\n        const positiveRe = utils$5.pattern.convertPatternsToRe(positive, this._micromatchOptions);\r\n        const negativeRe = utils$5.pattern.convertPatternsToRe(negative, this._micromatchOptions);\r\n        return (entry) => this._filter(entry, positiveRe, negativeRe);\r\n    }\r\n    _filter(entry, positiveRe, negativeRe) {\r\n        if (this._settings.unique) {\r\n            if (this._isDuplicateEntry(entry)) {\r\n                return false;\r\n            }\r\n            this._createIndexRecord(entry);\r\n        }\r\n        if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {\r\n            return false;\r\n        }\r\n        if (this._isSkippedByAbsoluteNegativePatterns(entry, negativeRe)) {\r\n            return false;\r\n        }\r\n        const filepath = this._settings.baseNameMatch ? entry.name : entry.path;\r\n        return this._isMatchToPatterns(filepath, positiveRe) && !this._isMatchToPatterns(entry.path, negativeRe);\r\n    }\r\n    _isDuplicateEntry(entry) {\r\n        return this.index.has(entry.path);\r\n    }\r\n    _createIndexRecord(entry) {\r\n        this.index.set(entry.path, undefined);\r\n    }\r\n    _onlyFileFilter(entry) {\r\n        return this._settings.onlyFiles && !entry.dirent.isFile();\r\n    }\r\n    _onlyDirectoryFilter(entry) {\r\n        return this._settings.onlyDirectories && !entry.dirent.isDirectory();\r\n    }\r\n    _isSkippedByAbsoluteNegativePatterns(entry, negativeRe) {\r\n        if (!this._settings.absolute) {\r\n            return false;\r\n        }\r\n        const fullpath = utils$5.path.makeAbsolute(this._settings.cwd, entry.path);\r\n        return this._isMatchToPatterns(fullpath, negativeRe);\r\n    }\r\n    _isMatchToPatterns(entryPath, patternsRe) {\r\n        const filepath = utils$5.path.removeLeadingDotSegment(entryPath);\r\n        return utils$5.pattern.matchAny(filepath, patternsRe);\r\n    }\r\n}\r\nexports.default = EntryFilter;\n});\n\nunwrapExports(entry);\n\nvar error = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nclass ErrorFilter {\r\n    constructor(_settings) {\r\n        this._settings = _settings;\r\n    }\r\n    getFilter() {\r\n        return (error) => this._isNonFatalError(error);\r\n    }\r\n    _isNonFatalError(error) {\r\n        return utils$5.errno.isEnoentCodeError(error) || this._settings.suppressErrors;\r\n    }\r\n}\r\nexports.default = ErrorFilter;\n});\n\nunwrapExports(error);\n\nvar entry$1 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\nclass EntryTransformer {\r\n    constructor(_settings) {\r\n        this._settings = _settings;\r\n    }\r\n    getTransformer() {\r\n        return (entry) => this._transform(entry);\r\n    }\r\n    _transform(entry) {\r\n        let filepath = entry.path;\r\n        if (this._settings.absolute) {\r\n            filepath = utils$5.path.makeAbsolute(this._settings.cwd, filepath);\r\n            filepath = utils$5.path.unixify(filepath);\r\n        }\r\n        if (this._settings.markDirectories && entry.dirent.isDirectory()) {\r\n            filepath += '/';\r\n        }\r\n        if (!this._settings.objectMode) {\r\n            return filepath;\r\n        }\r\n        return Object.assign(Object.assign({}, entry), { path: filepath });\r\n    }\r\n}\r\nexports.default = EntryTransformer;\n});\n\nunwrapExports(entry$1);\n\nvar provider = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\n\r\n\r\n\r\nclass Provider {\r\n    constructor(_settings) {\r\n        this._settings = _settings;\r\n        this.errorFilter = new error.default(this._settings);\r\n        this.entryFilter = new entry.default(this._settings, this._getMicromatchOptions());\r\n        this.deepFilter = new deep.default(this._settings, this._getMicromatchOptions());\r\n        this.entryTransformer = new entry$1.default(this._settings);\r\n    }\r\n    _getRootDirectory(task) {\r\n        return path$1.resolve(this._settings.cwd, task.base);\r\n    }\r\n    _getReaderOptions(task) {\r\n        const basePath = task.base === '.' ? '' : task.base;\r\n        return {\r\n            basePath,\r\n            pathSegmentSeparator: '/',\r\n            concurrency: this._settings.concurrency,\r\n            deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),\r\n            entryFilter: this.entryFilter.getFilter(task.positive, task.negative),\r\n            errorFilter: this.errorFilter.getFilter(),\r\n            followSymbolicLinks: this._settings.followSymbolicLinks,\r\n            fs: this._settings.fs,\r\n            stats: this._settings.stats,\r\n            throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,\r\n            transform: this.entryTransformer.getTransformer()\r\n        };\r\n    }\r\n    _getMicromatchOptions() {\r\n        return {\r\n            dot: this._settings.dot,\r\n            matchBase: this._settings.baseNameMatch,\r\n            nobrace: !this._settings.braceExpansion,\r\n            nocase: !this._settings.caseSensitiveMatch,\r\n            noext: !this._settings.extglob,\r\n            noglobstar: !this._settings.globstar,\r\n            posix: true,\r\n            strictSlashes: false\r\n        };\r\n    }\r\n}\r\nexports.default = Provider;\n});\n\nunwrapExports(provider);\n\nvar async$5 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\nclass ProviderAsync extends provider.default {\r\n    constructor() {\r\n        super(...arguments);\r\n        this._reader = new stream$2.default(this._settings);\r\n    }\r\n    read(task) {\r\n        const root = this._getRootDirectory(task);\r\n        const options = this._getReaderOptions(task);\r\n        const entries = [];\r\n        return new Promise((resolve, reject) => {\r\n            const stream = this.api(root, task, options);\r\n            stream.once('error', reject);\r\n            stream.on('data', (entry) => entries.push(options.transform(entry)));\r\n            stream.once('end', () => resolve(entries));\r\n        });\r\n    }\r\n    api(root, task, options) {\r\n        if (task.dynamic) {\r\n            return this._reader.dynamic(root, options);\r\n        }\r\n        return this._reader.static(task.patterns, options);\r\n    }\r\n}\r\nexports.default = ProviderAsync;\n});\n\nunwrapExports(async$5);\n\nvar stream$3 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\n\r\nclass ProviderStream extends provider.default {\r\n    constructor() {\r\n        super(...arguments);\r\n        this._reader = new stream$2.default(this._settings);\r\n    }\r\n    read(task) {\r\n        const root = this._getRootDirectory(task);\r\n        const options = this._getReaderOptions(task);\r\n        const source = this.api(root, task, options);\r\n        const destination = new stream$4.Readable({ objectMode: true, read: () => { } });\r\n        source\r\n            .once('error', (error) => destination.emit('error', error))\r\n            .on('data', (entry) => destination.emit('data', options.transform(entry)))\r\n            .once('end', () => destination.emit('end'));\r\n        destination\r\n            .once('close', () => source.destroy());\r\n        return destination;\r\n    }\r\n    api(root, task, options) {\r\n        if (task.dynamic) {\r\n            return this._reader.dynamic(root, options);\r\n        }\r\n        return this._reader.static(task.patterns, options);\r\n    }\r\n}\r\nexports.default = ProviderStream;\n});\n\nunwrapExports(stream$3);\n\nvar sync$5 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\n\r\nclass ReaderSync extends reader$1.default {\r\n    constructor() {\r\n        super(...arguments);\r\n        this._walkSync = out$2.walkSync;\r\n        this._statSync = out.statSync;\r\n    }\r\n    dynamic(root, options) {\r\n        return this._walkSync(root, options);\r\n    }\r\n    static(patterns, options) {\r\n        const entries = [];\r\n        for (const pattern of patterns) {\r\n            const filepath = this._getFullEntryPath(pattern);\r\n            const entry = this._getEntry(filepath, pattern, options);\r\n            if (entry === null || !options.entryFilter(entry)) {\r\n                continue;\r\n            }\r\n            entries.push(entry);\r\n        }\r\n        return entries;\r\n    }\r\n    _getEntry(filepath, pattern, options) {\r\n        try {\r\n            const stats = this._getStat(filepath);\r\n            return this._makeEntry(stats, pattern);\r\n        }\r\n        catch (error) {\r\n            if (options.errorFilter(error)) {\r\n                return null;\r\n            }\r\n            throw error;\r\n        }\r\n    }\r\n    _getStat(filepath) {\r\n        return this._statSync(filepath, this._fsStatSettings);\r\n    }\r\n}\r\nexports.default = ReaderSync;\n});\n\nunwrapExports(sync$5);\n\nvar sync$6 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\nclass ProviderSync extends provider.default {\r\n    constructor() {\r\n        super(...arguments);\r\n        this._reader = new sync$5.default(this._settings);\r\n    }\r\n    read(task) {\r\n        const root = this._getRootDirectory(task);\r\n        const options = this._getReaderOptions(task);\r\n        const entries = this.api(root, task, options);\r\n        return entries.map(options.transform);\r\n    }\r\n    api(root, task, options) {\r\n        if (task.dynamic) {\r\n            return this._reader.dynamic(root, options);\r\n        }\r\n        return this._reader.static(task.patterns, options);\r\n    }\r\n}\r\nexports.default = ProviderSync;\n});\n\nunwrapExports(sync$6);\n\nvar settings$3 = createCommonjsModule(function (module, exports) {\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n\r\n\r\nconst CPU_COUNT = os.cpus().length;\r\nexports.DEFAULT_FILE_SYSTEM_ADAPTER = {\r\n    lstat: fs$2.lstat,\r\n    lstatSync: fs$2.lstatSync,\r\n    stat: fs$2.stat,\r\n    statSync: fs$2.statSync,\r\n    readdir: fs$2.readdir,\r\n    readdirSync: fs$2.readdirSync\r\n};\r\nclass Settings {\r\n    constructor(_options = {}) {\r\n        this._options = _options;\r\n        this.absolute = this._getValue(this._options.absolute, false);\r\n        this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);\r\n        this.braceExpansion = this._getValue(this._options.braceExpansion, true);\r\n        this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);\r\n        this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);\r\n        this.cwd = this._getValue(this._options.cwd, process.cwd());\r\n        this.deep = this._getValue(this._options.deep, Infinity);\r\n        this.dot = this._getValue(this._options.dot, false);\r\n        this.extglob = this._getValue(this._options.extglob, true);\r\n        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);\r\n        this.fs = this._getFileSystemMethods(this._options.fs);\r\n        this.globstar = this._getValue(this._options.globstar, true);\r\n        this.ignore = this._getValue(this._options.ignore, []);\r\n        this.markDirectories = this._getValue(this._options.markDirectories, false);\r\n        this.objectMode = this._getValue(this._options.objectMode, false);\r\n        this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);\r\n        this.onlyFiles = this._getValue(this._options.onlyFiles, true);\r\n        this.stats = this._getValue(this._options.stats, false);\r\n        this.suppressErrors = this._getValue(this._options.suppressErrors, false);\r\n        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);\r\n        this.unique = this._getValue(this._options.unique, true);\r\n        if (this.onlyDirectories) {\r\n            this.onlyFiles = false;\r\n        }\r\n        if (this.stats) {\r\n            this.objectMode = true;\r\n        }\r\n    }\r\n    _getValue(option, value) {\r\n        return option === undefined ? value : option;\r\n    }\r\n    _getFileSystemMethods(methods = {}) {\r\n        return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods);\r\n    }\r\n}\r\nexports.default = Settings;\n});\n\nunwrapExports(settings$3);\nvar settings_1 = settings$3.DEFAULT_FILE_SYSTEM_ADAPTER;\n\nasync function FastGlob(source, options) {\r\n    assertPatternsInput(source);\r\n    const works = getWorks(source, async$5.default, options);\r\n    const result = await Promise.all(works);\r\n    return utils$5.array.flatten(result);\r\n}\r\n// https://github.com/typescript-eslint/typescript-eslint/issues/60\r\n// eslint-disable-next-line no-redeclare\r\n(function (FastGlob) {\r\n    function sync(source, options) {\r\n        assertPatternsInput(source);\r\n        const works = getWorks(source, sync$6.default, options);\r\n        return utils$5.array.flatten(works);\r\n    }\r\n    FastGlob.sync = sync;\r\n    function stream(source, options) {\r\n        assertPatternsInput(source);\r\n        const works = getWorks(source, stream$3.default, options);\r\n        /**\r\n         * The stream returned by the provider cannot work with an asynchronous iterator.\r\n         * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.\r\n         * This affects performance (+25%). I don't see best solution right now.\r\n         */\r\n        return utils$5.stream.merge(works);\r\n    }\r\n    FastGlob.stream = stream;\r\n    function generateTasks(source, options) {\r\n        assertPatternsInput(source);\r\n        const patterns = [].concat(source);\r\n        const settings = new settings$3.default(options);\r\n        return tasks.generate(patterns, settings);\r\n    }\r\n    FastGlob.generateTasks = generateTasks;\r\n    function isDynamicPattern(source, options) {\r\n        assertPatternsInput(source);\r\n        const settings = new settings$3.default(options);\r\n        return utils$5.pattern.isDynamicPattern(source, settings);\r\n    }\r\n    FastGlob.isDynamicPattern = isDynamicPattern;\r\n    function escapePath(source) {\r\n        assertPatternsInput(source);\r\n        return utils$5.path.escape(source);\r\n    }\r\n    FastGlob.escapePath = escapePath;\r\n})(FastGlob || (FastGlob = {}));\r\nfunction getWorks(source, _Provider, options) {\r\n    const patterns = [].concat(source);\r\n    const settings = new settings$3.default(options);\r\n    const tasks$1 = tasks.generate(patterns, settings);\r\n    const provider = new _Provider(settings);\r\n    return tasks$1.map(provider.read, provider);\r\n}\r\nfunction assertPatternsInput(input) {\r\n    const source = [].concat(input);\r\n    const isValidSource = source.every((item) => utils$5.string.isString(item) && !utils$5.string.isEmpty(item));\r\n    if (!isValidSource) {\r\n        throw new TypeError('Patterns must be a string (non empty) or an array of strings');\r\n    }\r\n}\r\nvar out$3 = FastGlob;\n\nconst {promisify} = util$2;\n\n\nasync function isType$1(fsStatType, statsMethodName, filePath) {\n\tif (typeof filePath !== 'string') {\n\t\tthrow new TypeError(`Expected a string, got ${typeof filePath}`);\n\t}\n\n\ttry {\n\t\tconst stats = await promisify(fs$2[fsStatType])(filePath);\n\t\treturn stats[statsMethodName]();\n\t} catch (error) {\n\t\tif (error.code === 'ENOENT') {\n\t\t\treturn false;\n\t\t}\n\n\t\tthrow error;\n\t}\n}\n\nfunction isTypeSync(fsStatType, statsMethodName, filePath) {\n\tif (typeof filePath !== 'string') {\n\t\tthrow new TypeError(`Expected a string, got ${typeof filePath}`);\n\t}\n\n\ttry {\n\t\treturn fs$2[fsStatType](filePath)[statsMethodName]();\n\t} catch (error) {\n\t\tif (error.code === 'ENOENT') {\n\t\t\treturn false;\n\t\t}\n\n\t\tthrow error;\n\t}\n}\n\nvar isFile = isType$1.bind(null, 'stat', 'isFile');\nvar isDirectory = isType$1.bind(null, 'stat', 'isDirectory');\nvar isSymlink = isType$1.bind(null, 'lstat', 'isSymbolicLink');\nvar isFileSync = isTypeSync.bind(null, 'statSync', 'isFile');\nvar isDirectorySync = isTypeSync.bind(null, 'statSync', 'isDirectory');\nvar isSymlinkSync = isTypeSync.bind(null, 'lstatSync', 'isSymbolicLink');\n\nvar pathType = {\n\tisFile: isFile,\n\tisDirectory: isDirectory,\n\tisSymlink: isSymlink,\n\tisFileSync: isFileSync,\n\tisDirectorySync: isDirectorySync,\n\tisSymlinkSync: isSymlinkSync\n};\n\nconst getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0];\n\nconst getPath$1 = (filepath, cwd) => {\n\tconst pth = filepath[0] === '!' ? filepath.slice(1) : filepath;\n\treturn path$1.isAbsolute(pth) ? pth : path$1.join(cwd, pth);\n};\n\nconst addExtensions = (file, extensions) => {\n\tif (path$1.extname(file)) {\n\t\treturn `**/${file}`;\n\t}\n\n\treturn `**/${file}.${getExtensions(extensions)}`;\n};\n\nconst getGlob = (directory, options) => {\n\tif (options.files && !Array.isArray(options.files)) {\n\t\tthrow new TypeError(`Expected \\`files\\` to be of type \\`Array\\` but received type \\`${typeof options.files}\\``);\n\t}\n\n\tif (options.extensions && !Array.isArray(options.extensions)) {\n\t\tthrow new TypeError(`Expected \\`extensions\\` to be of type \\`Array\\` but received type \\`${typeof options.extensions}\\``);\n\t}\n\n\tif (options.files && options.extensions) {\n\t\treturn options.files.map(x => path$1.posix.join(directory, addExtensions(x, options.extensions)));\n\t}\n\n\tif (options.files) {\n\t\treturn options.files.map(x => path$1.posix.join(directory, `**/${x}`));\n\t}\n\n\tif (options.extensions) {\n\t\treturn [path$1.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];\n\t}\n\n\treturn [path$1.posix.join(directory, '**')];\n};\n\nvar dirGlob = async (input, options) => {\n\toptions = {\n\t\tcwd: process.cwd(),\n\t\t...options\n\t};\n\n\tif (typeof options.cwd !== 'string') {\n\t\tthrow new TypeError(`Expected \\`cwd\\` to be of type \\`string\\` but received type \\`${typeof options.cwd}\\``);\n\t}\n\n\tconst globs = await Promise.all([].concat(input).map(async x => {\n\t\tconst isDirectory = await pathType.isDirectory(getPath$1(x, options.cwd));\n\t\treturn isDirectory ? getGlob(x, options) : x;\n\t}));\n\n\treturn [].concat.apply([], globs); // eslint-disable-line prefer-spread\n};\n\nvar sync$7 = (input, options) => {\n\toptions = {\n\t\tcwd: process.cwd(),\n\t\t...options\n\t};\n\n\tif (typeof options.cwd !== 'string') {\n\t\tthrow new TypeError(`Expected \\`cwd\\` to be of type \\`string\\` but received type \\`${typeof options.cwd}\\``);\n\t}\n\n\tconst globs = [].concat(input).map(x => pathType.isDirectorySync(getPath$1(x, options.cwd)) ? getGlob(x, options) : x);\n\n\treturn [].concat.apply([], globs); // eslint-disable-line prefer-spread\n};\ndirGlob.sync = sync$7;\n\n// A simple implementation of make-array\nfunction makeArray (subject) {\n  return Array.isArray(subject)\n    ? subject\n    : [subject]\n}\n\nconst EMPTY = '';\nconst SPACE = ' ';\nconst ESCAPE = '\\\\';\nconst REGEX_TEST_BLANK_LINE = /^\\s+$/;\nconst REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\\\!/;\nconst REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\\\#/;\nconst REGEX_SPLITALL_CRLF = /\\r?\\n/g;\n// /foo,\n// ./foo,\n// ../foo,\n// .\n// ..\nconst REGEX_TEST_INVALID_PATH = /^\\.*\\/|^\\.+$/;\n\nconst SLASH$1 = '/';\nconst KEY_IGNORE$1 = typeof Symbol !== 'undefined'\n  ? Symbol.for('node-ignore')\n  /* istanbul ignore next */\n  : 'node-ignore';\n\nconst define$1 = (object, key, value) =>\n  Object.defineProperty(object, key, {value});\n\nconst REGEX_REGEXP_RANGE$1 = /([0-z])-([0-z])/g;\n\n// Sanitize the range of a regular expression\n// The cases are complicated, see test cases for details\nconst sanitizeRange$1 = range => range.replace(\n  REGEX_REGEXP_RANGE$1,\n  (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0)\n    ? match\n    // Invalid range (out of order) which is ok for gitignore rules but\n    //   fatal for JavaScript regular expression, so eliminate it.\n    : EMPTY\n);\n\n// See fixtures #59\nconst cleanRangeBackSlash = slashes => {\n  const {length} = slashes;\n  return slashes.slice(0, length - length % 2)\n};\n\n// > If the pattern ends with a slash,\n// > it is removed for the purpose of the following description,\n// > but it would only find a match with a directory.\n// > In other words, foo/ will match a directory foo and paths underneath it,\n// > but will not match a regular file or a symbolic link foo\n// >  (this is consistent with the way how pathspec works in general in Git).\n// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'\n// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call\n//      you could use option `mark: true` with `glob`\n\n// '`foo/`' should not continue with the '`..`'\nconst REPLACERS = [\n\n  // > Trailing spaces are ignored unless they are quoted with backslash (\"\\\")\n  [\n    // (a\\ ) -> (a )\n    // (a  ) -> (a)\n    // (a \\ ) -> (a  )\n    /\\\\?\\s+$/,\n    match => match.indexOf('\\\\') === 0\n      ? SPACE\n      : EMPTY\n  ],\n\n  // replace (\\ ) with ' '\n  [\n    /\\\\\\s/g,\n    () => SPACE\n  ],\n\n  // Escape metacharacters\n  // which is written down by users but means special for regular expressions.\n\n  // > There are 12 characters with special meanings:\n  // > - the backslash \\,\n  // > - the caret ^,\n  // > - the dollar sign $,\n  // > - the period or dot .,\n  // > - the vertical bar or pipe symbol |,\n  // > - the question mark ?,\n  // > - the asterisk or star *,\n  // > - the plus sign +,\n  // > - the opening parenthesis (,\n  // > - the closing parenthesis ),\n  // > - and the opening square bracket [,\n  // > - the opening curly brace {,\n  // > These special characters are often called \"metacharacters\".\n  [\n    /[\\\\$.|*+(){^]/g,\n    match => `\\\\${match}`\n  ],\n\n  [\n    // > a question mark (?) matches a single character\n    /(?!\\\\)\\?/g,\n    () => '[^/]'\n  ],\n\n  // leading slash\n  [\n\n    // > A leading slash matches the beginning of the pathname.\n    // > For example, \"/*.c\" matches \"cat-file.c\" but not \"mozilla-sha1/sha1.c\".\n    // A leading slash matches the beginning of the pathname\n    /^\\//,\n    () => '^'\n  ],\n\n  // replace special metacharacter slash after the leading slash\n  [\n    /\\//g,\n    () => '\\\\/'\n  ],\n\n  [\n    // > A leading \"**\" followed by a slash means match in all directories.\n    // > For example, \"**/foo\" matches file or directory \"foo\" anywhere,\n    // > the same as pattern \"foo\".\n    // > \"**/foo/bar\" matches file or directory \"bar\" anywhere that is directly\n    // >   under directory \"foo\".\n    // Notice that the '*'s have been replaced as '\\\\*'\n    /^\\^*\\\\\\*\\\\\\*\\\\\\//,\n\n    // '**/foo' <-> 'foo'\n    () => '^(?:.*\\\\/)?'\n  ],\n\n  // starting\n  [\n    // there will be no leading '/'\n    //   (which has been replaced by section \"leading slash\")\n    // If starts with '**', adding a '^' to the regular expression also works\n    /^(?=[^^])/,\n    function startingReplacer () {\n      // If has a slash `/` at the beginning or middle\n      return !/\\/(?!$)/.test(this)\n        // > Prior to 2.22.1\n        // > If the pattern does not contain a slash /,\n        // >   Git treats it as a shell glob pattern\n        // Actually, if there is only a trailing slash,\n        //   git also treats it as a shell glob pattern\n\n        // After 2.22.1 (compatible but clearer)\n        // > If there is a separator at the beginning or middle (or both)\n        // > of the pattern, then the pattern is relative to the directory\n        // > level of the particular .gitignore file itself.\n        // > Otherwise the pattern may also match at any level below\n        // > the .gitignore level.\n        ? '(?:^|\\\\/)'\n\n        // > Otherwise, Git treats the pattern as a shell glob suitable for\n        // >   consumption by fnmatch(3)\n        : '^'\n    }\n  ],\n\n  // two globstars\n  [\n    // Use lookahead assertions so that we could match more than one `'/**'`\n    /\\\\\\/\\\\\\*\\\\\\*(?=\\\\\\/|$)/g,\n\n    // Zero, one or several directories\n    // should not use '*', or it will be replaced by the next replacer\n\n    // Check if it is not the last `'/**'`\n    (_, index, str) => index + 6 < str.length\n\n      // case: /**/\n      // > A slash followed by two consecutive asterisks then a slash matches\n      // >   zero or more directories.\n      // > For example, \"a/**/b\" matches \"a/b\", \"a/x/b\", \"a/x/y/b\" and so on.\n      // '/**/'\n      ? '(?:\\\\/[^\\\\/]+)*'\n\n      // case: /**\n      // > A trailing `\"/**\"` matches everything inside.\n\n      // #21: everything inside but it should not include the current folder\n      : '\\\\/.+'\n  ],\n\n  // intermediate wildcards\n  [\n    // Never replace escaped '*'\n    // ignore rule '\\*' will match the path '*'\n\n    // 'abc.*/' -> go\n    // 'abc.*'  -> skip this rule\n    /(^|[^\\\\]+)\\\\\\*(?=.+)/g,\n\n    // '*.js' matches '.js'\n    // '*.js' doesn't match 'abc'\n    (_, p1) => `${p1}[^\\\\/]*`\n  ],\n\n  [\n    // unescape, revert step 3 except for back slash\n    // For example, if a user escape a '\\\\*',\n    // after step 3, the result will be '\\\\\\\\\\\\*'\n    /\\\\\\\\\\\\(?=[$.|*+(){^])/g,\n    () => ESCAPE\n  ],\n\n  [\n    // '\\\\\\\\' -> '\\\\'\n    /\\\\\\\\/g,\n    () => ESCAPE\n  ],\n\n  [\n    // > The range notation, e.g. [a-zA-Z],\n    // > can be used to match one of the characters in a range.\n\n    // `\\` is escaped by step 3\n    /(\\\\)?\\[([^\\]/]*?)(\\\\*)($|\\])/g,\n    (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE\n      // '\\\\[bar]' -> '\\\\\\\\[bar\\\\]'\n      ? `\\\\[${range}${cleanRangeBackSlash(endEscape)}${close}`\n      : close === ']'\n        ? endEscape.length % 2 === 0\n          // A normal case, and it is a range notation\n          // '[bar]'\n          // '[bar\\\\\\\\]'\n          ? `[${sanitizeRange$1(range)}${endEscape}]`\n          // Invalid range notaton\n          // '[bar\\\\]' -> '[bar\\\\\\\\]'\n          : '[]'\n        : '[]'\n  ],\n\n  // ending\n  [\n    // 'js' will not match 'js.'\n    // 'ab' will not match 'abc'\n    /(?:[^*])$/,\n\n    // WTF!\n    // https://git-scm.com/docs/gitignore\n    // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)\n    // which re-fixes #24, #38\n\n    // > If there is a separator at the end of the pattern then the pattern\n    // > will only match directories, otherwise the pattern can match both\n    // > files and directories.\n\n    // 'js*' will not match 'a.js'\n    // 'js/' will not match 'a.js'\n    // 'js' will match 'a.js' and 'a.js/'\n    match => /\\/$/.test(match)\n      // foo/ will not match 'foo'\n      ? `${match}$`\n      // foo matches 'foo' and 'foo/'\n      : `${match}(?=$|\\\\/$)`\n  ],\n\n  // trailing wildcard\n  [\n    /(\\^|\\\\\\/)?\\\\\\*$/,\n    (_, p1) => {\n      const prefix = p1\n        // '\\^':\n        // '/*' does not match EMPTY\n        // '/*' does not match everything\n\n        // '\\\\\\/':\n        // 'abc/*' does not match 'abc/'\n        ? `${p1}[^/]+`\n\n        // 'a*' matches 'a'\n        // 'a*' matches 'aa'\n        : '[^/]*';\n\n      return `${prefix}(?=$|\\\\/$)`\n    }\n  ],\n];\n\n// A simple cache, because an ignore rule only has only one certain meaning\nconst regexCache = Object.create(null);\n\n// @param {pattern}\nconst makeRegex = (pattern, negative, ignorecase) => {\n  const r = regexCache[pattern];\n  if (r) {\n    return r\n  }\n\n  // const replacers = negative\n  //   ? NEGATIVE_REPLACERS\n  //   : POSITIVE_REPLACERS\n\n  const source = REPLACERS.reduce(\n    (prev, current) => prev.replace(current[0], current[1].bind(pattern)),\n    pattern\n  );\n\n  return regexCache[pattern] = ignorecase\n    ? new RegExp(source, 'i')\n    : new RegExp(source)\n};\n\nconst isString$1 = subject => typeof subject === 'string';\n\n// > A blank line matches no files, so it can serve as a separator for readability.\nconst checkPattern$1 = pattern => pattern\n  && isString$1(pattern)\n  && !REGEX_TEST_BLANK_LINE.test(pattern)\n\n  // > A line starting with # serves as a comment.\n  && pattern.indexOf('#') !== 0;\n\nconst splitPattern = pattern => pattern.split(REGEX_SPLITALL_CRLF);\n\nclass IgnoreRule {\n  constructor (\n    origin,\n    pattern,\n    negative,\n    regex\n  ) {\n    this.origin = origin;\n    this.pattern = pattern;\n    this.negative = negative;\n    this.regex = regex;\n  }\n}\n\nconst createRule$1 = (pattern, ignorecase) => {\n  const origin = pattern;\n  let negative = false;\n\n  // > An optional prefix \"!\" which negates the pattern;\n  if (pattern.indexOf('!') === 0) {\n    negative = true;\n    pattern = pattern.substr(1);\n  }\n\n  pattern = pattern\n  // > Put a backslash (\"\\\") in front of the first \"!\" for patterns that\n  // >   begin with a literal \"!\", for example, `\"\\!important!.txt\"`.\n  .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!')\n  // > Put a backslash (\"\\\") in front of the first hash for patterns that\n  // >   begin with a hash.\n  .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#');\n\n  const regex = makeRegex(pattern, negative, ignorecase);\n\n  return new IgnoreRule(\n    origin,\n    pattern,\n    negative,\n    regex\n  )\n};\n\nconst throwError$1 = (message, Ctor) => {\n  throw new Ctor(message)\n};\n\nconst checkPath = (path, originalPath, doThrow) => {\n  if (!isString$1(path)) {\n    return doThrow(\n      `path must be a string, but got \\`${originalPath}\\``,\n      TypeError\n    )\n  }\n\n  // We don't know if we should ignore EMPTY, so throw\n  if (!path) {\n    return doThrow(`path must not be empty`, TypeError)\n  }\n\n  // Check if it is a relative path\n  if (checkPath.isNotRelative(path)) {\n    const r = '`path.relative()`d';\n    return doThrow(\n      `path should be a ${r} string, but got \"${originalPath}\"`,\n      RangeError\n    )\n  }\n\n  return true\n};\n\nconst isNotRelative = path => REGEX_TEST_INVALID_PATH.test(path);\n\ncheckPath.isNotRelative = isNotRelative;\ncheckPath.convert = p => p;\n\nclass Ignore {\n  constructor ({\n    ignorecase = true\n  } = {}) {\n    this._rules = [];\n    this._ignorecase = ignorecase;\n    define$1(this, KEY_IGNORE$1, true);\n    this._initCache();\n  }\n\n  _initCache () {\n    this._ignoreCache = Object.create(null);\n    this._testCache = Object.create(null);\n  }\n\n  _addPattern (pattern) {\n    // #32\n    if (pattern && pattern[KEY_IGNORE$1]) {\n      this._rules = this._rules.concat(pattern._rules);\n      this._added = true;\n      return\n    }\n\n    if (checkPattern$1(pattern)) {\n      const rule = createRule$1(pattern, this._ignorecase);\n      this._added = true;\n      this._rules.push(rule);\n    }\n  }\n\n  // @param {Array<string> | string | Ignore} pattern\n  add (pattern) {\n    this._added = false;\n\n    makeArray(\n      isString$1(pattern)\n        ? splitPattern(pattern)\n        : pattern\n    ).forEach(this._addPattern, this);\n\n    // Some rules have just added to the ignore,\n    // making the behavior changed.\n    if (this._added) {\n      this._initCache();\n    }\n\n    return this\n  }\n\n  // legacy\n  addPattern (pattern) {\n    return this.add(pattern)\n  }\n\n  //          |           ignored : unignored\n  // negative |   0:0   |   0:1   |   1:0   |   1:1\n  // -------- | ------- | ------- | ------- | --------\n  //     0    |  TEST   |  TEST   |  SKIP   |    X\n  //     1    |  TESTIF |  SKIP   |  TEST   |    X\n\n  // - SKIP: always skip\n  // - TEST: always test\n  // - TESTIF: only test if checkUnignored\n  // - X: that never happen\n\n  // @param {boolean} whether should check if the path is unignored,\n  //   setting `checkUnignored` to `false` could reduce additional\n  //   path matching.\n\n  // @returns {TestResult} true if a file is ignored\n  _testOne (path, checkUnignored) {\n    let ignored = false;\n    let unignored = false;\n\n    this._rules.forEach(rule => {\n      const {negative} = rule;\n      if (\n        unignored === negative && ignored !== unignored\n        || negative && !ignored && !unignored && !checkUnignored\n      ) {\n        return\n      }\n\n      const matched = rule.regex.test(path);\n\n      if (matched) {\n        ignored = !negative;\n        unignored = negative;\n      }\n    });\n\n    return {\n      ignored,\n      unignored\n    }\n  }\n\n  // @returns {TestResult}\n  _test (originalPath, cache, checkUnignored, slices) {\n    const path = originalPath\n      // Supports nullable path\n      && checkPath.convert(originalPath);\n\n    checkPath(path, originalPath, throwError$1);\n\n    return this._t(path, cache, checkUnignored, slices)\n  }\n\n  _t (path, cache, checkUnignored, slices) {\n    if (path in cache) {\n      return cache[path]\n    }\n\n    if (!slices) {\n      // path/to/a.js\n      // ['path', 'to', 'a.js']\n      slices = path.split(SLASH$1);\n    }\n\n    slices.pop();\n\n    // If the path has no parent directory, just test it\n    if (!slices.length) {\n      return cache[path] = this._testOne(path, checkUnignored)\n    }\n\n    const parent = this._t(\n      slices.join(SLASH$1) + SLASH$1,\n      cache,\n      checkUnignored,\n      slices\n    );\n\n    // If the path contains a parent directory, check the parent first\n    return cache[path] = parent.ignored\n      // > It is not possible to re-include a file if a parent directory of\n      // >   that file is excluded.\n      ? parent\n      : this._testOne(path, checkUnignored)\n  }\n\n  ignores (path) {\n    return this._test(path, this._ignoreCache, false).ignored\n  }\n\n  createFilter () {\n    return path => !this.ignores(path)\n  }\n\n  filter (paths) {\n    return makeArray(paths).filter(this.createFilter())\n  }\n\n  // @returns {TestResult}\n  test (path) {\n    return this._test(path, this._testCache, true)\n  }\n}\n\nconst factory = options => new Ignore(options);\n\nconst returnFalse = () => false;\n\nconst isPathValid = path =>\n  checkPath(path && checkPath.convert(path), path, returnFalse);\n\nfactory.isPathValid = isPathValid;\n\n// Fixes typescript\nfactory.default = factory;\n\nvar ignore$1 = factory;\n\n// Windows\n// --------------------------------------------------------------\n/* istanbul ignore if  */\nif (\n  // Detect `process` so that it can run in browsers.\n  typeof process !== 'undefined'\n  && (\n    process.env && process.env.IGNORE_TEST_WIN32\n    || process.platform === 'win32'\n  )\n) {\n  /* eslint no-control-regex: \"off\" */\n  const makePosix = str => /^\\\\\\\\\\?\\\\/.test(str)\n  || /[\"<>|\\u0000-\\u001F]+/u.test(str)\n    ? str\n    : str.replace(/\\\\/g, '/');\n\n  checkPath.convert = makePosix;\n\n  // 'C:\\\\foo'     <- 'C:\\\\foo' has been converted to 'C:/'\n  // 'd:\\\\foo'\n  const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\\//i;\n  checkPath.isNotRelative = path =>\n    REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path)\n    || isNotRelative(path);\n}\n\nvar slash$1 = path => {\n\tconst isExtendedLengthPath = /^\\\\\\\\\\?\\\\/.test(path);\n\tconst hasNonAscii = /[^\\u0000-\\u0080]+/.test(path); // eslint-disable-line no-control-regex\n\n\tif (isExtendedLengthPath || hasNonAscii) {\n\t\treturn path;\n\t}\n\n\treturn path.replace(/\\\\/g, '/');\n};\n\nconst {promisify: promisify$1} = util$2;\n\n\n\n\n\n\nconst DEFAULT_IGNORE = [\n\t'**/node_modules/**',\n\t'**/flow-typed/**',\n\t'**/coverage/**',\n\t'**/.git'\n];\n\nconst readFileP = promisify$1(fs$2.readFile);\n\nconst mapGitIgnorePatternTo = base => ignore => {\n\tif (ignore.startsWith('!')) {\n\t\treturn '!' + path$1.posix.join(base, ignore.slice(1));\n\t}\n\n\treturn path$1.posix.join(base, ignore);\n};\n\nconst parseGitIgnore = (content, options) => {\n\tconst base = slash$1(path$1.relative(options.cwd, path$1.dirname(options.fileName)));\n\n\treturn content\n\t\t.split(/\\r?\\n/)\n\t\t.filter(Boolean)\n\t\t.filter(line => !line.startsWith('#'))\n\t\t.map(mapGitIgnorePatternTo(base));\n};\n\nconst reduceIgnore = files => {\n\treturn files.reduce((ignores, file) => {\n\t\tignores.add(parseGitIgnore(file.content, {\n\t\t\tcwd: file.cwd,\n\t\t\tfileName: file.filePath\n\t\t}));\n\t\treturn ignores;\n\t}, ignore$1());\n};\n\nconst ensureAbsolutePathForCwd = (cwd, p) => {\n\tif (path$1.isAbsolute(p)) {\n\t\tif (p.startsWith(cwd)) {\n\t\t\treturn p;\n\t\t}\n\n\t\tthrow new Error(`Path ${p} is not in cwd ${cwd}`);\n\t}\n\n\treturn path$1.join(cwd, p);\n};\n\nconst getIsIgnoredPredecate = (ignores, cwd) => {\n\treturn p => ignores.ignores(slash$1(path$1.relative(cwd, ensureAbsolutePathForCwd(cwd, p))));\n};\n\nconst getFile = async (file, cwd) => {\n\tconst filePath = path$1.join(cwd, file);\n\tconst content = await readFileP(filePath, 'utf8');\n\n\treturn {\n\t\tcwd,\n\t\tfilePath,\n\t\tcontent\n\t};\n};\n\nconst getFileSync = (file, cwd) => {\n\tconst filePath = path$1.join(cwd, file);\n\tconst content = fs$2.readFileSync(filePath, 'utf8');\n\n\treturn {\n\t\tcwd,\n\t\tfilePath,\n\t\tcontent\n\t};\n};\n\nconst normalizeOptions$5 = ({\n\tignore = [],\n\tcwd = slash$1(process.cwd())\n} = {}) => {\n\treturn {ignore, cwd};\n};\n\nvar gitignore = async options => {\n\toptions = normalizeOptions$5(options);\n\n\tconst paths = await out$3('**/.gitignore', {\n\t\tignore: DEFAULT_IGNORE.concat(options.ignore),\n\t\tcwd: options.cwd\n\t});\n\n\tconst files = await Promise.all(paths.map(file => getFile(file, options.cwd)));\n\tconst ignores = reduceIgnore(files);\n\n\treturn getIsIgnoredPredecate(ignores, options.cwd);\n};\n\nvar sync$8 = options => {\n\toptions = normalizeOptions$5(options);\n\n\tconst paths = out$3.sync('**/.gitignore', {\n\t\tignore: DEFAULT_IGNORE.concat(options.ignore),\n\t\tcwd: options.cwd\n\t});\n\n\tconst files = paths.map(file => getFileSync(file, options.cwd));\n\tconst ignores = reduceIgnore(files);\n\n\treturn getIsIgnoredPredecate(ignores, options.cwd);\n};\ngitignore.sync = sync$8;\n\nconst DEFAULT_FILTER = () => false;\n\nconst isNegative = pattern => pattern[0] === '!';\n\nconst assertPatternsInput$1 = patterns => {\n\tif (!patterns.every(pattern => typeof pattern === 'string')) {\n\t\tthrow new TypeError('Patterns must be a string or an array of strings');\n\t}\n};\n\nconst checkCwdOption = (options = {}) => {\n\tif (!options.cwd) {\n\t\treturn;\n\t}\n\n\tlet stat;\n\ttry {\n\t\tstat = fs$2.statSync(options.cwd);\n\t} catch (_) {\n\t\treturn;\n\t}\n\n\tif (!stat.isDirectory()) {\n\t\tthrow new Error('The `cwd` option must be a path to a directory');\n\t}\n};\n\nconst generateGlobTasks = (patterns, taskOptions) => {\n\tpatterns = arrayUnion([].concat(patterns));\n\tassertPatternsInput$1(patterns);\n\tcheckCwdOption(taskOptions);\n\n\tconst globTasks = [];\n\n\ttaskOptions = {\n\t\tignore: [],\n\t\texpandDirectories: true,\n\t\t...taskOptions\n\t};\n\n\tfor (const [index, pattern] of patterns.entries()) {\n\t\tif (isNegative(pattern)) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst ignore = patterns\n\t\t\t.slice(index)\n\t\t\t.filter(isNegative)\n\t\t\t.map(pattern => pattern.slice(1));\n\n\t\tconst options = {\n\t\t\t...taskOptions,\n\t\t\tignore: taskOptions.ignore.concat(ignore)\n\t\t};\n\n\t\tglobTasks.push({pattern, options});\n\t}\n\n\treturn globTasks;\n};\n\nconst globDirs = (task, fn) => {\n\tlet options = {};\n\tif (task.options.cwd) {\n\t\toptions.cwd = task.options.cwd;\n\t}\n\n\tif (Array.isArray(task.options.expandDirectories)) {\n\t\toptions = {\n\t\t\t...options,\n\t\t\tfiles: task.options.expandDirectories\n\t\t};\n\t} else if (typeof task.options.expandDirectories === 'object') {\n\t\toptions = {\n\t\t\t...options,\n\t\t\t...task.options.expandDirectories\n\t\t};\n\t}\n\n\treturn fn(task.pattern, options);\n};\n\nconst getPattern = (task, fn) => task.options.expandDirectories ? globDirs(task, fn) : [task.pattern];\n\nconst getFilterSync = options => {\n\treturn options && options.gitignore ?\n\t\tgitignore.sync({cwd: options.cwd, ignore: options.ignore}) :\n\t\tDEFAULT_FILTER;\n};\n\nconst globToTask = task => glob => {\n\tconst {options} = task;\n\tif (options.ignore && Array.isArray(options.ignore) && options.expandDirectories) {\n\t\toptions.ignore = dirGlob.sync(options.ignore);\n\t}\n\n\treturn {\n\t\tpattern: glob,\n\t\toptions\n\t};\n};\n\nvar sync$9 = (patterns, options) => {\n\tconst globTasks = generateGlobTasks(patterns, options);\n\n\tconst tasks = globTasks.reduce((tasks, task) => {\n\t\tconst newTask = getPattern(task, dirGlob.sync).map(globToTask(task));\n\t\treturn tasks.concat(newTask);\n\t}, []);\n\n\tconst filter = getFilterSync(options);\n\n\treturn tasks.reduce(\n\t\t(matches, task) => arrayUnion(matches, out$3.sync(task.pattern, task.options)),\n\t\t[]\n\t).filter(path_ => !filter(path_));\n};\n\nfunction convertGlobPaths(\n\tcwd,\n\textension,\n\tinclude,\n\texclude,\n\texcludeNodeModules\n) {\n\tif (excludeNodeModules) {\n\t\texclude.push('**/node_modules/**');\n\t}\n\n\tconst included = include\n\t\t.map((globString) =>\n\t\t\tsync$9(globString, {\n\t\t\t\tcwd: cwd,\n\t\t\t\tabsolute: true,\n\t\t\t\tonlyFiles: true,\n\t\t\t\tignore: exclude,\n\t\t\t})\n\t\t)\n\t\t.flat()\n\t\t.filter((file) => {\n\t\t\tif (extension.includes(path$1.extname(file))) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n\t\t});\n\n\treturn included;\n}\n\nfunction objectMerge(a, b) {\n\tfor (const key in b) {\n\t\tif (a[key] === undefined) {\n\t\t\ta[key] = {\n\t\t\t\t...b[key],\n\t\t\t};\n\t\t} else {\n\t\t\tfor (const key2 in b[key]) {\n\t\t\t\ta[key][key2] = {\n\t\t\t\t\t...a[key][key2],\n\t\t\t\t\t...b[key][key2],\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\t}\n}\n\nclass SpecBuilder  {\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\n\tconstructor(baseDefinition) {\n\t\tthis.openapi = baseDefinition.openapi;\n\t\tthis.info = baseDefinition.info;\n\t\tthis.servers = baseDefinition.servers;\n\t\tthis.paths = baseDefinition.paths || {};\n\t\tthis.components = baseDefinition.components;\n\t\tthis.security = baseDefinition.security;\n\t\tthis.tags = baseDefinition.tags;\n\t\tthis.externalDocs = baseDefinition.externalDocs;\n\t}\n\n\taddData(parsedFile) {\n\t\tparsedFile.forEach((file) => {\n\t\t\tconst { paths, components, ...rest } = file;\n\n\t\t\t// only merge paths and components\n\t\t\tobjectMerge(this, {\n\t\t\t\tpaths: paths,\n\t\t\t\tcomponents: components,\n\t\t\t} );\n\n\t\t\t// overwrite everthing else:\n\t\t\tObject.entries(rest).forEach(([key, value]) => {\n\t\t\t\tthis[key ] = value;\n\t\t\t});\n\t\t});\n\t}\n}\n\nfunction pluralize(word, count) {\n\treturn count === 1 ? word : `${word}s`;\n}\n\nfunction formatter(results) {\n\tlet output = '\\n';\n\tlet errorCount = 0;\n\tlet warningCount = 0;\n\n\tresults.forEach((result) => {\n\t\tconst messages = result.messages;\n\n\t\tif (messages.length === 0) {\n\t\t\treturn;\n\t\t}\n\n\t\toutput += `${source.underline(result.filePath)}\\n`;\n\n\t\tconst maxPositionWidth = messages.reduce((acc, message) => {\n\t\t\tconst position = `${message.line || 0}:${message.column || 0}`;\n\t\t\treturn Math.max(acc, position.length);\n\t\t}, 0);\n\n\t\toutput += `${messages\n\t\t\t.map((message) => {\n\t\t\t\tlet position = `${message.line || 0}:${message.column || 0}`;\n\t\t\t\tposition += ' '.repeat(maxPositionWidth - position.length);\n\t\t\t\tlet messageType;\n\t\t\t\tif (message.severity === 2) {\n\t\t\t\t\tmessageType = source.red('error  ');\n\t\t\t\t\terrorCount++;\n\t\t\t\t} else {\n\t\t\t\t\tmessageType = source.yellow('warning');\n\t\t\t\t\twarningCount++;\n\t\t\t\t}\n\t\t\t\treturn `  ${source.dim(position)}  ${messageType}  ${message.message}`;\n\t\t\t})\n\t\t\t.join('\\n')}\\n\\n`;\n\t});\n\n\tconst total = errorCount + warningCount;\n\n\tconst problems = `${total} ${pluralize('problem', total)}`;\n\tconst errors = `${errorCount} ${pluralize('error', errorCount)}`;\n\tconst warnings = `${warningCount} ${pluralize('warning', warningCount)}`;\n\n\tconst summary = `\\u2716 ${problems} (${errors}, ${warnings})`;\n\n\tif (errorCount > 0) {\n\t\toutput += source.red.bold(summary);\n\t} else {\n\t\toutput += source.yellow.bold(summary);\n\t}\n\n\t// Resets output color, for prevent change on top level\n\treturn total > 0 ? source.reset(output) : '';\n}\n\nconst DEFAULT_OPTIONS$1 = {\n\tcwd: undefined,\n\textension: ['.js', '.cjs', '.mjs', '.ts', '.tsx', '.jsx', '.yaml', '.yml'],\n\tinclude: ['**'],\n\texclude: [\n\t\t'coverage/**',\n\t\t'packages/*/test{,s}/**',\n\t\t'**/*.d.ts',\n\t\t'test{,s}/**',\n\t\t`test{,-*}.{js,cjs,mjs,ts,tsx,jsx,yaml,yml}`,\n\t\t`**/*{.,-}test.{js,cjs,mjs,ts,tsx,jsx,yaml,yml}`,\n\t\t'**/__tests__/**',\n\n\t\t/* Exclude common development tool configuration files */\n\t\t'**/{ava,babel,nyc}.config.{js,cjs,mjs}',\n\t\t'**/jest.config.{js,cjs,mjs,ts}',\n\t\t'**/{karma,rollup,webpack}.config.js',\n\t\t'**/.{eslint,mocha}rc.{js,cjs}',\n\t\t'**/.{travis,yarnrc}.yml',\n\t\t'**/{docker-compose}.yml',\n\n\t\t// always ignore '**/node_modules/**'\n\t],\n\texcludeNodeModules: true,\n\tverbose: true,\n\tthrowLevel: 'off',\n};\n\nfunction _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }\nfunction getCallerPath() {\n\tconst filename = _optionalChain([callerCallsite, 'call', _ => _(), 'optionalAccess', _2 => _2.getFileName, 'call', _3 => _3()]);\n\tif (filename) {\n\t\treturn path$1.dirname(filename);\n\t}\n\treturn '';\n}\n\nfunction parseComments(options = {}) {\n\tconst definition = {\n\t\topenapi: '',\n\t\tinfo: {\n\t\t\ttitle: '',\n\t\t\tversion: '',\n\t\t},\n\t};\n\n\tconst {\n\t\tcwd = getCallerPath(),\n\t\textension = DEFAULT_OPTIONS$1.extension,\n\t\tinclude = DEFAULT_OPTIONS$1.include,\n\t\texclude = DEFAULT_OPTIONS$1.exclude,\n\t\texcludeNodeModules = DEFAULT_OPTIONS$1.excludeNodeModules,\n\t\tverbose = DEFAULT_OPTIONS$1.verbose,\n\t\tthrowLevel = DEFAULT_OPTIONS$1.throwLevel,\n\t} = options;\n\n\tconst spec = new SpecBuilder(definition);\n\n\tconst files = convertGlobPaths(cwd, extension, include, exclude, excludeNodeModules);\n\n\tconst linter = new api_1();\n\tlinter.defineRules({\n\t\t...eslintPluginOpenapi.rules,\n\t});\n\n\tlet totalLOC = 0;\n\tlet allMessages = [];\n\tfiles.forEach((file) => {\n\t\tconst { parsedFile, messages } = parseFile(file, linter);\n\t\tallMessages.push({ filePath: file, messages: messages });\n\t\tconst specs = parsedFile.map((item) => item.spec);\n\t\tconst loc = parsedFile.reduce((acc, cur) => (acc += cur.loc), 0);\n\t\ttotalLOC += loc;\n\t\tspec.addData(specs);\n\t});\n\n\tif (verbose) {\n\t\tconst errorTable = formatter(allMessages);\n\t\tif (errorTable) {\n\t\t\tconsole.log(errorTable);\n\t\t}\n\t}\n\n\tif (throwLevel !== 'off') {\n\t\tlet errorCount = 0;\n\t\tlet warningCount = 0;\n\n\t\tallMessages.forEach((result) => {\n\t\t\tresult.messages.map((message) => {\n\t\t\t\tif (message.severity === 2) {\n\t\t\t\t\terrorCount++;\n\t\t\t\t} else {\n\t\t\t\t\twarningCount++;\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\n\t\tconst problemCount = errorCount + warningCount;\n\n\t\tif (throwLevel === 'error' && errorCount > 0) {\n\t\t\tthrow new Error(\n\t\t\t\t`openapi-comment-parser: Found ${errorCount} problem${\n\t\t\t\t\terrorCount > 1 ? 's' : ''\n\t\t\t\t}.`\n\t\t\t);\n\t\t}\n\t\tif (\n\t\t\t(throwLevel === 'warn' || throwLevel === 'warning') &&\n\t\t\tproblemCount > 0\n\t\t) {\n\t\t\tthrow new Error(\n\t\t\t\t`openapi-comment-parser: Found ${problemCount} problem${\n\t\t\t\t\tproblemCount > 1 ? 's' : ''\n\t\t\t\t}.`\n\t\t\t);\n\t\t}\n\t}\n\n\tif (verbose) {\n\t\t// Only measure paths and components.\n\t\tlet pathsAsYaml = '';\n\t\tif (spec.paths) {\n\t\t\tpathsAsYaml = jsYaml$1.safeDump(JSON.parse(JSON.stringify(spec.paths)));\n\t\t}\n\t\tlet componentAsYaml = '';\n\t\tif (spec.components) {\n\t\t\tcomponentAsYaml = jsYaml$1.safeDump(\n\t\t\t\tJSON.parse(JSON.stringify(spec.components))\n\t\t\t);\n\t\t}\n\t\tconst originalLOC = yamlLOC(pathsAsYaml) + yamlLOC(componentAsYaml);\n\t\tconst locDiff = originalLOC - totalLOC;\n\t\tconst savings = (locDiff / originalLOC) * 100;\n\t\tif (locDiff > 0) {\n\t\t\tconsole.log();\n\t\t\tconsole.log(\n\t\t\t\t`✨ You've saved ${source.bold(\n\t\t\t\t\tlocDiff\n\t\t\t\t)} lines of extra YAML (${source.green.bold(\n\t\t\t\t\t`\\u25BC ${savings.toFixed(1)}%`\n\t\t\t\t)})`\n\t\t\t);\n\t\t\tconsole.log();\n\t\t}\n\t}\n\n\treturn spec;\n}\n\nmodule.exports = parseComments;\n"]}