8436.js.map (675807B)
1 {"version":3,"file":"bundles/12c8185ea2689492c07b/8436.js","mappings":"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AS,CACtBxzB,SAAA,MAGO,SAASyzB,KAChB,MAAAriC,EAAAhL,KAAAoX,WACAwC,EAAA5Z,KAAA0Z,aAAA1Z,KAAAub,MAAA2kB,OAEA,OACAvvB,KAAA,QACA8M,IAAAzd,KAAAsW,YAAAtL,EAAAhL,KAAAoX,YACAwC,WAEA,CAEO,SAAS0zB,GAAQ/yB,GACxBva,KAAA4Z,SAAAW,EACA,CChBA,MAAMgzB,GAAK7tC,OAAA0nB,OAAA,CACXzW,KAAA,aACA8M,IAAA,KACAza,MAAA,MAGawqC,GAAI,aACJC,GAAS,CACtBzqC,MAAAkE,QAGO,SAASwmC,KAEhB,OADA1tC,KAAAgd,IAAa,IACFuwB,EAOX,CAEO,SAASI,GAAQpzB,GACxBva,KAAA2f,MAAe,GAAUpF,EAAAvX,MACzB,CCtBA,MAAA8wB,GAAA,CACA4B,SAAA,EACA/N,gBAAmBA,GpDLnB+N,SAAA,EACA/N,gBAAA,CACA,UACA,UACA,QACA,SACA,gBAEAyD,MAAA,CACAC,MAAA,CACA,MACA,OACA,MACA,QAEAC,QAAA,CACA,MAEAE,KAAA,CACA,MAEAD,UAAA,CACA,KACA,OAEA7qB,OAAA,CACA,KACA,KACA,IACA,KACA,KACA,KACA,KACA,KACA,MACA,KACA,MACA,MACA,OACA,KACA,MACA,KACA,MACA,KACA,MACA,KACA,MACA,MACA,MACA,KACA,MACA,MACA,MACA,KACA,MACA,MACA,MACA,KACA,MACA,MACA,MACA,OACA,QACA,QACA,QACA,OACA,QACA,QACA,QACA,MACA,MACA,MACA,MACA,QACA,SAEA+qB,WAAA,CACA,MACA,OACA,OACA,KAEAC,UAAA,CACA,MAEAC,KAAA,CACA,IACA,OAGArM,MAAA,CACA,4BACA,iFACA,8BACA,sCACA,qZACA,4EACA,+BACA,uGACA,iEACA,wFACA,0CACA,iDACA,mDACA,oGACA,gEACA,yFACA,8BACA,8BACA,6CACAsuB,WAAA,qBACA,mEACA,4CACA,sBACA,6DACA,0HACA,6FACA,4JACAC,KAAA,mBACA,6CACA,wFACA,iDACA,0CACA,0BACA,gHACA,4OACA,gEACA,+JACA,6BACA,wDACA,8BACA,8CACA,+DACA,4DACA,0EACA,wDACA,gFACA,mCACA,2CACA,uDACA,oCACA,qCACA,sBACAC,MAAA,gGACA,mEACA,oFACA,2GACA,mIACA,iGACA,sDACA,sDACA,+CACA,yFACA,6DACAhpB,WAAA,wBACA,6DACA,+FACA,6CACA,sFACA,8CACA,iJACA,wDACA,+DACA,gDACA,iEACA,mIACA,mHACA,kCACA,+GACA,yEACA,6FACA,0DACA,gCACA,qDACA,oDACA,8EACA,gFACA,4BACAipB,QAAA,2BACA,2DACA,gCACA,kDACA,sCACA,wEACA,qEACA,mEACA,yIACA,8UACA,sCACA,+DACAC,UAAA,qCACA,uCACA,oUACA,kFACA,8BACA,uDACA,0MACA,sFACA,sEACA,wCACA,2DACA,8GACA,mGACA,+EACA,4DACA,oGACA,yDACA,uDACA,4BACA,oEACA,yCACA,mDACA,yGACA,gFACA,oDACA,4DACA,+DACA,sCACA,oJACA,iDACA,4IACA,2DACA,sCACA,2FACA,4HACA,4JACA,wCACA,uDACA,yIACA,mCACA,kDACA,+EACA,0EACA,oHACA,sEACA,0DACAC,SAAA,yKACA,sDACA,mGACA,yEACA,8KACA,iLACAC,IAAA,mBACA,wEACA,iDACA,kHACA,iCACAC,MAAA,gFACA,8DACA,iDACA,yEACA,6BACA,uBACA,wEACA,yEACA,gDACA,+DACA,sFACA,2CACA,kIACA,kCACA,sCACA,kHACA,qCACA,4CACA,4CACA,iDACA,iDACA,uCACA,gFACA,0CACA,sDACA,0CACA,mDACA,6CACA,oEACA,qHACA,0CACA,6JACA,mGACA,8CACA,sBACA,8CACA,oCACA,yCACA,6BACA,yDACA,yEACA,yEACA,2DACA,6EACA,oCACA,uDACA,+FACA,oCACA,uBACA,yBACA,oBACA,oCACA,2LACA,kDACA,6BACA,sIACA,yCACA,kCACA,sEACA,88CACA,6BACA,sCACA,2CACA,mCACA,uCACA,4CACA,sDACA,mEACA,4DACA,4CACA,sIACA,sHACA,kDACA,wCACA,iFACA,yCACA,kCACA,4EACA,sEACA,2PACA,wDACA,2CACA,+DACAC,MAAA,iEACA,oDACA,+CACA,sCACA,sJACA,6CACA,uDACA,wCACA,qFACAC,SAAA,qMACA,ywBACA,yCACA,8FACA,2EACA,iFACA,yFACA,2CACA,2GACAvD,MAAA,sDACA,4EACA,oEACA,oIACA,gCACA,4EACAwD,MAAA,qCACA,kEACA,6EACA,4EACA,qIACA,uDACA,gDACA,iCACA,yCACA,uEACA,qFACA,wFACA,wFACA,qDACA,yJACA,6JACA,wCACA,6EACA,0CACA,0CACA,0CACA,oEACA,8CACA,oDACA,mDACA,qDACA,+CACA,+CACA,+CACA,wCACA,0CACA,6CACAC,SAAA,oBACA,4CACA,kGACA,qKACA,0CACA,2EACA,8CACAC,OAAA,kCACA,uCACAC,MAAA,oFACA,sCACA,8CACA,8BACA,kCACA,oCACA,4BACA,yQACA,wDACA,0EACA,4DACA,uDACA,+CACA,2EACA,0HACA,kDACA7tC,KAAA,4FACA,oDACA,wDACA,sCACA,sCACA,8BACA,oEACA,uDACA,kDACA,gCACA,iFACA,kDACA,kGACA,iEACA,iJACA,oCACA,4DACA,sFACA,wDACA8tC,OAAA,kCACA,6DACA,0DACA,+NACA,8EACA,4BACAC,OAAA,yDACA,4FACA,yGACA,yFACA,uGACA,wCACA,8EACA,0EACA,4EACA,2FACA,mHACA,0RACA,yCACA,oDACA,wEACA,sFACA,mDACA,mDACA,wCACA,qEACA,mDACA,kLACA,6CACA,+DACA,sDACA,6CACA,kDACA,uCACA,kGACAC,IAAA,sBACA,2DACA,sKACA,iNACA,yPACA,sFACA,iNACA,yPACA,4KACA,yGACA,iDACA,wUACA,m9BACA,8GACA,qIACA,oMACA,oPACA,uHACA,2GACA,kDACA,wCACA,iDACA,oDACA,kFACA,8GACA,6EACAC,IAAA,kBACA,wBACA,8BACAC,UAAA,mFACAC,OAAA,gBACA,+CACAC,OAAA,sBACA,mFACA,kEACA,+DACAzM,KAAA,gBACA,0EACA,0DACA,2FACA,8CACA,mFACAI,MAAA,gBACA,yDACA,mEACA,wDACA,4CACA,0DACA,8EACA,mFACA,iEACA,gFACA,wDACA,8EACA,8CACA,gDACAsM,IAAA,gBACAvlC,EAAA,WACAwlC,EAAA,WACAhrB,YAAA,wDACA,0DACAzZ,IAAA,8CACA,wDACA,mCACA,yCACA,kCACA,+GACA,iLACA,wvBACAyb,OAAA,mFACA,2FACA,+DACA,qJACA,0BACA,8BACA,4BAEAU,WAAA,CACA,4BACA,+BACA,sCACA,2CACA,yFACA,4CACA,4CACA,2FACA,uGACA,wDACA,kCACA,wBACA,yCACA,yCACA,yDACA,sDACA,uCACA,kDACA,iDACA,mDACA,6BACA,oEACA,qCACA,iIACA,yCACA,oCACA,yCACA,oCACA,iCACA,wHACA,wHACA,kDACA,4EACA,4EACA,uDACA,wCACA,sCACA,qCACA,2CACA,qCACA,0CACA,uCACA,sCACA,oGACA,mCACA,sCACA,oDACA,6BACA,+BACA,+uDACA,4BACA,4CACA,0CACA,2CACA,yCACA,4EACA,kEACA,qCACA,iDACA,yEACA,oDACA,qDACA,iDACA,kDACA,4CACA,+BACA,qGACA,+CACA,qDACA,sCACA,uDACA,mqCACA,sEACA,wCACA,iDACA,iDACA,qEACA,sCACA,mKACA,0CACA,yEACA,8CACA,yCACA,8DACA,sCACA,qEACA,qEACA,wCACA,uDACA,uDACA,iCACA,0CACA,wCACA,oCACA,0CACA,sCACA,uCACA,uCACA,uEACA,2CACA,8BACA,4GACA,wGACA,0GACA,8GACA,wJACAoJ,IAAA,4CACA,qCACA,0CACAmf,UAAA,sBACA,0DACA,4BACA,sDACA,6CACA,sDACA,kEACA,4CACA,wDACA,0EACA,iGACA,mGACA,oDACA,iDACA,oEACAC,WAAA,2CACA,+BACA,6CACA,uCACAC,WAAA,kCACA,wCACA,wCACA,+BACA,6BACA,iCACA,oCACA,uCACA,wFACA,wFACA,sCACA,+BACA,mDACA,oCACA,yBACAC,OAAA,sCACA,wCACA,iDACA,yEACA,gDACA,gDACA,gDACA,2EACA,kDACA,kDACA,kDACA,iDACA,iDACA,sDACA,6CACA,6DACA,8DACA,qCACA,qCACA,sCACA,8BACA,qDACA,uDACA,0KACA,6DACA,0DACA,uEACA,qCACA,4EACA,yCACA,kDACA,0EACA,iDACA,iDACA,iDACA,4EACA,mDACA,mDACA,mDACA,kDACA,kDACA,oDACA,8BACA,mCACA,mCACA,qFACA,qDACA,+BACA,oCACA,oCACA,iCACA,uDACA,yDACA,mCACA,mDACA,6BACA,0DACA,2DACA,kCACA,kCACA,mCACAP,OAAA,sDACA,gDACA,qCACA,yCACA,sBACA,6BACA,8BACA,gCACA,kEACA,sCACA,8BACA,sCACA,qHACA,sHACA,iEACA,4BACAQ,MAAA,wDACA,gCACA,6BACA,0CACAn8B,MAAA,+CACAo8B,KAAA,eACA,iEACA,8BACA1B,MAAA,UACA,oDACA,4DACA,gCACA,6BACA,0CACA,sCACA,oFACA,8BACA,uCACA,uCACA,yBACA,qCACA,iCACA73B,QAAA,8DACAw5B,QAAA,kEACA,uDACA,mDACA,wDACA,wDACA,kDACApQ,UAAA,6CACA,wCACA,8CACAv4B,QAAA,yFACA,2CACA,qDACA,uDACA,kDACA,kDACA,mDACA,8CACA,gDACA,sDACA,wDACA,gDACA,iDACA,2CACA,kDACA,gDACA,+CACA,+CACA,gDACA,wDACA,uFACA,kDACA4K,OAAA,2cACAg+B,GAAA,wBACAC,GAAA,wBACAC,EAAA,wBACAC,UAAA,UACAC,QAAA,qIACA,uJACA,kFACA,0BACA,+BACAl4B,KAAA,UACA,gDACA,8BACA3E,OAAA,sDACAuY,KAAA,wDACA,iCACA,yDACA,gDACA,uBACA,yBACA,uCACAukB,MAAA,0CACA,wBACA,8BACAC,KAAA,6KACA,kDACA,sDACA,kCACA,2CACA,kCACA,wEACA,6EACA,mGACA,2DACA,yCACA,8CACA,8DACA,sCACA,wCACA,mCACA,oCACA,4lBACA,8QACA,wGACA,kGACA,iDACA,2IACA,sIACA,2CACA,wDACA,sDACA,uJACA,wDACAC,IAAA,8BACAC,KAAA,4JACA,+CACA,oCACA,uCACA,iCACA,6CACA,gCACA,wCACA,kCACA,mDACA,0CACA,6BACA,qCACA,+BACA,6JACA,uCACA,wFACA,qFACA,kEACAC,OAAA,yKACA,sCACA,gDACAC,QAAA,mBACA,yDACA,oHACA,uDACA,kDACA,gDACA,+DACA,0BACAC,MAAA,eACA,6BACA,4BACA,8BACA,8BACA,6BACA,+BACA,iDACAC,UAAA,eACAC,cAAA,aACA,iDACA,qCACA,uCACA,uGACA,wJACA,yHACA,yGACAhO,KAAA,sDACA,8CACA,2BACA,iDACA,8BACA,sDACA,8BACA,kFACA,kCACA,uCACA,kDACAiO,OAAA,sBACA,qCACA,oCACA,sCACA,2DACA,sCACA,qCACA,uCACA,yDACA,0DACA,wDACA,iCACAC,OAAA,aACA,0BACA,0BACA,4BACApe,KAAA,gBACA,oKACA,qCACA,gDACA,yDACA,qDACA,oCACA,+DACA,qCACA,2CACA,iCACA,8BACA,6BACA,8BACA,gCACA,yBACA,8BACA,4DACA,mDACA,8BACA,8BACA,iCACA,sLACA,kCACA,6BACA,qLACA,iCACA,sLACA,kCACA,qLACA,yDACA,kDACA,+BACA,4CACArjB,OAAA,8GACA,kCACA,wCACA,gDACA,2CACA,0CACA0hC,QAAA,kBACAC,MAAA,YACAC,QAAA,YACAC,QAAA,0DACA,+BACA,4BACA,4CACA,+BACAC,SAAA,kEACA,8BACA,4EACA,8CACA,sDACA,6EACA,6CACA,wEACA,wEACAC,QAAA,YACA,iDACA,gDACA,iDACA,4CACA,4CACAC,QAAA,uBACA,uCACA,sCACA,wCACA,6CACA,wCACA,uCACA,yCACA,2CACA,4CACA,0CACAC,KAAA,sBACA,8DACA,+DACA,iCACA,+CACAC,YAAA,gBACA,kCACA,yDACA,mDACA,gDACA,8GACA7C,SAAA,uDACA,4CACA,uCACA,oEACA,oFACA,yCACA,6EACA,qCACA8C,OAAA,iCACAC,EAAA,wBACA,6FACA,4BACAC,OAAA,6CACA1O,MAAA,sDACA2O,OAAA,4CACA,uCACA,uDACA,sCACA,4BACA,4DACAC,GAAA,wBACAC,GAAA,wBACAC,MAAA,oCACA,gCACA,uCACA,gCACA,sCACA,qCACA,uCACA,kCACA,uCACA,sCACA,wCACA,gCACA,iCACA,+BACA,0CACA,mDACA,yDACA,sDACA,wDACA,mDACA,0DACA,uDACA,yDACA,iDACA,kDACA,gDACA,mDACA,4CACA,uCACA,4DACA,4DACA,mCACA,yEACA,gDACA,gDACA,kCACA,0EACA,6CACA,gDACA,oCACA,8CACA,mCACA,0CACA,qCACA,4DACA,qEACA,4EACA,yBACA,6BACAC,OAAA,UACA,yBACA,2CACA,mCACA,qCACA,sCACA,8CACA,+BACA,8BACA,gCACA,4BACA,gEACA,6DACA,iCACA,2CACA,yDACA,mCACA,qDACA,sDACA,kIACA,kCACA,6CACA,sGACA,2GACA,2CACA,0DACA,mEACA,mEACA,gCACA,4DACA,kGACA,0DACA,sDACA,4CACA,gDACA,4EACA,iCACA,4CACA,8DACA,+FACA,qDACA,iEACA,sDACA,+BACA,+CACA,wCACA,qJACA,+CACA,8GACA,kHACA,oHACA,+FACA,wGACA,0GACA,yDACAzC,IAAA,sDACA,0GACA0C,UAAA,wBACA,sEACA,qKACA,qCACAC,WAAA,uBACA,qDACA,6BACA,gCACA,2DACA,kDACAC,UAAA,4DACA,2CACA,4LACA,mCACA,uFACA,mGACA,+FACA,2CACA,2DACA,8CACA,+CACA,2DACAC,WAAA,0BACA,0FACA,wFACAC,OAAA,YACAC,MAAA,yKACA,4CACA,gEACA,iCACA,gCACA,kGACAtoC,EAAA,wBACAwlC,EAAA,wBACA,2BACA+C,KAAA,kDACA,wCACA,gEACA,kEACA,0DACA,+DACA,qDACA,2CACA,6CACA,qDACA,+DACA,mEACA,sCACA,sDACA,6BACA,oCACA,2CACA,oDACA,mDACA,gDACA,4DACA,wEACA,iDACA,kDACA,kDACA,sEACA,0GACA,6CACA,kDACA,wCACAC,SAAA,SACAC,IAAA,gCACA,oCACA,qCACA,yCACA,uCACAC,QAAA,oBACAC,MAAA,oCACA,+DACA,gEACA,oDACApvC,KAAA,kCACA,8DACA,+DACAqvC,MAAA,oBACA,kEACA,+BACA,+FACA,+GACA,+GACA,qEACA,qDACA,sEACA,wEAEA1c,QAAA,CACA2c,QAAA,CACAtd,QAAA,WACAC,YAAA,MAEA,iBACAD,QAAA,uBACAC,YAAA,CACA,kDACA1Y,SAAA,uBACAg2B,SAAA,qBACAC,IAAA,4BACAnrB,OAAA,WACA8F,MAAA,kCACA,uEACAslB,OAAA,WACAC,QAAA,YACAC,OAAA,kGAGAvT,UAAA,CACApK,QAAA,4CACAC,YAAA,MAEA2d,SAAA,CACA5d,QAAA,mGACAC,YAAA,MAEA,aACAD,QAAA,KACAC,YAAA,CACA,wCACA,yCACA,mDACA,8BACA,sDACA,8CACA,kDACA,wDACA,4CACA,0CACA,6BACAsE,IAAA,yDACA,8BAGA,uBACAvE,QAAA,iBACAC,YAAA,MAEA,uBACAD,QAAA,iBACAC,YAAA,CACA,4CACA,+BACA,iDAGA4d,OAAA,CACA7d,QAAA,0HACAC,YAAA,MAEA6d,UAAA,CACA9d,QAAA,mBACAC,YAAA,MAEA8d,MAAA,CACA/d,QAAA,gCACAC,YAAA,MAEAkK,MAAA,CACAnK,QAAA,qBACAC,YAAA,MAEA+d,UAAA,CACAhe,QAAA,uCACAC,YAAA,MAEA+b,KAAA,CACAhc,QAAA,uBACAC,YAAA,CACAge,MAAA,gBACAC,MAAA,qBACA,sDACAvyC,KAAA,iEAGA,gBACAq0B,QAAA,iBACAC,YAAA,CACA+Z,IAAA,UACA1M,KAAA,WACAwM,OAAA,aACApM,MAAA,YACA,4CACA,wCACA,8CACA,0CACA,gCACA,kCACA0N,MAAA,YACA,8BACA,gCACA,oCACA,kCACA,8CACA,0CACA,gDACA,4CACAG,OAAA,aACA,kCACA,oCACAwB,MAAA,YACA7B,OAAA,aACA,4BACA,8BACA,4BACA,8BACA,8BACA,gCACA,sCACA,wCACA,sCACA,wCACA,4CACA,kD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","sources":["webpack://element-web/../node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/array-set.js","webpack://element-web/../node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/base64-vlq.js","webpack://element-web/../node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/base64.js","webpack://element-web/../node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/mapping-list.js","webpack://element-web/../node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/source-map-generator.js","webpack://element-web/../node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/util.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/tokenizer/char-code-definitions.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/tokenizer/utils.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/tokenizer/index.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/utils/List.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/utils/create-custom-error.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/parser/SyntaxError.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/tokenizer/adopt-buffer.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/tokenizer/OffsetToLocation.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/tokenizer/names.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/tokenizer/TokenStream.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/parser/sequence.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/parser/create.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/generator/sourceMap.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/generator/token-before.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/generator/create.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/walker/create.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/definition-syntax/generate.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/lexer/error.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/utils/names.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/lexer/generic-const.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/lexer/generic-an-plus-b.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/lexer/generic-urange.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/lexer/generic.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/lexer/units.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/definition-syntax/SyntaxError.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/definition-syntax/scanner.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/definition-syntax/parse.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/definition-syntax/walk.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/lexer/prepare-tokens.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/lexer/match-graph.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/lexer/match.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/lexer/trace.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/lexer/search.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/lexer/structure.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/lexer/Lexer.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/config/mix.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/create.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/convertor/create.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/dist/data.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/AnPlusB.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Atrule.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/AtrulePrelude.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/AttributeSelector.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Block.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Brackets.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/CDC.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/CDO.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/ClassSelector.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Combinator.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Comment.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Condition.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Declaration.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/DeclarationList.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Dimension.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Feature.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/FeatureFunction.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/FeatureRange.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Function.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/GeneralEnclosed.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Hash.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Identifier.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/IdSelector.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Layer.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/LayerList.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/MediaQuery.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/MediaQueryList.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/NestingSelector.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Nth.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Number.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Operator.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Parentheses.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Percentage.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/PseudoClassSelector.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/PseudoElementSelector.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Ratio.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Raw.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Rule.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Scope.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Selector.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/SelectorList.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/utils/string.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/String.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/StyleSheet.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/SupportsDeclaration.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/TypeSelector.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/UnicodeRange.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Url.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/utils/url.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/Value.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/node/WhiteSpace.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/config/lexer.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/scope/default.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/scope/atrulePrelude.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/scope/selector.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/function/expression.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/function/var.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/scope/value.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/atrule/container.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/atrule/font-face.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/atrule/import.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/atrule/index.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/atrule/layer.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/atrule/media.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/atrule/nest.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/atrule/page.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/atrule/scope.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/atrule/starting-style.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/atrule/supports.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/pseudo/index.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/pseudo/lang.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/index.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/config/parser.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/syntax/config/walker.js","webpack://element-web/javascript/node_modules/.pnpm/source-map-loader@5.0.0_webpack@5.108.4/node_modules/source-map-loader/dist/node_modules/.pnpm/css-tree@3.2.1/node_modules/css-tree/lib/index.js"],"sourcesContent":["/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\nvar has = Object.prototype.hasOwnProperty;\nvar hasNativeMap = typeof Map !== \"undefined\";\n\n/**\n * A data structure which is a combination of an array and a set. Adding a new\n * member is O(1), testing for membership is O(1), and finding the index of an\n * element is O(1). Removing elements from the set is not supported. Only\n * strings are supported for membership.\n */\nfunction ArraySet() {\n this._array = [];\n this._set = hasNativeMap ? new Map() : Object.create(null);\n}\n\n/**\n * Static method for creating ArraySet instances from an existing array.\n */\nArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {\n var set = new ArraySet();\n for (var i = 0, len = aArray.length; i < len; i++) {\n set.add(aArray[i], aAllowDuplicates);\n }\n return set;\n};\n\n/**\n * Return how many unique items are in this ArraySet. If duplicates have been\n * added, than those do not count towards the size.\n *\n * @returns Number\n */\nArraySet.prototype.size = function ArraySet_size() {\n return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;\n};\n\n/**\n * Add the given string to this set.\n *\n * @param String aStr\n */\nArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {\n var sStr = hasNativeMap ? aStr : util.toSetString(aStr);\n var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);\n var idx = this._array.length;\n if (!isDuplicate || aAllowDuplicates) {\n this._array.push(aStr);\n }\n if (!isDuplicate) {\n if (hasNativeMap) {\n this._set.set(aStr, idx);\n } else {\n this._set[sStr] = idx;\n }\n }\n};\n\n/**\n * Is the given string a member of this set?\n *\n * @param String aStr\n */\nArraySet.prototype.has = function ArraySet_has(aStr) {\n if (hasNativeMap) {\n return this._set.has(aStr);\n } else {\n var sStr = util.toSetString(aStr);\n return has.call(this._set, sStr);\n }\n};\n\n/**\n * What is the index of the given string in the array?\n *\n * @param String aStr\n */\nArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {\n if (hasNativeMap) {\n var idx = this._set.get(aStr);\n if (idx >= 0) {\n return idx;\n }\n } else {\n var sStr = util.toSetString(aStr);\n if (has.call(this._set, sStr)) {\n return this._set[sStr];\n }\n }\n\n throw new Error('\"' + aStr + '\" is not in the set.');\n};\n\n/**\n * What is the element at the given index?\n *\n * @param Number aIdx\n */\nArraySet.prototype.at = function ArraySet_at(aIdx) {\n if (aIdx >= 0 && aIdx < this._array.length) {\n return this._array[aIdx];\n }\n throw new Error('No element indexed by ' + aIdx);\n};\n\n/**\n * Returns the array representation of this set (which has the proper indices\n * indicated by indexOf). Note that this is a copy of the internal array used\n * for storing the members so that no one can mess with internal state.\n */\nArraySet.prototype.toArray = function ArraySet_toArray() {\n return this._array.slice();\n};\n\nexports.ArraySet = ArraySet;\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n *\n * Based on the Base 64 VLQ implementation in Closure Compiler:\n * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java\n *\n * Copyright 2011 The Closure Compiler Authors. All rights reserved.\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * 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\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n * * Neither the name of Google Inc. nor the names of its\n * contributors may be used to endorse or promote products derived\n * from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nvar base64 = require('./base64');\n\n// A single base 64 digit can contain 6 bits of data. For the base 64 variable\n// length quantities we use in the source map spec, the first bit is the sign,\n// the next four bits are the actual value, and the 6th bit is the\n// continuation bit. The continuation bit tells us whether there are more\n// digits in this value following this digit.\n//\n// Continuation\n// | Sign\n// | |\n// V V\n// 101011\n\nvar VLQ_BASE_SHIFT = 5;\n\n// binary: 100000\nvar VLQ_BASE = 1 << VLQ_BASE_SHIFT;\n\n// binary: 011111\nvar VLQ_BASE_MASK = VLQ_BASE - 1;\n\n// binary: 100000\nvar VLQ_CONTINUATION_BIT = VLQ_BASE;\n\n/**\n * Converts from a two-complement value to a value where the sign bit is\n * placed in the least significant bit. For example, as decimals:\n * 1 becomes 2 (10 binary), -1 becomes 3 (11 binary)\n * 2 becomes 4 (100 binary), -2 becomes 5 (101 binary)\n */\nfunction toVLQSigned(aValue) {\n return aValue < 0\n ? ((-aValue) << 1) + 1\n : (aValue << 1) + 0;\n}\n\n/**\n * Converts to a two-complement value from a value where the sign bit is\n * placed in the least significant bit. For example, as decimals:\n * 2 (10 binary) becomes 1, 3 (11 binary) becomes -1\n * 4 (100 binary) becomes 2, 5 (101 binary) becomes -2\n */\nfunction fromVLQSigned(aValue) {\n var isNegative = (aValue & 1) === 1;\n var shifted = aValue >> 1;\n return isNegative\n ? -shifted\n : shifted;\n}\n\n/**\n * Returns the base 64 VLQ encoded value.\n */\nexports.encode = function base64VLQ_encode(aValue) {\n var encoded = \"\";\n var digit;\n\n var vlq = toVLQSigned(aValue);\n\n do {\n digit = vlq & VLQ_BASE_MASK;\n vlq >>>= VLQ_BASE_SHIFT;\n if (vlq > 0) {\n // There are still more digits in this value, so we must make sure the\n // continuation bit is marked.\n digit |= VLQ_CONTINUATION_BIT;\n }\n encoded += base64.encode(digit);\n } while (vlq > 0);\n\n return encoded;\n};\n\n/**\n * Decodes the next base 64 VLQ value from the given string and returns the\n * value and the rest of the string via the out parameter.\n */\nexports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {\n var strLen = aStr.length;\n var result = 0;\n var shift = 0;\n var continuation, digit;\n\n do {\n if (aIndex >= strLen) {\n throw new Error(\"Expected more digits in base 64 VLQ value.\");\n }\n\n digit = base64.decode(aStr.charCodeAt(aIndex++));\n if (digit === -1) {\n throw new Error(\"Invalid base64 digit: \" + aStr.charAt(aIndex - 1));\n }\n\n continuation = !!(digit & VLQ_CONTINUATION_BIT);\n digit &= VLQ_BASE_MASK;\n result = result + (digit << shift);\n shift += VLQ_BASE_SHIFT;\n } while (continuation);\n\n aOutParam.value = fromVLQSigned(result);\n aOutParam.rest = aIndex;\n};\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');\n\n/**\n * Encode an integer in the range of 0 to 63 to a single base 64 digit.\n */\nexports.encode = function (number) {\n if (0 <= number && number < intToCharMap.length) {\n return intToCharMap[number];\n }\n throw new TypeError(\"Must be between 0 and 63: \" + number);\n};\n\n/**\n * Decode a single base 64 character code digit to an integer. Returns -1 on\n * failure.\n */\nexports.decode = function (charCode) {\n var bigA = 65; // 'A'\n var bigZ = 90; // 'Z'\n\n var littleA = 97; // 'a'\n var littleZ = 122; // 'z'\n\n var zero = 48; // '0'\n var nine = 57; // '9'\n\n var plus = 43; // '+'\n var slash = 47; // '/'\n\n var littleOffset = 26;\n var numberOffset = 52;\n\n // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ\n if (bigA <= charCode && charCode <= bigZ) {\n return (charCode - bigA);\n }\n\n // 26 - 51: abcdefghijklmnopqrstuvwxyz\n if (littleA <= charCode && charCode <= littleZ) {\n return (charCode - littleA + littleOffset);\n }\n\n // 52 - 61: 0123456789\n if (zero <= charCode && charCode <= nine) {\n return (charCode - zero + numberOffset);\n }\n\n // 62: +\n if (charCode == plus) {\n return 62;\n }\n\n // 63: /\n if (charCode == slash) {\n return 63;\n }\n\n // Invalid base64 digit.\n return -1;\n};\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2014 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar util = require('./util');\n\n/**\n * Determine whether mappingB is after mappingA with respect to generated\n * position.\n */\nfunction generatedPositionAfter(mappingA, mappingB) {\n // Optimized for most common case\n var lineA = mappingA.generatedLine;\n var lineB = mappingB.generatedLine;\n var columnA = mappingA.generatedColumn;\n var columnB = mappingB.generatedColumn;\n return lineB > lineA || lineB == lineA && columnB >= columnA ||\n util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;\n}\n\n/**\n * A data structure to provide a sorted view of accumulated mappings in a\n * performance conscious manner. It trades a neglibable overhead in general\n * case for a large speedup in case of mappings being added in order.\n */\nfunction MappingList() {\n this._array = [];\n this._sorted = true;\n // Serves as infimum\n this._last = {generatedLine: -1, generatedColumn: 0};\n}\n\n/**\n * Iterate through internal items. This method takes the same arguments that\n * `Array.prototype.forEach` takes.\n *\n * NOTE: The order of the mappings is NOT guaranteed.\n */\nMappingList.prototype.unsortedForEach =\n function MappingList_forEach(aCallback, aThisArg) {\n this._array.forEach(aCallback, aThisArg);\n };\n\n/**\n * Add the given source mapping.\n *\n * @param Object aMapping\n */\nMappingList.prototype.add = function MappingList_add(aMapping) {\n if (generatedPositionAfter(this._last, aMapping)) {\n this._last = aMapping;\n this._array.push(aMapping);\n } else {\n this._sorted = false;\n this._array.push(aMapping);\n }\n};\n\n/**\n * Returns the flat, sorted array of mappings. The mappings are sorted by\n * generated position.\n *\n * WARNING: This method returns internal data without copying, for\n * performance. The return value must NOT be mutated, and should be treated as\n * an immutable borrow. If you want to take ownership, you must make your own\n * copy.\n */\nMappingList.prototype.toArray = function MappingList_toArray() {\n if (!this._sorted) {\n this._array.sort(util.compareByGeneratedPositionsInflated);\n this._sorted = true;\n }\n return this._array;\n};\n\nexports.MappingList = MappingList;\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\nvar base64VLQ = require('./base64-vlq');\nvar util = require('./util');\nvar ArraySet = require('./array-set').ArraySet;\nvar MappingList = require('./mapping-list').MappingList;\n\n/**\n * An instance of the SourceMapGenerator represents a source map which is\n * being built incrementally. You may pass an object with the following\n * properties:\n *\n * - file: The filename of the generated source.\n * - sourceRoot: A root for all relative URLs in this source map.\n */\nfunction SourceMapGenerator(aArgs) {\n if (!aArgs) {\n aArgs = {};\n }\n this._file = util.getArg(aArgs, 'file', null);\n this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);\n this._skipValidation = util.getArg(aArgs, 'skipValidation', false);\n this._ignoreInvalidMapping = util.getArg(aArgs, 'ignoreInvalidMapping', false);\n this._sources = new ArraySet();\n this._names = new ArraySet();\n this._mappings = new MappingList();\n this._sourcesContents = null;\n}\n\nSourceMapGenerator.prototype._version = 3;\n\n/**\n * Creates a new SourceMapGenerator based on a SourceMapConsumer\n *\n * @param aSourceMapConsumer The SourceMap.\n */\nSourceMapGenerator.fromSourceMap =\n function SourceMapGenerator_fromSourceMap(aSourceMapConsumer, generatorOps) {\n var sourceRoot = aSourceMapConsumer.sourceRoot;\n var generator = new SourceMapGenerator(Object.assign(generatorOps || {}, {\n file: aSourceMapConsumer.file,\n sourceRoot: sourceRoot\n }));\n aSourceMapConsumer.eachMapping(function (mapping) {\n var newMapping = {\n generated: {\n line: mapping.generatedLine,\n column: mapping.generatedColumn\n }\n };\n\n if (mapping.source != null) {\n newMapping.source = mapping.source;\n if (sourceRoot != null) {\n newMapping.source = util.relative(sourceRoot, newMapping.source);\n }\n\n newMapping.original = {\n line: mapping.originalLine,\n column: mapping.originalColumn\n };\n\n if (mapping.name != null) {\n newMapping.name = mapping.name;\n }\n }\n\n generator.addMapping(newMapping);\n });\n aSourceMapConsumer.sources.forEach(function (sourceFile) {\n var sourceRelative = sourceFile;\n if (sourceRoot !== null) {\n sourceRelative = util.relative(sourceRoot, sourceFile);\n }\n\n if (!generator._sources.has(sourceRelative)) {\n generator._sources.add(sourceRelative);\n }\n\n var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n if (content != null) {\n generator.setSourceContent(sourceFile, content);\n }\n });\n return generator;\n };\n\n/**\n * Add a single mapping from original source line and column to the generated\n * source's line and column for this source map being created. The mapping\n * object should have the following properties:\n *\n * - generated: An object with the generated line and column positions.\n * - original: An object with the original line and column positions.\n * - source: The original source file (relative to the sourceRoot).\n * - name: An optional original token name for this mapping.\n */\nSourceMapGenerator.prototype.addMapping =\n function SourceMapGenerator_addMapping(aArgs) {\n var generated = util.getArg(aArgs, 'generated');\n var original = util.getArg(aArgs, 'original', null);\n var source = util.getArg(aArgs, 'source', null);\n var name = util.getArg(aArgs, 'name', null);\n\n if (!this._skipValidation) {\n if (this._validateMapping(generated, original, source, name) === false) {\n return;\n }\n }\n\n if (source != null) {\n source = String(source);\n if (!this._sources.has(source)) {\n this._sources.add(source);\n }\n }\n\n if (name != null) {\n name = String(name);\n if (!this._names.has(name)) {\n this._names.add(name);\n }\n }\n\n this._mappings.add({\n generatedLine: generated.line,\n generatedColumn: generated.column,\n originalLine: original != null && original.line,\n originalColumn: original != null && original.column,\n source: source,\n name: name\n });\n };\n\n/**\n * Set the source content for a source file.\n */\nSourceMapGenerator.prototype.setSourceContent =\n function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {\n var source = aSourceFile;\n if (this._sourceRoot != null) {\n source = util.relative(this._sourceRoot, source);\n }\n\n if (aSourceContent != null) {\n // Add the source content to the _sourcesContents map.\n // Create a new _sourcesContents map if the property is null.\n if (!this._sourcesContents) {\n this._sourcesContents = Object.create(null);\n }\n this._sourcesContents[util.toSetString(source)] = aSourceContent;\n } else if (this._sourcesContents) {\n // Remove the source file from the _sourcesContents map.\n // If the _sourcesContents map is empty, set the property to null.\n delete this._sourcesContents[util.toSetString(source)];\n if (Object.keys(this._sourcesContents).length === 0) {\n this._sourcesContents = null;\n }\n }\n };\n\n/**\n * Applies the mappings of a sub-source-map for a specific source file to the\n * source map being generated. Each mapping to the supplied source file is\n * rewritten using the supplied source map. Note: The resolution for the\n * resulting mappings is the minimium of this map and the supplied map.\n *\n * @param aSourceMapConsumer The source map to be applied.\n * @param aSourceFile Optional. The filename of the source file.\n * If omitted, SourceMapConsumer's file property will be used.\n * @param aSourceMapPath Optional. The dirname of the path to the source map\n * to be applied. If relative, it is relative to the SourceMapConsumer.\n * This parameter is needed when the two source maps aren't in the same\n * directory, and the source map to be applied contains relative source\n * paths. If so, those relative source paths need to be rewritten\n * relative to the SourceMapGenerator.\n */\nSourceMapGenerator.prototype.applySourceMap =\n function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {\n var sourceFile = aSourceFile;\n // If aSourceFile is omitted, we will use the file property of the SourceMap\n if (aSourceFile == null) {\n if (aSourceMapConsumer.file == null) {\n throw new Error(\n 'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +\n 'or the source map\\'s \"file\" property. Both were omitted.'\n );\n }\n sourceFile = aSourceMapConsumer.file;\n }\n var sourceRoot = this._sourceRoot;\n // Make \"sourceFile\" relative if an absolute Url is passed.\n if (sourceRoot != null) {\n sourceFile = util.relative(sourceRoot, sourceFile);\n }\n // Applying the SourceMap can add and remove items from the sources and\n // the names array.\n var newSources = new ArraySet();\n var newNames = new ArraySet();\n\n // Find mappings for the \"sourceFile\"\n this._mappings.unsortedForEach(function (mapping) {\n if (mapping.source === sourceFile && mapping.originalLine != null) {\n // Check if it can be mapped by the source map, then update the mapping.\n var original = aSourceMapConsumer.originalPositionFor({\n line: mapping.originalLine,\n column: mapping.originalColumn\n });\n if (original.source != null) {\n // Copy mapping\n mapping.source = original.source;\n if (aSourceMapPath != null) {\n mapping.source = util.join(aSourceMapPath, mapping.source)\n }\n if (sourceRoot != null) {\n mapping.source = util.relative(sourceRoot, mapping.source);\n }\n mapping.originalLine = original.line;\n mapping.originalColumn = original.column;\n if (original.name != null) {\n mapping.name = original.name;\n }\n }\n }\n\n var source = mapping.source;\n if (source != null && !newSources.has(source)) {\n newSources.add(source);\n }\n\n var name = mapping.name;\n if (name != null && !newNames.has(name)) {\n newNames.add(name);\n }\n\n }, this);\n this._sources = newSources;\n this._names = newNames;\n\n // Copy sourcesContents of applied map.\n aSourceMapConsumer.sources.forEach(function (sourceFile) {\n var content = aSourceMapConsumer.sourceContentFor(sourceFile);\n if (content != null) {\n if (aSourceMapPath != null) {\n sourceFile = util.join(aSourceMapPath, sourceFile);\n }\n if (sourceRoot != null) {\n sourceFile = util.relative(sourceRoot, sourceFile);\n }\n this.setSourceContent(sourceFile, content);\n }\n }, this);\n };\n\n/**\n * A mapping can have one of the three levels of data:\n *\n * 1. Just the generated position.\n * 2. The Generated position, original position, and original source.\n * 3. Generated and original position, original source, as well as a name\n * token.\n *\n * To maintain consistency, we validate that any new mapping being added falls\n * in to one of these categories.\n */\nSourceMapGenerator.prototype._validateMapping =\n function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,\n aName) {\n // When aOriginal is truthy but has empty values for .line and .column,\n // it is most likely a programmer error. In this case we throw a very\n // specific error message to try to guide them the right way.\n // For example: https://github.com/Polymer/polymer-bundler/pull/519\n if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {\n var message = 'original.line and original.column are not numbers -- you probably meant to omit ' +\n 'the original mapping entirely and only map the generated position. If so, pass ' +\n 'null for the original mapping instead of an object with empty or null values.'\n\n if (this._ignoreInvalidMapping) {\n if (typeof console !== 'undefined' && console.warn) {\n console.warn(message);\n }\n return false;\n } else {\n throw new Error(message);\n }\n }\n\n if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n && aGenerated.line > 0 && aGenerated.column >= 0\n && !aOriginal && !aSource && !aName) {\n // Case 1.\n return;\n }\n else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated\n && aOriginal && 'line' in aOriginal && 'column' in aOriginal\n && aGenerated.line > 0 && aGenerated.column >= 0\n && aOriginal.line > 0 && aOriginal.column >= 0\n && aSource) {\n // Cases 2 and 3.\n return;\n }\n else {\n var message = 'Invalid mapping: ' + JSON.stringify({\n generated: aGenerated,\n source: aSource,\n original: aOriginal,\n name: aName\n });\n\n if (this._ignoreInvalidMapping) {\n if (typeof console !== 'undefined' && console.warn) {\n console.warn(message);\n }\n return false;\n } else {\n throw new Error(message)\n }\n }\n };\n\n/**\n * Serialize the accumulated mappings in to the stream of base 64 VLQs\n * specified by the source map format.\n */\nSourceMapGenerator.prototype._serializeMappings =\n function SourceMapGenerator_serializeMappings() {\n var previousGeneratedColumn = 0;\n var previousGeneratedLine = 1;\n var previousOriginalColumn = 0;\n var previousOriginalLine = 0;\n var previousName = 0;\n var previousSource = 0;\n var result = '';\n var next;\n var mapping;\n var nameIdx;\n var sourceIdx;\n\n var mappings = this._mappings.toArray();\n for (var i = 0, len = mappings.length; i < len; i++) {\n mapping = mappings[i];\n next = ''\n\n if (mapping.generatedLine !== previousGeneratedLine) {\n previousGeneratedColumn = 0;\n while (mapping.generatedLine !== previousGeneratedLine) {\n next += ';';\n previousGeneratedLine++;\n }\n }\n else {\n if (i > 0) {\n if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {\n continue;\n }\n next += ',';\n }\n }\n\n next += base64VLQ.encode(mapping.generatedColumn\n - previousGeneratedColumn);\n previousGeneratedColumn = mapping.generatedColumn;\n\n if (mapping.source != null) {\n sourceIdx = this._sources.indexOf(mapping.source);\n next += base64VLQ.encode(sourceIdx - previousSource);\n previousSource = sourceIdx;\n\n // lines are stored 0-based in SourceMap spec version 3\n next += base64VLQ.encode(mapping.originalLine - 1\n - previousOriginalLine);\n previousOriginalLine = mapping.originalLine - 1;\n\n next += base64VLQ.encode(mapping.originalColumn\n - previousOriginalColumn);\n previousOriginalColumn = mapping.originalColumn;\n\n if (mapping.name != null) {\n nameIdx = this._names.indexOf(mapping.name);\n next += base64VLQ.encode(nameIdx - previousName);\n previousName = nameIdx;\n }\n }\n\n result += next;\n }\n\n return result;\n };\n\nSourceMapGenerator.prototype._generateSourcesContent =\n function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {\n return aSources.map(function (source) {\n if (!this._sourcesContents) {\n return null;\n }\n if (aSourceRoot != null) {\n source = util.relative(aSourceRoot, source);\n }\n var key = util.toSetString(source);\n return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)\n ? this._sourcesContents[key]\n : null;\n }, this);\n };\n\n/**\n * Externalize the source map.\n */\nSourceMapGenerator.prototype.toJSON =\n function SourceMapGenerator_toJSON() {\n var map = {\n version: this._version,\n sources: this._sources.toArray(),\n names: this._names.toArray(),\n mappings: this._serializeMappings()\n };\n if (this._file != null) {\n map.file = this._file;\n }\n if (this._sourceRoot != null) {\n map.sourceRoot = this._sourceRoot;\n }\n if (this._sourcesContents) {\n map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);\n }\n\n return map;\n };\n\n/**\n * Render the source map being generated to a string.\n */\nSourceMapGenerator.prototype.toString =\n function SourceMapGenerator_toString() {\n return JSON.stringify(this.toJSON());\n };\n\nexports.SourceMapGenerator = SourceMapGenerator;\n","/* -*- Mode: js; js-indent-level: 2; -*- */\n/*\n * Copyright 2011 Mozilla Foundation and contributors\n * Licensed under the New BSD license. See LICENSE or:\n * http://opensource.org/licenses/BSD-3-Clause\n */\n\n/**\n * This is a helper function for getting values from parameter/options\n * objects.\n *\n * @param args The object we are extracting values from\n * @param name The name of the property we are getting.\n * @param defaultValue An optional value to return if the property is missing\n * from the object. If this is not specified and the property is missing, an\n * error will be thrown.\n */\nfunction getArg(aArgs, aName, aDefaultValue) {\n if (aName in aArgs) {\n return aArgs[aName];\n } else if (arguments.length === 3) {\n return aDefaultValue;\n } else {\n throw new Error('\"' + aName + '\" is a required argument.');\n }\n}\nexports.getArg = getArg;\n\nvar urlRegexp = /^(?:([\\w+\\-.]+):)?\\/\\/(?:(\\w+:\\w+)@)?([\\w.-]*)(?::(\\d+))?(.*)$/;\nvar dataUrlRegexp = /^data:.+\\,.+$/;\n\nfunction urlParse(aUrl) {\n var match = aUrl.match(urlRegexp);\n if (!match) {\n return null;\n }\n return {\n scheme: match[1],\n auth: match[2],\n host: match[3],\n port: match[4],\n path: match[5]\n };\n}\nexports.urlParse = urlParse;\n\nfunction urlGenerate(aParsedUrl) {\n var url = '';\n if (aParsedUrl.scheme) {\n url += aParsedUrl.scheme + ':';\n }\n url += '//';\n if (aParsedUrl.auth) {\n url += aParsedUrl.auth + '@';\n }\n if (aParsedUrl.host) {\n url += aParsedUrl.host;\n }\n if (aParsedUrl.port) {\n url += \":\" + aParsedUrl.port\n }\n if (aParsedUrl.path) {\n url += aParsedUrl.path;\n }\n return url;\n}\nexports.urlGenerate = urlGenerate;\n\nvar MAX_CACHED_INPUTS = 32;\n\n/**\n * Takes some function `f(input) -> result` and returns a memoized version of\n * `f`.\n *\n * We keep at most `MAX_CACHED_INPUTS` memoized results of `f` alive. The\n * memoization is a dumb-simple, linear least-recently-used cache.\n */\nfunction lruMemoize(f) {\n var cache = [];\n\n return function(input) {\n for (var i = 0; i < cache.length; i++) {\n if (cache[i].input === input) {\n var temp = cache[0];\n cache[0] = cache[i];\n cache[i] = temp;\n return cache[0].result;\n }\n }\n\n var result = f(input);\n\n cache.unshift({\n input,\n result,\n });\n\n if (cache.length > MAX_CACHED_INPUTS) {\n cache.pop();\n }\n\n return result;\n };\n}\n\n/**\n * Normalizes a path, or the path portion of a URL:\n *\n * - Replaces consecutive slashes with one slash.\n * - Removes unnecessary '.' parts.\n * - Removes unnecessary '<dir>/..' parts.\n *\n * Based on code in the Node.js 'path' core module.\n *\n * @param aPath The path or url to normalize.\n */\nvar normalize = lruMemoize(function normalize(aPath) {\n var path = aPath;\n var url = urlParse(aPath);\n if (url) {\n if (!url.path) {\n return aPath;\n }\n path = url.path;\n }\n var isAbsolute = exports.isAbsolute(path);\n // Split the path into parts between `/` characters. This is much faster than\n // using `.split(/\\/+/g)`.\n var parts = [];\n var start = 0;\n var i = 0;\n while (true) {\n start = i;\n i = path.indexOf(\"/\", start);\n if (i === -1) {\n parts.push(path.slice(start));\n break;\n } else {\n parts.push(path.slice(start, i));\n while (i < path.length && path[i] === \"/\") {\n i++;\n }\n }\n }\n\n for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {\n part = parts[i];\n if (part === '.') {\n parts.splice(i, 1);\n } else if (part === '..') {\n up++;\n } else if (up > 0) {\n if (part === '') {\n // The first part is blank if the path is absolute. Trying to go\n // above the root is a no-op. Therefore we can remove all '..' parts\n // directly after the root.\n parts.splice(i + 1, up);\n up = 0;\n } else {\n parts.splice(i, 2);\n up--;\n }\n }\n }\n path = parts.join('/');\n\n if (path === '') {\n path = isAbsolute ? '/' : '.';\n }\n\n if (url) {\n url.path = path;\n return urlGenerate(url);\n }\n return path;\n});\nexports.normalize = normalize;\n\n/**\n * Joins two paths/URLs.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be joined with the root.\n *\n * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a\n * scheme-relative URL: Then the scheme of aRoot, if any, is prepended\n * first.\n * - Otherwise aPath is a path. If aRoot is a URL, then its path portion\n * is updated with the result and aRoot is returned. Otherwise the result\n * is returned.\n * - If aPath is absolute, the result is aPath.\n * - Otherwise the two paths are joined with a slash.\n * - Joining for example 'http://' and 'www.example.com' is also supported.\n */\nfunction join(aRoot, aPath) {\n if (aRoot === \"\") {\n aRoot = \".\";\n }\n if (aPath === \"\") {\n aPath = \".\";\n }\n var aPathUrl = urlParse(aPath);\n var aRootUrl = urlParse(aRoot);\n if (aRootUrl) {\n aRoot = aRootUrl.path || '/';\n }\n\n // `join(foo, '//www.example.org')`\n if (aPathUrl && !aPathUrl.scheme) {\n if (aRootUrl) {\n aPathUrl.scheme = aRootUrl.scheme;\n }\n return urlGenerate(aPathUrl);\n }\n\n if (aPathUrl || aPath.match(dataUrlRegexp)) {\n return aPath;\n }\n\n // `join('http://', 'www.example.com')`\n if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {\n aRootUrl.host = aPath;\n return urlGenerate(aRootUrl);\n }\n\n var joined = aPath.charAt(0) === '/'\n ? aPath\n : normalize(aRoot.replace(/\\/+$/, '') + '/' + aPath);\n\n if (aRootUrl) {\n aRootUrl.path = joined;\n return urlGenerate(aRootUrl);\n }\n return joined;\n}\nexports.join = join;\n\nexports.isAbsolute = function (aPath) {\n return aPath.charAt(0) === '/' || urlRegexp.test(aPath);\n};\n\n/**\n * Make a path relative to a URL or another path.\n *\n * @param aRoot The root path or URL.\n * @param aPath The path or URL to be made relative to aRoot.\n */\nfunction relative(aRoot, aPath) {\n if (aRoot === \"\") {\n aRoot = \".\";\n }\n\n aRoot = aRoot.replace(/\\/$/, '');\n\n // It is possible for the path to be above the root. In this case, simply\n // checking whether the root is a prefix of the path won't work. Instead, we\n // need to remove components from the root one by one, until either we find\n // a prefix that fits, or we run out of components to remove.\n var level = 0;\n while (aPath.indexOf(aRoot + '/') !== 0) {\n var index = aRoot.lastIndexOf(\"/\");\n if (index < 0) {\n return aPath;\n }\n\n // If the only part of the root that is left is the scheme (i.e. http://,\n // file:///, etc.), one or more slashes (/), or simply nothing at all, we\n // have exhausted all components, so the path is not relative to the root.\n aRoot = aRoot.slice(0, index);\n if (aRoot.match(/^([^\\/]+:\\/)?\\/*$/)) {\n return aPath;\n }\n\n ++level;\n }\n\n // Make sure we add a \"../\" for each component we removed from the root.\n return Array(level + 1).join(\"../\") + aPath.substr(aRoot.length + 1);\n}\nexports.relative = relative;\n\nvar supportsNullProto = (function () {\n var obj = Object.create(null);\n return !('__proto__' in obj);\n}());\n\nfunction identity (s) {\n return s;\n}\n\n/**\n * Because behavior goes wacky when you set `__proto__` on objects, we\n * have to prefix all the strings in our set with an arbitrary character.\n *\n * See https://github.com/mozilla/source-map/pull/31 and\n * https://github.com/mozilla/source-map/issues/30\n *\n * @param String aStr\n */\nfunction toSetString(aStr) {\n if (isProtoString(aStr)) {\n return '$' + aStr;\n }\n\n return aStr;\n}\nexports.toSetString = supportsNullProto ? identity : toSetString;\n\nfunction fromSetString(aStr) {\n if (isProtoString(aStr)) {\n return aStr.slice(1);\n }\n\n return aStr;\n}\nexports.fromSetString = supportsNullProto ? identity : fromSetString;\n\nfunction isProtoString(s) {\n if (!s) {\n return false;\n }\n\n var length = s.length;\n\n if (length < 9 /* \"__proto__\".length */) {\n return false;\n }\n\n if (s.charCodeAt(length - 1) !== 95 /* '_' */ ||\n s.charCodeAt(length - 2) !== 95 /* '_' */ ||\n s.charCodeAt(length - 3) !== 111 /* 'o' */ ||\n s.charCodeAt(length - 4) !== 116 /* 't' */ ||\n s.charCodeAt(length - 5) !== 111 /* 'o' */ ||\n s.charCodeAt(length - 6) !== 114 /* 'r' */ ||\n s.charCodeAt(length - 7) !== 112 /* 'p' */ ||\n s.charCodeAt(length - 8) !== 95 /* '_' */ ||\n s.charCodeAt(length - 9) !== 95 /* '_' */) {\n return false;\n }\n\n for (var i = length - 10; i >= 0; i--) {\n if (s.charCodeAt(i) !== 36 /* '$' */) {\n return false;\n }\n }\n\n return true;\n}\n\n/**\n * Comparator between two mappings where the original positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same original source/line/column, but different generated\n * line and column the same. Useful when searching for a mapping with a\n * stubbed out mapping.\n */\nfunction compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {\n var cmp = strcmp(mappingA.source, mappingB.source);\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalLine - mappingB.originalLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalColumn - mappingB.originalColumn;\n if (cmp !== 0 || onlyCompareOriginal) {\n return cmp;\n }\n\n cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.generatedLine - mappingB.generatedLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByOriginalPositions = compareByOriginalPositions;\n\nfunction compareByOriginalPositionsNoSource(mappingA, mappingB, onlyCompareOriginal) {\n var cmp\n\n cmp = mappingA.originalLine - mappingB.originalLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalColumn - mappingB.originalColumn;\n if (cmp !== 0 || onlyCompareOriginal) {\n return cmp;\n }\n\n cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.generatedLine - mappingB.generatedLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByOriginalPositionsNoSource = compareByOriginalPositionsNoSource;\n\n/**\n * Comparator between two mappings with deflated source and name indices where\n * the generated positions are compared.\n *\n * Optionally pass in `true` as `onlyCompareGenerated` to consider two\n * mappings with the same generated line and column, but different\n * source/name/original line and column the same. Useful when searching for a\n * mapping with a stubbed out mapping.\n */\nfunction compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {\n var cmp = mappingA.generatedLine - mappingB.generatedLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n if (cmp !== 0 || onlyCompareGenerated) {\n return cmp;\n }\n\n cmp = strcmp(mappingA.source, mappingB.source);\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalLine - mappingB.originalLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalColumn - mappingB.originalColumn;\n if (cmp !== 0) {\n return cmp;\n }\n\n return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;\n\nfunction compareByGeneratedPositionsDeflatedNoLine(mappingA, mappingB, onlyCompareGenerated) {\n var cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n if (cmp !== 0 || onlyCompareGenerated) {\n return cmp;\n }\n\n cmp = strcmp(mappingA.source, mappingB.source);\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalLine - mappingB.originalLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalColumn - mappingB.originalColumn;\n if (cmp !== 0) {\n return cmp;\n }\n\n return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByGeneratedPositionsDeflatedNoLine = compareByGeneratedPositionsDeflatedNoLine;\n\nfunction strcmp(aStr1, aStr2) {\n if (aStr1 === aStr2) {\n return 0;\n }\n\n if (aStr1 === null) {\n return 1; // aStr2 !== null\n }\n\n if (aStr2 === null) {\n return -1; // aStr1 !== null\n }\n\n if (aStr1 > aStr2) {\n return 1;\n }\n\n return -1;\n}\n\n/**\n * Comparator between two mappings with inflated source and name strings where\n * the generated positions are compared.\n */\nfunction compareByGeneratedPositionsInflated(mappingA, mappingB) {\n var cmp = mappingA.generatedLine - mappingB.generatedLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.generatedColumn - mappingB.generatedColumn;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = strcmp(mappingA.source, mappingB.source);\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalLine - mappingB.originalLine;\n if (cmp !== 0) {\n return cmp;\n }\n\n cmp = mappingA.originalColumn - mappingB.originalColumn;\n if (cmp !== 0) {\n return cmp;\n }\n\n return strcmp(mappingA.name, mappingB.name);\n}\nexports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;\n\n/**\n * Strip any JSON XSSI avoidance prefix from the string (as documented\n * in the source maps specification), and then parse the string as\n * JSON.\n */\nfunction parseSourceMapInput(str) {\n return JSON.parse(str.replace(/^\\)]}'[^\\n]*\\n/, ''));\n}\nexports.parseSourceMapInput = parseSourceMapInput;\n\n/**\n * Compute the URL of a source given the the source root, the source's\n * URL, and the source map's URL.\n */\nfunction computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {\n sourceURL = sourceURL || '';\n\n if (sourceRoot) {\n // This follows what Chrome does.\n if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {\n sourceRoot += '/';\n }\n // The spec says:\n // Line 4: An optional source root, useful for relocating source\n // files on a server or removing repeated values in the\n // “sources” entry. This value is prepended to the individual\n // entries in the “source” field.\n sourceURL = sourceRoot + sourceURL;\n }\n\n // Historically, SourceMapConsumer did not take the sourceMapURL as\n // a parameter. This mode is still somewhat supported, which is why\n // this code block is conditional. However, it's preferable to pass\n // the source map URL to SourceMapConsumer, so that this function\n // can implement the source URL resolution algorithm as outlined in\n // the spec. This block is basically the equivalent of:\n // new URL(sourceURL, sourceMapURL).toString()\n // ... except it avoids using URL, which wasn't available in the\n // older releases of node still supported by this library.\n //\n // The spec says:\n // If the sources are not absolute URLs after prepending of the\n // “sourceRoot”, the sources are resolved relative to the\n // SourceMap (like resolving script src in a html document).\n if (sourceMapURL) {\n var parsed = urlParse(sourceMapURL);\n if (!parsed) {\n throw new Error(\"sourceMapURL could not be parsed\");\n }\n if (parsed.path) {\n // Strip the last path component, but keep the \"/\".\n var index = parsed.path.lastIndexOf('/');\n if (index >= 0) {\n parsed.path = parsed.path.substring(0, index + 1);\n }\n }\n sourceURL = join(urlGenerate(parsed), sourceURL);\n }\n\n return normalize(sourceURL);\n}\nexports.computeSourceURL = computeSourceURL;\n","const EOF = 0;\n\n// https://drafts.csswg.org/css-syntax-3/\n// § 4.2. Definitions\n\n// digit\n// A code point between U+0030 DIGIT ZERO (0) and U+0039 DIGIT NINE (9).\nexport function isDigit(code) {\n return code >= 0x0030 && code <= 0x0039;\n}\n\n// hex digit\n// A digit, or a code point between U+0041 LATIN CAPITAL LETTER A (A) and U+0046 LATIN CAPITAL LETTER F (F),\n// or a code point between U+0061 LATIN SMALL LETTER A (a) and U+0066 LATIN SMALL LETTER F (f).\nexport function isHexDigit(code) {\n return (\n isDigit(code) || // 0 .. 9\n (code >= 0x0041 && code <= 0x0046) || // A .. F\n (code >= 0x0061 && code <= 0x0066) // a .. f\n );\n}\n\n// uppercase letter\n// A code point between U+0041 LATIN CAPITAL LETTER A (A) and U+005A LATIN CAPITAL LETTER Z (Z).\nexport function isUppercaseLetter(code) {\n return code >= 0x0041 && code <= 0x005A;\n}\n\n// lowercase letter\n// A code point between U+0061 LATIN SMALL LETTER A (a) and U+007A LATIN SMALL LETTER Z (z).\nexport function isLowercaseLetter(code) {\n return code >= 0x0061 && code <= 0x007A;\n}\n\n// letter\n// An uppercase letter or a lowercase letter.\nexport function isLetter(code) {\n return isUppercaseLetter(code) || isLowercaseLetter(code);\n}\n\n// non-ASCII code point\n// A code point with a value equal to or greater than U+0080 <control>.\n//\n// 2024-09-02: The latest spec narrows the range for non-ASCII characters (see https://github.com/csstree/csstree/issues/188).\n// However, all modern browsers support a wider range, and strictly following the latest spec could result\n// in some CSS being parsed incorrectly, even though it works in the browser. Therefore, this function adheres\n// to the previous, broader definition of non-ASCII characters.\nexport function isNonAscii(code) {\n return code >= 0x0080;\n}\n\n// name-start code point\n// A letter, a non-ASCII code point, or U+005F LOW LINE (_).\nexport function isNameStart(code) {\n return isLetter(code) || isNonAscii(code) || code === 0x005F;\n}\n\n// name code point\n// A name-start code point, a digit, or U+002D HYPHEN-MINUS (-).\nexport function isName(code) {\n return isNameStart(code) || isDigit(code) || code === 0x002D;\n}\n\n// non-printable code point\n// A code point between U+0000 NULL and U+0008 BACKSPACE, or U+000B LINE TABULATION,\n// or a code point between U+000E SHIFT OUT and U+001F INFORMATION SEPARATOR ONE, or U+007F DELETE.\nexport function isNonPrintable(code) {\n return (\n (code >= 0x0000 && code <= 0x0008) ||\n (code === 0x000B) ||\n (code >= 0x000E && code <= 0x001F) ||\n (code === 0x007F)\n );\n}\n\n// newline\n// U+000A LINE FEED. Note that U+000D CARRIAGE RETURN and U+000C FORM FEED are not included in this definition,\n// as they are converted to U+000A LINE FEED during preprocessing.\n// TODO: we doesn't do a preprocessing, so check a code point for U+000D CARRIAGE RETURN and U+000C FORM FEED\nexport function isNewline(code) {\n return code === 0x000A || code === 0x000D || code === 0x000C;\n}\n\n// whitespace\n// A newline, U+0009 CHARACTER TABULATION, or U+0020 SPACE.\nexport function isWhiteSpace(code) {\n return isNewline(code) || code === 0x0020 || code === 0x0009;\n}\n\n// § 4.3.8. Check if two code points are a valid escape\nexport function isValidEscape(first, second) {\n // If the first code point is not U+005C REVERSE SOLIDUS (\\), return false.\n if (first !== 0x005C) {\n return false;\n }\n\n // Otherwise, if the second code point is a newline or EOF, return false.\n if (isNewline(second) || second === EOF) {\n return false;\n }\n\n // Otherwise, return true.\n return true;\n}\n\n// § 4.3.9. Check if three code points would start an identifier\nexport function isIdentifierStart(first, second, third) {\n // Look at the first code point:\n\n // U+002D HYPHEN-MINUS\n if (first === 0x002D) {\n // If the second code point is a name-start code point or a U+002D HYPHEN-MINUS,\n // or the second and third code points are a valid escape, return true. Otherwise, return false.\n return (\n isNameStart(second) ||\n second === 0x002D ||\n isValidEscape(second, third)\n );\n }\n\n // name-start code point\n if (isNameStart(first)) {\n // Return true.\n return true;\n }\n\n // U+005C REVERSE SOLIDUS (\\)\n if (first === 0x005C) {\n // If the first and second code points are a valid escape, return true. Otherwise, return false.\n return isValidEscape(first, second);\n }\n\n // anything else\n // Return false.\n return false;\n}\n\n// § 4.3.10. Check if three code points would start a number\nexport function isNumberStart(first, second, third) {\n // Look at the first code point:\n\n // U+002B PLUS SIGN (+)\n // U+002D HYPHEN-MINUS (-)\n if (first === 0x002B || first === 0x002D) {\n // If the second code point is a digit, return true.\n if (isDigit(second)) {\n return 2;\n }\n\n // Otherwise, if the second code point is a U+002E FULL STOP (.)\n // and the third code point is a digit, return true.\n // Otherwise, return false.\n return second === 0x002E && isDigit(third) ? 3 : 0;\n }\n\n // U+002E FULL STOP (.)\n if (first === 0x002E) {\n // If the second code point is a digit, return true. Otherwise, return false.\n return isDigit(second) ? 2 : 0;\n }\n\n // digit\n if (isDigit(first)) {\n // Return true.\n return 1;\n }\n\n // anything else\n // Return false.\n return 0;\n}\n\n//\n// Misc\n//\n\n// detect BOM (https://en.wikipedia.org/wiki/Byte_order_mark)\nexport function isBOM(code) {\n // UTF-16BE\n if (code === 0xFEFF) {\n return 1;\n }\n\n // UTF-16LE\n if (code === 0xFFFE) {\n return 1;\n }\n\n return 0;\n}\n\n// Fast code category\n// Only ASCII code points has a special meaning, that's why we define a maps for 0..127 codes only\nconst CATEGORY = new Array(0x80);\nexport const EofCategory = 0x80;\nexport const WhiteSpaceCategory = 0x82;\nexport const DigitCategory = 0x83;\nexport const NameStartCategory = 0x84;\nexport const NonPrintableCategory = 0x85;\n\nfor (let i = 0; i < CATEGORY.length; i++) {\n CATEGORY[i] =\n isWhiteSpace(i) && WhiteSpaceCategory ||\n isDigit(i) && DigitCategory ||\n isNameStart(i) && NameStartCategory ||\n isNonPrintable(i) && NonPrintableCategory ||\n i || EofCategory;\n}\n\nexport function charCodeCategory(code) {\n return code < 0x80 ? CATEGORY[code] : NameStartCategory;\n}\n","import {\n isDigit,\n isHexDigit,\n isUppercaseLetter,\n isName,\n isWhiteSpace,\n isValidEscape\n} from './char-code-definitions.js';\n\nfunction getCharCode(source, offset) {\n return offset < source.length ? source.charCodeAt(offset) : 0;\n}\n\nexport function getNewlineLength(source, offset, code) {\n if (code === 13 /* \\r */ && getCharCode(source, offset + 1) === 10 /* \\n */) {\n return 2;\n }\n\n return 1;\n}\n\nexport function cmpChar(testStr, offset, referenceCode) {\n let code = testStr.charCodeAt(offset);\n\n // code.toLowerCase() for A..Z\n if (isUppercaseLetter(code)) {\n code = code | 32;\n }\n\n return code === referenceCode;\n}\n\nexport function cmpStr(testStr, start, end, referenceStr) {\n if (end - start !== referenceStr.length) {\n return false;\n }\n\n if (start < 0 || end > testStr.length) {\n return false;\n }\n\n for (let i = start; i < end; i++) {\n const referenceCode = referenceStr.charCodeAt(i - start);\n let testCode = testStr.charCodeAt(i);\n\n // testCode.toLowerCase() for A..Z\n if (isUppercaseLetter(testCode)) {\n testCode = testCode | 32;\n }\n\n if (testCode !== referenceCode) {\n return false;\n }\n }\n\n return true;\n}\n\nexport function findWhiteSpaceStart(source, offset) {\n for (; offset >= 0; offset--) {\n if (!isWhiteSpace(source.charCodeAt(offset))) {\n break;\n }\n }\n\n return offset + 1;\n}\n\nexport function findWhiteSpaceEnd(source, offset) {\n for (; offset < source.length; offset++) {\n if (!isWhiteSpace(source.charCodeAt(offset))) {\n break;\n }\n }\n\n return offset;\n}\n\nexport function findDecimalNumberEnd(source, offset) {\n for (; offset < source.length; offset++) {\n if (!isDigit(source.charCodeAt(offset))) {\n break;\n }\n }\n\n return offset;\n}\n\n// § 4.3.7. Consume an escaped code point\nexport function consumeEscaped(source, offset) {\n // It assumes that the U+005C REVERSE SOLIDUS (\\) has already been consumed and\n // that the next input code point has already been verified to be part of a valid escape.\n offset += 2;\n\n // hex digit\n if (isHexDigit(getCharCode(source, offset - 1))) {\n // Consume as many hex digits as possible, but no more than 5.\n // Note that this means 1-6 hex digits have been consumed in total.\n for (const maxOffset = Math.min(source.length, offset + 5); offset < maxOffset; offset++) {\n if (!isHexDigit(getCharCode(source, offset))) {\n break;\n }\n }\n\n // If the next input code point is whitespace, consume it as well.\n const code = getCharCode(source, offset);\n if (isWhiteSpace(code)) {\n offset += getNewlineLength(source, offset, code);\n }\n }\n\n return offset;\n}\n\n// §4.3.11. Consume a name\n// Note: This algorithm does not do the verification of the first few code points that are necessary\n// to ensure the returned code points would constitute an <ident-token>. If that is the intended use,\n// ensure that the stream starts with an identifier before calling this algorithm.\nexport function consumeName(source, offset) {\n // Let result initially be an empty string.\n // Repeatedly consume the next input code point from the stream:\n for (; offset < source.length; offset++) {\n const code = source.charCodeAt(offset);\n\n // name code point\n if (isName(code)) {\n // Append the code point to result.\n continue;\n }\n\n // the stream starts with a valid escape\n if (isValidEscape(code, getCharCode(source, offset + 1))) {\n // Consume an escaped code point. Append the returned code point to result.\n offset = consumeEscaped(source, offset) - 1;\n continue;\n }\n\n // anything else\n // Reconsume the current input code point. Return result.\n break;\n }\n\n return offset;\n}\n\n// §4.3.12. Consume a number\nexport function consumeNumber(source, offset) {\n let code = source.charCodeAt(offset);\n\n // 2. If the next input code point is U+002B PLUS SIGN (+) or U+002D HYPHEN-MINUS (-),\n // consume it and append it to repr.\n if (code === 0x002B || code === 0x002D) {\n code = source.charCodeAt(offset += 1);\n }\n\n // 3. While the next input code point is a digit, consume it and append it to repr.\n if (isDigit(code)) {\n offset = findDecimalNumberEnd(source, offset + 1);\n code = source.charCodeAt(offset);\n }\n\n // 4. If the next 2 input code points are U+002E FULL STOP (.) followed by a digit, then:\n if (code === 0x002E && isDigit(source.charCodeAt(offset + 1))) {\n // 4.1 Consume them.\n // 4.2 Append them to repr.\n offset += 2;\n\n // 4.3 Set type to \"number\".\n // TODO\n\n // 4.4 While the next input code point is a digit, consume it and append it to repr.\n\n offset = findDecimalNumberEnd(source, offset);\n }\n\n // 5. If the next 2 or 3 input code points are U+0045 LATIN CAPITAL LETTER E (E)\n // or U+0065 LATIN SMALL LETTER E (e), ... , followed by a digit, then:\n if (cmpChar(source, offset, 101 /* e */)) {\n let sign = 0;\n code = source.charCodeAt(offset + 1);\n\n // ... optionally followed by U+002D HYPHEN-MINUS (-) or U+002B PLUS SIGN (+) ...\n if (code === 0x002D || code === 0x002B) {\n sign = 1;\n code = source.charCodeAt(offset + 2);\n }\n\n // ... followed by a digit\n if (isDigit(code)) {\n // 5.1 Consume them.\n // 5.2 Append them to repr.\n\n // 5.3 Set type to \"number\".\n // TODO\n\n // 5.4 While the next input code point is a digit, consume it and append it to repr.\n offset = findDecimalNumberEnd(source, offset + 1 + sign + 1);\n }\n }\n\n return offset;\n}\n\n// § 4.3.14. Consume the remnants of a bad url\n// ... its sole use is to consume enough of the input stream to reach a recovery point\n// where normal tokenizing can resume.\nexport function consumeBadUrlRemnants(source, offset) {\n // Repeatedly consume the next input code point from the stream:\n for (; offset < source.length; offset++) {\n const code = source.charCodeAt(offset);\n\n // U+0029 RIGHT PARENTHESIS ())\n // EOF\n if (code === 0x0029) {\n // Return.\n offset++;\n break;\n }\n\n if (isValidEscape(code, getCharCode(source, offset + 1))) {\n // Consume an escaped code point.\n // Note: This allows an escaped right parenthesis (\"\\)\") to be encountered\n // without ending the <bad-url-token>. This is otherwise identical to\n // the \"anything else\" clause.\n offset = consumeEscaped(source, offset);\n }\n }\n\n return offset;\n}\n\n// § 4.3.7. Consume an escaped code point\n// Note: This algorithm assumes that escaped is valid without leading U+005C REVERSE SOLIDUS (\\)\nexport function decodeEscaped(escaped) {\n // Single char escaped that's not a hex digit\n if (escaped.length === 1 && !isHexDigit(escaped.charCodeAt(0))) {\n return escaped[0];\n }\n\n // Interpret the hex digits as a hexadecimal number.\n let code = parseInt(escaped, 16);\n\n if (\n (code === 0) || // If this number is zero,\n (code >= 0xD800 && code <= 0xDFFF) || // or is for a surrogate,\n (code > 0x10FFFF) // or is greater than the maximum allowed code point\n ) {\n // ... return U+FFFD REPLACEMENT CHARACTER\n code = 0xFFFD;\n }\n\n // Otherwise, return the code point with that value.\n return String.fromCodePoint(code);\n}\n","import * as TYPE from './types.js';\nimport {\n isNewline,\n isName,\n isValidEscape,\n isNumberStart,\n isIdentifierStart,\n isBOM,\n charCodeCategory,\n WhiteSpaceCategory,\n DigitCategory,\n NameStartCategory,\n NonPrintableCategory\n} from './char-code-definitions.js';\nimport {\n cmpStr,\n getNewlineLength,\n findWhiteSpaceEnd,\n consumeEscaped,\n consumeName,\n consumeNumber,\n consumeBadUrlRemnants\n} from './utils.js';\n\nexport function tokenize(source, onToken) {\n function getCharCode(offset) {\n return offset < sourceLength ? source.charCodeAt(offset) : 0;\n }\n\n // § 4.3.3. Consume a numeric token\n function consumeNumericToken() {\n // Consume a number and let number be the result.\n offset = consumeNumber(source, offset);\n\n // If the next 3 input code points would start an identifier, then:\n if (isIdentifierStart(getCharCode(offset), getCharCode(offset + 1), getCharCode(offset + 2))) {\n // Create a <dimension-token> with the same value and type flag as number, and a unit set initially to the empty string.\n // Consume a name. Set the <dimension-token>’s unit to the returned value.\n // Return the <dimension-token>.\n type = TYPE.Dimension;\n offset = consumeName(source, offset);\n return;\n }\n\n // Otherwise, if the next input code point is U+0025 PERCENTAGE SIGN (%), consume it.\n if (getCharCode(offset) === 0x0025) {\n // Create a <percentage-token> with the same value as number, and return it.\n type = TYPE.Percentage;\n offset++;\n return;\n }\n\n // Otherwise, create a <number-token> with the same value and type flag as number, and return it.\n type = TYPE.Number;\n }\n\n // § 4.3.4. Consume an ident-like token\n function consumeIdentLikeToken() {\n const nameStartOffset = offset;\n\n // Consume a name, and let string be the result.\n offset = consumeName(source, offset);\n\n // If string’s value is an ASCII case-insensitive match for \"url\",\n // and the next input code point is U+0028 LEFT PARENTHESIS ((), consume it.\n if (cmpStr(source, nameStartOffset, offset, 'url') && getCharCode(offset) === 0x0028) {\n // While the next two input code points are whitespace, consume the next input code point.\n offset = findWhiteSpaceEnd(source, offset + 1);\n\n // If the next one or two input code points are U+0022 QUOTATION MARK (\"), U+0027 APOSTROPHE ('),\n // or whitespace followed by U+0022 QUOTATION MARK (\") or U+0027 APOSTROPHE ('),\n // then create a <function-token> with its value set to string and return it.\n if (getCharCode(offset) === 0x0022 ||\n getCharCode(offset) === 0x0027) {\n type = TYPE.Function;\n offset = nameStartOffset + 4;\n return;\n }\n\n // Otherwise, consume a url token, and return it.\n consumeUrlToken();\n return;\n }\n\n // Otherwise, if the next input code point is U+0028 LEFT PARENTHESIS ((), consume it.\n // Create a <function-token> with its value set to string and return it.\n if (getCharCode(offset) === 0x0028) {\n type = TYPE.Function;\n offset++;\n return;\n }\n\n // Otherwise, create an <ident-token> with its value set to string and return it.\n type = TYPE.Ident;\n }\n\n // § 4.3.5. Consume a string token\n function consumeStringToken(endingCodePoint) {\n // This algorithm may be called with an ending code point, which denotes the code point\n // that ends the string. If an ending code point is not specified,\n // the current input code point is used.\n if (!endingCodePoint) {\n endingCodePoint = getCharCode(offset++);\n }\n\n // Initially create a <string-token> with its value set to the empty string.\n type = TYPE.String;\n\n // Repeatedly consume the next input code point from the stream:\n for (; offset < source.length; offset++) {\n const code = source.charCodeAt(offset);\n\n switch (charCodeCategory(code)) {\n // ending code point\n case endingCodePoint:\n // Return the <string-token>.\n offset++;\n return;\n\n // EOF\n // case EofCategory:\n // This is a parse error. Return the <string-token>.\n // return;\n\n // newline\n case WhiteSpaceCategory:\n if (isNewline(code)) {\n // This is a parse error. Reconsume the current input code point,\n // create a <bad-string-token>, and return it.\n offset += getNewlineLength(source, offset, code);\n type = TYPE.BadString;\n return;\n }\n break;\n\n // U+005C REVERSE SOLIDUS (\\)\n case 0x005C:\n // If the next input code point is EOF, do nothing.\n if (offset === source.length - 1) {\n break;\n }\n\n const nextCode = getCharCode(offset + 1);\n\n // Otherwise, if the next input code point is a newline, consume it.\n if (isNewline(nextCode)) {\n offset += getNewlineLength(source, offset + 1, nextCode);\n } else if (isValidEscape(code, nextCode)) {\n // Otherwise, (the stream starts with a valid escape) consume\n // an escaped code point and append the returned code point to\n // the <string-token>’s value.\n offset = consumeEscaped(source, offset) - 1;\n }\n break;\n\n // anything else\n // Append the current input code point to the <string-token>’s value.\n }\n }\n }\n\n // § 4.3.6. Consume a url token\n // Note: This algorithm assumes that the initial \"url(\" has already been consumed.\n // This algorithm also assumes that it’s being called to consume an \"unquoted\" value, like url(foo).\n // A quoted value, like url(\"foo\"), is parsed as a <function-token>. Consume an ident-like token\n // automatically handles this distinction; this algorithm shouldn’t be called directly otherwise.\n function consumeUrlToken() {\n // Initially create a <url-token> with its value set to the empty string.\n type = TYPE.Url;\n\n // Consume as much whitespace as possible.\n offset = findWhiteSpaceEnd(source, offset);\n\n // Repeatedly consume the next input code point from the stream:\n for (; offset < source.length; offset++) {\n const code = source.charCodeAt(offset);\n\n switch (charCodeCategory(code)) {\n // U+0029 RIGHT PARENTHESIS ())\n case 0x0029:\n // Return the <url-token>.\n offset++;\n return;\n\n // EOF\n // case EofCategory:\n // This is a parse error. Return the <url-token>.\n // return;\n\n // whitespace\n case WhiteSpaceCategory:\n // Consume as much whitespace as possible.\n offset = findWhiteSpaceEnd(source, offset);\n\n // If the next input code point is U+0029 RIGHT PARENTHESIS ()) or EOF,\n // consume it and return the <url-token>\n // (if EOF was encountered, this is a parse error);\n if (getCharCode(offset) === 0x0029 || offset >= source.length) {\n if (offset < source.length) {\n offset++;\n }\n return;\n }\n\n // otherwise, consume the remnants of a bad url, create a <bad-url-token>,\n // and return it.\n offset = consumeBadUrlRemnants(source, offset);\n type = TYPE.BadUrl;\n return;\n\n // U+0022 QUOTATION MARK (\")\n // U+0027 APOSTROPHE (')\n // U+0028 LEFT PARENTHESIS (()\n // non-printable code point\n case 0x0022:\n case 0x0027:\n case 0x0028:\n case NonPrintableCategory:\n // This is a parse error. Consume the remnants of a bad url,\n // create a <bad-url-token>, and return it.\n offset = consumeBadUrlRemnants(source, offset);\n type = TYPE.BadUrl;\n return;\n\n // U+005C REVERSE SOLIDUS (\\)\n case 0x005C:\n // If the stream starts with a valid escape, consume an escaped code point and\n // append the returned code point to the <url-token>’s value.\n if (isValidEscape(code, getCharCode(offset + 1))) {\n offset = consumeEscaped(source, offset) - 1;\n break;\n }\n\n // Otherwise, this is a parse error. Consume the remnants of a bad url,\n // create a <bad-url-token>, and return it.\n offset = consumeBadUrlRemnants(source, offset);\n type = TYPE.BadUrl;\n return;\n\n // anything else\n // Append the current input code point to the <url-token>’s value.\n }\n }\n }\n\n // ensure source is a string\n source = String(source || '');\n\n const sourceLength = source.length;\n let start = isBOM(getCharCode(0));\n let offset = start;\n let type;\n\n // https://drafts.csswg.org/css-syntax-3/#consume-token\n // § 4.3.1. Consume a token\n while (offset < sourceLength) {\n const code = source.charCodeAt(offset);\n\n switch (charCodeCategory(code)) {\n // whitespace\n case WhiteSpaceCategory:\n // Consume as much whitespace as possible. Return a <whitespace-token>.\n type = TYPE.WhiteSpace;\n offset = findWhiteSpaceEnd(source, offset + 1);\n break;\n\n // U+0022 QUOTATION MARK (\")\n case 0x0022:\n // Consume a string token and return it.\n consumeStringToken();\n break;\n\n // U+0023 NUMBER SIGN (#)\n case 0x0023:\n // If the next input code point is a name code point or the next two input code points are a valid escape, then:\n if (isName(getCharCode(offset + 1)) || isValidEscape(getCharCode(offset + 1), getCharCode(offset + 2))) {\n // Create a <hash-token>.\n type = TYPE.Hash;\n\n // If the next 3 input code points would start an identifier, set the <hash-token>’s type flag to \"id\".\n // if (isIdentifierStart(getCharCode(offset + 1), getCharCode(offset + 2), getCharCode(offset + 3))) {\n // // TODO: set id flag\n // }\n\n // Consume a name, and set the <hash-token>’s value to the returned string.\n offset = consumeName(source, offset + 1);\n\n // Return the <hash-token>.\n } else {\n // Otherwise, return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n\n break;\n\n // U+0027 APOSTROPHE (')\n case 0x0027:\n // Consume a string token and return it.\n consumeStringToken();\n break;\n\n // U+0028 LEFT PARENTHESIS (()\n case 0x0028:\n // Return a <(-token>.\n type = TYPE.LeftParenthesis;\n offset++;\n break;\n\n // U+0029 RIGHT PARENTHESIS ())\n case 0x0029:\n // Return a <)-token>.\n type = TYPE.RightParenthesis;\n offset++;\n break;\n\n // U+002B PLUS SIGN (+)\n case 0x002B:\n // If the input stream starts with a number, ...\n if (isNumberStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {\n // ... reconsume the current input code point, consume a numeric token, and return it.\n consumeNumericToken();\n } else {\n // Otherwise, return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n break;\n\n // U+002C COMMA (,)\n case 0x002C:\n // Return a <comma-token>.\n type = TYPE.Comma;\n offset++;\n break;\n\n // U+002D HYPHEN-MINUS (-)\n case 0x002D:\n // If the input stream starts with a number, reconsume the current input code point, consume a numeric token, and return it.\n if (isNumberStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {\n consumeNumericToken();\n } else {\n // Otherwise, if the next 2 input code points are U+002D HYPHEN-MINUS U+003E GREATER-THAN SIGN (->), consume them and return a <CDC-token>.\n if (getCharCode(offset + 1) === 0x002D &&\n getCharCode(offset + 2) === 0x003E) {\n type = TYPE.CDC;\n offset = offset + 3;\n } else {\n // Otherwise, if the input stream starts with an identifier, ...\n if (isIdentifierStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {\n // ... reconsume the current input code point, consume an ident-like token, and return it.\n consumeIdentLikeToken();\n } else {\n // Otherwise, return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n }\n }\n break;\n\n // U+002E FULL STOP (.)\n case 0x002E:\n // If the input stream starts with a number, ...\n if (isNumberStart(code, getCharCode(offset + 1), getCharCode(offset + 2))) {\n // ... reconsume the current input code point, consume a numeric token, and return it.\n consumeNumericToken();\n } else {\n // Otherwise, return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n\n break;\n\n // U+002F SOLIDUS (/)\n case 0x002F:\n // If the next two input code point are U+002F SOLIDUS (/) followed by a U+002A ASTERISK (*),\n if (getCharCode(offset + 1) === 0x002A) {\n // ... consume them and all following code points up to and including the first U+002A ASTERISK (*)\n // followed by a U+002F SOLIDUS (/), or up to an EOF code point.\n type = TYPE.Comment;\n offset = source.indexOf('*/', offset + 2);\n offset = offset === -1 ? source.length : offset + 2;\n } else {\n type = TYPE.Delim;\n offset++;\n }\n break;\n\n // U+003A COLON (:)\n case 0x003A:\n // Return a <colon-token>.\n type = TYPE.Colon;\n offset++;\n break;\n\n // U+003B SEMICOLON (;)\n case 0x003B:\n // Return a <semicolon-token>.\n type = TYPE.Semicolon;\n offset++;\n break;\n\n // U+003C LESS-THAN SIGN (<)\n case 0x003C:\n // If the next 3 input code points are U+0021 EXCLAMATION MARK U+002D HYPHEN-MINUS U+002D HYPHEN-MINUS (!--), ...\n if (getCharCode(offset + 1) === 0x0021 &&\n getCharCode(offset + 2) === 0x002D &&\n getCharCode(offset + 3) === 0x002D) {\n // ... consume them and return a <CDO-token>.\n type = TYPE.CDO;\n offset = offset + 4;\n } else {\n // Otherwise, return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n\n break;\n\n // U+0040 COMMERCIAL AT (@)\n case 0x0040:\n // If the next 3 input code points would start an identifier, ...\n if (isIdentifierStart(getCharCode(offset + 1), getCharCode(offset + 2), getCharCode(offset + 3))) {\n // ... consume a name, create an <at-keyword-token> with its value set to the returned value, and return it.\n type = TYPE.AtKeyword;\n offset = consumeName(source, offset + 1);\n } else {\n // Otherwise, return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n\n break;\n\n // U+005B LEFT SQUARE BRACKET ([)\n case 0x005B:\n // Return a <[-token>.\n type = TYPE.LeftSquareBracket;\n offset++;\n break;\n\n // U+005C REVERSE SOLIDUS (\\)\n case 0x005C:\n // If the input stream starts with a valid escape, ...\n if (isValidEscape(code, getCharCode(offset + 1))) {\n // ... reconsume the current input code point, consume an ident-like token, and return it.\n consumeIdentLikeToken();\n } else {\n // Otherwise, this is a parse error. Return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n break;\n\n // U+005D RIGHT SQUARE BRACKET (])\n case 0x005D:\n // Return a <]-token>.\n type = TYPE.RightSquareBracket;\n offset++;\n break;\n\n // U+007B LEFT CURLY BRACKET ({)\n case 0x007B:\n // Return a <{-token>.\n type = TYPE.LeftCurlyBracket;\n offset++;\n break;\n\n // U+007D RIGHT CURLY BRACKET (})\n case 0x007D:\n // Return a <}-token>.\n type = TYPE.RightCurlyBracket;\n offset++;\n break;\n\n // digit\n case DigitCategory:\n // Reconsume the current input code point, consume a numeric token, and return it.\n consumeNumericToken();\n break;\n\n // name-start code point\n case NameStartCategory:\n // Reconsume the current input code point, consume an ident-like token, and return it.\n consumeIdentLikeToken();\n break;\n\n // EOF\n // case EofCategory:\n // Return an <EOF-token>.\n // break;\n\n // anything else\n default:\n // Return a <delim-token> with its value set to the current input code point.\n type = TYPE.Delim;\n offset++;\n }\n\n // put token to stream\n onToken(type, start, start = offset);\n }\n}\n\nexport * from './types.js';\nexport * as tokenTypes from './types.js';\nexport { default as tokenNames } from './names.js';\nexport * from './char-code-definitions.js';\nexport * from './utils.js';\nexport * from './OffsetToLocation.js';\nexport * from './TokenStream.js';\n","//\n// list\n// ┌──────┐\n// ┌──────────────┼─head │\n// │ │ tail─┼──────────────┐\n// │ └──────┘ │\n// ▼ ▼\n// item item item item\n// ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐\n// null ◀──┼─prev │◀───┼─prev │◀───┼─prev │◀───┼─prev │\n// │ next─┼───▶│ next─┼───▶│ next─┼───▶│ next─┼──▶ null\n// ├──────┤ ├──────┤ ├──────┤ ├──────┤\n// │ data │ │ data │ │ data │ │ data │\n// └──────┘ └──────┘ └──────┘ └──────┘\n//\n\nlet releasedCursors = null;\n\nexport class List {\n static createItem(data) {\n return {\n prev: null,\n next: null,\n data\n };\n }\n\n constructor() {\n this.head = null;\n this.tail = null;\n this.cursor = null;\n }\n createItem(data) {\n return List.createItem(data);\n }\n\n // cursor helpers\n allocateCursor(prev, next) {\n let cursor;\n\n if (releasedCursors !== null) {\n cursor = releasedCursors;\n releasedCursors = releasedCursors.cursor;\n cursor.prev = prev;\n cursor.next = next;\n cursor.cursor = this.cursor;\n } else {\n cursor = {\n prev,\n next,\n cursor: this.cursor\n };\n }\n\n this.cursor = cursor;\n\n return cursor;\n }\n releaseCursor() {\n const { cursor } = this;\n\n this.cursor = cursor.cursor;\n cursor.prev = null;\n cursor.next = null;\n cursor.cursor = releasedCursors;\n releasedCursors = cursor;\n }\n updateCursors(prevOld, prevNew, nextOld, nextNew) {\n let { cursor } = this;\n\n while (cursor !== null) {\n if (cursor.prev === prevOld) {\n cursor.prev = prevNew;\n }\n\n if (cursor.next === nextOld) {\n cursor.next = nextNew;\n }\n\n cursor = cursor.cursor;\n }\n }\n *[Symbol.iterator]() {\n for (let cursor = this.head; cursor !== null; cursor = cursor.next) {\n yield cursor.data;\n }\n }\n\n // getters\n get size() {\n let size = 0;\n\n for (let cursor = this.head; cursor !== null; cursor = cursor.next) {\n size++;\n }\n\n return size;\n }\n get isEmpty() {\n return this.head === null;\n }\n get first() {\n return this.head && this.head.data;\n }\n get last() {\n return this.tail && this.tail.data;\n }\n\n // convertors\n fromArray(array) {\n let cursor = null;\n this.head = null;\n\n for (let data of array) {\n const item = List.createItem(data);\n\n if (cursor !== null) {\n cursor.next = item;\n } else {\n this.head = item;\n }\n\n item.prev = cursor;\n cursor = item;\n }\n\n this.tail = cursor;\n return this;\n }\n toArray() {\n return [...this];\n }\n toJSON() {\n return [...this];\n }\n\n // array-like methods\n forEach(fn, thisArg = this) {\n // push cursor\n const cursor = this.allocateCursor(null, this.head);\n\n while (cursor.next !== null) {\n const item = cursor.next;\n cursor.next = item.next;\n fn.call(thisArg, item.data, item, this);\n }\n\n // pop cursor\n this.releaseCursor();\n }\n forEachRight(fn, thisArg = this) {\n // push cursor\n const cursor = this.allocateCursor(this.tail, null);\n\n while (cursor.prev !== null) {\n const item = cursor.prev;\n cursor.prev = item.prev;\n fn.call(thisArg, item.data, item, this);\n }\n\n // pop cursor\n this.releaseCursor();\n }\n reduce(fn, initialValue, thisArg = this) {\n // push cursor\n let cursor = this.allocateCursor(null, this.head);\n let acc = initialValue;\n let item;\n\n while (cursor.next !== null) {\n item = cursor.next;\n cursor.next = item.next;\n\n acc = fn.call(thisArg, acc, item.data, item, this);\n }\n\n // pop cursor\n this.releaseCursor();\n\n return acc;\n }\n reduceRight(fn, initialValue, thisArg = this) {\n // push cursor\n let cursor = this.allocateCursor(this.tail, null);\n let acc = initialValue;\n let item;\n\n while (cursor.prev !== null) {\n item = cursor.prev;\n cursor.prev = item.prev;\n\n acc = fn.call(thisArg, acc, item.data, item, this);\n }\n\n // pop cursor\n this.releaseCursor();\n\n return acc;\n }\n some(fn, thisArg = this) {\n for (let cursor = this.head; cursor !== null; cursor = cursor.next) {\n if (fn.call(thisArg, cursor.data, cursor, this)) {\n return true;\n }\n }\n\n return false;\n }\n map(fn, thisArg = this) {\n const result = new List();\n\n for (let cursor = this.head; cursor !== null; cursor = cursor.next) {\n result.appendData(fn.call(thisArg, cursor.data, cursor, this));\n }\n\n return result;\n }\n filter(fn, thisArg = this) {\n const result = new List();\n\n for (let cursor = this.head; cursor !== null; cursor = cursor.next) {\n if (fn.call(thisArg, cursor.data, cursor, this)) {\n result.appendData(cursor.data);\n }\n }\n\n return result;\n }\n\n nextUntil(start, fn, thisArg = this) {\n if (start === null) {\n return;\n }\n\n // push cursor\n const cursor = this.allocateCursor(null, start);\n\n while (cursor.next !== null) {\n const item = cursor.next;\n cursor.next = item.next;\n if (fn.call(thisArg, item.data, item, this)) {\n break;\n }\n }\n\n // pop cursor\n this.releaseCursor();\n }\n prevUntil(start, fn, thisArg = this) {\n if (start === null) {\n return;\n }\n\n // push cursor\n const cursor = this.allocateCursor(start, null);\n\n while (cursor.prev !== null) {\n const item = cursor.prev;\n cursor.prev = item.prev;\n if (fn.call(thisArg, item.data, item, this)) {\n break;\n }\n }\n\n // pop cursor\n this.releaseCursor();\n }\n\n // mutation\n clear() {\n this.head = null;\n this.tail = null;\n }\n copy() {\n const result = new List();\n\n for (let data of this) {\n result.appendData(data);\n }\n\n return result;\n }\n prepend(item) {\n // head\n // ^\n // item\n this.updateCursors(null, item, this.head, item);\n\n // insert to the beginning of the list\n if (this.head !== null) {\n // new item <- first item\n this.head.prev = item;\n // new item -> first item\n item.next = this.head;\n } else {\n // if list has no head, then it also has no tail\n // in this case tail points to the new item\n this.tail = item;\n }\n\n // head always points to new item\n this.head = item;\n return this;\n }\n prependData(data) {\n return this.prepend(List.createItem(data));\n }\n append(item) {\n return this.insert(item);\n }\n appendData(data) {\n return this.insert(List.createItem(data));\n }\n insert(item, before = null) {\n if (before !== null) {\n // prev before\n // ^\n // item\n this.updateCursors(before.prev, item, before, item);\n\n if (before.prev === null) {\n // insert to the beginning of list\n if (this.head !== before) {\n throw new Error('before doesn\\'t belong to list');\n }\n // since head points to before therefore list doesn't empty\n // no need to check tail\n this.head = item;\n before.prev = item;\n item.next = before;\n this.updateCursors(null, item);\n } else {\n // insert between two items\n before.prev.next = item;\n item.prev = before.prev;\n before.prev = item;\n item.next = before;\n }\n } else {\n // tail\n // ^\n // item\n this.updateCursors(this.tail, item, null, item);\n\n // insert to the ending of the list\n if (this.tail !== null) {\n // last item -> new item\n this.tail.next = item;\n // last item <- new item\n item.prev = this.tail;\n } else {\n // if list has no tail, then it also has no head\n // in this case head points to new item\n this.head = item;\n }\n\n // tail always points to new item\n this.tail = item;\n }\n\n return this;\n }\n insertData(data, before) {\n return this.insert(List.createItem(data), before);\n }\n remove(item) {\n // item\n // ^\n // prev next\n this.updateCursors(item, item.prev, item, item.next);\n\n if (item.prev !== null) {\n item.prev.next = item.next;\n } else {\n if (this.head !== item) {\n throw new Error('item doesn\\'t belong to list');\n }\n\n this.head = item.next;\n }\n\n if (item.next !== null) {\n item.next.prev = item.prev;\n } else {\n if (this.tail !== item) {\n throw new Error('item doesn\\'t belong to list');\n }\n\n this.tail = item.prev;\n }\n\n item.prev = null;\n item.next = null;\n\n return item;\n }\n push(data) {\n this.insert(List.createItem(data));\n }\n pop() {\n return this.tail !== null ? this.remove(this.tail) : null;\n }\n unshift(data) {\n this.prepend(List.createItem(data));\n }\n shift() {\n return this.head !== null ? this.remove(this.head) : null;\n }\n prependList(list) {\n return this.insertList(list, this.head);\n }\n appendList(list) {\n return this.insertList(list);\n }\n insertList(list, before) {\n // ignore empty lists\n if (list.head === null) {\n return this;\n }\n\n if (before !== undefined && before !== null) {\n this.updateCursors(before.prev, list.tail, before, list.head);\n\n // insert in the middle of dist list\n if (before.prev !== null) {\n // before.prev <-> list.head\n before.prev.next = list.head;\n list.head.prev = before.prev;\n } else {\n this.head = list.head;\n }\n\n before.prev = list.tail;\n list.tail.next = before;\n } else {\n this.updateCursors(this.tail, list.tail, null, list.head);\n\n // insert to end of the list\n if (this.tail !== null) {\n // if destination list has a tail, then it also has a head,\n // but head doesn't change\n // dest tail -> source head\n this.tail.next = list.head;\n // dest tail <- source head\n list.head.prev = this.tail;\n } else {\n // if list has no a tail, then it also has no a head\n // in this case points head to new item\n this.head = list.head;\n }\n\n // tail always start point to new item\n this.tail = list.tail;\n }\n\n list.head = null;\n list.tail = null;\n return this;\n }\n replace(oldItem, newItemOrList) {\n if ('head' in newItemOrList) {\n this.insertList(newItemOrList, oldItem);\n } else {\n this.insert(newItemOrList, oldItem);\n }\n\n this.remove(oldItem);\n }\n}\n","export function createCustomError(name, message) {\n // use Object.create(), because some VMs prevent setting line/column otherwise\n // (iOS Safari 10 even throws an exception)\n const error = Object.create(SyntaxError.prototype);\n const errorStack = new Error();\n\n return Object.assign(error, {\n name,\n message,\n get stack() {\n return (errorStack.stack || '').replace(/^(.+\\n){1,3}/, `${name}: ${message}\\n`);\n }\n });\n};\n","import { createCustomError } from '../utils/create-custom-error.js';\n\nconst MAX_LINE_LENGTH = 100;\nconst OFFSET_CORRECTION = 60;\nconst TAB_REPLACEMENT = ' ';\n\nfunction sourceFragment({ source, line, column, baseLine, baseColumn }, extraLines) {\n function processLines(start, end) {\n return lines\n .slice(start, end)\n .map((line, idx) =>\n String(start + idx + 1).padStart(maxNumLength) + ' |' + line\n ).join('\\n');\n }\n\n const prelines = '\\n'.repeat(Math.max(baseLine - 1, 0));\n const precolumns = ' '.repeat(Math.max(baseColumn - 1, 0));\n const lines = (prelines + precolumns + source).split(/\\r\\n?|\\n|\\f/);\n const startLine = Math.max(1, line - extraLines) - 1;\n const endLine = Math.min(line + extraLines, lines.length + 1);\n const maxNumLength = Math.max(4, String(endLine).length) + 1;\n let cutLeft = 0;\n\n // column correction according to replaced tab before column\n column += (TAB_REPLACEMENT.length - 1) * (lines[line - 1].substr(0, column - 1).match(/\\t/g) || []).length;\n\n if (column > MAX_LINE_LENGTH) {\n cutLeft = column - OFFSET_CORRECTION + 3;\n column = OFFSET_CORRECTION - 2;\n }\n\n for (let i = startLine; i <= endLine; i++) {\n if (i >= 0 && i < lines.length) {\n lines[i] = lines[i].replace(/\\t/g, TAB_REPLACEMENT);\n lines[i] =\n (cutLeft > 0 && lines[i].length > cutLeft ? '\\u2026' : '') +\n lines[i].substr(cutLeft, MAX_LINE_LENGTH - 2) +\n (lines[i].length > cutLeft + MAX_LINE_LENGTH - 1 ? '\\u2026' : '');\n }\n }\n\n return [\n processLines(startLine, line),\n new Array(column + maxNumLength + 2).join('-') + '^',\n processLines(line, endLine)\n ].filter(Boolean)\n .join('\\n')\n .replace(/^(\\s+\\d+\\s+\\|\\n)+/, '')\n .replace(/\\n(\\s+\\d+\\s+\\|)+$/, '');\n}\n\nexport function SyntaxError(message, source, offset, line, column, baseLine = 1, baseColumn = 1) {\n const error = Object.assign(createCustomError('SyntaxError', message), {\n source,\n offset,\n line,\n column,\n sourceFragment(extraLines) {\n return sourceFragment({ source, line, column, baseLine, baseColumn }, isNaN(extraLines) ? 0 : extraLines);\n },\n get formattedMessage() {\n return (\n `Parse error: ${message}\\n` +\n sourceFragment({ source, line, column, baseLine, baseColumn }, 2)\n );\n }\n });\n\n return error;\n}\n","const MIN_SIZE = 16 * 1024;\n\nexport function adoptBuffer(buffer = null, size) {\n if (buffer === null || buffer.length < size) {\n return new Uint32Array(Math.max(size + 1024, MIN_SIZE));\n }\n\n return buffer;\n};\n","import { adoptBuffer } from './adopt-buffer.js';\nimport { isBOM } from './char-code-definitions.js';\n\nconst N = 10;\nconst F = 12;\nconst R = 13;\n\nfunction computeLinesAndColumns(host) {\n const source = host.source;\n const sourceLength = source.length;\n const startOffset = source.length > 0 ? isBOM(source.charCodeAt(0)) : 0;\n const lines = adoptBuffer(host.lines, sourceLength);\n const columns = adoptBuffer(host.columns, sourceLength);\n let line = host.startLine;\n let column = host.startColumn;\n\n for (let i = startOffset; i < sourceLength; i++) {\n const code = source.charCodeAt(i);\n\n lines[i] = line;\n columns[i] = column++;\n\n if (code === N || code === R || code === F) {\n if (code === R && i + 1 < sourceLength && source.charCodeAt(i + 1) === N) {\n i++;\n lines[i] = line;\n columns[i] = column;\n }\n\n line++;\n column = 1;\n }\n }\n\n lines[sourceLength] = line;\n columns[sourceLength] = column;\n\n host.lines = lines;\n host.columns = columns;\n host.computed = true;\n}\n\nexport class OffsetToLocation {\n constructor(source, startOffset, startLine, startColumn) {\n this.setSource(source, startOffset, startLine, startColumn);\n this.lines = null;\n this.columns = null;\n }\n setSource(source = '', startOffset = 0, startLine = 1, startColumn = 1) {\n this.source = source;\n this.startOffset = startOffset;\n this.startLine = startLine;\n this.startColumn = startColumn;\n this.computed = false;\n }\n getLocation(offset, filename) {\n if (!this.computed) {\n computeLinesAndColumns(this);\n }\n\n return {\n source: filename,\n offset: this.startOffset + offset,\n line: this.lines[offset],\n column: this.columns[offset]\n };\n }\n getLocationRange(start, end, filename) {\n if (!this.computed) {\n computeLinesAndColumns(this);\n }\n\n return {\n source: filename,\n start: {\n offset: this.startOffset + start,\n line: this.lines[start],\n column: this.columns[start]\n },\n end: {\n offset: this.startOffset + end,\n line: this.lines[end],\n column: this.columns[end]\n }\n };\n }\n};\n","export default [\n 'EOF-token',\n 'ident-token',\n 'function-token',\n 'at-keyword-token',\n 'hash-token',\n 'string-token',\n 'bad-string-token',\n 'url-token',\n 'bad-url-token',\n 'delim-token',\n 'number-token',\n 'percentage-token',\n 'dimension-token',\n 'whitespace-token',\n 'CDO-token',\n 'CDC-token',\n 'colon-token',\n 'semicolon-token',\n 'comma-token',\n '[-token',\n ']-token',\n '(-token',\n ')-token',\n '{-token',\n '}-token',\n 'comment-token'\n];\n","import { adoptBuffer } from './adopt-buffer.js';\nimport { cmpStr } from './utils.js';\nimport tokenNames from './names.js';\nimport {\n WhiteSpace,\n Comment,\n Delim,\n EOF,\n Function as FunctionToken,\n LeftParenthesis,\n RightParenthesis,\n LeftSquareBracket,\n RightSquareBracket,\n LeftCurlyBracket,\n RightCurlyBracket\n} from './types.js';\n\nconst OFFSET_MASK = 0x00FFFFFF;\nconst TYPE_SHIFT = 24;\nconst BLOCK_OPEN_TOKEN = 1;\nconst BLOCK_CLOSE_TOKEN = 2;\nconst balancePair = new Uint8Array(32); // 32b of memory ought to be enough for anyone (any number of tokens)\nbalancePair[FunctionToken] = RightParenthesis;\nbalancePair[LeftParenthesis] = RightParenthesis;\nbalancePair[LeftSquareBracket] = RightSquareBracket;\nbalancePair[LeftCurlyBracket] = RightCurlyBracket;\n\nconst blockTokens = new Uint8Array(32);\nblockTokens[FunctionToken] = BLOCK_OPEN_TOKEN;\nblockTokens[LeftParenthesis] = BLOCK_OPEN_TOKEN;\nblockTokens[LeftSquareBracket] = BLOCK_OPEN_TOKEN;\nblockTokens[LeftCurlyBracket] = BLOCK_OPEN_TOKEN;\nblockTokens[RightParenthesis] = BLOCK_CLOSE_TOKEN;\nblockTokens[RightSquareBracket] = BLOCK_CLOSE_TOKEN;\nblockTokens[RightCurlyBracket] = BLOCK_CLOSE_TOKEN;\n\nfunction boundIndex(index, min, max) {\n return index < min ? min : index > max ? max : index;\n}\n\nexport class TokenStream {\n constructor(source, tokenize) {\n this.setSource(source, tokenize);\n }\n reset() {\n this.eof = false;\n this.tokenIndex = -1;\n this.tokenType = 0;\n this.tokenStart = this.firstCharOffset;\n this.tokenEnd = this.firstCharOffset;\n }\n setSource(source = '', tokenize = () => {}) {\n source = String(source || '');\n\n const sourceLength = source.length;\n const offsetAndType = adoptBuffer(this.offsetAndType, source.length + 1); // +1 because of eof-token\n const balance = adoptBuffer(this.balance, source.length + 1);\n let tokenCount = 0;\n let firstCharOffset = -1;\n let balanceCloseType = 0;\n let balanceStart = source.length;\n\n // capture buffers\n this.offsetAndType = null;\n this.balance = null;\n balance.fill(0);\n\n tokenize(source, (type, start, end) => {\n const index = tokenCount++;\n\n // type & offset\n offsetAndType[index] = (type << TYPE_SHIFT) | end;\n\n if (firstCharOffset === -1) {\n firstCharOffset = start;\n }\n\n // balance\n balance[index] = balanceStart;\n\n if (type === balanceCloseType) {\n const prevBalanceStart = balance[balanceStart];\n\n // set reference to balance end for a block opener\n balance[balanceStart] = index;\n\n // pop state\n balanceStart = prevBalanceStart;\n balanceCloseType = balancePair[offsetAndType[prevBalanceStart] >> TYPE_SHIFT];\n } else if (this.isBlockOpenerTokenType(type)) { // check for FunctionToken, <(-token>, <[-token> and <{-token>\n // push state\n balanceStart = index;\n balanceCloseType = balancePair[type];\n }\n });\n\n // finalize buffers\n offsetAndType[tokenCount] = (EOF << TYPE_SHIFT) | sourceLength; // <EOF-token>\n balance[tokenCount] = tokenCount; // prevents false positive balance match with any token\n\n // reverse references from balance start to end\n // tokens\n // token: a ( [ b c ] d e ) {\n // index: 0 1 2 3 4 5 6 7 8 9\n // before\n // balance: 0 8 5 2 2 2 1 1 1 0\n // - > > < < < < < < -\n // after\n // balance: 9 8 5 5 5 2 8 8 1 9\n // > > > > > < > > < >\n for (let i = 0; i < tokenCount; i++) {\n const balanceStart = balance[i];\n\n if (balanceStart <= i) {\n const balanceEnd = balance[balanceStart];\n\n if (balanceEnd !== i) {\n balance[i] = balanceEnd;\n }\n } else if (balanceStart > tokenCount) {\n balance[i] = tokenCount;\n }\n }\n\n // balance[0] = tokenCount;\n\n this.source = source;\n this.firstCharOffset = firstCharOffset === -1 ? 0 : firstCharOffset;\n this.tokenCount = tokenCount;\n this.offsetAndType = offsetAndType;\n this.balance = balance;\n\n this.reset();\n this.next();\n }\n\n lookupType(offset) {\n offset += this.tokenIndex;\n\n if (offset < this.tokenCount) {\n return this.offsetAndType[offset] >> TYPE_SHIFT;\n }\n\n return EOF;\n }\n lookupTypeNonSC(idx) {\n for (let offset = this.tokenIndex; offset < this.tokenCount; offset++) {\n const tokenType = this.offsetAndType[offset] >> TYPE_SHIFT;\n\n if (tokenType !== WhiteSpace && tokenType !== Comment) {\n if (idx-- === 0) {\n return tokenType;\n }\n }\n }\n\n return EOF;\n }\n lookupOffset(offset) {\n offset += this.tokenIndex;\n\n if (offset < this.tokenCount) {\n return this.offsetAndType[offset - 1] & OFFSET_MASK;\n }\n\n return this.source.length;\n }\n lookupOffsetNonSC(idx) {\n for (let offset = this.tokenIndex; offset < this.tokenCount; offset++) {\n const tokenType = this.offsetAndType[offset] >> TYPE_SHIFT;\n\n if (tokenType !== WhiteSpace && tokenType !== Comment) {\n if (idx-- === 0) {\n return offset - this.tokenIndex;\n }\n }\n }\n\n return EOF;\n }\n lookupValue(offset, referenceStr) {\n offset += this.tokenIndex;\n\n if (offset < this.tokenCount) {\n return cmpStr(\n this.source,\n this.offsetAndType[offset - 1] & OFFSET_MASK,\n this.offsetAndType[offset] & OFFSET_MASK,\n referenceStr\n );\n }\n\n return false;\n }\n getTokenStart(tokenIndex) {\n if (tokenIndex === this.tokenIndex) {\n return this.tokenStart;\n }\n\n if (tokenIndex > 0) {\n return tokenIndex < this.tokenCount\n ? this.offsetAndType[tokenIndex - 1] & OFFSET_MASK\n : this.offsetAndType[this.tokenCount] & OFFSET_MASK;\n }\n\n return this.firstCharOffset;\n }\n getTokenEnd(tokenIndex) {\n if (tokenIndex === this.tokenIndex) {\n return this.tokenEnd;\n }\n\n return this.offsetAndType[boundIndex(tokenIndex, 0, this.tokenCount)] & OFFSET_MASK;\n }\n getTokenType(tokenIndex) {\n if (tokenIndex === this.tokenIndex) {\n return this.tokenType;\n }\n\n return this.offsetAndType[boundIndex(tokenIndex, 0, this.tokenCount)] >> TYPE_SHIFT;\n }\n substrToCursor(start) {\n return this.source.substring(start, this.tokenStart);\n }\n\n isBlockOpenerTokenType(tokenType) {\n return blockTokens[tokenType] === BLOCK_OPEN_TOKEN;\n }\n isBlockCloserTokenType(tokenType) {\n return blockTokens[tokenType] === BLOCK_CLOSE_TOKEN;\n }\n getBlockTokenPairIndex(tokenIndex) {\n const type = this.getTokenType(tokenIndex);\n\n if (blockTokens[type] === 1) {\n // block open token\n const pairIndex = this.balance[tokenIndex];\n const closeType = this.getTokenType(pairIndex);\n\n return balancePair[type] === closeType ? pairIndex : -1;\n } else if (blockTokens[type] === 2) {\n // block close token\n const pairIndex = this.balance[tokenIndex];\n const openType = this.getTokenType(pairIndex);\n\n return balancePair[openType] === type ? pairIndex : -1;\n }\n\n return -1;\n }\n isBalanceEdge(tokenIndex) {\n return this.balance[this.tokenIndex] < tokenIndex;\n }\n\n isDelim(code, offset) {\n if (offset) {\n return (\n this.lookupType(offset) === Delim &&\n this.source.charCodeAt(this.lookupOffset(offset)) === code\n );\n }\n\n return (\n this.tokenType === Delim &&\n this.source.charCodeAt(this.tokenStart) === code\n );\n }\n\n skip(tokenCount) {\n let next = this.tokenIndex + tokenCount;\n\n if (next < this.tokenCount) {\n this.tokenIndex = next;\n this.tokenStart = this.offsetAndType[next - 1] & OFFSET_MASK;\n next = this.offsetAndType[next];\n this.tokenType = next >> TYPE_SHIFT;\n this.tokenEnd = next & OFFSET_MASK;\n } else {\n this.tokenIndex = this.tokenCount;\n this.next();\n }\n }\n next() {\n let next = this.tokenIndex + 1;\n\n if (next < this.tokenCount) {\n this.tokenIndex = next;\n this.tokenStart = this.tokenEnd;\n next = this.offsetAndType[next];\n this.tokenType = next >> TYPE_SHIFT;\n this.tokenEnd = next & OFFSET_MASK;\n } else {\n this.eof = true;\n this.tokenIndex = this.tokenCount;\n this.tokenType = EOF;\n this.tokenStart = this.tokenEnd = this.source.length;\n }\n }\n skipSC() {\n while (this.tokenType === WhiteSpace || this.tokenType === Comment) {\n this.next();\n }\n }\n skipUntilBalanced(startToken, stopConsume) {\n let cursor = startToken;\n let balanceEnd = 0;\n let offset = 0;\n\n loop:\n for (; cursor < this.tokenCount; cursor++) {\n balanceEnd = this.balance[cursor];\n\n // stop scanning on balance edge that points to offset before start token\n if (balanceEnd < startToken) {\n break loop;\n }\n\n offset = cursor > 0 ? this.offsetAndType[cursor - 1] & OFFSET_MASK : this.firstCharOffset;\n\n // check stop condition\n switch (stopConsume(this.source.charCodeAt(offset))) {\n case 1: // just stop\n break loop;\n\n case 2: // stop & included\n cursor++;\n break loop;\n\n default:\n // fast forward to the end of balanced block for an open block tokens\n if (this.isBlockOpenerTokenType(this.offsetAndType[cursor] >> TYPE_SHIFT)) {\n cursor = balanceEnd;\n }\n }\n }\n\n this.skip(cursor - this.tokenIndex);\n }\n\n forEachToken(fn) {\n for (let i = 0, offset = this.firstCharOffset; i < this.tokenCount; i++) {\n const start = offset;\n const item = this.offsetAndType[i];\n const end = item & OFFSET_MASK;\n const type = item >> TYPE_SHIFT;\n\n offset = end;\n\n fn(type, start, end, i);\n }\n }\n dump() {\n const tokens = new Array(this.tokenCount);\n\n this.forEachToken((type, start, end, index) => {\n tokens[index] = {\n idx: index,\n type: tokenNames[type],\n chunk: this.source.substring(start, end),\n balance: this.balance[index]\n };\n });\n\n return tokens;\n }\n};\n","import { WhiteSpace, Comment } from '../tokenizer/index.js';\n\nexport function readSequence(recognizer) {\n const children = this.createList();\n let space = false;\n const context = {\n recognizer\n };\n\n while (!this.eof) {\n switch (this.tokenType) {\n case Comment:\n this.next();\n continue;\n\n case WhiteSpace:\n space = true;\n this.next();\n continue;\n }\n\n let child = recognizer.getNode.call(this, context);\n\n if (child === undefined) {\n break;\n }\n\n if (space) {\n if (recognizer.onWhiteSpace) {\n recognizer.onWhiteSpace.call(this, child, children, context);\n }\n space = false;\n }\n\n children.push(child);\n }\n\n if (space && recognizer.onWhiteSpace) {\n recognizer.onWhiteSpace.call(this, null, children, context);\n }\n\n return children;\n};\n","import { List } from '../utils/List.js';\nimport { SyntaxError } from './SyntaxError.js';\nimport {\n tokenize,\n OffsetToLocation,\n TokenStream,\n tokenNames,\n\n consumeNumber,\n findWhiteSpaceStart,\n cmpChar,\n cmpStr,\n\n WhiteSpace,\n Comment,\n Ident,\n Function as FunctionToken,\n Url,\n Hash,\n Percentage,\n Number as NumberToken\n} from '../tokenizer/index.js';\nimport { readSequence } from './sequence.js';\n\nconst NOOP = () => {};\nconst EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!)\nconst NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#)\nconst SEMICOLON = 0x003B; // U+003B SEMICOLON (;)\nconst LEFTCURLYBRACKET = 0x007B; // U+007B LEFT CURLY BRACKET ({)\nconst NULL = 0;\n\nconst arrayMethods = {\n createList() {\n return [];\n },\n createSingleNodeList(node) {\n return [node];\n },\n getFirstListNode(list) {\n return list && list[0] || null;\n },\n getLastListNode(list) {\n return list && list.length > 0 ? list[list.length - 1] : null;\n }\n};\n\nconst listMethods = {\n createList() {\n return new List();\n },\n createSingleNodeList(node) {\n return new List().appendData(node);\n },\n getFirstListNode(list) {\n return list && list.first;\n },\n getLastListNode(list) {\n return list && list.last;\n }\n};\n\nfunction createParseContext(name) {\n return function() {\n return this[name]();\n };\n}\n\nfunction fetchParseValues(dict) {\n const result = Object.create(null);\n\n for (const name of Object.keys(dict)) {\n const item = dict[name];\n const fn = item.parse || item;\n\n if (fn) {\n result[name] = fn;\n }\n }\n\n return result;\n}\n\nfunction processConfig(config) {\n const parseConfig = {\n context: Object.create(null),\n features: Object.assign(Object.create(null), config.features),\n scope: Object.assign(Object.create(null), config.scope),\n atrule: fetchParseValues(config.atrule),\n pseudo: fetchParseValues(config.pseudo),\n node: fetchParseValues(config.node)\n };\n\n for (const [name, context] of Object.entries(config.parseContext)) {\n switch (typeof context) {\n case 'function':\n parseConfig.context[name] = context;\n break;\n\n case 'string':\n parseConfig.context[name] = createParseContext(context);\n break;\n }\n }\n\n return {\n config: parseConfig,\n ...parseConfig,\n ...parseConfig.node\n };\n}\n\nexport function createParser(config) {\n let source = '';\n let filename = '<unknown>';\n let needPositions = false;\n let onParseError = NOOP;\n let onParseErrorThrow = false;\n\n const locationMap = new OffsetToLocation();\n const parser = Object.assign(new TokenStream(), processConfig(config || {}), {\n parseAtrulePrelude: true,\n parseRulePrelude: true,\n parseValue: true,\n parseCustomProperty: false,\n\n readSequence,\n\n consumeUntilBalanceEnd: () => 0,\n consumeUntilLeftCurlyBracket(code) {\n return code === LEFTCURLYBRACKET ? 1 : 0;\n },\n consumeUntilLeftCurlyBracketOrSemicolon(code) {\n return code === LEFTCURLYBRACKET || code === SEMICOLON ? 1 : 0;\n },\n consumeUntilExclamationMarkOrSemicolon(code) {\n return code === EXCLAMATIONMARK || code === SEMICOLON ? 1 : 0;\n },\n consumeUntilSemicolonIncluded(code) {\n return code === SEMICOLON ? 2 : 0;\n },\n\n createList: NOOP,\n createSingleNodeList: NOOP,\n getFirstListNode: NOOP,\n getLastListNode: NOOP,\n\n parseWithFallback(consumer, fallback) {\n const startIndex = this.tokenIndex;\n\n try {\n return consumer.call(this);\n } catch (e) {\n if (onParseErrorThrow) {\n throw e;\n }\n\n this.skip(startIndex - this.tokenIndex);\n const fallbackNode = fallback.call(this);\n\n onParseErrorThrow = true;\n onParseError(e, fallbackNode);\n onParseErrorThrow = false;\n\n return fallbackNode;\n }\n },\n\n lookupNonWSType(offset) {\n let type;\n\n do {\n type = this.lookupType(offset++);\n if (type !== WhiteSpace && type !== Comment) {\n return type;\n }\n } while (type !== NULL);\n\n return NULL;\n },\n\n charCodeAt(offset) {\n return offset >= 0 && offset < source.length ? source.charCodeAt(offset) : 0;\n },\n substring(offsetStart, offsetEnd) {\n return source.substring(offsetStart, offsetEnd);\n },\n substrToCursor(start) {\n return this.source.substring(start, this.tokenStart);\n },\n\n cmpChar(offset, charCode) {\n return cmpChar(source, offset, charCode);\n },\n cmpStr(offsetStart, offsetEnd, str) {\n return cmpStr(source, offsetStart, offsetEnd, str);\n },\n\n consume(tokenType) {\n const start = this.tokenStart;\n\n this.eat(tokenType);\n\n return this.substrToCursor(start);\n },\n consumeFunctionName() {\n const name = source.substring(this.tokenStart, this.tokenEnd - 1);\n\n this.eat(FunctionToken);\n\n return name;\n },\n consumeNumber(type) {\n const number = source.substring(this.tokenStart, consumeNumber(source, this.tokenStart));\n\n this.eat(type);\n\n return number;\n },\n\n eat(tokenType) {\n if (this.tokenType !== tokenType) {\n const tokenName = tokenNames[tokenType].slice(0, -6).replace(/-/g, ' ').replace(/^./, m => m.toUpperCase());\n let message = `${/[[\\](){}]/.test(tokenName) ? `\"${tokenName}\"` : tokenName} is expected`;\n let offset = this.tokenStart;\n\n // tweak message and offset\n switch (tokenType) {\n case Ident:\n // when identifier is expected but there is a function or url\n if (this.tokenType === FunctionToken || this.tokenType === Url) {\n offset = this.tokenEnd - 1;\n message = 'Identifier is expected but function found';\n } else {\n message = 'Identifier is expected';\n }\n break;\n\n case Hash:\n if (this.isDelim(NUMBERSIGN)) {\n this.next();\n offset++;\n message = 'Name is expected';\n }\n break;\n\n case Percentage:\n if (this.tokenType === NumberToken) {\n offset = this.tokenEnd;\n message = 'Percent sign is expected';\n }\n break;\n }\n\n this.error(message, offset);\n }\n\n this.next();\n },\n eatIdent(name) {\n if (this.tokenType !== Ident || this.lookupValue(0, name) === false) {\n this.error(`Identifier \"${name}\" is expected`);\n }\n\n this.next();\n },\n eatDelim(code) {\n if (!this.isDelim(code)) {\n this.error(`Delim \"${String.fromCharCode(code)}\" is expected`);\n }\n\n this.next();\n },\n\n getLocation(start, end) {\n if (needPositions) {\n return locationMap.getLocationRange(\n start,\n end,\n filename\n );\n }\n\n return null;\n },\n getLocationFromList(list) {\n if (needPositions) {\n const head = this.getFirstListNode(list);\n const tail = this.getLastListNode(list);\n return locationMap.getLocationRange(\n head !== null ? head.loc.start.offset - locationMap.startOffset : this.tokenStart,\n tail !== null ? tail.loc.end.offset - locationMap.startOffset : this.tokenStart,\n filename\n );\n }\n\n return null;\n },\n\n error(message, offset) {\n const location = typeof offset !== 'undefined' && offset < source.length\n ? locationMap.getLocation(offset)\n : this.eof\n ? locationMap.getLocation(findWhiteSpaceStart(source, source.length - 1))\n : locationMap.getLocation(this.tokenStart);\n\n throw new SyntaxError(\n message || 'Unexpected input',\n source,\n location.offset,\n location.line,\n location.column,\n locationMap.startLine,\n locationMap.startColumn\n );\n }\n });\n const createTokenIterateAPI = () => ({\n filename,\n source,\n tokenCount: parser.tokenCount,\n\n getTokenType: (index) =>\n parser.getTokenType(index),\n getTokenTypeName: (index) =>\n tokenNames[parser.getTokenType(index)],\n getTokenStart: (index) =>\n parser.getTokenStart(index),\n getTokenEnd: (index) =>\n parser.getTokenEnd(index),\n getTokenValue: (index) =>\n parser.source.substring(parser.getTokenStart(index), parser.getTokenEnd(index)),\n\n substring: (start, end) =>\n parser.source.substring(start, end),\n\n balance: parser.balance.subarray(0, parser.tokenCount + 1),\n isBlockOpenerTokenType: parser.isBlockOpenerTokenType,\n isBlockCloserTokenType: parser.isBlockCloserTokenType,\n getBlockTokenPairIndex: (index) =>\n parser.getBlockTokenPairIndex(index),\n\n getLocation: (offset) =>\n locationMap.getLocation(offset, filename),\n getRangeLocation: (start, end) =>\n locationMap.getLocationRange(start, end, filename)\n });\n\n const parse = function(source_, options) {\n source = source_;\n options = options || {};\n\n parser.setSource(source, tokenize);\n locationMap.setSource(\n source,\n options.offset,\n options.line,\n options.column\n );\n\n filename = options.filename || '<unknown>';\n needPositions = Boolean(options.positions);\n onParseError = typeof options.onParseError === 'function' ? options.onParseError : NOOP;\n onParseErrorThrow = false;\n\n parser.parseAtrulePrelude = 'parseAtrulePrelude' in options ? Boolean(options.parseAtrulePrelude) : true;\n parser.parseRulePrelude = 'parseRulePrelude' in options ? Boolean(options.parseRulePrelude) : true;\n parser.parseValue = 'parseValue' in options ? Boolean(options.parseValue) : true;\n parser.parseCustomProperty = 'parseCustomProperty' in options ? Boolean(options.parseCustomProperty) : false;\n\n const { context = 'default', list = true, onComment, onToken } = options;\n\n if (context in parser.context === false) {\n throw new Error('Unknown context `' + context + '`');\n }\n\n Object.assign(parser, list ? listMethods : arrayMethods);\n\n if (Array.isArray(onToken)) {\n parser.forEachToken((type, start, end) => {\n onToken.push({ type, start, end });\n });\n } else if (typeof onToken === 'function') {\n parser.forEachToken(onToken.bind(createTokenIterateAPI()));\n }\n\n if (typeof onComment === 'function') {\n parser.forEachToken((type, start, end) => {\n if (type === Comment) {\n const loc = parser.getLocation(start, end);\n const value = cmpStr(source, end - 2, end, '*/')\n ? source.slice(start + 2, end - 2)\n : source.slice(start + 2, end);\n\n onComment(value, loc);\n }\n });\n }\n\n const ast = parser.context[context].call(parser, options);\n\n if (!parser.eof) {\n parser.error();\n }\n\n return ast;\n };\n\n return Object.assign(parse, {\n SyntaxError,\n config: parser.config\n });\n};\n","import { SourceMapGenerator } from 'source-map-js/lib/source-map-generator.js';\n\nconst trackNodes = new Set(['Atrule', 'Selector', 'Declaration']);\n\nexport function generateSourceMap(handlers) {\n const map = new SourceMapGenerator();\n const generated = {\n line: 1,\n column: 0\n };\n const original = {\n line: 0, // should be zero to add first mapping\n column: 0\n };\n const activatedGenerated = {\n line: 1,\n column: 0\n };\n const activatedMapping = {\n generated: activatedGenerated\n };\n let line = 1;\n let column = 0;\n let sourceMappingActive = false;\n\n const origHandlersNode = handlers.node;\n handlers.node = function(node) {\n if (node.loc && node.loc.start && trackNodes.has(node.type)) {\n const nodeLine = node.loc.start.line;\n const nodeColumn = node.loc.start.column - 1;\n\n if (original.line !== nodeLine ||\n original.column !== nodeColumn) {\n original.line = nodeLine;\n original.column = nodeColumn;\n\n generated.line = line;\n generated.column = column;\n\n if (sourceMappingActive) {\n sourceMappingActive = false;\n if (generated.line !== activatedGenerated.line ||\n generated.column !== activatedGenerated.column) {\n map.addMapping(activatedMapping);\n }\n }\n\n sourceMappingActive = true;\n map.addMapping({\n source: node.loc.source,\n original,\n generated\n });\n }\n }\n\n origHandlersNode.call(this, node);\n\n if (sourceMappingActive && trackNodes.has(node.type)) {\n activatedGenerated.line = line;\n activatedGenerated.column = column;\n }\n };\n\n const origHandlersEmit = handlers.emit;\n handlers.emit = function(value, type, auto) {\n for (let i = 0; i < value.length; i++) {\n if (value.charCodeAt(i) === 10) { // \\n\n line++;\n column = 0;\n } else {\n column++;\n }\n }\n\n origHandlersEmit(value, type, auto);\n };\n\n const origHandlersResult = handlers.result;\n handlers.result = function() {\n if (sourceMappingActive) {\n map.addMapping(activatedMapping);\n }\n\n return {\n css: origHandlersResult(),\n map\n };\n };\n\n return handlers;\n};\n","import {\n Delim,\n Ident,\n Function as FunctionToken,\n Url,\n BadUrl,\n AtKeyword,\n Hash,\n Percentage,\n Dimension,\n Number as NumberToken,\n String as StringToken,\n Colon,\n LeftParenthesis,\n RightParenthesis,\n CDC\n} from '../tokenizer/index.js';\n\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)\n\n// code:\n// 0xxxxxxx x0000000 - char code (0x80 for non-ASCII) or delim value\n// 00000000 0xxxxxx0 - token type (0 for delim, 1 for token)\n// 00000000 0000000x - reserved for carriage emit flag (0 for no space, 1 for space)\nconst code = (type, value) => {\n if (type === Delim) {\n type = value;\n }\n\n if (typeof type === 'string') {\n type = Math.min(type.charCodeAt(0), 0x80) << 6; // replace non-ASCII with 0x80\n }\n\n return type << 1;\n};\n\n// https://www.w3.org/TR/css-syntax-3/#serialization\n// The only requirement for serialization is that it must \"round-trip\" with parsing,\n// that is, parsing the stylesheet must produce the same data structures as parsing,\n// serializing, and parsing again, except for consecutive <whitespace-token>s,\n// which may be collapsed into a single token.\n\nconst specPairs = [\n [Ident, Ident],\n [Ident, FunctionToken],\n [Ident, Url],\n [Ident, BadUrl],\n [Ident, '-'],\n [Ident, NumberToken],\n [Ident, Percentage],\n [Ident, Dimension],\n [Ident, CDC],\n [Ident, LeftParenthesis],\n\n [AtKeyword, Ident],\n [AtKeyword, FunctionToken],\n [AtKeyword, Url],\n [AtKeyword, BadUrl],\n [AtKeyword, '-'],\n [AtKeyword, NumberToken],\n [AtKeyword, Percentage],\n [AtKeyword, Dimension],\n [AtKeyword, CDC],\n\n [Hash, Ident],\n [Hash, FunctionToken],\n [Hash, Url],\n [Hash, BadUrl],\n [Hash, '-'],\n [Hash, NumberToken],\n [Hash, Percentage],\n [Hash, Dimension],\n [Hash, CDC],\n\n [Dimension, Ident],\n [Dimension, FunctionToken],\n [Dimension, Url],\n [Dimension, BadUrl],\n [Dimension, '-'],\n [Dimension, NumberToken],\n [Dimension, Percentage],\n [Dimension, Dimension],\n [Dimension, CDC],\n\n ['#', Ident],\n ['#', FunctionToken],\n ['#', Url],\n ['#', BadUrl],\n ['#', '-'],\n ['#', NumberToken],\n ['#', Percentage],\n ['#', Dimension],\n ['#', CDC], // https://github.com/w3c/csswg-drafts/pull/6874\n\n ['-', Ident],\n ['-', FunctionToken],\n ['-', Url],\n ['-', BadUrl],\n ['-', '-'],\n ['-', NumberToken],\n ['-', Percentage],\n ['-', Dimension],\n ['-', CDC], // https://github.com/w3c/csswg-drafts/pull/6874\n\n [NumberToken, Ident],\n [NumberToken, FunctionToken],\n [NumberToken, Url],\n [NumberToken, BadUrl],\n [NumberToken, NumberToken],\n [NumberToken, Percentage],\n [NumberToken, Dimension],\n [NumberToken, '%'],\n [NumberToken, CDC], // https://github.com/w3c/csswg-drafts/pull/6874\n\n ['@', Ident],\n ['@', FunctionToken],\n ['@', Url],\n ['@', BadUrl],\n ['@', '-'],\n ['@', CDC], // https://github.com/w3c/csswg-drafts/pull/6874\n\n ['.', NumberToken],\n ['.', Percentage],\n ['.', Dimension],\n\n ['+', NumberToken],\n ['+', Percentage],\n ['+', Dimension],\n\n ['/', '*']\n];\n// validate with scripts/generate-safe\nconst safePairs = specPairs.concat([\n [Ident, Hash],\n\n [Dimension, Hash],\n\n [Hash, Hash],\n\n [AtKeyword, LeftParenthesis],\n [AtKeyword, StringToken],\n [AtKeyword, Colon],\n\n [Percentage, Percentage],\n [Percentage, Dimension],\n [Percentage, FunctionToken],\n [Percentage, '-'],\n\n [RightParenthesis, Ident],\n [RightParenthesis, FunctionToken],\n [RightParenthesis, Percentage],\n [RightParenthesis, Dimension],\n [RightParenthesis, Hash],\n [RightParenthesis, '-']\n]);\n\nfunction createMap(pairs) {\n const isWhiteSpaceRequired = new Set(\n pairs.map(([prev, next]) => (code(prev) << 16 | code(next)))\n );\n\n return function(prevCode, type, value) {\n const nextCode = code(type, value);\n const nextCharCode = value.charCodeAt(0);\n const emitWs =\n (nextCharCode === HYPHENMINUS &&\n type !== Ident &&\n type !== FunctionToken &&\n type !== CDC) ||\n (nextCharCode === PLUSSIGN)\n ? isWhiteSpaceRequired.has((prevCode & 0xFFFE) << 16 | nextCharCode << 7)\n : isWhiteSpaceRequired.has((prevCode & 0xFFFE) << 16 | nextCode);\n\n return nextCode | emitWs;\n };\n}\n\nexport const spec = createMap(specPairs);\nexport const safe = createMap(safePairs);\n","import { tokenize, Delim, WhiteSpace } from '../tokenizer/index.js';\nimport { generateSourceMap } from './sourceMap.js';\nimport * as tokenBefore from './token-before.js';\n\nconst REVERSESOLIDUS = 0x005c; // U+005C REVERSE SOLIDUS (\\)\n\nfunction processChildren(node, delimeter) {\n if (typeof delimeter === 'function') {\n let prev = null;\n\n node.children.forEach(node => {\n if (prev !== null) {\n delimeter.call(this, prev);\n }\n\n this.node(node);\n prev = node;\n });\n\n return;\n }\n\n node.children.forEach(this.node, this);\n}\n\nexport function createGenerator(config) {\n const types = new Map();\n\n for (let [name, item] of Object.entries(config.node)) {\n const fn = item.generate || item;\n\n if (typeof fn === 'function') {\n types.set(name, item.generate || item);\n }\n }\n\n return function(node, options) {\n let buffer = '';\n let prevCode = 0;\n let handlers = {\n node(node) {\n if (types.has(node.type)) {\n types.get(node.type).call(publicApi, node);\n } else {\n throw new Error('Unknown node type: ' + node.type);\n }\n },\n tokenBefore: tokenBefore.safe,\n token(type, value, suppressAutoWhiteSpace) {\n prevCode = this.tokenBefore(prevCode, type, value);\n\n if (!suppressAutoWhiteSpace && prevCode & 1) {\n this.emit(' ', WhiteSpace, true);\n }\n\n this.emit(value, type, false);\n\n if (type === Delim && value.charCodeAt(0) === REVERSESOLIDUS) {\n this.emit('\\n', WhiteSpace, true);\n }\n },\n emit(value) {\n buffer += value;\n },\n result() {\n return buffer;\n }\n };\n\n if (options) {\n if (typeof options.decorator === 'function') {\n handlers = options.decorator(handlers);\n }\n\n if (options.sourceMap) {\n handlers = generateSourceMap(handlers);\n }\n\n if (options.mode in tokenBefore) {\n handlers.tokenBefore = tokenBefore[options.mode];\n }\n }\n\n const publicApi = {\n node: (node) => handlers.node(node),\n children: processChildren,\n token: (type, value) => handlers.token(type, value),\n tokenize: (raw) =>\n tokenize(raw, (type, start, end) => {\n handlers.token(\n type,\n raw.slice(start, end),\n start !== 0 // suppress auto whitespace for internal value tokens\n );\n })\n };\n\n handlers.node(node);\n\n return handlers.result();\n };\n};\n","const { hasOwnProperty } = Object.prototype;\nconst noop = function() {};\n\nfunction ensureFunction(value) {\n return typeof value === 'function' ? value : noop;\n}\n\nfunction invokeForType(fn, type) {\n return function(node, item, list) {\n if (node.type === type) {\n fn.call(this, node, item, list);\n }\n };\n}\n\nfunction getWalkersFromStructure(name, nodeType) {\n const structure = nodeType.structure;\n const walkers = [];\n\n for (const key in structure) {\n if (hasOwnProperty.call(structure, key) === false) {\n continue;\n }\n\n let fieldTypes = structure[key];\n const walker = {\n name: key,\n type: false,\n nullable: false\n };\n\n if (!Array.isArray(fieldTypes)) {\n fieldTypes = [fieldTypes];\n }\n\n for (const fieldType of fieldTypes) {\n if (fieldType === null) {\n walker.nullable = true;\n } else if (typeof fieldType === 'string') {\n walker.type = 'node';\n } else if (Array.isArray(fieldType)) {\n walker.type = 'list';\n }\n }\n\n if (walker.type) {\n walkers.push(walker);\n }\n }\n\n if (walkers.length) {\n return {\n context: nodeType.walkContext,\n fields: walkers\n };\n }\n\n return null;\n}\n\nfunction getTypesFromConfig(config) {\n const types = {};\n\n for (const name in config.node) {\n if (hasOwnProperty.call(config.node, name)) {\n const nodeType = config.node[name];\n\n if (!nodeType.structure) {\n throw new Error('Missed `structure` field in `' + name + '` node type definition');\n }\n\n types[name] = getWalkersFromStructure(name, nodeType);\n }\n }\n\n return types;\n}\n\nfunction createTypeIterator(config, reverse) {\n const fields = config.fields.slice();\n const contextName = config.context;\n const useContext = typeof contextName === 'string';\n\n if (reverse) {\n fields.reverse();\n }\n\n return function(node, context, walk, walkReducer) {\n let prevContextValue;\n\n if (useContext) {\n prevContextValue = context[contextName];\n context[contextName] = node;\n }\n\n for (const field of fields) {\n const ref = node[field.name];\n\n if (!field.nullable || ref) {\n if (field.type === 'list') {\n const breakWalk = reverse\n ? ref.reduceRight(walkReducer, false)\n : ref.reduce(walkReducer, false);\n\n if (breakWalk) {\n return true;\n }\n } else if (walk(ref)) {\n return true;\n }\n }\n }\n\n if (useContext) {\n context[contextName] = prevContextValue;\n }\n };\n}\n\nfunction createFastTraveralMap({\n StyleSheet,\n Atrule,\n Rule,\n Block,\n DeclarationList\n}) {\n return {\n Atrule: {\n StyleSheet,\n Atrule,\n Rule,\n Block\n },\n Rule: {\n StyleSheet,\n Atrule,\n Rule,\n Block\n },\n Declaration: {\n StyleSheet,\n Atrule,\n Rule,\n Block,\n DeclarationList\n }\n };\n}\n\nexport function createWalker(config) {\n const types = getTypesFromConfig(config);\n const iteratorsNatural = {};\n const iteratorsReverse = {};\n const breakWalk = Symbol('break-walk');\n const skipNode = Symbol('skip-node');\n\n for (const name in types) {\n if (hasOwnProperty.call(types, name) && types[name] !== null) {\n iteratorsNatural[name] = createTypeIterator(types[name], false);\n iteratorsReverse[name] = createTypeIterator(types[name], true);\n }\n }\n\n const fastTraversalIteratorsNatural = createFastTraveralMap(iteratorsNatural);\n const fastTraversalIteratorsReverse = createFastTraveralMap(iteratorsReverse);\n\n const walk = function(root, options) {\n function walkNode(node, item, list) {\n const enterRet = enter.call(context, node, item, list);\n\n if (enterRet === breakWalk) {\n return true;\n }\n\n if (enterRet === skipNode) {\n return false;\n }\n\n if (iterators.hasOwnProperty(node.type)) {\n if (iterators[node.type](node, context, walkNode, walkReducer)) {\n return true;\n }\n }\n\n if (leave.call(context, node, item, list) === breakWalk) {\n return true;\n }\n\n return false;\n }\n\n let enter = noop;\n let leave = noop;\n let iterators = iteratorsNatural;\n let walkReducer = (ret, data, item, list) => ret || walkNode(data, item, list);\n const context = {\n break: breakWalk,\n skip: skipNode,\n\n root,\n stylesheet: null,\n atrule: null,\n atrulePrelude: null,\n rule: null,\n selector: null,\n block: null,\n declaration: null,\n function: null\n };\n\n if (typeof options === 'function') {\n enter = options;\n } else if (options) {\n enter = ensureFunction(options.enter);\n leave = ensureFunction(options.leave);\n\n if (options.reverse) {\n iterators = iteratorsReverse;\n }\n\n if (options.visit) {\n if (fastTraversalIteratorsNatural.hasOwnProperty(options.visit)) {\n iterators = options.reverse\n ? fastTraversalIteratorsReverse[options.visit]\n : fastTraversalIteratorsNatural[options.visit];\n } else if (!types.hasOwnProperty(options.visit)) {\n throw new Error('Bad value `' + options.visit + '` for `visit` option (should be: ' + Object.keys(types).sort().join(', ') + ')');\n }\n\n enter = invokeForType(enter, options.visit);\n leave = invokeForType(leave, options.visit);\n }\n }\n\n if (enter === noop && leave === noop) {\n throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\\'t a function');\n }\n\n walkNode(root);\n };\n\n walk.break = breakWalk;\n walk.skip = skipNode;\n\n walk.find = function(ast, fn) {\n let found = null;\n\n walk(ast, function(node, item, list) {\n if (fn.call(this, node, item, list)) {\n found = node;\n return breakWalk;\n }\n });\n\n return found;\n };\n\n walk.findLast = function(ast, fn) {\n let found = null;\n\n walk(ast, {\n reverse: true,\n enter(node, item, list) {\n if (fn.call(this, node, item, list)) {\n found = node;\n return breakWalk;\n }\n }\n });\n\n return found;\n };\n\n walk.findAll = function(ast, fn) {\n const found = [];\n\n walk(ast, function(node, item, list) {\n if (fn.call(this, node, item, list)) {\n found.push(node);\n }\n });\n\n return found;\n };\n\n return walk;\n};\n","function noop(value) {\n return value;\n}\n\nfunction generateMultiplier(multiplier) {\n const { min, max, comma } = multiplier;\n\n if (min === 0 && max === 0) {\n return comma ? '#?' : '*';\n }\n\n if (min === 0 && max === 1) {\n return '?';\n }\n\n if (min === 1 && max === 0) {\n return comma ? '#' : '+';\n }\n\n if (min === 1 && max === 1) {\n return '';\n }\n\n return (\n (comma ? '#' : '') +\n (min === max\n ? '{' + min + '}'\n : '{' + min + ',' + (max !== 0 ? max : '') + '}'\n )\n );\n}\n\nfunction generateTypeOpts(node) {\n switch (node.type) {\n case 'Range':\n return (\n ' [' +\n (node.min === null ? '-∞' : node.min) +\n ',' +\n (node.max === null ? '∞' : node.max) +\n ']'\n );\n\n default:\n throw new Error('Unknown node type `' + node.type + '`');\n }\n}\n\nfunction generateSequence(node, decorate, forceBraces, compact) {\n const combinator = node.combinator === ' ' || compact ? node.combinator : ' ' + node.combinator + ' ';\n const result = node.terms\n .map(term => internalGenerate(term, decorate, forceBraces, compact))\n .join(combinator);\n\n if (node.explicit || forceBraces) {\n return (compact || result[0] === ',' ? '[' : '[ ') + result + (compact ? ']' : ' ]');\n }\n\n return result;\n}\n\nfunction internalGenerate(node, decorate, forceBraces, compact) {\n let result;\n\n switch (node.type) {\n case 'Group':\n result =\n generateSequence(node, decorate, forceBraces, compact) +\n (node.disallowEmpty ? '!' : '');\n break;\n\n case 'Multiplier':\n // return since node is a composition\n return (\n internalGenerate(node.term, decorate, forceBraces, compact) +\n decorate(generateMultiplier(node), node)\n );\n\n case 'Boolean':\n result = '<boolean-expr[' + internalGenerate(node.term, decorate, forceBraces, compact) + ']>';\n break;\n\n case 'Type':\n result = '<' + node.name + (node.opts ? decorate(generateTypeOpts(node.opts), node.opts) : '') + '>';\n break;\n\n case 'Property':\n result = '<\\'' + node.name + '\\'>';\n break;\n\n case 'Keyword':\n result = node.name;\n break;\n\n case 'AtKeyword':\n result = '@' + node.name;\n break;\n\n case 'Function':\n result = node.name + '(';\n break;\n\n case 'String':\n case 'Token':\n result = node.value;\n break;\n\n case 'Comma':\n result = ',';\n break;\n\n default:\n throw new Error('Unknown node type `' + node.type + '`');\n }\n\n return decorate(result, node);\n}\n\nexport function generate(node, options) {\n let decorate = noop;\n let forceBraces = false;\n let compact = false;\n\n if (typeof options === 'function') {\n decorate = options;\n } else if (options) {\n forceBraces = Boolean(options.forceBraces);\n compact = Boolean(options.compact);\n if (typeof options.decorate === 'function') {\n decorate = options.decorate;\n }\n }\n\n return internalGenerate(node, decorate, forceBraces, compact);\n};\n","import { createCustomError } from '../utils/create-custom-error.js';\nimport { generate } from '../definition-syntax/generate.js';\n\nconst defaultLoc = { offset: 0, line: 1, column: 1 };\n\nfunction locateMismatch(matchResult, node) {\n const tokens = matchResult.tokens;\n const longestMatch = matchResult.longestMatch;\n const mismatchNode = longestMatch < tokens.length ? tokens[longestMatch].node || null : null;\n const badNode = mismatchNode !== node ? mismatchNode : null;\n let mismatchOffset = 0;\n let mismatchLength = 0;\n let entries = 0;\n let css = '';\n let start;\n let end;\n\n for (let i = 0; i < tokens.length; i++) {\n const token = tokens[i].value;\n\n if (i === longestMatch) {\n mismatchLength = token.length;\n mismatchOffset = css.length;\n }\n\n if (badNode !== null && tokens[i].node === badNode) {\n if (i <= longestMatch) {\n entries++;\n } else {\n entries = 0;\n }\n }\n\n css += token;\n }\n\n if (longestMatch === tokens.length || entries > 1) { // last\n start = fromLoc(badNode || node, 'end') || buildLoc(defaultLoc, css);\n end = buildLoc(start);\n } else {\n start = fromLoc(badNode, 'start') ||\n buildLoc(fromLoc(node, 'start') || defaultLoc, css.slice(0, mismatchOffset));\n end = fromLoc(badNode, 'end') ||\n buildLoc(start, css.substr(mismatchOffset, mismatchLength));\n }\n\n return {\n css,\n mismatchOffset,\n mismatchLength,\n start,\n end\n };\n}\n\nfunction fromLoc(node, point) {\n const value = node && node.loc && node.loc[point];\n\n if (value) {\n return 'line' in value ? buildLoc(value) : value;\n }\n\n return null;\n}\n\nfunction buildLoc({ offset, line, column }, extra) {\n const loc = {\n offset,\n line,\n column\n };\n\n if (extra) {\n const lines = extra.split(/\\n|\\r\\n?|\\f/);\n\n loc.offset += extra.length;\n loc.line += lines.length - 1;\n loc.column = lines.length === 1 ? loc.column + extra.length : lines.pop().length + 1;\n }\n\n return loc;\n}\n\nexport const SyntaxReferenceError = function(type, referenceName) {\n const error = createCustomError(\n 'SyntaxReferenceError',\n type + (referenceName ? ' `' + referenceName + '`' : '')\n );\n\n error.reference = referenceName;\n\n return error;\n};\n\nexport const SyntaxMatchError = function(message, syntax, node, matchResult) {\n const error = createCustomError('SyntaxMatchError', message);\n const {\n css,\n mismatchOffset,\n mismatchLength,\n start,\n end\n } = locateMismatch(matchResult, node);\n\n error.rawMessage = message;\n error.syntax = syntax ? generate(syntax) : '<generic>';\n error.css = css;\n error.mismatchOffset = mismatchOffset;\n error.mismatchLength = mismatchLength;\n error.message = message + '\\n' +\n ' syntax: ' + error.syntax + '\\n' +\n ' value: ' + (css || '<empty string>') + '\\n' +\n ' --------' + new Array(error.mismatchOffset + 1).join('-') + '^';\n\n Object.assign(error, start);\n error.loc = {\n source: (node && node.loc && node.loc.source) || '<unknown>',\n start,\n end\n };\n\n return error;\n};\n","const keywords = new Map();\nconst properties = new Map();\nconst HYPHENMINUS = 45; // '-'.charCodeAt()\n\nexport const keyword = getKeywordDescriptor;\nexport const property = getPropertyDescriptor;\nexport const vendorPrefix = getVendorPrefix;\nexport function isCustomProperty(str, offset) {\n offset = offset || 0;\n\n return str.length - offset >= 2 &&\n str.charCodeAt(offset) === HYPHENMINUS &&\n str.charCodeAt(offset + 1) === HYPHENMINUS;\n}\n\nfunction getVendorPrefix(str, offset) {\n offset = offset || 0;\n\n // verdor prefix should be at least 3 chars length\n if (str.length - offset >= 3) {\n // vendor prefix starts with hyper minus following non-hyper minus\n if (str.charCodeAt(offset) === HYPHENMINUS &&\n str.charCodeAt(offset + 1) !== HYPHENMINUS) {\n // vendor prefix should contain a hyper minus at the ending\n const secondDashIndex = str.indexOf('-', offset + 2);\n\n if (secondDashIndex !== -1) {\n return str.substring(offset, secondDashIndex + 1);\n }\n }\n }\n\n return '';\n}\n\nfunction getKeywordDescriptor(keyword) {\n if (keywords.has(keyword)) {\n return keywords.get(keyword);\n }\n\n const name = keyword.toLowerCase();\n let descriptor = keywords.get(name);\n\n if (descriptor === undefined) {\n const custom = isCustomProperty(name, 0);\n const vendor = !custom ? getVendorPrefix(name, 0) : '';\n descriptor = Object.freeze({\n basename: name.substr(vendor.length),\n name,\n prefix: vendor,\n vendor,\n custom\n });\n }\n\n keywords.set(keyword, descriptor);\n\n return descriptor;\n}\n\nfunction getPropertyDescriptor(property) {\n if (properties.has(property)) {\n return properties.get(property);\n }\n\n let name = property;\n let hack = property[0];\n\n if (hack === '/') {\n hack = property[1] === '/' ? '//' : '/';\n } else if (hack !== '_' &&\n hack !== '*' &&\n hack !== '$' &&\n hack !== '#' &&\n hack !== '+' &&\n hack !== '&') {\n hack = '';\n }\n\n const custom = isCustomProperty(name, hack.length);\n\n // re-use result when possible (the same as for lower case)\n if (!custom) {\n name = name.toLowerCase();\n if (properties.has(name)) {\n const descriptor = properties.get(name);\n properties.set(property, descriptor);\n return descriptor;\n }\n }\n\n const vendor = !custom ? getVendorPrefix(name, hack.length) : '';\n const prefix = name.substr(0, hack.length + vendor.length);\n const descriptor = Object.freeze({\n basename: name.substr(prefix.length),\n name: name.substr(hack.length),\n hack,\n vendor,\n prefix,\n custom\n });\n\n properties.set(property, descriptor);\n\n return descriptor;\n}\n","// https://drafts.csswg.org/css-cascade-5/\nexport const cssWideKeywords = [\n 'initial',\n 'inherit',\n 'unset',\n 'revert',\n 'revert-layer'\n];\n","import {\n isDigit,\n cmpChar,\n Delim,\n WhiteSpace,\n Comment,\n Ident,\n Number as NumberToken,\n Dimension\n} from '../tokenizer/index.js';\n\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)\nconst N = 0x006E; // U+006E LATIN SMALL LETTER N (n)\nconst DISALLOW_SIGN = true;\nconst ALLOW_SIGN = false;\n\nfunction isDelim(token, code) {\n return token !== null && token.type === Delim && token.value.charCodeAt(0) === code;\n}\n\nfunction skipSC(token, offset, getNextToken) {\n while (token !== null && (token.type === WhiteSpace || token.type === Comment)) {\n token = getNextToken(++offset);\n }\n\n return offset;\n}\n\nfunction checkInteger(token, valueOffset, disallowSign, offset) {\n if (!token) {\n return 0;\n }\n\n const code = token.value.charCodeAt(valueOffset);\n\n if (code === PLUSSIGN || code === HYPHENMINUS) {\n if (disallowSign) {\n // Number sign is not allowed\n return 0;\n }\n valueOffset++;\n }\n\n for (; valueOffset < token.value.length; valueOffset++) {\n if (!isDigit(token.value.charCodeAt(valueOffset))) {\n // Integer is expected\n return 0;\n }\n }\n\n return offset + 1;\n}\n\n// ... <signed-integer>\n// ... ['+' | '-'] <signless-integer>\nfunction consumeB(token, offset_, getNextToken) {\n let sign = false;\n let offset = skipSC(token, offset_, getNextToken);\n\n token = getNextToken(offset);\n\n if (token === null) {\n return offset_;\n }\n\n if (token.type !== NumberToken) {\n if (isDelim(token, PLUSSIGN) || isDelim(token, HYPHENMINUS)) {\n sign = true;\n offset = skipSC(getNextToken(++offset), offset, getNextToken);\n token = getNextToken(offset);\n\n if (token === null || token.type !== NumberToken) {\n return 0;\n }\n } else {\n return offset_;\n }\n }\n\n if (!sign) {\n const code = token.value.charCodeAt(0);\n if (code !== PLUSSIGN && code !== HYPHENMINUS) {\n // Number sign is expected\n return 0;\n }\n }\n\n return checkInteger(token, sign ? 0 : 1, sign, offset);\n}\n\n// An+B microsyntax https://www.w3.org/TR/css-syntax-3/#anb\nexport default function anPlusB(token, getNextToken) {\n /* eslint-disable brace-style*/\n let offset = 0;\n\n if (!token) {\n return 0;\n }\n\n // <integer>\n if (token.type === NumberToken) {\n return checkInteger(token, 0, ALLOW_SIGN, offset); // b\n }\n\n // -n\n // -n <signed-integer>\n // -n ['+' | '-'] <signless-integer>\n // -n- <signless-integer>\n // <dashndashdigit-ident>\n else if (token.type === Ident && token.value.charCodeAt(0) === HYPHENMINUS) {\n // expect 1st char is N\n if (!cmpChar(token.value, 1, N)) {\n return 0;\n }\n\n switch (token.value.length) {\n // -n\n // -n <signed-integer>\n // -n ['+' | '-'] <signless-integer>\n case 2:\n return consumeB(getNextToken(++offset), offset, getNextToken);\n\n // -n- <signless-integer>\n case 3:\n if (token.value.charCodeAt(2) !== HYPHENMINUS) {\n return 0;\n }\n\n offset = skipSC(getNextToken(++offset), offset, getNextToken);\n token = getNextToken(offset);\n\n return checkInteger(token, 0, DISALLOW_SIGN, offset);\n\n // <dashndashdigit-ident>\n default:\n if (token.value.charCodeAt(2) !== HYPHENMINUS) {\n return 0;\n }\n\n return checkInteger(token, 3, DISALLOW_SIGN, offset);\n }\n }\n\n // '+'? n\n // '+'? n <signed-integer>\n // '+'? n ['+' | '-'] <signless-integer>\n // '+'? n- <signless-integer>\n // '+'? <ndashdigit-ident>\n else if (token.type === Ident || (isDelim(token, PLUSSIGN) && getNextToken(offset + 1).type === Ident)) {\n // just ignore a plus\n if (token.type !== Ident) {\n token = getNextToken(++offset);\n }\n\n if (token === null || !cmpChar(token.value, 0, N)) {\n return 0;\n }\n\n switch (token.value.length) {\n // '+'? n\n // '+'? n <signed-integer>\n // '+'? n ['+' | '-'] <signless-integer>\n case 1:\n return consumeB(getNextToken(++offset), offset, getNextToken);\n\n // '+'? n- <signless-integer>\n case 2:\n if (token.value.charCodeAt(1) !== HYPHENMINUS) {\n return 0;\n }\n\n offset = skipSC(getNextToken(++offset), offset, getNextToken);\n token = getNextToken(offset);\n\n return checkInteger(token, 0, DISALLOW_SIGN, offset);\n\n // '+'? <ndashdigit-ident>\n default:\n if (token.value.charCodeAt(1) !== HYPHENMINUS) {\n return 0;\n }\n\n return checkInteger(token, 2, DISALLOW_SIGN, offset);\n }\n }\n\n // <ndashdigit-dimension>\n // <ndash-dimension> <signless-integer>\n // <n-dimension>\n // <n-dimension> <signed-integer>\n // <n-dimension> ['+' | '-'] <signless-integer>\n else if (token.type === Dimension) {\n let code = token.value.charCodeAt(0);\n let sign = code === PLUSSIGN || code === HYPHENMINUS ? 1 : 0;\n let i = sign;\n\n for (; i < token.value.length; i++) {\n if (!isDigit(token.value.charCodeAt(i))) {\n break;\n }\n }\n\n if (i === sign) {\n // Integer is expected\n return 0;\n }\n\n if (!cmpChar(token.value, i, N)) {\n return 0;\n }\n\n // <n-dimension>\n // <n-dimension> <signed-integer>\n // <n-dimension> ['+' | '-'] <signless-integer>\n if (i + 1 === token.value.length) {\n return consumeB(getNextToken(++offset), offset, getNextToken);\n } else {\n if (token.value.charCodeAt(i + 1) !== HYPHENMINUS) {\n return 0;\n }\n\n // <ndash-dimension> <signless-integer>\n if (i + 2 === token.value.length) {\n offset = skipSC(getNextToken(++offset), offset, getNextToken);\n token = getNextToken(offset);\n\n return checkInteger(token, 0, DISALLOW_SIGN, offset);\n }\n // <ndashdigit-dimension>\n else {\n return checkInteger(token, i + 2, DISALLOW_SIGN, offset);\n }\n }\n }\n\n return 0;\n};\n","import {\n isHexDigit,\n cmpChar,\n Ident,\n Delim,\n Number as NumberToken,\n Dimension\n} from '../tokenizer/index.js';\n\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)\nconst QUESTIONMARK = 0x003F; // U+003F QUESTION MARK (?)\nconst U = 0x0075; // U+0075 LATIN SMALL LETTER U (u)\n\nfunction isDelim(token, code) {\n return token !== null && token.type === Delim && token.value.charCodeAt(0) === code;\n}\n\nfunction startsWith(token, code) {\n return token.value.charCodeAt(0) === code;\n}\n\nfunction hexSequence(token, offset, allowDash) {\n let hexlen = 0;\n\n for (let pos = offset; pos < token.value.length; pos++) {\n const code = token.value.charCodeAt(pos);\n\n if (code === HYPHENMINUS && allowDash && hexlen !== 0) {\n hexSequence(token, offset + hexlen + 1, false);\n return 6; // dissallow following question marks\n }\n\n if (!isHexDigit(code)) {\n return 0; // not a hex digit\n }\n\n if (++hexlen > 6) {\n return 0; // too many hex digits\n };\n }\n\n return hexlen;\n}\n\nfunction withQuestionMarkSequence(consumed, length, getNextToken) {\n if (!consumed) {\n return 0; // nothing consumed\n }\n\n while (isDelim(getNextToken(length), QUESTIONMARK)) {\n if (++consumed > 6) {\n return 0; // too many question marks\n }\n\n length++;\n }\n\n return length;\n}\n\n// https://drafts.csswg.org/css-syntax/#urange\n// Informally, the <urange> production has three forms:\n// U+0001\n// Defines a range consisting of a single code point, in this case the code point \"1\".\n// U+0001-00ff\n// Defines a range of codepoints between the first and the second value, in this case\n// the range between \"1\" and \"ff\" (255 in decimal) inclusive.\n// U+00??\n// Defines a range of codepoints where the \"?\" characters range over all hex digits,\n// in this case defining the same as the value U+0000-00ff.\n// In each form, a maximum of 6 digits is allowed for each hexadecimal number (if you treat \"?\" as a hexadecimal digit).\n//\n// <urange> =\n// u '+' <ident-token> '?'* |\n// u <dimension-token> '?'* |\n// u <number-token> '?'* |\n// u <number-token> <dimension-token> |\n// u <number-token> <number-token> |\n// u '+' '?'+\nexport default function urange(token, getNextToken) {\n let length = 0;\n\n // should start with `u` or `U`\n if (token === null || token.type !== Ident || !cmpChar(token.value, 0, U)) {\n return 0;\n }\n\n token = getNextToken(++length);\n if (token === null) {\n return 0;\n }\n\n // u '+' <ident-token> '?'*\n // u '+' '?'+\n if (isDelim(token, PLUSSIGN)) {\n token = getNextToken(++length);\n if (token === null) {\n return 0;\n }\n\n if (token.type === Ident) {\n // u '+' <ident-token> '?'*\n return withQuestionMarkSequence(hexSequence(token, 0, true), ++length, getNextToken);\n }\n\n if (isDelim(token, QUESTIONMARK)) {\n // u '+' '?'+\n return withQuestionMarkSequence(1, ++length, getNextToken);\n }\n\n // Hex digit or question mark is expected\n return 0;\n }\n\n // u <number-token> '?'*\n // u <number-token> <dimension-token>\n // u <number-token> <number-token>\n if (token.type === NumberToken) {\n const consumedHexLength = hexSequence(token, 1, true);\n if (consumedHexLength === 0) {\n return 0;\n }\n\n token = getNextToken(++length);\n if (token === null) {\n // u <number-token> <eof>\n return length;\n }\n\n if (token.type === Dimension || token.type === NumberToken) {\n // u <number-token> <dimension-token>\n // u <number-token> <number-token>\n if (!startsWith(token, HYPHENMINUS) || !hexSequence(token, 1, false)) {\n return 0;\n }\n\n return length + 1;\n }\n\n // u <number-token> '?'*\n return withQuestionMarkSequence(consumedHexLength, length, getNextToken);\n }\n\n // u <dimension-token> '?'*\n if (token.type === Dimension) {\n return withQuestionMarkSequence(hexSequence(token, 1, true), ++length, getNextToken);\n }\n\n return 0;\n};\n","import { cssWideKeywords } from './generic-const.js';\nimport anPlusB from './generic-an-plus-b.js';\nimport urange from './generic-urange.js';\nimport {\n isIdentifierStart,\n isHexDigit,\n isDigit,\n cmpStr,\n consumeNumber,\n\n Ident,\n Function as FunctionToken,\n AtKeyword,\n Hash,\n String as StringToken,\n BadString,\n Url,\n BadUrl,\n Delim,\n Number as NumberToken,\n Percentage,\n Dimension,\n WhiteSpace,\n CDO,\n CDC,\n Colon,\n Semicolon,\n Comma,\n LeftSquareBracket,\n RightSquareBracket,\n LeftParenthesis,\n RightParenthesis,\n LeftCurlyBracket,\n RightCurlyBracket\n} from '../tokenizer/index.js';\n\n// CSS mathematical functions categorized by return type behavior\n// See: https://www.w3.org/TR/css-values-4/#math\n\n// Calculation functions that return different types depending on input\nconst calcFunctionNames = [\n 'calc(',\n '-moz-calc(',\n '-webkit-calc('\n];\n\n// Comparison functions that return different types depending on input\nconst comparisonFunctionNames = [\n 'min(',\n 'max(',\n 'clamp('\n];\n\n// Functions that return a stepped value, i.e. a value that is rounded to the nearest step\nconst steppedValueFunctionNames = [\n 'round(',\n 'mod(',\n 'rem('\n];\n\n// Trigonometrical functions that return a <number>\nconst trigNumberFunctionNames = [\n 'sin(',\n 'cos(',\n 'tan('\n];\n\n// Trigonometrical functions that return a <angle>\nconst trigAngleFunctionNames = [\n 'asin(',\n 'acos(',\n 'atan(',\n 'atan2('\n];\n\n// Other functions that return a <number>\nconst otherNumberFunctionNames = [\n 'pow(',\n 'sqrt(',\n 'log(',\n 'exp(',\n 'sign('\n];\n\n// Exponential functions that return a <number> or <dimension> or <percentage>\nconst expNumberDimensionPercentageFunctionNames = [\n 'hypot('\n];\n\n// Return the same type as the input\nconst signFunctionNames = [\n 'abs('\n];\n\nconst numberFunctionNames = [\n ...calcFunctionNames,\n ...comparisonFunctionNames,\n ...steppedValueFunctionNames,\n ...trigNumberFunctionNames,\n ...otherNumberFunctionNames,\n ...expNumberDimensionPercentageFunctionNames,\n ...signFunctionNames\n];\n\nconst percentageFunctionNames = [\n ...calcFunctionNames,\n ...comparisonFunctionNames,\n ...steppedValueFunctionNames,\n ...expNumberDimensionPercentageFunctionNames,\n ...signFunctionNames\n];\n\nconst dimensionFunctionNames = [\n ...calcFunctionNames,\n ...comparisonFunctionNames,\n ...steppedValueFunctionNames,\n ...trigAngleFunctionNames,\n ...expNumberDimensionPercentageFunctionNames,\n ...signFunctionNames\n];\n\nconst balancePair = new Map([\n [FunctionToken, RightParenthesis],\n [LeftParenthesis, RightParenthesis],\n [LeftSquareBracket, RightSquareBracket],\n [LeftCurlyBracket, RightCurlyBracket]\n]);\n\n// safe char code getter\nfunction charCodeAt(str, index) {\n return index < str.length ? str.charCodeAt(index) : 0;\n}\n\nfunction eqStr(actual, expected) {\n return cmpStr(actual, 0, actual.length, expected);\n}\n\nfunction eqStrAny(actual, expected) {\n for (let i = 0; i < expected.length; i++) {\n if (eqStr(actual, expected[i])) {\n return true;\n }\n }\n\n return false;\n}\n\n// IE postfix hack, i.e. 123\\0 or 123px\\9\nfunction isPostfixIeHack(str, offset) {\n if (offset !== str.length - 2) {\n return false;\n }\n\n return (\n charCodeAt(str, offset) === 0x005C && // U+005C REVERSE SOLIDUS (\\)\n isDigit(charCodeAt(str, offset + 1))\n );\n}\n\nfunction outOfRange(opts, value, numEnd) {\n if (opts && opts.type === 'Range') {\n const num = Number(\n numEnd !== undefined && numEnd !== value.length\n ? value.substr(0, numEnd)\n : value\n );\n\n if (isNaN(num)) {\n return true;\n }\n\n // FIXME: when opts.min is a string it's a dimension, skip a range validation\n // for now since it requires a type covertation which is not implmented yet\n if (opts.min !== null && num < opts.min && typeof opts.min !== 'string') {\n return true;\n }\n\n // FIXME: when opts.max is a string it's a dimension, skip a range validation\n // for now since it requires a type covertation which is not implmented yet\n if (opts.max !== null && num > opts.max && typeof opts.max !== 'string') {\n return true;\n }\n }\n\n return false;\n}\n\nfunction consumeFunction(token, getNextToken) {\n let balanceCloseType = 0;\n let balanceStash = [];\n let length = 0;\n\n // balanced token consuming\n scan:\n do {\n switch (token.type) {\n case RightCurlyBracket:\n case RightParenthesis:\n case RightSquareBracket:\n if (token.type !== balanceCloseType) {\n break scan;\n }\n\n balanceCloseType = balanceStash.pop();\n\n if (balanceStash.length === 0) {\n length++;\n break scan;\n }\n\n break;\n\n case FunctionToken:\n case LeftParenthesis:\n case LeftSquareBracket:\n case LeftCurlyBracket:\n balanceStash.push(balanceCloseType);\n balanceCloseType = balancePair.get(token.type);\n break;\n }\n\n length++;\n } while (token = getNextToken(length));\n\n return length;\n}\n\n\n// TODO: implement\n// can be used wherever <length>, <frequency>, <angle>, <time>, <percentage>, <number>, or <integer> values are allowed\n// https://drafts.csswg.org/css-values/#calc-notation\nfunction math(next, functionNames) {\n return function(token, getNextToken, opts) {\n if (token === null) {\n return 0;\n }\n\n if (token.type === FunctionToken && eqStrAny(token.value, functionNames)) {\n return consumeFunction(token, getNextToken);\n }\n\n return next(token, getNextToken, opts);\n };\n}\n\nfunction tokenType(expectedTokenType) {\n return function(token) {\n if (token === null || token.type !== expectedTokenType) {\n return 0;\n }\n\n return 1;\n };\n}\n\n// =========================\n// Complex types\n//\n\n// https://drafts.csswg.org/css-values-4/#custom-idents\n// 4.2. Author-defined Identifiers: the <custom-ident> type\n// Some properties accept arbitrary author-defined identifiers as a component value.\n// This generic data type is denoted by <custom-ident>, and represents any valid CSS identifier\n// that would not be misinterpreted as a pre-defined keyword in that property’s value definition.\n//\n// See also: https://developer.mozilla.org/en-US/docs/Web/CSS/custom-ident\nfunction customIdent(token) {\n if (token === null || token.type !== Ident) {\n return 0;\n }\n\n const name = token.value.toLowerCase();\n\n // The CSS-wide keywords are not valid <custom-ident>s\n if (eqStrAny(name, cssWideKeywords)) {\n return 0;\n }\n\n // The default keyword is reserved and is also not a valid <custom-ident>\n if (eqStr(name, 'default')) {\n return 0;\n }\n\n // TODO: ignore property specific keywords (as described https://developer.mozilla.org/en-US/docs/Web/CSS/custom-ident)\n // Specifications using <custom-ident> must specify clearly what other keywords\n // are excluded from <custom-ident>, if any—for example by saying that any pre-defined keywords\n // in that property’s value definition are excluded. Excluded keywords are excluded\n // in all ASCII case permutations.\n\n return 1;\n}\n\n// https://drafts.csswg.org/css-values-4/#dashed-idents\n// The <dashed-ident> production is a <custom-ident>, with all the case-sensitivity that implies,\n// with the additional restriction that it must start with two dashes (U+002D HYPHEN-MINUS).\nfunction dashedIdent(token) {\n if (token === null || token.type !== Ident) {\n return 0;\n }\n\n // ... must start with two dashes (U+002D HYPHEN-MINUS)\n if (charCodeAt(token.value, 0) !== 0x002D || charCodeAt(token.value, 1) !== 0x002D) {\n return 0;\n }\n\n return 1;\n}\n\n// https://drafts.csswg.org/css-variables/#typedef-custom-property-name\n// A custom property is any property whose name starts with two dashes (U+002D HYPHEN-MINUS), like --foo.\n// The <custom-property-name> production corresponds to this: it’s defined as any <dashed-ident>\n// (a valid identifier that starts with two dashes), except -- itself, which is reserved for future use by CSS.\nfunction customPropertyName(token) {\n // ... it’s defined as any <dashed-ident>\n if (!dashedIdent(token)) {\n return 0;\n }\n\n // ... except -- itself, which is reserved for future use by CSS\n if (token.value === '--') {\n return 0;\n }\n\n return 1;\n}\n\n// https://drafts.csswg.org/css-color-4/#hex-notation\n// The syntax of a <hex-color> is a <hash-token> token whose value consists of 3, 4, 6, or 8 hexadecimal digits.\n// In other words, a hex color is written as a hash character, \"#\", followed by some number of digits 0-9 or\n// letters a-f (the case of the letters doesn’t matter - #00ff00 is identical to #00FF00).\nfunction hexColor(token) {\n if (token === null || token.type !== Hash) {\n return 0;\n }\n\n const length = token.value.length;\n\n // valid values (length): #rgb (4), #rgba (5), #rrggbb (7), #rrggbbaa (9)\n if (length !== 4 && length !== 5 && length !== 7 && length !== 9) {\n return 0;\n }\n\n for (let i = 1; i < length; i++) {\n if (!isHexDigit(charCodeAt(token.value, i))) {\n return 0;\n }\n }\n\n return 1;\n}\n\nfunction idSelector(token) {\n if (token === null || token.type !== Hash) {\n return 0;\n }\n\n if (!isIdentifierStart(charCodeAt(token.value, 1), charCodeAt(token.value, 2), charCodeAt(token.value, 3))) {\n return 0;\n }\n\n return 1;\n}\n\n// https://drafts.csswg.org/css-syntax/#any-value\n// It represents the entirety of what a valid declaration can have as its value.\nfunction declarationValue(token, getNextToken) {\n if (!token) {\n return 0;\n }\n\n let balanceCloseType = 0;\n let balanceStash = [];\n let length = 0;\n\n // The <declaration-value> production matches any sequence of one or more tokens,\n // so long as the sequence does not contain ...\n scan:\n do {\n switch (token.type) {\n // ... <bad-string-token>, <bad-url-token>,\n case BadString:\n case BadUrl:\n break scan;\n\n // ... unmatched <)-token>, <]-token>, or <}-token>,\n case RightCurlyBracket:\n case RightParenthesis:\n case RightSquareBracket:\n if (token.type !== balanceCloseType) {\n break scan;\n }\n\n balanceCloseType = balanceStash.pop();\n break;\n\n // ... or top-level <semicolon-token> tokens\n case Semicolon:\n if (balanceCloseType === 0) {\n break scan;\n }\n\n break;\n\n // ... or <delim-token> tokens with a value of \"!\"\n case Delim:\n if (balanceCloseType === 0 && token.value === '!') {\n break scan;\n }\n\n break;\n\n case FunctionToken:\n case LeftParenthesis:\n case LeftSquareBracket:\n case LeftCurlyBracket:\n balanceStash.push(balanceCloseType);\n balanceCloseType = balancePair.get(token.type);\n break;\n }\n\n length++;\n } while (token = getNextToken(length));\n\n return length;\n}\n\n// https://drafts.csswg.org/css-syntax/#any-value\n// The <any-value> production is identical to <declaration-value>, but also\n// allows top-level <semicolon-token> tokens and <delim-token> tokens\n// with a value of \"!\". It represents the entirety of what valid CSS can be in any context.\nfunction anyValue(token, getNextToken) {\n if (!token) {\n return 0;\n }\n\n let balanceCloseType = 0;\n let balanceStash = [];\n let length = 0;\n\n // The <any-value> production matches any sequence of one or more tokens,\n // so long as the sequence ...\n scan:\n do {\n switch (token.type) {\n // ... does not contain <bad-string-token>, <bad-url-token>,\n case BadString:\n case BadUrl:\n break scan;\n\n // ... unmatched <)-token>, <]-token>, or <}-token>,\n case RightCurlyBracket:\n case RightParenthesis:\n case RightSquareBracket:\n if (token.type !== balanceCloseType) {\n break scan;\n }\n\n balanceCloseType = balanceStash.pop();\n break;\n\n case FunctionToken:\n case LeftParenthesis:\n case LeftSquareBracket:\n case LeftCurlyBracket:\n balanceStash.push(balanceCloseType);\n balanceCloseType = balancePair.get(token.type);\n break;\n }\n\n length++;\n } while (token = getNextToken(length));\n\n return length;\n}\n\n// =========================\n// Dimensions\n//\n\nfunction dimension(type) {\n if (type) {\n type = new Set(type);\n }\n\n return function(token, getNextToken, opts) {\n if (token === null || token.type !== Dimension) {\n return 0;\n }\n\n const numberEnd = consumeNumber(token.value, 0);\n\n // check unit\n if (type !== null) {\n // check for IE postfix hack, i.e. 123px\\0 or 123px\\9\n const reverseSolidusOffset = token.value.indexOf('\\\\', numberEnd);\n const unit = reverseSolidusOffset === -1 || !isPostfixIeHack(token.value, reverseSolidusOffset)\n ? token.value.substr(numberEnd)\n : token.value.substring(numberEnd, reverseSolidusOffset);\n\n if (type.has(unit.toLowerCase()) === false) {\n return 0;\n }\n }\n\n // check range if specified\n if (outOfRange(opts, token.value, numberEnd)) {\n return 0;\n }\n\n return 1;\n };\n}\n\n// =========================\n// Percentage\n//\n\n// §5.5. Percentages: the <percentage> type\n// https://drafts.csswg.org/css-values-4/#percentages\nfunction percentage(token, getNextToken, opts) {\n // ... corresponds to the <percentage-token> production\n if (token === null || token.type !== Percentage) {\n return 0;\n }\n\n // check range if specified\n if (outOfRange(opts, token.value, token.value.length - 1)) {\n return 0;\n }\n\n return 1;\n}\n\n// =========================\n// Numeric\n//\n\n// https://drafts.csswg.org/css-values-4/#numbers\n// The value <zero> represents a literal number with the value 0. Expressions that merely\n// evaluate to a <number> with the value 0 (for example, calc(0)) do not match <zero>;\n// only literal <number-token>s do.\nfunction zero(next) {\n if (typeof next !== 'function') {\n next = function() {\n return 0;\n };\n }\n\n return function(token, getNextToken, opts) {\n if (token !== null && token.type === NumberToken) {\n if (Number(token.value) === 0) {\n return 1;\n }\n }\n\n return next(token, getNextToken, opts);\n };\n}\n\n// § 5.3. Real Numbers: the <number> type\n// https://drafts.csswg.org/css-values-4/#numbers\n// Number values are denoted by <number>, and represent real numbers, possibly with a fractional component.\n// ... It corresponds to the <number-token> production\nfunction number(token, getNextToken, opts) {\n if (token === null) {\n return 0;\n }\n\n const numberEnd = consumeNumber(token.value, 0);\n const isNumber = numberEnd === token.value.length;\n if (!isNumber && !isPostfixIeHack(token.value, numberEnd)) {\n return 0;\n }\n\n // check range if specified\n if (outOfRange(opts, token.value, numberEnd)) {\n return 0;\n }\n\n return 1;\n}\n\n// §5.2. Integers: the <integer> type\n// https://drafts.csswg.org/css-values-4/#integers\nfunction integer(token, getNextToken, opts) {\n // ... corresponds to a subset of the <number-token> production\n if (token === null || token.type !== NumberToken) {\n return 0;\n }\n\n // The first digit of an integer may be immediately preceded by `-` or `+` to indicate the integer’s sign.\n let i = charCodeAt(token.value, 0) === 0x002B || // U+002B PLUS SIGN (+)\n charCodeAt(token.value, 0) === 0x002D ? 1 : 0; // U+002D HYPHEN-MINUS (-)\n\n // When written literally, an integer is one or more decimal digits 0 through 9 ...\n for (; i < token.value.length; i++) {\n if (!isDigit(charCodeAt(token.value, i))) {\n return 0;\n }\n }\n\n // check range if specified\n if (outOfRange(opts, token.value, i)) {\n return 0;\n }\n\n return 1;\n}\n\n// token types\nexport const tokenTypes = {\n 'ident-token': tokenType(Ident),\n 'function-token': tokenType(FunctionToken),\n 'at-keyword-token': tokenType(AtKeyword),\n 'hash-token': tokenType(Hash),\n 'string-token': tokenType(StringToken),\n 'bad-string-token': tokenType(BadString),\n 'url-token': tokenType(Url),\n 'bad-url-token': tokenType(BadUrl),\n 'delim-token': tokenType(Delim),\n 'number-token': tokenType(NumberToken),\n 'percentage-token': tokenType(Percentage),\n 'dimension-token': tokenType(Dimension),\n 'whitespace-token': tokenType(WhiteSpace),\n 'CDO-token': tokenType(CDO),\n 'CDC-token': tokenType(CDC),\n 'colon-token': tokenType(Colon),\n 'semicolon-token': tokenType(Semicolon),\n 'comma-token': tokenType(Comma),\n '[-token': tokenType(LeftSquareBracket),\n ']-token': tokenType(RightSquareBracket),\n '(-token': tokenType(LeftParenthesis),\n ')-token': tokenType(RightParenthesis),\n '{-token': tokenType(LeftCurlyBracket),\n '}-token': tokenType(RightCurlyBracket)\n};\n\n// token production types\nexport const productionTypes = {\n // token type aliases\n 'string': tokenType(StringToken),\n 'ident': tokenType(Ident),\n\n // percentage\n 'percentage': math(percentage, percentageFunctionNames),\n\n // numeric\n 'zero': zero(),\n 'number': math(number, numberFunctionNames),\n 'integer': math(integer, numberFunctionNames),\n\n // complex types\n 'custom-ident': customIdent,\n 'dashed-ident': dashedIdent,\n 'custom-property-name': customPropertyName,\n 'hex-color': hexColor,\n 'id-selector': idSelector, // element( <id-selector> )\n 'an-plus-b': anPlusB,\n 'urange': urange,\n 'declaration-value': declarationValue,\n 'any-value': anyValue\n};\n\nexport const unitGroups = [\n 'length',\n 'angle',\n 'time',\n 'frequency',\n 'resolution',\n 'flex',\n 'decibel',\n 'semitones'\n];\n\n// dimensions types depend on units set\nexport function createDemensionTypes(units) {\n const {\n angle,\n decibel,\n frequency,\n flex,\n length,\n resolution,\n semitones,\n time\n } = units || {};\n\n return {\n 'dimension': math(dimension(null), dimensionFunctionNames),\n 'angle': math(dimension(angle), dimensionFunctionNames),\n 'decibel': math(dimension(decibel), dimensionFunctionNames),\n 'frequency': math(dimension(frequency), dimensionFunctionNames),\n 'flex': math(dimension(flex), dimensionFunctionNames),\n 'length': math(zero(dimension(length)), dimensionFunctionNames),\n 'resolution': math(dimension(resolution), dimensionFunctionNames),\n 'semitones': math(dimension(semitones), dimensionFunctionNames),\n 'time': math(dimension(time), dimensionFunctionNames)\n };\n}\n\n// The <attr-unit> production matches any identifier that is an ASCII case-insensitive\n// match for the name of a CSS dimension unit, such as px, or the <delim-token> %.\nfunction createAttrUnit(units) {\n const unitSet = new Set();\n\n for (const group of unitGroups) {\n if (Array.isArray(units[group])) {\n for (const unit of units[group]) {\n unitSet.add(unit.toLowerCase());\n }\n }\n }\n\n return function attrUnit(token) {\n if (token === null) {\n return 0;\n }\n\n if (token.type === Delim && token.value === '%') {\n return 1;\n }\n\n if (token.type === Ident && unitSet.has(token.value.toLowerCase())) {\n return 1;\n }\n\n return 0;\n };\n}\n\nexport function createGenericTypes(units) {\n return {\n ...tokenTypes,\n ...productionTypes,\n ...createDemensionTypes(units),\n 'attr-unit': createAttrUnit(units)\n };\n};\n","export const length = [\n // absolute length units https://www.w3.org/TR/css-values-3/#lengths\n 'cm', 'mm', 'q', 'in', 'pt', 'pc', 'px',\n // font-relative length units https://drafts.csswg.org/css-values-4/#font-relative-lengths\n 'em', 'rem',\n 'ex', 'rex',\n 'cap', 'rcap',\n 'ch', 'rch',\n 'ic', 'ric',\n 'lh', 'rlh',\n // viewport-percentage lengths https://drafts.csswg.org/css-values-4/#viewport-relative-lengths\n 'vw', 'svw', 'lvw', 'dvw',\n 'vh', 'svh', 'lvh', 'dvh',\n 'vi', 'svi', 'lvi', 'dvi',\n 'vb', 'svb', 'lvb', 'dvb',\n 'vmin', 'svmin', 'lvmin', 'dvmin',\n 'vmax', 'svmax', 'lvmax', 'dvmax',\n // container relative lengths https://drafts.csswg.org/css-contain-3/#container-lengths\n 'cqw', 'cqh', 'cqi', 'cqb', 'cqmin', 'cqmax'\n];\nexport const angle = ['deg', 'grad', 'rad', 'turn']; // https://www.w3.org/TR/css-values-3/#angles\nexport const time = ['s', 'ms']; // https://www.w3.org/TR/css-values-3/#time\nexport const frequency = ['hz', 'khz']; // https://www.w3.org/TR/css-values-3/#frequency\nexport const resolution = ['dpi', 'dpcm', 'dppx', 'x']; // https://www.w3.org/TR/css-values-3/#resolution\nexport const flex = ['fr']; // https://drafts.csswg.org/css-grid/#fr-unit\nexport const decibel = ['db']; // https://www.w3.org/TR/css3-speech/#mixing-props-voice-volume\nexport const semitones = ['st']; // https://www.w3.org/TR/css3-speech/#voice-props-voice-pitch\n","import { createCustomError } from '../utils/create-custom-error.js';\n\nexport function SyntaxError(message, input, offset) {\n return Object.assign(createCustomError('SyntaxError', message), {\n input,\n offset,\n rawMessage: message,\n message: message + '\\n' +\n ' ' + input + '\\n' +\n '--' + new Array((offset || input.length) + 1).join('-') + '^'\n });\n};\n","import { SyntaxError } from './SyntaxError.js';\n\nconst TAB = 9;\nconst N = 10;\nconst F = 12;\nconst R = 13;\nconst SPACE = 32;\nconst NAME_CHAR = new Uint8Array(128).map((_, idx) =>\n /[a-zA-Z0-9\\-]/.test(String.fromCharCode(idx)) ? 1 : 0\n);\n\nexport class Scanner {\n constructor(str) {\n this.str = str;\n this.pos = 0;\n }\n\n charCodeAt(pos) {\n return pos < this.str.length ? this.str.charCodeAt(pos) : 0;\n }\n charCode() {\n return this.charCodeAt(this.pos);\n }\n isNameCharCode(code = this.charCode()) {\n return code < 128 && NAME_CHAR[code] === 1;\n }\n nextCharCode() {\n return this.charCodeAt(this.pos + 1);\n }\n nextNonWsCode(pos) {\n return this.charCodeAt(this.findWsEnd(pos));\n }\n skipWs() {\n this.pos = this.findWsEnd(this.pos);\n }\n findWsEnd(pos) {\n for (; pos < this.str.length; pos++) {\n const code = this.str.charCodeAt(pos);\n if (code !== R && code !== N && code !== F && code !== SPACE && code !== TAB) {\n break;\n }\n }\n\n return pos;\n }\n substringToPos(end) {\n return this.str.substring(this.pos, this.pos = end);\n }\n eat(code) {\n if (this.charCode() !== code) {\n this.error('Expect `' + String.fromCharCode(code) + '`');\n }\n\n this.pos++;\n }\n peek() {\n return this.pos < this.str.length ? this.str.charAt(this.pos++) : '';\n }\n error(message) {\n throw new SyntaxError(message, this.str, this.pos);\n }\n\n scanSpaces() {\n return this.substringToPos(this.findWsEnd(this.pos));\n }\n scanWord() {\n let end = this.pos;\n\n for (; end < this.str.length; end++) {\n const code = this.str.charCodeAt(end);\n if (code >= 128 || NAME_CHAR[code] === 0) {\n break;\n }\n }\n\n if (this.pos === end) {\n this.error('Expect a keyword');\n }\n\n return this.substringToPos(end);\n }\n scanNumber() {\n let end = this.pos;\n\n for (; end < this.str.length; end++) {\n const code = this.str.charCodeAt(end);\n\n if (code < 48 || code > 57) {\n break;\n }\n }\n\n if (this.pos === end) {\n this.error('Expect a number');\n }\n\n return this.substringToPos(end);\n }\n scanString() {\n const end = this.str.indexOf('\\'', this.pos + 1);\n\n if (end === -1) {\n this.pos = this.str.length;\n this.error('Expect an apostrophe');\n }\n\n return this.substringToPos(end + 1);\n }\n};\n","import { Scanner } from './scanner.js';\n\nconst TAB = 9;\nconst N = 10;\nconst F = 12;\nconst R = 13;\nconst SPACE = 32;\nconst EXCLAMATIONMARK = 33; // !\nconst NUMBERSIGN = 35; // #\nconst AMPERSAND = 38; // &\nconst APOSTROPHE = 39; // '\nconst LEFTPARENTHESIS = 40; // (\nconst RIGHTPARENTHESIS = 41; // )\nconst ASTERISK = 42; // *\nconst PLUSSIGN = 43; // +\nconst COMMA = 44; // ,\nconst HYPERMINUS = 45; // -\nconst LESSTHANSIGN = 60; // <\nconst GREATERTHANSIGN = 62; // >\nconst QUESTIONMARK = 63; // ?\nconst COMMERCIALAT = 64; // @\nconst LEFTSQUAREBRACKET = 91; // [\nconst RIGHTSQUAREBRACKET = 93; // ]\nconst LEFTCURLYBRACKET = 123; // {\nconst VERTICALLINE = 124; // |\nconst RIGHTCURLYBRACKET = 125; // }\nconst INFINITY = 8734; // ∞\nconst COMBINATOR_PRECEDENCE = {\n ' ': 1,\n '&&': 2,\n '||': 3,\n '|': 4\n};\n\nfunction readMultiplierRange(scanner) {\n let min = null;\n let max = null;\n\n scanner.eat(LEFTCURLYBRACKET);\n scanner.skipWs();\n\n min = scanner.scanNumber(scanner);\n scanner.skipWs();\n\n if (scanner.charCode() === COMMA) {\n scanner.pos++;\n scanner.skipWs();\n\n if (scanner.charCode() !== RIGHTCURLYBRACKET) {\n max = scanner.scanNumber(scanner);\n scanner.skipWs();\n }\n } else {\n max = min;\n }\n\n scanner.eat(RIGHTCURLYBRACKET);\n\n return {\n min: Number(min),\n max: max ? Number(max) : 0\n };\n}\n\nfunction readMultiplier(scanner) {\n let range = null;\n let comma = false;\n\n switch (scanner.charCode()) {\n case ASTERISK:\n scanner.pos++;\n\n range = {\n min: 0,\n max: 0\n };\n\n break;\n\n case PLUSSIGN:\n scanner.pos++;\n\n range = {\n min: 1,\n max: 0\n };\n\n break;\n\n case QUESTIONMARK:\n scanner.pos++;\n\n range = {\n min: 0,\n max: 1\n };\n\n break;\n\n case NUMBERSIGN:\n scanner.pos++;\n\n comma = true;\n\n if (scanner.charCode() === LEFTCURLYBRACKET) {\n range = readMultiplierRange(scanner);\n } else if (scanner.charCode() === QUESTIONMARK) {\n // https://www.w3.org/TR/css-values-4/#component-multipliers\n // > the # and ? multipliers may be stacked as #?\n // In this case just treat \"#?\" as a single multiplier\n // { min: 0, max: 0, comma: true }\n scanner.pos++;\n range = {\n min: 0,\n max: 0\n };\n } else {\n range = {\n min: 1,\n max: 0\n };\n }\n\n break;\n\n case LEFTCURLYBRACKET:\n range = readMultiplierRange(scanner);\n break;\n\n default:\n return null;\n }\n\n return {\n type: 'Multiplier',\n comma,\n min: range.min,\n max: range.max,\n term: null\n };\n}\n\nfunction maybeMultiplied(scanner, node) {\n const multiplier = readMultiplier(scanner);\n\n if (multiplier !== null) {\n multiplier.term = node;\n\n // https://www.w3.org/TR/css-values-4/#component-multipliers\n // > The + and # multipliers may be stacked as +#;\n // Represent \"+#\" as nested multipliers:\n // { ...<multiplier #>,\n // term: {\n // ...<multipler +>,\n // term: node\n // }\n // }\n if (scanner.charCode() === NUMBERSIGN &&\n scanner.charCodeAt(scanner.pos - 1) === PLUSSIGN) {\n return maybeMultiplied(scanner, multiplier);\n }\n\n // https://www.w3.org/TR/css-values-4/#component-multipliers\n // > the # and ? multipliers, {A} and ? multipliers, and {A,B} and ? multipliers\n // > may be stacked as #?, {A}?, and {A,B}?, respectively\n // Represent \"{}?\" as nested multipliers as well as \"+#\".\n // The \"#?\" case is already handled above, in maybeMultiplied()\n if (scanner.charCode() === QUESTIONMARK &&\n scanner.charCodeAt(scanner.pos - 1) === RIGHTCURLYBRACKET) {\n return maybeMultiplied(scanner, multiplier);\n }\n\n return multiplier;\n }\n\n return node;\n}\n\nfunction maybeToken(scanner) {\n const ch = scanner.peek();\n\n if (ch === '') {\n return null;\n }\n\n return maybeMultiplied(scanner, {\n type: 'Token',\n value: ch\n });\n}\n\nfunction readProperty(scanner) {\n let name;\n\n scanner.eat(LESSTHANSIGN);\n scanner.eat(APOSTROPHE);\n\n name = scanner.scanWord();\n\n scanner.eat(APOSTROPHE);\n scanner.eat(GREATERTHANSIGN);\n\n return maybeMultiplied(scanner, {\n type: 'Property',\n name\n });\n}\n\n// https://drafts.csswg.org/css-values-3/#numeric-ranges\n// 4.1. Range Restrictions and Range Definition Notation\n//\n// Range restrictions can be annotated in the numeric type notation using CSS bracketed\n// range notation—[min,max]—within the angle brackets, after the identifying keyword,\n// indicating a closed range between (and including) min and max.\n// For example, <integer [0, 10]> indicates an integer between 0 and 10, inclusive.\nfunction readTypeRange(scanner) {\n // use null for Infinity to make AST format JSON serializable/deserializable\n let min = null; // -Infinity\n let max = null; // Infinity\n let sign = 1;\n\n scanner.eat(LEFTSQUAREBRACKET);\n\n if (scanner.charCode() === HYPERMINUS) {\n scanner.peek();\n sign = -1;\n }\n\n if (sign == -1 && scanner.charCode() === INFINITY) {\n scanner.peek();\n } else {\n min = sign * Number(scanner.scanNumber(scanner));\n\n if (scanner.isNameCharCode()) {\n min += scanner.scanWord();\n }\n }\n\n scanner.skipWs();\n scanner.eat(COMMA);\n scanner.skipWs();\n\n if (scanner.charCode() === INFINITY) {\n scanner.peek();\n } else {\n sign = 1;\n\n if (scanner.charCode() === HYPERMINUS) {\n scanner.peek();\n sign = -1;\n }\n\n max = sign * Number(scanner.scanNumber(scanner));\n\n if (scanner.isNameCharCode()) {\n max += scanner.scanWord();\n }\n }\n\n scanner.eat(RIGHTSQUAREBRACKET);\n\n return {\n type: 'Range',\n min,\n max\n };\n}\n\nfunction readType(scanner) {\n let name;\n let opts = null;\n\n scanner.eat(LESSTHANSIGN);\n name = scanner.scanWord();\n\n // https://drafts.csswg.org/css-values-5/#boolean\n if (name === 'boolean-expr') {\n scanner.eat(LEFTSQUAREBRACKET);\n\n const implicitGroup = readImplicitGroup(scanner, RIGHTSQUAREBRACKET);\n\n scanner.eat(RIGHTSQUAREBRACKET);\n scanner.eat(GREATERTHANSIGN);\n\n return maybeMultiplied(scanner, {\n type: 'Boolean',\n term: implicitGroup.terms.length === 1\n ? implicitGroup.terms[0]\n : implicitGroup\n });\n }\n\n if (scanner.charCode() === LEFTPARENTHESIS &&\n scanner.nextCharCode() === RIGHTPARENTHESIS) {\n scanner.pos += 2;\n name += '()';\n }\n\n if (scanner.charCodeAt(scanner.findWsEnd(scanner.pos)) === LEFTSQUAREBRACKET) {\n scanner.skipWs();\n opts = readTypeRange(scanner);\n }\n\n scanner.eat(GREATERTHANSIGN);\n\n return maybeMultiplied(scanner, {\n type: 'Type',\n name,\n opts\n });\n}\n\nfunction readKeywordOrFunction(scanner) {\n const name = scanner.scanWord();\n\n if (scanner.charCode() === LEFTPARENTHESIS) {\n scanner.pos++;\n\n return {\n type: 'Function',\n name\n };\n }\n\n return maybeMultiplied(scanner, {\n type: 'Keyword',\n name\n });\n}\n\nfunction regroupTerms(terms, combinators) {\n function createGroup(terms, combinator) {\n return {\n type: 'Group',\n terms,\n combinator,\n disallowEmpty: false,\n explicit: false\n };\n }\n\n let combinator;\n\n combinators = Object.keys(combinators)\n .sort((a, b) => COMBINATOR_PRECEDENCE[a] - COMBINATOR_PRECEDENCE[b]);\n\n while (combinators.length > 0) {\n combinator = combinators.shift();\n\n let i = 0;\n let subgroupStart = 0;\n\n for (; i < terms.length; i++) {\n const term = terms[i];\n\n if (term.type === 'Combinator') {\n if (term.value === combinator) {\n if (subgroupStart === -1) {\n subgroupStart = i - 1;\n }\n terms.splice(i, 1);\n i--;\n } else {\n if (subgroupStart !== -1 && i - subgroupStart > 1) {\n terms.splice(\n subgroupStart,\n i - subgroupStart,\n createGroup(terms.slice(subgroupStart, i), combinator)\n );\n i = subgroupStart + 1;\n }\n subgroupStart = -1;\n }\n }\n }\n\n if (subgroupStart !== -1 && combinators.length) {\n terms.splice(\n subgroupStart,\n i - subgroupStart,\n createGroup(terms.slice(subgroupStart, i), combinator)\n );\n }\n }\n\n return combinator;\n}\n\nfunction readImplicitGroup(scanner, stopCharCode = -1) {\n const combinators = Object.create(null);\n const terms = [];\n let prevToken = null;\n let prevTokenPos = scanner.pos;\n let prevTokenIsFunction = false;\n\n while (scanner.charCode() !== stopCharCode) {\n let token = prevTokenIsFunction\n ? readImplicitGroup(scanner, RIGHTPARENTHESIS)\n : peek(scanner);\n\n if (!token) {\n break;\n }\n\n if (token.type === 'Spaces') {\n continue;\n }\n\n if (prevTokenIsFunction) {\n if (token.terms.length === 0) {\n prevTokenIsFunction = false;\n continue;\n }\n\n if (token.combinator === ' ') {\n while (token.terms.length > 1) {\n combinators[' '] = true; // a b\n terms.push({\n type: 'Combinator',\n value: ' '\n }, token.terms.shift());\n }\n\n token = token.terms[0];\n }\n }\n\n if (token.type === 'Combinator') {\n // check for combinator in group beginning and double combinator sequence\n if (prevToken === null || prevToken.type === 'Combinator') {\n scanner.pos = prevTokenPos;\n scanner.error('Unexpected combinator');\n }\n\n combinators[token.value] = true;\n } else if (prevToken !== null && prevToken.type !== 'Combinator') {\n combinators[' '] = true; // a b\n terms.push({\n type: 'Combinator',\n value: ' '\n });\n }\n\n terms.push(token);\n prevToken = token;\n prevTokenPos = scanner.pos;\n prevTokenIsFunction = token.type === 'Function';\n }\n\n // check for combinator in group ending\n if (prevToken !== null && prevToken.type === 'Combinator') {\n scanner.pos -= prevTokenPos;\n scanner.error('Unexpected combinator');\n }\n\n return {\n type: 'Group',\n terms,\n combinator: regroupTerms(terms, combinators) || ' ',\n disallowEmpty: false,\n explicit: false\n };\n}\n\nfunction readGroup(scanner) {\n let result;\n\n scanner.eat(LEFTSQUAREBRACKET);\n result = readImplicitGroup(scanner, RIGHTSQUAREBRACKET);\n scanner.eat(RIGHTSQUAREBRACKET);\n\n result.explicit = true;\n\n if (scanner.charCode() === EXCLAMATIONMARK) {\n scanner.pos++;\n result.disallowEmpty = true;\n }\n\n return result;\n}\n\nfunction peek(scanner) {\n let code = scanner.charCode();\n\n switch (code) {\n case RIGHTSQUAREBRACKET:\n // don't eat, stop scan a group\n break;\n\n case LEFTSQUAREBRACKET:\n return maybeMultiplied(scanner, readGroup(scanner));\n\n case LESSTHANSIGN:\n return scanner.nextCharCode() === APOSTROPHE\n ? readProperty(scanner)\n : readType(scanner);\n\n case VERTICALLINE:\n return {\n type: 'Combinator',\n value: scanner.substringToPos(\n scanner.pos + (scanner.nextCharCode() === VERTICALLINE ? 2 : 1)\n )\n };\n\n case AMPERSAND:\n scanner.pos++;\n scanner.eat(AMPERSAND);\n\n return {\n type: 'Combinator',\n value: '&&'\n };\n\n case COMMA:\n scanner.pos++;\n return {\n type: 'Comma'\n };\n\n case APOSTROPHE:\n return maybeMultiplied(scanner, {\n type: 'String',\n value: scanner.scanString()\n });\n\n case SPACE:\n case TAB:\n case N:\n case R:\n case F:\n return {\n type: 'Spaces',\n value: scanner.scanSpaces()\n };\n\n case COMMERCIALAT:\n code = scanner.nextCharCode();\n\n if (scanner.isNameCharCode(code)) {\n scanner.pos++;\n return {\n type: 'AtKeyword',\n name: scanner.scanWord()\n };\n }\n\n return maybeToken(scanner);\n\n case ASTERISK:\n case PLUSSIGN:\n case QUESTIONMARK:\n case NUMBERSIGN:\n case EXCLAMATIONMARK:\n // prohibited tokens (used as a multiplier start)\n break;\n\n case LEFTCURLYBRACKET:\n // LEFTCURLYBRACKET is allowed since mdn/data uses it w/o quoting\n // check next char isn't a number, because it's likely a disjoined multiplier\n code = scanner.nextCharCode();\n\n if (code < 48 || code > 57) {\n return maybeToken(scanner);\n }\n\n break;\n\n default:\n if (scanner.isNameCharCode(code)) {\n return readKeywordOrFunction(scanner);\n }\n\n return maybeToken(scanner);\n }\n}\n\nexport function parse(source) {\n const scanner = new Scanner(source);\n const result = readImplicitGroup(scanner);\n\n if (scanner.pos !== source.length) {\n scanner.error('Unexpected input');\n }\n\n // reduce redundant groups with single group term\n if (result.terms.length === 1 && result.terms[0].type === 'Group') {\n return result.terms[0];\n }\n\n return result;\n};\n","const noop = function() {};\n\nfunction ensureFunction(value) {\n return typeof value === 'function' ? value : noop;\n}\n\nexport function walk(node, options, context) {\n function walk(node) {\n enter.call(context, node);\n\n switch (node.type) {\n case 'Group':\n node.terms.forEach(walk);\n break;\n\n case 'Multiplier':\n case 'Boolean':\n walk(node.term);\n break;\n\n case 'Type':\n case 'Property':\n case 'Keyword':\n case 'AtKeyword':\n case 'Function':\n case 'String':\n case 'Token':\n case 'Comma':\n break;\n\n default:\n throw new Error('Unknown type: ' + node.type);\n }\n\n leave.call(context, node);\n }\n\n let enter = noop;\n let leave = noop;\n\n if (typeof options === 'function') {\n enter = options;\n } else if (options) {\n enter = ensureFunction(options.enter);\n leave = ensureFunction(options.leave);\n }\n\n if (enter === noop && leave === noop) {\n throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\\'t a function');\n }\n\n walk(node, context);\n};\n","import { tokenize } from '../tokenizer/index.js';\n\nconst astToTokens = {\n decorator(handlers) {\n const tokens = [];\n let curNode = null;\n\n return {\n ...handlers,\n node(node) {\n const tmp = curNode;\n curNode = node;\n handlers.node.call(this, node);\n curNode = tmp;\n },\n emit(value, type, auto) {\n tokens.push({\n type,\n value,\n node: auto ? null : curNode\n });\n },\n result() {\n return tokens;\n }\n };\n }\n};\n\nfunction stringToTokens(str) {\n const tokens = [];\n\n tokenize(str, (type, start, end) =>\n tokens.push({\n type,\n value: str.slice(start, end),\n node: null\n })\n );\n\n return tokens;\n}\n\nexport default function(value, syntax) {\n if (typeof value === 'string') {\n return stringToTokens(value);\n }\n\n return syntax.generate(value, astToTokens);\n};\n","import { parse } from '../definition-syntax/parse.js';\n\nexport const MATCH = { type: 'Match' };\nexport const MISMATCH = { type: 'Mismatch' };\nexport const DISALLOW_EMPTY = { type: 'DisallowEmpty' };\n\nconst LEFTPARENTHESIS = 40; // (\nconst RIGHTPARENTHESIS = 41; // )\n\nfunction createCondition(match, thenBranch, elseBranch) {\n // reduce node count\n if (thenBranch === MATCH && elseBranch === MISMATCH) {\n return match;\n }\n\n if (match === MATCH && thenBranch === MATCH && elseBranch === MATCH) {\n return match;\n }\n\n if (match.type === 'If' && match.else === MISMATCH && thenBranch === MATCH) {\n thenBranch = match.then;\n match = match.match;\n }\n\n return {\n type: 'If',\n match,\n then: thenBranch,\n else: elseBranch\n };\n}\n\nfunction isFunctionType(name) {\n return (\n name.length > 2 &&\n name.charCodeAt(name.length - 2) === LEFTPARENTHESIS &&\n name.charCodeAt(name.length - 1) === RIGHTPARENTHESIS\n );\n}\n\nfunction isEnumCapatible(term) {\n return (\n term.type === 'Keyword' ||\n term.type === 'AtKeyword' ||\n term.type === 'Function' ||\n term.type === 'Type' && isFunctionType(term.name)\n );\n}\n\nfunction groupNode(terms, combinator = ' ', explicit = false) {\n return {\n type: 'Group',\n terms,\n combinator,\n disallowEmpty: false,\n explicit\n };\n}\n\nfunction replaceTypeInGraph(node, replacements, visited = new Set()) {\n if (!visited.has(node)) {\n visited.add(node);\n\n switch (node.type) {\n case 'If':\n node.match = replaceTypeInGraph(node.match, replacements, visited);\n node.then = replaceTypeInGraph(node.then, replacements, visited);\n node.else = replaceTypeInGraph(node.else, replacements, visited);\n break;\n\n case 'Type':\n return replacements[node.name] || node;\n }\n }\n\n return node;\n}\n\nfunction buildGroupMatchGraph(combinator, terms, atLeastOneTermMatched) {\n switch (combinator) {\n case ' ': {\n // Juxtaposing components means that all of them must occur, in the given order.\n //\n // a b c\n // =\n // match a\n // then match b\n // then match c\n // then MATCH\n // else MISMATCH\n // else MISMATCH\n // else MISMATCH\n let result = MATCH;\n\n for (let i = terms.length - 1; i >= 0; i--) {\n const term = terms[i];\n\n result = createCondition(\n term,\n result,\n MISMATCH\n );\n };\n\n return result;\n }\n\n case '|': {\n // A bar (|) separates two or more alternatives: exactly one of them must occur.\n //\n // a | b | c\n // =\n // match a\n // then MATCH\n // else match b\n // then MATCH\n // else match c\n // then MATCH\n // else MISMATCH\n\n let result = MISMATCH;\n let map = null;\n\n for (let i = terms.length - 1; i >= 0; i--) {\n let term = terms[i];\n\n // reduce sequence of keywords into a Enum\n if (isEnumCapatible(term)) {\n if (map === null && i > 0 && isEnumCapatible(terms[i - 1])) {\n map = Object.create(null);\n result = createCondition(\n {\n type: 'Enum',\n map\n },\n MATCH,\n result\n );\n }\n\n if (map !== null) {\n const key = (isFunctionType(term.name) ? term.name.slice(0, -1) : term.name).toLowerCase();\n if (key in map === false) {\n map[key] = term;\n continue;\n }\n }\n }\n\n map = null;\n\n // create a new conditonal node\n result = createCondition(\n term,\n MATCH,\n result\n );\n };\n\n return result;\n }\n\n case '&&': {\n // A double ampersand (&&) separates two or more components,\n // all of which must occur, in any order.\n\n // Use MatchOnce for groups with a large number of terms,\n // since &&-groups produces at least N!-node trees\n if (terms.length > 5) {\n return {\n type: 'MatchOnce',\n terms,\n all: true\n };\n }\n\n // Use a combination tree for groups with small number of terms\n //\n // a && b && c\n // =\n // match a\n // then [b && c]\n // else match b\n // then [a && c]\n // else match c\n // then [a && b]\n // else MISMATCH\n //\n // a && b\n // =\n // match a\n // then match b\n // then MATCH\n // else MISMATCH\n // else match b\n // then match a\n // then MATCH\n // else MISMATCH\n // else MISMATCH\n let result = MISMATCH;\n\n for (let i = terms.length - 1; i >= 0; i--) {\n const term = terms[i];\n let thenClause;\n\n if (terms.length > 1) {\n thenClause = buildGroupMatchGraph(\n combinator,\n terms.filter(function(newGroupTerm) {\n return newGroupTerm !== term;\n }),\n false\n );\n } else {\n thenClause = MATCH;\n }\n\n result = createCondition(\n term,\n thenClause,\n result\n );\n };\n\n return result;\n }\n\n case '||': {\n // A double bar (||) separates two or more options:\n // one or more of them must occur, in any order.\n\n // Use MatchOnce for groups with a large number of terms,\n // since ||-groups produces at least N!-node trees\n if (terms.length > 5) {\n return {\n type: 'MatchOnce',\n terms,\n all: false\n };\n }\n\n // Use a combination tree for groups with small number of terms\n //\n // a || b || c\n // =\n // match a\n // then [b || c]\n // else match b\n // then [a || c]\n // else match c\n // then [a || b]\n // else MISMATCH\n //\n // a || b\n // =\n // match a\n // then match b\n // then MATCH\n // else MATCH\n // else match b\n // then match a\n // then MATCH\n // else MATCH\n // else MISMATCH\n let result = atLeastOneTermMatched ? MATCH : MISMATCH;\n\n for (let i = terms.length - 1; i >= 0; i--) {\n const term = terms[i];\n let thenClause;\n\n if (terms.length > 1) {\n thenClause = buildGroupMatchGraph(\n combinator,\n terms.filter(function(newGroupTerm) {\n return newGroupTerm !== term;\n }),\n true\n );\n } else {\n thenClause = MATCH;\n }\n\n result = createCondition(\n term,\n thenClause,\n result\n );\n };\n\n return result;\n }\n }\n}\n\nfunction buildMultiplierMatchGraph(node) {\n let result = MATCH;\n let matchTerm = buildMatchGraphInternal(node.term);\n\n if (node.max === 0) {\n // disable repeating of empty match to prevent infinite loop\n matchTerm = createCondition(\n matchTerm,\n DISALLOW_EMPTY,\n MISMATCH\n );\n\n // an occurrence count is not limited, make a cycle;\n // to collect more terms on each following matching mismatch\n result = createCondition(\n matchTerm,\n null, // will be a loop\n MISMATCH\n );\n\n result.then = createCondition(\n MATCH,\n MATCH,\n result // make a loop\n );\n\n if (node.comma) {\n result.then.else = createCondition(\n { type: 'Comma', syntax: node },\n result,\n MISMATCH\n );\n }\n } else {\n // create a match node chain for [min .. max] interval with optional matches\n for (let i = node.min || 1; i <= node.max; i++) {\n if (node.comma && result !== MATCH) {\n result = createCondition(\n { type: 'Comma', syntax: node },\n result,\n MISMATCH\n );\n }\n\n result = createCondition(\n matchTerm,\n createCondition(\n MATCH,\n MATCH,\n result\n ),\n MISMATCH\n );\n }\n }\n\n if (node.min === 0) {\n // allow zero match\n result = createCondition(\n MATCH,\n MATCH,\n result\n );\n } else {\n // create a match node chain to collect [0 ... min - 1] required matches\n for (let i = 0; i < node.min - 1; i++) {\n if (node.comma && result !== MATCH) {\n result = createCondition(\n { type: 'Comma', syntax: node },\n result,\n MISMATCH\n );\n }\n\n result = createCondition(\n matchTerm,\n result,\n MISMATCH\n );\n }\n }\n\n return result;\n}\n\nfunction buildMatchGraphInternal(node) {\n if (typeof node === 'function') {\n return {\n type: 'Generic',\n fn: node\n };\n }\n\n switch (node.type) {\n case 'Group': {\n let result = buildGroupMatchGraph(\n node.combinator,\n node.terms.map(buildMatchGraphInternal),\n false\n );\n\n if (node.disallowEmpty) {\n result = createCondition(\n result,\n DISALLOW_EMPTY,\n MISMATCH\n );\n }\n\n return result;\n }\n\n case 'Multiplier':\n return buildMultiplierMatchGraph(node);\n\n // https://drafts.csswg.org/css-values-5/#boolean\n case 'Boolean': {\n const term = buildMatchGraphInternal(node.term);\n // <boolean-expr[ <test> ]> = not <boolean-expr-group> | <boolean-expr-group> [ [ and <boolean-expr-group> ]* | [ or <boolean-expr-group> ]* ]\n const matchNode = buildMatchGraphInternal(groupNode([\n groupNode([\n { type: 'Keyword', name: 'not' },\n { type: 'Type', name: '!boolean-group' }\n ]),\n groupNode([\n { type: 'Type', name: '!boolean-group' },\n groupNode([\n { type: 'Multiplier', comma: false, min: 0, max: 0, term: groupNode([\n { type: 'Keyword', name: 'and' },\n { type: 'Type', name: '!boolean-group' }\n ]) },\n { type: 'Multiplier', comma: false, min: 0, max: 0, term: groupNode([\n { type: 'Keyword', name: 'or' },\n { type: 'Type', name: '!boolean-group' }\n ]) }\n ], '|')\n ])\n ], '|'));\n // <boolean-expr-group> = <test> | ( <boolean-expr[ <test> ]> ) | <general-enclosed>\n const booleanGroup = buildMatchGraphInternal(\n groupNode([\n { type: 'Type', name: '!term' },\n groupNode([\n { type: 'Token', value: '(' },\n { type: 'Type', name: '!self' },\n { type: 'Token', value: ')' }\n ]),\n { type: 'Type', name: 'general-enclosed' }\n ], '|')\n );\n\n replaceTypeInGraph(booleanGroup, { '!term': term, '!self': matchNode });\n replaceTypeInGraph(matchNode, { '!boolean-group': booleanGroup });\n\n return matchNode;\n }\n\n case 'Type':\n case 'Property':\n return {\n type: node.type,\n name: node.name,\n syntax: node\n };\n\n case 'Keyword':\n return {\n type: node.type,\n name: node.name.toLowerCase(),\n syntax: node\n };\n\n case 'AtKeyword':\n return {\n type: node.type,\n name: '@' + node.name.toLowerCase(),\n syntax: node\n };\n\n case 'Function':\n return {\n type: node.type,\n name: node.name.toLowerCase() + '(',\n syntax: node\n };\n\n case 'String':\n // convert a one char length String to a Token\n if (node.value.length === 3) {\n return {\n type: 'Token',\n value: node.value.charAt(1),\n syntax: node\n };\n }\n\n // otherwise use it as is\n return {\n type: node.type,\n value: node.value.substr(1, node.value.length - 2).replace(/\\\\'/g, '\\''),\n syntax: node\n };\n\n case 'Token':\n return {\n type: node.type,\n value: node.value,\n syntax: node\n };\n\n case 'Comma':\n return {\n type: node.type,\n syntax: node\n };\n\n default:\n throw new Error('Unknown node type:', node.type);\n }\n}\n\nexport function buildMatchGraph(syntaxTree, ref) {\n if (typeof syntaxTree === 'string') {\n syntaxTree = parse(syntaxTree);\n }\n\n return {\n type: 'MatchGraph',\n match: buildMatchGraphInternal(syntaxTree),\n syntax: ref || null,\n source: syntaxTree\n };\n}\n","import { MATCH, MISMATCH, DISALLOW_EMPTY } from './match-graph.js';\nimport * as TYPE from '../tokenizer/types.js';\n\nconst { hasOwnProperty } = Object.prototype;\nconst STUB = 0;\nconst TOKEN = 1;\nconst OPEN_SYNTAX = 2;\nconst CLOSE_SYNTAX = 3;\n\nconst EXIT_REASON_MATCH = 'Match';\nconst EXIT_REASON_MISMATCH = 'Mismatch';\nconst EXIT_REASON_ITERATION_LIMIT = 'Maximum iteration number exceeded (please fill an issue on https://github.com/csstree/csstree/issues)';\n\nconst ITERATION_LIMIT = 15000;\nexport let totalIterationCount = 0;\n\nfunction reverseList(list) {\n let prev = null;\n let next = null;\n let item = list;\n\n while (item !== null) {\n next = item.prev;\n item.prev = prev;\n prev = item;\n item = next;\n }\n\n return prev;\n}\n\nfunction areStringsEqualCaseInsensitive(testStr, referenceStr) {\n if (testStr.length !== referenceStr.length) {\n return false;\n }\n\n for (let i = 0; i < testStr.length; i++) {\n const referenceCode = referenceStr.charCodeAt(i);\n let testCode = testStr.charCodeAt(i);\n\n // testCode.toLowerCase() for U+0041 LATIN CAPITAL LETTER A (A) .. U+005A LATIN CAPITAL LETTER Z (Z).\n if (testCode >= 0x0041 && testCode <= 0x005A) {\n testCode = testCode | 32;\n }\n\n if (testCode !== referenceCode) {\n return false;\n }\n }\n\n return true;\n}\n\nfunction isContextEdgeDelim(token) {\n if (token.type !== TYPE.Delim) {\n return false;\n }\n\n // Fix matching for unicode-range: U+30??, U+FF00-FF9F\n // Probably we need to check out previous match instead\n return token.value !== '?';\n}\n\nfunction isCommaContextStart(token) {\n if (token === null) {\n return true;\n }\n\n return (\n token.type === TYPE.Comma ||\n token.type === TYPE.Function ||\n token.type === TYPE.LeftParenthesis ||\n token.type === TYPE.LeftSquareBracket ||\n token.type === TYPE.LeftCurlyBracket ||\n isContextEdgeDelim(token)\n );\n}\n\nfunction isCommaContextEnd(token) {\n if (token === null) {\n return true;\n }\n\n return (\n token.type === TYPE.RightParenthesis ||\n token.type === TYPE.RightSquareBracket ||\n token.type === TYPE.RightCurlyBracket ||\n (token.type === TYPE.Delim && token.value === '/')\n );\n}\n\nfunction internalMatch(tokens, state, syntaxes) {\n function moveToNextToken() {\n do {\n tokenIndex++;\n token = tokenIndex < tokens.length ? tokens[tokenIndex] : null;\n } while (token !== null && (token.type === TYPE.WhiteSpace || token.type === TYPE.Comment));\n }\n\n function getNextToken(offset) {\n const nextIndex = tokenIndex + offset;\n\n return nextIndex < tokens.length ? tokens[nextIndex] : null;\n }\n\n function stateSnapshotFromSyntax(nextState, prev) {\n return {\n nextState,\n matchStack,\n syntaxStack,\n thenStack,\n tokenIndex,\n prev\n };\n }\n\n function pushThenStack(nextState) {\n thenStack = {\n nextState,\n matchStack,\n syntaxStack,\n prev: thenStack\n };\n }\n\n function pushElseStack(nextState) {\n elseStack = stateSnapshotFromSyntax(nextState, elseStack);\n }\n\n function addTokenToMatch() {\n matchStack = {\n type: TOKEN,\n syntax: state.syntax,\n token,\n prev: matchStack\n };\n\n moveToNextToken();\n syntaxStash = null;\n\n if (tokenIndex > longestMatch) {\n longestMatch = tokenIndex;\n }\n }\n\n function openSyntax() {\n syntaxStack = {\n syntax: state.syntax,\n opts: state.syntax.opts || (syntaxStack !== null && syntaxStack.opts) || null,\n prev: syntaxStack\n };\n\n matchStack = {\n type: OPEN_SYNTAX,\n syntax: state.syntax,\n token: matchStack.token,\n prev: matchStack\n };\n }\n\n function closeSyntax() {\n if (matchStack.type === OPEN_SYNTAX) {\n matchStack = matchStack.prev;\n } else {\n matchStack = {\n type: CLOSE_SYNTAX,\n syntax: syntaxStack.syntax,\n token: matchStack.token,\n prev: matchStack\n };\n }\n\n syntaxStack = syntaxStack.prev;\n }\n\n let syntaxStack = null;\n let thenStack = null;\n let elseStack = null;\n\n // null – stashing allowed, nothing stashed\n // false – stashing disabled, nothing stashed\n // anithing else – fail stashable syntaxes, some syntax stashed\n let syntaxStash = null;\n\n let iterationCount = 0; // count iterations and prevent infinite loop\n let exitReason = null;\n\n let token = null;\n let tokenIndex = -1;\n let longestMatch = 0;\n let matchStack = {\n type: STUB,\n syntax: null,\n token: null,\n prev: null\n };\n\n moveToNextToken();\n\n while (exitReason === null && ++iterationCount < ITERATION_LIMIT) {\n // function mapList(list, fn) {\n // const result = [];\n // while (list) {\n // result.unshift(fn(list));\n // list = list.prev;\n // }\n // return result;\n // }\n // console.log('--\\n',\n // '#' + iterationCount,\n // require('util').inspect({\n // match: mapList(matchStack, x => x.type === TOKEN ? x.token && x.token.value : x.syntax ? ({ [OPEN_SYNTAX]: '<', [CLOSE_SYNTAX]: '</' }[x.type] || x.type) + '!' + x.syntax.name : null),\n // token: token && token.value,\n // tokenIndex,\n // syntax: syntax.type + (syntax.id ? ' #' + syntax.id : '')\n // }, { depth: null })\n // );\n switch (state.type) {\n case 'Match':\n if (thenStack === null) {\n // turn to MISMATCH when some tokens left unmatched\n if (token !== null) {\n // doesn't mismatch if just one token left and it's an IE hack\n if (tokenIndex !== tokens.length - 1 || (token.value !== '\\\\0' && token.value !== '\\\\9')) {\n state = MISMATCH;\n break;\n }\n }\n\n // break the main loop, return a result - MATCH\n exitReason = EXIT_REASON_MATCH;\n break;\n }\n\n // go to next syntax (`then` branch)\n state = thenStack.nextState;\n\n // check match is not empty\n if (state === DISALLOW_EMPTY) {\n if (thenStack.matchStack === matchStack) {\n state = MISMATCH;\n break;\n } else {\n state = MATCH;\n }\n }\n\n // close syntax if needed\n while (thenStack.syntaxStack !== syntaxStack) {\n closeSyntax();\n }\n\n // pop stack\n thenStack = thenStack.prev;\n break;\n\n case 'Mismatch':\n // when some syntax is stashed\n if (syntaxStash !== null && syntaxStash !== false) {\n // there is no else branches or a branch reduce match stack\n if (elseStack === null || tokenIndex > elseStack.tokenIndex) {\n // restore state from the stash\n elseStack = syntaxStash;\n syntaxStash = false; // disable stashing\n }\n } else if (elseStack === null) {\n // no else branches -> break the main loop\n // return a result - MISMATCH\n exitReason = EXIT_REASON_MISMATCH;\n break;\n }\n\n // go to next syntax (`else` branch)\n state = elseStack.nextState;\n\n // restore all the rest stack states\n thenStack = elseStack.thenStack;\n syntaxStack = elseStack.syntaxStack;\n matchStack = elseStack.matchStack;\n tokenIndex = elseStack.tokenIndex;\n token = tokenIndex < tokens.length ? tokens[tokenIndex] : null;\n\n // pop stack\n elseStack = elseStack.prev;\n break;\n\n case 'MatchGraph':\n state = state.match;\n break;\n\n case 'If':\n // IMPORTANT: else stack push must go first,\n // since it stores the state of thenStack before changes\n if (state.else !== MISMATCH) {\n pushElseStack(state.else);\n }\n\n if (state.then !== MATCH) {\n pushThenStack(state.then);\n }\n\n state = state.match;\n break;\n\n case 'MatchOnce':\n state = {\n type: 'MatchOnceBuffer',\n syntax: state,\n index: 0,\n mask: 0\n };\n break;\n\n case 'MatchOnceBuffer': {\n const terms = state.syntax.terms;\n\n if (state.index === terms.length) {\n // no matches at all or it's required all terms to be matched\n if (state.mask === 0 || state.syntax.all) {\n state = MISMATCH;\n break;\n }\n\n // a partial match is ok\n state = MATCH;\n break;\n }\n\n // all terms are matched\n if (state.mask === (1 << terms.length) - 1) {\n state = MATCH;\n break;\n }\n\n for (; state.index < terms.length; state.index++) {\n const matchFlag = 1 << state.index;\n\n if ((state.mask & matchFlag) === 0) {\n // IMPORTANT: else stack push must go first,\n // since it stores the state of thenStack before changes\n pushElseStack(state);\n pushThenStack({\n type: 'AddMatchOnce',\n syntax: state.syntax,\n mask: state.mask | matchFlag\n });\n\n // match\n state = terms[state.index++];\n break;\n }\n }\n break;\n }\n\n case 'AddMatchOnce':\n state = {\n type: 'MatchOnceBuffer',\n syntax: state.syntax,\n index: 0,\n mask: state.mask\n };\n break;\n\n case 'Enum':\n if (token !== null) {\n let name = token.value.toLowerCase();\n\n // drop \\0 and \\9 hack from keyword name\n if (name.indexOf('\\\\') !== -1) {\n name = name.replace(/\\\\[09].*$/, '');\n }\n\n if (hasOwnProperty.call(state.map, name)) {\n state = state.map[name];\n break;\n }\n }\n\n state = MISMATCH;\n break;\n\n case 'Generic': {\n const opts = syntaxStack !== null ? syntaxStack.opts : null;\n const lastTokenIndex = tokenIndex + Math.floor(state.fn(token, getNextToken, opts));\n\n if (!isNaN(lastTokenIndex) && lastTokenIndex > tokenIndex) {\n while (tokenIndex < lastTokenIndex) {\n addTokenToMatch();\n }\n\n state = MATCH;\n } else {\n state = MISMATCH;\n }\n\n break;\n }\n\n case 'Type':\n case 'Property': {\n const syntaxDict = state.type === 'Type' ? 'types' : 'properties';\n const dictSyntax = hasOwnProperty.call(syntaxes, syntaxDict) ? syntaxes[syntaxDict][state.name] : null;\n\n if (!dictSyntax || !dictSyntax.match) {\n throw new Error(\n 'Bad syntax reference: ' +\n (state.type === 'Type'\n ? '<' + state.name + '>'\n : '<\\'' + state.name + '\\'>')\n );\n }\n\n // stash a syntax for types with low priority\n if (syntaxStash !== false && token !== null && state.type === 'Type') {\n const lowPriorityMatching =\n // https://drafts.csswg.org/css-values-4/#custom-idents\n // When parsing positionally-ambiguous keywords in a property value, a <custom-ident> production\n // can only claim the keyword if no other unfulfilled production can claim it.\n (state.name === 'custom-ident' && token.type === TYPE.Ident) ||\n\n // https://drafts.csswg.org/css-values-4/#lengths\n // ... if a `0` could be parsed as either a <number> or a <length> in a property (such as line-height),\n // it must parse as a <number>\n (state.name === 'length' && token.value === '0');\n\n if (lowPriorityMatching) {\n if (syntaxStash === null) {\n syntaxStash = stateSnapshotFromSyntax(state, elseStack);\n }\n\n state = MISMATCH;\n break;\n }\n }\n\n openSyntax();\n state = dictSyntax.matchRef || dictSyntax.match;\n break;\n }\n\n case 'Keyword': {\n const name = state.name;\n\n if (token !== null) {\n let keywordName = token.value;\n\n // drop \\0 and \\9 hack from keyword name\n if (keywordName.indexOf('\\\\') !== -1) {\n keywordName = keywordName.replace(/\\\\[09].*$/, '');\n }\n\n if (areStringsEqualCaseInsensitive(keywordName, name)) {\n addTokenToMatch();\n state = MATCH;\n break;\n }\n }\n\n state = MISMATCH;\n break;\n }\n\n case 'AtKeyword':\n case 'Function':\n if (token !== null && areStringsEqualCaseInsensitive(token.value, state.name)) {\n addTokenToMatch();\n state = MATCH;\n break;\n }\n\n state = MISMATCH;\n break;\n\n case 'Token':\n if (token !== null && token.value === state.value) {\n addTokenToMatch();\n state = MATCH;\n break;\n }\n\n state = MISMATCH;\n break;\n\n case 'Comma':\n if (token !== null && token.type === TYPE.Comma) {\n if (isCommaContextStart(matchStack.token)) {\n state = MISMATCH;\n } else {\n addTokenToMatch();\n state = isCommaContextEnd(token) ? MISMATCH : MATCH;\n }\n } else {\n state = isCommaContextStart(matchStack.token) || isCommaContextEnd(token) ? MATCH : MISMATCH;\n }\n\n break;\n\n case 'String':\n let string = '';\n let lastTokenIndex = tokenIndex;\n\n for (; lastTokenIndex < tokens.length && string.length < state.value.length; lastTokenIndex++) {\n string += tokens[lastTokenIndex].value;\n }\n\n if (areStringsEqualCaseInsensitive(string, state.value)) {\n while (tokenIndex < lastTokenIndex) {\n addTokenToMatch();\n }\n\n state = MATCH;\n } else {\n state = MISMATCH;\n }\n\n break;\n\n default:\n throw new Error('Unknown node type: ' + state.type);\n }\n }\n\n totalIterationCount += iterationCount;\n\n switch (exitReason) {\n case null:\n console.warn('[csstree-match] BREAK after ' + ITERATION_LIMIT + ' iterations');\n exitReason = EXIT_REASON_ITERATION_LIMIT;\n matchStack = null;\n break;\n\n case EXIT_REASON_MATCH:\n while (syntaxStack !== null) {\n closeSyntax();\n }\n break;\n\n default:\n matchStack = null;\n }\n\n return {\n tokens,\n reason: exitReason,\n iterations: iterationCount,\n match: matchStack,\n longestMatch\n };\n}\n\nexport function matchAsList(tokens, matchGraph, syntaxes) {\n const matchResult = internalMatch(tokens, matchGraph, syntaxes || {});\n\n if (matchResult.match !== null) {\n let item = reverseList(matchResult.match).prev;\n\n matchResult.match = [];\n\n while (item !== null) {\n switch (item.type) {\n case OPEN_SYNTAX:\n case CLOSE_SYNTAX:\n matchResult.match.push({\n type: item.type,\n syntax: item.syntax\n });\n break;\n\n default:\n matchResult.match.push({\n token: item.token.value,\n node: item.token.node\n });\n break;\n }\n\n item = item.prev;\n }\n }\n\n return matchResult;\n}\n\nexport function matchAsTree(tokens, matchGraph, syntaxes) {\n const matchResult = internalMatch(tokens, matchGraph, syntaxes || {});\n\n if (matchResult.match === null) {\n return matchResult;\n }\n\n let item = matchResult.match;\n let host = matchResult.match = {\n syntax: matchGraph.syntax || null,\n match: []\n };\n const hostStack = [host];\n\n // revert a list and start with 2nd item since 1st is a stub item\n item = reverseList(item).prev;\n\n // build a tree\n while (item !== null) {\n switch (item.type) {\n case OPEN_SYNTAX:\n host.match.push(host = {\n syntax: item.syntax,\n match: []\n });\n hostStack.push(host);\n break;\n\n case CLOSE_SYNTAX:\n hostStack.pop();\n host = hostStack[hostStack.length - 1];\n break;\n\n default:\n host.match.push({\n syntax: item.syntax || null,\n token: item.token.value,\n node: item.token.node\n });\n }\n\n item = item.prev;\n }\n\n return matchResult;\n}\n","export function getTrace(node) {\n function shouldPutToTrace(syntax) {\n if (syntax === null) {\n return false;\n }\n\n return (\n syntax.type === 'Type' ||\n syntax.type === 'Property' ||\n syntax.type === 'Keyword'\n );\n }\n\n function hasMatch(matchNode) {\n if (Array.isArray(matchNode.match)) {\n // use for-loop for better perfomance\n for (let i = 0; i < matchNode.match.length; i++) {\n if (hasMatch(matchNode.match[i])) {\n if (shouldPutToTrace(matchNode.syntax)) {\n result.unshift(matchNode.syntax);\n }\n\n return true;\n }\n }\n } else if (matchNode.node === node) {\n result = shouldPutToTrace(matchNode.syntax)\n ? [matchNode.syntax]\n : [];\n\n return true;\n }\n\n return false;\n }\n\n let result = null;\n\n if (this.matched !== null) {\n hasMatch(this.matched);\n }\n\n return result;\n}\n\nexport function isType(node, type) {\n return testNode(this, node, match => match.type === 'Type' && match.name === type);\n}\n\nexport function isProperty(node, property) {\n return testNode(this, node, match => match.type === 'Property' && match.name === property);\n}\n\nexport function isKeyword(node) {\n return testNode(this, node, match => match.type === 'Keyword');\n}\n\nfunction testNode(match, node, fn) {\n const trace = getTrace.call(match, node);\n\n if (trace === null) {\n return false;\n }\n\n return trace.some(fn);\n}\n","import { List } from '../utils/List.js';\n\nfunction getFirstMatchNode(matchNode) {\n if ('node' in matchNode) {\n return matchNode.node;\n }\n\n return getFirstMatchNode(matchNode.match[0]);\n}\n\nfunction getLastMatchNode(matchNode) {\n if ('node' in matchNode) {\n return matchNode.node;\n }\n\n return getLastMatchNode(matchNode.match[matchNode.match.length - 1]);\n}\n\nexport function matchFragments(lexer, ast, match, type, name) {\n function findFragments(matchNode) {\n if (matchNode.syntax !== null &&\n matchNode.syntax.type === type &&\n matchNode.syntax.name === name) {\n const start = getFirstMatchNode(matchNode);\n const end = getLastMatchNode(matchNode);\n\n lexer.syntax.walk(ast, function(node, item, list) {\n if (node === start) {\n const nodes = new List();\n\n do {\n nodes.appendData(item.data);\n\n if (item.data === end) {\n break;\n }\n\n item = item.next;\n } while (item !== null);\n\n fragments.push({\n parent: list,\n nodes\n });\n }\n });\n }\n\n if (Array.isArray(matchNode.match)) {\n matchNode.match.forEach(findFragments);\n }\n }\n\n const fragments = [];\n\n if (match.matched !== null) {\n findFragments(match.matched);\n }\n\n return fragments;\n}\n","import { List } from '../utils/List.js';\n\nconst { hasOwnProperty } = Object.prototype;\n\nfunction isValidNumber(value) {\n // Number.isInteger(value) && value >= 0\n return (\n typeof value === 'number' &&\n isFinite(value) &&\n Math.floor(value) === value &&\n value >= 0\n );\n}\n\nfunction isValidLocation(loc) {\n return (\n Boolean(loc) &&\n isValidNumber(loc.offset) &&\n isValidNumber(loc.line) &&\n isValidNumber(loc.column)\n );\n}\n\nfunction createNodeStructureChecker(type, fields) {\n return function checkNode(node, warn) {\n if (!node || node.constructor !== Object) {\n return warn(node, 'Type of node should be an Object');\n }\n\n for (let key in node) {\n let valid = true;\n\n if (hasOwnProperty.call(node, key) === false) {\n continue;\n }\n\n if (key === 'type') {\n if (node.type !== type) {\n warn(node, 'Wrong node type `' + node.type + '`, expected `' + type + '`');\n }\n } else if (key === 'loc') {\n if (node.loc === null) {\n continue;\n } else if (node.loc && node.loc.constructor === Object) {\n if (typeof node.loc.source !== 'string') {\n key += '.source';\n } else if (!isValidLocation(node.loc.start)) {\n key += '.start';\n } else if (!isValidLocation(node.loc.end)) {\n key += '.end';\n } else {\n continue;\n }\n }\n\n valid = false;\n } else if (fields.hasOwnProperty(key)) {\n valid = false;\n\n for (let i = 0; !valid && i < fields[key].length; i++) {\n const fieldType = fields[key][i];\n\n switch (fieldType) {\n case String:\n valid = typeof node[key] === 'string';\n break;\n\n case Boolean:\n valid = typeof node[key] === 'boolean';\n break;\n\n case null:\n valid = node[key] === null;\n break;\n\n default:\n if (typeof fieldType === 'string') {\n valid = node[key] && node[key].type === fieldType;\n } else if (Array.isArray(fieldType)) {\n valid = node[key] instanceof List;\n }\n }\n }\n } else {\n warn(node, 'Unknown field `' + key + '` for ' + type + ' node type');\n }\n\n if (!valid) {\n warn(node, 'Bad value for `' + type + '.' + key + '`');\n }\n }\n\n for (const key in fields) {\n if (hasOwnProperty.call(fields, key) &&\n hasOwnProperty.call(node, key) === false) {\n warn(node, 'Field `' + type + '.' + key + '` is missed');\n }\n }\n };\n}\n\nfunction genTypesList(fieldTypes, path) {\n const docsTypes = [];\n\n for (let i = 0; i < fieldTypes.length; i++) {\n const fieldType = fieldTypes[i];\n if (fieldType === String || fieldType === Boolean) {\n docsTypes.push(fieldType.name.toLowerCase());\n } else if (fieldType === null) {\n docsTypes.push('null');\n } else if (typeof fieldType === 'string') {\n docsTypes.push(fieldType);\n } else if (Array.isArray(fieldType)) {\n docsTypes.push('List<' + (genTypesList(fieldType, path) || 'any') + '>'); // TODO: use type enum\n } else {\n throw new Error('Wrong value `' + fieldType + '` in `' + path + '` structure definition');\n }\n }\n\n return docsTypes.join(' | ');\n}\n\nfunction processStructure(name, nodeType) {\n const structure = nodeType.structure;\n const fields = {\n type: String,\n loc: true\n };\n const docs = {\n type: '\"' + name + '\"'\n };\n\n for (const key in structure) {\n if (hasOwnProperty.call(structure, key) === false) {\n continue;\n }\n\n const fieldTypes = fields[key] = Array.isArray(structure[key])\n ? structure[key].slice()\n : [structure[key]];\n\n docs[key] = genTypesList(fieldTypes, name + '.' + key);\n }\n\n return {\n docs,\n check: createNodeStructureChecker(name, fields)\n };\n}\n\nexport function getStructureFromConfig(config) {\n const structure = {};\n\n if (config.node) {\n for (const name in config.node) {\n if (hasOwnProperty.call(config.node, name)) {\n const nodeType = config.node[name];\n\n if (nodeType.structure) {\n structure[name] = processStructure(name, nodeType);\n } else {\n throw new Error('Missed `structure` field in `' + name + '` node type definition');\n }\n }\n }\n }\n\n return structure;\n};\n","import { SyntaxReferenceError, SyntaxMatchError } from './error.js';\nimport * as names from '../utils/names.js';\nimport { cssWideKeywords } from './generic-const.js';\nimport { createGenericTypes } from './generic.js';\nimport * as units from './units.js';\nimport { parse, generate, walk } from '../definition-syntax/index.js';\nimport prepareTokens from './prepare-tokens.js';\nimport { buildMatchGraph } from './match-graph.js';\nimport { matchAsTree } from './match.js';\nimport * as trace from './trace.js';\nimport { matchFragments } from './search.js';\nimport { getStructureFromConfig } from './structure.js';\n\nfunction dumpMapSyntax(map, compact, syntaxAsAst) {\n const result = {};\n\n for (const name in map) {\n if (map[name].syntax) {\n result[name] = syntaxAsAst\n ? map[name].syntax\n : generate(map[name].syntax, { compact });\n }\n }\n\n return result;\n}\n\nfunction dumpAtruleMapSyntax(map, compact, syntaxAsAst) {\n const result = {};\n\n for (const [name, atrule] of Object.entries(map)) {\n result[name] = {\n prelude: atrule.prelude && (\n syntaxAsAst\n ? atrule.prelude.syntax\n : generate(atrule.prelude.syntax, { compact })\n ),\n descriptors: atrule.descriptors && dumpMapSyntax(atrule.descriptors, compact, syntaxAsAst)\n };\n }\n\n return result;\n}\n\nfunction valueHasVar(tokens) {\n for (let i = 0; i < tokens.length; i++) {\n if (tokens[i].value.toLowerCase() === 'var(') {\n return true;\n }\n }\n\n return false;\n}\n\nfunction syntaxHasTopLevelCommaMultiplier(syntax) {\n const singleTerm = syntax.terms[0];\n\n return (\n syntax.explicit === false &&\n syntax.terms.length === 1 &&\n singleTerm.type === 'Multiplier' &&\n singleTerm.comma === true\n );\n}\n\nfunction buildMatchResult(matched, error, iterations) {\n return {\n matched,\n iterations,\n error,\n ...trace\n };\n}\n\nfunction matchSyntax(lexer, syntax, value, useCssWideKeywords) {\n const tokens = prepareTokens(value, lexer.syntax);\n let result;\n\n if (valueHasVar(tokens)) {\n return buildMatchResult(null, new Error('Matching for a tree with var() is not supported'));\n }\n\n if (useCssWideKeywords) {\n result = matchAsTree(tokens, lexer.cssWideKeywordsSyntax, lexer);\n }\n\n if (!useCssWideKeywords || !result.match) {\n result = matchAsTree(tokens, syntax.match, lexer);\n if (!result.match) {\n return buildMatchResult(\n null,\n new SyntaxMatchError(result.reason, syntax.syntax, value, result),\n result.iterations\n );\n }\n }\n\n return buildMatchResult(result.match, null, result.iterations);\n}\n\nexport class Lexer {\n constructor(config, syntax, structure) {\n this.cssWideKeywords = cssWideKeywords;\n this.syntax = syntax;\n this.generic = false;\n this.units = { ...units };\n this.atrules = Object.create(null);\n this.properties = Object.create(null);\n this.types = Object.create(null);\n this.structure = structure || getStructureFromConfig(config);\n\n if (config) {\n if (config.cssWideKeywords) {\n this.cssWideKeywords = config.cssWideKeywords;\n }\n\n if (config.units) {\n for (const group of Object.keys(units)) {\n if (Array.isArray(config.units[group])) {\n this.units[group] = config.units[group];\n }\n }\n }\n\n if (config.types) {\n for (const [name, type] of Object.entries(config.types)) {\n this.addType_(name, type);\n }\n }\n\n if (config.generic) {\n this.generic = true;\n for (const [name, value] of Object.entries(createGenericTypes(this.units))) {\n this.addType_(name, value);\n }\n }\n\n if (config.atrules) {\n for (const [name, atrule] of Object.entries(config.atrules)) {\n this.addAtrule_(name, atrule);\n }\n }\n\n if (config.properties) {\n for (const [name, property] of Object.entries(config.properties)) {\n this.addProperty_(name, property);\n }\n }\n }\n\n this.cssWideKeywordsSyntax = buildMatchGraph(this.cssWideKeywords.join(' | '));\n }\n\n checkStructure(ast) {\n function collectWarning(node, message) {\n warns.push({ node, message });\n }\n\n const structure = this.structure;\n const warns = [];\n\n this.syntax.walk(ast, function(node) {\n if (structure.hasOwnProperty(node.type)) {\n structure[node.type].check(node, collectWarning);\n } else {\n collectWarning(node, 'Unknown node type `' + node.type + '`');\n }\n });\n\n return warns.length ? warns : false;\n }\n\n createDescriptor(syntax, type, name, parent = null) {\n const ref = {\n type,\n name\n };\n const descriptor = {\n type,\n name,\n parent,\n serializable: typeof syntax === 'string' || (syntax && typeof syntax.type === 'string'),\n syntax: null,\n match: null,\n matchRef: null // used for properties when a syntax referenced as <'property'> in other syntax definitions\n };\n\n if (typeof syntax === 'function') {\n descriptor.match = buildMatchGraph(syntax, ref);\n } else {\n if (typeof syntax === 'string') {\n // lazy parsing on first access\n Object.defineProperty(descriptor, 'syntax', {\n get() {\n Object.defineProperty(descriptor, 'syntax', {\n value: parse(syntax)\n });\n\n return descriptor.syntax;\n }\n });\n } else {\n descriptor.syntax = syntax;\n }\n\n // lazy graph build on first access\n Object.defineProperty(descriptor, 'match', {\n get() {\n Object.defineProperty(descriptor, 'match', {\n value: buildMatchGraph(descriptor.syntax, ref)\n });\n\n return descriptor.match;\n }\n });\n\n if (type === 'Property') {\n Object.defineProperty(descriptor, 'matchRef', {\n get() {\n const syntax = descriptor.syntax;\n const value = syntaxHasTopLevelCommaMultiplier(syntax)\n ? buildMatchGraph({\n ...syntax,\n terms: [syntax.terms[0].term]\n }, ref)\n : null;\n\n Object.defineProperty(descriptor, 'matchRef', {\n value\n });\n\n return value;\n }\n });\n }\n }\n\n return descriptor;\n }\n addAtrule_(name, syntax) {\n if (!syntax) {\n return;\n }\n\n this.atrules[name] = {\n type: 'Atrule',\n name: name,\n prelude: syntax.prelude ? this.createDescriptor(syntax.prelude, 'AtrulePrelude', name) : null,\n descriptors: syntax.descriptors\n ? Object.keys(syntax.descriptors).reduce(\n (map, descName) => {\n map[descName] = this.createDescriptor(syntax.descriptors[descName], 'AtruleDescriptor', descName, name);\n return map;\n },\n Object.create(null)\n )\n : null\n };\n }\n addProperty_(name, syntax) {\n if (!syntax) {\n return;\n }\n\n this.properties[name] = this.createDescriptor(syntax, 'Property', name);\n }\n addType_(name, syntax) {\n if (!syntax) {\n return;\n }\n\n this.types[name] = this.createDescriptor(syntax, 'Type', name);\n }\n\n checkAtruleName(atruleName) {\n if (!this.getAtrule(atruleName)) {\n return new SyntaxReferenceError('Unknown at-rule', '@' + atruleName);\n }\n }\n checkAtrulePrelude(atruleName, prelude) {\n const error = this.checkAtruleName(atruleName);\n\n if (error) {\n return error;\n }\n\n const atrule = this.getAtrule(atruleName);\n\n if (!atrule.prelude && prelude) {\n return new SyntaxError('At-rule `@' + atruleName + '` should not contain a prelude');\n }\n\n if (atrule.prelude && !prelude) {\n if (!matchSyntax(this, atrule.prelude, '', false).matched) {\n return new SyntaxError('At-rule `@' + atruleName + '` should contain a prelude');\n }\n }\n }\n checkAtruleDescriptorName(atruleName, descriptorName) {\n const error = this.checkAtruleName(atruleName);\n\n if (error) {\n return error;\n }\n\n const atrule = this.getAtrule(atruleName);\n const descriptor = names.keyword(descriptorName);\n\n if (!atrule.descriptors) {\n return new SyntaxError('At-rule `@' + atruleName + '` has no known descriptors');\n }\n\n if (!atrule.descriptors[descriptor.name] &&\n !atrule.descriptors[descriptor.basename]) {\n return new SyntaxReferenceError('Unknown at-rule descriptor', descriptorName);\n }\n }\n checkPropertyName(propertyName) {\n if (!this.getProperty(propertyName)) {\n return new SyntaxReferenceError('Unknown property', propertyName);\n }\n }\n\n matchAtrulePrelude(atruleName, prelude) {\n const error = this.checkAtrulePrelude(atruleName, prelude);\n\n if (error) {\n return buildMatchResult(null, error);\n }\n\n const atrule = this.getAtrule(atruleName);\n\n if (!atrule.prelude) {\n return buildMatchResult(null, null);\n }\n\n return matchSyntax(this, atrule.prelude, prelude || '', false);\n }\n matchAtruleDescriptor(atruleName, descriptorName, value) {\n const error = this.checkAtruleDescriptorName(atruleName, descriptorName);\n\n if (error) {\n return buildMatchResult(null, error);\n }\n\n const atrule = this.getAtrule(atruleName);\n const descriptor = names.keyword(descriptorName);\n\n return matchSyntax(this, atrule.descriptors[descriptor.name] || atrule.descriptors[descriptor.basename], value, false);\n }\n matchDeclaration(node) {\n if (node.type !== 'Declaration') {\n return buildMatchResult(null, new Error('Not a Declaration node'));\n }\n\n return this.matchProperty(node.property, node.value);\n }\n matchProperty(propertyName, value) {\n // don't match syntax for a custom property at the moment\n if (names.property(propertyName).custom) {\n return buildMatchResult(null, new Error('Lexer matching doesn\\'t applicable for custom properties'));\n }\n\n const error = this.checkPropertyName(propertyName);\n\n if (error) {\n return buildMatchResult(null, error);\n }\n\n return matchSyntax(this, this.getProperty(propertyName), value, true);\n }\n matchType(typeName, value) {\n const typeSyntax = this.getType(typeName);\n\n if (!typeSyntax) {\n return buildMatchResult(null, new SyntaxReferenceError('Unknown type', typeName));\n }\n\n return matchSyntax(this, typeSyntax, value, false);\n }\n match(syntax, value) {\n if (typeof syntax !== 'string' && (!syntax || !syntax.type)) {\n return buildMatchResult(null, new SyntaxReferenceError('Bad syntax'));\n }\n\n if (typeof syntax === 'string' || !syntax.match) {\n syntax = this.createDescriptor(syntax, 'Type', 'anonymous');\n }\n\n return matchSyntax(this, syntax, value, false);\n }\n\n findValueFragments(propertyName, value, type, name) {\n return matchFragments(this, value, this.matchProperty(propertyName, value), type, name);\n }\n findDeclarationValueFragments(declaration, type, name) {\n return matchFragments(this, declaration.value, this.matchDeclaration(declaration), type, name);\n }\n findAllFragments(ast, type, name) {\n const result = [];\n\n this.syntax.walk(ast, {\n visit: 'Declaration',\n enter: (declaration) => {\n result.push.apply(result, this.findDeclarationValueFragments(declaration, type, name));\n }\n });\n\n return result;\n }\n\n getAtrule(atruleName, fallbackBasename = true) {\n const atrule = names.keyword(atruleName);\n const atruleEntry = atrule.vendor && fallbackBasename\n ? this.atrules[atrule.name] || this.atrules[atrule.basename]\n : this.atrules[atrule.name];\n\n return atruleEntry || null;\n }\n getAtrulePrelude(atruleName, fallbackBasename = true) {\n const atrule = this.getAtrule(atruleName, fallbackBasename);\n\n return atrule && atrule.prelude || null;\n }\n getAtruleDescriptor(atruleName, name) {\n return this.atrules.hasOwnProperty(atruleName) && this.atrules.declarators\n ? this.atrules[atruleName].declarators[name] || null\n : null;\n }\n getProperty(propertyName, fallbackBasename = true) {\n const property = names.property(propertyName);\n const propertyEntry = property.vendor && fallbackBasename\n ? this.properties[property.name] || this.properties[property.basename]\n : this.properties[property.name];\n\n return propertyEntry || null;\n }\n getType(name) {\n return hasOwnProperty.call(this.types, name) ? this.types[name] : null;\n }\n\n validate() {\n function syntaxRef(name, isType) {\n return isType ? `<${name}>` : `<'${name}'>`;\n }\n\n function validate(syntax, name, broken, descriptor) {\n if (broken.has(name)) {\n return broken.get(name);\n }\n\n broken.set(name, false);\n if (descriptor.syntax !== null) {\n walk(descriptor.syntax, function(node) {\n if (node.type !== 'Type' && node.type !== 'Property') {\n return;\n }\n\n const map = node.type === 'Type' ? syntax.types : syntax.properties;\n const brokenMap = node.type === 'Type' ? brokenTypes : brokenProperties;\n\n if (!hasOwnProperty.call(map, node.name)) {\n errors.push(`${syntaxRef(name, broken === brokenTypes)} used missed syntax definition ${syntaxRef(node.name, node.type === 'Type')}`);\n broken.set(name, true);\n } else if (validate(syntax, node.name, brokenMap, map[node.name])) {\n errors.push(`${syntaxRef(name, broken === brokenTypes)} used broken syntax definition ${syntaxRef(node.name, node.type === 'Type')}`);\n broken.set(name, true);\n }\n }, this);\n }\n }\n\n const errors = [];\n let brokenTypes = new Map();\n let brokenProperties = new Map();\n\n for (const key in this.types) {\n validate(this, key, brokenTypes, this.types[key]);\n }\n\n for (const key in this.properties) {\n validate(this, key, brokenProperties, this.properties[key]);\n }\n\n const brokenTypesArray = [...brokenTypes.keys()].filter(name => brokenTypes.get(name));\n const brokenPropertiesArray = [...brokenProperties.keys()].filter(name => brokenProperties.get(name));\n\n if (brokenTypesArray.length || brokenPropertiesArray.length) {\n return {\n errors,\n types: brokenTypesArray,\n properties: brokenPropertiesArray\n };\n }\n\n return null;\n }\n dump(syntaxAsAst, pretty) {\n return {\n generic: this.generic,\n cssWideKeywords: this.cssWideKeywords,\n units: this.units,\n types: dumpMapSyntax(this.types, !pretty, syntaxAsAst),\n properties: dumpMapSyntax(this.properties, !pretty, syntaxAsAst),\n atrules: dumpAtruleMapSyntax(this.atrules, !pretty, syntaxAsAst)\n };\n }\n toString() {\n return JSON.stringify(this.dump());\n }\n};\n","function appendOrSet(a, b) {\n if (typeof b === 'string' && /^\\s*\\|/.test(b)) {\n return typeof a === 'string'\n ? a + b\n : b.replace(/^\\s*\\|\\s*/, '');\n }\n\n return b || null;\n}\n\nfunction extractProps(obj, props) {\n const result = Object.create(null);\n\n for (const prop of Object.keys(obj)) {\n if (props.includes(prop)) {\n result[prop] = obj[prop];\n }\n }\n\n return result;\n}\n\nfunction mergeDicts(base, ext, fields) {\n const result = { ...base };\n\n for (const [key, props] of Object.entries(ext)) {\n result[key] = {\n ...result[key],\n ...fields ? extractProps(props, fields) : props\n };\n }\n\n return result;\n}\n\nexport default function mix(dest, src) {\n const result = { ...dest };\n\n for (const [prop, value] of Object.entries(src)) {\n switch (prop) {\n case 'generic':\n result[prop] = Boolean(value);\n break;\n\n case 'cssWideKeywords':\n result[prop] = dest[prop]\n ? [...dest[prop], ...value]\n : value || [];\n break;\n\n case 'units':\n result[prop] = { ...dest[prop] };\n for (const [name, patch] of Object.entries(value)) {\n result[prop][name] = Array.isArray(patch) ? patch : [];\n }\n break;\n\n case 'atrules':\n result[prop] = { ...dest[prop] };\n\n for (const [name, atrule] of Object.entries(value)) {\n const exists = result[prop][name] || {};\n const current = result[prop][name] = {\n prelude: exists.prelude || null,\n descriptors: {\n ...exists.descriptors\n }\n };\n\n if (!atrule) {\n continue;\n }\n\n current.prelude = atrule.prelude\n ? appendOrSet(current.prelude, atrule.prelude)\n : current.prelude || null;\n\n for (const [descriptorName, descriptorValue] of Object.entries(atrule.descriptors || {})) {\n current.descriptors[descriptorName] = descriptorValue\n ? appendOrSet(current.descriptors[descriptorName], descriptorValue)\n : null;\n }\n\n if (!Object.keys(current.descriptors).length) {\n current.descriptors = null;\n }\n }\n break;\n\n case 'types':\n case 'properties':\n result[prop] = { ...dest[prop] };\n for (const [name, syntax] of Object.entries(value)) {\n result[prop][name] = appendOrSet(result[prop][name], syntax);\n }\n break;\n\n case 'parseContext':\n result[prop] = {\n ...dest[prop],\n ...value\n };\n break;\n\n case 'scope':\n case 'features':\n result[prop] = mergeDicts(dest[prop], value);\n break;\n\n case 'atrule':\n case 'pseudo':\n result[prop] = mergeDicts(dest[prop], value, ['parse']);\n break;\n\n case 'node':\n result[prop] = mergeDicts(dest[prop], value, ['name', 'structure', 'parse', 'generate', 'walkContext']);\n break;\n }\n }\n\n return result;\n}\n","import { tokenize } from '../tokenizer/index.js';\nimport { createParser } from '../parser/create.js';\nimport { createGenerator } from '../generator/create.js';\nimport { createConvertor } from '../convertor/create.js';\nimport { createWalker } from '../walker/create.js';\nimport { Lexer } from '../lexer/Lexer.js';\nimport mix from './config/mix.js';\n\nfunction createSyntax(config) {\n const parse = createParser(config);\n const walk = createWalker(config);\n const generate = createGenerator(config);\n const { fromPlainObject, toPlainObject } = createConvertor(walk);\n\n const syntax = {\n lexer: null,\n createLexer: config => new Lexer(config, syntax, syntax.lexer.structure),\n\n tokenize,\n parse,\n generate,\n\n walk,\n find: walk.find,\n findLast: walk.findLast,\n findAll: walk.findAll,\n\n fromPlainObject,\n toPlainObject,\n\n fork(extension) {\n const base = mix({}, config); // copy of config\n\n return createSyntax(\n typeof extension === 'function'\n ? extension(base) // TODO: remove Object.assign as second parameter\n : mix(base, extension)\n );\n }\n };\n\n syntax.lexer = new Lexer({\n generic: config.generic,\n cssWideKeywords: config.cssWideKeywords,\n units: config.units,\n types: config.types,\n atrules: config.atrules,\n properties: config.properties,\n node: config.node\n }, syntax);\n\n return syntax;\n};\n\nexport default config => createSyntax(mix({}, config));\n","import { List } from '../utils/List.js';\n\nexport function createConvertor(walk) {\n return {\n fromPlainObject(ast) {\n walk(ast, {\n enter(node) {\n if (node.children && node.children instanceof List === false) {\n node.children = new List().fromArray(node.children);\n }\n }\n });\n\n return ast;\n },\n toPlainObject(ast) {\n walk(ast, {\n leave(node) {\n if (node.children && node.children instanceof List) {\n node.children = node.children.toArray();\n }\n }\n });\n\n return ast;\n }\n };\n};\n","export default {\n \"generic\": true,\n \"cssWideKeywords\": [\n \"initial\",\n \"inherit\",\n \"unset\",\n \"revert\",\n \"revert-layer\"\n ],\n \"units\": {\n \"angle\": [\n \"deg\",\n \"grad\",\n \"rad\",\n \"turn\"\n ],\n \"decibel\": [\n \"db\"\n ],\n \"flex\": [\n \"fr\"\n ],\n \"frequency\": [\n \"hz\",\n \"khz\"\n ],\n \"length\": [\n \"cm\",\n \"mm\",\n \"q\",\n \"in\",\n \"pt\",\n \"pc\",\n \"px\",\n \"em\",\n \"rem\",\n \"ex\",\n \"rex\",\n \"cap\",\n \"rcap\",\n \"ch\",\n \"rch\",\n \"ic\",\n \"ric\",\n \"lh\",\n \"rlh\",\n \"vw\",\n \"svw\",\n \"lvw\",\n \"dvw\",\n \"vh\",\n \"svh\",\n \"lvh\",\n \"dvh\",\n \"vi\",\n \"svi\",\n \"lvi\",\n \"dvi\",\n \"vb\",\n \"svb\",\n \"lvb\",\n \"dvb\",\n \"vmin\",\n \"svmin\",\n \"lvmin\",\n \"dvmin\",\n \"vmax\",\n \"svmax\",\n \"lvmax\",\n \"dvmax\",\n \"cqw\",\n \"cqh\",\n \"cqi\",\n \"cqb\",\n \"cqmin\",\n \"cqmax\"\n ],\n \"resolution\": [\n \"dpi\",\n \"dpcm\",\n \"dppx\",\n \"x\"\n ],\n \"semitones\": [\n \"st\"\n ],\n \"time\": [\n \"s\",\n \"ms\"\n ]\n },\n \"types\": {\n \"abs()\": \"abs( <calc-sum> )\",\n \"absolute-size\": \"xx-small|x-small|small|medium|large|x-large|xx-large|xxx-large\",\n \"acos()\": \"acos( <calc-sum> )\",\n \"alpha-value\": \"<number>|<percentage>\",\n \"an+b\": \"odd|even|<integer>|<n-dimension>|'+'? † n|-n|<ndashdigit-dimension>|'+'? † <ndashdigit-ident>|<dashndashdigit-ident>|<n-dimension> <signed-integer>|'+'? † n <signed-integer>|-n <signed-integer>|<ndash-dimension> <signless-integer>|'+'? † n- <signless-integer>|-n- <signless-integer>|<n-dimension> ['+'|'-'] <signless-integer>|'+'? † n ['+'|'-'] <signless-integer>|-n ['+'|'-'] <signless-integer>\",\n \"anchor()\": \"anchor( <anchor-name>?&&<anchor-side> , <length-percentage>? )\",\n \"anchor-name\": \"<dashed-ident>\",\n \"anchor-side\": \"inside|outside|top|left|right|bottom|start|end|self-start|self-end|<percentage>|center\",\n \"anchor-size\": \"width|height|block|inline|self-block|self-inline\",\n \"anchor-size()\": \"anchor-size( [<anchor-name>||<anchor-size>]? , <length-percentage>? )\",\n \"angle-percentage\": \"<angle>|<percentage>\",\n \"angular-color-hint\": \"<angle-percentage>|<zero>\",\n \"angular-color-stop\": \"<color> <color-stop-angle>?\",\n \"angular-color-stop-list\": \"<angular-color-stop> , [<angular-color-hint>? , <angular-color-stop>]#?\",\n \"animateable-feature\": \"scroll-position|contents|<custom-ident>\",\n \"animation-action\": \"none|play|play-once|play-forwards|play-backwards|pause|reset|replay\",\n \"asin()\": \"asin( <calc-sum> )\",\n \"atan()\": \"atan( <calc-sum> )\",\n \"atan2()\": \"atan2( <calc-sum> , <calc-sum> )\",\n \"attachment\": \"scroll|fixed|local\",\n \"attr()\": \"attr( <attr-name> <attr-type>? , <declaration-value>? )\",\n \"attr-matcher\": \"['~'|'|'|'^'|'$'|'*']? '='\",\n \"attr-modifier\": \"i|s\",\n \"attr-type\": \"type( <syntax> )|raw-string|number|<attr-unit>\",\n \"attribute-selector\": \"'[' <wq-name> ']'|'[' <wq-name> <attr-matcher> [<string-token>|<ident-token>] <attr-modifier>? ']'\",\n \"auto-repeat\": \"repeat( [auto-fill|auto-fit] , [<line-names>? <fixed-size>]+ <line-names>? )\",\n \"auto-track-list\": \"[<line-names>? [<fixed-size>|<fixed-repeat>]]* <line-names>? <auto-repeat> [<line-names>? [<fixed-size>|<fixed-repeat>]]* <line-names>?\",\n \"axis\": \"block|inline|x|y\",\n \"baseline-position\": \"[first|last]? baseline\",\n \"basic-shape\": \"<inset()>|<xywh()>|<rect()>|<circle()>|<ellipse()>|<polygon()>|<path()>\",\n \"basic-shape-rect\": \"<inset()>|<rect()>|<xywh()>\",\n \"bg-clip\": \"<visual-box>|border-area|text\",\n \"bg-image\": \"<image>|none\",\n \"bg-layer\": \"<bg-image>||<bg-position> [/ <bg-size>]?||<repeat-style>||<attachment>||<visual-box>||<visual-box>\",\n \"bg-position\": \"[[left|center|right|top|bottom|<length-percentage>]|[left|center|right|<length-percentage>] [top|center|bottom|<length-percentage>]|[center|[left|right] <length-percentage>?]&&[center|[top|bottom] <length-percentage>?]]\",\n \"bg-size\": \"[<length-percentage [0,∞]>|auto]{1,2}|cover|contain\",\n \"blend-mode\": \"normal|multiply|screen|overlay|darken|lighten|color-dodge|color-burn|hard-light|soft-light|difference|exclusion|hue|saturation|color|luminosity\",\n \"blur()\": \"blur( <length>? )\",\n \"brightness()\": \"brightness( [<number>|<percentage>]? )\",\n \"calc()\": \"calc( <calc-sum> )\",\n \"calc-constant\": \"e|pi|infinity|-infinity|NaN\",\n \"calc-product\": \"<calc-value> ['*' <calc-value>|'/' <number>]*\",\n \"calc-size()\": \"calc-size( <calc-size-basis> , <calc-sum> )\",\n \"calc-size-basis\": \"<intrinsic-size-keyword>|<calc-size()>|any|<calc-sum>\",\n \"calc-sum\": \"<calc-product> [['+'|'-'] <calc-product>]*\",\n \"calc-value\": \"<number>|<dimension>|<percentage>|<calc-constant>|( <calc-sum> )\",\n \"cf-final-image\": \"<image>|<color>\",\n \"cf-mixing-image\": \"<percentage>?&&<image>\",\n \"circle()\": \"circle( <radial-size>? [at <position>]? )\",\n \"clamp()\": \"clamp( <calc-sum>#{3} )\",\n \"class-selector\": \"'.' <ident-token>\",\n \"clip-source\": \"<url>\",\n \"color\": \"<color-base>|currentColor|<system-color>|<device-cmyk()>|<light-dark()>|<-non-standard-color>\",\n \"color()\": \"color( <colorspace-params> [/ [<alpha-value>|none]]? )\",\n \"color-base\": \"<hex-color>|<color-function>|<named-color>|<color-mix()>|transparent\",\n \"color-function\": \"<rgb()>|<rgba()>|<hsl()>|<hsla()>|<hwb()>|<lab()>|<lch()>|<oklab()>|<oklch()>|<color()>\",\n \"color-interpolation-method\": \"in [<rectangular-color-space>|<polar-color-space> <hue-interpolation-method>?|<custom-color-space>]\",\n \"color-mix()\": \"color-mix( <color-interpolation-method> , [<color>&&<percentage [0,100]>?]#{2} )\",\n \"color-stop\": \"<color-stop-length>|<color-stop-angle>\",\n \"color-stop-angle\": \"[<angle-percentage>|<zero>]{1,2}\",\n \"color-stop-length\": \"<length-percentage>{1,2}\",\n \"color-stop-list\": \"<linear-color-stop> , [<linear-color-hint>? , <linear-color-stop>]#?\",\n \"colorspace-params\": \"[<predefined-rgb-params>|<xyz-params>]\",\n \"combinator\": \"'>'|'+'|'~'|['|' '|']\",\n \"common-lig-values\": \"[common-ligatures|no-common-ligatures]\",\n \"compat-auto\": \"searchfield|textarea|checkbox|radio|menulist|listbox|meter|progress-bar|button\",\n \"compat-special\": \"textfield|menulist-button\",\n \"complex-selector\": \"<complex-selector-unit> [<combinator>? <complex-selector-unit>]*\",\n \"complex-selector-list\": \"<complex-selector>#\",\n \"composite-style\": \"clear|copy|source-over|source-in|source-out|source-atop|destination-over|destination-in|destination-out|destination-atop|xor\",\n \"compositing-operator\": \"add|subtract|intersect|exclude\",\n \"compound-selector\": \"[<type-selector>? <subclass-selector>*]!\",\n \"compound-selector-list\": \"<compound-selector>#\",\n \"conic-gradient()\": \"conic-gradient( [<conic-gradient-syntax>] )\",\n \"conic-gradient-syntax\": \"[[[from [<angle>|<zero>]]? [at <position>]?]||<color-interpolation-method>]? , <angular-color-stop-list>\",\n \"container-condition\": \"not <query-in-parens>|<query-in-parens> [[and <query-in-parens>]*|[or <query-in-parens>]*]\",\n \"container-name\": \"<custom-ident>\",\n \"container-query\": \"not <query-in-parens>|<query-in-parens> [[and <query-in-parens>]*|[or <query-in-parens>]*]\",\n \"content-distribution\": \"space-between|space-around|space-evenly|stretch\",\n \"content-list\": \"[<string>|contents|<image>|<counter>|<quote>|<target>|<leader()>|<attr()>]+\",\n \"content-position\": \"center|start|end|flex-start|flex-end\",\n \"content-replacement\": \"<image>\",\n \"contextual-alt-values\": \"[contextual|no-contextual]\",\n \"contrast()\": \"contrast( [<number>|<percentage>]? )\",\n \"coord-box\": \"content-box|padding-box|border-box|fill-box|stroke-box|view-box\",\n \"corner-shape-value\": \"round|scoop|bevel|notch|square|squircle|<superellipse()>\",\n \"cos()\": \"cos( <calc-sum> )\",\n \"counter\": \"<counter()>|<counters()>\",\n \"counter()\": \"counter( <counter-name> , <counter-style>? )\",\n \"counter-name\": \"<custom-ident>\",\n \"counter-style\": \"<counter-style-name>|symbols( )\",\n \"counter-style-name\": \"<custom-ident>\",\n \"counters()\": \"counters( <counter-name> , <string> , <counter-style>? )\",\n \"cross-fade()\": \"cross-fade( <cf-mixing-image> , <cf-final-image>? )\",\n \"cubic-bezier()\": \"cubic-bezier( [<number [0,1]> , <number>]#{2} )\",\n \"cubic-bezier-easing-function\": \"ease|ease-in|ease-out|ease-in-out|cubic-bezier( <number [0,1]> , <number> , <number [0,1]> , <number> )\",\n \"cursor-predefined\": \"auto|default|none|context-menu|help|pointer|progress|wait|cell|crosshair|text|vertical-text|alias|copy|move|no-drop|not-allowed|e-resize|n-resize|ne-resize|nw-resize|s-resize|se-resize|sw-resize|w-resize|ew-resize|ns-resize|nesw-resize|nwse-resize|col-resize|row-resize|all-scroll|zoom-in|zoom-out|grab|grabbing\",\n \"custom-color-space\": \"<dashed-ident>\",\n \"custom-params\": \"<dashed-ident> [<number>|<percentage>|none]+\",\n \"dasharray\": \"[[<length-percentage>|<number>]+]#\",\n \"dashndashdigit-ident\": \"<ident-token>\",\n \"deprecated-system-color\": \"ActiveBorder|ActiveCaption|AppWorkspace|Background|ButtonHighlight|ButtonShadow|CaptionText|InactiveBorder|InactiveCaption|InactiveCaptionText|InfoBackground|InfoText|Menu|MenuText|Scrollbar|ThreeDDarkShadow|ThreeDFace|ThreeDHighlight|ThreeDLightShadow|ThreeDShadow|Window|WindowFrame|WindowText\",\n \"discretionary-lig-values\": \"[discretionary-ligatures|no-discretionary-ligatures]\",\n \"display-box\": \"contents|none\",\n \"display-inside\": \"flow|flow-root|table|flex|grid|ruby\",\n \"display-internal\": \"table-row-group|table-header-group|table-footer-group|table-row|table-cell|table-column-group|table-column|table-caption|ruby-base|ruby-text|ruby-base-container|ruby-text-container\",\n \"display-legacy\": \"inline-block|inline-list-item|inline-table|inline-flex|inline-grid\",\n \"display-listitem\": \"<display-outside>?&&[flow|flow-root]?&&list-item\",\n \"display-outside\": \"block|inline|run-in\",\n \"drop-shadow()\": \"drop-shadow( [<color>?&&<length>{2,3}] )\",\n \"dynamic-range-limit-mix()\": \"dynamic-range-limit-mix( [<'dynamic-range-limit'>&&<percentage [0,100]>]#{2,} )\",\n \"easing-function\": \"<linear-easing-function>|<cubic-bezier-easing-function>|<step-easing-function>\",\n \"east-asian-variant-values\": \"[jis78|jis83|jis90|jis04|simplified|traditional]\",\n \"east-asian-width-values\": \"[full-width|proportional-width]\",\n \"element()\": \"element( <custom-ident> , [first|start|last|first-except]? )|element( <id-selector> )\",\n \"ellipse()\": \"ellipse( <radial-size>? [at <position>]? )\",\n \"env()\": \"env( <custom-ident> , <declaration-value>? )\",\n \"exp()\": \"exp( <calc-sum> )\",\n \"explicit-track-list\": \"[<line-names>? <track-size>]+ <line-names>?\",\n \"family-name\": \"<string>|<custom-ident>+\",\n \"feature-tag-value\": \"<string> [<integer>|on|off]?\",\n \"feature-type\": \"@stylistic|@historical-forms|@styleset|@character-variant|@swash|@ornaments|@annotation\",\n \"feature-value-block\": \"<feature-type> '{' <feature-value-declaration-list> '}'\",\n \"feature-value-block-list\": \"<feature-value-block>+\",\n \"feature-value-declaration\": \"<custom-ident> : <integer>+ ;\",\n \"feature-value-declaration-list\": \"<feature-value-declaration>\",\n \"feature-value-name\": \"<custom-ident>\",\n \"filter-function\": \"<blur()>|<brightness()>|<contrast()>|<drop-shadow()>|<grayscale()>|<hue-rotate()>|<invert()>|<opacity()>|<saturate()>|<sepia()>\",\n \"filter-value-list\": \"[<filter-function>|<url>]+\",\n \"final-bg-layer\": \"<bg-image>||<bg-position> [/ <bg-size>]?||<repeat-style>||<attachment>||<visual-box>||<visual-box>||<'background-color'>\",\n \"fit-content()\": \"fit-content( <length-percentage [0,∞]> )\",\n \"fixed-breadth\": \"<length-percentage>\",\n \"fixed-repeat\": \"repeat( [<integer [1,∞]>] , [<line-names>? <fixed-size>]+ <line-names>? )\",\n \"fixed-size\": \"<fixed-breadth>|minmax( <fixed-breadth> , <track-breadth> )|minmax( <inflexible-breadth> , <fixed-breadth> )\",\n \"font-stretch-absolute\": \"normal|ultra-condensed|extra-condensed|condensed|semi-condensed|semi-expanded|expanded|extra-expanded|ultra-expanded|<percentage>\",\n \"font-variant-css2\": \"normal|small-caps\",\n \"font-weight-absolute\": \"normal|bold|<number [1,1000]>\",\n \"font-width-css3\": \"normal|ultra-condensed|extra-condensed|condensed|semi-condensed|semi-expanded|expanded|extra-expanded|ultra-expanded\",\n \"form-control-identifier\": \"select\",\n \"frequency-percentage\": \"<frequency>|<percentage>\",\n \"generic-complete\": \"serif|sans-serif|system-ui|cursive|fantasy|math|monospace\",\n \"general-enclosed\": \"[<function-token> <any-value>? )]|[( <any-value>? )]\",\n \"generic-family\": \"<generic-script-specific>|<generic-complete>|<generic-incomplete>|<-non-standard-generic-family>\",\n \"generic-incomplete\": \"ui-serif|ui-sans-serif|ui-monospace|ui-rounded\",\n \"geometry-box\": \"<shape-box>|fill-box|stroke-box|view-box\",\n \"gradient\": \"<linear-gradient()>|<repeating-linear-gradient()>|<radial-gradient()>|<repeating-radial-gradient()>|<conic-gradient()>|<repeating-conic-gradient()>|<-legacy-gradient>\",\n \"grayscale()\": \"grayscale( [<number>|<percentage>]? )\",\n \"grid-line\": \"auto|<custom-ident>|[<integer>&&<custom-ident>?]|[span&&[<integer>||<custom-ident>]]\",\n \"historical-lig-values\": \"[historical-ligatures|no-historical-ligatures]\",\n \"hsl()\": \"hsl( <hue> , <percentage> , <percentage> , <alpha-value>? )|hsl( [<hue>|none] [<percentage>|<number>|none] [<percentage>|<number>|none] [/ [<alpha-value>|none]]? )\",\n \"hsla()\": \"hsla( <hue> , <percentage> , <percentage> , <alpha-value>? )|hsla( [<hue>|none] [<percentage>|<number>|none] [<percentage>|<number>|none] [/ [<alpha-value>|none]]? )\",\n \"hue\": \"<number>|<angle>\",\n \"hue-interpolation-method\": \"[shorter|longer|increasing|decreasing] hue\",\n \"hue-rotate()\": \"hue-rotate( [<angle>|<zero>]? )\",\n \"hwb()\": \"hwb( [<hue>|none] [<percentage>|<number>|none] [<percentage>|<number>|none] [/ [<alpha-value>|none]]? )\",\n \"hypot()\": \"hypot( <calc-sum># )\",\n \"image\": \"<url>|<image()>|<image-set()>|<element()>|<paint()>|<cross-fade()>|<gradient>\",\n \"image()\": \"image( <image-tags>? [<image-src>? , <color>?]! )\",\n \"image-set()\": \"image-set( <image-set-option># )\",\n \"image-set-option\": \"[<image>|<string>] [<resolution>||type( <string> )]\",\n \"image-src\": \"<url>|<string>\",\n \"image-tags\": \"ltr|rtl\",\n \"inflexible-breadth\": \"<length-percentage>|min-content|max-content|auto\",\n \"inset()\": \"inset( <length-percentage>{1,4} [round <'border-radius'>]? )\",\n \"invert()\": \"invert( [<number>|<percentage>]? )\",\n \"keyframe-block\": \"<keyframe-selector># { <declaration-list> }\",\n \"keyframe-selector\": \"from|to|<percentage [0,100]>|<timeline-range-name> <percentage>\",\n \"keyframes-name\": \"<custom-ident>|<string>\",\n \"lab()\": \"lab( [<percentage>|<number>|none] [<percentage>|<number>|none] [<percentage>|<number>|none] [/ [<alpha-value>|none]]? )\",\n \"layer()\": \"layer( <layer-name> )\",\n \"layer-name\": \"<ident> ['.' <ident>]*\",\n \"lch()\": \"lch( [<percentage>|<number>|none] [<percentage>|<number>|none] [<hue>|none] [/ [<alpha-value>|none]]? )\",\n \"leader()\": \"leader( <leader-type> )\",\n \"leader-type\": \"dotted|solid|space|<string>\",\n \"length-percentage\": \"<length>|<percentage>\",\n \"light-dark()\": \"light-dark( <color> , <color> )\",\n \"line-name-list\": \"[<line-names>|<name-repeat>]+\",\n \"line-names\": \"'[' <custom-ident>* ']'\",\n \"line-style\": \"none|hidden|dotted|dashed|solid|double|groove|ridge|inset|outset\",\n \"line-width\": \"<length>|thin|medium|thick\",\n \"linear()\": \"linear( [<number>&&<percentage>{0,2}]# )\",\n \"linear-color-hint\": \"<length-percentage>\",\n \"linear-color-stop\": \"<color> <color-stop-length>?\",\n \"linear-easing-function\": \"linear|<linear()>\",\n \"linear-gradient()\": \"linear-gradient( [<linear-gradient-syntax>] )\",\n \"linear-gradient-syntax\": \"[[<angle>|<zero>|to <side-or-corner>]||<color-interpolation-method>]? , <color-stop-list>\",\n \"log()\": \"log( <calc-sum> , <calc-sum>? )\",\n \"mask-layer\": \"<mask-reference>||<position> [/ <bg-size>]?||<repeat-style>||<geometry-box>||[<geometry-box>|no-clip]||<compositing-operator>||<masking-mode>\",\n \"mask-position\": \"[<length-percentage>|left|center|right] [<length-percentage>|top|center|bottom]?\",\n \"mask-reference\": \"none|<image>|<mask-source>\",\n \"mask-source\": \"<url>\",\n \"masking-mode\": \"alpha|luminance|match-source\",\n \"matrix()\": \"matrix( <number>#{6} )\",\n \"matrix3d()\": \"matrix3d( <number>#{16} )\",\n \"max()\": \"max( <calc-sum># )\",\n \"media-and\": \"<media-in-parens> [and <media-in-parens>]+\",\n \"media-condition\": \"<media-not>|<media-and>|<media-or>|<media-in-parens>\",\n \"media-condition-without-or\": \"<media-not>|<media-and>|<media-in-parens>\",\n \"media-feature\": \"( [<mf-plain>|<mf-boolean>|<mf-range>] )\",\n \"media-in-parens\": \"( <media-condition> )|<media-feature>|<general-enclosed>\",\n \"media-not\": \"not <media-in-parens>\",\n \"media-or\": \"<media-in-parens> [or <media-in-parens>]+\",\n \"media-query\": \"<media-condition>|[not|only]? <media-type> [and <media-condition-without-or>]?\",\n \"media-query-list\": \"<media-query>#\",\n \"media-type\": \"<ident>\",\n \"mf-boolean\": \"<mf-name>\",\n \"mf-name\": \"<ident>\",\n \"mf-plain\": \"<mf-name> : <mf-value>\",\n \"mf-range\": \"<mf-name> ['<'|'>']? '='? <mf-value>|<mf-value> ['<'|'>']? '='? <mf-name>|<mf-value> '<' '='? <mf-name> '<' '='? <mf-value>|<mf-value> '>' '='? <mf-name> '>' '='? <mf-value>\",\n \"mf-value\": \"<number>|<dimension>|<ident>|<ratio>\",\n \"min()\": \"min( <calc-sum># )\",\n \"minmax()\": \"minmax( [<length-percentage>|min-content|max-content|auto] , [<length-percentage>|<flex>|min-content|max-content|auto] )\",\n \"mod()\": \"mod( <calc-sum> , <calc-sum> )\",\n \"n-dimension\": \"<dimension-token>\",\n \"name-repeat\": \"repeat( [<integer [1,∞]>|auto-fill] , <line-names>+ )\",\n \"named-color\": \"aliceblue|antiquewhite|aqua|aquamarine|azure|beige|bisque|black|blanchedalmond|blue|blueviolet|brown|burlywood|cadetblue|chartreuse|chocolate|coral|cornflowerblue|cornsilk|crimson|cyan|darkblue|darkcyan|darkgoldenrod|darkgray|darkgreen|darkgrey|darkkhaki|darkmagenta|darkolivegreen|darkorange|darkorchid|darkred|darksalmon|darkseagreen|darkslateblue|darkslategray|darkslategrey|darkturquoise|darkviolet|deeppink|deepskyblue|dimgray|dimgrey|dodgerblue|firebrick|floralwhite|forestgreen|fuchsia|gainsboro|ghostwhite|gold|goldenrod|gray|green|greenyellow|grey|honeydew|hotpink|indianred|indigo|ivory|khaki|lavender|lavenderblush|lawngreen|lemonchiffon|lightblue|lightcoral|lightcyan|lightgoldenrodyellow|lightgray|lightgreen|lightgrey|lightpink|lightsalmon|lightseagreen|lightskyblue|lightslategray|lightslategrey|lightsteelblue|lightyellow|lime|limegreen|linen|magenta|maroon|mediumaquamarine|mediumblue|mediumorchid|mediumpurple|mediumseagreen|mediumslateblue|mediumspringgreen|mediumturquoise|mediumvioletred|midnightblue|mintcream|mistyrose|moccasin|navajowhite|navy|oldlace|olive|olivedrab|orange|orangered|orchid|palegoldenrod|palegreen|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|powderblue|purple|rebeccapurple|red|rosybrown|royalblue|saddlebrown|salmon|sandybrown|seagreen|seashell|sienna|silver|skyblue|slateblue|slategray|slategrey|snow|springgreen|steelblue|tan|teal|thistle|tomato|turquoise|violet|wheat|white|whitesmoke|yellow|yellowgreen\",\n \"namespace-prefix\": \"<ident>\",\n \"ndash-dimension\": \"<dimension-token>\",\n \"ndashdigit-dimension\": \"<dimension-token>\",\n \"ndashdigit-ident\": \"<ident-token>\",\n \"ns-prefix\": \"[<ident-token>|'*']? '|'\",\n \"number-percentage\": \"<number>|<percentage>\",\n \"numeric-figure-values\": \"[lining-nums|oldstyle-nums]\",\n \"numeric-fraction-values\": \"[diagonal-fractions|stacked-fractions]\",\n \"numeric-spacing-values\": \"[proportional-nums|tabular-nums]\",\n \"offset-path\": \"<ray()>|<url>|<basic-shape>\",\n \"oklab()\": \"oklab( [<percentage>|<number>|none] [<percentage>|<number>|none] [<percentage>|<number>|none] [/ [<alpha-value>|none]]? )\",\n \"oklch()\": \"oklch( [<percentage>|<number>|none] [<percentage>|<number>|none] [<hue>|none] [/ [<alpha-value>|none]]? )\",\n \"opacity()\": \"opacity( [<number>|<percentage>]? )\",\n \"opacity-value\": \"<number>|<percentage>\",\n \"outline-line-style\": \"none|dotted|dashed|solid|double|groove|ridge|inset|outset\",\n \"outline-radius\": \"<length>|<percentage>\",\n \"overflow-position\": \"unsafe|safe\",\n \"page-body\": \"<declaration>? [; <page-body>]?|<page-margin-box> <page-body>\",\n \"page-margin-box\": \"<page-margin-box-type> '{' <declaration-list> '}'\",\n \"page-margin-box-type\": \"@top-left-corner|@top-left|@top-center|@top-right|@top-right-corner|@bottom-left-corner|@bottom-left|@bottom-center|@bottom-right|@bottom-right-corner|@left-top|@left-middle|@left-bottom|@right-top|@right-middle|@right-bottom\",\n \"page-selector\": \"<pseudo-page>+|<ident> <pseudo-page>*\",\n \"page-selector-list\": \"[<page-selector>#]?\",\n \"page-size\": \"A5|A4|A3|B5|B4|JIS-B5|JIS-B4|letter|legal|ledger\",\n \"paint\": \"none|<color>|<url> [none|<color>]?|context-fill|context-stroke\",\n \"paint()\": \"paint( <ident> , <declaration-value>? )\",\n \"paint-box\": \"<visual-box>|fill-box|stroke-box\",\n \"palette-identifier\": \"<dashed-ident>\",\n \"palette-mix()\": \"palette-mix( <color-interpolation-method> , [[normal|light|dark|<palette-identifier>|<palette-mix()>]&&<percentage [0,100]>?]#{2} )\",\n \"path()\": \"path( <'fill-rule'>? , <string> )\",\n \"perspective()\": \"perspective( [<length [0,∞]>|none] )\",\n \"polar-color-space\": \"hsl|hwb|lch|oklch\",\n \"polygon()\": \"polygon( <'fill-rule'>? , [<length-percentage> <length-percentage>]# )\",\n \"position\": \"[[left|center|right]||[top|center|bottom]|[left|center|right|<length-percentage>] [top|center|bottom|<length-percentage>]?|[[left|right] <length-percentage>]&&[[top|bottom] <length-percentage>]]\",\n \"position-area\": \"[[left|center|right|span-left|span-right|x-start|x-end|span-x-start|span-x-end|x-self-start|x-self-end|span-x-self-start|span-x-self-end|span-all]||[top|center|bottom|span-top|span-bottom|y-start|y-end|span-y-start|span-y-end|y-self-start|y-self-end|span-y-self-start|span-y-self-end|span-all]|[block-start|center|block-end|span-block-start|span-block-end|span-all]||[inline-start|center|inline-end|span-inline-start|span-inline-end|span-all]|[self-block-start|center|self-block-end|span-self-block-start|span-self-block-end|span-all]||[self-inline-start|center|self-inline-end|span-self-inline-start|span-self-inline-end|span-all]|[start|center|end|span-start|span-end|span-all]{1,2}|[self-start|center|self-end|span-self-start|span-self-end|span-all]{1,2}]\",\n \"pow()\": \"pow( <calc-sum> , <calc-sum> )\",\n \"predefined-rgb\": \"srgb|srgb-linear|display-p3|display-p3-linear|a98-rgb|prophoto-rgb|rec2020\",\n \"predefined-rgb-params\": \"<predefined-rgb> [<number>|<percentage>|none]{3}\",\n \"pseudo-class-selector\": \"':' <ident-token>|':' <function-token> <any-value> ')'\",\n \"pseudo-element-selector\": \"':' <pseudo-class-selector>|<legacy-pseudo-element-selector>\",\n \"pseudo-page\": \": [left|right|first|blank]\",\n \"query-in-parens\": \"( <container-condition> )|( <size-feature> )|style( <style-query> )|<general-enclosed>\",\n \"quote\": \"open-quote|close-quote|no-open-quote|no-close-quote\",\n \"radial-extent\": \"closest-corner|closest-side|farthest-corner|farthest-side\",\n \"radial-gradient()\": \"radial-gradient( [<radial-gradient-syntax>] )\",\n \"radial-gradient-syntax\": \"[[[<radial-shape>||<radial-size>]? [at <position>]?]||<color-interpolation-method>]? , <color-stop-list>\",\n \"radial-shape\": \"circle|ellipse\",\n \"radial-size\": \"<radial-extent>|<length [0,∞]>|<length-percentage [0,∞]>{2}\",\n \"ratio\": \"<number [0,∞]> [/ <number [0,∞]>]?\",\n \"ray()\": \"ray( <angle>&&<ray-size>?&&contain?&&[at <position>]? )\",\n \"ray-size\": \"closest-side|closest-corner|farthest-side|farthest-corner|sides\",\n \"rect()\": \"rect( [<length-percentage>|auto]{4} [round <'border-radius'>]? )\",\n \"rectangular-color-space\": \"srgb|srgb-linear|display-p3|display-p3-linear|a98-rgb|prophoto-rgb|rec2020|lab|oklab|xyz|xyz-d50|xyz-d65\",\n \"relative-selector\": \"<combinator>? <complex-selector>\",\n \"relative-selector-list\": \"<relative-selector>#\",\n \"relative-size\": \"larger|smaller\",\n \"rem()\": \"rem( <calc-sum> , <calc-sum> )\",\n \"repeat-style\": \"repeat-x|repeat-y|[repeat|space|round|no-repeat]{1,2}\",\n \"repeating-conic-gradient()\": \"repeating-conic-gradient( [<conic-gradient-syntax>] )\",\n \"repeating-linear-gradient()\": \"repeating-linear-gradient( [<linear-gradient-syntax>] )\",\n \"repeating-radial-gradient()\": \"repeating-radial-gradient( [<radial-gradient-syntax>] )\",\n \"reversed-counter-name\": \"reversed( <counter-name> )\",\n \"rgb()\": \"rgb( <percentage>#{3} , <alpha-value>? )|rgb( <number>#{3} , <alpha-value>? )|rgb( [<number>|<percentage>|none]{3} [/ [<alpha-value>|none]]? )\",\n \"rgba()\": \"rgba( <percentage>#{3} , <alpha-value>? )|rgba( <number>#{3} , <alpha-value>? )|rgba( [<number>|<percentage>|none]{3} [/ [<alpha-value>|none]]? )\",\n \"rotate()\": \"rotate( [<angle>|<zero>] )\",\n \"rotate3d()\": \"rotate3d( <number> , <number> , <number> , [<angle>|<zero>] )\",\n \"rotateX()\": \"rotateX( [<angle>|<zero>] )\",\n \"rotateY()\": \"rotateY( [<angle>|<zero>] )\",\n \"rotateZ()\": \"rotateZ( [<angle>|<zero>] )\",\n \"round()\": \"round( <rounding-strategy>? , <calc-sum> , <calc-sum> )\",\n \"rounding-strategy\": \"nearest|up|down|to-zero\",\n \"saturate()\": \"saturate( [<number>|<percentage>]? )\",\n \"scale()\": \"scale( [<number>|<percentage>]#{1,2} )\",\n \"scale3d()\": \"scale3d( [<number>|<percentage>]#{3} )\",\n \"scaleX()\": \"scaleX( [<number>|<percentage>] )\",\n \"scaleY()\": \"scaleY( [<number>|<percentage>] )\",\n \"scaleZ()\": \"scaleZ( [<number>|<percentage>] )\",\n \"scope-end\": \"<forgiving-selector-list>\",\n \"scope-start\": \"<forgiving-selector-list>\",\n \"scroll()\": \"scroll( [<scroller>||<axis>]? )\",\n \"scroller\": \"root|nearest|self\",\n \"scroll-state-feature\": \"<media-query-list>\",\n \"scroll-state-in-parens\": \"( <scroll-state-query> )|( <scroll-state-feature> )|<general-enclosed>\",\n \"scroll-state-query\": \"not <scroll-state-in-parens>|<scroll-state-in-parens> [[and <scroll-state-in-parens>]*|[or <scroll-state-in-parens>]*]|<scroll-state-feature>\",\n \"selector-list\": \"<complex-selector-list>\",\n \"self-position\": \"center|start|end|self-start|self-end|flex-start|flex-end\",\n \"sepia()\": \"sepia( [<number>|<percentage>]? )\",\n \"shadow\": \"inset?&&<length>{2,4}&&<color>?\",\n \"shadow-t\": \"[<length>{2,3}&&<color>?]\",\n \"shape\": \"rect( <top> , <right> , <bottom> , <left> )|rect( <top> <right> <bottom> <left> )\",\n \"shape-box\": \"<visual-box>|margin-box\",\n \"side-or-corner\": \"[left|right]||[top|bottom]\",\n \"sign()\": \"sign( <calc-sum> )\",\n \"signed-integer\": \"<number-token>\",\n \"signless-integer\": \"<number-token>\",\n \"sin()\": \"sin( <calc-sum> )\",\n \"single-animation\": \"<'animation-duration'>||<easing-function>||<'animation-delay'>||<single-animation-iteration-count>||<single-animation-direction>||<single-animation-fill-mode>||<single-animation-play-state>||[none|<keyframes-name>]||<single-animation-timeline>\",\n \"single-animation-composition\": \"replace|add|accumulate\",\n \"single-animation-direction\": \"normal|reverse|alternate|alternate-reverse\",\n \"single-animation-fill-mode\": \"none|forwards|backwards|both\",\n \"single-animation-iteration-count\": \"infinite|<number>\",\n \"single-animation-play-state\": \"running|paused\",\n \"single-animation-timeline\": \"auto|none|<dashed-ident>|<scroll()>|<view()>\",\n \"single-transition\": \"[none|<single-transition-property>]||<time>||<easing-function>||<time>||<transition-behavior-value>\",\n \"single-transition-property\": \"all|<custom-ident>\",\n \"size\": \"closest-side|farthest-side|closest-corner|farthest-corner|<length>|<length-percentage>{2}\",\n \"size-feature\": \"<mf-plain>|<mf-boolean>|<mf-range>\",\n \"skew()\": \"skew( [<angle>|<zero>] , [<angle>|<zero>]? )\",\n \"skewX()\": \"skewX( [<angle>|<zero>] )\",\n \"skewY()\": \"skewY( [<angle>|<zero>] )\",\n \"sqrt()\": \"sqrt( <calc-sum> )\",\n \"step-position\": \"jump-start|jump-end|jump-none|jump-both|start|end\",\n \"step-easing-function\": \"step-start|step-end|<steps()>\",\n \"steps()\": \"steps( <integer> , <step-position>? )\",\n \"style-feature\": \"<declaration>\",\n \"style-in-parens\": \"( <style-condition> )|( <style-feature> )|<general-enclosed>\",\n \"style-query\": \"<style-condition>|<style-feature>\",\n \"subclass-selector\": \"<id-selector>|<class-selector>|<attribute-selector>|<pseudo-class-selector>\",\n \"superellipse()\": \"superellipse( [<number>|infinity|-infinity] )\",\n \"supports-condition\": \"not <supports-in-parens>|<supports-in-parens> [and <supports-in-parens>]*|<supports-in-parens> [or <supports-in-parens>]*\",\n \"supports-decl\": \"( <declaration> )\",\n \"supports-feature\": \"<supports-decl>|<supports-selector-fn>\",\n \"supports-in-parens\": \"( <supports-condition> )|<supports-feature>|<general-enclosed>\",\n \"supports-selector-fn\": \"selector( <complex-selector> )\",\n \"symbol\": \"<string>|<image>|<custom-ident>\",\n \"symbols()\": \"symbols( <symbols-type>? [<string>|<image>]+ )\",\n \"symbols-type\": \"cyclic|numeric|alphabetic|symbolic|fixed\",\n \"system-color\": \"AccentColor|AccentColorText|ActiveText|ButtonBorder|ButtonFace|ButtonText|Canvas|CanvasText|Field|FieldText|GrayText|Highlight|HighlightText|LinkText|Mark|MarkText|SelectedItem|SelectedItemText|VisitedText\",\n \"system-family-name\": \"caption|icon|menu|message-box|small-caption|status-bar\",\n \"tan()\": \"tan( <calc-sum> )\",\n \"target\": \"<target-counter()>|<target-counters()>|<target-text()>\",\n \"target-counter()\": \"target-counter( [<string>|<url>] , <custom-ident> , <counter-style>? )\",\n \"target-counters()\": \"target-counters( [<string>|<url>] , <custom-ident> , <string> , <counter-style>? )\",\n \"target-text()\": \"target-text( [<string>|<url>] , [content|before|after|first-letter]? )\",\n \"text-edge\": \"[text|cap|ex|ideographic|ideographic-ink] [text|alphabetic|ideographic|ideographic-ink]?\",\n \"time-percentage\": \"<time>|<percentage>\",\n \"timeline-range-name\": \"cover|contain|entry|exit|entry-crossing|exit-crossing\",\n \"track-breadth\": \"<length-percentage>|<flex>|min-content|max-content|auto\",\n \"track-list\": \"[<line-names>? [<track-size>|<track-repeat>]]+ <line-names>?\",\n \"track-repeat\": \"repeat( [<integer [1,∞]>] , [<line-names>? <track-size>]+ <line-names>? )\",\n \"track-size\": \"<track-breadth>|minmax( <inflexible-breadth> , <track-breadth> )|fit-content( <length-percentage> )\",\n \"transform-function\": \"<matrix()>|<translate()>|<translateX()>|<translateY()>|<scale()>|<scaleX()>|<scaleY()>|<rotate()>|<skew()>|<skewX()>|<skewY()>|<matrix3d()>|<translate3d()>|<translateZ()>|<scale3d()>|<scaleZ()>|<rotate3d()>|<rotateX()>|<rotateY()>|<rotateZ()>|<perspective()>\",\n \"transform-list\": \"<transform-function>+\",\n \"transition-behavior-value\": \"normal|allow-discrete\",\n \"translate()\": \"translate( <length-percentage> , <length-percentage>? )\",\n \"translate3d()\": \"translate3d( <length-percentage> , <length-percentage> , <length> )\",\n \"translateX()\": \"translateX( <length-percentage> )\",\n \"translateY()\": \"translateY( <length-percentage> )\",\n \"translateZ()\": \"translateZ( <length> )\",\n \"try-size\": \"most-width|most-height|most-block-size|most-inline-size\",\n \"try-tactic\": \"flip-block||flip-inline||flip-start\",\n \"type-or-unit\": \"string|color|url|integer|number|length|angle|time|frequency|cap|ch|em|ex|ic|lh|rlh|rem|vb|vi|vw|vh|vmin|vmax|mm|Q|cm|in|pt|pc|px|deg|grad|rad|turn|ms|s|Hz|kHz|%\",\n \"type-selector\": \"<wq-name>|<ns-prefix>? '*'\",\n \"var()\": \"var( <custom-property-name> , <declaration-value>? )\",\n \"view()\": \"view( [<axis>||<'view-timeline-inset'>]? )\",\n \"viewport-length\": \"auto|<length-percentage>\",\n \"visual-box\": \"content-box|padding-box|border-box\",\n \"wq-name\": \"<ns-prefix>? <ident-token>\",\n \"xywh()\": \"xywh( <length-percentage>{2} <length-percentage [0,∞]>{2} [round <'border-radius'>]? )\",\n \"xyz\": \"xyz|xyz-d50|xyz-d65\",\n \"xyz-params\": \"<xyz-space> [<number>|<percentage>|none]{3}\",\n \"-legacy-gradient\": \"<-webkit-gradient()>|<-legacy-linear-gradient>|<-legacy-repeating-linear-gradient>|<-legacy-radial-gradient>|<-legacy-repeating-radial-gradient>\",\n \"-legacy-linear-gradient\": \"-moz-linear-gradient( <-legacy-linear-gradient-arguments> )|-webkit-linear-gradient( <-legacy-linear-gradient-arguments> )|-o-linear-gradient( <-legacy-linear-gradient-arguments> )\",\n \"-legacy-repeating-linear-gradient\": \"-moz-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )|-webkit-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )|-o-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )\",\n \"-legacy-linear-gradient-arguments\": \"[<angle>|<side-or-corner>]? , <color-stop-list>\",\n \"-legacy-radial-gradient\": \"-moz-radial-gradient( <-legacy-radial-gradient-arguments> )|-webkit-radial-gradient( <-legacy-radial-gradient-arguments> )|-o-radial-gradient( <-legacy-radial-gradient-arguments> )\",\n \"-legacy-repeating-radial-gradient\": \"-moz-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )|-webkit-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )|-o-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )\",\n \"-legacy-radial-gradient-arguments\": \"[<position> ,]? [[[<-legacy-radial-gradient-shape>||<-legacy-radial-gradient-size>]|[<length>|<percentage>]{2}] ,]? <color-stop-list>\",\n \"-legacy-radial-gradient-size\": \"closest-side|closest-corner|farthest-side|farthest-corner|contain|cover\",\n \"-legacy-radial-gradient-shape\": \"circle|ellipse\",\n \"-non-standard-font\": \"-apple-system-body|-apple-system-headline|-apple-system-subheadline|-apple-system-caption1|-apple-system-caption2|-apple-system-footnote|-apple-system-short-body|-apple-system-short-headline|-apple-system-short-subheadline|-apple-system-short-caption1|-apple-system-short-footnote|-apple-system-tall-body\",\n \"-non-standard-color\": \"-moz-ButtonDefault|-moz-ButtonHoverFace|-moz-ButtonHoverText|-moz-CellHighlight|-moz-CellHighlightText|-moz-Combobox|-moz-ComboboxText|-moz-Dialog|-moz-DialogText|-moz-dragtargetzone|-moz-EvenTreeRow|-moz-Field|-moz-FieldText|-moz-html-CellHighlight|-moz-html-CellHighlightText|-moz-mac-accentdarkestshadow|-moz-mac-accentdarkshadow|-moz-mac-accentface|-moz-mac-accentlightesthighlight|-moz-mac-accentlightshadow|-moz-mac-accentregularhighlight|-moz-mac-accentregularshadow|-moz-mac-chrome-active|-moz-mac-chrome-inactive|-moz-mac-focusring|-moz-mac-menuselect|-moz-mac-menushadow|-moz-mac-menutextselect|-moz-MenuHover|-moz-MenuHoverText|-moz-MenuBarText|-moz-MenuBarHoverText|-moz-nativehyperlinktext|-moz-OddTreeRow|-moz-win-communicationstext|-moz-win-mediatext|-moz-activehyperlinktext|-moz-default-background-color|-moz-default-color|-moz-hyperlinktext|-moz-visitedhyperlinktext|-webkit-activelink|-webkit-focus-ring-color|-webkit-link|-webkit-text\",\n \"-non-standard-image-rendering\": \"optimize-contrast|-moz-crisp-edges|-o-crisp-edges|-webkit-optimize-contrast\",\n \"-non-standard-overflow\": \"overlay|-moz-scrollbars-none|-moz-scrollbars-horizontal|-moz-scrollbars-vertical|-moz-hidden-unscrollable\",\n \"-non-standard-size\": \"intrinsic|min-intrinsic|-webkit-fill-available|-webkit-fit-content|-webkit-min-content|-webkit-max-content|-moz-available|-moz-fit-content|-moz-min-content|-moz-max-content\",\n \"-webkit-gradient()\": \"-webkit-gradient( <-webkit-gradient-type> , <-webkit-gradient-point> [, <-webkit-gradient-point>|, <-webkit-gradient-radius> , <-webkit-gradient-point>] [, <-webkit-gradient-radius>]? [, <-webkit-gradient-color-stop>]* )\",\n \"-webkit-gradient-color-stop\": \"from( <color> )|color-stop( [<number-zero-one>|<percentage>] , <color> )|to( <color> )\",\n \"-webkit-gradient-point\": \"[left|center|right|<length-percentage>] [top|center|bottom|<length-percentage>]\",\n \"-webkit-gradient-radius\": \"<length>|<percentage>\",\n \"-webkit-gradient-type\": \"linear|radial\",\n \"-webkit-mask-box-repeat\": \"repeat|stretch|round\",\n \"-ms-filter-function-list\": \"<-ms-filter-function>+\",\n \"-ms-filter-function\": \"<-ms-filter-function-progid>|<-ms-filter-function-legacy>\",\n \"-ms-filter-function-progid\": \"'progid:' [<ident-token> '.']* [<ident-token>|<function-token> <any-value>? )]\",\n \"-ms-filter-function-legacy\": \"<ident-token>|<function-token> <any-value>? )\",\n \"age\": \"child|young|old\",\n \"attr-name\": \"<wq-name>\",\n \"attr-fallback\": \"<any-value>\",\n \"autospace\": \"no-autospace|[ideograph-alpha||ideograph-numeric||punctuation]||[insert|replace]\",\n \"bottom\": \"<length>|auto\",\n \"generic-voice\": \"[<age>? <gender> <integer>?]\",\n \"gender\": \"male|female|neutral\",\n \"generic-script-specific\": \"generic( kai )|generic( fangsong )|generic( nastaliq )\",\n \"-non-standard-generic-family\": \"-apple-system|BlinkMacSystemFont\",\n \"intrinsic-size-keyword\": \"min-content|max-content|fit-content\",\n \"left\": \"<length>|auto\",\n \"device-cmyk()\": \"<legacy-device-cmyk-syntax>|<modern-device-cmyk-syntax>\",\n \"legacy-device-cmyk-syntax\": \"device-cmyk( <number>#{4} )\",\n \"modern-device-cmyk-syntax\": \"device-cmyk( <cmyk-component>{4} [/ [<alpha-value>|none]]? )\",\n \"cmyk-component\": \"<number>|<percentage>|none\",\n \"color-space\": \"<rectangular-color-space>|<polar-color-space>|<custom-color-space>\",\n \"right\": \"<length>|auto\",\n \"forgiving-selector-list\": \"<complex-real-selector-list>\",\n \"forgiving-relative-selector-list\": \"<relative-real-selector-list>\",\n \"complex-real-selector-list\": \"<complex-real-selector>#\",\n \"simple-selector-list\": \"<simple-selector>#\",\n \"relative-real-selector-list\": \"<relative-real-selector>#\",\n \"complex-selector-unit\": \"[<compound-selector>? <pseudo-compound-selector>*]!\",\n \"complex-real-selector\": \"<compound-selector> [<combinator>? <compound-selector>]*\",\n \"relative-real-selector\": \"<combinator>? <complex-real-selector>\",\n \"pseudo-compound-selector\": \"<pseudo-element-selector> <pseudo-class-selector>*\",\n \"simple-selector\": \"<type-selector>|<subclass-selector>\",\n \"legacy-pseudo-element-selector\": \"':' [before|after|first-line|first-letter]\",\n \"svg-length\": \"<percentage>|<length>|<number>\",\n \"svg-writing-mode\": \"lr-tb|rl-tb|tb-rl|lr|rl|tb\",\n \"top\": \"<length>|auto\",\n \"x\": \"<number>\",\n \"y\": \"<number>\",\n \"declaration\": \"<ident-token> : <declaration-value>? ['!' important]?\",\n \"declaration-list\": \"[<declaration>? ';']* <declaration>?\",\n \"url\": \"url( <string> <url-modifier>* )|<url-token>\",\n \"url-modifier\": \"<ident>|<function-token> <any-value> )\",\n \"number-zero-one\": \"<number [0,1]>\",\n \"number-one-or-greater\": \"<number [1,∞]>\",\n \"xyz-space\": \"xyz|xyz-d50|xyz-d65\",\n \"style-condition\": \"not <style-in-parens>|<style-in-parens> [[and <style-in-parens>]*|[or <style-in-parens>]*]\",\n \"-non-standard-display\": \"-ms-inline-flexbox|-ms-grid|-ms-inline-grid|-webkit-flex|-webkit-inline-flex|-webkit-box|-webkit-inline-box|-moz-inline-stack|-moz-box|-moz-inline-box\",\n \"inset-area\": \"[[left|center|right|span-left|span-right|x-start|x-end|span-x-start|span-x-end|x-self-start|x-self-end|span-x-self-start|span-x-self-end|span-all]||[top|center|bottom|span-top|span-bottom|y-start|y-end|span-y-start|span-y-end|y-self-start|y-self-end|span-y-self-start|span-y-self-end|span-all]|[block-start|center|block-end|span-block-start|span-block-end|span-all]||[inline-start|center|inline-end|span-inline-start|span-inline-end|span-all]|[self-block-start|self-block-end|span-self-block-start|span-self-block-end|span-all]||[self-inline-start|self-inline-end|span-self-inline-start|span-self-inline-end|span-all]|[start|center|end|span-start|span-end|span-all]{1,2}|[self-start|center|self-end|span-self-start|span-self-end|span-all]{1,2}]\",\n \"syntax\": \"'*'|<syntax-component> [<syntax-combinator> <syntax-component>]*|<syntax-string>\",\n \"syntax-component\": \"<syntax-single-component> <syntax-multiplier>?|'<' transform-list '>'\",\n \"syntax-single-component\": \"'<' <syntax-type-name> '>'|<ident>\",\n \"syntax-type-name\": \"angle|color|custom-ident|image|integer|length|length-percentage|number|percentage|resolution|string|time|url|transform-function\",\n \"syntax-combinator\": \"'|'\",\n \"syntax-multiplier\": \"'#'|'+'\",\n \"syntax-string\": \"<string>\"\n },\n \"properties\": {\n \"--*\": \"<declaration-value>\",\n \"-ms-accelerator\": \"false|true\",\n \"-ms-block-progression\": \"tb|rl|bt|lr\",\n \"-ms-content-zoom-chaining\": \"none|chained\",\n \"-ms-content-zoom-limit\": \"<'-ms-content-zoom-limit-min'> <'-ms-content-zoom-limit-max'>\",\n \"-ms-content-zoom-limit-max\": \"<percentage>\",\n \"-ms-content-zoom-limit-min\": \"<percentage>\",\n \"-ms-content-zoom-snap\": \"<'-ms-content-zoom-snap-type'>||<'-ms-content-zoom-snap-points'>\",\n \"-ms-content-zoom-snap-points\": \"snapInterval( <percentage> , <percentage> )|snapList( <percentage># )\",\n \"-ms-content-zoom-snap-type\": \"none|proximity|mandatory\",\n \"-ms-content-zooming\": \"none|zoom\",\n \"-ms-filter\": \"<string>\",\n \"-ms-flow-from\": \"[none|<custom-ident>]#\",\n \"-ms-flow-into\": \"[none|<custom-ident>]#\",\n \"-ms-grid-columns\": \"none|<track-list>|<auto-track-list>\",\n \"-ms-grid-rows\": \"none|<track-list>|<auto-track-list>\",\n \"-ms-high-contrast-adjust\": \"auto|none\",\n \"-ms-hyphenate-limit-chars\": \"auto|<integer>{1,3}\",\n \"-ms-hyphenate-limit-lines\": \"no-limit|<integer>\",\n \"-ms-hyphenate-limit-zone\": \"<percentage>|<length>\",\n \"-ms-ime-align\": \"auto|after\",\n \"-ms-overflow-style\": \"auto|none|scrollbar|-ms-autohiding-scrollbar\",\n \"-ms-scroll-chaining\": \"chained|none\",\n \"-ms-scroll-limit\": \"<'-ms-scroll-limit-x-min'> <'-ms-scroll-limit-y-min'> <'-ms-scroll-limit-x-max'> <'-ms-scroll-limit-y-max'>\",\n \"-ms-scroll-limit-x-max\": \"auto|<length>\",\n \"-ms-scroll-limit-x-min\": \"<length>\",\n \"-ms-scroll-limit-y-max\": \"auto|<length>\",\n \"-ms-scroll-limit-y-min\": \"<length>\",\n \"-ms-scroll-rails\": \"none|railed\",\n \"-ms-scroll-snap-points-x\": \"snapInterval( <length-percentage> , <length-percentage> )|snapList( <length-percentage># )\",\n \"-ms-scroll-snap-points-y\": \"snapInterval( <length-percentage> , <length-percentage> )|snapList( <length-percentage># )\",\n \"-ms-scroll-snap-type\": \"none|proximity|mandatory\",\n \"-ms-scroll-snap-x\": \"<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-x'>\",\n \"-ms-scroll-snap-y\": \"<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-y'>\",\n \"-ms-scroll-translation\": \"none|vertical-to-horizontal\",\n \"-ms-scrollbar-3dlight-color\": \"<color>\",\n \"-ms-scrollbar-arrow-color\": \"<color>\",\n \"-ms-scrollbar-base-color\": \"<color>\",\n \"-ms-scrollbar-darkshadow-color\": \"<color>\",\n \"-ms-scrollbar-face-color\": \"<color>\",\n \"-ms-scrollbar-highlight-color\": \"<color>\",\n \"-ms-scrollbar-shadow-color\": \"<color>\",\n \"-ms-scrollbar-track-color\": \"<color>\",\n \"-ms-text-autospace\": \"none|ideograph-alpha|ideograph-numeric|ideograph-parenthesis|ideograph-space\",\n \"-ms-touch-select\": \"grippers|none\",\n \"-ms-user-select\": \"none|element|text\",\n \"-ms-wrap-flow\": \"auto|both|start|end|maximum|clear\",\n \"-ms-wrap-margin\": \"<length>\",\n \"-ms-wrap-through\": \"wrap|none\",\n \"-moz-appearance\": \"none|button|button-arrow-down|button-arrow-next|button-arrow-previous|button-arrow-up|button-bevel|button-focus|caret|checkbox|checkbox-container|checkbox-label|checkmenuitem|dualbutton|groupbox|listbox|listitem|menuarrow|menubar|menucheckbox|menuimage|menuitem|menuitemtext|menulist|menulist-button|menulist-text|menulist-textfield|menupopup|menuradio|menuseparator|meterbar|meterchunk|progressbar|progressbar-vertical|progresschunk|progresschunk-vertical|radio|radio-container|radio-label|radiomenuitem|range|range-thumb|resizer|resizerpanel|scale-horizontal|scalethumbend|scalethumb-horizontal|scalethumbstart|scalethumbtick|scalethumb-vertical|scale-vertical|scrollbarbutton-down|scrollbarbutton-left|scrollbarbutton-right|scrollbarbutton-up|scrollbarthumb-horizontal|scrollbarthumb-vertical|scrollbartrack-horizontal|scrollbartrack-vertical|searchfield|separator|sheet|spinner|spinner-downbutton|spinner-textfield|spinner-upbutton|splitter|statusbar|statusbarpanel|tab|tabpanel|tabpanels|tab-scroll-arrow-back|tab-scroll-arrow-forward|textfield|textfield-multiline|toolbar|toolbarbutton|toolbarbutton-dropdown|toolbargripper|toolbox|tooltip|treeheader|treeheadercell|treeheadersortarrow|treeitem|treeline|treetwisty|treetwistyopen|treeview|-moz-mac-unified-toolbar|-moz-win-borderless-glass|-moz-win-browsertabbar-toolbox|-moz-win-communicationstext|-moz-win-communications-toolbox|-moz-win-exclude-glass|-moz-win-glass|-moz-win-mediatext|-moz-win-media-toolbox|-moz-window-button-box|-moz-window-button-box-maximized|-moz-window-button-close|-moz-window-button-maximize|-moz-window-button-minimize|-moz-window-button-restore|-moz-window-frame-bottom|-moz-window-frame-left|-moz-window-frame-right|-moz-window-titlebar|-moz-window-titlebar-maximized\",\n \"-moz-binding\": \"<url>|none\",\n \"-moz-border-bottom-colors\": \"<color>+|none\",\n \"-moz-border-left-colors\": \"<color>+|none\",\n \"-moz-border-right-colors\": \"<color>+|none\",\n \"-moz-border-top-colors\": \"<color>+|none\",\n \"-moz-context-properties\": \"none|[fill|fill-opacity|stroke|stroke-opacity]#\",\n \"-moz-float-edge\": \"border-box|content-box|margin-box|padding-box\",\n \"-moz-force-broken-image-icon\": \"0|1\",\n \"-moz-orient\": \"inline|block|horizontal|vertical\",\n \"-moz-outline-radius\": \"<outline-radius>{1,4} [/ <outline-radius>{1,4}]?\",\n \"-moz-outline-radius-bottomleft\": \"<outline-radius>\",\n \"-moz-outline-radius-bottomright\": \"<outline-radius>\",\n \"-moz-outline-radius-topleft\": \"<outline-radius>\",\n \"-moz-outline-radius-topright\": \"<outline-radius>\",\n \"-moz-stack-sizing\": \"ignore|stretch-to-fit\",\n \"-moz-text-blink\": \"none|blink\",\n \"-moz-user-focus\": \"ignore|normal|select-after|select-before|select-menu|select-same|select-all|none\",\n \"-moz-user-input\": \"auto|none|enabled|disabled\",\n \"-moz-user-modify\": \"read-only|read-write|write-only\",\n \"-moz-window-dragging\": \"drag|no-drag\",\n \"-moz-window-shadow\": \"default|menu|tooltip|sheet|none\",\n \"-webkit-appearance\": \"none|button|button-bevel|caps-lock-indicator|caret|checkbox|default-button|inner-spin-button|listbox|listitem|media-controls-background|media-controls-fullscreen-background|media-current-time-display|media-enter-fullscreen-button|media-exit-fullscreen-button|media-fullscreen-button|media-mute-button|media-overlay-play-button|media-play-button|media-seek-back-button|media-seek-forward-button|media-slider|media-sliderthumb|media-time-remaining-display|media-toggle-closed-captions-button|media-volume-slider|media-volume-slider-container|media-volume-sliderthumb|menulist|menulist-button|menulist-text|menulist-textfield|meter|progress-bar|progress-bar-value|push-button|radio|scrollbarbutton-down|scrollbarbutton-left|scrollbarbutton-right|scrollbarbutton-up|scrollbargripper-horizontal|scrollbargripper-vertical|scrollbarthumb-horizontal|scrollbarthumb-vertical|scrollbartrack-horizontal|scrollbartrack-vertical|searchfield|searchfield-cancel-button|searchfield-decoration|searchfield-results-button|searchfield-results-decoration|slider-horizontal|slider-vertical|sliderthumb-horizontal|sliderthumb-vertical|square-button|textarea|textfield|-apple-pay-button\",\n \"-webkit-border-before\": \"<'border-width'>||<'border-style'>||<color>\",\n \"-webkit-border-before-color\": \"<color>\",\n \"-webkit-border-before-style\": \"<'border-style'>\",\n \"-webkit-border-before-width\": \"<'border-width'>\",\n \"-webkit-box-reflect\": \"[above|below|right|left]? <length>? <image>?\",\n \"-webkit-line-clamp\": \"none|<integer>\",\n \"-webkit-mask\": \"[<mask-reference>||<position> [/ <bg-size>]?||<repeat-style>||[<visual-box>|border|padding|content|text]||[<visual-box>|border|padding|content]]#\",\n \"-webkit-mask-attachment\": \"<attachment>#\",\n \"-webkit-mask-clip\": \"[<coord-box>|no-clip|border|padding|content|text]#\",\n \"-webkit-mask-composite\": \"<composite-style>#\",\n \"-webkit-mask-image\": \"<mask-reference>#\",\n \"-webkit-mask-origin\": \"[<coord-box>|border|padding|content]#\",\n \"-webkit-mask-position\": \"<position>#\",\n \"-webkit-mask-position-x\": \"[<length-percentage>|left|center|right]#\",\n \"-webkit-mask-position-y\": \"[<length-percentage>|top|center|bottom]#\",\n \"-webkit-mask-repeat\": \"<repeat-style>#\",\n \"-webkit-mask-repeat-x\": \"repeat|no-repeat|space|round\",\n \"-webkit-mask-repeat-y\": \"repeat|no-repeat|space|round\",\n \"-webkit-mask-size\": \"<bg-size>#\",\n \"-webkit-overflow-scrolling\": \"auto|touch\",\n \"-webkit-tap-highlight-color\": \"<color>\",\n \"-webkit-text-fill-color\": \"<color>\",\n \"-webkit-text-stroke\": \"<length>||<color>\",\n \"-webkit-text-stroke-color\": \"<color>\",\n \"-webkit-text-stroke-width\": \"<length>\",\n \"-webkit-touch-callout\": \"default|none\",\n \"-webkit-user-modify\": \"read-only|read-write|read-write-plaintext-only\",\n \"-webkit-user-select\": \"auto|none|text|all\",\n \"accent-color\": \"auto|<color>\",\n \"align-content\": \"normal|<baseline-position>|<content-distribution>|<overflow-position>? <content-position>\",\n \"align-items\": \"normal|stretch|<baseline-position>|[<overflow-position>? <self-position>]|anchor-center\",\n \"align-self\": \"auto|normal|stretch|<baseline-position>|<overflow-position>? <self-position>|anchor-center\",\n \"align-tracks\": \"[normal|<baseline-position>|<content-distribution>|<overflow-position>? <content-position>]#\",\n \"alignment-baseline\": \"auto|baseline|before-edge|text-before-edge|middle|central|after-edge|text-after-edge|ideographic|alphabetic|hanging|mathematical\",\n \"all\": \"initial|inherit|unset|revert|revert-layer\",\n \"anchor-name\": \"none|<dashed-ident>#\",\n \"anchor-scope\": \"none|all|<dashed-ident>#\",\n \"animation\": \"<single-animation>#\",\n \"animation-composition\": \"<single-animation-composition>#\",\n \"animation-delay\": \"<time>#\",\n \"animation-direction\": \"<single-animation-direction>#\",\n \"animation-duration\": \"[auto|<time [0s,∞]>]#\",\n \"animation-fill-mode\": \"<single-animation-fill-mode>#\",\n \"animation-iteration-count\": \"<single-animation-iteration-count>#\",\n \"animation-name\": \"[none|<keyframes-name>]#\",\n \"animation-play-state\": \"<single-animation-play-state>#\",\n \"animation-range\": \"[<'animation-range-start'> <'animation-range-end'>?]#\",\n \"animation-range-end\": \"[normal|<length-percentage>|<timeline-range-name> <length-percentage>?]#\",\n \"animation-range-start\": \"[normal|<length-percentage>|<timeline-range-name> <length-percentage>?]#\",\n \"animation-timeline\": \"<single-animation-timeline>#\",\n \"animation-timing-function\": \"<easing-function>#\",\n \"animation-trigger\": \"[none|[<dashed-ident> <animation-action>+]+]#\",\n \"appearance\": \"none|auto|<compat-auto>|<compat-special>\",\n \"aspect-ratio\": \"auto||<ratio>\",\n \"backdrop-filter\": \"none|<filter-value-list>\",\n \"backface-visibility\": \"visible|hidden\",\n \"background\": \"<bg-layer>#? , <final-bg-layer>\",\n \"background-attachment\": \"<attachment>#\",\n \"background-blend-mode\": \"<blend-mode>#\",\n \"background-clip\": \"<bg-clip>#\",\n \"background-color\": \"<color>\",\n \"background-image\": \"<bg-image>#\",\n \"background-origin\": \"<visual-box>#\",\n \"background-position\": \"<bg-position>#\",\n \"background-position-x\": \"[center|[[left|right|x-start|x-end]? <length-percentage>?]!]#\",\n \"background-position-y\": \"[center|[[top|bottom|y-start|y-end]? <length-percentage>?]!]#\",\n \"background-repeat\": \"<repeat-style>#\",\n \"background-size\": \"<bg-size>#\",\n \"baseline-shift\": \"baseline|sub|super|<svg-length>\",\n \"baseline-source\": \"auto|first|last\",\n \"block-size\": \"<'width'>\",\n \"border\": \"<line-width>||<line-style>||<color>\",\n \"border-block\": \"<'border-block-start'>\",\n \"border-block-color\": \"<'border-top-color'>{1,2}\",\n \"border-block-end\": \"<'border-top-width'>||<'border-top-style'>||<color>\",\n \"border-block-end-color\": \"<'border-top-color'>\",\n \"border-block-end-style\": \"<'border-top-style'>\",\n \"border-block-end-width\": \"<'border-top-width'>\",\n \"border-block-start\": \"<'border-top-width'>||<'border-top-style'>||<color>\",\n \"border-block-start-color\": \"<'border-top-color'>\",\n \"border-block-start-style\": \"<'border-top-style'>\",\n \"border-block-start-width\": \"<'border-top-width'>\",\n \"border-block-style\": \"<'border-top-style'>{1,2}\",\n \"border-block-width\": \"<'border-top-width'>{1,2}\",\n \"border-bottom\": \"<line-width>||<line-style>||<color>\",\n \"border-bottom-color\": \"<'border-top-color'>\",\n \"border-bottom-left-radius\": \"<length-percentage [0,∞]>{1,2}\",\n \"border-bottom-right-radius\": \"<length-percentage [0,∞]>{1,2}\",\n \"border-bottom-style\": \"<line-style>\",\n \"border-bottom-width\": \"<line-width>\",\n \"border-collapse\": \"separate|collapse\",\n \"border-color\": \"<color>{1,4}\",\n \"border-end-end-radius\": \"<'border-top-left-radius'>\",\n \"border-end-start-radius\": \"<'border-top-left-radius'>\",\n \"border-image\": \"<'border-image-source'>||<'border-image-slice'> [/ <'border-image-width'>|/ <'border-image-width'>? / <'border-image-outset'>]?||<'border-image-repeat'>\",\n \"border-image-outset\": \"[<length [0,∞]>|<number [0,∞]>]{1,4}\",\n \"border-image-repeat\": \"[stretch|repeat|round|space]{1,2}\",\n \"border-image-slice\": \"[<number [0,∞]>|<percentage [0,∞]>]{1,4}&&fill?\",\n \"border-image-source\": \"none|<image>\",\n \"border-image-width\": \"[<length-percentage [0,∞]>|<number [0,∞]>|auto]{1,4}\",\n \"border-inline\": \"<'border-block-start'>\",\n \"border-inline-color\": \"<'border-top-color'>{1,2}\",\n \"border-inline-end\": \"<'border-top-width'>||<'border-top-style'>||<color>\",\n \"border-inline-end-color\": \"<'border-top-color'>\",\n \"border-inline-end-style\": \"<'border-top-style'>\",\n \"border-inline-end-width\": \"<'border-top-width'>\",\n \"border-inline-start\": \"<'border-top-width'>||<'border-top-style'>||<color>\",\n \"border-inline-start-color\": \"<'border-top-color'>\",\n \"border-inline-start-style\": \"<'border-top-style'>\",\n \"border-inline-start-width\": \"<'border-top-width'>\",\n \"border-inline-style\": \"<'border-top-style'>{1,2}\",\n \"border-inline-width\": \"<'border-top-width'>{1,2}\",\n \"border-left\": \"<line-width>||<line-style>||<color>\",\n \"border-left-color\": \"<color>\",\n \"border-left-style\": \"<line-style>\",\n \"border-left-width\": \"<line-width>\",\n \"border-radius\": \"<length-percentage [0,∞]>{1,4} [/ <length-percentage [0,∞]>{1,4}]?\",\n \"border-right\": \"<line-width>||<line-style>||<color>\",\n \"border-right-color\": \"<color>\",\n \"border-right-style\": \"<line-style>\",\n \"border-right-width\": \"<line-width>\",\n \"border-spacing\": \"<length>{1,2}\",\n \"border-start-end-radius\": \"<'border-top-left-radius'>\",\n \"border-start-start-radius\": \"<'border-top-left-radius'>\",\n \"border-style\": \"<line-style>{1,4}\",\n \"border-top\": \"<line-width>||<line-style>||<color>\",\n \"border-top-color\": \"<color>\",\n \"border-top-left-radius\": \"<length-percentage [0,∞]>{1,2}\",\n \"border-top-right-radius\": \"<length-percentage [0,∞]>{1,2}\",\n \"border-top-style\": \"<line-style>\",\n \"border-top-width\": \"<line-width>\",\n \"border-width\": \"<line-width>{1,4}\",\n \"bottom\": \"auto|<length-percentage>|<anchor()>|<anchor-size()>\",\n \"box-align\": \"start|center|end|baseline|stretch\",\n \"box-decoration-break\": \"slice|clone\",\n \"box-direction\": \"normal|reverse|inherit\",\n \"box-flex\": \"<number>\",\n \"box-flex-group\": \"<integer>\",\n \"box-lines\": \"single|multiple\",\n \"box-ordinal-group\": \"<integer>\",\n \"box-orient\": \"horizontal|vertical|inline-axis|block-axis|inherit\",\n \"box-pack\": \"start|center|end|justify\",\n \"box-shadow\": \"none|<shadow>#\",\n \"box-sizing\": \"content-box|border-box\",\n \"break-after\": \"auto|avoid|always|all|avoid-page|page|left|right|recto|verso|avoid-column|column|avoid-region|region\",\n \"break-before\": \"auto|avoid|always|all|avoid-page|page|left|right|recto|verso|avoid-column|column|avoid-region|region\",\n \"break-inside\": \"auto|avoid|avoid-page|avoid-column|avoid-region\",\n \"caption-side\": \"top|bottom\",\n \"caret\": \"<'caret-color'>||<'caret-animation'>||<'caret-shape'>\",\n \"caret-animation\": \"auto|manual\",\n \"caret-color\": \"auto|<color>\",\n \"caret-shape\": \"auto|bar|block|underscore\",\n \"clear\": \"none|left|right|both|inline-start|inline-end\",\n \"clip\": \"<shape>|auto\",\n \"clip-path\": \"<clip-source>|[<basic-shape>||<geometry-box>]|none\",\n \"clip-rule\": \"nonzero|evenodd\",\n \"color\": \"<color>\",\n \"color-interpolation-filters\": \"auto|sRGB|linearRGB\",\n \"color-scheme\": \"normal|[light|dark|<custom-ident>]+&&only?\",\n \"column-count\": \"<integer>|auto\",\n \"column-fill\": \"auto|balance\",\n \"column-gap\": \"normal|<length-percentage>\",\n \"column-height\": \"auto|<length [0,∞]>\",\n \"column-rule\": \"<'column-rule-width'>||<'column-rule-style'>||<'column-rule-color'>\",\n \"column-rule-color\": \"<color>\",\n \"column-rule-style\": \"<'border-style'>\",\n \"column-rule-width\": \"<'border-width'>\",\n \"column-span\": \"none|all\",\n \"column-width\": \"auto|<length [0,∞]>\",\n \"column-wrap\": \"auto|nowrap|wrap\",\n \"columns\": \"[<'column-width'>||<'column-count'>] [/ <'column-height'>]?\",\n \"contain\": \"none|strict|content|[[size||inline-size]||layout||style||paint]\",\n \"contain-intrinsic-block-size\": \"auto? [none|<length>]\",\n \"contain-intrinsic-height\": \"auto? [none|<length>]\",\n \"contain-intrinsic-inline-size\": \"auto? [none|<length>]\",\n \"contain-intrinsic-size\": \"[auto? [none|<length>]]{1,2}\",\n \"contain-intrinsic-width\": \"auto? [none|<length>]\",\n \"container\": \"<'container-name'> [/ <'container-type'>]?\",\n \"container-name\": \"none|<custom-ident>+\",\n \"container-type\": \"normal||[size|inline-size]\",\n \"content\": \"normal|none|[<content-replacement>|<content-list>] [/ [<string>|<counter>|<attr()>]+]?\",\n \"content-visibility\": \"visible|auto|hidden\",\n \"corner-block-end-shape\": \"<corner-shape-value>{1,2}\",\n \"corner-block-start-shape\": \"<corner-shape-value>{1,2}\",\n \"corner-bottom-shape\": \"<corner-shape-value>{1,2}\",\n \"corner-bottom-left-shape\": \"<corner-shape-value>\",\n \"corner-bottom-right-shape\": \"<corner-shape-value>\",\n \"corner-end-end-shape\": \"<corner-shape-value>\",\n \"corner-end-start-shape\": \"<corner-shape-value>\",\n \"corner-inline-end-shape\": \"<corner-shape-value>{1,2}\",\n \"corner-inline-start-shape\": \"<corner-shape-value>{1,2}\",\n \"corner-left-shape\": \"<corner-shape-value>{1,2}\",\n \"corner-right-shape\": \"<corner-shape-value>{1,2}\",\n \"corner-shape\": \"<corner-shape-value>{1,4}\",\n \"corner-start-start-shape\": \"<corner-shape-value>\",\n \"corner-start-end-shape\": \"<corner-shape-value>\",\n \"corner-top-shape\": \"<corner-shape-value>{1,2}\",\n \"corner-top-left-shape\": \"<corner-shape-value>\",\n \"corner-top-right-shape\": \"<corner-shape-value>\",\n \"counter-increment\": \"[<counter-name> <integer>?]+|none\",\n \"counter-reset\": \"[<counter-name> <integer>?|<reversed-counter-name> <integer>?]+|none\",\n \"counter-set\": \"[<counter-name> <integer>?]+|none\",\n \"cursor\": \"[[<url> [<x> <y>]? ,]* [auto|default|none|context-menu|help|pointer|progress|wait|cell|crosshair|text|vertical-text|alias|copy|move|no-drop|not-allowed|e-resize|n-resize|ne-resize|nw-resize|s-resize|se-resize|sw-resize|w-resize|ew-resize|ns-resize|nesw-resize|nwse-resize|col-resize|row-resize|all-scroll|zoom-in|zoom-out|grab|grabbing|hand|-webkit-grab|-webkit-grabbing|-webkit-zoom-in|-webkit-zoom-out|-moz-grab|-moz-grabbing|-moz-zoom-in|-moz-zoom-out]]\",\n \"cx\": \"<length>|<percentage>\",\n \"cy\": \"<length>|<percentage>\",\n \"d\": \"none|path( <string> )\",\n \"direction\": \"ltr|rtl\",\n \"display\": \"[<display-outside>||<display-inside>]|<display-listitem>|<display-internal>|<display-box>|<display-legacy>|<-non-standard-display>\",\n \"dominant-baseline\": \"auto|use-script|no-change|reset-size|ideographic|alphabetic|hanging|mathematical|central|middle|text-after-edge|text-before-edge\",\n \"dynamic-range-limit\": \"standard|no-limit|constrained|<dynamic-range-limit-mix()>\",\n \"empty-cells\": \"show|hide\",\n \"field-sizing\": \"content|fixed\",\n \"fill\": \"<paint>\",\n \"fill-opacity\": \"<number-zero-one>|<percentage>\",\n \"fill-rule\": \"nonzero|evenodd\",\n \"filter\": \"none|<filter-value-list>|<-ms-filter-function-list>\",\n \"flex\": \"none|[<'flex-grow'> <'flex-shrink'>?||<'flex-basis'>]\",\n \"flex-basis\": \"content|<'width'>\",\n \"flex-direction\": \"row|row-reverse|column|column-reverse\",\n \"flex-flow\": \"<'flex-direction'>||<'flex-wrap'>\",\n \"flex-grow\": \"<number>\",\n \"flex-shrink\": \"<number>\",\n \"flex-wrap\": \"nowrap|wrap|wrap-reverse\",\n \"float\": \"left|right|none|inline-start|inline-end\",\n \"flood-color\": \"<color>\",\n \"flood-opacity\": \"<'opacity'>\",\n \"font\": \"[[<'font-style'>||<font-variant-css2>||<'font-weight'>||<font-width-css3>]? <'font-size'> [/ <'line-height'>]? <'font-family'>#]|<system-family-name>|<-non-standard-font>\",\n \"font-family\": \"[<family-name>|<generic-family>]#\",\n \"font-feature-settings\": \"normal|<feature-tag-value>#\",\n \"font-kerning\": \"auto|normal|none\",\n \"font-language-override\": \"normal|<string>\",\n \"font-optical-sizing\": \"auto|none\",\n \"font-palette\": \"normal|light|dark|<palette-identifier>|<palette-mix()>\",\n \"font-size\": \"<absolute-size>|<relative-size>|<length-percentage [0,∞]>|math\",\n \"font-size-adjust\": \"none|[ex-height|cap-height|ch-width|ic-width|ic-height]? [from-font|<number>]\",\n \"font-smooth\": \"auto|never|always|<absolute-size>|<length>\",\n \"font-stretch\": \"<font-stretch-absolute>\",\n \"font-style\": \"normal|italic|oblique <angle>?\",\n \"font-synthesis\": \"none|[weight||style||small-caps||position]\",\n \"font-synthesis-position\": \"auto|none\",\n \"font-synthesis-small-caps\": \"auto|none\",\n \"font-synthesis-style\": \"auto|none\",\n \"font-synthesis-weight\": \"auto|none\",\n \"font-variant\": \"normal|none|[<common-lig-values>||<discretionary-lig-values>||<historical-lig-values>||<contextual-alt-values>||stylistic( <feature-value-name> )||historical-forms||styleset( <feature-value-name># )||character-variant( <feature-value-name># )||swash( <feature-value-name> )||ornaments( <feature-value-name> )||annotation( <feature-value-name> )||[small-caps|all-small-caps|petite-caps|all-petite-caps|unicase|titling-caps]||<numeric-figure-values>||<numeric-spacing-values>||<numeric-fraction-values>||ordinal||slashed-zero||<east-asian-variant-values>||<east-asian-width-values>||ruby]\",\n \"font-variant-alternates\": \"normal|[stylistic( <feature-value-name> )||historical-forms||styleset( <feature-value-name># )||character-variant( <feature-value-name># )||swash( <feature-value-name> )||ornaments( <feature-value-name> )||annotation( <feature-value-name> )]\",\n \"font-variant-caps\": \"normal|small-caps|all-small-caps|petite-caps|all-petite-caps|unicase|titling-caps\",\n \"font-variant-east-asian\": \"normal|[<east-asian-variant-values>||<east-asian-width-values>||ruby]\",\n \"font-variant-emoji\": \"normal|text|emoji|unicode\",\n \"font-variant-ligatures\": \"normal|none|[<common-lig-values>||<discretionary-lig-values>||<historical-lig-values>||<contextual-alt-values>]\",\n \"font-variant-numeric\": \"normal|[<numeric-figure-values>||<numeric-spacing-values>||<numeric-fraction-values>||ordinal||slashed-zero]\",\n \"font-variant-position\": \"normal|sub|super\",\n \"font-variation-settings\": \"normal|[<string> <number>]#\",\n \"font-weight\": \"<font-weight-absolute>|bolder|lighter\",\n \"font-width\": \"normal|<percentage [0,∞]>|ultra-condensed|extra-condensed|condensed|semi-condensed|semi-expanded|expanded|extra-expanded|ultra-expanded\",\n \"forced-color-adjust\": \"auto|none|preserve-parent-color\",\n \"gap\": \"<'row-gap'> <'column-gap'>?\",\n \"grid\": \"<'grid-template'>|<'grid-template-rows'> / [auto-flow&&dense?] <'grid-auto-columns'>?|[auto-flow&&dense?] <'grid-auto-rows'>? / <'grid-template-columns'>\",\n \"grid-area\": \"<grid-line> [/ <grid-line>]{0,3}\",\n \"grid-auto-columns\": \"<track-size>+\",\n \"grid-auto-flow\": \"[row|column]||dense\",\n \"grid-auto-rows\": \"<track-size>+\",\n \"grid-column\": \"<grid-line> [/ <grid-line>]?\",\n \"grid-column-end\": \"<grid-line>\",\n \"grid-column-gap\": \"<length-percentage>\",\n \"grid-column-start\": \"<grid-line>\",\n \"grid-gap\": \"<'grid-row-gap'> <'grid-column-gap'>?\",\n \"grid-row\": \"<grid-line> [/ <grid-line>]?\",\n \"grid-row-end\": \"<grid-line>\",\n \"grid-row-gap\": \"<length-percentage>\",\n \"grid-row-start\": \"<grid-line>\",\n \"grid-template\": \"none|[<'grid-template-rows'> / <'grid-template-columns'>]|[<line-names>? <string> <track-size>? <line-names>?]+ [/ <explicit-track-list>]?\",\n \"grid-template-areas\": \"none|<string>+\",\n \"grid-template-columns\": \"none|<track-list>|<auto-track-list>|subgrid <line-name-list>?\",\n \"grid-template-rows\": \"none|<track-list>|<auto-track-list>|subgrid <line-name-list>?\",\n \"hanging-punctuation\": \"none|[first||[force-end|allow-end]||last]\",\n \"height\": \"auto|<length-percentage [0,∞]>|min-content|max-content|fit-content|fit-content( <length-percentage [0,∞]> )|<calc-size()>|<anchor-size()>|stretch|<-non-standard-size>\",\n \"hyphenate-character\": \"auto|<string>\",\n \"hyphenate-limit-chars\": \"[auto|<integer>]{1,3}\",\n \"hyphens\": \"none|manual|auto\",\n \"image-orientation\": \"from-image|<angle>|[<angle>? flip]\",\n \"image-rendering\": \"auto|crisp-edges|pixelated|smooth|optimizeSpeed|optimizeQuality|<-non-standard-image-rendering>\",\n \"image-resolution\": \"[from-image||<resolution>]&&snap?\",\n \"ime-mode\": \"auto|normal|active|inactive|disabled\",\n \"initial-letter\": \"normal|[<number> <integer>?]\",\n \"initial-letter-align\": \"[auto|alphabetic|hanging|ideographic]\",\n \"inline-size\": \"<'width'>\",\n \"inset\": \"<'top'>{1,4}\",\n \"inset-block\": \"<'top'>{1,2}\",\n \"inset-block-end\": \"<'top'>\",\n \"inset-block-start\": \"<'top'>\",\n \"inset-inline\": \"<'top'>{1,2}\",\n \"inset-inline-end\": \"<'top'>\",\n \"inset-inline-start\": \"<'top'>\",\n \"interpolate-size\": \"numeric-only|allow-keywords\",\n \"isolation\": \"auto|isolate\",\n \"interactivity\": \"auto|inert\",\n \"interest-delay\": \"<'interest-delay-start'>{1,2}\",\n \"interest-delay-end\": \"normal|<time>\",\n \"interest-delay-start\": \"normal|<time>\",\n \"justify-content\": \"normal|<content-distribution>|<overflow-position>? [<content-position>|left|right]\",\n \"justify-items\": \"normal|stretch|<baseline-position>|<overflow-position>? [<self-position>|left|right]|legacy|legacy&&[left|right|center]|anchor-center\",\n \"justify-self\": \"auto|normal|stretch|<baseline-position>|<overflow-position>? [<self-position>|left|right]|anchor-center\",\n \"justify-tracks\": \"[normal|<content-distribution>|<overflow-position>? [<content-position>|left|right]]#\",\n \"left\": \"auto|<length-percentage>|<anchor()>|<anchor-size()>\",\n \"letter-spacing\": \"normal|<length-percentage>\",\n \"lighting-color\": \"<color>\",\n \"line-break\": \"auto|loose|normal|strict|anywhere\",\n \"line-clamp\": \"none|<integer>\",\n \"line-height\": \"normal|<number>|<length>|<percentage>\",\n \"line-height-step\": \"<length>\",\n \"list-style\": \"<'list-style-type'>||<'list-style-position'>||<'list-style-image'>\",\n \"list-style-image\": \"<image>|none\",\n \"list-style-position\": \"inside|outside\",\n \"list-style-type\": \"<counter-style>|<string>|none\",\n \"margin\": \"<'margin-top'>{1,4}\",\n \"margin-block\": \"<'margin-top'>{1,2}\",\n \"margin-block-end\": \"<'margin-top'>\",\n \"margin-block-start\": \"<'margin-top'>\",\n \"margin-bottom\": \"<length-percentage>|auto|<anchor-size()>\",\n \"margin-inline\": \"<'margin-top'>{1,2}\",\n \"margin-inline-end\": \"<'margin-top'>\",\n \"margin-inline-start\": \"<'margin-top'>\",\n \"margin-left\": \"<length-percentage>|auto|<anchor-size()>\",\n \"margin-right\": \"<length-percentage>|auto|<anchor-size()>\",\n \"margin-top\": \"<length-percentage>|auto|<anchor-size()>\",\n \"margin-trim\": \"none|in-flow|all\",\n \"marker\": \"none|<url>\",\n \"marker-end\": \"none|<url>\",\n \"marker-mid\": \"none|<url>\",\n \"marker-start\": \"none|<url>\",\n \"mask\": \"<mask-layer>#\",\n \"mask-border\": \"<'mask-border-source'>||<'mask-border-slice'> [/ <'mask-border-width'>? [/ <'mask-border-outset'>]?]?||<'mask-border-repeat'>||<'mask-border-mode'>\",\n \"mask-border-mode\": \"luminance|alpha\",\n \"mask-border-outset\": \"[<length>|<number>]{1,4}\",\n \"mask-border-repeat\": \"[stretch|repeat|round|space]{1,2}\",\n \"mask-border-slice\": \"<number-percentage>{1,4} fill?\",\n \"mask-border-source\": \"none|<image>\",\n \"mask-border-width\": \"[<length-percentage>|<number>|auto]{1,4}\",\n \"mask-clip\": \"[<coord-box>|no-clip]#\",\n \"mask-composite\": \"<compositing-operator>#\",\n \"mask-image\": \"<mask-reference>#\",\n \"mask-mode\": \"<masking-mode>#\",\n \"mask-origin\": \"<coord-box>#\",\n \"mask-position\": \"<position>#\",\n \"mask-repeat\": \"<repeat-style>#\",\n \"mask-size\": \"<bg-size>#\",\n \"mask-type\": \"luminance|alpha\",\n \"masonry-auto-flow\": \"[pack|next]||[definite-first|ordered]\",\n \"math-depth\": \"auto-add|add( <integer> )|<integer>\",\n \"math-shift\": \"normal|compact\",\n \"math-style\": \"normal|compact\",\n \"max-block-size\": \"<'max-width'>\",\n \"max-height\": \"none|<length-percentage [0,∞]>|min-content|max-content|fit-content|fit-content( <length-percentage [0,∞]> )|<calc-size()>|<anchor-size()>|stretch|<-non-standard-size>\",\n \"max-inline-size\": \"<'max-width'>\",\n \"max-lines\": \"none|<integer>\",\n \"max-width\": \"none|<length-percentage [0,∞]>|min-content|max-content|fit-content|fit-content( <length-percentage [0,∞]> )|<calc-size()>|<anchor-size()>|stretch|<-non-standard-size>\",\n \"min-block-size\": \"<'min-width'>\",\n \"min-height\": \"auto|<length-percentage [0,∞]>|min-content|max-content|fit-content|fit-content( <length-percentage [0,∞]> )|<calc-size()>|<anchor-size()>|stretch|<-non-standard-size>\",\n \"min-inline-size\": \"<'min-width'>\",\n \"min-width\": \"auto|<length-percentage [0,∞]>|min-content|max-content|fit-content|fit-content( <length-percentage [0,∞]> )|<calc-size()>|<anchor-size()>|stretch|<-non-standard-size>\",\n \"mix-blend-mode\": \"<blend-mode>|plus-darker|plus-lighter\",\n \"object-fit\": \"fill|contain|cover|none|scale-down\",\n \"object-position\": \"<position>\",\n \"object-view-box\": \"none|<basic-shape-rect>\",\n \"offset\": \"[<'offset-position'>? [<'offset-path'> [<'offset-distance'>||<'offset-rotate'>]?]?]! [/ <'offset-anchor'>]?\",\n \"offset-anchor\": \"auto|<position>\",\n \"offset-distance\": \"<length-percentage>\",\n \"offset-path\": \"none|<offset-path>||<coord-box>\",\n \"offset-position\": \"normal|auto|<position>\",\n \"offset-rotate\": \"[auto|reverse]||<angle>\",\n \"opacity\": \"<opacity-value>\",\n \"order\": \"<integer>\",\n \"orphans\": \"<integer>\",\n \"outline\": \"<'outline-width'>||<'outline-style'>||<'outline-color'>\",\n \"outline-color\": \"auto|<color>\",\n \"outline-offset\": \"<length>\",\n \"outline-style\": \"auto|<outline-line-style>\",\n \"outline-width\": \"<line-width>\",\n \"overflow\": \"[visible|hidden|clip|scroll|auto]{1,2}|<-non-standard-overflow>\",\n \"overflow-anchor\": \"auto|none\",\n \"overflow-block\": \"visible|hidden|clip|scroll|auto|<-non-standard-overflow>\",\n \"overflow-clip-box\": \"padding-box|content-box\",\n \"overflow-clip-margin\": \"<visual-box>||<length [0,∞]>\",\n \"overflow-inline\": \"visible|hidden|clip|scroll|auto|<-non-standard-overflow>\",\n \"overflow-wrap\": \"normal|break-word|anywhere\",\n \"overflow-x\": \"visible|hidden|clip|scroll|auto|<-non-standard-overflow>\",\n \"overflow-y\": \"visible|hidden|clip|scroll|auto|<-non-standard-overflow>\",\n \"overlay\": \"none|auto\",\n \"overscroll-behavior\": \"[contain|none|auto]{1,2}\",\n \"overscroll-behavior-block\": \"contain|none|auto\",\n \"overscroll-behavior-inline\": \"contain|none|auto\",\n \"overscroll-behavior-x\": \"contain|none|auto\",\n \"overscroll-behavior-y\": \"contain|none|auto\",\n \"padding\": \"<'padding-top'>{1,4}\",\n \"padding-block\": \"<'padding-top'>{1,2}\",\n \"padding-block-end\": \"<'padding-top'>\",\n \"padding-block-start\": \"<'padding-top'>\",\n \"padding-bottom\": \"<length-percentage [0,∞]>\",\n \"padding-inline\": \"<'padding-top'>{1,2}\",\n \"padding-inline-end\": \"<'padding-top'>\",\n \"padding-inline-start\": \"<'padding-top'>\",\n \"padding-left\": \"<length-percentage [0,∞]>\",\n \"padding-right\": \"<length-percentage [0,∞]>\",\n \"padding-top\": \"<length-percentage [0,∞]>\",\n \"page\": \"auto|<custom-ident>\",\n \"page-break-after\": \"auto|always|avoid|left|right|recto|verso\",\n \"page-break-before\": \"auto|always|avoid|left|right|recto|verso\",\n \"page-break-inside\": \"auto|avoid\",\n \"paint-order\": \"normal|[fill||stroke||markers]\",\n \"perspective\": \"none|<length>\",\n \"perspective-origin\": \"<position>\",\n \"place-content\": \"<'align-content'> <'justify-content'>?\",\n \"place-items\": \"<'align-items'> <'justify-items'>?\",\n \"place-self\": \"<'align-self'> <'justify-self'>?\",\n \"pointer-events\": \"auto|none|visiblePainted|visibleFill|visibleStroke|visible|painted|fill|stroke|all|inherit\",\n \"position\": \"static|relative|absolute|sticky|fixed|-webkit-sticky\",\n \"position-anchor\": \"auto|none|<anchor-name>\",\n \"position-area\": \"none|<position-area>\",\n \"position-try\": \"<'position-try-order'>? <'position-try-fallbacks'>\",\n \"position-try-fallbacks\": \"none|[[<dashed-ident>||<try-tactic>]|<'position-area'>]#\",\n \"position-try-order\": \"normal|<try-size>\",\n \"position-visibility\": \"always|[anchors-valid||anchors-visible||no-overflow]\",\n \"print-color-adjust\": \"economy|exact\",\n \"quotes\": \"none|auto|[<string> <string>]+\",\n \"r\": \"<length>|<percentage>\",\n \"reading-flow\": \"normal|source-order|flex-visual|flex-flow|grid-rows|grid-columns|grid-order\",\n \"reading-order\": \"<integer>\",\n \"resize\": \"none|both|horizontal|vertical|block|inline\",\n \"right\": \"auto|<length-percentage>|<anchor()>|<anchor-size()>\",\n \"rotate\": \"none|<angle>|[x|y|z|<number>{3}]&&<angle>\",\n \"row-gap\": \"normal|<length-percentage>\",\n \"ruby-align\": \"start|center|space-between|space-around\",\n \"ruby-merge\": \"separate|collapse|auto\",\n \"ruby-overhang\": \"auto|none\",\n \"ruby-position\": \"[alternate||[over|under]]|inter-character\",\n \"rx\": \"<length>|<percentage>\",\n \"ry\": \"<length>|<percentage>\",\n \"scale\": \"none|[<number>|<percentage>]{1,3}\",\n \"scroll-behavior\": \"auto|smooth\",\n \"scroll-initial-target\": \"none|nearest\",\n \"scroll-margin\": \"<length>{1,4}\",\n \"scroll-margin-block\": \"<length>{1,2}\",\n \"scroll-margin-block-end\": \"<length>\",\n \"scroll-margin-block-start\": \"<length>\",\n \"scroll-margin-bottom\": \"<length>\",\n \"scroll-margin-inline\": \"<length>{1,2}\",\n \"scroll-margin-inline-end\": \"<length>\",\n \"scroll-margin-inline-start\": \"<length>\",\n \"scroll-margin-left\": \"<length>\",\n \"scroll-margin-right\": \"<length>\",\n \"scroll-margin-top\": \"<length>\",\n \"scroll-marker-group\": \"none|before|after\",\n \"scroll-padding\": \"[auto|<length-percentage>]{1,4}\",\n \"scroll-padding-block\": \"[auto|<length-percentage>]{1,2}\",\n \"scroll-padding-block-end\": \"auto|<length-percentage>\",\n \"scroll-padding-block-start\": \"auto|<length-percentage>\",\n \"scroll-padding-bottom\": \"auto|<length-percentage>\",\n \"scroll-padding-inline\": \"[auto|<length-percentage>]{1,2}\",\n \"scroll-padding-inline-end\": \"auto|<length-percentage>\",\n \"scroll-padding-inline-start\": \"auto|<length-percentage>\",\n \"scroll-padding-left\": \"auto|<length-percentage>\",\n \"scroll-padding-right\": \"auto|<length-percentage>\",\n \"scroll-padding-top\": \"auto|<length-percentage>\",\n \"scroll-snap-align\": \"[none|start|end|center]{1,2}\",\n \"scroll-snap-coordinate\": \"none|<position>#\",\n \"scroll-snap-destination\": \"<position>\",\n \"scroll-snap-points-x\": \"none|repeat( <length-percentage> )\",\n \"scroll-snap-points-y\": \"none|repeat( <length-percentage> )\",\n \"scroll-snap-stop\": \"normal|always\",\n \"scroll-snap-type\": \"none|[x|y|block|inline|both] [mandatory|proximity]?\",\n \"scroll-snap-type-x\": \"none|mandatory|proximity\",\n \"scroll-snap-type-y\": \"none|mandatory|proximity\",\n \"scroll-target-group\": \"none|auto\",\n \"scroll-timeline\": \"[<'scroll-timeline-name'> <'scroll-timeline-axis'>?]#\",\n \"scroll-timeline-axis\": \"[block|inline|x|y]#\",\n \"scroll-timeline-name\": \"[none|<dashed-ident>]#\",\n \"scrollbar-color\": \"auto|<color>{2}\",\n \"scrollbar-gutter\": \"auto|stable&&both-edges?\",\n \"scrollbar-width\": \"auto|thin|none\",\n \"shape-image-threshold\": \"<opacity-value>\",\n \"shape-margin\": \"<length-percentage>\",\n \"shape-outside\": \"none|[<shape-box>||<basic-shape>]|<image>\",\n \"shape-rendering\": \"auto|optimizeSpeed|crispEdges|geometricPrecision\",\n \"speak-as\": \"normal|spell-out||digits||[literal-punctuation|no-punctuation]\",\n \"stop-color\": \"<'color'>\",\n \"stop-opacity\": \"<'opacity'>\",\n \"stroke\": \"<paint>\",\n \"stroke-color\": \"<color>\",\n \"stroke-dasharray\": \"none|[<svg-length>+]#\",\n \"stroke-dashoffset\": \"<svg-length>\",\n \"stroke-linecap\": \"butt|round|square\",\n \"stroke-linejoin\": \"miter|round|bevel\",\n \"stroke-miterlimit\": \"<number-one-or-greater>\",\n \"stroke-opacity\": \"<'opacity'>\",\n \"stroke-width\": \"<svg-length>\",\n \"tab-size\": \"<integer>|<length>\",\n \"table-layout\": \"auto|fixed\",\n \"text-align\": \"start|end|left|right|center|justify|match-parent\",\n \"text-align-last\": \"auto|start|end|left|right|center|justify\",\n \"text-anchor\": \"start|middle|end\",\n \"text-autospace\": \"normal|<autospace>|auto\",\n \"text-box\": \"normal|<'text-box-trim'>||<'text-box-edge'>\",\n \"text-box-edge\": \"auto|<text-edge>\",\n \"text-box-trim\": \"none|trim-start|trim-end|trim-both\",\n \"text-combine-upright\": \"none|all|[digits <integer>?]\",\n \"text-decoration\": \"<'text-decoration-line'>||<'text-decoration-style'>||<'text-decoration-color'>||<'text-decoration-thickness'>\",\n \"text-decoration-color\": \"<color>\",\n \"text-decoration-inset\": \"<length>{1,2}|auto\",\n \"text-decoration-line\": \"none|[underline||overline||line-through||blink]|spelling-error|grammar-error\",\n \"text-decoration-skip\": \"none|[objects||[spaces|[leading-spaces||trailing-spaces]]||edges||box-decoration]\",\n \"text-decoration-skip-ink\": \"auto|all|none\",\n \"text-decoration-style\": \"solid|double|dotted|dashed|wavy\",\n \"text-decoration-thickness\": \"auto|from-font|<length>|<percentage>\",\n \"text-emphasis\": \"<'text-emphasis-style'>||<'text-emphasis-color'>\",\n \"text-emphasis-color\": \"<color>\",\n \"text-emphasis-position\": \"auto|[over|under]&&[right|left]?\",\n \"text-emphasis-style\": \"none|[[filled|open]||[dot|circle|double-circle|triangle|sesame]]|<string>\",\n \"text-indent\": \"<length-percentage>&&hanging?&&each-line?\",\n \"text-justify\": \"auto|inter-character|inter-word|none\",\n \"text-orientation\": \"mixed|upright|sideways\",\n \"text-overflow\": \"[clip|ellipsis|<string>]{1,2}\",\n \"text-rendering\": \"auto|optimizeSpeed|optimizeLegibility|geometricPrecision\",\n \"text-shadow\": \"none|<shadow-t>#\",\n \"text-size-adjust\": \"none|auto|<percentage>\",\n \"text-spacing-trim\": \"space-all|normal|space-first|trim-start\",\n \"text-transform\": \"none|[capitalize|uppercase|lowercase]||full-width||full-size-kana|math-auto\",\n \"text-underline-offset\": \"auto|<length>|<percentage>\",\n \"text-underline-position\": \"auto|from-font|[under||[left|right]]\",\n \"text-wrap\": \"<'text-wrap-mode'>||<'text-wrap-style'>\",\n \"text-wrap-mode\": \"wrap|nowrap\",\n \"text-wrap-style\": \"auto|balance|stable|pretty\",\n \"timeline-scope\": \"none|<dashed-ident>#\",\n \"timeline-trigger\": \"none|[<'timeline-trigger-name'> <'timeline-trigger-source'> <'timeline-trigger-range'> ['/' <'timeline-trigger-exit-range'>]?]#\",\n \"timeline-trigger-name\": \"none|<dashed-ident>#\",\n \"timeline-trigger-exit-range\": \"[<'timeline-trigger-exit-range-start'> <'timeline-trigger-exit-range-end'>?]#\",\n \"timeline-trigger-exit-range-end\": \"[auto|normal|<length-percentage>|<timeline-range-name> <length-percentage>?]#\",\n \"timeline-trigger-exit-range-start\": \"[auto|normal|<length-percentage>|<timeline-range-name> <length-percentage>?]#\",\n \"timeline-trigger-range\": \"[<'timeline-trigger-range-start'> <'timeline-trigger-range-end'>?]#\",\n \"timeline-trigger-range-end\": \"[normal|<length-percentage>|<timeline-range-name> <length-percentage>?]#\",\n \"timeline-trigger-range-start\": \"[normal|<length-percentage>|<timeline-range-name> <length-percentage>?]#\",\n \"timeline-trigger-source\": \"<single-animation-timeline>#\",\n \"top\": \"auto|<length-percentage>|<anchor()>|<anchor-size()>\",\n \"touch-action\": \"auto|none|[[pan-x|pan-left|pan-right]||[pan-y|pan-up|pan-down]||pinch-zoom]|manipulation\",\n \"transform\": \"none|<transform-list>\",\n \"transform-box\": \"content-box|border-box|fill-box|stroke-box|view-box\",\n \"transform-origin\": \"[<length-percentage>|left|center|right|top|bottom]|[[<length-percentage>|left|center|right]&&[<length-percentage>|top|center|bottom]] <length>?\",\n \"transform-style\": \"flat|preserve-3d\",\n \"transition\": \"<single-transition>#\",\n \"transition-behavior\": \"<transition-behavior-value>#\",\n \"transition-delay\": \"<time>#\",\n \"transition-duration\": \"<time>#\",\n \"transition-property\": \"none|<single-transition-property>#\",\n \"transition-timing-function\": \"<easing-function>#\",\n \"translate\": \"none|<length-percentage> [<length-percentage> <length>?]?\",\n \"trigger-scope\": \"none|all|<dashed-ident>#\",\n \"unicode-bidi\": \"normal|embed|isolate|bidi-override|isolate-override|plaintext|-moz-isolate|-moz-isolate-override|-moz-plaintext|-webkit-isolate|-webkit-isolate-override|-webkit-plaintext\",\n \"user-select\": \"auto|text|none|all\",\n \"vector-effect\": \"none|non-scaling-stroke|non-scaling-size|non-rotation|fixed-position\",\n \"vertical-align\": \"baseline|sub|super|text-top|text-bottom|middle|top|bottom|<percentage>|<length>\",\n \"view-timeline\": \"[<'view-timeline-name'> [<'view-timeline-axis'>||<'view-timeline-inset'>]?]#\",\n \"view-timeline-axis\": \"[block|inline|x|y]#\",\n \"view-timeline-inset\": \"[[auto|<length-percentage>]{1,2}]#\",\n \"view-timeline-name\": \"[none|<dashed-ident>]#\",\n \"view-transition-class\": \"none|<custom-ident>+\",\n \"view-transition-name\": \"none|<custom-ident>|match-element\",\n \"visibility\": \"visible|hidden|collapse\",\n \"white-space\": \"normal|pre|pre-wrap|pre-line|<'white-space-collapse'>||<'text-wrap-mode'>\",\n \"white-space-collapse\": \"collapse|preserve|preserve-breaks|preserve-spaces|break-spaces\",\n \"widows\": \"<integer>\",\n \"width\": \"auto|<length-percentage [0,∞]>|min-content|max-content|fit-content|fit-content( <length-percentage [0,∞]> )|<calc-size()>|<anchor-size()>|stretch|<-non-standard-size>\",\n \"will-change\": \"auto|<animateable-feature>#\",\n \"word-break\": \"normal|break-all|keep-all|break-word|auto-phrase\",\n \"word-spacing\": \"normal|<length>\",\n \"word-wrap\": \"normal|break-word\",\n \"writing-mode\": \"horizontal-tb|vertical-rl|vertical-lr|sideways-rl|sideways-lr|<svg-writing-mode>\",\n \"x\": \"<length>|<percentage>\",\n \"y\": \"<length>|<percentage>\",\n \"z-index\": \"auto|<integer>\",\n \"zoom\": \"normal|reset|<number [0,∞]>||<percentage [0,∞]>\",\n \"-moz-background-clip\": \"padding|border\",\n \"-moz-border-radius-bottomleft\": \"<'border-bottom-left-radius'>\",\n \"-moz-border-radius-bottomright\": \"<'border-bottom-right-radius'>\",\n \"-moz-border-radius-topleft\": \"<'border-top-left-radius'>\",\n \"-moz-border-radius-topright\": \"<'border-bottom-right-radius'>\",\n \"-moz-control-character-visibility\": \"visible|hidden\",\n \"-moz-osx-font-smoothing\": \"auto|grayscale\",\n \"-moz-user-select\": \"none|text|all|-moz-none\",\n \"-ms-flex-align\": \"start|end|center|baseline|stretch\",\n \"-ms-flex-item-align\": \"auto|start|end|center|baseline|stretch\",\n \"-ms-flex-line-pack\": \"start|end|center|justify|distribute|stretch\",\n \"-ms-flex-negative\": \"<'flex-shrink'>\",\n \"-ms-flex-pack\": \"start|end|center|justify|distribute\",\n \"-ms-flex-order\": \"<integer>\",\n \"-ms-flex-positive\": \"<'flex-grow'>\",\n \"-ms-flex-preferred-size\": \"<'flex-basis'>\",\n \"-ms-interpolation-mode\": \"nearest-neighbor|bicubic\",\n \"-ms-grid-column-align\": \"start|end|center|stretch\",\n \"-ms-grid-row-align\": \"start|end|center|stretch\",\n \"-ms-hyphenate-limit-last\": \"none|always|column|page|spread\",\n \"-webkit-background-clip\": \"[<visual-box>|border|padding|content|text]#\",\n \"-webkit-column-break-after\": \"always|auto|avoid\",\n \"-webkit-column-break-before\": \"always|auto|avoid\",\n \"-webkit-column-break-inside\": \"always|auto|avoid\",\n \"-webkit-font-smoothing\": \"auto|none|antialiased|subpixel-antialiased\",\n \"-webkit-mask-box-image\": \"[<url>|<gradient>|none] [<length-percentage>{4} <-webkit-mask-box-repeat>{2}]?\",\n \"-webkit-print-color-adjust\": \"economy|exact\",\n \"-webkit-text-security\": \"none|circle|disc|square\",\n \"-webkit-user-drag\": \"none|element|auto\",\n \"behavior\": \"<url>+\",\n \"cue\": \"<'cue-before'> <'cue-after'>?\",\n \"cue-after\": \"<url> <decibel>?|none\",\n \"cue-before\": \"<url> <decibel>?|none\",\n \"glyph-orientation-horizontal\": \"<angle>\",\n \"glyph-orientation-vertical\": \"<angle>\",\n \"kerning\": \"auto|<svg-length>\",\n \"pause\": \"<'pause-before'> <'pause-after'>?\",\n \"pause-after\": \"<time>|none|x-weak|weak|medium|strong|x-strong\",\n \"pause-before\": \"<time>|none|x-weak|weak|medium|strong|x-strong\",\n \"position-try-options\": \"<'position-try-fallbacks'>\",\n \"rest\": \"<'rest-before'> <'rest-after'>?\",\n \"rest-after\": \"<time>|none|x-weak|weak|medium|strong|x-strong\",\n \"rest-before\": \"<time>|none|x-weak|weak|medium|strong|x-strong\",\n \"speak\": \"auto|never|always\",\n \"voice-balance\": \"<number>|left|center|right|leftwards|rightwards\",\n \"voice-duration\": \"auto|<time>\",\n \"voice-family\": \"[[<family-name>|<generic-voice>] ,]* [<family-name>|<generic-voice>]|preserve\",\n \"voice-pitch\": \"<frequency>&&absolute|[[x-low|low|medium|high|x-high]||[<frequency>|<semitones>|<percentage>]]\",\n \"voice-range\": \"<frequency>&&absolute|[[x-low|low|medium|high|x-high]||[<frequency>|<semitones>|<percentage>]]\",\n \"voice-rate\": \"[normal|x-slow|slow|medium|fast|x-fast]||<percentage>\",\n \"voice-stress\": \"normal|strong|moderate|none|reduced\",\n \"voice-volume\": \"silent|[[x-soft|soft|medium|loud|x-loud]||<decibel>]\",\n \"white-space-trim\": \"none|discard-before||discard-after||discard-inner\"\n },\n \"atrules\": {\n \"charset\": {\n \"prelude\": \"<string>\",\n \"descriptors\": null\n },\n \"counter-style\": {\n \"prelude\": \"<counter-style-name>\",\n \"descriptors\": {\n \"additive-symbols\": \"[<integer [0,∞]>&&<symbol>]#\",\n \"fallback\": \"<counter-style-name>\",\n \"negative\": \"<symbol> <symbol>?\",\n \"pad\": \"<integer [0,∞]>&&<symbol>\",\n \"prefix\": \"<symbol>\",\n \"range\": \"[[<integer>|infinite]{2}]#|auto\",\n \"speak-as\": \"auto|bullets|numbers|words|spell-out|<counter-style-name>\",\n \"suffix\": \"<symbol>\",\n \"symbols\": \"<symbol>+\",\n \"system\": \"cyclic|numeric|alphabetic|symbolic|additive|[fixed <integer>?]|[extends <counter-style-name>]\"\n }\n },\n \"container\": {\n \"prelude\": \"[<container-name>]? <container-condition>\",\n \"descriptors\": null\n },\n \"document\": {\n \"prelude\": \"[<url>|url-prefix( <string> )|domain( <string> )|media-document( <string> )|regexp( <string> )]#\",\n \"descriptors\": null\n },\n \"font-face\": {\n \"prelude\": null,\n \"descriptors\": {\n \"ascent-override\": \"normal|<percentage>\",\n \"descent-override\": \"normal|<percentage>\",\n \"font-display\": \"auto|block|swap|fallback|optional\",\n \"font-family\": \"<family-name>\",\n \"font-feature-settings\": \"normal|<feature-tag-value>#\",\n \"font-stretch\": \"<font-stretch-absolute>{1,2}\",\n \"font-style\": \"normal|italic|oblique <angle>{0,2}\",\n \"font-variation-settings\": \"normal|[<string> <number>]#\",\n \"font-weight\": \"<font-weight-absolute>{1,2}\",\n \"line-gap-override\": \"normal|<percentage>\",\n \"size-adjust\": \"<percentage>\",\n \"src\": \"[<url> [format( <string># )]?|local( <family-name> )]#\",\n \"unicode-range\": \"<urange>#\"\n }\n },\n \"font-feature-values\": {\n \"prelude\": \"<family-name>#\",\n \"descriptors\": null\n },\n \"font-palette-values\": {\n \"prelude\": \"<dashed-ident>\",\n \"descriptors\": {\n \"base-palette\": \"light|dark|<integer [0,∞]>\",\n \"font-family\": \"<family-name>#\",\n \"override-colors\": \"[<integer [0,∞]> <color>]#\"\n }\n },\n \"import\": {\n \"prelude\": \"[<string>|<url>] [layer|layer( <layer-name> )]? [supports( [<supports-condition>|<declaration>] )]? <media-query-list>?\",\n \"descriptors\": null\n },\n \"keyframes\": {\n \"prelude\": \"<keyframes-name>\",\n \"descriptors\": null\n },\n \"layer\": {\n \"prelude\": \"[<layer-name>#|<layer-name>?]\",\n \"descriptors\": null\n },\n \"media\": {\n \"prelude\": \"<media-query-list>\",\n \"descriptors\": null\n },\n \"namespace\": {\n \"prelude\": \"<namespace-prefix>? [<string>|<url>]\",\n \"descriptors\": null\n },\n \"page\": {\n \"prelude\": \"<page-selector-list>\",\n \"descriptors\": {\n \"bleed\": \"auto|<length>\",\n \"marks\": \"none|[crop||cross]\",\n \"page-orientation\": \"upright|rotate-left|rotate-right\",\n \"size\": \"<length [0,∞]>{1,2}|auto|[<page-size>||[portrait|landscape]]\"\n }\n },\n \"position-try\": {\n \"prelude\": \"<dashed-ident>\",\n \"descriptors\": {\n \"top\": \"<'top'>\",\n \"left\": \"<'left'>\",\n \"bottom\": \"<'bottom'>\",\n \"right\": \"<'right'>\",\n \"inset-block-start\": \"<'inset-block-start'>\",\n \"inset-block-end\": \"<'inset-block-end'>\",\n \"inset-inline-start\": \"<'inset-inline-start'>\",\n \"inset-inline-end\": \"<'inset-inline-end'>\",\n \"inset-block\": \"<'inset-block'>\",\n \"inset-inline\": \"<'inset-inline'>\",\n \"inset\": \"<'inset'>\",\n \"margin-top\": \"<'margin-top'>\",\n \"margin-left\": \"<'margin-left'>\",\n \"margin-bottom\": \"<'margin-bottom'>\",\n \"margin-right\": \"<'margin-right'>\",\n \"margin-block-start\": \"<'margin-block-start'>\",\n \"margin-block-end\": \"<'margin-block-end'>\",\n \"margin-inline-start\": \"<'margin-inline-start'>\",\n \"margin-inline-end\": \"<'margin-inline-end'>\",\n \"margin\": \"<'margin'>\",\n \"margin-block\": \"<'margin-block'>\",\n \"margin-inline\": \"<'margin-inline'>\",\n \"width\": \"<'width'>\",\n \"height\": \"<'height'>\",\n \"min-width\": \"<'min-width'>\",\n \"min-height\": \"<'min-height'>\",\n \"max-width\": \"<'max-width'>\",\n \"max-height\": \"<'max-height'>\",\n \"block-size\": \"<'block-size'>\",\n \"inline-size\": \"<'inline-size'>\",\n \"min-block-size\": \"<'min-block-size'>\",\n \"min-inline-size\": \"<'min-inline-size'>\",\n \"max-block-size\": \"<'max-block-size'>\",\n \"max-inline-size\": \"<'max-inline-size'>\",\n \"align-self\": \"<'align-self'>|anchor-center\",\n \"justify-self\": \"<'justify-self'>|anchor-center\"\n }\n },\n \"property\": {\n \"prelude\": \"<custom-property-name>\",\n \"descriptors\": {\n \"inherits\": \"true|false\",\n \"initial-value\": \"<declaration-value>?\",\n \"syntax\": \"<string>\"\n }\n },\n \"scope\": {\n \"prelude\": \"[( <scope-start> )]? [to ( <scope-end> )]?\",\n \"descriptors\": null\n },\n \"starting-style\": {\n \"prelude\": null,\n \"descriptors\": null\n },\n \"supports\": {\n \"prelude\": \"<supports-condition>\",\n \"descriptors\": null\n },\n \"view-transition\": {\n \"prelude\": null,\n \"descriptors\": {\n \"navigation\": \"auto|none\",\n \"types\": \"none|<custom-ident>+\"\n }\n },\n \"font-features-values\": {\n \"prelude\": \"[<string>|<custom-ident>]+\",\n \"descriptors\": {\n \"font-display\": \"auto|block|swap|fallback|optional\"\n }\n }\n }\n};","import {\n isDigit,\n WhiteSpace,\n Comment,\n Ident,\n Number,\n Dimension\n} from '../../tokenizer/index.js';\n\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)\nconst N = 0x006E; // U+006E LATIN SMALL LETTER N (n)\nconst DISALLOW_SIGN = true;\nconst ALLOW_SIGN = false;\n\nfunction checkInteger(offset, disallowSign) {\n let pos = this.tokenStart + offset;\n const code = this.charCodeAt(pos);\n\n if (code === PLUSSIGN || code === HYPHENMINUS) {\n if (disallowSign) {\n this.error('Number sign is not allowed');\n }\n pos++;\n }\n\n for (; pos < this.tokenEnd; pos++) {\n if (!isDigit(this.charCodeAt(pos))) {\n this.error('Integer is expected', pos);\n }\n }\n}\n\nfunction checkTokenIsInteger(disallowSign) {\n return checkInteger.call(this, 0, disallowSign);\n}\n\nfunction expectCharCode(offset, code) {\n if (!this.cmpChar(this.tokenStart + offset, code)) {\n let msg = '';\n\n switch (code) {\n case N:\n msg = 'N is expected';\n break;\n case HYPHENMINUS:\n msg = 'HyphenMinus is expected';\n break;\n }\n\n this.error(msg, this.tokenStart + offset);\n }\n}\n\n// ... <signed-integer>\n// ... ['+' | '-'] <signless-integer>\nfunction consumeB() {\n let offset = 0;\n let sign = 0;\n let type = this.tokenType;\n\n while (type === WhiteSpace || type === Comment) {\n type = this.lookupType(++offset);\n }\n\n if (type !== Number) {\n if (this.isDelim(PLUSSIGN, offset) ||\n this.isDelim(HYPHENMINUS, offset)) {\n sign = this.isDelim(PLUSSIGN, offset) ? PLUSSIGN : HYPHENMINUS;\n\n do {\n type = this.lookupType(++offset);\n } while (type === WhiteSpace || type === Comment);\n\n if (type !== Number) {\n this.skip(offset);\n checkTokenIsInteger.call(this, DISALLOW_SIGN);\n }\n } else {\n return null;\n }\n }\n\n if (offset > 0) {\n this.skip(offset);\n }\n\n if (sign === 0) {\n type = this.charCodeAt(this.tokenStart);\n if (type !== PLUSSIGN && type !== HYPHENMINUS) {\n this.error('Number sign is expected');\n }\n }\n\n checkTokenIsInteger.call(this, sign !== 0);\n return sign === HYPHENMINUS ? '-' + this.consume(Number) : this.consume(Number);\n}\n\n// An+B microsyntax https://www.w3.org/TR/css-syntax-3/#anb\nexport const name = 'AnPlusB';\nexport const structure = {\n a: [String, null],\n b: [String, null]\n};\n\nexport function parse() {\n /* eslint-disable brace-style*/\n const start = this.tokenStart;\n let a = null;\n let b = null;\n\n // <integer>\n if (this.tokenType === Number) {\n checkTokenIsInteger.call(this, ALLOW_SIGN);\n b = this.consume(Number);\n }\n\n // -n\n // -n <signed-integer>\n // -n ['+' | '-'] <signless-integer>\n // -n- <signless-integer>\n // <dashndashdigit-ident>\n else if (this.tokenType === Ident && this.cmpChar(this.tokenStart, HYPHENMINUS)) {\n a = '-1';\n\n expectCharCode.call(this, 1, N);\n\n switch (this.tokenEnd - this.tokenStart) {\n // -n\n // -n <signed-integer>\n // -n ['+' | '-'] <signless-integer>\n case 2:\n this.next();\n b = consumeB.call(this);\n break;\n\n // -n- <signless-integer>\n case 3:\n expectCharCode.call(this, 2, HYPHENMINUS);\n\n this.next();\n this.skipSC();\n\n checkTokenIsInteger.call(this, DISALLOW_SIGN);\n\n b = '-' + this.consume(Number);\n break;\n\n // <dashndashdigit-ident>\n default:\n expectCharCode.call(this, 2, HYPHENMINUS);\n checkInteger.call(this, 3, DISALLOW_SIGN);\n this.next();\n\n b = this.substrToCursor(start + 2);\n }\n }\n\n // '+'? n\n // '+'? n <signed-integer>\n // '+'? n ['+' | '-'] <signless-integer>\n // '+'? n- <signless-integer>\n // '+'? <ndashdigit-ident>\n else if (this.tokenType === Ident || (this.isDelim(PLUSSIGN) && this.lookupType(1) === Ident)) {\n let sign = 0;\n a = '1';\n\n // just ignore a plus\n if (this.isDelim(PLUSSIGN)) {\n sign = 1;\n this.next();\n }\n\n expectCharCode.call(this, 0, N);\n\n switch (this.tokenEnd - this.tokenStart) {\n // '+'? n\n // '+'? n <signed-integer>\n // '+'? n ['+' | '-'] <signless-integer>\n case 1:\n this.next();\n b = consumeB.call(this);\n break;\n\n // '+'? n- <signless-integer>\n case 2:\n expectCharCode.call(this, 1, HYPHENMINUS);\n\n this.next();\n this.skipSC();\n\n checkTokenIsInteger.call(this, DISALLOW_SIGN);\n\n b = '-' + this.consume(Number);\n break;\n\n // '+'? <ndashdigit-ident>\n default:\n expectCharCode.call(this, 1, HYPHENMINUS);\n checkInteger.call(this, 2, DISALLOW_SIGN);\n this.next();\n\n b = this.substrToCursor(start + sign + 1);\n }\n }\n\n // <ndashdigit-dimension>\n // <ndash-dimension> <signless-integer>\n // <n-dimension>\n // <n-dimension> <signed-integer>\n // <n-dimension> ['+' | '-'] <signless-integer>\n else if (this.tokenType === Dimension) {\n const code = this.charCodeAt(this.tokenStart);\n const sign = code === PLUSSIGN || code === HYPHENMINUS;\n let i = this.tokenStart + sign;\n\n for (; i < this.tokenEnd; i++) {\n if (!isDigit(this.charCodeAt(i))) {\n break;\n }\n }\n\n if (i === this.tokenStart + sign) {\n this.error('Integer is expected', this.tokenStart + sign);\n }\n\n expectCharCode.call(this, i - this.tokenStart, N);\n a = this.substring(start, i);\n\n // <n-dimension>\n // <n-dimension> <signed-integer>\n // <n-dimension> ['+' | '-'] <signless-integer>\n if (i + 1 === this.tokenEnd) {\n this.next();\n b = consumeB.call(this);\n } else {\n expectCharCode.call(this, i - this.tokenStart + 1, HYPHENMINUS);\n\n // <ndash-dimension> <signless-integer>\n if (i + 2 === this.tokenEnd) {\n this.next();\n this.skipSC();\n checkTokenIsInteger.call(this, DISALLOW_SIGN);\n b = '-' + this.consume(Number);\n }\n // <ndashdigit-dimension>\n else {\n checkInteger.call(this, i - this.tokenStart + 2, DISALLOW_SIGN);\n this.next();\n b = this.substrToCursor(i + 1);\n }\n }\n } else {\n this.error();\n }\n\n if (a !== null && a.charCodeAt(0) === PLUSSIGN) {\n a = a.substr(1);\n }\n\n if (b !== null && b.charCodeAt(0) === PLUSSIGN) {\n b = b.substr(1);\n }\n\n return {\n type: 'AnPlusB',\n loc: this.getLocation(start, this.tokenStart),\n a,\n b\n };\n}\n\nexport function generate(node) {\n if (node.a) {\n const a =\n node.a === '+1' && 'n' ||\n node.a === '1' && 'n' ||\n node.a === '-1' && '-n' ||\n node.a + 'n';\n\n if (node.b) {\n const b = node.b[0] === '-' || node.b[0] === '+'\n ? node.b\n : '+' + node.b;\n this.tokenize(a + b);\n } else {\n this.tokenize(a);\n }\n } else {\n this.tokenize(node.b);\n }\n}\n","import {\n AtKeyword,\n Semicolon,\n LeftCurlyBracket,\n RightCurlyBracket\n} from '../../tokenizer/index.js';\n\nfunction consumeRaw() {\n return this.Raw(this.consumeUntilLeftCurlyBracketOrSemicolon, true);\n}\n\nfunction isDeclarationBlockAtrule() {\n for (let offset = 1, type; type = this.lookupType(offset); offset++) {\n if (type === RightCurlyBracket) {\n return true;\n }\n\n if (type === LeftCurlyBracket ||\n type === AtKeyword) {\n return false;\n }\n }\n\n return false;\n}\n\n\nexport const name = 'Atrule';\nexport const walkContext = 'atrule';\nexport const structure = {\n name: String,\n prelude: ['AtrulePrelude', 'Raw', null],\n block: ['Block', null]\n};\n\nexport function parse(isDeclaration = false) {\n const start = this.tokenStart;\n let name;\n let nameLowerCase;\n let prelude = null;\n let block = null;\n\n this.eat(AtKeyword);\n\n name = this.substrToCursor(start + 1);\n nameLowerCase = name.toLowerCase();\n this.skipSC();\n\n // parse prelude\n if (this.eof === false &&\n this.tokenType !== LeftCurlyBracket &&\n this.tokenType !== Semicolon) {\n if (this.parseAtrulePrelude) {\n prelude = this.parseWithFallback(this.AtrulePrelude.bind(this, name, isDeclaration), consumeRaw);\n } else {\n prelude = consumeRaw.call(this, this.tokenIndex);\n }\n\n this.skipSC();\n }\n\n switch (this.tokenType) {\n case Semicolon:\n this.next();\n break;\n\n case LeftCurlyBracket:\n if (hasOwnProperty.call(this.atrule, nameLowerCase) &&\n typeof this.atrule[nameLowerCase].block === 'function') {\n block = this.atrule[nameLowerCase].block.call(this, isDeclaration);\n } else {\n // TODO: should consume block content as Raw?\n block = this.Block(isDeclarationBlockAtrule.call(this));\n }\n\n break;\n }\n\n return {\n type: 'Atrule',\n loc: this.getLocation(start, this.tokenStart),\n name,\n prelude,\n block\n };\n}\n\nexport function generate(node) {\n this.token(AtKeyword, '@' + node.name);\n\n if (node.prelude !== null) {\n this.node(node.prelude);\n }\n\n if (node.block) {\n this.node(node.block);\n } else {\n this.token(Semicolon, ';');\n }\n}\n","import {\n Semicolon,\n LeftCurlyBracket\n} from '../../tokenizer/index.js';\n\nexport const name = 'AtrulePrelude';\nexport const walkContext = 'atrulePrelude';\nexport const structure = {\n children: [[]]\n};\n\nexport function parse(name) {\n let children = null;\n\n if (name !== null) {\n name = name.toLowerCase();\n }\n\n this.skipSC();\n\n if (hasOwnProperty.call(this.atrule, name) &&\n typeof this.atrule[name].prelude === 'function') {\n // custom consumer\n children = this.atrule[name].prelude.call(this);\n } else {\n // default consumer\n children = this.readSequence(this.scope.AtrulePrelude);\n }\n\n this.skipSC();\n\n if (this.eof !== true &&\n this.tokenType !== LeftCurlyBracket &&\n this.tokenType !== Semicolon) {\n this.error('Semicolon or block is expected');\n }\n\n return {\n type: 'AtrulePrelude',\n loc: this.getLocationFromList(children),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node);\n}\n","import {\n Ident,\n String as StringToken,\n Delim,\n LeftSquareBracket,\n RightSquareBracket\n} from '../../tokenizer/index.js';\n\nconst DOLLARSIGN = 0x0024; // U+0024 DOLLAR SIGN ($)\nconst ASTERISK = 0x002A; // U+002A ASTERISK (*)\nconst EQUALSSIGN = 0x003D; // U+003D EQUALS SIGN (=)\nconst CIRCUMFLEXACCENT = 0x005E; // U+005E (^)\nconst VERTICALLINE = 0x007C; // U+007C VERTICAL LINE (|)\nconst TILDE = 0x007E; // U+007E TILDE (~)\n\nfunction getAttributeName() {\n if (this.eof) {\n this.error('Unexpected end of input');\n }\n\n const start = this.tokenStart;\n let expectIdent = false;\n\n if (this.isDelim(ASTERISK)) {\n expectIdent = true;\n this.next();\n } else if (!this.isDelim(VERTICALLINE)) {\n this.eat(Ident);\n }\n\n if (this.isDelim(VERTICALLINE)) {\n if (this.charCodeAt(this.tokenStart + 1) !== EQUALSSIGN) {\n this.next();\n this.eat(Ident);\n } else if (expectIdent) {\n this.error('Identifier is expected', this.tokenEnd);\n }\n } else if (expectIdent) {\n this.error('Vertical line is expected');\n }\n\n return {\n type: 'Identifier',\n loc: this.getLocation(start, this.tokenStart),\n name: this.substrToCursor(start)\n };\n}\n\nfunction getOperator() {\n const start = this.tokenStart;\n const code = this.charCodeAt(start);\n\n if (code !== EQUALSSIGN && // =\n code !== TILDE && // ~=\n code !== CIRCUMFLEXACCENT && // ^=\n code !== DOLLARSIGN && // $=\n code !== ASTERISK && // *=\n code !== VERTICALLINE // |=\n ) {\n this.error('Attribute selector (=, ~=, ^=, $=, *=, |=) is expected');\n }\n\n this.next();\n\n if (code !== EQUALSSIGN) {\n if (!this.isDelim(EQUALSSIGN)) {\n this.error('Equal sign is expected');\n }\n\n this.next();\n }\n\n return this.substrToCursor(start);\n}\n\n// '[' <wq-name> ']'\n// '[' <wq-name> <attr-matcher> [ <string-token> | <ident-token> ] <attr-modifier>? ']'\nexport const name = 'AttributeSelector';\nexport const structure = {\n name: 'Identifier',\n matcher: [String, null],\n value: ['String', 'Identifier', null],\n flags: [String, null]\n};\n\nexport function parse() {\n const start = this.tokenStart;\n let name;\n let matcher = null;\n let value = null;\n let flags = null;\n\n this.eat(LeftSquareBracket);\n this.skipSC();\n\n name = getAttributeName.call(this);\n this.skipSC();\n\n if (this.tokenType !== RightSquareBracket) {\n // avoid case `[name i]`\n if (this.tokenType !== Ident) {\n matcher = getOperator.call(this);\n\n this.skipSC();\n\n value = this.tokenType === StringToken\n ? this.String()\n : this.Identifier();\n\n this.skipSC();\n }\n\n // attribute flags\n if (this.tokenType === Ident) {\n flags = this.consume(Ident);\n\n this.skipSC();\n }\n }\n\n this.eat(RightSquareBracket);\n\n return {\n type: 'AttributeSelector',\n loc: this.getLocation(start, this.tokenStart),\n name,\n matcher,\n value,\n flags\n };\n}\n\nexport function generate(node) {\n this.token(Delim, '[');\n this.node(node.name);\n\n if (node.matcher !== null) {\n this.tokenize(node.matcher);\n this.node(node.value);\n }\n\n if (node.flags !== null) {\n this.token(Ident, node.flags);\n }\n\n this.token(Delim, ']');\n}\n","import {\n WhiteSpace,\n Comment,\n Semicolon,\n AtKeyword,\n LeftCurlyBracket,\n RightCurlyBracket\n} from '../../tokenizer/index.js';\n\nconst AMPERSAND = 0x0026; // U+0026 AMPERSAND (&)\n\nfunction consumeRaw() {\n return this.Raw(null, true);\n}\nfunction consumeRule() {\n return this.parseWithFallback(this.Rule, consumeRaw);\n}\nfunction consumeRawDeclaration() {\n return this.Raw(this.consumeUntilSemicolonIncluded, true);\n}\nfunction consumeDeclaration() {\n if (this.tokenType === Semicolon) {\n return consumeRawDeclaration.call(this, this.tokenIndex);\n }\n\n const node = this.parseWithFallback(this.Declaration, consumeRawDeclaration);\n\n if (this.tokenType === Semicolon) {\n this.next();\n }\n\n return node;\n}\n\nexport const name = 'Block';\nexport const walkContext = 'block';\nexport const structure = {\n children: [[\n 'Atrule',\n 'Rule',\n 'Declaration'\n ]]\n};\n\nexport function parse(isStyleBlock) {\n const consumer = isStyleBlock ? consumeDeclaration : consumeRule;\n const start = this.tokenStart;\n let children = this.createList();\n\n this.eat(LeftCurlyBracket);\n\n scan:\n while (!this.eof) {\n switch (this.tokenType) {\n case RightCurlyBracket:\n break scan;\n\n case WhiteSpace:\n case Comment:\n this.next();\n break;\n\n case AtKeyword:\n children.push(this.parseWithFallback(this.Atrule.bind(this, isStyleBlock), consumeRaw));\n break;\n\n default:\n if (isStyleBlock && this.isDelim(AMPERSAND)) {\n children.push(consumeRule.call(this));\n } else {\n children.push(consumer.call(this));\n }\n }\n }\n\n if (!this.eof) {\n this.eat(RightCurlyBracket);\n }\n\n return {\n type: 'Block',\n loc: this.getLocation(start, this.tokenStart),\n children\n };\n}\n\nexport function generate(node) {\n this.token(LeftCurlyBracket, '{');\n this.children(node, prev => {\n if (prev.type === 'Declaration') {\n this.token(Semicolon, ';');\n }\n });\n this.token(RightCurlyBracket, '}');\n}\n","import {\n Delim,\n LeftSquareBracket,\n RightSquareBracket\n} from '../../tokenizer/index.js';\n\nexport const name = 'Brackets';\nexport const structure = {\n children: [[]]\n};\n\nexport function parse(readSequence, recognizer) {\n const start = this.tokenStart;\n let children = null;\n\n this.eat(LeftSquareBracket);\n\n children = readSequence.call(this, recognizer);\n\n if (!this.eof) {\n this.eat(RightSquareBracket);\n }\n\n return {\n type: 'Brackets',\n loc: this.getLocation(start, this.tokenStart),\n children\n };\n}\n\nexport function generate(node) {\n this.token(Delim, '[');\n this.children(node);\n this.token(Delim, ']');\n}\n","import { CDC } from '../../tokenizer/index.js';\n\nexport const name = 'CDC';\nexport const structure = [];\n\nexport function parse() {\n const start = this.tokenStart;\n\n this.eat(CDC); // -->\n\n return {\n type: 'CDC',\n loc: this.getLocation(start, this.tokenStart)\n };\n}\n\nexport function generate() {\n this.token(CDC, '-->');\n}\n","import { CDO } from '../../tokenizer/index.js';\n\nexport const name = 'CDO';\nexport const structure = [];\n\nexport function parse() {\n const start = this.tokenStart;\n\n this.eat(CDO); // <!--\n\n return {\n type: 'CDO',\n loc: this.getLocation(start, this.tokenStart)\n };\n}\n\nexport function generate() {\n this.token(CDO, '<!--');\n}\n","import { Delim, Ident } from '../../tokenizer/index.js';\n\nconst FULLSTOP = 0x002E; // U+002E FULL STOP (.)\n\n// '.' ident\nexport const name = 'ClassSelector';\nexport const structure = {\n name: String\n};\n\nexport function parse() {\n this.eatDelim(FULLSTOP);\n\n return {\n type: 'ClassSelector',\n loc: this.getLocation(this.tokenStart - 1, this.tokenEnd),\n name: this.consume(Ident)\n };\n}\n\nexport function generate(node) {\n this.token(Delim, '.');\n this.token(Ident, node.name);\n}\n","import { WhiteSpace, Delim } from '../../tokenizer/index.js';\n\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\nconst GREATERTHANSIGN = 0x003E; // U+003E GREATER-THAN SIGN (>)\nconst TILDE = 0x007E; // U+007E TILDE (~)\n\nexport const name = 'Combinator';\nexport const structure = {\n name: String\n};\n\n// + | > | ~ | /deep/\nexport function parse() {\n const start = this.tokenStart;\n let name;\n\n switch (this.tokenType) {\n case WhiteSpace:\n name = ' ';\n break;\n\n case Delim:\n switch (this.charCodeAt(this.tokenStart)) {\n case GREATERTHANSIGN:\n case PLUSSIGN:\n case TILDE:\n this.next();\n break;\n\n case SOLIDUS:\n this.next();\n this.eatIdent('deep');\n this.eatDelim(SOLIDUS);\n break;\n\n default:\n this.error('Combinator is expected');\n }\n\n name = this.substrToCursor(start);\n break;\n }\n\n return {\n type: 'Combinator',\n loc: this.getLocation(start, this.tokenStart),\n name\n };\n}\n\nexport function generate(node) {\n this.tokenize(node.name);\n}\n","import { Comment } from '../../tokenizer/index.js';\n\nconst ASTERISK = 0x002A; // U+002A ASTERISK (*)\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\n\n\nexport const name = 'Comment';\nexport const structure = {\n value: String\n};\n\nexport function parse() {\n const start = this.tokenStart;\n let end = this.tokenEnd;\n\n this.eat(Comment);\n\n if ((end - start + 2) >= 2 &&\n this.charCodeAt(end - 2) === ASTERISK &&\n this.charCodeAt(end - 1) === SOLIDUS) {\n end -= 2;\n }\n\n return {\n type: 'Comment',\n loc: this.getLocation(start, this.tokenStart),\n value: this.substring(start + 2, end)\n };\n}\n\nexport function generate(node) {\n this.token(Comment, '/*' + node.value + '*/');\n}\n","import {\n WhiteSpace,\n Comment,\n Ident,\n LeftParenthesis,\n RightParenthesis,\n Function as FunctionToken,\n Colon,\n EOF\n} from '../../tokenizer/index.js';\n\nconst likelyFeatureToken = new Set([Colon, RightParenthesis, EOF]);\n\nexport const name = 'Condition';\nexport const structure = {\n kind: String,\n children: [[\n 'Identifier',\n 'Feature',\n 'FeatureFunction',\n 'FeatureRange',\n 'SupportsDeclaration'\n ]]\n};\n\nfunction featureOrRange(kind) {\n if (this.lookupTypeNonSC(1) === Ident &&\n likelyFeatureToken.has(this.lookupTypeNonSC(2))) {\n return this.Feature(kind);\n }\n\n return this.FeatureRange(kind);\n}\n\nconst parentheses = {\n media: featureOrRange,\n container: featureOrRange,\n supports() {\n return this.SupportsDeclaration();\n }\n};\n\nexport function parse(kind = 'media') {\n const children = this.createList();\n\n scan: while (!this.eof) {\n switch (this.tokenType) {\n case Comment:\n case WhiteSpace:\n this.next();\n continue;\n\n case Ident:\n children.push(this.Identifier());\n break;\n\n case LeftParenthesis: {\n let term = this.parseWithFallback(\n () => parentheses[kind].call(this, kind),\n () => null\n );\n\n if (!term) {\n term = this.parseWithFallback(\n () => {\n this.eat(LeftParenthesis);\n const res = this.Condition(kind);\n this.eat(RightParenthesis);\n return res;\n },\n () => {\n return this.GeneralEnclosed(kind);\n }\n );\n }\n\n children.push(term);\n break;\n }\n\n case FunctionToken: {\n let term = this.parseWithFallback(\n () => this.FeatureFunction(kind),\n () => null\n );\n\n if (!term) {\n term = this.GeneralEnclosed(kind);\n }\n\n children.push(term);\n break;\n }\n\n default:\n break scan;\n }\n }\n\n if (children.isEmpty) {\n this.error('Condition is expected');\n }\n\n return {\n type: 'Condition',\n loc: this.getLocationFromList(children),\n kind,\n children\n };\n}\n\nexport function generate(node) {\n node.children.forEach(child => {\n if (child.type === 'Condition') {\n this.token(LeftParenthesis, '(');\n this.node(child);\n this.token(RightParenthesis, ')');\n } else {\n this.node(child);\n }\n });\n}\n\n","import { isCustomProperty } from '../../utils/names.js';\nimport {\n Ident,\n Hash,\n Colon,\n Semicolon,\n Delim,\n WhiteSpace\n} from '../../tokenizer/index.js';\n\nconst EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!)\nconst NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#)\nconst DOLLARSIGN = 0x0024; // U+0024 DOLLAR SIGN ($)\nconst AMPERSAND = 0x0026; // U+0026 AMPERSAND (&)\nconst ASTERISK = 0x002A; // U+002A ASTERISK (*)\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\n\nfunction consumeValueRaw() {\n return this.Raw(this.consumeUntilExclamationMarkOrSemicolon, true);\n}\n\nfunction consumeCustomPropertyRaw() {\n return this.Raw(this.consumeUntilExclamationMarkOrSemicolon, false);\n}\n\nfunction consumeValue() {\n const startValueToken = this.tokenIndex;\n const value = this.Value();\n\n if (value.type !== 'Raw' &&\n this.eof === false &&\n this.tokenType !== Semicolon &&\n this.isDelim(EXCLAMATIONMARK) === false &&\n this.isBalanceEdge(startValueToken) === false) {\n this.error();\n }\n\n return value;\n}\n\nexport const name = 'Declaration';\nexport const walkContext = 'declaration';\nexport const structure = {\n important: [Boolean, String],\n property: String,\n value: ['Value', 'Raw']\n};\n\nexport function parse() {\n const start = this.tokenStart;\n const startToken = this.tokenIndex;\n const property = readProperty.call(this);\n const customProperty = isCustomProperty(property);\n const parseValue = customProperty ? this.parseCustomProperty : this.parseValue;\n const consumeRaw = customProperty ? consumeCustomPropertyRaw : consumeValueRaw;\n let important = false;\n let value;\n\n this.skipSC();\n this.eat(Colon);\n\n const valueStart = this.tokenIndex;\n\n if (!customProperty) {\n this.skipSC();\n }\n\n if (parseValue) {\n value = this.parseWithFallback(consumeValue, consumeRaw);\n } else {\n value = consumeRaw.call(this, this.tokenIndex);\n }\n\n if (customProperty && value.type === 'Value' && value.children.isEmpty) {\n for (let offset = valueStart - this.tokenIndex; offset <= 0; offset++) {\n if (this.lookupType(offset) === WhiteSpace) {\n value.children.appendData({\n type: 'WhiteSpace',\n loc: null,\n value: ' '\n });\n break;\n }\n }\n }\n\n if (this.isDelim(EXCLAMATIONMARK)) {\n important = getImportant.call(this);\n this.skipSC();\n }\n\n // Do not include semicolon to range per spec\n // https://drafts.csswg.org/css-syntax/#declaration-diagram\n\n if (this.eof === false &&\n this.tokenType !== Semicolon &&\n this.isBalanceEdge(startToken) === false) {\n this.error();\n }\n\n return {\n type: 'Declaration',\n loc: this.getLocation(start, this.tokenStart),\n important,\n property,\n value\n };\n}\n\nexport function generate(node) {\n this.token(Ident, node.property);\n this.token(Colon, ':');\n this.node(node.value);\n\n if (node.important) {\n this.token(Delim, '!');\n this.token(Ident, node.important === true ? 'important' : node.important);\n }\n}\n\nfunction readProperty() {\n const start = this.tokenStart;\n\n // hacks\n if (this.tokenType === Delim) {\n switch (this.charCodeAt(this.tokenStart)) {\n case ASTERISK:\n case DOLLARSIGN:\n case PLUSSIGN:\n case NUMBERSIGN:\n case AMPERSAND:\n this.next();\n break;\n\n // TODO: not sure we should support this hack\n case SOLIDUS:\n this.next();\n if (this.isDelim(SOLIDUS)) {\n this.next();\n }\n break;\n }\n }\n\n if (this.tokenType === Hash) {\n this.eat(Hash);\n } else {\n this.eat(Ident);\n }\n\n return this.substrToCursor(start);\n}\n\n// ! ws* important\nfunction getImportant() {\n this.eat(Delim);\n this.skipSC();\n\n const important = this.consume(Ident);\n\n // store original value in case it differ from `important`\n // for better original source restoring and hacks like `!ie` support\n return important === 'important' ? true : important;\n}\n","import {\n WhiteSpace,\n Comment,\n Semicolon,\n AtKeyword\n} from '../../tokenizer/index.js';\n\nconst AMPERSAND = 0x0026; // U+0026 AMPERSAND (&)\n\nfunction consumeRaw() {\n return this.Raw(this.consumeUntilSemicolonIncluded, true);\n}\n\nexport const name = 'DeclarationList';\nexport const structure = {\n children: [[\n 'Declaration',\n 'Atrule',\n 'Rule'\n ]]\n};\n\nexport function parse() {\n const children = this.createList();\n\n scan:\n while (!this.eof) {\n switch (this.tokenType) {\n case WhiteSpace:\n case Comment:\n case Semicolon:\n this.next();\n break;\n\n case AtKeyword:\n children.push(this.parseWithFallback(this.Atrule.bind(this, true), consumeRaw));\n break;\n\n default:\n if (this.isDelim(AMPERSAND)) {\n children.push(this.parseWithFallback(this.Rule, consumeRaw));\n } else {\n children.push(this.parseWithFallback(this.Declaration, consumeRaw));\n }\n }\n }\n\n return {\n type: 'DeclarationList',\n loc: this.getLocationFromList(children),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node, prev => {\n if (prev.type === 'Declaration') {\n this.token(Semicolon, ';');\n }\n });\n}\n\n","import { Dimension } from '../../tokenizer/index.js';\n\nexport const name = 'Dimension';\nexport const structure = {\n value: String,\n unit: String\n};\n\nexport function parse() {\n const start = this.tokenStart;\n const value = this.consumeNumber(Dimension);\n\n return {\n type: 'Dimension',\n loc: this.getLocation(start, this.tokenStart),\n value,\n unit: this.substring(start + value.length, this.tokenStart)\n };\n}\n\nexport function generate(node) {\n this.token(Dimension, node.value + node.unit);\n}\n","import {\n Ident,\n Number,\n Dimension,\n Function as FunctionToken,\n LeftParenthesis,\n RightParenthesis,\n Colon,\n Delim\n} from '../../tokenizer/index.js';\n\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\n\nexport const name = 'Feature';\nexport const structure = {\n kind: String,\n name: String,\n value: ['Identifier', 'Number', 'Dimension', 'Ratio', 'Function', null]\n};\n\nexport function parse(kind) {\n const start = this.tokenStart;\n let name;\n let value = null;\n\n this.eat(LeftParenthesis);\n this.skipSC();\n\n name = this.consume(Ident);\n this.skipSC();\n\n if (this.tokenType !== RightParenthesis) {\n this.eat(Colon);\n this.skipSC();\n\n switch (this.tokenType) {\n case Number:\n if (this.lookupNonWSType(1) === Delim) {\n value = this.Ratio();\n } else {\n value = this.Number();\n }\n\n break;\n\n case Dimension:\n value = this.Dimension();\n break;\n\n case Ident:\n value = this.Identifier();\n break;\n\n case FunctionToken:\n value = this.parseWithFallback(\n () => {\n const res = this.Function(this.readSequence, this.scope.Value);\n\n this.skipSC();\n\n if (this.isDelim(SOLIDUS)) {\n this.error();\n }\n\n return res;\n },\n () => {\n return this.Ratio();\n }\n );\n break;\n\n default:\n this.error('Number, dimension, ratio or identifier is expected');\n }\n\n this.skipSC();\n }\n\n if (!this.eof) {\n this.eat(RightParenthesis);\n }\n\n return {\n type: 'Feature',\n loc: this.getLocation(start, this.tokenStart),\n kind,\n name,\n value\n };\n}\n\nexport function generate(node) {\n this.token(LeftParenthesis, '(');\n this.token(Ident, node.name);\n\n if (node.value !== null) {\n this.token(Colon, ':');\n this.node(node.value);\n }\n\n this.token(RightParenthesis, ')');\n}\n","import {\n Function as FunctionToken,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nexport const name = 'FeatureFunction';\nexport const structure = {\n kind: String,\n feature: String,\n value: ['Declaration', 'Selector']\n};\n\nfunction getFeatureParser(kind, name) {\n const featuresOfKind = this.features[kind] || {};\n const parser = featuresOfKind[name];\n\n if (typeof parser !== 'function') {\n this.error(`Unknown feature ${name}()`);\n }\n\n return parser;\n}\n\nexport function parse(kind = 'unknown') {\n const start = this.tokenStart;\n const functionName = this.consumeFunctionName();\n const valueParser = getFeatureParser.call(this, kind, functionName.toLowerCase());\n\n this.skipSC();\n\n const value = this.parseWithFallback(\n () => {\n const startValueToken = this.tokenIndex;\n const value = valueParser.call(this);\n\n if (this.eof === false &&\n this.isBalanceEdge(startValueToken) === false) {\n this.error();\n }\n\n return value;\n },\n () => this.Raw(null, false)\n );\n\n if (!this.eof) {\n this.eat(RightParenthesis);\n }\n\n return {\n type: 'FeatureFunction',\n loc: this.getLocation(start, this.tokenStart),\n kind,\n feature: functionName,\n value\n };\n}\n\nexport function generate(node) {\n this.token(FunctionToken, node.feature + '(');\n this.node(node.value);\n this.token(RightParenthesis, ')');\n}\n","import {\n Ident,\n Number,\n Dimension,\n Function as FunctionToken,\n LeftParenthesis,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\nconst LESSTHANSIGN = 0x003C; // U+003C LESS-THAN SIGN (<)\nconst EQUALSSIGN = 0x003D; // U+003D EQUALS SIGN (=)\nconst GREATERTHANSIGN = 0x003E; // U+003E GREATER-THAN SIGN (>)\n\nexport const name = 'FeatureRange';\nexport const structure = {\n kind: String,\n left: ['Identifier', 'Number', 'Dimension', 'Ratio', 'Function'],\n leftComparison: String,\n middle: ['Identifier', 'Number', 'Dimension', 'Ratio', 'Function'],\n rightComparison: [String, null],\n right: ['Identifier', 'Number', 'Dimension', 'Ratio', 'Function', null]\n};\n\nfunction readTerm() {\n this.skipSC();\n\n switch (this.tokenType) {\n case Number:\n if (this.isDelim(SOLIDUS, this.lookupOffsetNonSC(1))) {\n return this.Ratio();\n } else {\n return this.Number();\n }\n\n case Dimension:\n return this.Dimension();\n\n case Ident:\n return this.Identifier();\n\n case FunctionToken:\n return this.parseWithFallback(\n () => {\n const res = this.Function(this.readSequence, this.scope.Value);\n\n this.skipSC();\n\n if (this.isDelim(SOLIDUS)) {\n this.error();\n }\n\n return res;\n },\n () => {\n return this.Ratio();\n }\n );\n\n default:\n this.error('Number, dimension, ratio or identifier is expected');\n }\n}\n\nfunction readComparison(expectColon) {\n this.skipSC();\n\n if (this.isDelim(LESSTHANSIGN) ||\n this.isDelim(GREATERTHANSIGN)) {\n const value = this.source[this.tokenStart];\n\n this.next();\n\n if (this.isDelim(EQUALSSIGN)) {\n this.next();\n return value + '=';\n }\n\n return value;\n }\n\n if (this.isDelim(EQUALSSIGN)) {\n return '=';\n }\n\n this.error(`Expected ${expectColon ? '\":\", ' : ''}\"<\", \">\", \"=\" or \")\"`);\n}\n\nexport function parse(kind = 'unknown') {\n const start = this.tokenStart;\n\n this.skipSC();\n this.eat(LeftParenthesis);\n\n const left = readTerm.call(this);\n const leftComparison = readComparison.call(this, left.type === 'Identifier');\n const middle = readTerm.call(this);\n let rightComparison = null;\n let right = null;\n\n if (this.lookupNonWSType(0) !== RightParenthesis) {\n rightComparison = readComparison.call(this);\n right = readTerm.call(this);\n }\n\n this.skipSC();\n this.eat(RightParenthesis);\n\n return {\n type: 'FeatureRange',\n loc: this.getLocation(start, this.tokenStart),\n kind,\n left,\n leftComparison,\n middle,\n rightComparison,\n right\n };\n}\n\nexport function generate(node) {\n this.token(LeftParenthesis, '(');\n this.node(node.left);\n this.tokenize(node.leftComparison);\n this.node(node.middle);\n\n if (node.right) {\n this.tokenize(node.rightComparison);\n this.node(node.right);\n }\n\n this.token(RightParenthesis, ')');\n}\n","import {\n Function as FunctionToken,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\n\nexport const name = 'Function';\nexport const walkContext = 'function';\nexport const structure = {\n name: String,\n children: [[]]\n};\n\n// <function-token> <sequence> )\nexport function parse(readSequence, recognizer) {\n const start = this.tokenStart;\n const name = this.consumeFunctionName();\n const nameLowerCase = name.toLowerCase();\n let children;\n\n children = recognizer.hasOwnProperty(nameLowerCase)\n ? recognizer[nameLowerCase].call(this, recognizer)\n : readSequence.call(this, recognizer);\n\n if (!this.eof) {\n this.eat(RightParenthesis);\n }\n\n return {\n type: 'Function',\n loc: this.getLocation(start, this.tokenStart),\n name,\n children\n };\n}\n\nexport function generate(node) {\n this.token(FunctionToken, node.name + '(');\n this.children(node);\n this.token(RightParenthesis, ')');\n}\n","import {\n Function as FunctionToken,\n LeftParenthesis,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\n\nexport const name = 'GeneralEnclosed';\nexport const structure = {\n kind: String,\n function: [String, null],\n children: [[]]\n};\n\n// <function-token> <any-value> )\n// ( <any-value> )\nexport function parse(kind) {\n const start = this.tokenStart;\n let functionName = null;\n\n if (this.tokenType === FunctionToken) {\n functionName = this.consumeFunctionName();\n } else {\n this.eat(LeftParenthesis);\n }\n\n const children = this.parseWithFallback(\n () => {\n const startValueToken = this.tokenIndex;\n const children = this.readSequence(this.scope.Value);\n\n if (this.eof === false &&\n this.isBalanceEdge(startValueToken) === false) {\n this.error();\n }\n\n return children;\n },\n () => this.createSingleNodeList(\n this.Raw(null, false)\n )\n );\n\n if (!this.eof) {\n this.eat(RightParenthesis);\n }\n\n return {\n type: 'GeneralEnclosed',\n loc: this.getLocation(start, this.tokenStart),\n kind,\n function: functionName,\n children\n };\n}\n\nexport function generate(node) {\n if (node.function) {\n this.token(FunctionToken, node.function + '(');\n } else {\n this.token(LeftParenthesis, '(');\n }\n\n this.children(node);\n this.token(RightParenthesis, ')');\n}\n","import { Hash } from '../../tokenizer/index.js';\n\n// '#' ident\nexport const xxx = 'XXX';\nexport const name = 'Hash';\nexport const structure = {\n value: String\n};\nexport function parse() {\n const start = this.tokenStart;\n\n this.eat(Hash);\n\n return {\n type: 'Hash',\n loc: this.getLocation(start, this.tokenStart),\n value: this.substrToCursor(start + 1)\n };\n}\nexport function generate(node) {\n this.token(Hash, '#' + node.value);\n}\n\n","import { Ident } from '../../tokenizer/index.js';\n\nexport const name = 'Identifier';\nexport const structure = {\n name: String\n};\n\nexport function parse() {\n return {\n type: 'Identifier',\n loc: this.getLocation(this.tokenStart, this.tokenEnd),\n name: this.consume(Ident)\n };\n}\n\nexport function generate(node) {\n this.token(Ident, node.name);\n}\n","import { Hash, Delim } from '../../tokenizer/index.js';\n\nexport const name = 'IdSelector';\nexport const structure = {\n name: String\n};\n\nexport function parse() {\n const start = this.tokenStart;\n\n // TODO: check value is an ident\n this.eat(Hash);\n\n return {\n type: 'IdSelector',\n loc: this.getLocation(start, this.tokenStart),\n name: this.substrToCursor(start + 1)\n };\n}\n\nexport function generate(node) {\n // Using Delim instead of Hash is a hack to avoid for a whitespace between ident and id-selector\n // in safe mode (e.g. \"a#id\"), because IE11 doesn't allow a sequence <ident-token> <hash-token>\n // without a whitespace in values (e.g. \"1px solid#000\")\n this.token(Delim, '#' + node.name);\n}\n","import { Ident, Delim } from '../../tokenizer/index.js';\n\nconst FULLSTOP = 0x002E; // U+002E FULL STOP (.)\n\nexport const name = 'Layer';\nexport const structure = {\n name: String\n};\n\nexport function parse() {\n let tokenStart = this.tokenStart;\n let name = this.consume(Ident);\n\n while (this.isDelim(FULLSTOP)) {\n this.eat(Delim);\n name += '.' + this.consume(Ident);\n }\n\n return {\n type: 'Layer',\n loc: this.getLocation(tokenStart, this.tokenStart),\n name\n };\n}\n\nexport function generate(node) {\n this.tokenize(node.name);\n}\n","import { Comma } from '../../tokenizer/index.js';\n\nexport const name = 'LayerList';\nexport const structure = {\n children: [[\n 'Layer'\n ]]\n};\n\nexport function parse() {\n const children = this.createList();\n\n this.skipSC();\n\n while (!this.eof) {\n children.push(this.Layer());\n\n if (this.lookupTypeNonSC(0) !== Comma) {\n break;\n }\n\n this.skipSC();\n this.next();\n this.skipSC();\n }\n\n return {\n type: 'LayerList',\n loc: this.getLocationFromList(children),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node, () => this.token(Comma, ','));\n}\n","import {\n Comma,\n EOF,\n Ident,\n LeftCurlyBracket,\n LeftParenthesis,\n Function as FunctionToken,\n Semicolon\n} from '../../tokenizer/index.js';\n\nexport const name = 'MediaQuery';\nexport const structure = {\n modifier: [String, null],\n mediaType: [String, null],\n condition: ['Condition', null]\n};\n\nexport function parse() {\n const start = this.tokenStart;\n let modifier = null;\n let mediaType = null;\n let condition = null;\n\n this.skipSC();\n\n if (this.tokenType === Ident && this.lookupTypeNonSC(1) !== LeftParenthesis) {\n // [ not | only ]? <media-type>\n const ident = this.consume(Ident);\n const identLowerCase = ident.toLowerCase();\n\n if (identLowerCase === 'not' || identLowerCase === 'only') {\n this.skipSC();\n modifier = identLowerCase;\n mediaType = this.consume(Ident);\n } else {\n mediaType = ident;\n }\n\n switch (this.lookupTypeNonSC(0)) {\n case Ident: {\n // and <media-condition-without-or>\n this.skipSC();\n this.eatIdent('and');\n condition = this.Condition('media');\n break;\n }\n\n case LeftCurlyBracket:\n case Semicolon:\n case Comma:\n case EOF:\n break;\n\n default:\n this.error('Identifier or parenthesis is expected');\n }\n } else {\n switch (this.tokenType) {\n case Ident:\n case LeftParenthesis:\n case FunctionToken: {\n // <media-condition>\n condition = this.Condition('media');\n break;\n }\n\n case LeftCurlyBracket:\n case Semicolon:\n case EOF:\n break;\n\n default:\n this.error('Identifier or parenthesis is expected');\n }\n }\n\n return {\n type: 'MediaQuery',\n loc: this.getLocation(start, this.tokenStart),\n modifier,\n mediaType,\n condition\n };\n}\n\nexport function generate(node) {\n if (node.mediaType) {\n if (node.modifier) {\n this.token(Ident, node.modifier);\n }\n\n this.token(Ident, node.mediaType);\n\n if (node.condition) {\n this.token(Ident, 'and');\n this.node(node.condition);\n }\n } else if (node.condition) {\n this.node(node.condition);\n }\n}\n\n","import { Comma } from '../../tokenizer/index.js';\n\nexport const name = 'MediaQueryList';\nexport const structure = {\n children: [[\n 'MediaQuery'\n ]]\n};\n\nexport function parse() {\n const children = this.createList();\n\n this.skipSC();\n\n while (!this.eof) {\n children.push(this.MediaQuery());\n\n if (this.tokenType !== Comma) {\n break;\n }\n\n this.next();\n }\n\n return {\n type: 'MediaQueryList',\n loc: this.getLocationFromList(children),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node, () => this.token(Comma, ','));\n}\n","import { Delim } from '../../tokenizer/index.js';\n\nconst AMPERSAND = 0x0026; // U+0026 AMPERSAND (&)\n\nexport const name = 'NestingSelector';\nexport const structure = {\n};\n\nexport function parse() {\n const start = this.tokenStart;\n\n this.eatDelim(AMPERSAND);\n\n return {\n type: 'NestingSelector',\n loc: this.getLocation(start, this.tokenStart)\n };\n}\n\nexport function generate() {\n this.token(Delim, '&');\n}\n","import { Ident } from '../../tokenizer/index.js';\n\nexport const name = 'Nth';\nexport const structure = {\n nth: ['AnPlusB', 'Identifier'],\n selector: ['SelectorList', null]\n};\n\nexport function parse() {\n this.skipSC();\n\n const start = this.tokenStart;\n let end = start;\n let selector = null;\n let nth;\n\n if (this.lookupValue(0, 'odd') || this.lookupValue(0, 'even')) {\n nth = this.Identifier();\n } else {\n nth = this.AnPlusB();\n }\n\n end = this.tokenStart;\n this.skipSC();\n\n if (this.lookupValue(0, 'of')) {\n this.next();\n\n selector = this.SelectorList();\n end = this.tokenStart;\n }\n\n return {\n type: 'Nth',\n loc: this.getLocation(start, end),\n nth,\n selector\n };\n}\n\nexport function generate(node) {\n this.node(node.nth);\n if (node.selector !== null) {\n this.token(Ident, 'of');\n this.node(node.selector);\n }\n}\n","import { Number as NumberToken } from '../../tokenizer/index.js';\n\nexport const name = 'Number';\nexport const structure = {\n value: String\n};\n\nexport function parse() {\n return {\n type: 'Number',\n loc: this.getLocation(this.tokenStart, this.tokenEnd),\n value: this.consume(NumberToken)\n };\n}\n\nexport function generate(node) {\n this.token(NumberToken, node.value);\n}\n","// '/' | '*' | ',' | ':' | '+' | '-'\nexport const name = 'Operator';\nexport const structure = {\n value: String\n};\n\nexport function parse() {\n const start = this.tokenStart;\n\n this.next();\n\n return {\n type: 'Operator',\n loc: this.getLocation(start, this.tokenStart),\n value: this.substrToCursor(start)\n };\n}\n\nexport function generate(node) {\n this.tokenize(node.value);\n}\n","import {\n LeftParenthesis,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nexport const name = 'Parentheses';\nexport const structure = {\n children: [[]]\n};\n\nexport function parse(readSequence, recognizer) {\n const start = this.tokenStart;\n let children = null;\n\n this.eat(LeftParenthesis);\n\n children = readSequence.call(this, recognizer);\n\n if (!this.eof) {\n this.eat(RightParenthesis);\n }\n\n return {\n type: 'Parentheses',\n loc: this.getLocation(start, this.tokenStart),\n children\n };\n}\n\nexport function generate(node) {\n this.token(LeftParenthesis, '(');\n this.children(node);\n this.token(RightParenthesis, ')');\n}\n","import { Percentage } from '../../tokenizer/index.js';\n\nexport const name = 'Percentage';\nexport const structure = {\n value: String\n};\n\nexport function parse() {\n return {\n type: 'Percentage',\n loc: this.getLocation(this.tokenStart, this.tokenEnd),\n value: this.consumeNumber(Percentage)\n };\n}\n\nexport function generate(node) {\n this.token(Percentage, node.value + '%');\n}\n","import {\n Ident,\n Function as FunctionToken,\n Colon,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\n\nexport const name = 'PseudoClassSelector';\nexport const walkContext = 'function';\nexport const structure = {\n name: String,\n children: [['Raw'], null]\n};\n\n// : [ <ident> | <function-token> <any-value>? ) ]\nexport function parse() {\n const start = this.tokenStart;\n let children = null;\n let name;\n let nameLowerCase;\n\n this.eat(Colon);\n\n if (this.tokenType === FunctionToken) {\n name = this.consumeFunctionName();\n nameLowerCase = name.toLowerCase();\n\n if (this.lookupNonWSType(0) == RightParenthesis) {\n children = this.createList();\n } else if (hasOwnProperty.call(this.pseudo, nameLowerCase)) {\n this.skipSC();\n children = this.pseudo[nameLowerCase].call(this);\n this.skipSC();\n } else {\n children = this.createList();\n children.push(\n this.Raw(null, false)\n );\n }\n\n this.eat(RightParenthesis);\n } else {\n name = this.consume(Ident);\n }\n\n return {\n type: 'PseudoClassSelector',\n loc: this.getLocation(start, this.tokenStart),\n name,\n children\n };\n}\n\nexport function generate(node) {\n this.token(Colon, ':');\n\n if (node.children === null) {\n this.token(Ident, node.name);\n } else {\n this.token(FunctionToken, node.name + '(');\n this.children(node);\n this.token(RightParenthesis, ')');\n }\n}\n","import {\n Ident,\n Function as FunctionToken,\n Colon,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nexport const name = 'PseudoElementSelector';\nexport const walkContext = 'function';\nexport const structure = {\n name: String,\n children: [['Raw'], null]\n};\n\n// :: [ <ident> | <function-token> <any-value>? ) ]\nexport function parse() {\n const start = this.tokenStart;\n let children = null;\n let name;\n let nameLowerCase;\n\n this.eat(Colon);\n this.eat(Colon);\n\n if (this.tokenType === FunctionToken) {\n name = this.consumeFunctionName();\n nameLowerCase = name.toLowerCase();\n\n if (this.lookupNonWSType(0) == RightParenthesis) {\n children = this.createList();\n } else if (hasOwnProperty.call(this.pseudo, nameLowerCase)) {\n this.skipSC();\n children = this.pseudo[nameLowerCase].call(this);\n this.skipSC();\n } else {\n children = this.createList();\n children.push(\n this.Raw(null, false)\n );\n }\n\n this.eat(RightParenthesis);\n } else {\n name = this.consume(Ident);\n }\n\n return {\n type: 'PseudoElementSelector',\n loc: this.getLocation(start, this.tokenStart),\n name,\n children\n };\n}\n\nexport function generate(node) {\n this.token(Colon, ':');\n this.token(Colon, ':');\n\n if (node.children === null) {\n this.token(Ident, node.name);\n } else {\n this.token(FunctionToken, node.name + '(');\n this.children(node);\n this.token(RightParenthesis, ')');\n }\n}\n","import {\n Delim,\n Number as NumberToken,\n Function as FunctionToken\n} from '../../tokenizer/index.js';\n\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\n\n// Media Queries Level 3 defines terms of <ratio> as a positive (not zero or negative)\n// integers (see https://drafts.csswg.org/mediaqueries-3/#values)\n// However, Media Queries Level 4 removes any definition of values\n// (see https://drafts.csswg.org/mediaqueries-4/#values) and refers to\n// CSS Values and Units for detail. In CSS Values and Units Level 4 a <ratio>\n// definition was added (see https://drafts.csswg.org/css-values-4/#ratios) which\n// defines ratio as \"<number [0,∞]> [ / <number [0,∞]> ]?\" and based on it\n// any constrains on terms were removed. Parser also doesn't test numbers\n// in any way to make possible for linting and fixing them by the tools using CSSTree.\n// An additional syntax examination may be applied by a lexer.\nfunction consumeTerm() {\n this.skipSC();\n\n switch (this.tokenType) {\n case NumberToken:\n return this.Number();\n\n case FunctionToken:\n return this.Function(this.readSequence, this.scope.Value);\n\n default:\n this.error('Number of function is expected');\n }\n}\n\nexport const name = 'Ratio';\nexport const structure = {\n left: ['Number', 'Function'],\n right: ['Number', 'Function', null]\n};\n\n// <number [0,∞]> [ / <number [0,∞]> ]?\nexport function parse() {\n const start = this.tokenStart;\n const left = consumeTerm.call(this);\n let right = null;\n\n this.skipSC();\n if (this.isDelim(SOLIDUS)) {\n this.eatDelim(SOLIDUS);\n right = consumeTerm.call(this);\n }\n\n return {\n type: 'Ratio',\n loc: this.getLocation(start, this.tokenStart),\n left,\n right\n };\n}\n\nexport function generate(node) {\n this.node(node.left);\n this.token(Delim, '/');\n if (node.right) {\n this.node(node.right);\n } else {\n this.node(NumberToken, 1);\n }\n}\n","import { WhiteSpace } from '../../tokenizer/index.js';\n\nfunction getOffsetExcludeWS() {\n if (this.tokenIndex > 0) {\n if (this.lookupType(-1) === WhiteSpace) {\n return this.tokenIndex > 1\n ? this.getTokenStart(this.tokenIndex - 1)\n : this.firstCharOffset;\n }\n }\n\n return this.tokenStart;\n}\n\nexport const name = 'Raw';\nexport const structure = {\n value: String\n};\n\nexport function parse(consumeUntil, excludeWhiteSpace) {\n const startOffset = this.getTokenStart(this.tokenIndex);\n let endOffset;\n\n this.skipUntilBalanced(this.tokenIndex, consumeUntil || this.consumeUntilBalanceEnd);\n\n if (excludeWhiteSpace && this.tokenStart > startOffset) {\n endOffset = getOffsetExcludeWS.call(this);\n } else {\n endOffset = this.tokenStart;\n }\n\n return {\n type: 'Raw',\n loc: this.getLocation(startOffset, endOffset),\n value: this.substring(startOffset, endOffset)\n };\n}\n\nexport function generate(node) {\n this.tokenize(node.value);\n}\n","import { LeftCurlyBracket } from '../../tokenizer/index.js';\n\nfunction consumeRaw() {\n return this.Raw(this.consumeUntilLeftCurlyBracket, true);\n}\n\nfunction consumePrelude() {\n const prelude = this.SelectorList();\n\n if (prelude.type !== 'Raw' &&\n this.eof === false &&\n this.tokenType !== LeftCurlyBracket) {\n this.error();\n }\n\n return prelude;\n}\n\nexport const name = 'Rule';\nexport const walkContext = 'rule';\nexport const structure = {\n prelude: ['SelectorList', 'Raw'],\n block: ['Block']\n};\n\nexport function parse() {\n const startToken = this.tokenIndex;\n const startOffset = this.tokenStart;\n let prelude;\n let block;\n\n if (this.parseRulePrelude) {\n prelude = this.parseWithFallback(consumePrelude, consumeRaw);\n } else {\n prelude = consumeRaw.call(this, startToken);\n }\n\n block = this.Block(true);\n\n return {\n type: 'Rule',\n loc: this.getLocation(startOffset, this.tokenStart),\n prelude,\n block\n };\n}\nexport function generate(node) {\n this.node(node.prelude);\n this.node(node.block);\n}\n\n","import {\n Ident,\n LeftParenthesis,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nexport const name = 'Scope';\nexport const structure = {\n root: ['SelectorList', 'Raw', null],\n limit: ['SelectorList', 'Raw', null]\n};\n\nexport function parse() {\n let root = null;\n let limit = null;\n\n this.skipSC();\n\n const startOffset = this.tokenStart;\n if (this.tokenType === LeftParenthesis) {\n this.next();\n this.skipSC();\n root = this.parseWithFallback(\n this.SelectorList,\n () => this.Raw(false, true)\n );\n this.skipSC();\n this.eat(RightParenthesis);\n }\n\n if (this.lookupNonWSType(0) === Ident) {\n this.skipSC();\n this.eatIdent('to');\n this.skipSC();\n this.eat(LeftParenthesis);\n this.skipSC();\n limit = this.parseWithFallback(\n this.SelectorList,\n () => this.Raw(false, true)\n );\n this.skipSC();\n this.eat(RightParenthesis);\n }\n\n return {\n type: 'Scope',\n loc: this.getLocation(startOffset, this.tokenStart),\n root,\n limit\n };\n}\n\nexport function generate(node) {\n if (node.root) {\n this.token(LeftParenthesis, '(');\n this.node(node.root);\n this.token(RightParenthesis, ')');\n }\n\n if (node.limit) {\n this.token(Ident, 'to');\n this.token(LeftParenthesis, '(');\n this.node(node.limit);\n this.token(RightParenthesis, ')');\n }\n}\n","export const name = 'Selector';\nexport const structure = {\n children: [[\n 'TypeSelector',\n 'IdSelector',\n 'ClassSelector',\n 'AttributeSelector',\n 'PseudoClassSelector',\n 'PseudoElementSelector',\n 'Combinator'\n ]]\n};\n\nexport function parse() {\n const children = this.readSequence(this.scope.Selector);\n\n // nothing were consumed\n if (this.getFirstListNode(children) === null) {\n this.error('Selector is expected');\n }\n\n return {\n type: 'Selector',\n loc: this.getLocationFromList(children),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node);\n}\n","import { Comma } from '../../tokenizer/index.js';\n\nexport const name = 'SelectorList';\nexport const walkContext = 'selector';\nexport const structure = {\n children: [[\n 'Selector',\n 'Raw'\n ]]\n};\n\nexport function parse() {\n const children = this.createList();\n\n while (!this.eof) {\n children.push(this.Selector());\n\n if (this.tokenType === Comma) {\n this.next();\n continue;\n }\n\n break;\n }\n\n return {\n type: 'SelectorList',\n loc: this.getLocationFromList(children),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node, () => this.token(Comma, ','));\n}\n","import {\n isHexDigit,\n isWhiteSpace,\n isValidEscape,\n consumeEscaped,\n decodeEscaped\n} from '../tokenizer/index.js';\n\nconst REVERSE_SOLIDUS = 0x005c; // U+005C REVERSE SOLIDUS (\\)\nconst QUOTATION_MARK = 0x0022; // \"\nconst APOSTROPHE = 0x0027; // '\n\nexport function decode(str) {\n const len = str.length;\n const firstChar = str.charCodeAt(0);\n const start = firstChar === QUOTATION_MARK || firstChar === APOSTROPHE ? 1 : 0;\n const end = start === 1 && len > 1 && str.charCodeAt(len - 1) === firstChar ? len - 2 : len - 1;\n let decoded = '';\n\n for (let i = start; i <= end; i++) {\n let code = str.charCodeAt(i);\n\n if (code === REVERSE_SOLIDUS) {\n // special case at the ending\n if (i === end) {\n // if the next input code point is EOF, do nothing\n // otherwise include last quote as escaped\n if (i !== len - 1) {\n decoded = str.substr(i + 1);\n }\n break;\n }\n\n code = str.charCodeAt(++i);\n\n // consume escaped\n if (isValidEscape(REVERSE_SOLIDUS, code)) {\n const escapeStart = i - 1;\n const escapeEnd = consumeEscaped(str, escapeStart);\n\n i = escapeEnd - 1;\n decoded += decodeEscaped(str.substring(escapeStart + 1, escapeEnd));\n } else {\n // \\r\\n\n if (code === 0x000d && str.charCodeAt(i + 1) === 0x000a) {\n i++;\n }\n }\n } else {\n decoded += str[i];\n }\n }\n\n return decoded;\n}\n\n// https://drafts.csswg.org/cssom/#serialize-a-string\n// § 2.1. Common Serializing Idioms\nexport function encode(str, apostrophe) {\n const quote = apostrophe ? '\\'' : '\"';\n const quoteCode = apostrophe ? APOSTROPHE : QUOTATION_MARK;\n let encoded = '';\n let wsBeforeHexIsNeeded = false;\n\n for (let i = 0; i < str.length; i++) {\n const code = str.charCodeAt(i);\n\n // If the character is NULL (U+0000), then the REPLACEMENT CHARACTER (U+FFFD).\n if (code === 0x0000) {\n encoded += '\\uFFFD';\n continue;\n }\n\n // If the character is in the range [\\1-\\1f] (U+0001 to U+001F) or is U+007F,\n // the character escaped as code point.\n // Note: Do not compare with 0x0001 since 0x0000 is precessed before\n if (code <= 0x001f || code === 0x007F) {\n encoded += '\\\\' + code.toString(16);\n wsBeforeHexIsNeeded = true;\n continue;\n }\n\n // If the character is '\"' (U+0022) or \"\\\" (U+005C), the escaped character.\n if (code === quoteCode || code === REVERSE_SOLIDUS) {\n encoded += '\\\\' + str.charAt(i);\n wsBeforeHexIsNeeded = false;\n } else {\n if (wsBeforeHexIsNeeded && (isHexDigit(code) || isWhiteSpace(code))) {\n encoded += ' ';\n }\n\n // Otherwise, the character itself.\n encoded += str.charAt(i);\n wsBeforeHexIsNeeded = false;\n }\n }\n\n return quote + encoded + quote;\n}\n","import { String as StringToken } from '../../tokenizer/index.js';\nimport { decode, encode } from '../../utils/string.js';\n\nexport const name = 'String';\nexport const structure = {\n value: String\n};\n\nexport function parse() {\n return {\n type: 'String',\n loc: this.getLocation(this.tokenStart, this.tokenEnd),\n value: decode(this.consume(StringToken))\n };\n}\n\nexport function generate(node) {\n this.token(StringToken, encode(node.value));\n}\n","import {\n WhiteSpace,\n Comment,\n AtKeyword,\n CDO,\n CDC\n} from '../../tokenizer/index.js';\n\nconst EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!)\n\nfunction consumeRaw() {\n return this.Raw(null, false);\n}\n\nexport const name = 'StyleSheet';\nexport const walkContext = 'stylesheet';\nexport const structure = {\n children: [[\n 'Comment',\n 'CDO',\n 'CDC',\n 'Atrule',\n 'Rule',\n 'Raw'\n ]]\n};\n\nexport function parse() {\n const start = this.tokenStart;\n const children = this.createList();\n let child;\n\n scan:\n while (!this.eof) {\n switch (this.tokenType) {\n case WhiteSpace:\n this.next();\n continue;\n\n case Comment:\n // ignore comments except exclamation comments (i.e. /*! .. */) on top level\n if (this.charCodeAt(this.tokenStart + 2) !== EXCLAMATIONMARK) {\n this.next();\n continue;\n }\n\n child = this.Comment();\n break;\n\n case CDO: // <!--\n child = this.CDO();\n break;\n\n case CDC: // -->\n child = this.CDC();\n break;\n\n // CSS Syntax Module Level 3\n // §2.2 Error handling\n // At the \"top level\" of a stylesheet, an <at-keyword-token> starts an at-rule.\n case AtKeyword:\n child = this.parseWithFallback(this.Atrule, consumeRaw);\n break;\n\n // Anything else starts a qualified rule ...\n default:\n child = this.parseWithFallback(this.Rule, consumeRaw);\n }\n\n children.push(child);\n }\n\n return {\n type: 'StyleSheet',\n loc: this.getLocation(start, this.tokenStart),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node);\n}\n","import {\n LeftParenthesis,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nexport const name = 'SupportsDeclaration';\nexport const structure = {\n declaration: 'Declaration'\n};\n\nexport function parse() {\n const start = this.tokenStart;\n\n this.eat(LeftParenthesis);\n this.skipSC();\n\n const declaration = this.Declaration();\n\n if (!this.eof) {\n this.eat(RightParenthesis);\n }\n\n return {\n type: 'SupportsDeclaration',\n loc: this.getLocation(start, this.tokenStart),\n declaration\n };\n}\n\nexport function generate(node) {\n this.token(LeftParenthesis, '(');\n this.node(node.declaration);\n this.token(RightParenthesis, ')');\n}\n","import { Ident } from '../../tokenizer/index.js';\n\nconst ASTERISK = 0x002A; // U+002A ASTERISK (*)\nconst VERTICALLINE = 0x007C; // U+007C VERTICAL LINE (|)\n\nfunction eatIdentifierOrAsterisk() {\n if (this.tokenType !== Ident &&\n this.isDelim(ASTERISK) === false) {\n this.error('Identifier or asterisk is expected');\n }\n\n this.next();\n}\n\nexport const name = 'TypeSelector';\nexport const structure = {\n name: String\n};\n\n// ident\n// ident|ident\n// ident|*\n// *\n// *|ident\n// *|*\n// |ident\n// |*\nexport function parse() {\n const start = this.tokenStart;\n\n if (this.isDelim(VERTICALLINE)) {\n this.next();\n eatIdentifierOrAsterisk.call(this);\n } else {\n eatIdentifierOrAsterisk.call(this);\n\n if (this.isDelim(VERTICALLINE)) {\n this.next();\n eatIdentifierOrAsterisk.call(this);\n }\n }\n\n return {\n type: 'TypeSelector',\n loc: this.getLocation(start, this.tokenStart),\n name: this.substrToCursor(start)\n };\n}\n\nexport function generate(node) {\n this.tokenize(node.name);\n}\n","import {\n isHexDigit,\n Ident,\n Number,\n Dimension\n} from '../../tokenizer/index.js';\n\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)\nconst QUESTIONMARK = 0x003F; // U+003F QUESTION MARK (?)\n\nfunction eatHexSequence(offset, allowDash) {\n let len = 0;\n\n for (let pos = this.tokenStart + offset; pos < this.tokenEnd; pos++) {\n const code = this.charCodeAt(pos);\n\n if (code === HYPHENMINUS && allowDash && len !== 0) {\n eatHexSequence.call(this, offset + len + 1, false);\n return -1;\n }\n\n if (!isHexDigit(code)) {\n this.error(\n allowDash && len !== 0\n ? 'Hyphen minus' + (len < 6 ? ' or hex digit' : '') + ' is expected'\n : (len < 6 ? 'Hex digit is expected' : 'Unexpected input'),\n pos\n );\n }\n\n if (++len > 6) {\n this.error('Too many hex digits', pos);\n };\n }\n\n this.next();\n return len;\n}\n\nfunction eatQuestionMarkSequence(max) {\n let count = 0;\n\n while (this.isDelim(QUESTIONMARK)) {\n if (++count > max) {\n this.error('Too many question marks');\n }\n\n this.next();\n }\n}\n\nfunction startsWith(code) {\n if (this.charCodeAt(this.tokenStart) !== code) {\n this.error((code === PLUSSIGN ? 'Plus sign' : 'Hyphen minus') + ' is expected');\n }\n}\n\n// https://drafts.csswg.org/css-syntax/#urange\n// Informally, the <urange> production has three forms:\n// U+0001\n// Defines a range consisting of a single code point, in this case the code point \"1\".\n// U+0001-00ff\n// Defines a range of codepoints between the first and the second value, in this case\n// the range between \"1\" and \"ff\" (255 in decimal) inclusive.\n// U+00??\n// Defines a range of codepoints where the \"?\" characters range over all hex digits,\n// in this case defining the same as the value U+0000-00ff.\n// In each form, a maximum of 6 digits is allowed for each hexadecimal number (if you treat \"?\" as a hexadecimal digit).\n//\n// <urange> =\n// u '+' <ident-token> '?'* |\n// u <dimension-token> '?'* |\n// u <number-token> '?'* |\n// u <number-token> <dimension-token> |\n// u <number-token> <number-token> |\n// u '+' '?'+\nfunction scanUnicodeRange() {\n let hexLength = 0;\n\n switch (this.tokenType) {\n case Number:\n // u <number-token> '?'*\n // u <number-token> <dimension-token>\n // u <number-token> <number-token>\n hexLength = eatHexSequence.call(this, 1, true);\n\n if (this.isDelim(QUESTIONMARK)) {\n eatQuestionMarkSequence.call(this, 6 - hexLength);\n break;\n }\n\n if (this.tokenType === Dimension ||\n this.tokenType === Number) {\n startsWith.call(this, HYPHENMINUS);\n eatHexSequence.call(this, 1, false);\n break;\n }\n\n break;\n\n case Dimension:\n // u <dimension-token> '?'*\n hexLength = eatHexSequence.call(this, 1, true);\n\n if (hexLength > 0) {\n eatQuestionMarkSequence.call(this, 6 - hexLength);\n }\n\n break;\n\n default:\n // u '+' <ident-token> '?'*\n // u '+' '?'+\n this.eatDelim(PLUSSIGN);\n\n if (this.tokenType === Ident) {\n hexLength = eatHexSequence.call(this, 0, true);\n if (hexLength > 0) {\n eatQuestionMarkSequence.call(this, 6 - hexLength);\n }\n break;\n }\n\n if (this.isDelim(QUESTIONMARK)) {\n this.next();\n eatQuestionMarkSequence.call(this, 5);\n break;\n }\n\n this.error('Hex digit or question mark is expected');\n }\n}\n\nexport const name = 'UnicodeRange';\nexport const structure = {\n value: String\n};\n\nexport function parse() {\n const start = this.tokenStart;\n\n // U or u\n this.eatIdent('u');\n scanUnicodeRange.call(this);\n\n return {\n type: 'UnicodeRange',\n loc: this.getLocation(start, this.tokenStart),\n value: this.substrToCursor(start)\n };\n}\n\nexport function generate(node) {\n this.tokenize(node.value);\n}\n","import * as url from '../../utils/url.js';\nimport * as string from '../../utils/string.js';\nimport {\n Function as FunctionToken,\n String as StringToken,\n Url,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nexport const name = 'Url';\nexport const structure = {\n value: String\n};\n\n// <url-token> | <function-token> <string> )\nexport function parse() {\n const start = this.tokenStart;\n let value;\n\n switch (this.tokenType) {\n case Url:\n value = url.decode(this.consume(Url));\n break;\n\n case FunctionToken:\n if (!this.cmpStr(this.tokenStart, this.tokenEnd, 'url(')) {\n this.error('Function name must be `url`');\n }\n\n this.eat(FunctionToken);\n this.skipSC();\n value = string.decode(this.consume(StringToken));\n this.skipSC();\n if (!this.eof) {\n this.eat(RightParenthesis);\n }\n break;\n\n default:\n this.error('Url or Function is expected');\n }\n\n return {\n type: 'Url',\n loc: this.getLocation(start, this.tokenStart),\n value\n };\n}\n\nexport function generate(node) {\n this.token(Url, url.encode(node.value));\n}\n","import {\n isHexDigit,\n isWhiteSpace,\n isValidEscape,\n consumeEscaped,\n decodeEscaped\n} from '../tokenizer/index.js';\n\nconst SPACE = 0x0020; // U+0020 SPACE\nconst REVERSE_SOLIDUS = 0x005c; // U+005C REVERSE SOLIDUS (\\)\nconst QUOTATION_MARK = 0x0022; // \"\nconst APOSTROPHE = 0x0027; // '\nconst LEFTPARENTHESIS = 0x0028; // U+0028 LEFT PARENTHESIS (()\nconst RIGHTPARENTHESIS = 0x0029; // U+0029 RIGHT PARENTHESIS ())\n\nexport function decode(str) {\n const len = str.length;\n let start = 4; // length of \"url(\"\n let end = str.charCodeAt(len - 1) === RIGHTPARENTHESIS ? len - 2 : len - 1;\n let decoded = '';\n\n while (start < end && isWhiteSpace(str.charCodeAt(start))) {\n start++;\n }\n\n while (start < end && isWhiteSpace(str.charCodeAt(end))) {\n end--;\n }\n\n for (let i = start; i <= end; i++) {\n let code = str.charCodeAt(i);\n\n if (code === REVERSE_SOLIDUS) {\n // special case at the ending\n if (i === end) {\n // if the next input code point is EOF, do nothing\n // otherwise include last left parenthesis as escaped\n if (i !== len - 1) {\n decoded = str.substr(i + 1);\n }\n break;\n }\n\n code = str.charCodeAt(++i);\n\n // consume escaped\n if (isValidEscape(REVERSE_SOLIDUS, code)) {\n const escapeStart = i - 1;\n const escapeEnd = consumeEscaped(str, escapeStart);\n\n i = escapeEnd - 1;\n decoded += decodeEscaped(str.substring(escapeStart + 1, escapeEnd));\n } else {\n // \\r\\n\n if (code === 0x000d && str.charCodeAt(i + 1) === 0x000a) {\n i++;\n }\n }\n } else {\n decoded += str[i];\n }\n }\n\n return decoded;\n}\n\nexport function encode(str) {\n let encoded = '';\n let wsBeforeHexIsNeeded = false;\n\n for (let i = 0; i < str.length; i++) {\n const code = str.charCodeAt(i);\n\n // If the character is NULL (U+0000), then the REPLACEMENT CHARACTER (U+FFFD).\n if (code === 0x0000) {\n encoded += '\\uFFFD';\n continue;\n }\n\n // If the character is in the range [\\1-\\1f] (U+0001 to U+001F) or is U+007F,\n // the character escaped as code point.\n // Note: Do not compare with 0x0001 since 0x0000 is precessed before\n if (code <= 0x001f || code === 0x007F) {\n encoded += '\\\\' + code.toString(16);\n wsBeforeHexIsNeeded = true;\n continue;\n }\n\n if (code === SPACE ||\n code === REVERSE_SOLIDUS ||\n code === QUOTATION_MARK ||\n code === APOSTROPHE ||\n code === LEFTPARENTHESIS ||\n code === RIGHTPARENTHESIS) {\n encoded += '\\\\' + str.charAt(i);\n wsBeforeHexIsNeeded = false;\n } else {\n if (wsBeforeHexIsNeeded && isHexDigit(code)) {\n encoded += ' ';\n }\n\n encoded += str.charAt(i);\n wsBeforeHexIsNeeded = false;\n }\n }\n\n return 'url(' + encoded + ')';\n}\n","export const name = 'Value';\nexport const structure = {\n children: [[]]\n};\n\nexport function parse() {\n const start = this.tokenStart;\n const children = this.readSequence(this.scope.Value);\n\n return {\n type: 'Value',\n loc: this.getLocation(start, this.tokenStart),\n children\n };\n}\n\nexport function generate(node) {\n this.children(node);\n}\n","import { WhiteSpace } from '../../tokenizer/index.js';\n\nconst SPACE = Object.freeze({\n type: 'WhiteSpace',\n loc: null,\n value: ' '\n});\n\nexport const name = 'WhiteSpace';\nexport const structure = {\n value: String\n};\n\nexport function parse() {\n this.eat(WhiteSpace);\n return SPACE;\n\n // return {\n // type: 'WhiteSpace',\n // loc: this.getLocation(this.tokenStart, this.tokenEnd),\n // value: this.consume(WHITESPACE)\n // };\n}\n\nexport function generate(node) {\n this.token(WhiteSpace, node.value);\n}\n","import { cssWideKeywords } from '../../lexer/generic-const.js';\nimport definitions from '../../data.js';\nimport * as node from '../node/index.js';\n\nexport default {\n generic: true,\n cssWideKeywords,\n ...definitions,\n node\n};\n","import {\n Ident,\n String as StringToken,\n Number as NumberToken,\n Function as FunctionToken,\n Url,\n Hash,\n Dimension,\n Percentage,\n LeftParenthesis,\n LeftSquareBracket,\n Comma,\n Delim\n} from '../../tokenizer/index.js';\n\nconst NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#)\nconst ASTERISK = 0x002A; // U+002A ASTERISK (*)\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\nconst U = 0x0075; // U+0075 LATIN SMALL LETTER U (u)\n\nexport default function defaultRecognizer(context) {\n switch (this.tokenType) {\n case Hash:\n return this.Hash();\n\n case Comma:\n return this.Operator();\n\n case LeftParenthesis:\n return this.Parentheses(this.readSequence, context.recognizer);\n\n case LeftSquareBracket:\n return this.Brackets(this.readSequence, context.recognizer);\n\n case StringToken:\n return this.String();\n\n case Dimension:\n return this.Dimension();\n\n case Percentage:\n return this.Percentage();\n\n case NumberToken:\n return this.Number();\n\n case FunctionToken:\n return this.cmpStr(this.tokenStart, this.tokenEnd, 'url(')\n ? this.Url()\n : this.Function(this.readSequence, context.recognizer);\n\n case Url:\n return this.Url();\n\n case Ident:\n // check for unicode range, it should start with u+ or U+\n if (this.cmpChar(this.tokenStart, U) &&\n this.cmpChar(this.tokenStart + 1, PLUSSIGN)) {\n return this.UnicodeRange();\n } else {\n return this.Identifier();\n }\n\n case Delim: {\n const code = this.charCodeAt(this.tokenStart);\n\n if (code === SOLIDUS ||\n code === ASTERISK ||\n code === PLUSSIGN ||\n code === HYPHENMINUS) {\n return this.Operator(); // TODO: replace with Delim\n }\n\n // TODO: produce a node with Delim node type\n\n if (code === NUMBERSIGN) {\n this.error('Hex or identifier is expected', this.tokenStart + 1);\n }\n\n break;\n }\n }\n};\n","import getNode from './default.js';\n\nexport default {\n getNode\n};\n","import {\n Delim,\n Ident,\n Dimension,\n Percentage,\n Number as NumberToken,\n Hash,\n Colon,\n LeftSquareBracket\n} from '../../tokenizer/index.js';\n\nconst NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#)\nconst AMPERSAND = 0x0026; // U+0026 AMPERSAND (&)\nconst ASTERISK = 0x002A; // U+002A ASTERISK (*)\nconst PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+)\nconst SOLIDUS = 0x002F; // U+002F SOLIDUS (/)\nconst FULLSTOP = 0x002E; // U+002E FULL STOP (.)\nconst GREATERTHANSIGN = 0x003E; // U+003E GREATER-THAN SIGN (>)\nconst VERTICALLINE = 0x007C; // U+007C VERTICAL LINE (|)\nconst TILDE = 0x007E; // U+007E TILDE (~)\n\nfunction onWhiteSpace(next, children) {\n if (children.last !== null && children.last.type !== 'Combinator' &&\n next !== null && next.type !== 'Combinator') {\n children.push({ // FIXME: this.Combinator() should be used instead\n type: 'Combinator',\n loc: null,\n name: ' '\n });\n }\n}\n\nfunction getNode() {\n switch (this.tokenType) {\n case LeftSquareBracket:\n return this.AttributeSelector();\n\n case Hash:\n return this.IdSelector();\n\n case Colon:\n if (this.lookupType(1) === Colon) {\n return this.PseudoElementSelector();\n } else {\n return this.PseudoClassSelector();\n }\n\n case Ident:\n return this.TypeSelector();\n\n case NumberToken:\n case Percentage:\n return this.Percentage();\n\n case Dimension:\n // throws when .123ident\n if (this.charCodeAt(this.tokenStart) === FULLSTOP) {\n this.error('Identifier is expected', this.tokenStart + 1);\n }\n break;\n\n case Delim: {\n const code = this.charCodeAt(this.tokenStart);\n\n switch (code) {\n case PLUSSIGN:\n case GREATERTHANSIGN:\n case TILDE:\n case SOLIDUS: // /deep/\n return this.Combinator();\n\n case FULLSTOP:\n return this.ClassSelector();\n\n case ASTERISK:\n case VERTICALLINE:\n return this.TypeSelector();\n\n case NUMBERSIGN:\n return this.IdSelector();\n\n case AMPERSAND:\n return this.NestingSelector();\n }\n\n break;\n }\n }\n};\n\nexport default {\n onWhiteSpace,\n getNode\n};\n","// legacy IE function\n// expression( <any-value> )\nexport default function() {\n return this.createSingleNodeList(\n this.Raw(null, false)\n );\n}\n","import { Comma, WhiteSpace } from '../../tokenizer/index.js';\n\n// var( <ident> , <value>? )\nexport default function() {\n const children = this.createList();\n\n this.skipSC();\n\n // NOTE: Don't check more than a first argument is an ident, rest checks are for lexer\n children.push(this.Identifier());\n\n this.skipSC();\n\n if (this.tokenType === Comma) {\n children.push(this.Operator());\n\n const startIndex = this.tokenIndex;\n const value = this.parseCustomProperty\n ? this.Value(null)\n : this.Raw(this.consumeUntilExclamationMarkOrSemicolon, false);\n\n if (value.type === 'Value' && value.children.isEmpty) {\n for (let offset = startIndex - this.tokenIndex; offset <= 0; offset++) {\n if (this.lookupType(offset) === WhiteSpace) {\n value.children.appendData({\n type: 'WhiteSpace',\n loc: null,\n value: ' '\n });\n break;\n }\n }\n }\n\n children.push(value);\n }\n\n return children;\n};\n","import getNode from './default.js';\nimport expressionFn from '../function/expression.js';\nimport varFn from '../function/var.js';\n\nfunction isPlusMinusOperator(node) {\n return (\n node !== null &&\n node.type === 'Operator' &&\n (node.value[node.value.length - 1] === '-' || node.value[node.value.length - 1] === '+')\n );\n}\n\nexport default {\n getNode,\n onWhiteSpace(next, children) {\n if (isPlusMinusOperator(next)) {\n next.value = ' ' + next.value;\n }\n if (isPlusMinusOperator(children.last)) {\n children.last.value += ' ';\n }\n },\n 'expression': expressionFn,\n 'var': varFn\n};\n","import { Ident } from '../../tokenizer/index.js';\n\n// https://drafts.csswg.org/css-contain-3/#container-rule\n// The keywords `none`, `and`, `not`, and `or` are excluded from the <custom-ident> above.\nconst nonContainerNameKeywords = new Set(['none', 'and', 'not', 'or']);\n\nexport default {\n parse: {\n prelude() {\n const children = this.createList();\n\n if (this.tokenType === Ident) {\n const name = this.substring(this.tokenStart, this.tokenEnd);\n\n if (!nonContainerNameKeywords.has(name.toLowerCase())) {\n children.push(this.Identifier());\n }\n }\n\n children.push(this.Condition('container'));\n\n return children;\n },\n block(nested = false) {\n return this.Block(nested);\n }\n }\n};\n","export default {\n parse: {\n prelude: null,\n block() {\n return this.Block(true);\n }\n }\n};\n","import {\n String as StringToken,\n Ident,\n Url,\n Function as FunctionToken,\n LeftParenthesis,\n RightParenthesis\n} from '../../tokenizer/index.js';\n\nfunction parseWithFallback(parse, fallback) {\n return this.parseWithFallback(\n () => {\n try {\n return parse.call(this);\n } finally {\n this.skipSC();\n if (this.lookupNonWSType(0) !== RightParenthesis) {\n this.error();\n }\n }\n },\n fallback || (() => this.Raw(null, true))\n );\n}\n\nconst parseFunctions = {\n layer() {\n this.skipSC();\n\n const children = this.createList();\n const node = parseWithFallback.call(this, this.Layer);\n\n if (node.type !== 'Raw' || node.value !== '') {\n children.push(node);\n }\n\n return children;\n },\n supports() {\n this.skipSC();\n\n const children = this.createList();\n const node = parseWithFallback.call(\n this,\n this.Declaration,\n () => parseWithFallback.call(this, () => this.Condition('supports'))\n );\n\n if (node.type !== 'Raw' || node.value !== '') {\n children.push(node);\n }\n\n return children;\n }\n};\n\nexport default {\n parse: {\n prelude() {\n const children = this.createList();\n\n switch (this.tokenType) {\n case StringToken:\n children.push(this.String());\n break;\n\n case Url:\n case FunctionToken:\n children.push(this.Url());\n break;\n\n default:\n this.error('String or url() is expected');\n }\n\n this.skipSC();\n\n if (this.tokenType === Ident &&\n this.cmpStr(this.tokenStart, this.tokenEnd, 'layer')) {\n children.push(this.Identifier());\n } else if (\n this.tokenType === FunctionToken &&\n this.cmpStr(this.tokenStart, this.tokenEnd, 'layer(')\n ) {\n children.push(this.Function(null, parseFunctions));\n }\n\n this.skipSC();\n\n if (this.tokenType === FunctionToken &&\n this.cmpStr(this.tokenStart, this.tokenEnd, 'supports(')) {\n children.push(this.Function(null, parseFunctions));\n }\n\n if (this.lookupNonWSType(0) === Ident ||\n this.lookupNonWSType(0) === LeftParenthesis) {\n children.push(this.MediaQueryList());\n }\n\n return children;\n },\n block: null\n }\n};\n","import container from './container.js';\nimport fontFace from './font-face.js';\nimport importAtrule from './import.js';\nimport layer from './layer.js';\nimport media from './media.js';\nimport nest from './nest.js';\nimport page from './page.js';\nimport scope from './scope.js';\nimport startingStyle from './starting-style.js';\nimport supports from './supports.js';\n\nexport default {\n container,\n 'font-face': fontFace,\n import: importAtrule,\n layer,\n media,\n nest,\n page,\n scope,\n 'starting-style': startingStyle,\n supports\n};\n","export default {\n parse: {\n prelude() {\n return this.createSingleNodeList(\n this.LayerList()\n );\n },\n block() {\n return this.Block(false);\n }\n }\n};\n","export default {\n parse: {\n prelude() {\n return this.createSingleNodeList(\n this.MediaQueryList()\n );\n },\n block(nested = false) {\n return this.Block(nested);\n }\n }\n};\n","export default {\n parse: {\n prelude() {\n return this.createSingleNodeList(\n this.SelectorList()\n );\n },\n block() {\n return this.Block(true);\n }\n }\n};\n","export default {\n parse: {\n prelude() {\n return this.createSingleNodeList(\n this.SelectorList()\n );\n },\n block() {\n return this.Block(true);\n }\n }\n};\n","export default {\n parse: {\n prelude() {\n return this.createSingleNodeList(\n this.Scope()\n );\n },\n block(nested = false) {\n return this.Block(nested);\n }\n }\n};\n","export default {\n parse: {\n prelude: null,\n block(nested = false) {\n return this.Block(nested);\n }\n }\n};\n","export default {\n parse: {\n prelude() {\n return this.createSingleNodeList(\n this.Condition('supports')\n );\n },\n block(nested = false) {\n return this.Block(nested);\n }\n }\n};\n","import { parseLanguageRangeList } from './lang.js';\n\nconst selectorList = {\n parse() {\n return this.createSingleNodeList(\n this.SelectorList()\n );\n }\n};\n\nconst selector = {\n parse() {\n return this.createSingleNodeList(\n this.Selector()\n );\n }\n};\n\nconst identList = {\n parse() {\n return this.createSingleNodeList(\n this.Identifier()\n );\n }\n};\n\nconst langList = {\n parse: parseLanguageRangeList\n};\n\nconst nth = {\n parse() {\n return this.createSingleNodeList(\n this.Nth()\n );\n }\n};\n\nexport default {\n 'dir': identList,\n 'has': selectorList,\n 'lang': langList,\n 'matches': selectorList,\n 'is': selectorList,\n '-moz-any': selectorList,\n '-webkit-any': selectorList,\n 'where': selectorList,\n 'not': selectorList,\n 'nth-child': nth,\n 'nth-last-child': nth,\n 'nth-last-of-type': nth,\n 'nth-of-type': nth,\n 'slotted': selector,\n 'host': selector,\n 'host-context': selector\n};\n","import { Comma, String as StringToken, Ident, RightParenthesis } from '../../tokenizer/index.js';\n\nexport function parseLanguageRangeList() {\n const children = this.createList();\n\n this.skipSC();\n\n loop: while (!this.eof) {\n switch (this.tokenType) {\n case Ident:\n children.push(this.Identifier());\n break;\n\n case StringToken:\n children.push(this.String());\n break;\n\n case Comma:\n children.push(this.Operator());\n break;\n\n case RightParenthesis:\n break loop;\n\n default:\n this.error('Identifier, string or comma is expected');\n }\n\n this.skipSC();\n }\n\n return children;\n}\n","import createSyntax from './create.js';\nimport lexerConfig from './config/lexer.js';\nimport parserConfig from './config/parser.js';\nimport walkerConfig from './config/walker.js';\n\nexport default createSyntax({\n ...lexerConfig,\n ...parserConfig,\n ...walkerConfig\n});\n","import * as scope from '../scope/index.js';\nimport atrule from '../atrule/index.js';\nimport pseudo from '../pseudo/index.js';\nimport * as node from '../node/index-parse.js';\n\nexport default {\n parseContext: {\n default: 'StyleSheet',\n stylesheet: 'StyleSheet',\n atrule: 'Atrule',\n atrulePrelude(options) {\n return this.AtrulePrelude(options.atrule ? String(options.atrule) : null);\n },\n mediaQueryList: 'MediaQueryList',\n mediaQuery: 'MediaQuery',\n condition(options) {\n return this.Condition(options.kind);\n },\n rule: 'Rule',\n selectorList: 'SelectorList',\n selector: 'Selector',\n block() {\n return this.Block(true);\n },\n declarationList: 'DeclarationList',\n declaration: 'Declaration',\n value: 'Value'\n },\n features: {\n supports: {\n selector() {\n return this.Selector();\n }\n },\n container: {\n style() {\n return this.Declaration();\n }\n }\n },\n scope,\n atrule,\n pseudo,\n node\n};\n","import * as node from '../node/index.js';\n\nexport default {\n node\n};\n","import syntax from './syntax/index.js';\n\nexport * from './version.js';\nexport { default as createSyntax } from './syntax/create.js';\nexport { List } from './utils/List.js';\nexport { Lexer } from './lexer/Lexer.js';\nexport { tokenTypes, tokenNames, TokenStream, OffsetToLocation } from './tokenizer/index.js';\nexport * as definitionSyntax from './definition-syntax/index.js';\nexport { clone } from './utils/clone.js';\nexport * from './utils/names.js';\nexport * as ident from './utils/ident.js';\nexport * as string from './utils/string.js';\nexport * as url from './utils/url.js';\nexport const {\n tokenize,\n parse,\n generate,\n lexer,\n createLexer,\n\n walk,\n find,\n findLast,\n findAll,\n\n toPlainObject,\n fromPlainObject,\n\n fork\n} = syntax;\n"],"names":["util","__webpack_require__","has","Object","prototype","hasOwnProperty","hasNativeMap","Map","ArraySet","this","_array","_set","create","fromArray","aArray","aAllowDuplicates","set","i","len","length","add","size","getOwnPropertyNames","aStr","sStr","toSetString","isDuplicate","call","idx","push","indexOf","get","Error","at","aIdx","toArray","slice","exports","C","base64","encode","aValue","digit","encoded","vlq","toVLQSigned","VLQ_BASE","decode","aIndex","aOutParam","continuation","shifted","strLen","result","shift","charCodeAt","charAt","value","rest","intToCharMap","split","number","TypeError","charCode","MappingList","_sorted","_last","generatedLine","generatedColumn","unsortedForEach","aCallback","aThisArg","forEach","aMapping","mappingA","mappingB","lineA","lineB","columnA","columnB","compareByGeneratedPositionsInflated","sort","P","base64VLQ","SourceMapGenerator","aArgs","_file","getArg","_sourceRoot","_skipValidation","_ignoreInvalidMapping","_sources","_names","_mappings","_sourcesContents","_version","fromSourceMap","aSourceMapConsumer","generatorOps","sourceRoot","generator","assign","file","eachMapping","mapping","newMapping","generated","line","column","source","relative","original","originalLine","originalColumn","name","addMapping","sources","sourceFile","sourceRelative","content","sourceContentFor","setSourceContent","_validateMapping","String","aSourceFile","aSourceContent","keys","applySourceMap","aSourceMapPath","newSources","newNames","originalPositionFor","join","aGenerated","aOriginal","aSource","aName","message","console","warn","JSON","stringify","_serializeMappings","next","nameIdx","sourceIdx","previousGeneratedColumn","previousGeneratedLine","previousOriginalColumn","previousOriginalLine","previousName","previousSource","mappings","_generateSourcesContent","aSources","aSourceRoot","map","key","toJSON","version","names","sourcesContent","toString","x","aDefaultValue","arguments","urlRegexp","dataUrlRegexp","urlParse","aUrl","match","scheme","auth","host","port","path","urlGenerate","aParsedUrl","url","f","cache","normalize","aPath","isAbsolute","parts","start","part","up","splice","input","temp","unshift","pop","aRoot","aPathUrl","aRootUrl","joined","replace","test","level","index","lastIndexOf","Array","substr","supportsNullProto","identity","s","isProtoString","strcmp","aStr1","aStr2","fromSetString","compareByOriginalPositions","onlyCompareOriginal","cmp","compareByOriginalPositionsNoSource","compareByGeneratedPositionsDeflated","onlyCompareGenerated","compareByGeneratedPositionsDeflatedNoLine","parseSourceMapInput","str","parse","computeSourceURL","sourceURL","sourceMapURL","parsed","substring","isDigit","code","isHexDigit","isUppercaseLetter","isNameStart","isLowercaseLetter","isLetter","isNonAscii","isName","isNonPrintable","isNewline","isWhiteSpace","isValidEscape","first","second","isIdentifierStart","third","isNumberStart","isBOM","CATEGORY","charCodeCategory","getCharCode","offset","getNewlineLength","cmpChar","testStr","referenceCode","cmpStr","end","referenceStr","testCode","findWhiteSpaceEnd","findDecimalNumberEnd","consumeEscaped","maxOffset","Math","min","consumeName","consumeNumber","sign","consumeBadUrlRemnants","decodeEscaped","escaped","parseInt","fromCodePoint","tokenize","onToken","sourceLength","consumeNumericToken","type","consumeIdentLikeToken","nameStartOffset","consumeUrlToken","consumeStringToken","endingCodePoint","nextCode","releasedCursors","List","createItem","data","prev","constructor","head","tail","cursor","allocateCursor","releaseCursor","updateCursors","prevOld","prevNew","nextOld","nextNew","Symbol","iterator","isEmpty","last","array","item","fn","thisArg","forEachRight","reduce","initialValue","acc","reduceRight","some","appendData","filter","nextUntil","prevUntil","clear","copy","prepend","prependData","append","insert","before","insertData","remove","prependList","list","insertList","appendList","oldItem","newItemOrList","createCustomError","error","SyntaxError","errorStack","stack","TAB_REPLACEMENT","sourceFragment","baseLine","baseColumn","extraLines","processLines","lines","padStart","maxNumLength","repeat","max","startLine","endLine","cutLeft","OFFSET_CORRECTION","MAX_LINE_LENGTH","Boolean","SyntaxError_SyntaxError","isNaN","formattedMessage","adoptBuffer","buffer","Uint32Array","computeLinesAndColumns","startOffset","columns","startColumn","computed","OffsetToLocation","setSource","getLocation","filename","getLocationRange","OFFSET_MASK","TYPE_SHIFT","balancePair","Uint8Array","blockTokens","boundIndex","TokenStream","reset","eof","tokenIndex","tokenType","tokenStart","firstCharOffset","tokenEnd","offsetAndType","balance","tokenCount","balanceCloseType","balanceStart","fill","prevBalanceStart","isBlockOpenerTokenType","balanceEnd","lookupType","lookupTypeNonSC","lookupOffset","lookupOffsetNonSC","lookupValue","getTokenStart","getTokenEnd","getTokenType","substrToCursor","isBlockCloserTokenType","getBlockTokenPairIndex","pairIndex","closeType","openType","isBalanceEdge","isDelim","skip","skipSC","skipUntilBalanced","startToken","stopConsume","loop","forEachToken","dump","tokens","chunk","readSequence","recognizer","children","createList","space","context","child","getNode","undefined","onWhiteSpace","NOOP","arrayMethods","createSingleNodeList","node","getFirstListNode","getLastListNode","listMethods","createParseContext","fetchParseValues","dict","createParser","config","needPositions","onParseError","onParseErrorThrow","locationMap","parser","parseConfig","features","scope","atrule","pseudo","entries","parseContext","processConfig","parseAtrulePrelude","parseRulePrelude","parseValue","parseCustomProperty","consumeUntilBalanceEnd","consumeUntilLeftCurlyBracket","consumeUntilLeftCurlyBracketOrSemicolon","consumeUntilExclamationMarkOrSemicolon","consumeUntilSemicolonIncluded","parseWithFallback","consumer","fallback","startIndex","e","fallbackNode","lookupNonWSType","offsetStart","offsetEnd","consume","eat","consumeFunctionName","tokenName","m","toUpperCase","eatIdent","eatDelim","fromCharCode","getLocationFromList","loc","location","findWhiteSpaceStart","source_","options","positions","onComment","isArray","bind","getTokenTypeName","getTokenValue","subarray","getRangeLocation","ast","trackNodes","Set","specPairs","safePairs","concat","createMap","pairs","isWhiteSpaceRequired","prevCode","nextCharCode","spec","safe","processChildren","delimeter","createGenerator","types","generate","handlers","publicApi","tokenBefore","token","suppressAutoWhiteSpace","emit","decorator","sourceMap","source_map_generator","activatedGenerated","activatedMapping","sourceMappingActive","origHandlersNode","nodeLine","nodeColumn","origHandlersEmit","auto","origHandlersResult","css","generateSourceMap","mode","token_before_namespaceObject","raw","create_hasOwnProperty","noop","ensureFunction","invokeForType","getWalkersFromStructure","nodeType","structure","walkers","fieldTypes","walker","nullable","fieldType","walkContext","fields","createTypeIterator","reverse","contextName","useContext","walk","walkReducer","prevContextValue","field","ref","createFastTraveralMap","StyleSheet","Atrule","Rule","Block","DeclarationList","Declaration","createWalker","getTypesFromConfig","iteratorsNatural","iteratorsReverse","breakWalk","skipNode","fastTraversalIteratorsNatural","fastTraversalIteratorsReverse","root","walkNode","enterRet","enter","iterators","leave","ret","break","stylesheet","atrulePrelude","rule","selector","block","declaration","function","visit","find","found","findLast","findAll","generate_noop","internalGenerate","decorate","forceBraces","compact","combinator","terms","term","explicit","generateSequence","disallowEmpty","multiplier","comma","generateMultiplier","opts","generateTypeOpts","defaultLoc","fromLoc","point","buildLoc","extra","SyntaxReferenceError","referenceName","reference","SyntaxMatchError","syntax","matchResult","mismatchOffset","mismatchLength","longestMatch","mismatchNode","badNode","locateMismatch","rawMessage","keywords","properties","keyword","toLowerCase","descriptor","custom","isCustomProperty","vendor","getVendorPrefix","freeze","basename","prefix","names_property","property","hack","secondDashIndex","cssWideKeywords","generic_an_plus_b_HYPHENMINUS","DISALLOW_SIGN","getNextToken","checkInteger","valueOffset","disallowSign","consumeB","offset_","generic_urange_isDelim","hexSequence","allowDash","hexlen","pos","withQuestionMarkSequence","consumed","calcFunctionNames","comparisonFunctionNames","steppedValueFunctionNames","expNumberDimensionPercentageFunctionNames","signFunctionNames","numberFunctionNames","percentageFunctionNames","dimensionFunctionNames","generic_balancePair","eqStr","actual","expected","eqStrAny","isPostfixIeHack","outOfRange","numEnd","num","Number","math","functionNames","balanceStash","scan","consumeFunction","expectedTokenType","dashedIdent","dimension","numberEnd","reverseSolidusOffset","unit","zero","tokenTypes","productionTypes","string","ident","percentage","integer","urange","consumedHexLength","startsWith","unitGroups","createDemensionTypes","units","angle","decibel","frequency","flex","resolution","semitones","time","createAttrUnit","unitSet","group","units_length","definition_syntax_SyntaxError_SyntaxError","NAME_CHAR","_","Scanner","isNameCharCode","nextNonWsCode","findWsEnd","skipWs","substringToPos","peek","scanSpaces","scanWord","scanNumber","scanString","RIGHTSQUAREBRACKET","parse_LEFTCURLYBRACKET","COMBINATOR_PRECEDENCE","readMultiplierRange","scanner","maybeMultiplied","range","readMultiplier","maybeToken","ch","readType","implicitGroup","readImplicitGroup","readTypeRange","regroupTerms","combinators","createGroup","a","b","subgroupStart","stopCharCode","prevToken","prevTokenPos","prevTokenIsFunction","readGroup","readProperty","readKeywordOrFunction","walk_noop","walk_ensureFunction","astToTokens","curNode","tmp","prepare_tokens","stringToTokens","MATCH","MISMATCH","DISALLOW_EMPTY","createCondition","thenBranch","elseBranch","else","then","isFunctionType","isEnumCapatible","groupNode","replaceTypeInGraph","replacements","visited","buildGroupMatchGraph","atLeastOneTermMatched","all","thenClause","newGroupTerm","buildMatchGraphInternal","matchTerm","buildMultiplierMatchGraph","matchNode","booleanGroup","buildMatchGraph","syntaxTree","match_hasOwnProperty","EXIT_REASON_MATCH","totalIterationCount","reverseList","areStringsEqualCaseInsensitive","isCommaContextStart","isContextEdgeDelim","isCommaContextEnd","internalMatch","state","syntaxes","moveToNextToken","nextIndex","stateSnapshotFromSyntax","nextState","matchStack","syntaxStack","thenStack","pushThenStack","pushElseStack","elseStack","addTokenToMatch","syntaxStash","openSyntax","closeSyntax","iterationCount","exitReason","mask","matchFlag","lastTokenIndex","floor","syntaxDict","dictSyntax","matchRef","keywordName","reason","iterations","matchAsTree","matchGraph","hostStack","getTrace","shouldPutToTrace","matched","hasMatch","isType","testNode","isProperty","isKeyword","trace","getFirstMatchNode","getLastMatchNode","matchFragments","lexer","fragments","findFragments","nodes","parent","structure_hasOwnProperty","isValidNumber","isFinite","isValidLocation","createNodeStructureChecker","valid","genTypesList","docsTypes","processStructure","docs","check","dumpMapSyntax","syntaxAsAst","dumpAtruleMapSyntax","prelude","descriptors","buildMatchResult","trace_namespaceObject","matchSyntax","useCssWideKeywords","valueHasVar","cssWideKeywordsSyntax","Lexer","generic","units_namespaceObject","atrules","getStructureFromConfig","addType_","addAtrule_","addProperty_","checkStructure","collectWarning","warns","createDescriptor","serializable","defineProperty","singleTerm","syntaxHasTopLevelCommaMultiplier","descName","checkAtruleName","atruleName","getAtrule","checkAtrulePrelude","checkAtruleDescriptorName","descriptorName","checkPropertyName","propertyName","getProperty","matchAtrulePrelude","matchAtruleDescriptor","matchDeclaration","matchProperty","matchType","typeName","typeSyntax","getType","findValueFragments","findDeclarationValueFragments","findAllFragments","apply","fallbackBasename","getAtrulePrelude","getAtruleDescriptor","declarators","validate","syntaxRef","broken","brokenMap","brokenTypes","brokenProperties","errors","brokenTypesArray","brokenPropertiesArray","pretty","appendOrSet","extractProps","obj","props","prop","includes","mergeDicts","base","ext","mix","dest","src","patch","exists","current","descriptorValue","createSyntax","fromPlainObject","toPlainObject","createConvertor","createLexer","fork","extension","dn","AnPlusB_PLUSSIGN","AnPlusB_HYPHENMINUS","AnPlusB_N","AnPlusB_DISALLOW_SIGN","AnPlusB_checkInteger","checkTokenIsInteger","expectCharCode","msg","AnPlusB_consumeB","AnPlusB_name","AnPlusB_parse","AnPlusB_generate","consumeRaw","Raw","isDeclarationBlockAtrule","Atrule_name","Atrule_structure","Atrule_parse","isDeclaration","nameLowerCase","AtrulePrelude","Atrule_generate","AtrulePrelude_name","AtrulePrelude_walkContext","AtrulePrelude_structure","AtrulePrelude_parse","AtrulePrelude_generate","getAttributeName","expectIdent","getOperator","AttributeSelector_name","AttributeSelector_structure","matcher","flags","AttributeSelector_parse","Identifier","AttributeSelector_generate","Block_consumeRaw","consumeRule","consumeRawDeclaration","consumeDeclaration","Block_name","Block_walkContext","Block_structure","Block_parse","isStyleBlock","Block_generate","Brackets_name","Brackets_structure","Brackets_parse","Brackets_generate","CDC_name","CDC_structure","CDC_parse","CDC_generate","CDO_name","CDO_structure","CDO_parse","CDO_generate","ClassSelector_name","ClassSelector_structure","ClassSelector_parse","ClassSelector_generate","Combinator_name","Combinator_structure","Combinator_parse","Combinator_generate","Comment_name","Comment_structure","Comment_parse","Comment_generate","likelyFeatureToken","Condition_name","Condition_structure","kind","featureOrRange","Feature","FeatureRange","parentheses","media","container","supports","SupportsDeclaration","Condition_parse","res","Condition","GeneralEnclosed","FeatureFunction","Condition_generate","consumeValueRaw","consumeCustomPropertyRaw","consumeValue","startValueToken","Value","Declaration_name","Declaration_walkContext","Declaration_structure","important","Declaration_parse","Declaration_readProperty","customProperty","valueStart","getImportant","Declaration_generate","DeclarationList_consumeRaw","DeclarationList_name","DeclarationList_structure","DeclarationList_parse","DeclarationList_generate","Dimension_name","Dimension_structure","Dimension_parse","Dimension_generate","Feature_name","Feature_structure","Feature_parse","Ratio","Dimension","Function","Feature_generate","FeatureFunction_name","FeatureFunction_structure","feature","getFeatureParser","FeatureFunction_parse","functionName","valueParser","FeatureFunction_generate","FeatureRange_name","FeatureRange_structure","left","leftComparison","middle","rightComparison","right","readTerm","readComparison","expectColon","FeatureRange_parse","FeatureRange_generate","Function_name","Function_walkContext","Function_structure","Function_parse","Function_generate","GeneralEnclosed_name","GeneralEnclosed_structure","GeneralEnclosed_parse","GeneralEnclosed_generate","xxx","Hash_name","Hash_structure","Hash_parse","Hash_generate","Identifier_name","Identifier_structure","Identifier_parse","Identifier_generate","IdSelector_name","IdSelector_structure","IdSelector_parse","IdSelector_generate","Layer_name","Layer_structure","Layer_parse","Layer_generate","LayerList_name","LayerList_structure","LayerList_parse","Layer","LayerList_generate","MediaQuery_name","MediaQuery_structure","modifier","mediaType","condition","MediaQuery_parse","identLowerCase","MediaQuery_generate","MediaQueryList_name","MediaQueryList_structure","MediaQueryList_parse","MediaQuery","MediaQueryList_generate","NestingSelector_name","NestingSelector_structure","NestingSelector_parse","NestingSelector_generate","Nth_name","Nth_structure","nth","Nth_parse","AnPlusB","SelectorList","Nth_generate","Number_name","Number_structure","Number_parse","Number_generate","Operator_name","Operator_structure","Operator_parse","Operator_generate","Parentheses_name","Parentheses_structure","Parentheses_parse","Parentheses_generate","Percentage_name","Percentage_structure","Percentage_parse","Percentage_generate","PseudoClassSelector_name","PseudoClassSelector_walkContext","PseudoClassSelector_structure","PseudoClassSelector_parse","PseudoClassSelector_generate","PseudoElementSelector_name","PseudoElementSelector_walkContext","PseudoElementSelector_structure","PseudoElementSelector_parse","PseudoElementSelector_generate","consumeTerm","Ratio_name","Ratio_structure","Ratio_parse","Ratio_generate","getOffsetExcludeWS","Raw_name","Raw_structure","Raw_parse","consumeUntil","excludeWhiteSpace","endOffset","Raw_generate","Rule_consumeRaw","consumePrelude","Rule_name","Rule_walkContext","Rule_structure","Rule_parse","Rule_generate","Scope_name","Scope_structure","limit","Scope_parse","Scope_generate","Selector_name","Selector_structure","Selector_parse","Selector","Selector_generate","SelectorList_name","SelectorList_walkContext","SelectorList_structure","SelectorList_parse","SelectorList_generate","firstChar","decoded","escapeStart","escapeEnd","String_name","String_structure","String_parse","String_generate","apostrophe","quote","quoteCode","wsBeforeHexIsNeeded","StyleSheet_consumeRaw","StyleSheet_name","StyleSheet_walkContext","StyleSheet_structure","StyleSheet_parse","Comment","CDO","CDC","StyleSheet_generate","SupportsDeclaration_name","SupportsDeclaration_structure","SupportsDeclaration_parse","SupportsDeclaration_generate","eatIdentifierOrAsterisk","TypeSelector_name","TypeSelector_structure","TypeSelector_parse","TypeSelector_generate","eatHexSequence","eatQuestionMarkSequence","count","UnicodeRange_startsWith","scanUnicodeRange","hexLength","UnicodeRange_name","UnicodeRange_structure","UnicodeRange_parse","UnicodeRange_generate","Url_name","Url_structure","Url_parse","url_decode","Url_generate","url_encode","Value_name","Value_structure","Value_parse","Value_generate","WhiteSpace_SPACE","WhiteSpace_name","WhiteSpace_structure","WhiteSpace_parse","WhiteSpace_generate","attachment","axis","color","counter","dasharray","gradient","hue","image","paint","position","ratio","scroller","shadow","shape","symbol","target","xyz","age","autospace","bottom","gender","top","y","animation","appearance","background","border","caret","clip","contain","cx","cy","d","direction","display","float","font","gap","grid","height","hyphens","inset","isolation","interactivity","margin","marker","opacity","order","orphans","outline","overflow","overlay","padding","page","perspective","quotes","r","resize","rotate","rx","ry","scale","stroke","transform","transition","translate","visibility","widows","width","zoom","behavior","cue","kerning","pause","speak","charset","negative","pad","suffix","symbols","system","document","import","keyframes","layer","namespace","bleed","marks","inherits","navigation","node_namespaceObject","defaultRecognizer","Hash","Operator","Parentheses","Brackets","Percentage","Url","UnicodeRange","AttributeSelector","IdSelector","PseudoElementSelector","PseudoClassSelector","TypeSelector","Combinator","ClassSelector","NestingSelector","expression","function_var","isPlusMinusOperator","var","nonContainerNameKeywords","nested","font_face","parseFunctions","MediaQueryList","LayerList","nest","Scope","selectorList","pseudo_selector","identList","langList","Nth","dir","lang","matches","is","where","not","slotted","default","mediaQueryList","mediaQuery","declarationList","style","scope_namespaceObject","index_parse_namespaceObject","lib_tokenize","lib_parse","lib_generate","lib_lexer","lib_walk"],"sourceRoot":""}